def test_EventProxy(self):
proxy_event = EventProxy(rawio=self.reader,
event_channel_index=0,
block_index=0,
seg_index=0)
assert proxy_event.name == 'Some events'
assert proxy_event.shape == (6, )
# full load
full_event = proxy_event.load(time_slice=None)
assert isinstance(full_event, Event)
assert_same_attributes(proxy_event,
full_event,
exclude=('times', 'labels'))
assert full_event.shape == proxy_event.shape
# slice time
event = proxy_event.load(time_slice=(1 * pq.s, 2 * pq.s))
assert event.shape == (2, )
assert event.labels.shape == (2, )
assert_same_attributes(proxy_event.time_slice(1 * pq.s, 2 * pq.s),
event)
# buggy time slice
with self.assertRaises(AssertionError):
event = proxy_event.load(time_slice=(2 * pq.s, 15 * pq.s))
event = proxy_event.load(time_slice=(2 * pq.s, 15 * pq.s),
strict_slicing=False)
def test_EpochProxy(self):
proxy_epoch = EpochProxy(rawio=self.reader,
event_channel_index=1,
block_index=0,
seg_index=0)
assert proxy_epoch.name == 'Some epochs'
assert proxy_epoch.shape == (10, )
# full load
full_epoch = proxy_epoch.load(time_slice=None)
assert isinstance(full_epoch, Epoch)
assert_same_attributes(proxy_epoch,
full_epoch,
exclude=('times', 'labels', 'durations'))
assert full_epoch.shape == proxy_epoch.shape
# slice time
epoch = proxy_epoch.load(time_slice=(1 * pq.s, 4 * pq.s))
assert epoch.shape == (3, )
assert epoch.labels.shape == (3, )
assert epoch.durations.shape == (3, )
assert_same_attributes(proxy_epoch.time_slice(1 * pq.s, 4 * pq.s),
epoch)
# buggy time slice
with self.assertRaises(AssertionError):
epoch = proxy_epoch.load(time_slice=(2 * pq.s, 15 * pq.s))
epoch = proxy_epoch.load(time_slice=(2 * pq.s, 15 * pq.s),
strict_slicing=False)
def test_AnalogSignalProxy(self):
proxy_anasig = AnalogSignalProxy(rawio=self.reader, global_channel_indexes=None,
block_index=0, seg_index=0,)
assert proxy_anasig.sampling_rate == 10 * pq.kHz
assert proxy_anasig.t_start == 0 * pq.s
assert proxy_anasig.t_stop == 10 * pq.s
assert proxy_anasig.duration == 10 * pq.s
assert proxy_anasig.file_origin == 'my_filename.fake'
# full load
full_anasig = proxy_anasig.load(time_slice=None)
assert isinstance(full_anasig, AnalogSignal)
assert_same_attributes(proxy_anasig, full_anasig)
# slice time
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 5 * pq.s))
assert anasig.t_start == 2. * pq.s
assert anasig.duration == 3. * pq.s
assert anasig.shape == (30000, 16)
assert_same_attributes(proxy_anasig.time_slice(2. * pq.s, 5 * pq.s), anasig)
# ceil next sample when slicing
anasig = proxy_anasig.load(time_slice=(1.99999 * pq.s, 5.000001 * pq.s))
assert anasig.t_start == 2. * pq.s
assert anasig.duration == 3. * pq.s
assert anasig.shape == (30000, 16)
# buggy time slice
with self.assertRaises(AssertionError):
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 15 * pq.s))
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 15 * pq.s), strict_slicing=False)
assert proxy_anasig.t_stop == 10 * pq.s
# select channels
anasig = proxy_anasig.load(channel_indexes=[3, 4, 9])
assert anasig.shape[1] == 3
# select channels and slice times
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 5 * pq.s), channel_indexes=[3, 4, 9])
assert anasig.shape == (30000, 3)
# magnitude mode rescaled
anasig_float = proxy_anasig.load(magnitude_mode='rescaled')
assert anasig_float.dtype == 'float32'
assert anasig_float.units == pq.uV
assert anasig_float.units == proxy_anasig.units
# magnitude mode raw
anasig_int = proxy_anasig.load(magnitude_mode='raw')
assert anasig_int.dtype == 'int16'
assert anasig_int.units == pq.CompoundUnit('0.0152587890625*uV')
assert_arrays_almost_equal(anasig_float, anasig_int.rescale('uV'), 1e-9)
# test array_annotations
assert 'info' in proxy_anasig.array_annotations
assert proxy_anasig.array_annotations['info'].size == 16
assert 'info' in anasig_float.array_annotations
assert anasig_float.array_annotations['info'].size == 16
def test_SpikeTrainProxy(self):
proxy_sptr = SpikeTrainProxy(rawio=self.reader, spike_channel_index=0,
block_index=0, seg_index=0)
assert proxy_sptr.name == 'unit0'
assert proxy_sptr.t_start == 0 * pq.s
assert proxy_sptr.t_stop == 10 * pq.s
assert proxy_sptr.shape == (20,)
assert proxy_sptr.left_sweep == 0.002 * pq.s
assert proxy_sptr.sampling_rate == 10 * pq.kHz
# full load
full_sptr = proxy_sptr.load(time_slice=None)
assert isinstance(full_sptr, SpikeTrain)
assert_same_attributes(proxy_sptr, full_sptr)
assert full_sptr.shape == proxy_sptr.shape
# slice time
sptr = proxy_sptr.load(time_slice=(250 * pq.ms, 500 * pq.ms))
assert sptr.t_start == .25 * pq.s
assert sptr.t_stop == .5 * pq.s
assert sptr.shape == (6,)
assert_same_attributes(proxy_sptr.time_slice(250 * pq.ms, 500 * pq.ms), sptr)
# buggy time slice
with self.assertRaises(AssertionError):
sptr = proxy_sptr.load(time_slice=(2. * pq.s, 15 * pq.s))
sptr = proxy_sptr.load(time_slice=(2. * pq.s, 15 * pq.s), strict_slicing=False)
assert sptr.t_stop == 10 * pq.s
# magnitude mode rescaled
sptr_float = proxy_sptr.load(magnitude_mode='rescaled')
assert sptr_float.dtype == 'float64'
assert sptr_float.units == pq.s
# magnitude mode raw
# TODO when raw mode implemented
# sptr_int = proxy_sptr.load(magnitude_mode='raw')
# assert sptr_int.dtype=='int64'
# assert sptr_int.units==pq.CompoundUnit('1/10000*s')
# assert_arrays_almost_equal(sptr_float, sptr_int.rescale('s'), 1e-9)
# Without waveforms
sptr = proxy_sptr.load(load_waveforms=False)
assert sptr.waveforms is None
# With waveforms
sptr = proxy_sptr.load(load_waveforms=True, magnitude_mode='rescaled')
assert sptr.waveforms is not None
assert sptr.waveforms.shape == (20, 1, 50)
assert sptr.waveforms.units == 1 * pq.uV
# slice waveforms
sptr = proxy_sptr.load(load_waveforms=True, time_slice=(250 * pq.ms, 500 * pq.ms))
assert sptr.waveforms.shape == (6, 1, 50)
# test array_annotations
assert '__array_annotations__' not in proxy_sptr.annotations
assert 'amplitudes' in proxy_sptr.array_annotations
def _compare_objects(self, object1, object2, exclude_attr=[]):
assert object1.__class__.__name__ == object2.__class__.__name__
assert object2.file_origin == self.filename
assert_same_attributes(object1, object2, exclude=[
'file_origin',
'file_datetime'] + exclude_attr)
assert_same_annotations(object1, object2)
def _compare_objects(self, object1, object2, exclude_attr=[]):
assert object1.__class__.__name__ == object2.__class__.__name__
assert object2.file_origin == self.filename
assert_same_attributes(object1,
object2,
exclude=['file_origin', 'file_datetime'] +
exclude_attr)
assert_same_annotations(object1, object2)
def _compare_objects(self, object1, object2, exclude_attr=[]):
assert object1.__class__.__name__ == object2.__class__.__name__
assert object2.file_origin == self.filename
if hasattr(object1, 'file_datetime'):
assert object2.file_datetime == datetime.fromtimestamp(os.stat(self.filename).st_mtime)
assert_same_attributes(object1, object2, exclude=['file_origin', 'file_datetime'] + exclude_attr)
assert_same_annotations(object1, object2, exclude=['nsdfio_path'])
def test_SpikeTrainProxy(self):
proxy_sptr = SpikeTrainProxy(rawio=self.reader, unit_index=0,
block_index=0, seg_index=0)
assert proxy_sptr.name == 'unit0'
assert proxy_sptr.t_start == 0 * pq.s
assert proxy_sptr.t_stop == 10 * pq.s
assert proxy_sptr.shape == (20,)
assert proxy_sptr.left_sweep == 0.002 * pq.s
assert proxy_sptr.sampling_rate == 10 * pq.kHz
# full load
full_sptr = proxy_sptr.load(time_slice=None)
assert isinstance(full_sptr, SpikeTrain)
assert_same_attributes(proxy_sptr, full_sptr)
assert full_sptr.shape == proxy_sptr.shape
# slice time
sptr = proxy_sptr.load(time_slice=(250 * pq.ms, 500 * pq.ms))
assert sptr.t_start == .25 * pq.s
assert sptr.t_stop == .5 * pq.s
assert sptr.shape == (6,)
# buggy time slice
with self.assertRaises(AssertionError):
sptr = proxy_sptr.load(time_slice=(2. * pq.s, 15 * pq.s))
sptr = proxy_sptr.load(time_slice=(2. * pq.s, 15 * pq.s), strict_slicing=False)
assert sptr.t_stop == 10 * pq.s
# magnitude mode rescaled
sptr_float = proxy_sptr.load(magnitude_mode='rescaled')
assert sptr_float.dtype == 'float64'
assert sptr_float.units == pq.s
# magnitude mode raw
# TODO when raw mode implemented
# sptr_int = proxy_sptr.load(magnitude_mode='raw')
# assert sptr_int.dtype=='int64'
# assert sptr_int.units==pq.CompoundUnit('1/10000*s')
# assert_arrays_almost_equal(sptr_float, sptr_int.rescale('s'), 1e-9)
# Without waveforms
sptr = proxy_sptr.load(load_waveforms=False)
assert sptr.waveforms is None
# With waveforms
sptr = proxy_sptr.load(load_waveforms=True, magnitude_mode='rescaled')
assert sptr.waveforms is not None
assert sptr.waveforms.shape == (20, 1, 50)
assert sptr.waveforms.units == 1 * pq.uV
# slice waveforms
sptr = proxy_sptr.load(load_waveforms=True, time_slice=(250 * pq.ms, 500 * pq.ms))
assert sptr.waveforms.shape == (6, 1, 50)
def test_block_conversion(self):
# verify that all previous data is present in new structure
groups = self.new_block.groups
for channel_index in self.old_block.channel_indexes:
# check existence of objects and attributes
self.assertIn(channel_index.name, [g.name for g in groups])
group = groups[[g.name for g in groups].index(channel_index.name)]
# comparing group attributes to channel_index attributes
assert_same_attributes(group, channel_index)
self.assertDictEqual(channel_index.annotations, group.annotations)
# comparing views and their attributes
view_names = np.asarray([v.name for v in group.channelviews])
matching_views = np.asarray(
group.channelviews)[view_names == channel_index.name]
for view in matching_views:
self.assertIn('channel_ids', view.array_annotations)
self.assertIn('channel_names', view.array_annotations)
self.assertIn('coordinates_dim0', view.array_annotations)
self.assertIn('coordinates_dim1', view.array_annotations)
# check content of attributes
assert_arrays_equal(channel_index.index, view.index)
assert_arrays_equal(channel_index.channel_ids,
view.array_annotations['channel_ids'])
assert_arrays_equal(channel_index.channel_names,
view.array_annotations['channel_names'])
view_coordinates = np.vstack(
(view.array_annotations['coordinates_dim0'],
view.array_annotations['coordinates_dim1'])).T
# readd unit lost during stacking of arrays
units = view.array_annotations['coordinates_dim0'].units
view_coordinates = view_coordinates.magnitude * units
assert_arrays_equal(channel_index.coordinates,
view_coordinates)
self.assertDictEqual(channel_index.annotations,
view.annotations)
# check linking between objects
self.assertEqual(len(channel_index.data_children),
len(matching_views))
# check linking between objects
for child in channel_index.data_children:
# comparing names instead of objects as attributes differ
self.assertIn(child.name, [v.obj.name for v in matching_views])
group_names = np.asarray([g.name for g in group.groups])
for unit in channel_index.units:
self.assertIn(unit.name, group_names)
unit_names = np.asarray([u.name for u in channel_index.units])
matching_groups = np.isin(group_names, unit_names)
self.assertEqual(len(channel_index.units), len(matching_groups))
def test_AnalogSignalProxy(self):
proxy_anasig = AnalogSignalProxy(rawio=self.reader, global_channel_indexes=None,
block_index=0, seg_index=0,)
assert proxy_anasig.sampling_rate == 10 * pq.kHz
assert proxy_anasig.t_start == 0 * pq.s
assert proxy_anasig.t_stop == 10 * pq.s
assert proxy_anasig.duration == 10 * pq.s
assert proxy_anasig.file_origin == 'my_filename.fake'
# full load
full_anasig = proxy_anasig.load(time_slice=None)
assert isinstance(full_anasig, AnalogSignal)
assert_same_attributes(proxy_anasig, full_anasig)
# slice time
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 5 * pq.s))
assert anasig.t_start == 2. * pq.s
assert anasig.duration == 3. * pq.s
assert anasig.shape == (30000, 16)
# ceil next sample when slicing
anasig = proxy_anasig.load(time_slice=(1.99999 * pq.s, 5.000001 * pq.s))
assert anasig.t_start == 2. * pq.s
assert anasig.duration == 3. * pq.s
assert anasig.shape == (30000, 16)
# buggy time slice
with self.assertRaises(AssertionError):
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 15 * pq.s))
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 15 * pq.s), strict_slicing=False)
assert proxy_anasig.t_stop == 10 * pq.s
# select channels
anasig = proxy_anasig.load(channel_indexes=[3, 4, 9])
assert anasig.shape[1] == 3
# select channels and slice times
anasig = proxy_anasig.load(time_slice=(2. * pq.s, 5 * pq.s), channel_indexes=[3, 4, 9])
assert anasig.shape == (30000, 3)
# magnitude mode rescaled
anasig_float = proxy_anasig.load(magnitude_mode='rescaled')
assert anasig_float.dtype == 'float32'
assert anasig_float.units == pq.uV
assert anasig_float.units == proxy_anasig.units
# magnitude mode raw
anasig_int = proxy_anasig.load(magnitude_mode='raw')
assert anasig_int.dtype == 'int16'
assert anasig_int.units == pq.CompoundUnit('0.0152587890625*uV')
assert_arrays_almost_equal(anasig_float, anasig_int.rescale('uV'), 1e-9)
def test__match_events(self):
proxy_event = EventProxy(rawio=self.reader, event_channel_index=0,
block_index=0, seg_index=0)
loaded_event = proxy_event.load()
regular_event = Event(times=loaded_event.times - 1 * loaded_event.units,
labels=np.array(['trigger_a', 'trigger_b'] * 3, dtype='U12'))
seg = Segment()
seg.events = [regular_event, proxy_event]
# test matching two events one of which is a proxy
matched_regular, matched_proxy = match_events(regular_event, proxy_event)
assert_same_attributes(matched_regular, regular_event)
assert_same_attributes(matched_proxy, loaded_event)
def test_EventProxy(self):
proxy_event = EventProxy(rawio=self.reader, event_channel_index=0,
block_index=0, seg_index=0)
assert proxy_event.name == 'Some events'
assert proxy_event.shape == (6,)
# full load
full_event = proxy_event.load(time_slice=None)
assert isinstance(full_event, Event)
assert_same_attributes(proxy_event, full_event, exclude=('times', 'labels'))
assert full_event.shape == proxy_event.shape
# slice time
event = proxy_event.load(time_slice=(1 * pq.s, 2 * pq.s))
assert event.shape == (2,)
assert event.labels.shape == (2,)
# buggy time slice
with self.assertRaises(AssertionError):
event = proxy_event.load(time_slice=(2 * pq.s, 15 * pq.s))
event = proxy_event.load(time_slice=(2 * pq.s, 15 * pq.s), strict_slicing=False)
def test_EpochProxy(self):
proxy_epoch = EpochProxy(rawio=self.reader, event_channel_index=1,
block_index=0, seg_index=0)
assert proxy_epoch.name == 'Some epochs'
assert proxy_epoch.shape == (10,)
# full load
full_epoch = proxy_epoch.load(time_slice=None)
assert isinstance(full_epoch, Epoch)
assert_same_attributes(proxy_epoch, full_epoch, exclude=('times', 'labels', 'durations'))
assert full_epoch.shape == proxy_epoch.shape
# slice time
epoch = proxy_epoch.load(time_slice=(1 * pq.s, 4 * pq.s))
assert epoch.shape == (3,)
assert epoch.labels.shape == (3,)
assert epoch.durations.shape == (3,)
# buggy time slice
with self.assertRaises(AssertionError):
epoch = proxy_epoch.load(time_slice=(2 * pq.s, 15 * pq.s))
epoch = proxy_epoch.load(time_slice=(2 * pq.s, 15 * pq.s), strict_slicing=False)
def test__match_events(self):
starts = Event(times=[0.5, 10.0, 25.2] * pq.s)
starts.annotate(event_type='trial start')
starts.array_annotate(trial_id=[1, 2, 3])
stops = Event(times=[5.5, 14.9, 30.1] * pq.s)
stops.annotate(event_type='trial stop')
stops.array_annotate(trial_id=[1, 2, 3])
stops2 = Event(times=[0.1, 5.5, 5.6, 14.9, 25.2, 30.1] * pq.s)
stops2.annotate(event_type='trial stop')
stops2.array_annotate(trial_id=[1, 1, 2, 2, 3, 3])
# test for matching input events, should just return identical copies
matched_starts, matched_stops = match_events(starts, stops)
assert_same_attributes(matched_starts, starts)
assert_same_attributes(matched_stops, stops)
# test for non-matching input events, should find shortest positive non-zero durations
matched_starts2, matched_stops2 = match_events(starts, stops2)
assert_same_attributes(matched_starts2, starts)
assert_same_attributes(matched_stops2, stops)
def test__get_epochs(self):
a_1 = Epoch([0.5, 10.0, 25.2] * pq.s, durations=[5.1, 4.8, 5.0] * pq.s)
a_1.annotate(epoch_type='a', pick='me')
a_1.array_annotate(trial_id=[1, 2, 3])
b_1 = Epoch([5.5, 14.9, 30.1] * pq.s, durations=[4.7, 4.9, 5.2] * pq.s)
b_1.annotate(epoch_type='b')
b_1.array_annotate(trial_id=[1, 2, 3])
a_2 = Epoch([33.2, 41.7, 52.4] * pq.s,
durations=[5.3, 5.0, 5.1] * pq.s)
a_2.annotate(epoch_type='a')
a_2.array_annotate(trial_id=[4, 5, 6])
b_2 = Epoch([37.6, 46.1, 57.0] * pq.s,
durations=[4.9, 5.2, 5.1] * pq.s)
b_2.annotate(epoch_type='b')
b_2.array_annotate(trial_id=[4, 5, 6])
seg = Segment()
seg2 = Segment()
seg.epochs = [a_1, b_1]
seg2.epochs = [a_2, b_2]
block = Block()
block.segments = [seg, seg2]
# test getting one whole event via annotation
extracted_a_1 = get_epochs(seg, epoch_type='a')
extracted_a_1b = get_epochs(block, pick='me')
self.assertEqual(len(extracted_a_1), 1)
self.assertEqual(len(extracted_a_1b), 1)
extracted_a_1 = extracted_a_1[0]
extracted_a_1b = extracted_a_1b[0]
assert_same_attributes(extracted_a_1, a_1)
assert_same_attributes(extracted_a_1b, a_1)
# test getting an empty list by searching for a non-existent property
empty1 = get_epochs(seg, foo='bar')
self.assertEqual(len(empty1), 0)
# test getting an empty list by searching for a non-existent property value
empty2 = get_epochs(seg, epoch_type='undefined')
self.assertEqual(len(empty2), 0)
# test getting only one event time of one event
trial_2 = get_epochs(block, trial_id=2, epoch_type='a')
self.assertEqual(len(trial_2), 1)
trial_2 = trial_2[0]
self.assertEqual(a_1.name, trial_2.name)
self.assertEqual(a_1.description, trial_2.description)
self.assertEqual(a_1.file_origin, trial_2.file_origin)
self.assertEqual(a_1.annotations['epoch_type'],
trial_2.annotations['epoch_type'])
assert_arrays_equal(trial_2.array_annotations['trial_id'],
np.array([2]))
self.assertIsInstance(trial_2.array_annotations, ArrayDict)
# test getting only one event time of more than one event
trial_2b = get_epochs(block, trial_id=2)
self.assertEqual(len(trial_2b), 2)
a_idx = np.where(
np.array([ev.annotations['epoch_type']
for ev in trial_2b]) == 'a')[0][0]
trial_2b_a = trial_2b[a_idx]
trial_2b_b = trial_2b[a_idx - 1]
assert_same_attributes(trial_2b_a, trial_2)
self.assertEqual(b_1.name, trial_2b_b.name)
self.assertEqual(b_1.description, trial_2b_b.description)
self.assertEqual(b_1.file_origin, trial_2b_b.file_origin)
self.assertEqual(b_1.annotations['epoch_type'],
trial_2b_b.annotations['epoch_type'])
assert_arrays_equal(trial_2b_b.array_annotations['trial_id'],
np.array([2]))
self.assertIsInstance(trial_2b_b.array_annotations, ArrayDict)
# test getting more than one event time of one event
trials_1_2 = get_epochs(block, trial_id=[1, 2], epoch_type='a')
self.assertEqual(len(trials_1_2), 1)
trials_1_2 = trials_1_2[0]
self.assertEqual(a_1.name, trials_1_2.name)
self.assertEqual(a_1.description, trials_1_2.description)
self.assertEqual(a_1.file_origin, trials_1_2.file_origin)
self.assertEqual(a_1.annotations['epoch_type'],
trials_1_2.annotations['epoch_type'])
assert_arrays_equal(trials_1_2.array_annotations['trial_id'],
np.array([1, 2]))
self.assertIsInstance(trials_1_2.array_annotations, ArrayDict)
# test getting more than one event time of more than one event
trials_1_2b = get_epochs(block, trial_id=[1, 2])
self.assertEqual(len(trials_1_2b), 2)
a_idx = np.where(
np.array([ev.annotations['epoch_type']
for ev in trials_1_2b]) == 'a')[0][0]
trials_1_2b_a = trials_1_2b[a_idx]
trials_1_2b_b = trials_1_2b[a_idx - 1]
assert_same_attributes(trials_1_2b_a, trials_1_2)
self.assertEqual(b_1.name, trials_1_2b_b.name)
self.assertEqual(b_1.description, trials_1_2b_b.description)
self.assertEqual(b_1.file_origin, trials_1_2b_b.file_origin)
self.assertEqual(b_1.annotations['epoch_type'],
trials_1_2b_b.annotations['epoch_type'])
assert_arrays_equal(trials_1_2b_b.array_annotations['trial_id'],
np.array([1, 2]))
self.assertIsInstance(trials_1_2b_b.array_annotations, ArrayDict)
def test__time_shift_same_attributes(self):
result = self.signal1.time_shift(1 * pq.ms)
assert_same_attributes(result, self.signal1, exclude=['times', 't_start', 't_stop'])
def test__cut_block_by_epochs(self):
seg = Segment()
proxy_anasig = AnalogSignalProxy(rawio=self.reader,
global_channel_indexes=None,
block_index=0,
seg_index=0)
seg.analogsignals.append(proxy_anasig)
proxy_st = SpikeTrainProxy(rawio=self.reader,
unit_index=0,
block_index=0,
seg_index=0)
seg.spiketrains.append(proxy_st)
proxy_event = EventProxy(rawio=self.reader,
event_channel_index=0,
block_index=0,
seg_index=0)
seg.events.append(proxy_event)
proxy_epoch = EpochProxy(rawio=self.reader,
event_channel_index=1,
block_index=0,
seg_index=0)
proxy_epoch.annotate(pick='me')
seg.epochs.append(proxy_epoch)
loaded_epoch = proxy_epoch.load()
loaded_event = proxy_event.load()
loaded_st = proxy_st.load()
loaded_anasig = proxy_anasig.load()
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
cut_block_by_epochs(block, properties={'pick': 'me'})
assert_neo_object_is_compliant(block)
self.assertEqual(len(block.segments), proxy_epoch.shape[0])
for epoch_idx in range(len(loaded_epoch)):
sliced_event = loaded_event.time_slice(
t_start=loaded_epoch.times[epoch_idx],
t_stop=loaded_epoch.times[epoch_idx] +
loaded_epoch.durations[epoch_idx])
has_event = len(sliced_event) > 0
sliced_anasig = loaded_anasig.time_slice(
t_start=loaded_epoch.times[epoch_idx],
t_stop=loaded_epoch.times[epoch_idx] +
loaded_epoch.durations[epoch_idx])
sliced_st = loaded_st.time_slice(
t_start=loaded_epoch.times[epoch_idx],
t_stop=loaded_epoch.times[epoch_idx] +
loaded_epoch.durations[epoch_idx])
self.assertEqual(len(block.segments[epoch_idx].events),
int(has_event))
self.assertEqual(len(block.segments[epoch_idx].spiketrains), 1)
self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
self.assertTrue(
isinstance(block.segments[epoch_idx].spiketrains[0],
SpikeTrain))
assert_same_attributes(block.segments[epoch_idx].spiketrains[0],
sliced_st)
self.assertTrue(
isinstance(block.segments[epoch_idx].analogsignals[0],
AnalogSignal))
assert_same_attributes(block.segments[epoch_idx].analogsignals[0],
sliced_anasig)
if has_event:
self.assertTrue(
isinstance(block.segments[epoch_idx].events[0], Event))
assert_same_attributes(block.segments[epoch_idx].events[0],
sliced_event)
block2 = Block()
seg2 = Segment()
epoch = Epoch(np.arange(10) * pq.s, durations=np.ones((10)) * pq.s)
epoch.annotate(pick='me instead')
seg2.epochs = [proxy_epoch, epoch]
block2.segments = [seg2]
block2.create_many_to_one_relationship()
# test correct loading and slicing of EpochProxy objects
# (not tested above since we used the EpochProxy to cut the block)
cut_block_by_epochs(block2, properties={'pick': 'me instead'})
for epoch_idx in range(len(epoch)):
sliced_epoch = loaded_epoch.time_slice(
t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] + epoch.durations[epoch_idx])
has_epoch = len(sliced_epoch) > 0
if has_epoch:
self.assertTrue(
isinstance(block2.segments[epoch_idx].epochs[0], Epoch))
assert_same_attributes(block2.segments[epoch_idx].epochs[0],
sliced_epoch)
def test__cut_block_by_epochs(self):
epoch = Epoch([0.5, 10.0, 25.2] * pq.s,
durations=[5.1, 4.8, 5.0] * pq.s,
t_start=.1 * pq.s)
epoch.annotate(epoch_type='a', pick='me')
epoch.array_annotate(trial_id=[1, 2, 3])
epoch2 = Epoch([0.6, 9.5, 16.8, 34.1] * pq.s,
durations=[4.5, 4.8, 5.0, 5.0] * pq.s,
t_start=.1 * pq.s)
epoch2.annotate(epoch_type='b')
epoch2.array_annotate(trial_id=[1, 2, 3, 4])
event = Event(times=[0.5, 10.0, 25.2] * pq.s, t_start=.1 * pq.s)
event.annotate(event_type='trial start')
event.array_annotate(trial_id=[1, 2, 3])
anasig = AnalogSignal(np.arange(50.0) * pq.mV,
t_start=.1 * pq.s,
sampling_rate=1.0 * pq.Hz)
irrsig = IrregularlySampledSignal(signal=np.arange(50.0) * pq.mV,
times=anasig.times,
t_start=.1 * pq.s)
st = SpikeTrain(
np.arange(0.5, 50, 7) * pq.s,
t_start=.1 * pq.s,
t_stop=50.0 * pq.s,
waveforms=np.array(
[[[0., 1.], [0.1, 1.1]], [[2., 3.], [2.1, 3.1]],
[[4., 5.], [4.1, 5.1]], [[6., 7.], [6.1, 7.1]],
[[8., 9.], [8.1, 9.1]], [[12., 13.], [12.1, 13.1]],
[[14., 15.], [14.1, 15.1]], [[16., 17.], [16.1, 17.1]]]) *
pq.mV,
array_annotations={'spikenum': np.arange(1, 9)})
seg = Segment()
seg2 = Segment(name='NoCut')
seg.epochs = [epoch, epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg, seg2]
block.create_many_to_one_relationship()
# test without resetting the time
cut_block_by_epochs(block, properties={'pick': 'me'})
assert_neo_object_is_compliant(block)
self.assertEqual(len(block.segments), 3)
for epoch_idx in range(len(epoch)):
self.assertEqual(len(block.segments[epoch_idx].events), 1)
self.assertEqual(len(block.segments[epoch_idx].spiketrains), 1)
self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
self.assertEqual(
len(block.segments[epoch_idx].irregularlysampledsignals), 1)
if epoch_idx != 0:
self.assertEqual(len(block.segments[epoch_idx].epochs), 1)
else:
self.assertEqual(len(block.segments[epoch_idx].epochs), 2)
assert_same_attributes(
block.segments[epoch_idx].spiketrains[0],
st.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[epoch_idx].analogsignals[0],
anasig.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[epoch_idx].irregularlysampledsignals[0],
irrsig.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[epoch_idx].events[0],
event.time_slice(t_start=epoch.times[epoch_idx],
t_stop=epoch.times[epoch_idx] +
epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[0].epochs[0],
epoch.time_slice(t_start=epoch.times[0],
t_stop=epoch.times[0] + epoch.durations[0]))
assert_same_attributes(
block.segments[0].epochs[1],
epoch2.time_slice(t_start=epoch.times[0],
t_stop=epoch.times[0] + epoch.durations[0]))
seg = Segment()
seg2 = Segment(name='NoCut')
seg.epochs = [epoch, epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg, seg2]
block.create_many_to_one_relationship()
# test with resetting the time
cut_block_by_epochs(block, properties={'pick': 'me'}, reset_time=True)
assert_neo_object_is_compliant(block)
self.assertEqual(len(block.segments), 3)
for epoch_idx in range(len(epoch)):
self.assertEqual(len(block.segments[epoch_idx].events), 1)
self.assertEqual(len(block.segments[epoch_idx].spiketrains), 1)
self.assertEqual(len(block.segments[epoch_idx].analogsignals), 1)
self.assertEqual(
len(block.segments[epoch_idx].irregularlysampledsignals), 1)
if epoch_idx != 0:
self.assertEqual(len(block.segments[epoch_idx].epochs), 1)
else:
self.assertEqual(len(block.segments[epoch_idx].epochs), 2)
assert_same_attributes(
block.segments[epoch_idx].spiketrains[0],
st.time_shift(-epoch.times[epoch_idx]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx]))
anasig_target = anasig.time_shift(-epoch.times[epoch_idx])
anasig_target = anasig_target.time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx])
assert_same_attributes(block.segments[epoch_idx].analogsignals[0],
anasig_target)
irrsig_target = irrsig.time_shift(-epoch.times[epoch_idx])
irrsig_target = irrsig_target.time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx])
assert_same_attributes(
block.segments[epoch_idx].irregularlysampledsignals[0],
irrsig_target)
assert_same_attributes(
block.segments[epoch_idx].events[0],
event.time_shift(-epoch.times[epoch_idx]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[epoch_idx]))
assert_same_attributes(
block.segments[0].epochs[0],
epoch.time_shift(-epoch.times[0]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[0]))
assert_same_attributes(
block.segments[0].epochs[1],
epoch2.time_shift(-epoch.times[0]).time_slice(
t_start=0 * pq.s, t_stop=epoch.durations[0]))
def test__time_slice(self):
time_slice = [.5, 5.6] * pq.s
epoch2 = Epoch([0.6, 9.5, 16.8, 34.1] * pq.s,
durations=[4.5, 4.8, 5.0, 5.0] * pq.s,
t_start=.1 * pq.s)
epoch2.annotate(epoch_type='b')
epoch2.array_annotate(trial_id=[1, 2, 3, 4])
event = Event(times=[0.5, 10.0, 25.2] * pq.s, t_start=.1 * pq.s)
event.annotate(event_type='trial start')
event.array_annotate(trial_id=[1, 2, 3])
anasig = AnalogSignal(np.arange(50.0) * pq.mV,
t_start=.1 * pq.s,
sampling_rate=1.0 * pq.Hz)
irrsig = IrregularlySampledSignal(signal=np.arange(50.0) * pq.mV,
times=anasig.times,
t_start=.1 * pq.s)
st = SpikeTrain(
np.arange(0.5, 50, 7) * pq.s,
t_start=.1 * pq.s,
t_stop=50.0 * pq.s,
waveforms=np.array(
[[[0., 1.], [0.1, 1.1]], [[2., 3.], [2.1, 3.1]],
[[4., 5.], [4.1, 5.1]], [[6., 7.], [6.1, 7.1]],
[[8., 9.], [8.1, 9.1]], [[12., 13.], [12.1, 13.1]],
[[14., 15.], [14.1, 15.1]], [[16., 17.], [16.1, 17.1]]]) *
pq.mV,
array_annotations={'spikenum': np.arange(1, 9)})
seg = Segment()
seg.epochs = [epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test without resetting the time
sliced = seg.time_slice(time_slice[0], time_slice[1])
assert_neo_object_is_compliant(sliced)
self.assertEqual(len(sliced.events), 1)
self.assertEqual(len(sliced.spiketrains), 1)
self.assertEqual(len(sliced.analogsignals), 1)
self.assertEqual(len(sliced.irregularlysampledsignals), 1)
self.assertEqual(len(sliced.epochs), 1)
assert_same_attributes(
sliced.spiketrains[0],
st.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.analogsignals[0],
anasig.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.irregularlysampledsignals[0],
irrsig.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.events[0],
event.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
assert_same_attributes(
sliced.epochs[0],
epoch2.time_slice(t_start=time_slice[0], t_stop=time_slice[1]))
seg = Segment()
seg.epochs = [epoch2]
seg.events = [event]
seg.analogsignals = [anasig]
seg.irregularlysampledsignals = [irrsig]
seg.spiketrains = [st]
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test with resetting the time
sliced = seg.time_slice(time_slice[0], time_slice[1], reset_time=True)
assert_neo_object_is_compliant(sliced)
self.assertEqual(len(sliced.events), 1)
self.assertEqual(len(sliced.spiketrains), 1)
self.assertEqual(len(sliced.analogsignals), 1)
self.assertEqual(len(sliced.irregularlysampledsignals), 1)
self.assertEqual(len(sliced.epochs), 1)
assert_same_attributes(
sliced.spiketrains[0],
st.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s,
t_stop=time_slice[1] -
time_slice[0]))
anasig_target = anasig.copy()
anasig_target = anasig_target.time_shift(-time_slice[0]).time_slice(
t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])
assert_same_attributes(sliced.analogsignals[0], anasig_target)
irrsig_target = irrsig.copy()
irrsig_target = irrsig_target.time_shift(-time_slice[0]).time_slice(
t_start=0 * pq.s, t_stop=time_slice[1] - time_slice[0])
assert_same_attributes(sliced.irregularlysampledsignals[0],
irrsig_target)
assert_same_attributes(
sliced.events[0],
event.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s,
t_stop=time_slice[1] -
time_slice[0]))
assert_same_attributes(
sliced.epochs[0],
epoch2.time_shift(-time_slice[0]).time_slice(t_start=0 * pq.s,
t_stop=time_slice[1] -
time_slice[0]))
seg = Segment()
reader = ExampleRawIO(filename='my_filename.fake')
reader.parse_header()
proxy_anasig = AnalogSignalProxy(rawio=reader,
stream_index=0,
inner_stream_channels=None,
block_index=0,
seg_index=0)
seg.analogsignals.append(proxy_anasig)
proxy_st = SpikeTrainProxy(rawio=reader,
spike_channel_index=0,
block_index=0,
seg_index=0)
seg.spiketrains.append(proxy_st)
proxy_event = EventProxy(rawio=reader,
event_channel_index=0,
block_index=0,
seg_index=0)
seg.events.append(proxy_event)
proxy_epoch = EpochProxy(rawio=reader,
event_channel_index=1,
block_index=0,
seg_index=0)
proxy_epoch.annotate(pick='me')
seg.epochs.append(proxy_epoch)
loaded_epoch = proxy_epoch.load()
loaded_event = proxy_event.load()
loaded_st = proxy_st.load()
loaded_anasig = proxy_anasig.load()
block = Block()
block.segments = [seg]
block.create_many_to_one_relationship()
# test with proxy objects
sliced = seg.time_slice(time_slice[0], time_slice[1])
assert_neo_object_is_compliant(sliced)
sliced_event = loaded_event.time_slice(t_start=time_slice[0],
t_stop=time_slice[1])
has_event = len(sliced_event) > 0
sliced_anasig = loaded_anasig.time_slice(t_start=time_slice[0],
t_stop=time_slice[1])
sliced_st = loaded_st.time_slice(t_start=time_slice[0],
t_stop=time_slice[1])
self.assertEqual(len(sliced.events), int(has_event))
self.assertEqual(len(sliced.spiketrains), 1)
self.assertEqual(len(sliced.analogsignals), 1)
self.assertTrue(isinstance(sliced.spiketrains[0], SpikeTrain))
assert_same_attributes(sliced.spiketrains[0], sliced_st)
self.assertTrue(isinstance(sliced.analogsignals[0], AnalogSignal))
assert_same_attributes(sliced.analogsignals[0], sliced_anasig)
if has_event:
self.assertTrue(isinstance(sliced.events[0], Event))
assert_same_attributes(sliced.events[0], sliced_event)
def test__time_shift_same_attributes(self):
result = self.epc.time_shift(1 * pq.ms)
assert_same_attributes(result, self.epc, exclude=['times'])
def test__get_events(self):
starts_1 = Event(times=[0.5, 10.0, 25.2] * pq.s)
starts_1.annotate(event_type='trial start', pick='me')
starts_1.array_annotate(trial_id=[1, 2, 3])
stops_1 = Event(times=[5.5, 14.9, 30.1] * pq.s)
stops_1.annotate(event_type='trial stop')
stops_1.array_annotate(trial_id=[1, 2, 3])
starts_2 = Event(times=[33.2, 41.7, 52.4] * pq.s)
starts_2.annotate(event_type='trial start')
starts_2.array_annotate(trial_id=[4, 5, 6])
stops_2 = Event(times=[37.6, 46.1, 57.0] * pq.s)
stops_2.annotate(event_type='trial stop')
stops_2.array_annotate(trial_id=[4, 5, 6])
seg = Segment()
seg2 = Segment()
seg.events = [starts_1, stops_1]
seg2.events = [starts_2, stops_2]
block = Block()
block.segments = [seg, seg2]
# test getting one whole event via annotation
extracted_starts1 = get_events(seg, event_type='trial start')
extracted_starts1b = get_events(block, pick='me')
self.assertEqual(len(extracted_starts1), 1)
self.assertEqual(len(extracted_starts1b), 1)
extracted_starts1 = extracted_starts1[0]
extracted_starts1b = extracted_starts1b[0]
assert_same_attributes(extracted_starts1, starts_1)
assert_same_attributes(extracted_starts1b, starts_1)
# test getting an empty list by searching for a non-existent property
empty1 = get_events(seg, foo='bar')
self.assertEqual(len(empty1), 0)
# test getting an empty list by searching for a non-existent property value
empty2 = get_events(seg, event_type='undefined')
self.assertEqual(len(empty2), 0)
# test getting only one event time of one event
trial_2 = get_events(block, trial_id=2, event_type='trial start')
self.assertEqual(len(trial_2), 1)
trial_2 = trial_2[0]
self.assertEqual(starts_1.name, trial_2.name)
self.assertEqual(starts_1.description, trial_2.description)
self.assertEqual(starts_1.file_origin, trial_2.file_origin)
self.assertEqual(starts_1.annotations['event_type'],
trial_2.annotations['event_type'])
assert_arrays_equal(trial_2.array_annotations['trial_id'],
np.array([2]))
self.assertIsInstance(trial_2.array_annotations, ArrayDict)
# test getting only one event time of more than one event
trial_2b = get_events(block, trial_id=2)
self.assertEqual(len(trial_2b), 2)
start_idx = np.where(
np.array([ev.annotations['event_type']
for ev in trial_2b]) == 'trial start')[0][0]
trial_2b_start = trial_2b[start_idx]
trial_2b_stop = trial_2b[start_idx - 1]
assert_same_attributes(trial_2b_start, trial_2)
self.assertEqual(stops_1.name, trial_2b_stop.name)
self.assertEqual(stops_1.description, trial_2b_stop.description)
self.assertEqual(stops_1.file_origin, trial_2b_stop.file_origin)
self.assertEqual(stops_1.annotations['event_type'],
trial_2b_stop.annotations['event_type'])
assert_arrays_equal(trial_2b_stop.array_annotations['trial_id'],
np.array([2]))
self.assertIsInstance(trial_2b_stop.array_annotations, ArrayDict)
# test getting more than one event time of one event
trials_1_2 = get_events(block,
trial_id=[1, 2],
event_type='trial start')
self.assertEqual(len(trials_1_2), 1)
trials_1_2 = trials_1_2[0]
self.assertEqual(starts_1.name, trials_1_2.name)
self.assertEqual(starts_1.description, trials_1_2.description)
self.assertEqual(starts_1.file_origin, trials_1_2.file_origin)
self.assertEqual(starts_1.annotations['event_type'],
trials_1_2.annotations['event_type'])
assert_arrays_equal(trials_1_2.array_annotations['trial_id'],
np.array([1, 2]))
self.assertIsInstance(trials_1_2.array_annotations, ArrayDict)
# test getting more than one event time of more than one event
trials_1_2b = get_events(block, trial_id=[1, 2])
self.assertEqual(len(trials_1_2b), 2)
start_idx = np.where(
np.array([ev.annotations['event_type']
for ev in trials_1_2b]) == 'trial start')[0][0]
trials_1_2b_start = trials_1_2b[start_idx]
trials_1_2b_stop = trials_1_2b[start_idx - 1]
assert_same_attributes(trials_1_2b_start, trials_1_2)
self.assertEqual(stops_1.name, trials_1_2b_stop.name)
self.assertEqual(stops_1.description, trials_1_2b_stop.description)
self.assertEqual(stops_1.file_origin, trials_1_2b_stop.file_origin)
self.assertEqual(stops_1.annotations['event_type'],
trials_1_2b_stop.annotations['event_type'])
assert_arrays_equal(trials_1_2b_stop.array_annotations['trial_id'],
np.array([1, 2]))
self.assertIsInstance(trials_1_2b_stop.array_annotations, ArrayDict)
