def test_annotations_special_cases(self): # Special cases for annotations: empty list, list of strings, # multidimensional lists/arrays # These are handled differently on read, so we test them on a block # instead of just checking the property writer method # empty value # empty list wblock = Block("block with empty list", an_empty_list=list()) self.writer.write_block(wblock) rblock = self.writer.read_block(neoname="block with empty list") self.assertEqual(rblock.annotations["an_empty_list"], list()) # empty tuple (gets read out as list) wblock = Block("block with empty tuple", an_empty_tuple=tuple()) self.writer.write_block(wblock) rblock = self.writer.read_block(neoname="block with empty tuple") self.assertEqual(rblock.annotations["an_empty_tuple"], list()) # list of strings losval = ["one", "two", "one million"] wblock = Block("block with list of strings", los=losval) self.writer.write_block(wblock) rblock = self.writer.read_block(neoname="block with list of strings") self.assertEqual(rblock.annotations["los"], losval)
def test_time_slice_None(self): time_slices = [(None, 5.0 * pq.s), (5.0 * pq.s, None), (None, None)] anasig = AnalogSignal(np.arange(50.0) * pq.mV, sampling_rate=1.0 * pq.Hz) seg = Segment() seg.analogsignals = [anasig] block = Block() block.segments = [seg] block.create_many_to_one_relationship() # test without resetting the time for t_start, t_stop in time_slices: sliced = seg.time_slice(t_start, t_stop) assert_neo_object_is_compliant(sliced) self.assertEqual(len(sliced.analogsignals), 1) exp_t_start, exp_t_stop = t_start, t_stop if exp_t_start is None: exp_t_start = seg.t_start if exp_t_stop is None: exp_t_stop = seg.t_stop self.assertEqual(exp_t_start, sliced.t_start) self.assertEqual(exp_t_stop, sliced.t_stop)
def read_block(self, lazy=False, group=None, reader=None): """ Read a Block from the file :param lazy: Enables lazy reading :param group: HDF5 Group representing the block in NSDF model tree (optional) :param reader: NSDFReader instance (optional) :return: Read block """ assert not lazy, 'Do not support lazy' block = Block() group, reader = self._select_first_container(group, reader, 'block') if group is None: return None attrs = group.attrs self._read_block_children(block, group, reader) block.create_many_to_one_relationship() self._read_container_metadata(attrs, block) return block
def test_block_write(self): block = Block(name=self.rword(), description=self.rsentence()) self.write_and_compare([block]) block.annotate(**self.rdict(5)) self.write_and_compare([block])
def read_block(self, lazy=False, cascade=True): block = Block(file_origin=self.filename) if cascade: block.segments.append(self.read_segment(lazy=lazy, cascade=cascade)) block.segments[-1].block = block return block
def read_block(self, lazy=False, cascade=True, channel_index=None): """ Arguments: Channel_index: can be int, iterable or None to select one, many or all channel(s) """ blk = Block() if cascade: seg = Segment(file_origin=self._filename) blk.segments += [seg] if channel_index: if type(channel_index) is int: channel_index = [channel_index] if type(channel_index) is list: channel_index = np.array(channel_index) else: channel_index = np.arange(0, self._attrs['shape'][1]) chx = ChannelIndex(name='all channels', index=channel_index) blk.channel_indexes.append(chx) ana = self.read_analogsignal(channel_index=channel_index, lazy=lazy, cascade=cascade) ana.channel_index = chx seg.duration = (self._attrs['shape'][0] / self._attrs['kwik']['sample_rate']) * pq.s # neo.tools.populate_RecordingChannel(blk) blk.create_many_to_one_relationship() return blk
def test_spiketrain_write(self): block = Block() seg = Segment() block.segments.append(seg) spiketrain = SpikeTrain(times=[3, 4, 5] * pq.s, t_stop=10.0, name="spikes!", description="sssssspikes") seg.spiketrains.append(spiketrain) self.write_and_compare([block]) waveforms = self.rquant((3, 5, 10), pq.mV) spiketrain = SpikeTrain(times=[1, 1.1, 1.2] * pq.ms, t_stop=1.5 * pq.s, name="spikes with wf", description="spikes for waveform test", waveforms=waveforms) seg.spiketrains.append(spiketrain) self.write_and_compare([block]) spiketrain.left_sweep = np.random.random(10) * pq.ms self.write_and_compare([block]) spiketrain.left_sweep = pq.Quantity(-10, "ms") self.write_and_compare([block])
def test__construct_subsegment_by_unit(self): nb_seg = 3 nb_unit = 7 unit_with_sig = [0, 2, 5] signal_types = ['Vm', 'Conductances'] sig_len = 100 #recordingchannelgroups rcgs = [ RecordingChannelGroup(name = 'Vm', channel_indexes = unit_with_sig), RecordingChannelGroup(name = 'Conductance', channel_indexes = unit_with_sig), ] # Unit all_unit = [ ] for u in range(nb_unit): un = Unit(name = 'Unit #%d' % u, channel_indexes = [u]) all_unit.append(un) bl = Block() for s in range(nb_seg): seg = Segment(name = 'Simulation %s' % s) for j in range(nb_unit): st = SpikeTrain([1, 2, 3], units = 'ms', t_start = 0., t_stop = 10) st.unit = all_unit[j] for t in signal_types: anasigarr = AnalogSignalArray( np.zeros((sig_len, len(unit_with_sig)) ), units = 'nA', sampling_rate = 1000.*pq.Hz, channel_indexes = unit_with_sig ) seg.analogsignalarrays.append(anasigarr) # what you want subseg = seg.construct_subsegment_by_unit(all_unit[:4])
def read_block(self, gid_list=None, time_unit=pq.ms, t_start=None, t_stop=None, sampling_period=None, id_column_dat=0, time_column_dat=1, value_columns_dat=2, id_column_gdf=0, time_column_gdf=1, value_types=None, value_units=None, lazy=False, cascade=True): seg = self.read_segment(gid_list, time_unit, t_start, t_stop, sampling_period, id_column_dat, time_column_dat, value_columns_dat, id_column_gdf, time_column_gdf, value_types, value_units, lazy, cascade) blk = Block(file_origin=seg.file_origin, file_datetime=seg.file_datetime) blk.segments.append(seg) seg.block = blk return blk
def test_roundtrip_with_json_metadata(self): sample_data = np.random.uniform(size=(200, 3)) filename = "test_roundtrip_with_json_metadata.txt" metadata_filename = "test_roundtrip_with_json_metadata_about.json" signal1 = AnalogSignal(sample_data, units="pA", sampling_rate=2 * pq.kHz) seg1 = Segment() block1 = Block() seg1.analogsignals.append(signal1) seg1.block = block1 block1.segments.append(seg1) iow = AsciiSignalIO(filename, metadata_filename=metadata_filename) iow.write_block(block1) self.assert_(os.path.exists(metadata_filename)) ior = AsciiSignalIO(filename) block2 = ior.read_block() assert len(block2.segments[0].analogsignals) == 3 signal2 = block2.segments[0].analogsignals[1] assert_array_almost_equal(signal1.magnitude[:, 1], signal2.magnitude.reshape(-1), decimal=7) self.assertEqual(signal1.units, signal2.units) self.assertEqual(signal1.sampling_rate, signal2.sampling_rate) assert_array_equal(signal1.times, signal2.times) os.remove(filename) os.remove(metadata_filename)
def _read_block(self, node): attributes = self._get_standard_attributes(node) if "index" in attributes: attributes["index"] = int(attributes["index"]) block = Block(**attributes) for name, child_node in node['segments'].items(): if "Segment" in name: block.segments.append( self._read_segment(child_node, parent=block)) if len(node['recordingchannelgroups']) > 0: for name, child_node in node['recordingchannelgroups'].items(): if "RecordingChannelGroup" in name: block.channel_indexes.append( self._read_recordingchannelgroup(child_node, parent=block)) self._resolve_channel_indexes(block) elif self.merge_singles: # if no RecordingChannelGroups are defined, merging # takes place here. for segment in block.segments: if hasattr(segment, 'unmerged_analogsignals'): segment.analogsignals.extend( self._merge_data_objects( segment.unmerged_analogsignals)) del segment.unmerged_analogsignals if hasattr(segment, 'unmerged_irregularlysampledsignals'): segment.irregularlysampledsignals.extend( self._merge_data_objects( segment.unmerged_irregularlysampledsignals)) del segment.unmerged_irregularlysampledsignals return block
def read_block(self, lazy=False, cascade=True, **kwargs): self._file = h5py.File(self.filename, 'r') self._lazy = lazy file_access_dates = self._file.get('file_create_date') if file_access_dates is None: file_creation_date = None else: file_access_dates = [parse_datetime(dt) for dt in file_access_dates] file_creation_date = file_access_dates[0] identifier = self._file.get('identifier').value if identifier == '_neo': # this is an automatically generated name used if block.name is None identifier = None description = self._file.get('session_description').value if description == "no description": description = None block = Block(name=identifier, description=description, file_origin=self.filename, file_datetime=file_creation_date, rec_datetime=parse_datetime(self._file.get('session_start_time').value), #index=?, nwb_version=self._file.get('nwb_version').value, file_access_dates=file_access_dates, file_read_log='') if cascade: self._handle_general_group(block) self._handle_epochs_group(block) self._handle_acquisition_group(block) self._handle_stimulus_group(block) self._handle_processing_group(block) self._handle_analysis_group(block) self._lazy = False return block
def read_block(self, lazy=False, cascade=True): # TODO read block blk = Block() if cascade: seg = Segment(file_origin=self._absolute_folder_path) for name in self._processing: if (name == "Position"): seg.irregularlysampledsignals += self.read_tracking( path="") if (name == "LFP"): seg.analogsignals += self.read_analogsignal(path="") if (name == "EventWaveform"): seg.spiketrains += self.read_spiketrain(path="") for key in self._processing[name]: if (key == "Position"): seg.irregularlysampledsignals += self.read_tracking( path=name) if (key == "LFP"): seg.analogsignals += self.read_analogsignal(path=name) if (key == "EventWaveform"): seg.spiketrains += self.read_spiketrain(path=name) #blk.channel_indexes = self._channel_indexes blk.segments += [seg] # TODO add duration #seg.duration = self._duration # TODO May need to "populate_RecordingChannel" #blk.create_many_to_one_relationship() return blk
def test_annotations(self): self.testfilename = self.get_filename_path('nixio_fr_ann.nix') with NixIO(filename=self.testfilename, mode='ow') as io: annotations = {'my_custom_annotation': 'hello block'} bl = Block(**annotations) annotations = {'something': 'hello hello000'} seg = Segment(**annotations) an =AnalogSignal([[1, 2, 3], [4, 5, 6]], units='V', sampling_rate=1*pq.Hz) an.annotations['ansigrandom'] = 'hello chars' sp = SpikeTrain([3, 4, 5]* s, t_stop=10.0) sp.annotations['railway'] = 'hello train' ev = Event(np.arange(0, 30, 10)*pq.Hz, labels=np.array(['trig0', 'trig1', 'trig2'], dtype='S')) ev.annotations['venue'] = 'hello event' ev2 = Event(np.arange(0, 30, 10) * pq.Hz, labels=np.array(['trig0', 'trig1', 'trig2'], dtype='S')) ev2.annotations['evven'] = 'hello ev' seg.spiketrains.append(sp) seg.events.append(ev) seg.events.append(ev2) seg.analogsignals.append(an) bl.segments.append(seg) io.write_block(bl) io.close() with NixIOfr(filename=self.testfilename) as frio: frbl = frio.read_block() assert 'my_custom_annotation' in frbl.annotations assert 'something' in frbl.segments[0].annotations # assert 'ansigrandom' in frbl.segments[0].analogsignals[0].annotations assert 'railway' in frbl.segments[0].spiketrains[0].annotations assert 'venue' in frbl.segments[0].events[0].annotations assert 'evven' in frbl.segments[0].events[1].annotations os.remove(self.testfilename)
def read_block(self, lazy=False): assert not lazy, 'This IO does not support lazy mode' block = Block(file_origin=str(self.filename)) block.segments.append(self.read_segment(lazy=lazy)) block.segments[-1].block = block return block
def random_block(): block = Block( name=random_string(10), description=random_string(100), file_origin=random_string(20), file_datetime=random_datetime(), rec_datetime=random_datetime(), **random_annotations(6) ) n_seg = random.randint(0, 5) for i in range(n_seg): seg = random_segment() block.segments.append(seg) seg.block = block children = list(block.data_children_recur) views = [] for child in children: if isinstance(child, (AnalogSignal, IrregularlySampledSignal)): PROB_SIGNAL_HAS_VIEW = 0.5 if np.random.random_sample() < PROB_SIGNAL_HAS_VIEW: chv = random_channelview(child) if chv: views.append(chv) children.extend(views) n_groups = random.randint(0, 5) for i in range(n_groups): group = random_group(children) if group: block.groups.append(group) group.block = block children.append(group) # this can give us nested groups return block
def read_block(self, lazy=False, cascade=True, read_waveforms=True, elphys_directory_name='electrophysiology'): ''' ''' blk = Block(file_origin=self._absolute_directory_path, **self._exdir_directory.attrs.to_dict()) seg = Segment(name='Segment #0', index=0) blk.segments.append(seg) if cascade: for group in self._epochs.values(): epo = self.read_epoch(group.name, cascade, lazy) seg.epochs.append(epo) for channel_group in self._processing[ elphys_directory_name].values(): chx = self.read_channelindex(channel_group.name, cascade=cascade, lazy=lazy, read_waveforms=read_waveforms) blk.channel_indexes.append(chx) seg.analogsignals.extend(chx.analogsignals) seg.spiketrains.extend( [sptr for unit in chx.units for sptr in unit.spiketrains]) return blk
def read_block(self, lazy=False, cascade=True): """ """ blk = Block() if cascade: seg = Segment(file_origin=self._absolute_filename) blk.channel_indexes = self._channel_indexes blk.segments += [seg] seg.analogsignals = self.read_analogsignal(lazy=lazy, cascade=cascade) try: seg.irregularlysampledsignals = self.read_tracking() except Exception as e: print('Warning: unable to read tracking') print(e) seg.spiketrains = self.read_spiketrain() # TODO Call all other read functions seg.duration = self._duration # TODO May need to "populate_RecordingChannel" # spiketrain = self.read_spiketrain() # seg.spiketrains.append() blk.create_many_to_one_relationship() return blk
def test_segment_write(self): block = Block(name=self.rword()) segment = Segment(name=self.rword(), description=self.rword()) block.segments.append(segment) self.write_and_compare([block]) segment.annotate(**self.rdict(2)) self.write_and_compare([block])
def _block_to_neo(self, nix_block): neo_attrs = self._nix_attr_to_neo(nix_block) neo_block = Block(**neo_attrs) neo_block.rec_datetime = datetime.fromtimestamp( nix_block.created_at ) self._neo_map[nix_block.name] = neo_block return neo_block
def test__children(self): blk = Block(name='block1') blk.segments = [self.seg1] blk.create_many_to_one_relationship(force=True) assert_neo_object_is_compliant(self.seg1) assert_neo_object_is_compliant(blk) childobjs = ('AnalogSignal', 'Epoch', 'Event', 'IrregularlySampledSignal', 'SpikeTrain', 'ImageSequence') childconts = ('analogsignals', 'epochs', 'events', 'irregularlysampledsignals', 'spiketrains', 'imagesequences') self.assertEqual(self.seg1._container_child_objects, ()) self.assertEqual(self.seg1._data_child_objects, childobjs) self.assertEqual(self.seg1._single_parent_objects, ('Block', )) self.assertEqual(self.seg1._multi_child_objects, ()) self.assertEqual(self.seg1._multi_parent_objects, ()) self.assertEqual(self.seg1._child_properties, ()) self.assertEqual(self.seg1._single_child_objects, childobjs) self.assertEqual(self.seg1._container_child_containers, ()) self.assertEqual(self.seg1._data_child_containers, childconts) self.assertEqual(self.seg1._single_child_containers, childconts) self.assertEqual(self.seg1._single_parent_containers, ('block', )) self.assertEqual(self.seg1._multi_child_containers, ()) self.assertEqual(self.seg1._multi_parent_containers, ()) self.assertEqual(self.seg1._child_objects, childobjs) self.assertEqual(self.seg1._child_containers, childconts) self.assertEqual(self.seg1._parent_objects, ('Block', )) self.assertEqual(self.seg1._parent_containers, ('block', )) totchildren = ( self.nchildren * 2 + # epoch/event self.nchildren + # analogsignal self.nchildren**2 + # spiketrain self.nchildren + # irregsignal self.nchildren) # imagesequence self.assertEqual(len(self.seg1._single_children), totchildren) self.assertEqual(len(self.seg1.data_children), totchildren) self.assertEqual(len(self.seg1.children), totchildren) self.assertEqual(len(self.seg1.data_children_recur), totchildren) self.assertEqual(len(self.seg1.children_recur), totchildren) self.assertEqual(len(self.seg1._multi_children), 0) self.assertEqual(len(self.seg1.container_children), 0) self.assertEqual(len(self.seg1.container_children_recur), 0) children = (self.sigarrs1a + self.epcs1a + self.evts1a + self.irsigs1a + self.trains1a + self.img_seqs1a) assert_same_sub_schema(list(self.seg1._single_children), children) assert_same_sub_schema(list(self.seg1.data_children), children) assert_same_sub_schema(list(self.seg1.data_children_recur), children) assert_same_sub_schema(list(self.seg1.children), children) assert_same_sub_schema(list(self.seg1.children_recur), children) self.assertEqual(len(self.seg1.parents), 1) self.assertEqual(self.seg1.parents[0].name, 'block1')
def proc_dam(filename): '''Load an dam file that has already been processed by the official matlab file converter. That matlab data is saved to an m-file, which is then converted to a numpy '.npz' file. This numpy file is the file actually loaded. This function converts it to a neo block and returns the block. This block can be compared to the block produced by BrainwareDamIO to make sure BrainwareDamIO is working properly block = proc_dam(filename) filename: The file name of the numpy file to load. It should end with '*_dam_py?.npz'. This will be converted to a neo 'file_origin' property with the value '*.dam', so the filename to compare should fit that pattern. 'py?' should be 'py2' for the python 2 version of the numpy file or 'py3' for the python 3 version of the numpy file. example: filename = 'file1_dam_py2.npz' dam file name = 'file1.dam' ''' with np.load(filename) as damobj: damfile = damobj.items()[0][1].flatten() filename = os.path.basename(filename[:-12] + '.dam') signals = [res.flatten() for res in damfile['signal']] stimIndexes = [int(res[0, 0].tolist()) for res in damfile['stimIndex']] timestamps = [res[0, 0] for res in damfile['timestamp']] block = Block(file_origin=filename) chx = ChannelIndex(file_origin=filename, index=np.array([0]), channel_ids=np.array([1]), channel_names=np.array(['Chan1'], dtype='S')) block.channel_indexes.append(chx) params = [res['params'][0, 0].flatten() for res in damfile['stim']] values = [res['values'][0, 0].flatten() for res in damfile['stim']] params = [[res1[0] for res1 in res] for res in params] values = [[res1 for res1 in res] for res in values] stims = [dict(zip(param, value)) for param, value in zip(params, values)] fulldam = zip(stimIndexes, timestamps, signals, stims) for stimIndex, timestamp, signal, stim in fulldam: sig = AnalogSignal(signal=signal * pq.mV, t_start=timestamp * pq.d, file_origin=filename, sampling_period=1. * pq.s) segment = Segment(file_origin=filename, index=stimIndex, **stim) segment.analogsignals = [sig] block.segments.append(segment) block.create_many_to_one_relationship() return block
def read_block(self, lazy=False, cascade=True, **kargs): ''' Reads a block from the simple spike data file "fname" generated with BrainWare ''' # there are no keyargs implemented to so far. If someone tries to pass # them they are expecting them to do something or making a mistake, # neither of which should pass silently if kargs: raise NotImplementedError('This method does not have any ' 'argument implemented yet') self._fsrc = None self.__lazy = lazy self._blk = Block(file_origin=self._filename) block = self._blk # if we aren't doing cascade, don't load anything if not cascade: return block # create the objects to store other objects chx = ChannelIndex(file_origin=self._filename, index=np.array([], dtype=np.int)) self.__unit = Unit(file_origin=self._filename) # load objects into their containers block.channel_indexes.append(chx) chx.units.append(self.__unit) # initialize values self.__t_stop = None self.__params = None self.__seg = None self.__spiketimes = None # open the file with open(self._path, 'rb') as self._fsrc: res = True # while the file is not done keep reading segments while res: res = self.__read_id() block.create_many_to_one_relationship() # cleanup attributes self._fsrc = None self.__lazy = False self._blk = None self.__t_stop = None self.__params = None self.__seg = None self.__spiketimes = None return block
def read_block(self, lazy=False): assert os.path.exists(self.filename), "Cannot locate file: {}".format( self.filename) with NWBHDF5IO(self.filename, mode='r') as io: nwb = io.read() blk = Block()
def test_signals_compound_units(self): block = Block() seg = Segment() block.segments.append(seg) units = pq.CompoundUnit("1/30000*V") srate = pq.Quantity(10, pq.CompoundUnit("1.0/10 * Hz")) asig = AnalogSignal(signal=self.rquant((10, 3), units), sampling_rate=srate) seg.analogsignals.append(asig) self.write_and_compare([block]) anotherblock = Block("ir signal block") seg = Segment("ir signal seg") anotherblock.segments.append(seg) irsig = IrregularlySampledSignal(signal=np.random.random((20, 3)), times=self.rquant( 20, pq.CompoundUnit("0.1 * ms"), True), units=pq.CompoundUnit("10 * V / s")) seg.irregularlysampledsignals.append(irsig) self.write_and_compare([block, anotherblock]) block.segments[0].analogsignals.append( AnalogSignal(signal=[10.0, 1.0, 3.0], units=pq.S, sampling_period=pq.Quantity(3, "s"), dtype=np.double, name="signal42", description="this is an analogsignal", t_start=45 * pq.CompoundUnit("3.14 * s")), ) self.write_and_compare([block, anotherblock]) times = self.rquant(10, pq.CompoundUnit("3 * year"), True) block.segments[0].irregularlysampledsignals.append( IrregularlySampledSignal(times=times, signal=np.random.random((10, 3)), units="mV", dtype=np.float, name="some sort of signal", description="the signal is described")) self.write_and_compare([block, anotherblock])
def nuevobloque(bloqueviejo, umbral=100, desde=50, hasta=500, cual=0): '''funcion que a partir de un Bloque de neo crea otro recortado y alineado''' result = Block() for j in bloqueviejo.segments: #Toma el primer canal (activo), de cada analogsignal y la recorta estimindex = detectaestimulo(j.analogsignals[0], umbral, cual) cacho = recortasegnal(j.analogsignals[0], estimindex, desde, hasta) result.segments.append(cacho) return result
def test_channel_index_write(self): block = Block(name=self.rword()) chx = ChannelIndex(name=self.rword(), description=self.rsentence(), index=[1, 2, 3, 5, 8, 13]) block.channel_indexes.append(chx) self.write_and_compare([block]) chx.annotate(**self.rdict(3)) self.write_and_compare([block])
def import_dapsys_csv_files(directory: str, sampling_rate: Union[Quantity, str] = "imply", ap_correlation_window_size: Quantity = Quantity(0.003, "s")) \ -> Tuple[Block, Dict[TypeID, Dict[str, str]], List[APTrack]]: csv_files = _get_files_with_extension(directory, ".csv") main_pulses: Event = _read_main_pulse_file(filepaths=csv_files) irregular_sig: IrregularlySampledSignal = _read_signal_file( filepaths=csv_files, signal_unit="uV") if isinstance(sampling_rate, str) and sampling_rate == "imply": sampling_rate = _imply_sampling_rate_from_irregular_signal( irregular_sig) analog_sig: AnalogSignal = convert_irregularly_sampled_signal_to_analog_signal( irregular_sig, sampling_rate=sampling_rate) analog_sig.annotate(id=f"{TypeID.RAW_DATA.value}.1", type_id=TypeID.RAW_DATA.value) ap_tracks: List[APTrack] = _read_track_files(filepaths=csv_files, el_stimuli=main_pulses, sampling_rate=sampling_rate) track_aps: SpikeTrain = _find_action_potentials_on_tracks( ap_tracks=ap_tracks, el_stimuli=main_pulses, signal=irregular_sig, window_size=ap_correlation_window_size, sampling_rate=sampling_rate) # create mapping from names to channel ids channel_id_map = {type_id: {} for type_id in TypeID} channel_id_map[TypeID.ELECTRICAL_STIMULUS].update( {"Main Pulse": main_pulses.annotations["id"]}) channel_id_map[TypeID.RAW_DATA].update({ "Analog Signal": analog_sig.annotations["id"], "Irregular Signal": irregular_sig.annotations["id"] }) channel_id_map[TypeID.ACTION_POTENTIAL].update( {"Track APs": track_aps.annotations["id"]}) # produce the corresponding NEO objects block: Block = Block(name="Base block of dapsys csv recording") segment: Segment = Segment(name="This recording consists of one segment") segment.events.append(main_pulses) segment.irregularlysampledsignals.append(irregular_sig) segment.analogsignals.append(analog_sig) segment.spiketrains.append(track_aps) block.segments.append(segment) return block, channel_id_map, ap_tracks
def read_block(self, lazy=False, **kwargs): # to sort file def natural_sort(l): convert = lambda text: int(text) if text.isdigit() else text.lower( ) alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] return sorted(l, key=alphanum_key) # find all the images in the given directory file_name_list = [] # name of extensions to track types = ["*.tif", "*.tiff"] for file in types: file_name_list.append(glob.glob(self.filename + "/" + file)) # flatten list file_name_list = [ item for sublist in file_name_list for item in sublist ] # delete path in the name of file file_name_list = [ file_name[len(self.filename) + 1::] for file_name in file_name_list ] # sorting file file_name_list = natural_sort(file_name_list) list_data_image = [] for file_name in file_name_list: list_data_image.append( np.array(Image.open(self.filename + "/" + file_name), dtype=np.float)) list_data_image = np.array(list_data_image) if len(list_data_image.shape) == 4: list_data_image = [] for file_name in file_name_list: list_data_image.append( np.array(Image.open(self.filename + "/" + file_name).convert('L'), dtype=np.float)) print("read block") image_sequence = ImageSequence(np.stack(list_data_image), units=self.units, sampling_rate=self.sampling_rate, spatial_scale=self.spatial_scale) print("creating segment") segment = Segment(file_origin=self.filename) segment.annotate(tiff_file_names=file_name_list) segment.imagesequences = [image_sequence] block = Block(file_origin=self.filename) segment.block = block block.segments.append(segment) print("returning block") return block
def test_event_write(self): block = Block() seg = Segment() block.segments.append(seg) event = Event(times=np.arange(0, 30, 10) * pq.s, labels=np.array(["0", "1", "2"]), name="event name", description="event description") seg.events.append(event) self.write_and_compare([block])