def test_reset(self):
'''
Call the reset function to improve (functional) code coverage
'''
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
simulator.reset()
def test_get_current_time(self):
'''
Call the get_current_time function to improve (functional) code coverage
'''
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
self.assertEqual(simulator.get_current_time(), -1)
def test_set_time(self):
'''
Call the set_time function to improve (functional) code coverage
'''
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
simulator.set_time(5)
def test_set_simulation_data(self):
'''
Verify if the simulation data can be set
Only function is called to improve (functional) code coverage, so no verification yet
'''
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
sim_data = self.create_simulation_data()
simulator.set_simulation_data(sim_data)
def setUp(self):
unittest.TestCase.setUp(self)
self.blackboard = Blackboard()
self.pat = '/test'
self.gen = DataGenerator(self.blackboard, self.pat, [1], [1])
self.gen.start()
self.pat2 = '/test2'
self.gen2 = DataGenerator(self.blackboard, self.pat2, [2], [1])
self.gen2.start()
def test_pause(self):
'''
Call the pause function to improve (functional) code coverage
'''
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
simulator.set_state(self.states.get('PLAYING'))
simulator.pause()
self.assertEqual(simulator.get_simulation_state(),
self.states.get('PAUSED'))
def test_get_set_simulation_state(self):
'''
Verify if the getting and setting of simulation states works correctly
'''
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
# Set all the states and verify if the state is set correctly
for _, value in self.states.iteritems():
simulator.set_state(value)
self.assertEqual(simulator.get_simulation_state(), value)
def setUp(self):
self.nr_of_headsets = 2
self.channels = [1, 2, 3, 4]
self.processors = []
self.bb = Blackboard()
patterns = []
for channel in [1, 3]:
for freq in [PatternStrings.ALPHA, PatternStrings.BETA]:
patterns.append(PatternStrings.SIGNAL_EEG + '%d' % (1) +
PatternStrings.CHANNEL + '%d' % (channel) +
freq)
self.processor = ArousalProcessor(self.bb, patterns)
def test_play_stop(self):
blackboard = Blackboard()
simulator = DataSimulator(blackboard)
# Prepare the simulator preconditions
simulator.set_simulation_data("test")
simulator.set_patterns("test")
simulator.set_simulation_interval(1)
simulator.start()
simulator.stop()
simulator.set_state(self.states.get('PAUSED'))
simulator.start()
simulator.stop()
def _test_get_time(self):
bb = Blackboard()
sim = DataSimulator(bb)
reader = HDFReader()
filename = filenames[5][0]
# Reading two datafiles
[mat, frequencies,
_] = reader.read(filename) # Read data from first data file
data = [np.asarray(mat[i - 1][1])
for i in range(1, 9)] # get data from selected channels
patterns = ['/EEG/channel_%d' % (i) for i in range(1, 9)]
interval = 1. / frequencies[1]
sim.set_simulation_data(data)
sim.set_simulation_interval(interval)
sim.set_patterns(patterns)
total_time = sim.get_total_time()
start_time = sim.get_current_time()
self.assertEquals(start_time, 0, 'Time should be zero before playback')
sim.start()
time.sleep(3)
now_time = sim.get_current_time()
self.assertAlmostEquals(
now_time,
3,
msg='Time should be close to 3 after 3 seconds playback. Is %f' %
now_time,
delta=.05)
sim.set_time(total_time - 2)
self.assertTrue(sim.get_simulation_state() is DataSimulator.PLAYING,
'Should be playing after setting time')
time.sleep(3)
self.assertTrue(sim.get_simulation_state() is DataSimulator.IDLE,
'Should be done playing')
sim.stop()
def setUp(self):
unittest.TestCase.setUp(self)
self.bb = Blackboard()
pattern = '/sines'
self.offset = 10
self.frequencies = [1, 3, 5, 7]
self.amps = [1, 2, 1, 8]
self.gen = DataGenerator(self.bb,
pattern,
frequencies=self.frequencies,
amplitudes=self.amps,
offset=self.offset,
noise=0)
self.freqspec = FFTAnalyzer(self.bb, pattern, windowsize=256)
self.bb.set_bufsize('/sines/fft', 128)
def setUp(self):
unittest.TestCase.setUp(self)
self.bb = Blackboard()
self.sim = TimedSimulator(self.bb)
[mat,
_] = HDFReader().read(test_filename) # Read data from first data file
_data = []
for i in range(4):
_data.append([v[:2] for v in mat[i][1]])
self.sim.set_simulation_data(_data)
eeg_chans = [
'/EEG_0/channel_%d/notch_50/lpf_75' % (i + 1) for i in range(4)
]
self.sim.set_patterns(eeg_chans)
def setUp(self):
"""
Initialize blackboard and a simulation data generator
"""
unittest.TestCase.setUp(self)
self.bb = Blackboard()
self.pattern = '/sines'
self.offset = 10
self.frequencies = [50, 10]
self.amps = [1, 1]
self.gen = DataGenerator(self.bb,
self.pattern,
frequencies=self.frequencies,
amplitudes=self.amps,
offset=self.offset,
noise=0)
def _test_set_data_and_playback_states(self):
bb = Blackboard()
sim = DataSimulator(bb)
reader = HDFReader()
filename = filenames[5][0]
# Reading two datafiles
[mat, frequencies,
_] = reader.read(filename) # Read data from first data file
data = [np.asarray(mat[i - 1][1])
for i in range(1, 9)] # get data from selected channels
patterns = ['/EEG/channel_%d' % (i) for i in range(1, 9)]
interval = 1. / frequencies[1]
sim.set_simulation_data(data)
sim.set_simulation_interval(interval)
sim.set_patterns(patterns)
self.assertEqual(sim.get_simulation_state(), DataSimulator.IDLE,
"Simulator should be idle now")
sim.start()
time.sleep(.1)
self.assertEqual(sim.get_simulation_state(), DataSimulator.PLAYING,
"Simulator should be playing now")
sim.pause()
time.sleep(.1)
self.assertEqual(sim.get_simulation_state(), DataSimulator.PAUSED,
"Simulator should be paused now")
sim.start()
time.sleep(.1)
self.assertEqual(sim.get_simulation_state(), DataSimulator.PLAYING,
"Simulator should be playing now")
sim.stop()
time.sleep(.1)
self.assertEqual(sim.get_simulation_state(), DataSimulator.IDLE,
"Simulator should be stopped now")
self.assertTrue(
bb.get_count(patterns[0]) > 0,
"Samples should be received on blackboard")
def setUp(self):
self.blackboard = Blackboard()
def setUp(self):
self.bb = Blackboard()
self.pattern = "/foo"
self._fig, self._ax = plt.subplots(1)
def setUp(self):
self.bb = Blackboard()
self.input = HDFReader()
def __init__(self):
Subject.__init__( self )
self.nr_of_headsets = 2
self.channels = [1,2,3,4]
self.blackboard = Blackboard()
self.simulators = []
self.headsets = []
self.processors = []
self.filerecorders = []
self.oscwriters = []
self._connected_headsets = 0
self.timeSettings = TimeSettings()
self.frequencySpectrumSettings =SpectrumSettings()
self.frequencyBandSettings = FrequencyBandSettings()
# Initialize simulators
for _ in range( self.nr_of_headsets ):
self.simulators.append( TimedSimulator( self.blackboard ) )
# Initialize headsets
for headset in range( self.nr_of_headsets ):
self.headsets.append( ImecInput( self.blackboard, PatternStrings.SIGNAL_EEG + '%d' % (headset) ) )
# Initialize preprocessing filters
for i, channel in enumerate(self.channels):
for headset in range( self.nr_of_headsets ):
pat = PatternStrings.SIGNAL_EEG + '%d' % (headset) + PatternStrings.CHANNEL + '%d' % (channel)
# Add notch filtering
notch = FIRFilter( self.blackboard, pat, FilterSettings.NOTCH_NUMTAPS, FilterSettings.NOTCH_FS, FilterSettings.NOTCH_FREQ, 'notch' )
notch.start(name = 'fir_notch' + pat)
self.processors.append( notch )
pat += PatternStrings.FILTERNOTCH
# Add low-pass filtering
lpf = FIRFilter( self.blackboard, pat, FilterSettings.LPF_NUMTAPS, FilterSettings.LPF_FS, FilterSettings.LPF_FREQ, 'lpf' )
lpf.start(name = 'fir_lpf' + pat)
self.processors.append( lpf )
# Patterns that will be recorded
patterns = []
for headset in range(self.nr_of_headsets):
patterns.append( [(PatternStrings.SIGNAL_EEG + '%d' % (headset) + PatternStrings.CHANNEL + '%d' % (i))
for i in self.channels])
names = [SignalNames.RAWSIGNAL for _ in self.channels ]
# Initialize recorders
for i, pat in enumerate(patterns):
rec = FileRecorder( self.blackboard, pat, self.channels, names, writer=IMECWriter() )
rec.start( interval=10, name = 'recorder-%d' % i )
self.filerecorders.append( rec )
# Perform FFT only on raw signals
patterns = []
for headset in range(self.nr_of_headsets):
patterns.append( [(PatternStrings.SIGNAL_EEG + '%d' % (headset) + PatternStrings.CHANNEL + '%d' % (i)) for i in self.channels] )
# Initialize FFT analyzer
freqspec = FFTAnalyzer(self.blackboard, sum(patterns, [])) # NOTE: Could be made faster by using for's i.s.o. sum, but for init-code not really relevant
#freqspec.start() DO NOT START FFT AT INIT
self.processors.append( freqspec )
# Initialize Arousal processors
for headset in range(self.nr_of_headsets):
patterns = []
for channel in [1,3]:
for freq in [PatternStrings.ALPHA, PatternStrings.BETA]:
patterns.append(PatternStrings.SIGNAL_EEG + '%d' % (headset) + PatternStrings.CHANNEL + '%d' % (channel) + freq)
# Initialize Arousal processor
arousal = ArousalProcessor(self.blackboard, patterns)
#arousal.start() DO NOT START ArousalProcessor AT INIT
self.processors.append( arousal )
def setUp(self):
self.test_pattern = 'test_eeg'
self.test_buffer = Blackboard()
self.imec = ImecInput(self.test_buffer, self.test_pattern)