source: trunk/Puzzlebox/Synapse/Session.py @ 411

Last change on this file since 411 was 411, checked in by sc, 4 years ago
  • exportTrainingDataToCSV() added
  • collectProcessedData() added
  • Training debug output added to Protocol
File size: 29.8 KB
Line 
1# -*- coding: utf-8 -*-
2
3# Copyright Puzzlebox Productions, LLC (2010-2014)
4#
5# This code is released under the GNU Pulic License (GPL) version 2
6# For more information please refer to http://www.gnu.org/copyleft/gpl.html
7
8__changelog__ = """\
9Last Update: 2016.01.26
10"""
11
12__todo__ = """
13"""
14
15### IMPORTS ###
16import os, sys, time
17
18import Puzzlebox.Synapse.Configuration as configuration
19
20if configuration.ENABLE_PYSIDE:
21        try:
22                import PySide as PyQt4
23                from PySide import QtCore, QtGui
24        except Exception, e:
25                print "ERROR: [Synapse:Session] Exception importing PySide:",
26                print e
27                configuration.ENABLE_PYSIDE = False
28        else:
29                print "INFO: [Synapse:Session] Using PySide module"
30
31if not configuration.ENABLE_PYSIDE:
32        print "INFO: [Synapse:Session] Using PyQt4 module"
33        from PyQt4 import QtCore, QtGui
34
35
36try:
37        import cPickle as pickle
38except:
39        import pickle
40
41
42#####################################################################
43# Globals
44#####################################################################
45
46DEBUG = configuration.DEBUG
47
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
95#####################################################################
96# Classes
97#####################################################################
98
99class puzzlebox_synapse_session(QtGui.QWidget):
100       
101        def __init__(self, log, \
102                     DEBUG=DEBUG, \
103                     parent=None, \
104                     ):
105               
106                self.log = log
107                self.DEBUG = DEBUG
108                self.parent=parent
109               
110                if self.parent == None:
111                        QtGui.QWidget.__init__(self, parent)
112                        #self.setupUi(self)
113               
114                        self.configureSettings()
115                        self.connectWidgets()
116               
117                self.name = "Synapse:Session"
118               
119               
120                if (sys.platform == 'win32'):
121                        self.homepath = os.path.join( \
122                           os.environ['HOMEDRIVE'], \
123                           os.environ['HOMEPATH'], \
124                           'Desktop')
125                elif (sys.platform == 'darwin'):
126                        desktop = os.path.join(os.environ['HOME'], 'Documents')
127                        if os.path.exists(desktop):
128                                self.homepath = desktop
129                        else:
130                                self.homepath = os.environ['HOME']
131                else:
132                        desktop = os.path.join(os.environ['HOME'], 'Desktop')
133                        if os.path.exists(desktop):
134                                self.homepath = desktop
135                        else:
136                                self.homepath = os.environ['HOME']
137               
138               
139                if not os.path.exists(self.homepath):
140                        if self.DEBUG:
141                                print "WARNING: [Synapse:Session] User default path not found"
142                        self.homepath = os.getcwd()
143       
144       
145        ##################################################################
146       
147        def configureSettings(self):
148               
149                pass
150       
151       
152        ##################################################################
153       
154        def connectWidgets(self):
155               
156                pass
157       
158       
159        ##################################################################
160       
161        def updateProfileSessionStatus(self, source=None, target=None):
162               
163                session_time = self.calculateSessionTime()
164               
165                #if source == None:
166                        #if self.parent == None:
167                                #source = self
168                        #else:
169                                #source = self.parent
170               
171                #if target == None:
172                        #if self.parent == None:
173                                #target = self
174                        #else:
175                                #target = self.parent
176               
177                #target.textLabelSessionTime.setText(session_time)
178                self.textLabelSessionTime.setText(session_time)
179               
180                        #self.parent.packet_count)
181                        #self.synapseServer.protocol.packet_count)
182               
183                try:
184                        packet_count = self.parent.plugin_eeg.getPacketCount()
185                except:
186                        try:
187                                packet_count = self.synapseServer.protocol.packet_count
188                        except:
189                                packet_count = 0
190               
191                self.textLabelPacketsReceived.setText( "%i" % packet_count)
192               
193               
194                try:
195                        bad_packets = self.parent.plugin_eeg.getBadPackets()
196                except:
197                        try:
198                                bad_packets = self.synapseServer.protocol.bad_packets
199                        except:
200                                bad_packets = 0
201               
202                self.textLabelPacketsDropped.setText( "%i" % bad_packets)
203       
204       
205        ##################################################################
206       
207        def calculateSessionTime(self):
208               
209                session_time = self.getSessionTime()
210               
211                session_time = time.time() - session_time
212                session_time = int(session_time)
213                session_time = self.convert_seconds_to_datetime(session_time)
214               
215                return (session_time)
216       
217       
218        ##################################################################
219       
220        def getSessionTime(self):
221               
222                return (self.synapseServer.session_start_timestamp)
223       
224       
225        ##################################################################
226       
227        def collectData(self, source=None, target=None):
228               
229                if source == None:
230                        if self.parent == None:
231                                source = self
232                        else:
233                                source = self.parent
234               
235                if target == None:
236                        if self.parent == None:
237                                target = self
238                        else:
239                                target = self.parent
240               
241                data = {}
242               
243                data['rawEeg'] = source.packets['rawEeg']
244                data['signals'] = source.packets['signals']
245               
246                data['sessionTime'] = self.calculateSessionTime()
247               
248                data['profileName'] = str(target.lineEditSessionProfile.text())
249               
250                return(data)
251       
252       
253        ##################################################################
254       
255        def parseTimeStamp(self, timestamp, local_version=False, truncate_time_zone=False):
256               
257                try:
258                        decimal = '%f' % timestamp
259                        decimal = decimal.split('.')[1]
260                except:
261                        decimal = '0'
262               
263                localtime = time.localtime(timestamp)
264               
265                if local_version:
266                        date = time.strftime('%x', localtime)
267                        localtime = time.strftime('%X', localtime)
268               
269                elif truncate_time_zone:
270                        date = time.strftime('%Y-%m-%d', localtime)
271                        localtime = time.strftime('%H:%M:%S', localtime)
272                        localtime = '%s.%s' % (localtime, decimal[:3])
273               
274                else:
275                        date = time.strftime('%Y-%m-%d', localtime)
276                        localtime = time.strftime('%H:%M:%S', localtime)
277                        localtime = '%s.%s %s' % (localtime, decimal, \
278                                       time.strftime('%Z', time.localtime(timestamp)))
279               
280               
281                return(date, localtime)
282       
283       
284        ##################################################################
285       
286        def saveData(self, source=None, target=None, output_file=None, use_default=False):
287               
288                if source == None:
289                        if self.parent == None:
290                                source = self
291                        else:
292                                source = self.parent
293               
294                if target == None:
295                        if self.parent == None:
296                                target = self
297                        else:
298                                target = self.parent
299               
300                data = self.collectData(source=source, target=target)
301               
302                (date, localtime) = self.parseTimeStamp(time.time())
303               
304                default_filename = '%s %s.synapse' % (date, \
305                                      target.lineEditSessionProfile.text())
306                                     
307                default_filename = os.path.join(self.homepath, default_filename)
308               
309               
310                if output_file == None:
311                       
312                        # use_default controls whether or not a file is automatically saves using the
313                        # default name and path (as opposed to raising a GUI file selection menu)
314                        # whenever an explicit filepath is not defined
315                        if use_default:
316                                       
317                                        output_file = default_filename
318                       
319                        else:
320                       
321                                output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \
322                                                 caption="Save Session Data to File", \
323                                                 directory=default_filename, \
324                                                 filter="Puzzlebox Synapse Data File (*.synapse)")
325                               
326                                # TODO 2014-02-09 Disabling due to failure with Puzzlebox Orbit
327                                # TODO 2014-02-23 Re-enabled due to failure to write files
328                                try:
329                                        output_file = output_file[0]
330                                except:
331                                        #output_file = ''
332                                        # TODO 2014-02-23 Attempted compromise
333                                        pass
334                                       
335               
336               
337                if output_file == '':
338                        return
339               
340               
341                file = open(str(output_file), 'w')
342                pickle.dump(data, file)
343                file.close()
344       
345       
346        ##################################################################
347       
348        def exportData(self, parent=None, source=None, target=None, output_file=None, use_default=False):
349               
350                if parent == None:
351                        if self.parent == None:
352                                parent = self
353                        else:
354                                parent = self.parent
355               
356                if source == None:
357                        if self.parent == None:
358                                source = self
359                        else:
360                                source = self.parent
361               
362                if target == None:
363                        if self.parent == None:
364                                target = self
365                        else:
366                                target = self.parent
367               
368               
369                try:
370                        export_csv_raw = target.configuration.EXPORT_CSV_RAW_DATA
371                except:
372                        export_csv_raw = False
373               
374               
375                (date, localtime) = self.parseTimeStamp(time.time())
376               
377                default_filename = '%s %s.csv' % (date, \
378                                      target.lineEditSessionProfile.text())
379               
380                default_filename = os.path.join(target.homepath, default_filename)
381               
382               
383                if output_file == None:
384                       
385                        # use_default controls whether or not a file is automatically saves using the
386                        # default name and path (as opposed to raising a GUI file selection menu)
387                        # whenever an explicit filepath is not defined
388                        if use_default:
389                                       
390                                        output_file = default_filename
391                       
392                        else:
393                                output_file = QtGui.QFileDialog.getSaveFileName(parent=target, \
394                                                 caption="Export Session Data to File", \
395                                                 directory=default_filename, \
396                                                 filter="CSV File (*.csv);;Text File (*.txt)")
397                               
398                                # TODO 2014-02-09 Disabling due to failure with Puzzlebox Orbit
399                                # TODO 2014-02-23 Re-enabled due to failure to write files
400                                try:
401                                        output_file = output_file[0]
402                                except:
403                                        #output_file = ''
404                                        # TODO 2014-02-23 Attempted compromise
405                                        pass
406               
407               
408                if output_file == '':
409                        return
410               
411               
412                if str(output_file).endswith('.csv'):
413                       
414                        outputData = self.exportDataToCSV(parent=parent, source=source, target=target)
415               
416               
417                else:
418                       
419                        try:
420                                outputData = self.textEditDebugConsole.toPlainText()
421                        except:
422                                outputData = self.exportDataToCSV(parent=parent, source=source, target=target)
423               
424               
425                if self.DEBUG:
426                        print "Writing file:",
427                        print output_file
428               
429               
430                file = open(os.path.join(str(output_file)), 'w')
431                file.write(outputData)
432                file.close()
433               
434               
435                if export_csv_raw:
436                       
437                        output_file = output_file.replace('.csv', '-rawEeg.csv')
438                       
439                        outputData = self.exportRawDataToCSV(parent=parent, source=source, target=target)
440                       
441                        if outputData != None:
442                               
443                                file = open(str(output_file), 'w')
444                                file.write(outputData)
445                                file.close()
446       
447       
448                # TODO
449                print "here"
450                export_csv_training = True
451                if export_csv_training:
452                       
453                        output_file = output_file.replace('.csv', '-trainingEeg.csv')
454                       
455                        if self.DEBUG:
456                                print "Writing file:",
457                                print output_file
458                       
459                        outputData = self.exportTrainingDataToCSV(parent=parent, source=source, target=target)
460                       
461                        if outputData != None:
462                               
463                                file = open(str(output_file), 'w')
464                                file.write(outputData)
465                                file.close()
466       
467       
468        ##################################################################
469       
470        def exportDataToCSV(self, parent=None, source=None, target=None):
471               
472                # handle importing class from multiple sources
473                if parent == None:
474                        if self.parent == None:
475                                parent = self
476                        else:
477                                parent = self.parent
478               
479                if source == None:
480                        if self.parent == None:
481                                source = self
482                        else:
483                                source = self.parent
484               
485                if target == None:
486                        if self.parent == None:
487                                target = self
488                        else:
489                                target = self.parent
490               
491                try:
492                        truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE
493                except:
494                        truncate_csv_timezone = False
495               
496               
497                #print source.name
498                #print source.packets['signals']
499               
500               
501                # NOTE: no need to scrub emulated data
502                try:
503                        scrub_data = target.configuration.EXPORT_CSV_SCRUB_DATA
504                except:
505                        scrub_data = False
506               
507                try:
508                        if self.parent.plugin_eeg.emulate_headset_data:
509                                scrub_data = False
510                except:
511                        pass
512               
513               
514                headers = 'Date,Time'
515               
516               
517                customDataHeaders = []
518                for header in parent.customDataHeaders:
519                        customDataHeaders.append(header)
520                for plugin in parent.activePlugins:
521                        #print plugin.name
522                        for header in plugin.customDataHeaders:
523                                customDataHeaders.append(header)
524               
525                for each in customDataHeaders:
526                        headers = headers + ',%s' % each
527               
528                headers = headers + '\n'
529               
530               
531                csv = {}
532               
533               
534                for packet in source.packets['signals']:
535                       
536                       
537                        # NOTE: Move this to ThinkGear Server object
538                        #if 'rawEeg' in packet.keys():
539                                #continue
540                       
541                       
542                        if 'timestamp' not in packet.keys() and len(packet.keys()) == 1:
543                                if self.DEBUG:
544                                        print "WARN: Skipping empty packet:",
545                                        print packet
546                                # skip empty packets
547                                continue
548                       
549                       
550                        print "packet:",
551                        print packet
552                       
553                        timestamp = packet['timestamp']
554                        #(date, localtime) = self.parseTimeStamp(timestamp, \
555                                                                                #truncate_time_zone=truncate_csv_timezone)
556                        (date, localtime) = source.parseTimeStamp(timestamp, \
557                                                                                truncate_time_zone=truncate_csv_timezone)
558                       
559                        if timestamp not in csv.keys():
560                               
561                                #if 'blinkStrength' in packet.keys():
562                                        ## Skip any blink packets from log
563                                        #continue
564                               
565                               
566                                #timestamp = packet['timestamp']
567                                ##(date, localtime) = self.parseTimeStamp(timestamp, \
568                                                    ##truncate_time_zone=truncate_csv_timezone)
569                                #(date, localtime) = source.parseTimeStamp(timestamp, \
570                                                    #truncate_time_zone=truncate_csv_timezone)
571                               
572                                csv[timestamp] = {}
573                                csv[timestamp]['Date'] = date
574                                csv[timestamp]['Time'] = localtime
575                       
576                       
577                        for plugin in parent.activePlugins:
578                                if plugin.customDataHeaders != []:
579                                        if self.DEBUG > 2:
580                                                print "INFO: [Synapse:Session] Exporting:",
581                                                print plugin.name
582                                        try:
583                                                csv[timestamp] = plugin.processPacketForExport(packet=packet, output=csv[timestamp])
584                                                if self.DEBUG > 2:
585                                                        print "INFO [Synapse:Session]: Export Successful"
586                                                        print plugin.name
587                                        except Exception, e:
588                                                if self.DEBUG:
589                                                        print "ERROR: [Synapse:Session] Exception calling processPacketForExport on",
590                                                        print plugin.name
591                       
592                       
593                        for header in customDataHeaders:
594                               
595                                if 'custom' in packet.keys() and \
596                                   header in packet['custom'].keys():
597                                       
598                                        timestamp = packet['timestamp']
599                                        (date, localtime) = source.parseTimeStamp(timestamp, \
600                                                               truncate_time_zone=truncate_csv_timezone)
601                                       
602                                        if timestamp not in csv.keys():
603                                                csv[timestamp] = {}
604                                                csv[timestamp]['Date'] = date
605                                                csv[timestamp]['Time'] = localtime
606                                                if self.DEBUG:
607                                                        print "WARN: Unmatched custom packet:",
608                                                        print packet
609                                       
610                                        csv[timestamp][header] = packet['custom'][header]
611               
612               
613                if scrub_data:
614                        csv = self.scrubData(csv, truncate_csv_timezone, source=source)
615               
616               
617                output = headers
618               
619                timestamps = csv.keys()
620                timestamps.sort()
621               
622                for timestamp in timestamps:
623                       
624                        row = '%s,%s' % \
625                              (csv[timestamp]['Date'], \
626                               csv[timestamp]['Time'])
627                       
628                        for header in customDataHeaders:
629                                if header in csv[timestamp].keys():
630                                        row = row + ',%s' % csv[timestamp][header]
631                                else:
632                                        #row = row + ','
633                                        row = ''
634                                        if self.DEBUG > 1:
635                                                print "WARN: empty signals packet:",
636                                                print csv[timestamp]
637                                        break
638                       
639                        if row != '':
640                                row = row + '\n'
641                       
642                        output = output + row
643               
644               
645                return(output)
646       
647       
648        ##################################################################
649       
650        def exportRawDataToCSV(self, parent=None, source=None, target=None):
651               
652                # handle importing class from multiple sources
653                if parent == None:
654                        if self.parent == None:
655                                parent = self
656                        else:
657                                parent = self.parent
658               
659                if source == None:
660                        if self.parent == None:
661                                source = self
662                        else:
663                                source = self.parent
664               
665                if target == None:
666                        if self.parent == None:
667                                target = self
668                        else:
669                                target = self.parent
670               
671               
672                try:
673                        truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE
674                except:
675                        truncate_csv_timezone = False
676               
677               
678                if source.packets['rawEeg'] == []:
679                        return(None)
680               
681               
682                headers = 'Date,Time,Raw EEG'
683                headers = headers + '\n'
684               
685                csv = {}
686               
687                for packet in source.packets['rawEeg']:
688                       
689                        # NOTE: Move this to ThinkGear Server object
690                        if 'rawEeg' in packet.keys():
691                               
692                                if packet['timestamp'] not in csv.keys():
693                                       
694                                        timestamp = packet['timestamp']
695                                       
696                                        (date, localtime) = source.parseTimeStamp(timestamp, \
697                                                            truncate_time_zone=truncate_csv_timezone)
698                                       
699                                        csv[timestamp] = {}
700                                        csv[timestamp]['Date'] = date
701                                        csv[timestamp]['Time'] = localtime
702                                        csv[timestamp]['rawEeg'] = packet['rawEeg']
703               
704               
705                output = headers
706               
707                timestamps = csv.keys()
708               
709                # Don't sort timestamps in order to better preserve the original raw signal
710                #timestamps.sort()
711               
712                for timestamp in timestamps:
713                       
714                        row = '%s,%s,%s' % \
715                              (csv[timestamp]['Date'], \
716                               csv[timestamp]['Time'], \
717                               csv[timestamp]['rawEeg'])
718                       
719                        row = row + '\n'
720                       
721                        output = output + row
722               
723               
724                return(output)
725       
726       
727        ##################################################################
728       
729        def exportTrainingDataToCSV(self, parent=None, source=None, target=None):
730               
731                # handle importing class from multiple sources
732                if parent == None:
733                        if self.parent == None:
734                                parent = self
735                        else:
736                                parent = self.parent
737               
738                if source == None:
739                        if self.parent == None:
740                                source = self
741                        else:
742                                source = self.parent
743               
744                if target == None:
745                        if self.parent == None:
746                                target = self
747                        else:
748                                target = self.parent
749               
750               
751                try:
752                        truncate_csv_timezone = target.configuration.EXPORT_CSV_TRUNCATE_TIMEZONE
753                except:
754                        truncate_csv_timezone = False
755               
756               
757                if source.packets['rawEeg'] == []:
758                        if self.DEBUG:
759                                print "WARNING: No raw EEG packets"
760                        return(None)
761                else:
762                        if self.DEBUG:
763                                print "INFO: Raw EEG packets:",
764                                print len(source.packets['rawEeg'])
765               
766               
767                #headers = 'Date,Time,Raw EEG'
768                #headers = headers + '\n'
769               
770               
771                headers = 'Date,Time'
772               
773               
774                customDataHeaders = []
775                for header in parent.customDataHeaders:
776                        customDataHeaders.append(header)
777                for plugin in parent.activePlugins:
778                        #print plugin.name
779                        for header in plugin.customDataHeaders:
780                                customDataHeaders.append(header)
781               
782                for each in customDataHeaders:
783                        headers = headers + ',%s' % each
784                       
785                       
786                headers = headers +',%s' % 'Raw EEG'
787                       
788               
789                headers = headers + '\n'
790               
791               
792                csv = {}
793               
794                for packet in source.packets['rawEeg']:
795                       
796                        # NOTE: Move this to ThinkGear Server object
797                        if 'rawEeg' in packet.keys():
798                               
799                                if packet['timestamp'] not in csv.keys():
800                                       
801                                       
802                                        timestamp = packet['timestamp']
803                                       
804                                        (date, localtime) = source.parseTimeStamp(timestamp, \
805                                                            truncate_time_zone=truncate_csv_timezone)
806                                       
807                                        csv[timestamp] = {}
808                                        csv[timestamp]['Date'] = date
809                                        csv[timestamp]['Time'] = localtime
810                                        csv[timestamp]['rawEeg'] = packet['rawEeg']
811                                       
812                                       
813                                        csv[timestamp].update(self.collectProcessedData(parent, source, timestamp))
814               
815               
816                output = headers
817               
818                timestamps = csv.keys()
819               
820                # Don't sort timestamps in order to better preserve the original raw signal
821                #timestamps.sort()
822               
823                for timestamp in timestamps:
824                       
825                        row = '%s,%s,%s' % \
826                              (csv[timestamp]['Date'], \
827                               csv[timestamp]['Time'], \
828                               csv[timestamp]['rawEeg'])
829                               
830                               
831                               
832                        for header in customDataHeaders:
833                                if header in csv[timestamp].keys():
834                                        row = row + ',%s' % csv[timestamp][header]
835                                else:
836                                        #row = row + ','
837                                        row = ''
838                                        if self.DEBUG > 1:
839                                                print "WARN: empty signals packet:",
840                                                print csv[timestamp]
841                                        break
842                               
843                               
844                               
845                       
846                        row = row + '\n'
847                       
848                        output = output + row
849               
850               
851                return(output)
852       
853       
854        #################################################################
855       
856        def collectProcessedData(self, parent, source, match_timestamp):
857               
858                # Return processed and custom data fields for this timestamp
859               
860               
861                if self.DEBUG:
862                        print "Match Timestamp:",
863                        print match_timestamp
864               
865               
866                packet_timestamps = []
867                for packet in source.packets['signals']:
868                       
869                        if 'blinkStrength' in packet.keys():
870                                # Skip any blink packets from log
871                                continue
872                       
873                        packet_timestamps.append(packet['timestamp'])
874               
875               
876                packet_timestamps.sort()
877               
878               
879                #found = {}
880               
881                for timestamp in packet_timestamps:
882                       
883                        if self.DEBUG:
884                                print "--> Search Timestamp:",
885                                print match_timestamp
886                       
887                        #if (found == {}):
888                                #found = packet
889                                #continue
890                       
891                        # Keep searching until
892                        if (match_timestamp > timestamp):
893                                continue
894                       
895                        #found = packet
896               
897                        if self.DEBUG:
898                                print "Matched Timestamp:",
899                                print timestamp
900               
901               
902                packet = {}
903               
904                for each in source.packets['signals']:
905                        if each['timestamp'] == timestamp:
906                                #if self.DEBUG:
907                                        #print "INFO: Packet Found:",
908                                        #print each
909                                packet = each
910               
911               
912                data = {}
913                       
914                for plugin in parent.activePlugins:
915                        if plugin.customDataHeaders != []:
916                                if self.DEBUG > 2:
917                                        print "INFO: [Synapse:Session] Exporting:",
918                                        print plugin.name
919                                try:
920                                        data = plugin.processPacketForExport(packet=packet, output=data)
921                                        if self.DEBUG > 2:
922                                                print "INFO [Synapse:Session]: Export Successful"
923                                                print plugin.name
924                                except Exception, e:
925                                        if self.DEBUG:
926                                                print "ERROR: [Synapse:Session] Exception calling processPacketForExport on",
927                                                print plugin.name
928               
929               
930                #print "INFO: data",
931                #print data
932               
933                return data
934               
935               
936                #for header in customDataHeaders:
937                       
938                        #if 'custom' in packet.keys() and \
939                                #header in packet['custom'].keys():
940                               
941                                #timestamp = packet['timestamp']
942                                #(date, localtime) = source.parseTimeStamp(timestamp, \
943                                                                                                #truncate_time_zone=truncate_csv_timezone)
944                               
945                                #if timestamp not in csv.keys():
946                                        #data = {}
947                                        #data['Date'] = date
948                                        #data['Time'] = localtime
949                                        #if self.DEBUG:
950                                                #print "WARN: Unmatched custom packet:",
951                                                #print packet
952                               
953                                #data[header] = packet['custom'][header]
954
955               
956               
957               
958                #for packet in source.packets['signals']:
959                       
960                       
961                        ## NOTE: Move this to ThinkGear Server object
962                        ##if 'rawEeg' in packet.keys():
963                                ##continue
964                       
965                       
966                        #if 'timestamp' not in packet.keys() and len(packet.keys()) == 1:
967                                #if self.DEBUG:
968                                        #print "WARN: Skipping empty packet:",
969                                        #print packet
970                                ## skip empty packets
971                                #continue
972                       
973                       
974                        #print "packet:",
975                        #print packet
976                       
977                        #timestamp = packet['timestamp']
978                        ##(date, localtime) = self.parseTimeStamp(timestamp, \
979                                                                                ##truncate_time_zone=truncate_csv_timezone)
980                        #(date, localtime) = source.parseTimeStamp(timestamp, \
981                                                                                #truncate_time_zone=truncate_csv_timezone)
982                       
983                        #if timestamp not in csv.keys():
984                               
985
986                               
987                               
988                                ##timestamp = packet['timestamp']
989                                ###(date, localtime) = self.parseTimeStamp(timestamp, \
990                                                    ###truncate_time_zone=truncate_csv_timezone)
991                                ##(date, localtime) = source.parseTimeStamp(timestamp, \
992                                                    ##truncate_time_zone=truncate_csv_timezone)
993                               
994                                #csv[timestamp] = {}
995                                #csv[timestamp]['Date'] = date
996                                #csv[timestamp]['Time'] = localtime
997                       
998                       
999                        #for plugin in parent.activePlugins:
1000                                #if plugin.customDataHeaders != []:
1001                                        #if self.DEBUG > 2:
1002                                                #print "INFO: [Synapse:Session] Exporting:",
1003                                                #print plugin.name
1004                                        #try:
1005                                                #csv[timestamp] = plugin.processPacketForExport(packet=packet, output=csv[timestamp])
1006                                                #if self.DEBUG > 2:
1007                                                        #print "INFO [Synapse:Session]: Export Successful"
1008                                                        #print plugin.name
1009                                        #except Exception, e:
1010                                                #if self.DEBUG:
1011                                                        #print "ERROR: [Synapse:Session] Exception calling processPacketForExport on",
1012                                                        #print plugin.name
1013                       
1014                       
1015                        #for header in customDataHeaders:
1016                               
1017                                #if 'custom' in packet.keys() and \
1018                                   #header in packet['custom'].keys():
1019                                       
1020                                        #timestamp = packet['timestamp']
1021                                        #(date, localtime) = source.parseTimeStamp(timestamp, \
1022                                                               #truncate_time_zone=truncate_csv_timezone)
1023                                       
1024                                        #if timestamp not in csv.keys():
1025                                                #csv[timestamp] = {}
1026                                                #csv[timestamp]['Date'] = date
1027                                                #csv[timestamp]['Time'] = localtime
1028                                                #if self.DEBUG:
1029                                                        #print "WARN: Unmatched custom packet:",
1030                                                        #print packet
1031                                       
1032                                        #csv[timestamp][header] = packet['custom'][header]
1033
1034       
1035        #################################################################
1036       
1037        def scrubData(self, csv, truncate_csv_timezone=False, source=None):
1038               
1039                # If there are missing packets, repeat a given packet once per missing
1040                # second until there is a gap between 1 and 2 seconds, in which case
1041                # produce a final duplicate packet at the mid-point between the packets
1042               
1043                if self.DEBUG:
1044                        print "INFO: Scrubbing Data"
1045               
1046                if source == None:
1047                        if self.parent == None:
1048                                source = self
1049                        else:
1050                                source = self.parent
1051               
1052                last_time = None
1053                last_recorded_time = None
1054               
1055                output = {}
1056               
1057                csv_keys = csv.keys()
1058                csv_keys.sort()
1059               
1060                for key in csv_keys:
1061                       
1062                        timestamp = key
1063                       
1064                        if last_time == None:
1065                                # First entry in log
1066                                last_time = timestamp
1067                                last_recorded_time = timestamp
1068                                #output[key] = csv[key]
1069                                if key not in output.keys():
1070                                        output[key] = DEFAULT_PACKET.copy()
1071                                output[key].update(csv[key])
1072                                continue
1073                       
1074                        else:
1075                               
1076                                #time_difference = timestamp - last_time
1077                                #time_difference = timestamp - last_recorded_time
1078                                time_difference = abs(timestamp - last_recorded_time)
1079                               
1080                                if (time_difference <= 1) and \
1081                                   (time_difference >= PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD):
1082                                        # Skip packets within the correct time threshold
1083                                        last_time = timestamp
1084                                        last_recorded_time = timestamp
1085                                        #output[key] = csv[key]
1086                                        if key not in output.keys():
1087                                                output[key] = DEFAULT_PACKET.copy()
1088                                        output[key].update(csv[key])
1089                                       
1090                                        #print "<=1 and >=min"
1091                                        continue
1092                               
1093                                else:
1094                                       
1095                                        if self.DEBUG > 1:
1096                                                print "time_difference:",
1097                                                print time_difference
1098                                                print "timestamp:",
1099                                                print source.parseTimeStamp(timestamp)[-1].split(' ')[0]
1100                                                print "last_time:",
1101                                                print source.parseTimeStamp(last_time)[-1].split(' ')[0]
1102                                                print "last_recorded_time:",
1103                                                print source.parseTimeStamp(last_recorded_time)[-1].split(' ')[0]
1104                                       
1105                                       
1106                                        #new_packet = csv[key].copy()
1107                                        if key not in output.keys():
1108                                                new_packet = DEFAULT_PACKET.copy()
1109                                        new_packet.update(csv[key])
1110                                       
1111                                        if time_difference >= 2:
1112                                               
1113                                                ##new_time = last_time + 1
1114                                                #new_time = last_recorded_time + 1
1115                                               
1116                                                count = int(time_difference)
1117                                                while count >= 1:
1118                                                        #new_packet = csv[key].copy()
1119                                                        if key not in output.keys():
1120                                                                new_packet = DEFAULT_PACKET.copy()
1121                                                        new_packet.update(csv[key])
1122                                                       
1123                                                        new_time = last_recorded_time + 1
1124                                                        (date, formatted_new_time) = source.parseTimeStamp(new_time, \
1125                                                         truncate_time_zone=truncate_csv_timezone)
1126                                                        new_packet['Time'] = formatted_new_time
1127                                                        last_recorded_time = new_time
1128                                                        last_time = timestamp
1129                                                        if key not in output.keys():
1130                                                                output[new_time] = new_packet
1131                                                        else:
1132                                                                output[new_time].update(new_packet)
1133                                                        count = count - 1
1134                                                continue
1135                                       
1136                                                #print ">=2"
1137                                       
1138                                       
1139                                        elif time_difference < PACKET_MINIMUM_TIME_DIFFERENCE_THRESHOLD:
1140                                                # Spread out "bunched up" packets
1141                                                #new_time = last_time + 1
1142                                                new_time = last_recorded_time + 1
1143                                                #new_time = last_recorded_time
1144                                                #print "<min"
1145                                       
1146                                       
1147                                        elif (time_difference < 2) and (time_difference > 1):
1148                                               
1149                                                #new_time = last_time + ((last_time - timestamp) / 2)
1150                                                #new_time = last_recorded_time + ((last_recorded_time - timestamp) / 2)
1151                                                #new_time = last_time + 1
1152                                                #new_time = last_recorded_time + 1
1153                                                new_time = last_recorded_time
1154                                                #print "<2"
1155                                       
1156                                       
1157                                        (date, formatted_new_time) = source.parseTimeStamp(new_time, \
1158                                           truncate_time_zone=truncate_csv_timezone)
1159                                       
1160                                        new_packet['Time'] = formatted_new_time
1161                                       
1162                                        #last_time = new_time
1163                                        last_recorded_time = new_time
1164                                        #last_time = timestamp
1165                                        last_time = new_time
1166                                        try:
1167                                                output[new_time].update(new_packet)
1168                                        except Exception, e:
1169                                                output[new_time] = new_packet
1170                                                #print e
1171                                       
1172                                        if self.DEBUG > 1:
1173                                                print "WARN: Scrubbing new packet:",
1174                                                print new_packet
1175                                                print
1176               
1177               
1178                return(output)
1179       
1180       
1181        ##################################################################
1182       
1183        def resetData(self, source=None):
1184               
1185                if source == None:
1186                        if self.parent == None:
1187                                source = self
1188                        else:
1189                                source = self.parent
1190               
1191                source.packets['rawEeg'] = []
1192                source.packets['signals'] = []
1193               
1194                if self.synapseServer != None:
1195                        self.synapseServer.protocol.resetSessionStartTime()
1196                else:
1197                        self.resetSessionStartTime()
1198               
1199                if self.synapseServer != None:
1200                        source.synapseServer.protocol.packet_count = 0
1201                        source.synapseServer.protocol.bad_packets = 0
1202                else:
1203                        source.packet_count = 0
1204                        source.bad_packets = 0
1205               
1206                self.updateProfileSessionStatus()
1207               
1208                try:
1209                        source.textEditDebugConsole.setText("")
1210                except:
1211                        pass
1212       
1213       
1214        #####################################################################
1215       
1216        def resetSessionStartTime(self, source=None):
1217               
1218                self.session_start_timestamp = time.time()
1219               
1220               
1221        #####################################################################
1222       
1223        def convert_seconds_to_datetime(self, duration):
1224               
1225                duration_hours = duration / (60 * 60)
1226                duration_minutes = (duration - (duration_hours * (60 * 60))) / 60
1227                duration_seconds = (duration - (duration_hours * (60 * 60)) - (duration_minutes * 60))
1228               
1229                duration_hours = '%i' % duration_hours
1230                if (len(duration_hours) == 1):
1231                        duration_hours = "0%s" % duration_hours
1232               
1233                duration_minutes = '%i' % duration_minutes
1234                if (len(duration_minutes) == 1):
1235                        duration_minutes = "0%s" % duration_minutes
1236               
1237                duration_seconds = '%i' % duration_seconds
1238                if (len(duration_seconds) == 1):
1239                        duration_seconds = "0%s" % duration_seconds
1240               
1241                datetime = '%s:%s:%s' % (duration_hours, duration_minutes, duration_seconds)
1242               
1243                return(datetime)
1244
Note: See TracBrowser for help on using the repository browser.