Пример #1
0
    def __init__(self):
        QThread.__init__(self)
        self.current_challenge = None
        self.challenges = defaultdict(list)
        self.progress = ProgressBarThread.ProgressBarThread()
        self.progress.signal_progress.connect(self.change_progress)
        self.progress.signal_toggle_lights.connect(self.prompter_toggle_lights)
        self.progress.signal_start_new_stage.connect(self.start_new_stage)
        #self.camera_thread = Camera.WebcamRecorder()  # Main Camera thread
        self.eeg_thread = EEG.EEG()  # Main EEG client thread
        self.eeg_thread.sample_signal.connect(self.get_samples)
        self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.StreamPlayback)
        self.beeper_thread = Beeper.Beeper()  # beeper thread
        self.current_samples = []
        self.current_original_duration = 0
        self.current_eyes_open = True
        self.current_movie = ""
        self.used_challenges = []
        self.current_state_filename = ""
        self.session_labels_dict = dict()
        self.symbols_count = 15  # number of repetitions for each class
        self.symbols_status = defaultdict(lambda: 0)  # keep track


        # EEG samples collection
        self.current_log_saving = False
        self.current_log_filename = ""
Пример #2
0
    def __init__(self):
        QThread.__init__(self)
        self.current_challenge = None
        self.challenges = defaultdict(list)
        self.progress = ProgressBarThread.ProgressBarThread()
        self.progress.signal_progress.connect(self.change_progress)
        self.progress.signal_toggle_lights.connect(self.prompter_toggle_lights)
        self.progress.signal_start_new_stage.connect(self.start_new_stage)
        self.camera_thread = Camera.WebcamRecorder()  # Main Camera thread
        self.eeg_thread = EEG.EEG()  # Main EEG client thread
        self.eeg_thread.sample_signal.connect(self.get_samples)
        self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.StreamPlayback)
        self.current_samples = []
        self.current_original_duration = 0
        self.current_eyes_open = True
        self.current_movie = ""
        self.used_challenges = []

        # EEG samples collection
        self.current_log_saving = False
        self.current_log_filename = ""
Пример #3
0
import numpy as np
#import pygtk

import EEG

#p = EEG.EEG('Dog_2', 'interictal', 17)
#p = EEG.EEG('Dog_2', 'preictal', 17)
#p = EEG.EEG('Patient_2', 'interictal', 17)
p = EEG.EEG('Patient_2', 'preictal', 17)
p.load()
print p
#p.normalize_channels()
p.normalize_overall()

#print np.shape(p.data)  == (16, ~240k)

data = p.data
eeg = np.rollaxis(data, 1)

# see p797 of matplotlib pdf : matshow() for 2d colour-map of (say) correlation matrix

#import matplotlib
#matplotlib.use('Qt4Agg')  # Needs PySide - difficult to install, large
#matplotlib.use('GTKAgg')  # Needs pygtk   - found script on Gist.github.com
#matplotlib.use('TkAgg')  # Needs Tkinter - difficult within VirtualEnv
import matplotlib.pyplot as plt

#data = p.data
n = p.n_channels
spacing = 5
trace_levels = spacing * np.arange(n, 0, -1)
Пример #4
0
    to_hickle = dict(
        features=all_params,
        signal_period_starts=signal_period_starts,
    )

    # Dump data, with compression
    f = "data/feat/%s/%s_%s_segment_%04d.hickle" % (p.subject, p.subject,
                                                    p.desc, p.num)
    hickle.dump(to_hickle, f, mode='w', compression='gzip')


if (args.fft > 0):
    if False:  # Just do one sample
        #p = EEG.EEG(_subject, 'interictal', 17)
        p = EEG.EEG(_subject, 'preictal', 18)
        preprocess(p)
        exit(1)

    if True:  # Load in the survey, and do the fft thing for everything
        #d = "data/orig/%s/" % (_subject, )
        csv = open("data/survey.%s.csv" % (_subject, ), 'r')
        headers = csv.readline()
        for line in csv.readlines():
            p = EEG.EEG(_subject, '', '')  # Nonsense entries
            p.survey_line_read(line)

            preprocess(p)

if (args.scale > 0):
    ## concatinate entries  (NB, must do train first, to generate min/max meta-data)
Пример #5
0
import argparse
parser = argparse.ArgumentParser(description='Survey the data')
parser.add_argument('--subject',
                    type=str,
                    required=True,
                    help="Dog_{1,2,3,4,5}, Patient_{1,2}")
args = parser.parse_args()

# 'Dog_2', 'Patient_2'
_subject = args.subject

d = "data/orig/%s/" % (_subject, )

csv = open("data/survey.%s.csv" % (_subject, ), 'w')
csv.write(EEG.EEG.survey_header() + "\n")

f_match = re.compile(r'%s_(.*?)_segment_(\d*?)\.mat' % (_subject, ))
for f in sorted(os.listdir(d)):
    m = re.match(f_match, f)
    if m is None: continue
    desc, num = m.group(1), int(m.group(2))

    print desc, num

    p = EEG.EEG(_subject, desc, num)
    p.load()
    csv.write(p.survey_line_write())

csv.close()