def __init__(self, dir_path):
RecordingExtractor.__init__(self)
phy_folder = Path(dir_path)
self.params = read_python(str(phy_folder / 'params.py'))
datfile = [x for x in phy_folder.iterdir() if x.suffix == '.dat' or x.suffix == '.bin']
if (phy_folder / 'channel_map_si.npy').is_file():
channel_map = list(np.squeeze(np.load(phy_folder / 'channel_map_si.npy')))
assert len(channel_map) == self.params['n_channels_dat']
elif (phy_folder / 'channel_map.npy').is_file():
channel_map = list(np.squeeze(np.load(phy_folder / 'channel_map.npy')))
assert len(channel_map) == self.params['n_channels_dat']
else:
channel_map = list(range(self.params['n_channels_dat']))
BinDatRecordingExtractor.__init__(self, datfile[0], samplerate=float(self.params['sample_rate']),
dtype=self.params['dtype'], numchan=self.params['n_channels_dat'],
recording_channels=list(channel_map))
if (phy_folder / 'channel_groups.npy').is_file():
channel_groups = np.load(phy_folder / 'channel_groups.npy')
assert len(channel_groups) == self.get_num_channels()
for (ch, cg) in zip(self.get_channel_ids(), channel_groups):
self.set_channel_property(ch, 'group', cg)
if (phy_folder / 'channel_positions.npy').is_file():
channel_locations = np.load(phy_folder / 'channel_positions.npy')
assert len(channel_locations) == self.get_num_channels()
for (ch, loc) in zip(self.get_channel_ids(), channel_locations):
self.set_channel_property(ch, 'location', loc)
def __init__(self, file_path):
# load params file related to the given shybrid recording
assert self.installed, self.installation_mesg
RecordingExtractor.__init__(self)
params = sbio.get_params(file_path)['data']
# create a shybrid probe object
probe = sbprb.Probe(params['probe'])
nb_channels = probe.total_nb_channels
# translate the byte ordering
# TODO still ambiguous, shybrid should assume time_axis=1, since spike interface makes an assumption on the byte ordering
byte_order = params['order']
if byte_order == 'C':
time_axis = 1
elif byte_order == 'F':
time_axis = 0
# piggyback on binary data recording extractor
recording = BinDatRecordingExtractor(file_path,
params['fs'],
nb_channels,
params['dtype'],
time_axis=time_axis)
# load probe file
self._recording = load_probe_file(recording, params['probe'])
self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self, recording, chunk_size=None, save_path=None):
RecordingExtractor.__init__(self) # init tmp folder before constructing BinDatRecordingExtractor
tmp_folder = self.get_tmp_folder()
self._recording = recording
if save_path is None:
self._is_tmp = True
self._tmp_file = tempfile.NamedTemporaryFile(suffix=".dat", dir=tmp_folder).name
else:
save_path = Path(save_path)
if save_path.suffix != '.dat' and save_path.suffix != '.bin':
save_path = save_path.with_suffix('.dat')
if not save_path.parent.is_dir():
os.makedirs(save_path.parent)
self._is_tmp = False
self._tmp_file = save_path
self._dtype = recording.get_dtype()
recording.write_to_binary_dat_format(save_path=self._tmp_file, dtype=self._dtype, chunk_size=chunk_size)
# keep track of filter status when dumping
self.is_filtered = self._recording.is_filtered
BinDatRecordingExtractor.__init__(self, self._tmp_file, numchan=recording.get_num_channels(),
recording_channels=recording.get_channel_ids(),
sampling_frequency=recording.get_sampling_frequency(),
dtype=self._dtype, is_filtered=self.is_filtered)
# keep BinDatRecording kwargs
self._bindat_kwargs = deepcopy(self._kwargs)
self.set_tmp_folder(tmp_folder)
self.copy_channel_properties(recording)
self._kwargs = {'recording': recording, 'chunk_size': chunk_size}
def __init__(self, recording, threshold=None, seed=0):
if not isinstance(recording, RecordingExtractor):
raise ValueError("'recording' must be a RecordingExtractor")
self._recording = recording
random_data = self._get_random_data_for_scaling(seed=seed).ravel()
q = np.quantile(random_data, [0.001, 0.5, 1 - 0.001])
if 2 * q[1] - q[0] - q[2] < 2 * np.min([q[1] - q[0], q[2] - q[1]]):
print('Warning, narrow signal range suggests artefact-free data.')
self._median = q[1]
if threshold is None:
if np.abs(q[1] - q[0]) > np.abs(q[1] - q[2]):
self._threshold = q[0]
self._lower = True
else:
self._threshold = q[2]
self._lower = False
else:
self._threshold = threshold
if q[1] - threshold < 0:
self._lower = False
else:
self._lower = True
RecordingExtractor.__init__(self)
self.copy_channel_properties(recording=self._recording)
self._kwargs = {
'recording': recording.make_serialized_dict(),
'threshold': threshold,
'seed': seed
}
def __init__(self, recording_path=None):
RecordingExtractor.__init__(self)
self._recording_path = recording_path
self._fs = None
self._positions = None
self._recordings = None
self._initialize()
def __init__(self, folder_path):
RecordingExtractor.__init__(self)
phy_folder = Path(folder_path)
self.params = read_python(str(phy_folder / 'params.py'))
datfile = [x for x in phy_folder.iterdir() if x.suffix == '.dat' or x.suffix == '.bin']
if (phy_folder / 'channel_map_si.npy').is_file():
channel_map = list(np.squeeze(np.load(phy_folder / 'channel_map_si.npy')))
assert len(channel_map) == self.params['n_channels_dat']
elif (phy_folder / 'channel_map.npy').is_file():
channel_map = list(np.squeeze(np.load(phy_folder / 'channel_map.npy')))
assert len(channel_map) == self.params['n_channels_dat']
else:
channel_map = list(range(self.params['n_channels_dat']))
BinDatRecordingExtractor.__init__(self, datfile[0], sampling_frequency=float(self.params['sample_rate']),
dtype=self.params['dtype'], numchan=self.params['n_channels_dat'],
recording_channels=list(channel_map))
if (phy_folder / 'channel_groups.npy').is_file():
channel_groups = np.load(phy_folder / 'channel_groups.npy')
assert len(channel_groups) == self.get_num_channels()
self.set_channel_groups(channel_groups)
if (phy_folder / 'channel_positions.npy').is_file():
channel_locations = np.load(phy_folder / 'channel_positions.npy')
assert len(channel_locations) == self.get_num_channels()
self.set_channel_locations(channel_locations)
self._kwargs = {'folder_path': str(Path(folder_path).absolute())}
def __init__(self, npx_file, x_pitch=None, y_pitch=None):
RecordingExtractor.__init__(self)
self._npxfile = Path(npx_file)
numchan = 385
dtype = 'int16'
root = str(self._npxfile.stem).split('.')[0]
# find metafile in same folder
metafile = [
x for x in self._npxfile.parent.iterdir()
if 'meta' in str(x) and root in str(x) and 'ap' in str(x)
]
if len(metafile) == 0:
raise Exception(
"'meta' file for ap traces should be in the same folder.")
else:
metafile = metafile[0]
tot_chan, ap_chan, samplerate, locations = _parse_spikeglx_metafile(
metafile, x_pitch, y_pitch)
frames_first = True
self._timeseries = read_binary(self._npxfile,
tot_chan,
dtype,
frames_first,
offset=0)
self._samplerate = float(samplerate)
if ap_chan < tot_chan:
self._timeseries = self._timeseries[:ap_chan]
self._channels = list(range(self._timeseries.shape[0]))
if len(locations) > 0:
for m in range(self._timeseries.shape[0]):
self.set_channel_property(m, 'location', locations[m])
def import_sorting(*, feed: kp.Feed, workspace_name: str,
recording: se.RecordingExtractor,
sorting: se.SortingExtractor, recording_id: str,
sorting_label: str):
sorting_id = 'S-' + random_id()
x = {
'sortingId':
sorting_id,
'sortingLabel':
sorting_label,
'sortingPath':
ka.store_object(sorting.object(), basename=f'{sorting_label}.json'),
'sortingObject':
sorting.object(),
'recordingId':
recording_id,
'recordingPath':
ka.store_object(recording.object(), basename=f'{recording_id}.json'),
'recordingObject':
recording.object(),
'description':
f'Imported from Python: {sorting_label}'
}
sortings_subfeed = feed.get_subfeed(
dict(workspaceName=workspace_name, key='sortings'))
_import_le_sorting(sortings_subfeed, x)
return x
def __init__(self, recording_file):
RecordingExtractor.__init__(self)
self._recording_file = recording_file
self._rf, self._nFrames, self._samplingRate, self._nRecCh, self._chIndices, self._file_format, self._signalInv, self._positions, self._read_function = openBiocamFile(
self._recording_file)
for m in range(self._nRecCh):
self.setChannelProperty(m, 'location', self._positions[m])
def __init__(self, block_index=None, seg_index=None, **kargs):
RecordingExtractor.__init__(self)
_NeoBaseExtractor.__init__(self, block_index=block_index, seg_index=seg_index, **kargs)
# TODO propose a meachanisim to select the appropriate channel groups
# in neo one channel group have the same dtype/sampling_rate/group_id
try:
# Neo >= 0.9.0
channel_indexes_list = self.neo_reader.get_group_signal_channel_indexes()
except AttributeError:
# Neo < 0.9.0
channel_indexes_list = self.neo_reader.get_group_channel_indexes()
num_chan_group = len(channel_indexes_list)
assert num_chan_group == 1, 'This file have several channel groups spikeextractors support only one groups'
# spikeextractor for units to be uV implicitly
# check that units are V, mV or uV
# otherwise raise error
# @alessio @cole : this can be a problem in extractor evrything is base
# on the fact that the get_traces() give microVolt
# some file don't have units
# do we allow this ?
units = self.neo_reader.header['signal_channels']['units']
assert np.all(np.isin(units, ['V', 'mV', 'uV'])), 'Signal units no Volt compatible'
self.additional_gain = np.ones(units.size, dtype='float')
self.additional_gain[units == 'V'] = 1e6
self.additional_gain[units == 'mV'] = 1e3
self.additional_gain[units == 'uV'] = 1.
self.additional_gain = self.additional_gain.reshape(1, -1)
def __init__(self,
folder_path,
raw_fname='raw.mda',
params_fname='params.json',
geom_fname='geom.csv'):
dataset_directory = Path(folder_path)
self._dataset_directory = dataset_directory
timeseries0 = dataset_directory / raw_fname
self._dataset_params = read_dataset_params(dataset_directory,
params_fname)
self._sampling_frequency = self._dataset_params['samplerate'] * 1.0
self._timeseries_path = os.path.abspath(timeseries0)
geom0 = dataset_directory / geom_fname
self._geom_fname = geom0
self._geom = np.loadtxt(self._geom_fname, delimiter=',', ndmin=2)
X = DiskReadMda(self._timeseries_path)
if self._geom.shape[0] != X.N1():
raise Exception(
'Incompatible dimensions between geom.csv and timeseries file {} <> {}'
.format(self._geom.shape[0], X.N1()))
self._num_channels = X.N1()
self._num_timepoints = X.N2()
RecordingExtractor.__init__(self)
self.set_channel_locations(self._geom)
self._kwargs = {'folder_path': str(Path(folder_path).absolute())}
def __init__(self, file_path, dtype='float', verbose=False):
assert HAVE_INTAN, self.installation_mesg
RecordingExtractor.__init__(self)
assert Path(file_path).suffix == '.rhs' or Path(file_path).suffix == '.rhd', \
"Only '.rhd' and '.rhs' files are supported"
self._recording_file = file_path
self._recording = pyintan.File(file_path, verbose)
self._num_frames = len(self._recording.times)
self._analog_channels = np.array([
ch for ch in self._recording._anas_chan if all([
other_ch not in ch['name']
for other_ch in ['ADC', 'VDD', 'AUX']
])
])
self._num_channels = len(self._analog_channels)
self._channel_ids = list(range(self._num_channels))
self._fs = float(self._recording.sample_rate.rescale('Hz').magnitude)
assert dtype in ['float',
'uint16'], "'dtype' can be either 'float' or 'uint16'"
self._dtype = dtype
if self._dtype == 'uint16':
for i, ch in enumerate(self._analog_channels):
self.set_channel_property(i, 'gain', ch['gain'])
self.set_channel_property(i, 'offset', ch['offset'])
self._kwargs = {
'file_path': str(Path(file_path).absolute()),
'verbose': verbose
}
def __init__(self, file_path: PathType):
assert HAVE_BS4_LXML, self.installation_mesg
file_path = Path(file_path)
assert file_path.is_file() and file_path.suffix == '.dat', 'file_path must lead to a .dat file!'
RecordingExtractor.__init__(self)
self._recording_file = file_path
file_path = Path(file_path)
folder_path = file_path.parent
xml_files = [f for f in folder_path.iterdir() if f.is_file() if f.suffix == '.xml']
assert any(xml_files), 'No .xml file found in the folder_path.'
assert len(xml_files) == 1, 'More than one .xml file found in the folder_path.'
xml_filepath = xml_files[0]
with xml_filepath.open('r') as xml_file:
contents = xml_file.read()
soup = BeautifulSoup(contents, 'lxml')
# Normally, this would be a .xml, but there were strange issues
# in the write_recording method that require it to be a .lxml instead
# which also requires all capital letters to be removed from the tag names
n_bits = int(soup.nbits.string)
dtype = 'int' + str(n_bits)
numchan_from_file = int(soup.nchannels.string)
numchan = numchan_from_file
sampling_frequency = float(soup.samplingrate.string)
BinDatRecordingExtractor.__init__(self, file_path, sampling_frequency=sampling_frequency,
dtype=dtype, numchan=numchan)
self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self, file_path):
assert self.installed, self.installation_mesg
file_path = str(file_path)
RecordingExtractor.__init__(self)
self._file = nix.File.open(file_path, nix.FileMode.ReadOnly)
self._load_properties()
self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self,
file_path,
sampling_frequency,
numchan,
dtype,
recording_channels=None,
time_axis=0,
geom=None,
offset=0,
gain=None):
RecordingExtractor.__init__(self)
self._datfile = Path(file_path)
self._time_axis = time_axis
self._dtype = str(dtype)
self._timeseries = read_binary(self._datfile, numchan, dtype,
time_axis, offset)
self._sampling_frequency = float(sampling_frequency)
self._gain = gain
self._geom = geom
if recording_channels is not None:
assert len(recording_channels) == self._timeseries.shape[0], \
'Provided recording channels have the wrong length'
self._channels = recording_channels
else:
self._channels = list(range(self._timeseries.shape[0]))
if geom is not None:
for m in range(self._timeseries.shape[0]):
self.set_channel_property(m, 'location', self._geom[m, :])
def __init__(self, dataset_directory, *, download=True):
ca = _load_required_modules()
RecordingExtractor.__init__(self)
self._dataset_directory = dataset_directory
timeseries0 = dataset_directory + '/raw.mda'
self._dataset_params = read_dataset_params(dataset_directory)
self._samplerate = self._dataset_params['samplerate'] * 1.0
if is_kbucket_url(timeseries0):
download_needed = is_url(ca.findFile(path=timeseries0))
else:
download_needed = is_url(timeseries0)
if download and download_needed:
print('Downloading file: ' + timeseries0)
self._timeseries_path = ca.realizeFile(path=timeseries0)
print('Done.')
else:
self._timeseries_path = ca.findFile(path=timeseries0)
geom0 = dataset_directory + '/geom.csv'
self._geom_fname = ca.realizeFile(path=geom0)
self._geom = np.genfromtxt(self._geom_fname, delimiter=',')
X = DiskReadMda(self._timeseries_path)
if self._geom.shape[0] != X.N1():
raise Exception(
'Incompatible dimensions between geom.csv and timeseries file {} <> {}'.format(self._geom.shape[0],
X.N1()))
self._num_channels = X.N1()
self._num_timepoints = X.N2()
for m in range(self._num_channels):
self.setChannelProperty(m, 'location', self._geom[m, :])
def __init__(self,
recording,
scale=1.0,
median=0.0,
q1=0.01,
q2=0.99,
seed=0):
if not isinstance(recording, RecordingExtractor):
raise ValueError("'recording' must be a RecordingExtractor")
self._recording = recording
random_data = self._get_random_data_for_scaling(seed=seed).ravel()
loc_q1, pre_median, loc_q2 = np.quantile(random_data, q=[q1, 0.5, q2])
pre_scale = abs(loc_q2 - loc_q1)
self._scalar = scale / pre_scale
self._offset = median - pre_median * self._scalar
RecordingExtractor.__init__(self)
self.copy_channel_properties(recording=self._recording)
self.is_filtered = self._recording.is_filtered
self._kwargs = {
'recording': recording.make_serialized_dict(),
'scale': scale,
'median': median,
'q1': q1,
'q2': q2,
'seed': seed
}
def __init__(self, file_path):
if not HAVE_NIXIO:
raise ImportError(missing_nixio_msg)
RecordingExtractor.__init__(self)
self._file = nix.File.open(file_path, nix.FileMode.ReadOnly)
self._load_properties()
self._kwargs = {'file_path': str(Path(file_path).absolute())}
def intervals_from_traces(recording: RecordingExtractor):
"""Extract interval times from TTL pulses."""
traces = recording.get_traces(channel_ids=[1, 2])
sf = recording.get_sampling_frequency()
ttls = []
states = []
for tr in traces:
threshold = np.ptp(tr) / 2 + np.min(tr)
crossings = np.array(tr > threshold).astype("int8")
rising = np.nonzero(np.diff(crossings, 1) > 0)[0]
falling = np.nonzero(np.diff(crossings, 1) < 0)[0]
ttl = np.concatenate((rising, falling))
sort_order = np.argsort(ttl)
ttl = np.sort(ttl)
state = [1] * len(rising) + [-1] * len(falling)
state = np.array(state)[sort_order]
ttls.append(ttl)
states.append(state)
conditions = []
for ttl, state in zip(ttls, states):
assert len(ttl[state == 1]) == len(
ttl[state == -1]), "Different number of rising/falling edges!"
condition = np.zeros((len(ttl[state == 1]), 2), dtype="int")
condition[:, 0] = ttl[state == 1] / sf
condition[:, 1] = ttl[state == -1] / sf
conditions.append(condition)
return conditions
def __init__(self, file_path: PathType):
assert HAVE_LXML, self.installation_mesg
file_path = Path(file_path)
assert file_path.is_file() and file_path.suffix == '.dat', 'file_path must lead to a .dat file!'
RecordingExtractor.__init__(self)
self._recording_file = file_path
file_path = Path(file_path)
folder_path = file_path.parent
xml_files = [f for f in folder_path.iterdir() if f.is_file() if f.suffix == '.xml']
assert any(xml_files), 'No .xml file found in the folder_path.'
assert len(xml_files) == 1, 'More than one .xml file found in the folder_path.'
xml_filepath = xml_files[0]
xml_root = et.parse(str(xml_filepath.absolute())).getroot()
n_bits = int(xml_root.find('acquisitionSystem').find('nBits').text)
dtype = 'int' + str(n_bits)
numchan_from_file = int(xml_root.find('acquisitionSystem').find('nChannels').text)
sampling_frequency = float(xml_root.find('acquisitionSystem').find('samplingRate').text)
BinDatRecordingExtractor.__init__(self, file_path, sampling_frequency=sampling_frequency,
dtype=dtype, numchan=numchan_from_file)
self._kwargs = {'file_path': str(Path(file_path).absolute())}
def __init__(self, recording_file, verbose=False):
assert HAVE_INTAN, "To use the Intan extractor, install pyintan: \n\n pip install pyintan\n\n"
RecordingExtractor.__init__(self)
assert Path(recording_file).suffix == '.rhs' or Path(recording_file).suffix == '.rhd', \
"Only '.rhd' and '.rhs' files are supported"
self._recording_file = recording_file
self._recording = pyintan.File(recording_file, verbose)
def __init__(self, recording, reference='median', groups=None, ref_channels=None, dtype=None, verbose=False):
if not isinstance(recording, RecordingExtractor):
raise ValueError("'recording' must be a RecordingExtractor")
if reference != 'median' and reference != 'average' and reference != 'single':
raise ValueError("'reference' must be either 'median' or 'average'")
self._recording = recording
self._ref = reference
self._groups = groups
if self._ref == 'single':
assert ref_channels is not None, "With 'single' reference, provide 'ref_channels'"
if self._groups is not None:
assert len(ref_channels) == len(self._groups), "'ref_channel' and 'groups' must have the " \
"same length"
else:
if isinstance(ref_channels, (list, np.ndarray)):
assert len(ref_channels) == 1, "'ref_channel' with no 'groups' can be int or a list of one element"
else:
assert isinstance(ref_channels, (int, np.integer)), "'ref_channels' must be int"
ref_channels = [ref_channels]
self._ref_channel = ref_channels
if dtype is None:
self._dtype = recording.get_dtype()
else:
self._dtype = dtype
self.verbose = verbose
RecordingExtractor.__init__(self)
self.copy_channel_properties(recording=self._recording)
self.is_filtered = self._recording.is_filtered
# update dump dict
self._kwargs = {'recording': recording.make_serialized_dict(), 'reference': reference, 'groups': groups,
'ref_channels': ref_channels, 'dtype': dtype, 'verbose': verbose}
def __init__(self,
datfile,
samplerate,
numchan,
dtype,
recording_channels=None,
frames_first=True,
geom=None,
offset=0,
gain=None):
RecordingExtractor.__init__(self)
self._datfile = Path(datfile)
self._frame_first = frames_first
self._dtype = str(dtype)
self._timeseries = read_binary(self._datfile, numchan, dtype,
frames_first, offset)
self._samplerate = float(samplerate)
self._gain = gain
self._geom = geom
if recording_channels is not None:
assert len(recording_channels) == self._timeseries.shape[0], \
'Provided recording channels have the wrong length'
self._channels = recording_channels
else:
self._channels = list(range(self._timeseries.shape[0]))
if geom is not None:
for m in range(self._timeseries.shape[0]):
self.set_channel_property(m, 'location', self._geom[m, :])
def __init__(self, timeseries, sampling_frequency, geom=None):
RecordingExtractor.__init__(self)
if isinstance(timeseries, str):
if Path(timeseries).is_file():
assert Path(
timeseries
).suffix == '.npy', "'timeseries' file is not a numpy file (.npy)"
self.is_dumpable = True
self._timeseries = np.load(timeseries)
self._kwargs = {
'timeseries': str(Path(timeseries).absolute()),
'sampling_frequency': sampling_frequency,
'geom': geom
}
else:
raise ValueError("'timeeseries' is does not exist")
elif isinstance(timeseries, np.ndarray):
self.is_dumpable = False
self._timeseries = timeseries
self._kwargs = {
'timeseries': timeseries,
'sampling_frequency': sampling_frequency,
'geom': geom
}
else:
raise TypeError("'timeseries' can be a str or a numpy array")
self._sampling_frequency = float(sampling_frequency)
self._geom = geom
if geom is not None:
for m in range(self._timeseries.shape[0]):
self.set_channel_property(m, 'location', self._geom[m, :])
def __init__(self,
*,
recording_directory=None,
timeseries_path=None,
download=False,
samplerate=None,
geom=None,
geom_path=None,
params_path=None):
RecordingExtractor.__init__(self)
if recording_directory:
timeseries_path = recording_directory + '/raw.mda'
geom_path = recording_directory + '/geom.csv'
params_path = recording_directory + '/params.json'
self._timeseries_path = timeseries_path
if params_path:
self._dataset_params = ka.load_object(params_path)
self._samplerate = self._dataset_params['samplerate']
else:
self._dataset_params = dict(samplerate=samplerate)
self._samplerate = samplerate
if download:
path0 = ka.load_file(path=self._timeseries_path)
if not path0:
raise Exception('Unable to realize file: ' +
self._timeseries_path)
self._timeseries_path = path0
self._timeseries = DiskReadMda(self._timeseries_path)
if self._timeseries is None:
raise Exception('Unable to load timeseries: {}'.format(
self._timeseries_path))
X = self._timeseries
if geom is not None:
self._geom = geom
elif geom_path:
geom_path2 = ka.load_file(geom_path)
self._geom = np.genfromtxt(geom_path2, delimiter=',')
else:
self._geom = np.zeros((X.N1(), 2))
if self._geom.shape[0] != X.N1():
# raise Exception(
# 'Incompatible dimensions between geom.csv and timeseries file {} <> {}'.format(self._geom.shape[0], X.N1()))
print(
'WARNING: Incompatible dimensions between geom.csv and timeseries file {} <> {}'
.format(self._geom.shape[0], X.N1()))
self._geom = np.zeros((X.N1(), 2))
self._hash = ka.get_object_hash(
dict(timeseries=ka.get_file_hash(self._timeseries_path),
samplerate=self._samplerate,
geom=_json_serialize(self._geom)))
self._num_channels = X.N1()
self._num_timepoints = X.N2()
for m in range(self._num_channels):
self.set_channel_property(m, 'location', self._geom[m, :])
def __init__(self, recording, a_min=None, a_max=None):
if not isinstance(recording, RecordingExtractor):
raise ValueError("'recording' must be a RecordingExtractor")
self._recording = recording
self._a_min = a_min
self._a_max = a_max
RecordingExtractor.__init__(self)
self.copy_channel_properties(recording=self._recording)
def __init__(self, recording_file, verbose=False):
assert HAVE_MCSH5, "To use the MCSH5RecordingExtractor install h5py: \n\n pip install h5py\n\n"
self._recording_file = recording_file
self._rf, self._nFrames, self._samplingRate, self._nRecCh, \
self._channel_ids, self._electrodeLabels, self._exponent, self._convFact \
= openMCSH5File(
self._recording_file, verbose)
RecordingExtractor.__init__(self)
def __init__(self, recording, scalar=1, offset=0):
if not isinstance(recording, RecordingExtractor):
raise ValueError("'recording' must be a RecordingExtractor")
self._recording = recording
self._scalar = scalar
self._offset = offset
RecordingExtractor.__init__(self)
self.copy_channel_properties(recording=self._recording)
def __init__(self, recording, resample_rate):
assert HAVE_RR, "To use the ResampleRecording, install scipy: \n\n pip install scipy\n\n"
self._recording = recording
self._resample_rate = resample_rate
RecordingExtractor.__init__(self)
self.copy_channel_properties(recording)
self._kwargs = {'recording': recording.make_serialized_dict(), 'resample_rate': resample_rate}
def __init__(self, file_path, stream_id=0, verbose=False):
assert HAVE_MCSH5, "To use the MCSH5RecordingExtractor install h5py: \n\n pip install h5py\n\n"
self._recording_file = file_path
self._verbose = verbose
self._available_stream_ids = self.get_available_stream_ids()
self.set_stream_id(stream_id)
RecordingExtractor.__init__(self)
