Ignore:
Timestamp:
05/07/12 17:07:54 (8 years ago)
Author:
sc
Message:
  • changes for Jigsaw release 1.2.2
File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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) 
Note: See TracChangeset for help on using the changeset viewer.