def test_remove_bad_channels(): num_channels = 4 sampling_frequency = 30000. durations = [10.325, 3.5] num_segments = len(durations) num_timepoints = [int(sampling_frequency * d) for d in durations] traces_list = [] for i in range(num_segments): traces = np.random.randn(num_timepoints[i], num_channels).astype('float32') # one channel have big noise traces[:, 1] *= 10 times = np.arange(num_timepoints[i]) / sampling_frequency traces += np.sin(2 * np.pi * 50 * times)[:, None] traces_list.append(traces) rec = NumpyRecording(traces_list, sampling_frequency) probe = generate_linear_probe(num_elec=num_channels) probe.set_device_channel_indices(np.arange(num_channels)) rec.set_probe(probe, in_place=True) rec2 = remove_bad_channels(rec, bad_threshold=5.) # Check that the noisy channel is taken out assert np.array_equal(rec2.get_channel_ids(), [0, 2, 3]), "wrong channel detected." # Check that the number of segments is maintained after preprocessor assert np.array_equal(rec2.get_num_segments(), rec.get_num_segments()), "wrong numbber of segments." # Check that the size of the segments os maintained after preprocessor assert np.array_equal(*([r.get_num_frames(x) for x in range(rec.get_num_segments())] for r in [rec, rec2])), "wrong lenght of resulting segments." # Check that locations are mantained assert np.array_equal(rec.get_channel_locations()[[0, 2, 3]], rec2.get_channel_locations()), "wrong channels locations."
def test_ChannelSliceRecording(): num_seg = 2 num_chan = 3 num_samples = 30 sampling_frequency = 10000 dtype = 'int16' file_paths = [f'test_BinaryRecordingExtractor_{i}.raw' for i in range(num_seg)] for i in range(num_seg): traces = np.memmap(file_paths[i], dtype=dtype, mode='w+', shape=(num_samples, num_chan)) traces[:] = np.arange(3)[None, :] rec = BinaryRecordingExtractor(file_paths, sampling_frequency, num_chan, dtype) # keep original ids rec_sliced = ChannelSliceRecording(rec, channel_ids=[0, 2]) assert np.all(rec_sliced.get_channel_ids() == [0, 2]) traces = rec_sliced.get_traces(segment_index=1) assert traces.shape[1] == 2 traces = rec_sliced.get_traces(segment_index=1, channel_ids=[0, 2]) assert traces.shape[1] == 2 traces = rec_sliced.get_traces(segment_index=1, channel_ids=[2, 0]) assert traces.shape[1] == 2 assert np.allclose(rec_sliced.get_times(0), rec.get_times(0)) # with channel ids renaming rec_sliced2 = ChannelSliceRecording(rec, channel_ids=[0, 2], renamed_channel_ids=[3, 4]) assert np.all(rec_sliced2.get_channel_ids() == [3, 4]) traces = rec_sliced2.get_traces(segment_index=1) assert traces.shape[1] == 2 assert np.all(traces[:, 0] == 0) assert np.all(traces[:, 1] == 2) traces = rec_sliced2.get_traces(segment_index=1, channel_ids=[4, 3]) assert traces.shape[1] == 2 assert np.all(traces[:, 0] == 2) assert np.all(traces[:, 1] == 0) # with probe and after save() probe = pi.generate_linear_probe(num_elec=num_chan) probe.set_device_channel_indices(np.arange(num_chan)) rec_p = rec.set_probe(probe) rec_sliced3 = ChannelSliceRecording(rec_p, channel_ids=[0, 2], renamed_channel_ids=[3, 4]) probe3 = rec_sliced3.get_probe() locations3 = probe3.contact_positions cache_folder = Path('./my_cache_folder') folder = cache_folder / 'sliced_recording' rec_saved = rec_sliced3.save(folder=folder, chunk_size=10, n_jobs=2) probe = rec_saved.get_probe() assert np.array_equal(locations3, rec_saved.get_channel_locations()) traces3 = rec_saved.get_traces(segment_index=0) assert np.all(traces3[:, 0] == 0) assert np.all(traces3[:, 1] == 2)
def test_generate(): probe = generate_dummy_probe() probegroup = generate_dummy_probe_group() tetrode = generate_tetrode() multi_columns = generate_multi_columns_probe(num_columns=3, num_elec_per_column=[10, 12, 10], xpitch=22, ypitch=20, y_shift_per_column=[0, -10, 0]) linear = generate_linear_probe(num_elec=16, ypitch=20, electrode_shapes='square', electrode_shape_params={'width': 15}) multi_shank = generate_multi_shank()
def generate_recording( num_channels=2, sampling_frequency=30000., # in Hz durations=[10.325, 3.5], # in s for 2 segments ): num_segments = len(durations) num_timepoints = [int(sampling_frequency * d) for d in durations] traces_list = [] for i in range(num_segments): traces = np.random.randn(num_timepoints[i], num_channels).astype('float32') times = np.arange(num_timepoints[i]) / sampling_frequency traces += np.sin(2 * np.pi * 50 * times)[:, None] traces_list.append(traces) recording = NumpyRecording(traces_list, sampling_frequency) probe = generate_linear_probe(num_elec=num_channels) probe.set_device_channel_indices(np.arange(num_channels)) recording.set_probe(probe, in_place=True) return recording
# A `Shank` is link to a `Probe` object and can also retrieve # positions, electrode shapes, etc.: for i, shank in enumerate(multi_shank.get_shanks()): print('shank', i) print(shank.__class__) print(shank.get_electrode_count()) print(shank.electrode_positions.shape) ############################################################################## # Another option to create multi-shank probes is to create several `Shank` # objects as separate probes and then combine then into a single `Probe` object # generate a 2 shanks linear probe0 = generate_linear_probe(num_elec=16, ypitch=20, electrode_shapes='square', electrode_shape_params={'width': 12}) probe1 = probe0.copy() probe1.move([100, 0]) multi_shank = combine_probes([probe0, probe1]) ############################################################################## print(multi_shank.shank_ids) ############################################################################## plot_probe(multi_shank) plt.show()
print('Sampling frequency = {} Hz'.format(recording.get_sampling_frequency())) print('Num. timepoints seg0= {}'.format(recording.get_num_segments())) print('Num. timepoints seg0= {}'.format( recording.get_num_frames(segment_index=0))) print('Num. timepoints seg1= {}'.format( recording.get_num_frames(segment_index=1))) ############################################################################## # The geometry of the Probe is handle with the :code:`probeinterface`. # Let's generate a linear probe: from probeinterface import generate_linear_probe from probeinterface.plotting import plot_probe probe = generate_linear_probe(num_elec=7, ypitch=20, contact_shapes='circle', contact_shape_params={'radius': 6}) # the probe has to be wired to the recording probe.set_device_channel_indices(np.arange(7)) recording = recording.set_probe(probe) plot_probe(probe) ############################################################################## # Some extractors also implement a :code:`write` function. file_paths = ['traces0.raw', 'traces1.raw'] se.BinaryRecordingExtractor.write_recording(recording, file_paths) ##############################################################################
tetrode.move([i * 50, 0]) probegroup.add_probe(tetrode) probegroup.set_global_device_channel_indices(np.arange(16)) df = probegroup.to_dataframe() df plot_probe_group(probegroup, with_channel_index=True, same_axes=True) ############################################################################## # Generate a linear probe: # from probeinterface import generate_linear_probe linear_probe = generate_linear_probe(num_elec=16, ypitch=20) plot_probe(linear_probe, with_channel_index=True) ############################################################################## # Generate a multi-column probe: # from probeinterface import generate_multi_columns_probe multi_columns = generate_multi_columns_probe(num_columns=3, num_contact_per_column=[10, 12, 10], xpitch=22, ypitch=20, y_shift_per_column=[0, -10, 0], contact_shapes='square', contact_shape_params={'width': 12}) plot_probe(multi_columns, with_channel_index=True, )
import matplotlib.pyplot as plt from probeinterface import Probe, ProbeGroup from probeinterface.plotting import plot_probe, plot_probe_group from probeinterface import generate_multi_columns_probe, generate_linear_probe ############################################################################## # Some examples in 2d fig, ax = plt.subplots() probe0 = generate_multi_columns_probe() plot_probe(probe0, ax=ax) # make some colors for each probe probe1 = generate_linear_probe(num_elec=9) probe1.rotate(theta=15) probe1.move([200, 0]) plot_probe(probe1, ax=ax, electrode_colors=['red', 'cyan', 'yellow'] * 3) # prepare yourself for carnival! probe2 = generate_linear_probe() probe2.rotate(theta=-35) probe2.move([400, 0]) n = probe2.get_electrode_count() rand_colors = np.random.rand(n, 3) plot_probe(probe2, ax=ax, electrode_colors=rand_colors, probe_shape_kwargs={ 'facecolor': 'purple',