def _read_epocharray(self, node, parent):
attributes = self._get_standard_attributes(node)
times = self._get_quantity(node["times"])
durations = self._get_quantity(node["durations"])
if self._lazy:
labels = np.array((), dtype=node["labels"].dtype)
else:
labels = node["labels"].value
epoch = Epoch(times=times, durations=durations, labels=labels, **attributes)
epoch.segment = parent
if self._lazy:
epoch.lazy_shape = node["times"].shape
return epoch
def _read_epocharray(self, node, parent):
attributes = self._get_standard_attributes(node)
times = self._get_quantity(node["times"])
durations = self._get_quantity(node["durations"])
if self._lazy:
labels = np.array((), dtype=node["labels"].dtype)
else:
labels = node["labels"].value
epoch = Epoch(times=times,
durations=durations,
labels=labels,
**attributes)
epoch.segment = parent
if self._lazy:
epoch.lazy_shape = node["times"].shape
return epoch
def read_segment(self, lazy=False, cascade=True):
fid = open(self.filename, 'rb')
global_header = HeaderReader(fid, GlobalHeader).read_f(offset=0)
# ~ print globalHeader
#~ print 'version' , globalHeader['version']
seg = Segment()
seg.file_origin = os.path.basename(self.filename)
seg.annotate(neuroexplorer_version=global_header['version'])
seg.annotate(comment=global_header['comment'])
if not cascade:
return seg
offset = 544
for i in range(global_header['nvar']):
entity_header = HeaderReader(fid, EntityHeader).read_f(
offset=offset + i * 208)
entity_header['name'] = entity_header['name'].replace('\x00', '')
#print 'i',i, entityHeader['type']
if entity_header['type'] == 0:
# neuron
if lazy:
spike_times = [] * pq.s
else:
spike_times = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
spike_times = spike_times.astype('f8') / global_header[
'freq'] * pq.s
sptr = SpikeTrain(
times=spike_times,
t_start=global_header['tbeg'] /
global_header['freq'] * pq.s,
t_stop=global_header['tend'] /
global_header['freq'] * pq.s,
name=entity_header['name'])
if lazy:
sptr.lazy_shape = entity_header['n']
sptr.annotate(channel_index=entity_header['WireNumber'])
seg.spiketrains.append(sptr)
if entity_header['type'] == 1:
# event
if lazy:
event_times = [] * pq.s
else:
event_times = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
event_times = event_times.astype('f8') / global_header[
'freq'] * pq.s
labels = np.array([''] * event_times.size, dtype='S')
evar = Event(times=event_times, labels=labels,
channel_name=entity_header['name'])
if lazy:
evar.lazy_shape = entity_header['n']
seg.events.append(evar)
if entity_header['type'] == 2:
# interval
if lazy:
start_times = [] * pq.s
stop_times = [] * pq.s
else:
start_times = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
start_times = start_times.astype('f8') / global_header[
'freq'] * pq.s
stop_times = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'] +
entity_header['n'] * 4)
stop_times = stop_times.astype('f') / global_header[
'freq'] * pq.s
epar = Epoch(times=start_times,
durations=stop_times - start_times,
labels=np.array([''] * start_times.size,
dtype='S'),
channel_name=entity_header['name'])
if lazy:
epar.lazy_shape = entity_header['n']
seg.epochs.append(epar)
if entity_header['type'] == 3:
# spiketrain and wavefoms
if lazy:
spike_times = [] * pq.s
waveforms = None
else:
spike_times = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
spike_times = spike_times.astype('f8') / global_header[
'freq'] * pq.s
waveforms = np.memmap(self.filename, np.dtype('i2'), 'r',
shape=(entity_header['n'], 1,
entity_header['NPointsWave']),
offset=entity_header['offset'] +
entity_header['n'] * 4)
waveforms = (waveforms.astype('f') *
entity_header['ADtoMV'] +
entity_header['MVOffset']) * pq.mV
t_stop = global_header['tend'] / global_header['freq'] * pq.s
if spike_times.size > 0:
t_stop = max(t_stop, max(spike_times))
sptr = SpikeTrain(
times=spike_times,
t_start=global_header['tbeg'] /
global_header['freq'] * pq.s,
#~ t_stop = max(globalHeader['tend']/
#~ globalHeader['freq']*pq.s,max(spike_times)),
t_stop=t_stop, name=entity_header['name'],
waveforms=waveforms,
sampling_rate=entity_header['WFrequency'] * pq.Hz,
left_sweep=0 * pq.ms)
if lazy:
sptr.lazy_shape = entity_header['n']
sptr.annotate(channel_index=entity_header['WireNumber'])
seg.spiketrains.append(sptr)
if entity_header['type'] == 4:
# popvectors
pass
if entity_header['type'] == 5:
# analog
timestamps = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
timestamps = timestamps.astype('f8') / global_header['freq']
fragment_starts = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
fragment_starts = fragment_starts.astype('f8') / global_header[
'freq']
t_start = timestamps[0] - fragment_starts[0] / float(
entity_header['WFrequency'])
del timestamps, fragment_starts
if lazy:
signal = [] * pq.mV
else:
signal = np.memmap(self.filename, np.dtype('i2'), 'r',
shape=(entity_header['NPointsWave']),
offset=entity_header['offset'])
signal = signal.astype('f')
signal *= entity_header['ADtoMV']
signal += entity_header['MVOffset']
signal = signal * pq.mV
ana_sig = AnalogSignal(
signal=signal, t_start=t_start * pq.s,
sampling_rate=entity_header['WFrequency'] * pq.Hz,
name=entity_header['name'],
channel_index=entity_header['WireNumber'])
if lazy:
ana_sig.lazy_shape = entity_header['NPointsWave']
seg.analogsignals.append(ana_sig)
if entity_header['type'] == 6:
# markers : TO TEST
if lazy:
times = [] * pq.s
labels = np.array([], dtype='S')
markertype = None
else:
times = np.memmap(self.filename, np.dtype('i4'), 'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
times = times.astype('f8') / global_header['freq'] * pq.s
fid.seek(entity_header['offset'] + entity_header['n'] * 4)
markertype = fid.read(64).replace('\x00', '')
labels = np.memmap(
self.filename, np.dtype(
'S' + str(entity_header['MarkerLength'])),
'r', shape=(entity_header['n']),
offset=entity_header['offset'] +
entity_header['n'] * 4 + 64)
ea = Event(times=times,
labels=labels.view(np.ndarray),
name=entity_header['name'],
channel_index=entity_header['WireNumber'],
marker_type=markertype)
if lazy:
ea.lazy_shape = entity_header['n']
seg.events.append(ea)
seg.create_many_to_one_relationship()
return seg
def read_segment(self, cascade=True, lazy=False, ):
"""
Arguments:
"""
f = StructFile(open(self.filename, 'rb'))
# Name
f.seek(64, 0)
surname = f.read(22).decode('ascii')
while surname[-1] == ' ':
if len(surname) == 0:
break
surname = surname[:-1]
firstname = f.read(20).decode('ascii')
while firstname[-1] == ' ':
if len(firstname) == 0:
break
firstname = firstname[:-1]
#Date
f.seek(128, 0)
day, month, year, hour, minute, sec = f.read_f('bbbbbb')
rec_datetime = datetime.datetime(year + 1900, month, day, hour, minute,
sec)
f.seek(138, 0)
Data_Start_Offset, Num_Chan, Multiplexer, Rate_Min, Bytes = f.read_f(
'IHHHH')
#~ print Num_Chan, Bytes
#header version
f.seek(175, 0)
header_version, = f.read_f('b')
assert header_version == 4
seg = Segment(name=str(firstname + ' ' + surname),
file_origin=os.path.basename(self.filename))
seg.annotate(surname=surname)
seg.annotate(firstname=firstname)
seg.annotate(rec_datetime=rec_datetime)
if not cascade:
f.close()
return seg
# area
f.seek(176, 0)
zone_names = ['ORDER', 'LABCOD', 'NOTE', 'FLAGS', 'TRONCA', 'IMPED_B',
'IMPED_E', 'MONTAGE',
'COMPRESS', 'AVERAGE', 'HISTORY', 'DVIDEO', 'EVENT A',
'EVENT B', 'TRIGGER']
zones = {}
for zname in zone_names:
zname2, pos, length = f.read_f('8sII')
zones[zname] = zname2, pos, length
#~ print zname2, pos, length
# reading raw data
if not lazy:
f.seek(Data_Start_Offset, 0)
rawdata = np.fromstring(f.read(), dtype='u' + str(Bytes))
rawdata = rawdata.reshape((-1, Num_Chan))
# Reading Code Info
zname2, pos, length = zones['ORDER']
f.seek(pos, 0)
code = np.fromstring(f.read(Num_Chan*2), dtype='u2', count=Num_Chan)
units = {-1: pq.nano * pq.V, 0: pq.uV, 1: pq.mV, 2: 1, 100: pq.percent,
101: pq.dimensionless, 102: pq.dimensionless}
for c in range(Num_Chan):
zname2, pos, length = zones['LABCOD']
f.seek(pos + code[c] * 128 + 2, 0)
label = f.read(6).strip(b"\x00").decode('ascii')
ground = f.read(6).strip(b"\x00").decode('ascii')
(logical_min, logical_max, logical_ground, physical_min,
physical_max) = f.read_f('iiiii')
k, = f.read_f('h')
if k in units.keys():
unit = units[k]
else:
unit = pq.uV
f.seek(8, 1)
sampling_rate, = f.read_f('H') * pq.Hz
sampling_rate *= Rate_Min
if lazy:
signal = [] * unit
else:
factor = float(physical_max - physical_min) / float(
logical_max - logical_min + 1)
signal = (rawdata[:, c].astype(
'f') - logical_ground) * factor * unit
ana_sig = AnalogSignal(signal, sampling_rate=sampling_rate,
name=str(label), channel_index=c)
if lazy:
ana_sig.lazy_shape = None
ana_sig.annotate(ground=ground)
seg.analogsignals.append(ana_sig)
sampling_rate = np.mean(
[ana_sig.sampling_rate for ana_sig in seg.analogsignals]) * pq.Hz
# Read trigger and notes
for zname, label_dtype in [('TRIGGER', 'u2'), ('NOTE', 'S40')]:
zname2, pos, length = zones[zname]
f.seek(pos, 0)
triggers = np.fromstring(f.read(length), dtype=[('pos', 'u4'), (
'label', label_dtype)])
if not lazy:
keep = (triggers['pos'] >= triggers['pos'][0]) & (
triggers['pos'] < rawdata.shape[0]) & (
triggers['pos'] != 0)
triggers = triggers[keep]
ea = Event(name=zname[0] + zname[1:].lower(),
labels=triggers['label'].astype('S'),
times=(triggers['pos'] / sampling_rate).rescale('s'))
else:
ea = Event(name=zname[0] + zname[1:].lower())
ea.lazy_shape = triggers.size
seg.events.append(ea)
# Read Event A and B
# Not so well tested
for zname in ['EVENT A', 'EVENT B']:
zname2, pos, length = zones[zname]
f.seek(pos, 0)
epochs = np.fromstring(f.read(length),
dtype=[('label', 'u4'), ('start', 'u4'),
('stop', 'u4'), ])
ep = Epoch(name=zname[0] + zname[1:].lower())
if not lazy:
keep = (epochs['start'] > 0) & (
epochs['start'] < rawdata.shape[0]) & (
epochs['stop'] < rawdata.shape[0])
epochs = epochs[keep]
ep = Epoch(name=zname[0] + zname[1:].lower(),
labels=epochs['label'].astype('S'),
times=(epochs['start'] / sampling_rate).rescale('s'),
durations=((epochs['stop'] - epochs['start']) / sampling_rate).rescale('s'))
else:
ep = Epoch(name=zname[0] + zname[1:].lower())
ep.lazy_shape = triggers.size
seg.epochs.append(ep)
seg.create_many_to_one_relationship()
f.close()
return seg
def read_segment(self, lazy=False, cascade=True):
fid = open(self.filename, 'rb')
global_header = HeaderReader(fid, GlobalHeader).read_f(offset=0)
# ~ print globalHeader
#~ print 'version' , globalHeader['version']
seg = Segment()
seg.file_origin = os.path.basename(self.filename)
seg.annotate(neuroexplorer_version=global_header['version'])
seg.annotate(comment=global_header['comment'])
if not cascade:
return seg
offset = 544
for i in range(global_header['nvar']):
entity_header = HeaderReader(
fid, EntityHeader).read_f(offset=offset + i * 208)
entity_header['name'] = entity_header['name'].replace('\x00', '')
#print 'i',i, entityHeader['type']
if entity_header['type'] == 0:
# neuron
if lazy:
spike_times = [] * pq.s
else:
spike_times = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
spike_times = spike_times.astype(
'f8') / global_header['freq'] * pq.s
sptr = SpikeTrain(times=spike_times,
t_start=global_header['tbeg'] /
global_header['freq'] * pq.s,
t_stop=global_header['tend'] /
global_header['freq'] * pq.s,
name=entity_header['name'])
if lazy:
sptr.lazy_shape = entity_header['n']
sptr.annotate(channel_index=entity_header['WireNumber'])
seg.spiketrains.append(sptr)
if entity_header['type'] == 1:
# event
if lazy:
event_times = [] * pq.s
else:
event_times = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
event_times = event_times.astype(
'f8') / global_header['freq'] * pq.s
labels = np.array([''] * event_times.size, dtype='S')
evar = Event(times=event_times,
labels=labels,
channel_name=entity_header['name'])
if lazy:
evar.lazy_shape = entity_header['n']
seg.events.append(evar)
if entity_header['type'] == 2:
# interval
if lazy:
start_times = [] * pq.s
stop_times = [] * pq.s
else:
start_times = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
start_times = start_times.astype(
'f8') / global_header['freq'] * pq.s
stop_times = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'] +
entity_header['n'] * 4)
stop_times = stop_times.astype(
'f') / global_header['freq'] * pq.s
epar = Epoch(times=start_times,
durations=stop_times - start_times,
labels=np.array([''] * start_times.size,
dtype='S'),
channel_name=entity_header['name'])
if lazy:
epar.lazy_shape = entity_header['n']
seg.epochs.append(epar)
if entity_header['type'] == 3:
# spiketrain and wavefoms
if lazy:
spike_times = [] * pq.s
waveforms = None
else:
spike_times = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
spike_times = spike_times.astype(
'f8') / global_header['freq'] * pq.s
waveforms = np.memmap(self.filename,
np.dtype('i2'),
'r',
shape=(entity_header['n'], 1,
entity_header['NPointsWave']),
offset=entity_header['offset'] +
entity_header['n'] * 4)
waveforms = (
waveforms.astype('f') * entity_header['ADtoMV'] +
entity_header['MVOffset']) * pq.mV
t_stop = global_header['tend'] / global_header['freq'] * pq.s
if spike_times.size > 0:
t_stop = max(t_stop, max(spike_times))
sptr = SpikeTrain(
times=spike_times,
t_start=global_header['tbeg'] / global_header['freq'] *
pq.s,
#~ t_stop = max(globalHeader['tend']/
#~ globalHeader['freq']*pq.s,max(spike_times)),
t_stop=t_stop,
name=entity_header['name'],
waveforms=waveforms,
sampling_rate=entity_header['WFrequency'] * pq.Hz,
left_sweep=0 * pq.ms)
if lazy:
sptr.lazy_shape = entity_header['n']
sptr.annotate(channel_index=entity_header['WireNumber'])
seg.spiketrains.append(sptr)
if entity_header['type'] == 4:
# popvectors
pass
if entity_header['type'] == 5:
# analog
timestamps = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
timestamps = timestamps.astype('f8') / global_header['freq']
fragment_starts_offset = entity_header[
'offset'] + entity_header['n'] * 4
fragment_starts = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=fragment_starts_offset)
fragment_starts = fragment_starts.astype(
'f8') / global_header['freq']
t_start = timestamps[0] - fragment_starts[0] / float(
entity_header['WFrequency'])
del timestamps, fragment_starts
if lazy:
signal = [] * pq.mV
else:
signal_offset = fragment_starts_offset + entity_header[
'n'] * 4
signal = np.memmap(self.filename,
np.dtype('i2'),
'r',
shape=(entity_header['NPointsWave']),
offset=signal_offset)
signal = signal.astype('f')
signal *= entity_header['ADtoMV']
signal += entity_header['MVOffset']
signal = signal * pq.mV
ana_sig = AnalogSignal(
signal=signal,
t_start=t_start * pq.s,
sampling_rate=entity_header['WFrequency'] * pq.Hz,
name=entity_header['name'],
channel_index=entity_header['WireNumber'])
if lazy:
ana_sig.lazy_shape = entity_header['NPointsWave']
seg.analogsignals.append(ana_sig)
if entity_header['type'] == 6:
# markers : TO TEST
if lazy:
times = [] * pq.s
labels = np.array([], dtype='S')
markertype = None
else:
times = np.memmap(self.filename,
np.dtype('i4'),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'])
times = times.astype('f8') / global_header['freq'] * pq.s
fid.seek(entity_header['offset'] + entity_header['n'] * 4)
markertype = fid.read(64).replace('\x00', '')
labels = np.memmap(
self.filename,
np.dtype('S' + str(entity_header['MarkerLength'])),
'r',
shape=(entity_header['n']),
offset=entity_header['offset'] +
entity_header['n'] * 4 + 64)
ea = Event(times=times,
labels=labels.view(np.ndarray),
name=entity_header['name'],
channel_index=entity_header['WireNumber'],
marker_type=markertype)
if lazy:
ea.lazy_shape = entity_header['n']
seg.events.append(ea)
seg.create_many_to_one_relationship()
return seg
def read_segment(
self,
cascade=True,
lazy=False,
):
"""
Arguments:
"""
f = StructFile(open(self.filename, 'rb'))
# Name
f.seek(64, 0)
surname = f.read(22).decode('ascii')
while surname[-1] == ' ':
if len(surname) == 0:
break
surname = surname[:-1]
firstname = f.read(20).decode('ascii')
while firstname[-1] == ' ':
if len(firstname) == 0:
break
firstname = firstname[:-1]
#Date
f.seek(128, 0)
day, month, year, hour, minute, sec = f.read_f('bbbbbb')
rec_datetime = datetime.datetime(year + 1900, month, day, hour, minute,
sec)
f.seek(138, 0)
Data_Start_Offset, Num_Chan, Multiplexer, Rate_Min, Bytes = f.read_f(
'IHHHH')
#~ print Num_Chan, Bytes
#header version
f.seek(175, 0)
header_version, = f.read_f('b')
assert header_version == 4
seg = Segment(name=str(firstname + ' ' + surname),
file_origin=os.path.basename(self.filename))
seg.annotate(surname=surname)
seg.annotate(firstname=firstname)
seg.annotate(rec_datetime=rec_datetime)
if not cascade:
f.close()
return seg
# area
f.seek(176, 0)
zone_names = [
'ORDER', 'LABCOD', 'NOTE', 'FLAGS', 'TRONCA', 'IMPED_B', 'IMPED_E',
'MONTAGE', 'COMPRESS', 'AVERAGE', 'HISTORY', 'DVIDEO', 'EVENT A',
'EVENT B', 'TRIGGER'
]
zones = {}
for zname in zone_names:
zname2, pos, length = f.read_f('8sII')
zones[zname] = zname2, pos, length
#~ print zname2, pos, length
# reading raw data
if not lazy:
f.seek(Data_Start_Offset, 0)
rawdata = np.fromstring(f.read(), dtype='u' + str(Bytes))
rawdata = rawdata.reshape((-1, Num_Chan))
# Reading Code Info
zname2, pos, length = zones['ORDER']
f.seek(pos, 0)
code = np.fromstring(f.read(Num_Chan * 2), dtype='u2', count=Num_Chan)
units = {
-1: pq.nano * pq.V,
0: pq.uV,
1: pq.mV,
2: 1,
100: pq.percent,
101: pq.dimensionless,
102: pq.dimensionless
}
for c in range(Num_Chan):
zname2, pos, length = zones['LABCOD']
f.seek(pos + code[c] * 128 + 2, 0)
label = f.read(6).strip(b"\x00").decode('ascii')
ground = f.read(6).strip(b"\x00").decode('ascii')
(logical_min, logical_max, logical_ground, physical_min,
physical_max) = f.read_f('iiiii')
k, = f.read_f('h')
if k in units.keys():
unit = units[k]
else:
unit = pq.uV
f.seek(8, 1)
sampling_rate, = f.read_f('H') * pq.Hz
sampling_rate *= Rate_Min
if lazy:
signal = [] * unit
else:
factor = float(physical_max -
physical_min) / float(logical_max -
logical_min + 1)
signal = (rawdata[:, c].astype('f') -
logical_ground) * factor * unit
ana_sig = AnalogSignal(signal,
sampling_rate=sampling_rate,
name=str(label),
channel_index=c)
if lazy:
ana_sig.lazy_shape = None
ana_sig.annotate(ground=ground)
seg.analogsignals.append(ana_sig)
sampling_rate = np.mean(
[ana_sig.sampling_rate for ana_sig in seg.analogsignals]) * pq.Hz
# Read trigger and notes
for zname, label_dtype in [('TRIGGER', 'u2'), ('NOTE', 'S40')]:
zname2, pos, length = zones[zname]
f.seek(pos, 0)
triggers = np.fromstring(f.read(length),
dtype=[('pos', 'u4'),
('label', label_dtype)])
if not lazy:
keep = (triggers['pos'] >= triggers['pos'][0]) & (
triggers['pos'] < rawdata.shape[0]) & (triggers['pos'] !=
0)
triggers = triggers[keep]
ea = Event(name=zname[0] + zname[1:].lower(),
labels=triggers['label'].astype('S'),
times=(triggers['pos'] /
sampling_rate).rescale('s'))
else:
ea = Event(name=zname[0] + zname[1:].lower())
ea.lazy_shape = triggers.size
seg.events.append(ea)
# Read Event A and B
# Not so well tested
for zname in ['EVENT A', 'EVENT B']:
zname2, pos, length = zones[zname]
f.seek(pos, 0)
epochs = np.fromstring(f.read(length),
dtype=[
('label', 'u4'),
('start', 'u4'),
('stop', 'u4'),
])
ep = Epoch(name=zname[0] + zname[1:].lower())
if not lazy:
keep = (epochs['start'] > 0) & (
epochs['start'] < rawdata.shape[0]) & (epochs['stop'] <
rawdata.shape[0])
epochs = epochs[keep]
ep = Epoch(name=zname[0] + zname[1:].lower(),
labels=epochs['label'].astype('S'),
times=(epochs['start'] /
sampling_rate).rescale('s'),
durations=((epochs['stop'] - epochs['start']) /
sampling_rate).rescale('s'))
else:
ep = Epoch(name=zname[0] + zname[1:].lower())
ep.lazy_shape = triggers.size
seg.epochs.append(ep)
seg.create_many_to_one_relationship()
f.close()
return seg
def _handle_timeseries(self, name, timeseries):
# todo: check timeseries.attrs.get('schema_id')
# todo: handle timeseries.attrs.get('source')
subtype = timeseries.attrs['ancestry'][-1]
data_group = timeseries.get('data')
dtype = data_group.dtype
if self._lazy:
data = np.array((), dtype=dtype)
lazy_shape = data_group.value.shape # inefficient to load the data to get the shape
else:
data = data_group.value
if dtype.type is np.string_:
if self._lazy:
times = np.array(())
else:
times = timeseries.get('timestamps')
durations = timeseries.get('durations')
if durations:
# Epoch
if self._lazy:
durations = np.array(())
obj = Epoch(times=times,
durations=durations,
labels=data,
units='second')
else:
# Event
obj = Event(times=times,
labels=data,
units='second')
else:
units = get_units(data_group)
if 'starting_time' in timeseries:
# AnalogSignal
sampling_metadata = timeseries.get('starting_time')
t_start = sampling_metadata.value * pq.s
sampling_rate = sampling_metadata.attrs.get('rate') * pq.Hz
assert sampling_metadata.attrs.get('unit') == 'Seconds'
# todo: handle data.attrs['resolution']
obj = AnalogSignal(data,
units=units,
sampling_rate=sampling_rate,
t_start=t_start,
name=name)
elif 'timestamps' in timeseries:
# IrregularlySampledSignal
if self._lazy:
time_data = np.array(())
else:
time_data = timeseries.get('timestamps')
assert time_data.attrs.get('unit') == 'Seconds'
obj = IrregularlySampledSignal(time_data.value,
data,
units=units,
time_units=pq.second)
else:
raise Exception("Timeseries group does not contain sufficient time information")
if self._lazy:
obj.lazy_shape = lazy_shape
return obj
def _mtag_eest_to_neo(self, nix_mtag, lazy):
neo_attrs = self._nix_attr_to_neo(nix_mtag)
neo_type = nix_mtag.type
time_unit = nix_mtag.positions.unit
if lazy:
times = pq.Quantity(np.empty(0), time_unit)
lazy_shape = np.shape(nix_mtag.positions)
else:
times = pq.Quantity(nix_mtag.positions, time_unit)
lazy_shape = None
if neo_type == "neo.epoch":
if lazy:
durations = pq.Quantity(np.empty(0), nix_mtag.extents.unit)
labels = np.empty(0, dtype='S')
else:
durations = pq.Quantity(nix_mtag.extents,
nix_mtag.extents.unit)
labels = np.array(nix_mtag.positions.dimensions[0].labels,
dtype="S")
eest = Epoch(times=times,
durations=durations,
labels=labels,
**neo_attrs)
elif neo_type == "neo.event":
if lazy:
labels = np.empty(0, dtype='S')
else:
labels = np.array(nix_mtag.positions.dimensions[0].labels,
dtype="S")
eest = Event(times=times, labels=labels, **neo_attrs)
elif neo_type == "neo.spiketrain":
if "t_start" in neo_attrs:
if "t_start.units" in neo_attrs:
t_start_units = neo_attrs["t_start.units"]
del neo_attrs["t_start.units"]
else:
t_start_units = time_unit
t_start = pq.Quantity(neo_attrs["t_start"], t_start_units)
del neo_attrs["t_start"]
else:
t_start = None
if "t_stop" in neo_attrs:
if "t_stop.units" in neo_attrs:
t_stop_units = neo_attrs["t_stop.units"]
del neo_attrs["t_stop.units"]
else:
t_stop_units = time_unit
t_stop = pq.Quantity(neo_attrs["t_stop"], t_stop_units)
del neo_attrs["t_stop"]
else:
t_stop = None
if "sampling_interval.units" in neo_attrs:
interval_units = neo_attrs["sampling_interval.units"]
del neo_attrs["sampling_interval.units"]
else:
interval_units = None
if "left_sweep.units" in neo_attrs:
left_sweep_units = neo_attrs["left_sweep.units"]
del neo_attrs["left_sweep.units"]
else:
left_sweep_units = None
eest = SpikeTrain(times=times,
t_start=t_start,
t_stop=t_stop,
**neo_attrs)
if len(nix_mtag.features):
wfda = nix_mtag.features[0].data
wftime = self._get_time_dimension(wfda)
if lazy:
eest.waveforms = pq.Quantity(np.empty((0, 0, 0)),
wfda.unit)
eest.sampling_period = pq.Quantity(1, wftime.unit)
eest.left_sweep = pq.Quantity(0, wftime.unit)
else:
eest.waveforms = pq.Quantity(wfda, wfda.unit)
if interval_units is None:
interval_units = wftime.unit
eest.sampling_period = pq.Quantity(
wftime.sampling_interval, interval_units)
if left_sweep_units is None:
left_sweep_units = wftime.unit
if "left_sweep" in wfda.metadata:
eest.left_sweep = pq.Quantity(
wfda.metadata["left_sweep"], left_sweep_units)
else:
return None
self._object_map[nix_mtag.id] = eest
if lazy_shape:
eest.lazy_shape = lazy_shape
return eest
def _handle_timeseries(self, name, timeseries):
# todo: check timeseries.attrs.get('schema_id')
# todo: handle timeseries.attrs.get('source')
subtype = timeseries.attrs['ancestry'][-1]
data_group = timeseries.get('data')
dtype = data_group.dtype
if self._lazy:
data = np.array((), dtype=dtype)
lazy_shape = data_group.value.shape # inefficient to load the data to get the shape
else:
data = data_group.value
if dtype.type is np.string_:
if self._lazy:
times = np.array(())
else:
times = timeseries.get('timestamps')
durations = timeseries.get('durations')
if durations:
# Epoch
if self._lazy:
durations = np.array(())
obj = Epoch(times=times,
durations=durations,
labels=data,
units='second')
else:
# Event
obj = Event(times=times,
labels=data,
units='second')
else:
units = get_units(data_group)
if 'starting_time' in timeseries:
# AnalogSignal
sampling_metadata = timeseries.get('starting_time')
t_start = sampling_metadata.value * pq.s
sampling_rate = sampling_metadata.attrs.get('rate') * pq.Hz
assert sampling_metadata.attrs.get('unit') == 'Seconds'
# todo: handle data.attrs['resolution']
obj = AnalogSignal(data,
units=units,
sampling_rate=sampling_rate,
t_start=t_start,
name=name)
elif 'timestamps' in timeseries:
# IrregularlySampledSignal
if self._lazy:
time_data = np.array(())
else:
time_data = timeseries.get('timestamps')
assert time_data.attrs.get('unit') == 'Seconds'
obj = IrregularlySampledSignal(time_data.value,
data,
units=units,
time_units=pq.second)
else:
raise Exception("Timeseries group does not contain sufficient time information")
if self._lazy:
obj.lazy_shape = lazy_shape
return obj
def _mtag_eest_to_neo(self, nix_mtag, lazy):
neo_attrs = self._nix_attr_to_neo(nix_mtag)
neo_type = nix_mtag.type
time_unit = nix_mtag.positions.unit
if lazy:
times = pq.Quantity(np.empty(0), time_unit)
lazy_shape = np.shape(nix_mtag.positions)
else:
times = pq.Quantity(nix_mtag.positions, time_unit)
lazy_shape = None
if neo_type == "neo.epoch":
if lazy:
durations = pq.Quantity(np.empty(0), nix_mtag.extents.unit)
labels = np.empty(0, dtype='S')
else:
durations = pq.Quantity(nix_mtag.extents,
nix_mtag.extents.unit)
labels = np.array(nix_mtag.positions.dimensions[0].labels,
dtype="S")
eest = Epoch(times=times, durations=durations, labels=labels,
**neo_attrs)
elif neo_type == "neo.event":
if lazy:
labels = np.empty(0, dtype='S')
else:
labels = np.array(nix_mtag.positions.dimensions[0].labels,
dtype="S")
eest = Event(times=times, labels=labels, **neo_attrs)
elif neo_type == "neo.spiketrain":
if "t_start" in neo_attrs:
if "t_start.units" in neo_attrs:
t_start_units = neo_attrs["t_start.units"]
del neo_attrs["t_start.units"]
else:
t_start_units = time_unit
t_start = pq.Quantity(neo_attrs["t_start"], t_start_units)
del neo_attrs["t_start"]
else:
t_start = None
if "t_stop" in neo_attrs:
if "t_stop.units" in neo_attrs:
t_stop_units = neo_attrs["t_stop.units"]
del neo_attrs["t_stop.units"]
else:
t_stop_units = time_unit
t_stop = pq.Quantity(neo_attrs["t_stop"], t_stop_units)
del neo_attrs["t_stop"]
else:
t_stop = None
if "sampling_interval.units" in neo_attrs:
interval_units = neo_attrs["sampling_interval.units"]
del neo_attrs["sampling_interval.units"]
else:
interval_units = None
if "left_sweep.units" in neo_attrs:
left_sweep_units = neo_attrs["left_sweep.units"]
del neo_attrs["left_sweep.units"]
else:
left_sweep_units = None
eest = SpikeTrain(times=times, t_start=t_start,
t_stop=t_stop, **neo_attrs)
if len(nix_mtag.features):
wfda = nix_mtag.features[0].data
wftime = self._get_time_dimension(wfda)
if lazy:
eest.waveforms = pq.Quantity(np.empty((0, 0, 0)),
wfda.unit)
eest.sampling_period = pq.Quantity(1, wftime.unit)
eest.left_sweep = pq.Quantity(0, wftime.unit)
else:
eest.waveforms = pq.Quantity(wfda, wfda.unit)
if interval_units is None:
interval_units = wftime.unit
eest.sampling_period = pq.Quantity(
wftime.sampling_interval, interval_units
)
if left_sweep_units is None:
left_sweep_units = wftime.unit
if "left_sweep" in wfda.metadata:
eest.left_sweep = pq.Quantity(
wfda.metadata["left_sweep"], left_sweep_units
)
else:
return None
self._neo_map[nix_mtag.name] = eest
if lazy_shape:
eest.lazy_shape = lazy_shape
return eest
