def create_CN_figure(probe_name, probe):
"""
Create custum figire for CN with custum colors + logo
"""
fig, ax = plt.subplots()
fig.set_size_inches(18.5, 10.5)
n = probe.get_contact_count()
plot_probe(
probe,
ax=ax,
contacts_colors=['#5bc5f2'] * n, # made change to default color
probe_shape_kwargs=dict(facecolor='#6f6f6e',
edgecolor='k',
lw=0.5,
alpha=0.3), # made change to default color
with_channel_index=True)
ax.set_xlabel(u'Width (\u03bcm)') #modif to legend
ax.set_ylabel(u'Height (\u03bcm)') #modif to legend
ax.spines['right'].set_visible(False) #remove external axis
ax.spines['top'].set_visible(False) #remove external axis
ax.set_title('\n' + 'CambridgeNeuroTech' + '\n' +
probe.annotations.get('name'),
fontsize=24)
fig.tight_layout() #modif tight layout
im = plt.imread(work_dir / 'CN_logo-01.jpg')
newax = fig.add_axes([0.8, 0.85, 0.2, 0.1], anchor='NW', zorder=0)
newax.imshow(im)
newax.axis('off')
return fig
def test_wire_probe():
manufacturer = 'neuronexus'
probe_name = 'A1x32-Poly3-10mm-50-177'
probe = get_probe(manufacturer, probe_name)
probe.wiring_to_device('H32>RHD')
plot_probe(probe, with_channel_index=True)
def _plot_one_bin(self, rec, probe, peaks, duration):
# TODO: @alessio weight_with_amplitudes is not implemented yet
rates = np.zeros(rec.get_num_channels(), dtype='float64')
for chan_ind, chan_id in enumerate(rec.channel_ids):
mask = peaks['channel_ind'] == chan_ind
num_spike = np.sum(mask)
rates[chan_ind] = num_spike / duration
artists = ()
if self.with_contact_color:
poly, poly_contour = plot_probe(probe,
ax=self.ax,
contacts_values=rates,
probe_shape_kwargs={
'facecolor': 'w',
'alpha': .1
},
contacts_kargs={'alpha': 1.})
artists = artists + (poly, poly_contour)
if self.with_interpolated_map:
image, xlims, ylims = probe.to_image(rates,
pixel_size=0.5,
num_pixel=None,
method='linear',
xlims=None,
ylims=None)
im = self.ax.imshow(image,
extent=xlims + ylims,
origin='lower',
alpha=0.5)
artists = artists + (im, )
return artists
def plot(self):
we = self.waveform_extractor
unit_localisation = self.unit_localisation
unit_ids = we.sorting.unit_ids
if unit_localisation is None:
assert self.method in ('center_of_mass',)
if self.method == 'center_of_mass':
coms = compute_unit_centers_of_mass(we, **self.method_kwargs)
unit_localisation = np.array([e for e in coms.values()])
else:
raise ValueError('UnitLocalizationWidget: method not implemented.')
ax = self.ax
probegroup = we.recording.get_probegroup()
probe_shape_kwargs = dict(facecolor='w', edgecolor='k', lw=0.5, alpha=1.)
contacts_kargs = dict(alpha=1., edgecolor='k', lw=0.5)
for probe in probegroup.probes:
poly_contact, poly_contour = plot_probe(probe, ax=ax,
contacts_colors='w', contacts_kargs=contacts_kargs,
probe_shape_kwargs=probe_shape_kwargs)
poly_contact.set_zorder(2)
if poly_contour is not None:
poly_contour.set_zorder(1)
ax.set_title('')
color = np.array([self.unit_colors[unit_id] for unit_id in unit_ids])
loc = ax.scatter(
unit_localisation[:, 0], unit_localisation[:, 1], marker='1', color=color, s=80, lw=3)
loc.set_zorder(3)
def test_wire_probe():
manufacturer = 'neuronexus'
probe_name = 'A1x32-Poly3-10mm-50-177'
probe = get_probe(manufacturer, probe_name)
probe.wiring_to_device('H32>RHD2132')
plot_probe(probe, with_channel_index=True)
manufacturer = 'cambridgeneurotech'
probe_name = 'ASSY-156-P-1'
probe = get_probe(manufacturer, probe_name)
probe.wiring_to_device('ASSY-156>RHD2164')
plot_probe(probe, with_channel_index=True)
def _do_plot(self):
rec = self.recording
peaks = self.peaks
if peaks is None:
from spikeinterface.sortingcomponents import detect_peaks
self.detect_peaks_kwargs['outputs'] = 'numpy_compact'
peaks = detect_peaks(rec, **self.detect_peaks_kwargs)
fs = rec.get_sampling_frequency()
duration = rec.get_total_duration()
probe = rec.get_probe()
positions = probe.contact_positions
# TODO: @alessio weight_with_amplitudes is not implemented yet
rates = np.zeros(rec.get_num_channels(), dtype='float64')
for chan_ind, chan_id in enumerate(rec.channel_ids):
mask = peaks['channel_ind'] == chan_ind
num_spike = np.sum(mask)
rates[chan_ind] = num_spike / duration
if self.with_contact_color:
plot_probe(probe,
ax=self.ax,
contacts_values=rates,
probe_shape_kwargs={
'facecolor': 'w',
'alpha': .1
},
contacts_kargs={'alpha': 1.})
if self.with_interpolated_map:
image, xlims, ylims = probe.to_image(rates,
pixel_size=0.5,
num_pixel=None,
method='linear',
xlims=None,
ylims=None)
self.ax.imshow(image,
extent=xlims + ylims,
origin='lower',
alpha=0.5)
def test_plot_probe():
probe = generate_dummy_probe()
plot_probe(probe)
plot_probe(probe, with_channel_index=True)
# with color
n = probe.get_electrode_count()
electrode_colors = np.random.rand(n, 3)
plot_probe(probe, electrode_colors=electrode_colors)
# 3d
probe_3d = probe.to_3d(plane='xz')
plot_probe(probe_3d)
def plot(self):
we = self.waveform_extractor
probe = we.recording.get_probe()
probe_shape_kwargs = dict(facecolor='w',
edgecolor='k',
lw=0.5,
alpha=1.)
all_poly_contact = []
for i, unit_id in enumerate(self.unit_ids):
ax = self.axes.flatten()[i]
template = we.get_template(unit_id)
# static
if self.animated:
contacts_values = np.zeros(template.shape[1])
else:
contacts_values = np.max(np.abs(template), axis=0)
poly_contact, poly_contour = plot_probe(
probe,
contacts_values=contacts_values,
ax=ax,
probe_shape_kwargs=probe_shape_kwargs)
poly_contact.set_zorder(2)
if poly_contour is not None:
poly_contour.set_zorder(1)
if self.colorbar:
self.figure.colorbar(poly_contact, ax=ax)
poly_contact.set_clim(0, np.max(np.abs(template)))
all_poly_contact.append(poly_contact)
ax.set_title(str(unit_id))
if self.animated:
num_frames = template.shape[0]
def animate_func(frame):
for i, unit_id in enumerate(self.unit_ids):
template = we.get_template(unit_id)
contacts_values = np.abs(template[frame, :])
poly_contact = all_poly_contact[i]
poly_contact.set_array(contacts_values)
return all_poly_contact
self.animation = FuncAnimation(self.figure,
animate_func,
frames=num_frames,
interval=20,
blit=True)
def plot(self):
we = self.waveform_extractor
unit_localisation = self.unit_localisation
if unit_localisation is None:
assert self.method in ('center_of_mass', )
if self.method == 'center_of_mass':
coms = compute_unit_centers_of_mass(we, **self.method_kwargs)
localisation = np.array([e for e in coms.values()])
else:
raise ValueError(
'UnitLocalizationWidget: method not implemenetd')
ax = self.ax
probe = we.recording.get_probe()
plot_probe(probe, ax=ax)
ax.set_title('')
ax.scatter(localisation[:, 0],
localisation[:, 1],
marker='1',
color='r')
def plot(self):
we = self.waveform_extractor
unit_location = self.unit_location
unit_ids = we.sorting.unit_ids
if unit_location is None:
unit_location = localize_unit(we,
method=self.method,
**self.method_kwargs)
ax = self.ax
probegroup = we.recording.get_probegroup()
probe_shape_kwargs = dict(facecolor='w',
edgecolor='k',
lw=0.5,
alpha=1.)
contacts_kargs = dict(alpha=1., edgecolor='k', lw=0.5)
for probe in probegroup.probes:
poly_contact, poly_contour = plot_probe(
probe,
ax=ax,
contacts_colors='w',
contacts_kargs=contacts_kargs,
probe_shape_kwargs=probe_shape_kwargs)
poly_contact.set_zorder(2)
if poly_contour is not None:
poly_contour.set_zorder(1)
ax.set_title('')
color = np.array([self.unit_colors[unit_id] for unit_id in unit_ids])
loc = ax.scatter(unit_location[:, 0],
unit_location[:, 1],
marker='1',
color=color,
s=80,
lw=3)
loc.set_zorder(3)
# Import
import numpy as np
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,
def _do_plot(self):
plot_probe(self._probe, ax=self.ax)
manufacturer = 'neuronexus'
probe_name = 'A1x32-Poly3-10mm-50-177'
probe = get_probe(manufacturer, probe_name)
probe.rotate(23)
##############################################################################
# fake values
values = np.random.randn(32)
##############################################################################
# plot with value
fig, ax = plt.subplots()
poly, poly_contour = plot_probe(probe, electrode_values=values,
cmap='jet', ax=ax, electrodes_kargs={'alpha' : 1})
poly.set_clim(-2, 2)
fig.colorbar(poly)
##############################################################################
# generated an interpolated image and plot it on top
image, xlims, ylims = probe.to_image(values, pixel_size=4, method='linear')
print(image.shape)
fig, ax = plt.subplots()
plot_probe(probe, ax=ax)
im = ax.imshow(image, extent=xlims+ylims, origin='lower', cmap='jet')
im.set_clim(-2,2)
import numpy as np
import matplotlib.pyplot as plt
from probeinterface import Probe, ProbeGroup
from probeinterface import generate_linear_probe, generate_multi_shank
from probeinterface import combine_probes
from probeinterface.plotting import plot_probe
##############################################################################
# Let's use a generator to create a multi shank probe:
multi_shank = generate_multi_shank(num_shank=3,
num_columns=2,
num_elec_per_column=6)
plot_probe(multi_shank)
##############################################################################
# `multi_shank` is one `probe` object, but internally the `Probe.shank_ids` vector handles the shank ids.
print(multi_shank.shank_ids)
##############################################################################
# The dataframe displays the `shank_ids` column:
df = multi_shank.to_dataframe()
df
##############################################################################
# We can iterate over a multi-shank probe and get :py:class:`Shank` objects.
# A `Shank` is link to a `Probe` object and can also retrieve
# 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)
##############################################################################
# We can read the written recording back with the proper extractor.
# Note that this new recording is now "on disk" and not "in memory" as the Numpy recording.
# This meand that the loading is "lazy" and the data are not loaded in memory.
recording2 = se.BinaryRecordingExtractor(file_paths, sampling_frequency,
num_channels, traces0.dtype)
print(recording2)
probe = get_probe(manufacturer, probe_name)
probe.rotate(23)
##############################################################################
# fake values
values = np.random.randn(32)
##############################################################################
# plot with value
fig, ax = plt.subplots()
poly, poly_contour = plot_probe(probe,
contacts_values=values,
cmap='jet',
ax=ax,
contacts_kargs={'alpha': 1},
title=False)
poly.set_clim(-2, 2)
fig.colorbar(poly)
##############################################################################
# generated an interpolated image and plot it on top
image, xlims, ylims = probe.to_image(values, pixel_size=4, method='linear')
print(image.shape)
fig, ax = plt.subplots()
plot_probe(probe, ax=ax, title=False)
im = ax.imshow(image, extent=xlims + ylims, origin='lower', cmap='jet')
# The shape of probe_3d.contact_positions is now (n_elec, 3) probe_3d = probe_2d.to_3d(axes='xz') print(probe_2d.contact_positions.shape) print(probe_3d.contact_positions.shape) ############################################################################## # Note that all **"y"** coordinates are 0 df = probe_3d.to_dataframe() df[['x', 'y', 'z']].head() ############################################################################## # The plotting function autiomatically displays the `Probe` in 3d: plot_probe(probe_3d) ############################################################################## # We can create another probe lying on another plane: other_3d = probe_2d.to_3d(axes='yz') plot_probe(other_3d) ############################################################################## # `Probe` can be moved and rotated in 3d: probe_3d.move([0, 30, -50]) probe_3d.rotate(theta=35, center=[0, 0, 0], axis=[0, 1, 1]) plot_probe(probe_3d)
import numpy as np import matplotlib.pyplot as plt from probeinterface import Probe, get_probe from probeinterface.plotting import plot_probe ############################################################################## # Download one probe: manufacturer = 'neuronexus' probe_name = 'A1x32-Poly3-10mm-50-177' probe = get_probe(manufacturer, probe_name) print(probe) ############################################################################## # Files from the library also contain annotations specific to manufacturers. # We can see here that Neuronexus probes have contact indices starting at "1" (one-based) pprint(probe.annotations) ############################################################################## # When plotting, the channel indices are automatically displayed with # one-based notation (even if internally everything is still zero based): plot_probe(probe, with_channel_index=True) ############################################################################## plt.show()
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, )
##############################################################################
probe0.create_auto_shape(probe_type='tip')
probe1 = generate_tetrode(r=25)
probe1.create_auto_shape(probe_type='tip')
probe1.move([150, 0])
probe = combine_probes([probe0, probe1])
pos = probe.electrode_positions
pos[np.abs(pos) < 0.0001] = 0
probe.electrode_positions = pos
# do not include wiring in example : too complicated
# probe.set_device_channel_indices([3,2,1,0, 7, 6, 5, 4])
probe.annotate(name='2 shank tetrodes', manufacturer='homemade')
print(probe.shank_ids)
d = probe.to_dict()
print(d.keys())
fig, ax = plt.subplots(figsize=(8, 8))
plot_probe(probe, with_channel_index=True, ax=ax)
ax.set_xlim(-50, 200)
ax.set_ylim(-150, 120)
write_probeinterface('probe_format_example.json', probe)
fig.savefig('img/probe_format_example.png')
plt.show()
############################################################################## # `Probe` objects have fancy prints! print(probe) ############################################################################## # In addition to contacts, we can crate the planar contour (polygon) of the probe polygon = [(-20, -30), (20, -110), (60, -30), (60, 190), (-20, 190)] probe.set_planar_contour(polygon) ############################################################################## # If `pandas` is installed, the `Probe` object can be exported as a dataframe for a simpler view: df = probe.to_dataframe() df ############################################################################## # If `matplotlib` is installed, the `Probe` can also be easily plotted: plot_probe(probe) ############################################################################## # A 2d `Probe` can be transformed to a 3d `Probe` by indicating the `axes` # on which contacts will lie (Here the 'y' coordinate will be 0 for all contacts): probe_3d = probe.to_3d(axes='xz') plot_probe(probe_3d) plt.show()
##############################################################################
# First, let's create a toy example:
recording, sorting_true = se.toy_example(duration=10,
num_channels=32,
seed=0,
num_segments=2)
print(recording)
###############################################################################
# This genertor already contain a probe object you can retreive directly an plot
probe = recording.get_probe()
print(probe)
from probeinterface.plotting import plot_probe
plot_probe(probe)
###############################################################################
# You can also change the probe
# In that case you need to manually make the wiring
# Lets use a probe from cambridgeneurotech with 32ch
from probeinterface import get_probe
other_probe = get_probe('cambridgeneurotech', 'ASSY-37-E-1')
print(other_probe)
other_probe.set_device_channel_indices(np.arange(32))
recording_2_shanks = recording.set_probe(other_probe, group_mode='by_shank')
plot_probe(recording_2_shanks.get_probe())
###############################################################################
# Now let's check what we have loaded.