Changeset 390 for trunk


Ignore:
Timestamp:
05/07/12 17:07:54 (8 years ago)
Author:
sc
Message:
  • changes for Jigsaw release 1.2.2
Location:
trunk/Puzzlebox/Synapse
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Puzzlebox/Synapse/Client.py

    r389 r390  
    230230                 
    231231                # ThinkGear Connect server does not provide a timestamp in its JSON protocol 
    232                 if ('timpstamp' not in packet.keys()): 
    233                         #print packet 
     232                if ('timestamp' not in packet.keys()): 
    234233                        packet['timestamp'] = time.time() 
    235                         #print packet 
    236234                 
    237235                if ('isAuthorized' in packet.keys()): 
  • trunk/Puzzlebox/Synapse/Session.py

    r389 r390  
    77 
    88__changelog__ = """\ 
    9 Last Update: 2012.04.09 
     9Last Update: 2012.05.07 
    1010""" 
    1111 
     
    4646DEBUG = configuration.DEBUG 
    4747 
     48DEFAULT_SIGNAL_LEVEL_MESSAGE = \ 
     49        {"poorSignalLevel": 0} 
     50                # A quantifier of the quality of the brainwave signal. 
     51                # This is an integer value that is generally in the 
     52                # range of 0 to 200, with 0 indicating a 
     53                # good signal and 200 indicating an off-head state. 
     54 
     55DEFAULT_EEG_POWER_MESSAGE = \ 
     56        {"eegPower": { \ 
     57                'delta': 0, \ 
     58                'theta': 0, \ 
     59                'lowAlpha': 0, \ 
     60                'highAlpha': 0, \ 
     61                'lowBeta': 0, \ 
     62                'highBeta': 0, \ 
     63                'lowGamma': 0, \ 
     64                'highGamma': 0, \ 
     65                }, \ 
     66        } # A container for the EEG powers. These may 
     67          # be either integer or floating-point values. 
     68          # Maximum values are undocumented but assumed to be 65535 
     69 
     70DEFAULT_ESENSE_MESSAGE = \ 
     71        {"eSense": { \ 
     72                'attention': 0, \ 
     73                'meditation': 0, \ 
     74                }, \ 
     75        } # A container for the eSense™ attributes. 
     76          # These are integer values between 0 and 100, 
     77          # where 0 is perceived as a lack of that attribute 
     78          # and 100 is an excess of that attribute. 
     79 
     80DEFAULT_BLINK_MESSAGE = {"blinkStrength": 255} 
     81        # The strength of a detected blink. This is 
     82        # an integer in the range of 0-255. 
     83 
     84DEFAULT_RAWEEG_MESSAGE = {"rawEeg": 255} 
     85        # The raw data reading off the forehead sensor. 
     86        # This may be either an integer or a floating-point value. 
     87 
     88DEFAULT_PACKET = {} 
     89DEFAULT_PACKET.update(DEFAULT_EEG_POWER_MESSAGE) 
     90DEFAULT_PACKET.update(DEFAULT_SIGNAL_LEVEL_MESSAGE) 
     91DEFAULT_PACKET.update(DEFAULT_ESENSE_MESSAGE) 
     92 
     93PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD = 0.75 
     94 
    4895##################################################################### 
    4996# Classes 
     
    152199        def calculateSessionTime(self): 
    153200                 
    154                 if self.synapseServer != None: 
    155                         session_time = time.time() - \ 
    156                                         self.synapseServer.session_start_timestamp 
    157                         session_time = int(session_time) 
    158                 else: 
    159                         #session_time = int( self.session_start_timestamp ) 
    160                         session_time = int( self.parent.session_start_timestamp ) 
    161                  
     201                session_time = self.getSessionTime() 
     202                 
     203                session_time = time.time() - session_time 
     204                session_time = int(session_time) 
    162205                session_time = self.convert_seconds_to_datetime(session_time) 
    163206                 
    164                 return(session_time) 
     207                return (session_time) 
     208         
     209         
     210        ################################################################## 
     211         
     212        def getSessionTime(self): 
     213                 
     214                return (self.synapseServer.session_start_timestamp) 
    165215         
    166216         
     
    355405        ################################################################## 
    356406         
     407        #def exportDataToCSV(self, parent=None, source=None, target=None): 
     408                 
     409                #output = '' 
     410                 
     411                #if self.synapseServer != None: 
     412                        ##output = self.synapseServer.exportDataToCSV(parent=self.parent, source=self) 
     413                        #output = self.synapseServer.exportDataToCSV(parent=parent, source=source, target=target) 
     414                 
     415                #else: 
     416                         
     417                        #if self.DEBUG: 
     418                                #print "ERROR: exportDataToCSV exists in synapseServer object which is not in use" 
     419                 
     420                #return(output) 
     421         
     422         
     423        ################################################################## 
     424         
    357425        def exportDataToCSV(self, parent=None, source=None, target=None): 
    358426                 
    359                 output = '' 
    360                  
    361                 if self.synapseServer != None: 
    362                         #output = self.synapseServer.exportDataToCSV(parent=self.parent, source=self) 
    363                         output = self.synapseServer.exportDataToCSV(parent=parent, source=source, target=target) 
    364                  
    365                 else: 
    366                          
    367                         if self.DEBUG: 
    368                                 print "ERROR: exportDataToCSV exists in synapseServer object which is not in use" 
     427                # handle importing class from multiple sources 
     428                if parent == None: 
     429                        if self.parent == None: 
     430                                parent = self 
     431                        else: 
     432                                parent = self.parent 
     433                 
     434                if source == None: 
     435                        if self.parent == None: 
     436                                source = self 
     437                        else: 
     438                                source = self.parent 
     439                 
     440                if target == None: 
     441                        if self.parent == None: 
     442                                target = self 
     443                        else: 
     444                                target = self.parent 
     445                 
     446                try: 
     447                        truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE 
     448                except: 
     449                        truncate_csv_timezone = False 
     450                 
     451                 
     452                # NOTE: no need to scrub emulated data 
     453                try: 
     454                        scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA 
     455                except: 
     456                        scrub_data = False 
     457                 
     458                try: 
     459                        if self.parent.plugin_eeg.emulate_headset_data: 
     460                                scrub_data = False 
     461                except: 
     462                        pass 
     463                 
     464                 
     465                #headers = 'Date,Time' 
     466                headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma' 
     467                #headers = self.customDataHeaders 
     468                 
     469                customDataHeaders = [] 
     470                for header in parent.customDataHeaders: 
     471                        customDataHeaders.append(header) 
     472                for plugin in parent.activePlugins: 
     473                        for header in plugin.customDataHeaders: 
     474                                customDataHeaders.append(header) 
     475                 
     476                for each in customDataHeaders: 
     477                        headers = headers + ',%s' % each 
     478                 
     479                headers = headers + '\n' 
     480                 
     481                 
     482                csv = {} 
     483                 
     484                for packet in source.packets['signals']: 
     485                         
     486                         
     487                        if 'rawEeg' in packet.keys(): 
     488                                continue 
     489                         
     490                        if packet['timestamp'] not in csv.keys(): 
     491                                 
     492                                if 'blinkStrength' in packet.keys(): 
     493                                        # Skip any blink packets from log 
     494                                        continue 
     495                                 
     496                                 
     497                                timestamp = packet['timestamp'] 
     498                                #(date, localtime) = self.parseTimeStamp(timestamp, \ 
     499                                                    #truncate_time_zone=truncate_csv_timezone) 
     500                                (date, localtime) = source.parseTimeStamp(timestamp, \ 
     501                                                    truncate_time_zone=truncate_csv_timezone) 
     502                                 
     503                                csv[timestamp] = {} 
     504                                csv[timestamp]['Date'] = date 
     505                                csv[timestamp]['Time'] = localtime 
     506                                csv[timestamp]['Attention'] = '' 
     507                                csv[timestamp]['Meditation'] = '' 
     508                                csv[timestamp]['Signal Level'] = '' 
     509                                csv[timestamp]['Delta'] = '' 
     510                                csv[timestamp]['Theta'] = '' 
     511                                csv[timestamp]['Low Alpha'] = '' 
     512                                csv[timestamp]['High Alpha'] = '' 
     513                                csv[timestamp]['Low Beta'] = '' 
     514                                csv[timestamp]['High Beta'] = '' 
     515                                csv[timestamp]['Low Gamma'] = '' 
     516                                csv[timestamp]['Mid Gamma'] = '' 
     517                                 
     518                                for header in customDataHeaders: 
     519                                        csv[timestamp][header] = '' 
     520                         
     521                         
     522                        if 'eSense' in packet.keys(): 
     523                                if 'attention' in packet['eSense'].keys(): 
     524                                        csv[timestamp]['Attention'] = packet['eSense']['attention'] 
     525                                if 'meditation' in packet['eSense'].keys(): 
     526                                        csv[timestamp]['Meditation'] = packet['eSense']['meditation'] 
     527                         
     528                        if 'poorSignalLevel' in packet.keys(): 
     529                                csv[timestamp]['Signal Level'] = packet['poorSignalLevel'] 
     530                         
     531                        if 'eegPower' in packet.keys(): 
     532                                if 'delta' in packet['eegPower'].keys(): 
     533                                        csv[timestamp]['Delta'] = packet['eegPower']['delta'] 
     534                                if 'theta' in packet['eegPower'].keys(): 
     535                                        csv[timestamp]['Theta'] = packet['eegPower']['theta'] 
     536                                if 'lowAlpha' in packet['eegPower'].keys(): 
     537                                        csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha'] 
     538                                if 'highAlpha' in packet['eegPower'].keys(): 
     539                                        csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha'] 
     540                                if 'lowBeta' in packet['eegPower'].keys(): 
     541                                        csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta'] 
     542                                if 'highBeta' in packet['eegPower'].keys(): 
     543                                        csv[timestamp]['High Beta'] = packet['eegPower']['highBeta'] 
     544                                if 'lowGamma' in packet['eegPower'].keys(): 
     545                                        csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma'] 
     546                                if 'highGamma' in packet['eegPower'].keys(): 
     547                                        csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma'] 
     548                         
     549                        for header in customDataHeaders: 
     550                                if 'custom' in packet.keys() and \ 
     551                                   header in packet['custom'].keys(): 
     552                                        csv[timestamp][header] = packet['custom'][header] 
     553                 
     554                 
     555                if scrub_data: 
     556                        csv = self.scrubData(csv, truncate_csv_timezone, source=source) 
     557                 
     558                 
     559                output = headers 
     560                 
     561                csv_keys = csv.keys() 
     562                csv_keys.sort() 
     563                 
     564                for key in csv_keys: 
     565                         
     566                        row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \ 
     567                              (csv[key]['Date'], \ 
     568                               csv[key]['Time'], \ 
     569                               csv[key]['Attention'], \ 
     570                               csv[key]['Meditation'], \ 
     571                               csv[key]['Signal Level'], \ 
     572                               csv[key]['Delta'], \ 
     573                               csv[key]['Theta'], \ 
     574                               csv[key]['Low Alpha'], \ 
     575                               csv[key]['High Alpha'], \ 
     576                               csv[key]['Low Beta'], \ 
     577                               csv[key]['High Beta'], \ 
     578                               csv[key]['Low Gamma'], \ 
     579                               csv[key]['Mid Gamma']) 
     580                         
     581                        for header in customDataHeaders: 
     582                                row = row + ',%s' % csv[key][header] 
     583                         
     584                        row = row + '\n' 
     585                         
     586                        output = output + row 
     587                 
     588                 
     589                return(output) 
     590         
     591         
     592        ################################################################## 
     593         
     594        def scrubData(self, csv, truncate_csv_timezone=False, source=None): 
     595                 
     596                # If there are missing packets, repeat a given packet once per missing 
     597                # second until there is a gap between 1 and 2 seconds, in which case 
     598                # produce a final duplicate packet at the mid-point between the packets 
     599                 
     600                if self.DEBUG: 
     601                        print "INFO: Scrubbing Data" 
     602                 
     603                if source == None: 
     604                        if self.parent == None: 
     605                                source = self 
     606                        else: 
     607                                source = self.parent 
     608                 
     609                last_time = None 
     610                last_recorded_time = None 
     611                 
     612                output = {} 
     613                 
     614                csv_keys = csv.keys() 
     615                csv_keys.sort() 
     616                 
     617                for key in csv_keys: 
     618                         
     619                        timestamp = key 
     620                         
     621                        if last_time == None: 
     622                                # First entry in log 
     623                                last_time = timestamp 
     624                                last_recorded_time = timestamp 
     625                                #output[key] = csv[key] 
     626                                if key not in output.keys(): 
     627                                        output[key] = DEFAULT_PACKET.copy() 
     628                                output[key].update(csv[key]) 
     629                                continue 
     630                         
     631                        else: 
     632                                 
     633                                #time_difference = timestamp - last_time 
     634                                #time_difference = timestamp - last_recorded_time 
     635                                time_difference = abs(timestamp - last_recorded_time) 
     636                                 
     637                                if (time_difference <= 1) and \ 
     638                                   (time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD): 
     639                                        # Skip packets within the correct time threshold 
     640                                        last_time = timestamp 
     641                                        last_recorded_time = timestamp 
     642                                        #output[key] = csv[key] 
     643                                        if key not in output.keys(): 
     644                                                output[key] = DEFAULT_PACKET.copy() 
     645                                        output[key].update(csv[key]) 
     646                                         
     647                                        #print "<=1 and >=min" 
     648                                        continue 
     649                                 
     650                                else: 
     651                                         
     652                                        if self.DEBUG > 1: 
     653                                                print "time_difference:", 
     654                                                print time_difference 
     655                                                print "timestamp:", 
     656                                                print source.parseTimeStamp(timestamp)[-1].split(' ')[0] 
     657                                                print "last_time:", 
     658                                                print source.parseTimeStamp(last_time)[-1].split(' ')[0] 
     659                                                print "last_recorded_time:", 
     660                                                print source.parseTimeStamp(last_recorded_time)[-1].split(' ')[0] 
     661                                         
     662                                         
     663                                        #new_packet = csv[key].copy() 
     664                                        if key not in output.keys(): 
     665                                                new_packet = DEFAULT_PACKET.copy() 
     666                                        new_packet.update(csv[key]) 
     667                                         
     668                                        if time_difference >= 2: 
     669                                                 
     670                                                ##new_time = last_time + 1 
     671                                                #new_time = last_recorded_time + 1 
     672                                                 
     673                                                count = int(time_difference) 
     674                                                while count >= 1: 
     675                                                        #new_packet = csv[key].copy() 
     676                                                        if key not in output.keys(): 
     677                                                                new_packet = DEFAULT_PACKET.copy() 
     678                                                        new_packet.update(csv[key]) 
     679                                                         
     680                                                        new_time = last_recorded_time + 1 
     681                                                        (date, formatted_new_time) = source.parseTimeStamp(new_time, \ 
     682                                                         truncate_time_zone=truncate_csv_timezone) 
     683                                                        new_packet['Time'] = formatted_new_time 
     684                                                        last_recorded_time = new_time 
     685                                                        last_time = timestamp 
     686                                                        if key not in output.keys(): 
     687                                                                output[new_time] = new_packet 
     688                                                        else: 
     689                                                                output[new_time].update(new_packet) 
     690                                                        count = count - 1 
     691                                                continue 
     692                                         
     693                                                #print ">=2" 
     694                                         
     695                                         
     696                                        elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD: 
     697                                                # Spread out "bunched up" packets 
     698                                                #new_time = last_time + 1 
     699                                                new_time = last_recorded_time + 1 
     700                                                #new_time = last_recorded_time 
     701                                                #print "<min" 
     702                                         
     703                                         
     704                                        elif (time_difference < 2) and (time_difference > 1): 
     705                                                 
     706                                                #new_time = last_time + ((last_time - timestamp) / 2) 
     707                                                #new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2) 
     708                                                #new_time = last_time + 1 
     709                                                #new_time = last_recorded_time + 1 
     710                                                new_time = last_recorded_time 
     711                                                #print "<2" 
     712                                         
     713                                         
     714                                        (date, formatted_new_time) = source.parseTimeStamp(new_time, \ 
     715                                           truncate_time_zone=truncate_csv_timezone) 
     716                                         
     717                                        new_packet['Time'] = formatted_new_time 
     718                                         
     719                                        #last_time = new_time 
     720                                        last_recorded_time = new_time 
     721                                        #last_time = timestamp 
     722                                        last_time = new_time 
     723                                        try: 
     724                                                output[new_time].update(new_packet) 
     725                                        except Exception, e: 
     726                                                output[new_time] = new_packet 
     727                                                #print e 
     728                                         
     729                                        if self.DEBUG > 1: 
     730                                                print "WARN: Scrubbing new packet:", 
     731                                                print new_packet 
     732                                                print 
     733                 
    369734                 
    370735                return(output) 
  • trunk/Puzzlebox/Synapse/ThinkGear/Protocol.py

    r389 r390  
    868868        def resetSessionStartTime(self): 
    869869                 
    870                 self.session_start_timestamp = time.time() 
     870                #self.session_start_timestamp = time.time() 
    871871                 
    872872                if (self.parent != None): 
  • trunk/Puzzlebox/Synapse/ThinkGear/Server.py

    r389 r390  
    130130DEFAULT_RESPONSE_MESSAGE = DEFAULT_SIGNAL_LEVEL_MESSAGE 
    131131 
    132 PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD = 0.75 
     132#PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD = 0.75 
    133133 
    134134##################################################################### 
     
    472472        ################################################################## 
    473473         
    474         def exportDataToCSV(self, parent=None, source=None, target=None): 
    475                  
    476                 # handle importing class from multiple sources 
    477                 if parent == None: 
    478                         if self.parent == None: 
    479                                 parent = self 
    480                         else: 
    481                                 parent = self.parent 
    482                  
    483                 if source == None: 
    484                         if self.parent == None: 
    485                                 source = self 
    486                         else: 
    487                                 source = self.parent 
    488                  
    489                 if target == None: 
    490                         if self.parent == None: 
    491                                 target = self 
    492                         else: 
    493                                 target = self.parent 
    494                  
    495                 try: 
    496                         truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE 
    497                 except: 
    498                         truncate_csv_timezone = False 
    499                  
    500                  
    501                 if not self.emulate_headset_data: 
    502                         # NOTE: no need to scrub emulated data 
    503                         try: 
    504                                 scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA 
    505                         except: 
    506                                 scrub_data = False 
    507                 else: 
    508                         scrub_data = False 
    509                  
    510                 #headers = 'Date,Time' 
    511                 headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma' 
    512                 #headers = self.customDataHeaders 
    513                  
    514                 customDataHeaders = [] 
    515                 for header in parent.customDataHeaders: 
    516                         customDataHeaders.append(header) 
    517                 for plugin in parent.activePlugins: 
    518                         for header in plugin.customDataHeaders: 
    519                                 customDataHeaders.append(header) 
    520                  
    521                 for each in customDataHeaders: 
    522                         headers = headers + ',%s' % each 
    523                  
    524                 headers = headers + '\n' 
    525                  
    526                  
    527                 csv = {} 
    528                  
    529                 for packet in source.packets['signals']: 
    530                          
    531                          
    532                         if 'rawEeg' in packet.keys(): 
    533                                 continue 
    534                          
    535                         if packet['timestamp'] not in csv.keys(): 
    536                                  
    537                                 if 'blinkStrength' in packet.keys(): 
    538                                         # Skip any blink packets from log 
    539                                         continue 
    540                                  
    541                                  
    542                                 timestamp = packet['timestamp'] 
    543                                 #(date, localtime) = self.parseTimeStamp(timestamp, \ 
     474        #def exportDataToCSV(self, parent=None, source=None, target=None): 
     475                 
     476                ## handle importing class from multiple sources 
     477                #if parent == None: 
     478                        #if self.parent == None: 
     479                                #parent = self 
     480                        #else: 
     481                                #parent = self.parent 
     482                 
     483                #if source == None: 
     484                        #if self.parent == None: 
     485                                #source = self 
     486                        #else: 
     487                                #source = self.parent 
     488                 
     489                #if target == None: 
     490                        #if self.parent == None: 
     491                                #target = self 
     492                        #else: 
     493                                #target = self.parent 
     494                 
     495                #try: 
     496                        #truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE 
     497                #except: 
     498                        #truncate_csv_timezone = False 
     499                 
     500                 
     501                #if not self.emulate_headset_data: 
     502                        ## NOTE: no need to scrub emulated data 
     503                        #try: 
     504                                #scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA 
     505                        #except: 
     506                                #scrub_data = False 
     507                #else: 
     508                        #scrub_data = False 
     509                 
     510                ##headers = 'Date,Time' 
     511                #headers = 'Date,Time,Attention,Meditation,Signal Level,Delta,Theta,Low Alpha,High Alpha,Low Beta,High Beta,Low Gamma,Mid Gamma' 
     512                ##headers = self.customDataHeaders 
     513                 
     514                #customDataHeaders = [] 
     515                #for header in parent.customDataHeaders: 
     516                        #customDataHeaders.append(header) 
     517                #for plugin in parent.activePlugins: 
     518                        #for header in plugin.customDataHeaders: 
     519                                #customDataHeaders.append(header) 
     520                 
     521                #for each in customDataHeaders: 
     522                        #headers = headers + ',%s' % each 
     523                 
     524                #headers = headers + '\n' 
     525                 
     526                 
     527                #csv = {} 
     528                 
     529                #for packet in source.packets['signals']: 
     530                         
     531                         
     532                        #if 'rawEeg' in packet.keys(): 
     533                                #continue 
     534                         
     535                        #if packet['timestamp'] not in csv.keys(): 
     536                                 
     537                                #if 'blinkStrength' in packet.keys(): 
     538                                        ## Skip any blink packets from log 
     539                                        #continue 
     540                                 
     541                                 
     542                                #timestamp = packet['timestamp'] 
     543                                ##(date, localtime) = self.parseTimeStamp(timestamp, \ 
     544                                                    ##truncate_time_zone=truncate_csv_timezone) 
     545                                #(date, localtime) = source.parseTimeStamp(timestamp, \ 
    544546                                                    #truncate_time_zone=truncate_csv_timezone) 
    545                                 (date, localtime) = source.parseTimeStamp(timestamp, \ 
    546                                                     truncate_time_zone=truncate_csv_timezone) 
    547                                  
    548                                 csv[timestamp] = {} 
    549                                 csv[timestamp]['Date'] = date 
    550                                 csv[timestamp]['Time'] = localtime 
    551                                 csv[timestamp]['Attention'] = '' 
    552                                 csv[timestamp]['Meditation'] = '' 
    553                                 csv[timestamp]['Signal Level'] = '' 
    554                                 csv[timestamp]['Delta'] = '' 
    555                                 csv[timestamp]['Theta'] = '' 
    556                                 csv[timestamp]['Low Alpha'] = '' 
    557                                 csv[timestamp]['High Alpha'] = '' 
    558                                 csv[timestamp]['Low Beta'] = '' 
    559                                 csv[timestamp]['High Beta'] = '' 
    560                                 csv[timestamp]['Low Gamma'] = '' 
    561                                 csv[timestamp]['Mid Gamma'] = '' 
    562                                  
    563                                 for header in customDataHeaders: 
    564                                         csv[timestamp][header] = '' 
    565                          
    566                          
    567                         if 'eSense' in packet.keys(): 
    568                                 if 'attention' in packet['eSense'].keys(): 
    569                                         csv[timestamp]['Attention'] = packet['eSense']['attention'] 
    570                                 if 'meditation' in packet['eSense'].keys(): 
    571                                         csv[timestamp]['Meditation'] = packet['eSense']['meditation'] 
    572                          
    573                         if 'poorSignalLevel' in packet.keys(): 
    574                                 csv[timestamp]['Signal Level'] = packet['poorSignalLevel'] 
    575                          
    576                         if 'eegPower' in packet.keys(): 
    577                                 if 'delta' in packet['eegPower'].keys(): 
    578                                         csv[timestamp]['Delta'] = packet['eegPower']['delta'] 
    579                                 if 'theta' in packet['eegPower'].keys(): 
    580                                         csv[timestamp]['Theta'] = packet['eegPower']['theta'] 
    581                                 if 'lowAlpha' in packet['eegPower'].keys(): 
    582                                         csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha'] 
    583                                 if 'highAlpha' in packet['eegPower'].keys(): 
    584                                         csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha'] 
    585                                 if 'lowBeta' in packet['eegPower'].keys(): 
    586                                         csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta'] 
    587                                 if 'highBeta' in packet['eegPower'].keys(): 
    588                                         csv[timestamp]['High Beta'] = packet['eegPower']['highBeta'] 
    589                                 if 'lowGamma' in packet['eegPower'].keys(): 
    590                                         csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma'] 
    591                                 if 'highGamma' in packet['eegPower'].keys(): 
    592                                         csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma'] 
    593                          
    594                         for header in customDataHeaders: 
    595                                 if 'custom' in packet.keys() and \ 
    596                                    header in packet['custom'].keys(): 
    597                                         csv[timestamp][header] = packet['custom'][header] 
    598                  
    599                  
    600                 if scrub_data: 
    601                         csv = self.scrubData(csv, truncate_csv_timezone, source=source) 
    602                  
    603                  
    604                 output = headers 
    605                  
    606                 csv_keys = csv.keys() 
    607                 csv_keys.sort() 
    608                  
    609                 for key in csv_keys: 
    610                          
    611                         row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \ 
    612                               (csv[key]['Date'], \ 
    613                                csv[key]['Time'], \ 
    614                                csv[key]['Attention'], \ 
    615                                csv[key]['Meditation'], \ 
    616                                csv[key]['Signal Level'], \ 
    617                                csv[key]['Delta'], \ 
    618                                csv[key]['Theta'], \ 
    619                                csv[key]['Low Alpha'], \ 
    620                                csv[key]['High Alpha'], \ 
    621                                csv[key]['Low Beta'], \ 
    622                                csv[key]['High Beta'], \ 
    623                                csv[key]['Low Gamma'], \ 
    624                                csv[key]['Mid Gamma']) 
    625                          
    626                         for header in customDataHeaders: 
    627                                 row = row + ',%s' % csv[key][header] 
    628                          
    629                         row = row + '\n' 
    630                          
    631                         output = output + row 
    632                  
    633                  
    634                 return(output) 
    635          
    636          
    637         ################################################################## 
    638          
    639         def scrubData(self, csv, truncate_csv_timezone=False, source=None): 
    640                  
    641                 # If there are missing packets, repeat a given packet once per missing 
    642                 # second until there is a gap between 1 and 2 seconds, in which case 
    643                 # produce a final duplicate packet at the mid-point between the packets 
    644                  
    645                 if self.DEBUG: 
    646                         print "INFO: Scrubbing Data" 
    647                  
    648                 if source == None: 
    649                         if self.parent == None: 
    650                                 source = self 
    651                         else: 
    652                                 source = self.parent 
    653                  
    654                 last_time = None 
    655                 last_recorded_time = None 
    656                  
    657                 output = {} 
    658                  
    659                 csv_keys = csv.keys() 
    660                 csv_keys.sort() 
    661                  
    662                 for key in csv_keys: 
    663                          
    664                         timestamp = key 
    665  
    666                         if csv[key]['Attention'] == '': 
    667                                 continue 
    668                          
    669                         if last_time == None: 
    670                                 # First entry in log 
    671                                 last_time = timestamp 
    672                                 last_recorded_time = timestamp 
    673                                 output[key] = csv[key] 
    674                                 continue 
    675                          
    676                         else: 
    677                                  
    678                                 #time_difference = timestamp - last_time 
    679                                 time_difference = timestamp - last_recorded_time 
    680                                  
    681                                 if (time_difference <= 1) and \ 
    682                                    (time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD): 
    683                                         # Skip packets within the correct time threshold 
    684                                         last_time = timestamp 
    685                                         last_recorded_time = timestamp 
    686                                         output[key] = csv[key] 
    687                                         continue 
    688                                  
    689                                 else: 
    690                                          
    691                                         if self.DEBUG > 1: 
    692                                                 print "time_difference:", 
    693                                                 print time_difference 
    694                                                 print "timestamp:", 
    695                                                 print source.parseTimeStamp(timestamp)[-1].split(' ')[0] 
    696                                                 print "last_time:", 
    697                                                 print source.parseTimeStamp(last_time)[-1].split(' ')[0] 
    698                                                 print "last_recorded_time:", 
    699                                                 print source.parseTimeStamp(last_recorded_time)[-1].split(' ')[0] 
    700                                          
    701                                          
    702                                         new_packet = csv[key].copy() 
    703                                          
    704                                         if time_difference >= 2: 
     547                                 
     548                                #csv[timestamp] = {} 
     549                                #csv[timestamp]['Date'] = date 
     550                                #csv[timestamp]['Time'] = localtime 
     551                                #csv[timestamp]['Attention'] = '' 
     552                                #csv[timestamp]['Meditation'] = '' 
     553                                #csv[timestamp]['Signal Level'] = '' 
     554                                #csv[timestamp]['Delta'] = '' 
     555                                #csv[timestamp]['Theta'] = '' 
     556                                #csv[timestamp]['Low Alpha'] = '' 
     557                                #csv[timestamp]['High Alpha'] = '' 
     558                                #csv[timestamp]['Low Beta'] = '' 
     559                                #csv[timestamp]['High Beta'] = '' 
     560                                #csv[timestamp]['Low Gamma'] = '' 
     561                                #csv[timestamp]['Mid Gamma'] = '' 
     562                                 
     563                                #for header in customDataHeaders: 
     564                                        #csv[timestamp][header] = '' 
     565                         
     566                         
     567                        #if 'eSense' in packet.keys(): 
     568                                #if 'attention' in packet['eSense'].keys(): 
     569                                        #csv[timestamp]['Attention'] = packet['eSense']['attention'] 
     570                                #if 'meditation' in packet['eSense'].keys(): 
     571                                        #csv[timestamp]['Meditation'] = packet['eSense']['meditation'] 
     572                         
     573                        #if 'poorSignalLevel' in packet.keys(): 
     574                                #csv[timestamp]['Signal Level'] = packet['poorSignalLevel'] 
     575                         
     576                        #if 'eegPower' in packet.keys(): 
     577                                #if 'delta' in packet['eegPower'].keys(): 
     578                                        #csv[timestamp]['Delta'] = packet['eegPower']['delta'] 
     579                                #if 'theta' in packet['eegPower'].keys(): 
     580                                        #csv[timestamp]['Theta'] = packet['eegPower']['theta'] 
     581                                #if 'lowAlpha' in packet['eegPower'].keys(): 
     582                                        #csv[timestamp]['Low Alpha'] = packet['eegPower']['lowAlpha'] 
     583                                #if 'highAlpha' in packet['eegPower'].keys(): 
     584                                        #csv[timestamp]['High Alpha'] = packet['eegPower']['highAlpha'] 
     585                                #if 'lowBeta' in packet['eegPower'].keys(): 
     586                                        #csv[timestamp]['Low Beta'] = packet['eegPower']['lowBeta'] 
     587                                #if 'highBeta' in packet['eegPower'].keys(): 
     588                                        #csv[timestamp]['High Beta'] = packet['eegPower']['highBeta'] 
     589                                #if 'lowGamma' in packet['eegPower'].keys(): 
     590                                        #csv[timestamp]['Low Gamma'] = packet['eegPower']['lowGamma'] 
     591                                #if 'highGamma' in packet['eegPower'].keys(): 
     592                                        #csv[timestamp]['Mid Gamma'] = packet['eegPower']['highGamma'] 
     593                         
     594                        #for header in customDataHeaders: 
     595                                #if 'custom' in packet.keys() and \ 
     596                                   #header in packet['custom'].keys(): 
     597                                        #csv[timestamp][header] = packet['custom'][header] 
     598                 
     599                 
     600                #if scrub_data: 
     601                        #csv = self.scrubData(csv, truncate_csv_timezone, source=source) 
     602                 
     603                 
     604                #output = headers 
     605                 
     606                #csv_keys = csv.keys() 
     607                #csv_keys.sort() 
     608                 
     609                #for key in csv_keys: 
     610                         
     611                        #row = '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % \ 
     612                              #(csv[key]['Date'], \ 
     613                               #csv[key]['Time'], \ 
     614                               #csv[key]['Attention'], \ 
     615                               #csv[key]['Meditation'], \ 
     616                               #csv[key]['Signal Level'], \ 
     617                               #csv[key]['Delta'], \ 
     618                               #csv[key]['Theta'], \ 
     619                               #csv[key]['Low Alpha'], \ 
     620                               #csv[key]['High Alpha'], \ 
     621                               #csv[key]['Low Beta'], \ 
     622                               #csv[key]['High Beta'], \ 
     623                               #csv[key]['Low Gamma'], \ 
     624                               #csv[key]['Mid Gamma']) 
     625                         
     626                        #for header in customDataHeaders: 
     627                                #row = row + ',%s' % csv[key][header] 
     628                         
     629                        #row = row + '\n' 
     630                         
     631                        #output = output + row 
     632                 
     633                 
     634                #return(output) 
     635         
     636         
     637        ################################################################## 
     638         
     639        #def scrubData(self, csv, truncate_csv_timezone=False, source=None): 
     640                 
     641                ## If there are missing packets, repeat a given packet once per missing 
     642                ## second until there is a gap between 1 and 2 seconds, in which case 
     643                ## produce a final duplicate packet at the mid-point between the packets 
     644                 
     645                #if self.DEBUG: 
     646                        #print "INFO: Scrubbing Data" 
     647                 
     648                #if source == None: 
     649                        #if self.parent == None: 
     650                                #source = self 
     651                        #else: 
     652                                #source = self.parent 
     653                 
     654                #last_time = None 
     655                #last_recorded_time = None 
     656                 
     657                #output = {} 
     658                 
     659                #csv_keys = csv.keys() 
     660                #csv_keys.sort() 
     661                 
     662                #for key in csv_keys: 
     663                         
     664                        #timestamp = key 
     665 
     666                        #if csv[key]['Attention'] == '': 
     667                                #continue 
     668                         
     669                        #if last_time == None: 
     670                                ## First entry in log 
     671                                #last_time = timestamp 
     672                                #last_recorded_time = timestamp 
     673                                #output[key] = csv[key] 
     674                                #continue 
     675                         
     676                        #else: 
     677                                 
     678                                ##time_difference = timestamp - last_time 
     679                                #time_difference = timestamp - last_recorded_time 
     680                                 
     681                                #if (time_difference <= 1) and \ 
     682                                   #(time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD): 
     683                                        ## Skip packets within the correct time threshold 
     684                                        #last_time = timestamp 
     685                                        #last_recorded_time = timestamp 
     686                                        #output[key] = csv[key] 
     687                                        #continue 
     688                                 
     689                                #else: 
     690                                         
     691                                        #if self.DEBUG > 1: 
     692                                                #print "time_difference:", 
     693                                                #print time_difference 
     694                                                #print "timestamp:", 
     695                                                #print source.parseTimeStamp(timestamp)[-1].split(' ')[0] 
     696                                                #print "last_time:", 
     697                                                #print source.parseTimeStamp(last_time)[-1].split(' ')[0] 
     698                                                #print "last_recorded_time:", 
     699                                                #print source.parseTimeStamp(last_recorded_time)[-1].split(' ')[0] 
     700                                         
     701                                         
     702                                        #new_packet = csv[key].copy() 
     703                                         
     704                                        #if time_difference >= 2: 
    705705                                                 
     706                                                ###new_time = last_time + 1 
     707                                                ##new_time = last_recorded_time + 1 
     708                                                 
     709                                                #count = int(time_difference) 
     710                                                #while count >= 1: 
     711                                                        #new_packet = csv[key].copy() 
     712                                                        #new_time = last_recorded_time + 1 
     713                                                        #(date, formatted_new_time) = source.parseTimeStamp(new_time, \ 
     714                                                         #truncate_time_zone=truncate_csv_timezone) 
     715                                                        #new_packet['Time'] = formatted_new_time 
     716                                                        #last_recorded_time = new_time 
     717                                                        #last_time = timestamp 
     718                                                        #output[new_time] = new_packet 
     719                                                        #count = count - 1 
     720                                                #continue 
     721                                                 
     722                                        #elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD: 
     723                                                ## Spread out "bunched up" packets 
    706724                                                ##new_time = last_time + 1 
    707725                                                #new_time = last_recorded_time + 1 
     726                                         
     727                                         
     728                                        #elif (time_difference < 2) and (time_difference > 1): 
    708729                                                 
    709                                                 count = int(time_difference) 
    710                                                 while count >= 1: 
    711                                                         new_packet = csv[key].copy() 
    712                                                         new_time = last_recorded_time + 1 
    713                                                         (date, formatted_new_time) = source.parseTimeStamp(new_time, \ 
    714                                                          truncate_time_zone=truncate_csv_timezone) 
    715                                                         new_packet['Time'] = formatted_new_time 
    716                                                         last_recorded_time = new_time 
    717                                                         last_time = timestamp 
    718                                                         output[new_time] = new_packet 
    719                                                         count = count - 1 
    720                                                 continue 
    721                                                  
    722                                         elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD: 
    723                                                 # Spread out "bunched up" packets 
    724                                                 #new_time = last_time + 1 
    725                                                 new_time = last_recorded_time + 1 
    726                                          
    727                                          
    728                                         elif (time_difference < 2) and (time_difference > 1): 
    729                                                  
    730                                                 #new_time = last_time + ((last_time - timestamp) / 2) 
    731                                                 #new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2) 
    732                                                 #new_time = last_time + 1 
    733                                                 new_time = last_recorded_time + 1 
    734                                          
    735                                          
    736                                         (date, formatted_new_time) = source.parseTimeStamp(new_time, \ 
    737                                            truncate_time_zone=truncate_csv_timezone) 
    738                                          
    739                                         new_packet['Time'] = formatted_new_time 
    740                                          
    741                                         #last_time = new_time 
    742                                         last_recorded_time = new_time 
    743                                         last_time = timestamp 
    744                                         output[new_time] = new_packet 
    745                                          
    746                                         if self.DEBUG > 1: 
    747                                                 print "WARN: Scrubbing new packet:", 
    748                                                 print new_packet 
    749                                                 print 
    750                  
    751                  
    752                 return(output) 
     730                                                ##new_time = last_time + ((last_time - timestamp) / 2) 
     731                                                ##new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2) 
     732                                                ##new_time = last_time + 1 
     733                                                #new_time = last_recorded_time + 1 
     734                                         
     735                                         
     736                                        #(date, formatted_new_time) = source.parseTimeStamp(new_time, \ 
     737                                           #truncate_time_zone=truncate_csv_timezone) 
     738                                         
     739                                        #new_packet['Time'] = formatted_new_time 
     740                                         
     741                                        ##last_time = new_time 
     742                                        #last_recorded_time = new_time 
     743                                        #last_time = timestamp 
     744                                        #output[new_time] = new_packet 
     745                                         
     746                                        #if self.DEBUG > 1: 
     747                                                #print "WARN: Scrubbing new packet:", 
     748                                                #print new_packet 
     749                                                #print 
     750                 
     751                 
     752                #return(output) 
    753753         
    754754         
Note: See TracChangeset for help on using the changeset viewer.