def test__get_epochs(self):
a = Epoch([0.5, 10.0, 25.2] * pq.s, durations=[5.1, 4.8, 5.0] * pq.s)
a.annotate(epoch_type='a', pick='me')
a.array_annotate(trial_id=[1, 2, 3])
b = Epoch([5.5, 14.9, 30.1] * pq.s, durations=[4.7, 4.9, 5.2] * pq.s)
b.annotate(epoch_type='b')
b.array_annotate(trial_id=[1, 2, 3])
proxy_epoch = EpochProxy(rawio=self.reader,
event_channel_index=1,
block_index=0,
seg_index=0)
proxy_epoch.annotate(epoch_type='a')
seg = Segment()
seg.epochs = [a, b, proxy_epoch]
# test getting multiple epochs including a proxy
extracted_epochs = get_epochs(seg, epoch_type='a')
self.assertEqual(len(extracted_epochs), 2)
# make sure the epoch is loaded and a neo.Epoch object is returned
self.assertTrue(isinstance(extracted_epochs[0], Epoch))
self.assertTrue(isinstance(extracted_epochs[1], Epoch))
def _create_extra_stimuli_channel(from_channel: Event, time_threshold: Quantity) -> Epoch:
stimuli: List[Tuple[int, int]] = _group_stimuli(from_channel, time_threshold)
#data_points: List[Quantity] = [from_channel.times[start:stop] for start, stop in stimuli]
# the label of each timespan is the label of the first event
labels = np.array([from_channel.labels[start] for start, _ in stimuli])
# the timestamp of each timespan is the timestamp of the first event
times: Quantity = np.array([from_channel.times[start] for start, _ in stimuli]) * from_channel.units
# the duration is the time difference between the first and last event
durations: Quantity = np.array([from_channel.times[stop-1] - from_channel.times[start] for start, stop in stimuli]) * from_channel.units
frequencies: Quantity = None
# with this deactivate the divide by 0 warning from NP
# it just returns infinity
with np.errstate(divide="ignore"):
# the frequency is the number of pulses by the duration.
# FIXME: shouldn't it be the number -1 as the last one marks exactly the end, so we only count the ones in the middle?
frequencies = np.array([(stop - start) / durations[i] for i, (start, stop) in enumerate(stimuli)]) / from_channel.units
frequencies.units = Hz
epoch = Epoch(times=times, durations=durations, labels=labels, units=from_channel.units)
epoch.array_annotate(frequencies=frequencies)
return epoch
def generate_one_simple_segment(seg_name='segment 0', supported_objects=[], nb_analogsignal=4,
t_start=0. * pq.s, sampling_rate=10 * pq.kHz, duration=6. * pq.s,
nb_spiketrain=6, spikerate_range=[.5 * pq.Hz, 12 * pq.Hz],
event_types={'stim': ['a', 'b', 'c', 'd'],
'enter_zone': ['one', 'two'],
'color': ['black', 'yellow', 'green'], },
event_size_range=[5, 20],
epoch_types={'animal state': ['Sleep', 'Freeze', 'Escape'],
'light': ['dark', 'lighted']},
epoch_duration_range=[.5, 3.],
# this should be multiplied by pq.s, no?
array_annotations={'valid': np.array([True, False]),
'number': np.array(range(5))}
):
if supported_objects and Segment not in supported_objects:
raise ValueError('Segment must be in supported_objects')
seg = Segment(name=seg_name)
if AnalogSignal in supported_objects:
for a in range(nb_analogsignal):
anasig = AnalogSignal(rand(int((sampling_rate * duration).simplified)),
sampling_rate=sampling_rate,
t_start=t_start, units=pq.mV, channel_index=a,
name='sig %d for segment %s' % (a, seg.name))
seg.analogsignals.append(anasig)
if SpikeTrain in supported_objects:
for s in range(nb_spiketrain):
spikerate = rand() * np.diff(spikerate_range)
spikerate += spikerate_range[0].magnitude
# spikedata = rand(int((spikerate*duration).simplified))*duration
# sptr = SpikeTrain(spikedata,
# t_start=t_start, t_stop=t_start+duration)
# #, name = 'spiketrain %d'%s)
spikes = rand(int((spikerate * duration).simplified))
spikes.sort() # spikes are supposed to be an ascending sequence
sptr = SpikeTrain(spikes * duration, t_start=t_start, t_stop=t_start + duration)
sptr.annotations['channel_index'] = s
# Randomly generate array_annotations from given options
arr_ann = {key: value[(rand(len(spikes)) * len(value)).astype('i')] for (key, value) in
array_annotations.items()}
sptr.array_annotate(**arr_ann)
seg.spiketrains.append(sptr)
if Event in supported_objects:
for name, labels in event_types.items():
evt_size = rand() * np.diff(event_size_range)
evt_size += event_size_range[0]
evt_size = int(evt_size)
labels = np.array(labels, dtype='S')
labels = labels[(rand(evt_size) * len(labels)).astype('i')]
evt = Event(times=rand(evt_size) * duration, labels=labels)
# Randomly generate array_annotations from given options
arr_ann = {key: value[(rand(evt_size) * len(value)).astype('i')] for (key, value) in
array_annotations.items()}
evt.array_annotate(**arr_ann)
seg.events.append(evt)
if Epoch in supported_objects:
for name, labels in epoch_types.items():
t = 0
times = []
durations = []
while t < duration:
times.append(t)
dur = rand() * (epoch_duration_range[1] - epoch_duration_range[0])
dur += epoch_duration_range[0]
durations.append(dur)
t = t + dur
labels = np.array(labels, dtype='S')
labels = labels[(rand(len(times)) * len(labels)).astype('i')]
assert len(times) == len(durations)
assert len(times) == len(labels)
epc = Epoch(times=pq.Quantity(times, units=pq.s),
durations=pq.Quantity(durations, units=pq.s),
labels=labels,)
assert epc.times.dtype == 'float'
# Randomly generate array_annotations from given options
arr_ann = {key: value[(rand(len(times)) * len(value)).astype('i')] for (key, value) in
array_annotations.items()}
epc.array_annotate(**arr_ann)
seg.epochs.append(epc)
# TODO : Spike, Event
seg.create_many_to_one_relationship()
return seg
def generate_one_simple_segment(seg_name='segment 0', supported_objects=[], nb_analogsignal=4,
t_start=0. * pq.s, sampling_rate=10 * pq.kHz, duration=6. * pq.s,
nb_spiketrain=6, spikerate_range=[.5 * pq.Hz, 12 * pq.Hz],
event_types={'stim': ['a', 'b', 'c', 'd'],
'enter_zone': ['one', 'two'],
'color': ['black', 'yellow', 'green'], },
event_size_range=[5, 20],
epoch_types={'animal state': ['Sleep', 'Freeze', 'Escape'],
'light': ['dark', 'lighted']},
epoch_duration_range=[.5, 3.],
# this should be multiplied by pq.s, no?
array_annotations={'valid': np.array([True, False]),
'number': np.array(range(5))}
):
if supported_objects and Segment not in supported_objects:
raise ValueError('Segment must be in supported_objects')
seg = Segment(name=seg_name)
if AnalogSignal in supported_objects:
for a in range(nb_analogsignal):
anasig = AnalogSignal(rand(int(sampling_rate * duration)), sampling_rate=sampling_rate,
t_start=t_start, units=pq.mV, channel_index=a,
name='sig %d for segment %s' % (a, seg.name))
seg.analogsignals.append(anasig)
if SpikeTrain in supported_objects:
for s in range(nb_spiketrain):
spikerate = rand() * np.diff(spikerate_range)
spikerate += spikerate_range[0].magnitude
# spikedata = rand(int((spikerate*duration).simplified))*duration
# sptr = SpikeTrain(spikedata,
# t_start=t_start, t_stop=t_start+duration)
# #, name = 'spiketrain %d'%s)
spikes = rand(int((spikerate * duration).simplified))
spikes.sort() # spikes are supposed to be an ascending sequence
sptr = SpikeTrain(spikes * duration, t_start=t_start, t_stop=t_start + duration)
sptr.annotations['channel_index'] = s
# Randomly generate array_annotations from given options
arr_ann = {key: value[(rand(len(spikes)) * len(value)).astype('i')] for (key, value) in
array_annotations.items()}
sptr.array_annotate(**arr_ann)
seg.spiketrains.append(sptr)
if Event in supported_objects:
for name, labels in event_types.items():
evt_size = rand() * np.diff(event_size_range)
evt_size += event_size_range[0]
evt_size = int(evt_size)
labels = np.array(labels, dtype='S')
labels = labels[(rand(evt_size) * len(labels)).astype('i')]
evt = Event(times=rand(evt_size) * duration, labels=labels)
# Randomly generate array_annotations from given options
arr_ann = {key: value[(rand(evt_size) * len(value)).astype('i')] for (key, value) in
array_annotations.items()}
evt.array_annotate(**arr_ann)
seg.events.append(evt)
if Epoch in supported_objects:
for name, labels in epoch_types.items():
t = 0
times = []
durations = []
while t < duration:
times.append(t)
dur = rand() * (epoch_duration_range[1] - epoch_duration_range[0])
dur += epoch_duration_range[0]
durations.append(dur)
t = t + dur
labels = np.array(labels, dtype='S')
labels = labels[(rand(len(times)) * len(labels)).astype('i')]
assert len(times) == len(durations)
assert len(times) == len(labels)
epc = Epoch(times=pq.Quantity(times, units=pq.s),
durations=pq.Quantity(durations, units=pq.s),
labels=labels,)
assert epc.times.dtype == 'float'
# Randomly generate array_annotations from given options
arr_ann = {key: value[(rand(len(times)) * len(value)).astype('i')] for (key, value) in
array_annotations.items()}
epc.array_annotate(**arr_ann)
seg.epochs.append(epc)
# TODO : Spike, Event
seg.create_many_to_one_relationship()
return seg
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__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_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)