def plot_morpho(self, figsize, save_path=None, alpha=1, color=None, volume=None, vol_color = (250, 250, 250, .05), azim=-90, elev=-90, dist=6, xlim3d=(-4500, 110000), ylim3d=(-4500, 110000), linewidth=1.5, connectors=False):
# recommended volume for L1 dataset, 'PS_Neuropil_manual'
neurons = pymaid.get_neurons(self.skids)
if(color==None):
color = self.color
if(volume!=None):
neuropil = pymaid.get_volume(volume)
neuropil.color = vol_color
fig, ax = navis.plot2d([neurons, neuropil], method='3d_complex', color=color, linewidth=linewidth, connectors=connectors, cn_size=2, alpha=alpha)
if(volume==None):
fig, ax = navis.plot2d([neurons], method='3d_complex', color=color, linewidth=linewidth, connectors=connectors, cn_size=2, alpha=alpha)
ax.azim = azim
ax.elev = elev
ax.dist = dist
ax.set_xlim3d(xlim3d)
ax.set_ylim3d(ylim3d)
plt.show()
if(save_path!=None):
fig.savefig(f'{save_path}.png', format='png', dpi=300, transparent=True)
def setUp(self):
self.rm = pymaid.CatmaidInstance(config_test.server_url,
config_test.http_user,
config_test.http_pw,
config_test.token)
self.nl = pymaid.get_neuron(config_test.test_skids,
remote_instance=self.rm)
self.vol = pymaid.get_volume(config_test.test_volume)
def plot_3view(
data,
axs,
palette=None,
connectors=False,
connectors_only=False,
label_by=None,
alpha=1,
s=1,
row_title=None,
**kws,
):
volumes = [pymaid.get_volume(v) for v in volume_names]
for i, view in enumerate(views):
ax = axs[i]
if label_by is None:
pymaid.plot2d(
data,
color=palette,
ax=ax,
method="3d",
connectors=connectors,
connectors_only=connectors_only,
**kws,
)
else:
uni_labels = np.unique(data[label_by])
for ul in uni_labels:
temp_data = data[data[label_by] == ul]
color = palette[ul]
scatter_kws = dict(s=s, alpha=alpha, color=color)
pymaid.plot2d(
temp_data[["x", "y", "z"]],
ax=ax,
method="3d",
connectors=connectors,
connectors_only=connectors_only,
scatter_kws=scatter_kws,
**kws,
)
set_view_params(ax, **view_dict[view])
plot_volumes(volumes, ax)
if row_title is not None:
ax = axs[0]
ax.text2D(
x=0,
y=0.5,
s=row_title,
ha="right",
va="center",
color="grey",
rotation=90,
transform=ax.transAxes,
)
def plot_celltype(path, pairids, n_rows, n_cols, celltypes, pairs_path, plot_pairs=True, connectors=False, cn_size=0.25, color=None, names=False, plot_padding=[0,0]):
pairs = Promat.get_pairs(pairs_path)
# pull specific cell type identities
celltype_ct = [Celltype(f'{pairid}-ipsi-bi', Promat.get_paired_skids(pairid, pairs)) for pairid in pairids]
celltype_ct = Celltype_Analyzer(celltype_ct)
celltype_ct.set_known_types(celltypes)
members = celltype_ct.memberships()
# link identities to official celltype colors
celltype_identities = [np.where(members.iloc[:, i]==1.0)[0][0] for i in range(0, len(members.columns))]
if(plot_pairs):
celltype_ct = [Celltype(celltypes[celltype_identities[i]].name.replace('s', ''), Promat.get_paired_skids(pairid, pairs), celltypes[celltype_identities[i]].color) if celltype_identities[i]<17 else Celltype(f'{pairid}', Promat.get_paired_skids(pairid, pairs), '#7F7F7F') for i, pairid in enumerate(pairids)]
if(plot_pairs==False):
celltype_ct = [Celltype(celltypes[celltype_identities[i]].name.replace('s', ''), pairid, celltypes[celltype_identities[i]].color) if celltype_identities[i]<17 else Celltype('Other', pairid, '#7F7F7F') for i, pairid in enumerate(pairids)]
# plot neuron morphologies
neuropil = pymaid.get_volume('PS_Neuropil_manual')
neuropil.color = (250, 250, 250, .05)
n_rows = n_rows
n_cols = n_cols
alpha = 1
fig = plt.figure(figsize=(n_cols*2, n_rows*2))
gs = plt.GridSpec(n_rows, n_cols, figure=fig, wspace=plot_padding[0], hspace=plot_padding[1])
axs = np.empty((n_rows, n_cols), dtype=object)
for i, skids in enumerate([x.skids for x in celltype_ct]):
if(color!=None):
col = color
else: col = celltype_ct[i].color
neurons = pymaid.get_neurons(skids)
inds = np.unravel_index(i, shape=(n_rows, n_cols))
ax = fig.add_subplot(gs[inds], projection="3d")
axs[inds] = ax
navis.plot2d(x=[neurons, neuropil], connectors=connectors, cn_size=cn_size, color=col, alpha=alpha, ax=ax, method='3d_complex')
ax.azim = -90
ax.elev = -90
ax.dist = 6
ax.set_xlim3d((-4500, 110000))
ax.set_ylim3d((-4500, 110000))
if(names):
ax.text(x=(ax.get_xlim()[0] + ax.get_xlim()[1])/2 - ax.get_xlim()[1]*0.05, y=ax.get_ylim()[1]*4/5, z=0,
s=celltype_ct[i].name, transform=ax.transData, color=col, alpha=1)
fig.savefig(f'{path}.png', format='png', dpi=300, transparent=True)
def test_connectivity_filter(self):
dist, prox = pymaid.cut_neuron(
self.n, pymaid.find_main_branchpoint(self.n))
vol = pymaid.get_volume(config_test.test_volume)
# Connectivity table by neuron
self.assertIsInstance(pymaid.filter_connectivity(self.cn_table, prox),
pd.DataFrame)
# Adjacency matrix by neuron
self.assertIsInstance(pymaid.filter_connectivity(self.adj, prox),
pd.DataFrame)
# Connectivity table by volume
self.assertIsInstance(pymaid.filter_connectivity(self.cn_table, vol),
pd.DataFrame)
# Adjacency matrix by volume
self.assertIsInstance(pymaid.filter_connectivity(self.adj, vol),
pd.DataFrame)
def test_get_volume(self):
self.assertIsInstance(pymaid.get_volume(
config_test.test_volume, remote_instance=self.rm), pymaid.Volume)
pns_ms = neurogenesis.init_from_skid_list(fafb_c, pn_skids)
import pickle
path = local_path + "data/pn_bouton_clusters/"
with open(path + "pns_ms.pkl", 'wb') as f:
pickle.dump(pns_ms, f, -1)
nl = [pymaid.get_neuron([str(i) for i in j]) for j in [pn_skids[:40], pn_skids[40:80], pn_skids[80:]]]
pns_pm = nl[0] + nl[1] + nl [2]
with open(path + "pns_pm.pkl", 'wb') as f:
pickle.dump(pns_pm, f, -1)
ca = pymaid.get_volume('MB_CA_R')
with open(path + "ca.pkl", 'wb') as f:
pickle.dump(ca, f, -1)
df = pd.read_excel(local_path + 'data/180613-pn_subtypes.xlsx')
# for loading the pickle pymaid neuronlist data
path = local_path + "data/pn_bouton_clusters/"
with open(path + "pns_pm.pkl", 'rb') as f:
pns_pm = pickle.load(f)
with open(path + "pns_ms.pkl", 'rb') as f:
pns_ms = pickle.load(f)
axs = np.empty((n_row, n_col), dtype="O")
connection_types = ["axon", "dendrite", "unsplittable"]
pal = sns.color_palette("deep", 5)
colors = [pal[3], pal[0], pal[4]] # red, blue, purple
connection_colors = dict(zip(connection_types, colors))
views = ["front", "side", "top"]
view_params = [
dict(azim=-90, elev=0, dist=5),
dict(azim=0, elev=0, dist=5),
dict(azim=-90, elev=90, dist=5),
]
view_dict = dict(zip(views, view_params))
volumes = [pymaid.get_volume(v) for v in volume_names]
def set_view_params(ax, azim=-90, elev=0, dist=5):
ax.azim = azim
ax.elev = elev
ax.dist = dist
set_axes_equal(ax)
def plot_volumes(ax):
pymaid.plot2d(volumes, ax=ax, method="3d")
for c in ax.collections:
if isinstance(c, Poly3DCollection):
c.set_alpha(0.03)
def add_subplot(row, col, projection=None):
ax = fig.add_subplot(gs[row, col], projection=projection)
def get_volume_pruned_neurons_by_skid(skids,
volume_id,
mode='fele',
resample=0,
only_keep_largest_fragment=False,
verbose=False,
remote_instance=None):
"""
mode : 'fele' - Keep all parts of the neuron between its primary
neurite's First Entry to and Last Exit from the volume.
So if a segment of the primary neurite leaves and then
re-enters the volume, that segment is not removed.
'strict' - All nodes outside the volume are pruned.
resample : If set to a positive value, the neuron will be resampled before
pruning to have treenodes placed every `resample` nanometers. If
left at 0, resampling is not performed.
In both cases, if a branch point is encountered before the first entry or
last exit, that branch point is used as the prune point.
"""
if remote_instance is None:
remote_instance = source_project
#if exit_volume_id is None:
# exit_volume_id = entry_volume_id
neurons = pymaid.get_neuron(skids, remote_instance=source_project)
if volume_id not in volumes:
try:
print(f'Pulling volume {volume_id} from project'
f' {remote_instance.project_id}.')
volumes[volume_id] = pymaid.get_volume(
volume_id, remote_instance=remote_instance)
except:
print(f"Couldn't find volume {volume_id} in project_id"
f" {remote_instance.project_id}! Exiting.")
raise
else:
print(f'Loading volume {volume_id} from cache.')
volume = volumes[volume_id]
if type(neurons) is pymaid.core.CatmaidNeuron:
neurons = pymaid.core.CatmaidNeuronList(neurons)
if resample > 0:
#TODO find the last node on the primary neurite and store its position
neurons.resample(
resample) # This throws out radius info except for root
#TODO find the new node closest to the stored node and set all nodes
#between that node and root to have radius 500
for neuron in neurons:
if 'pruned by vol' in neuron.neuron_name:
raise Exception(
'Volume pruning was requested for '
f' "{neuron.neuron_name}". You probably didn\'t mean to do'
' this since it was already pruned. Exiting.')
continue
print(f'Pruning neuron {neuron.neuron_name}')
if mode == 'fele':
"""
First, find the most distal primary neurite node. Then, walk
backward until either finding a node within the volume or a branch
point. Prune distal to one distal to that point (so it only gets
the primary neurite and not the offshoot).
Then, start from the primary neurite node that's a child of the
soma node, and walk forward (how?) until finding a node within the
volume or a branch point. Prune proximal to that.
"""
nodes = neuron.nodes.set_index('node_id')
# Find end of the primary neurite
nodes['has_fat_child'] = False
for tid in nodes.index:
if nodes.at[tid, 'radius'] == PRIMARY_NEURITE_RADIUS:
parent = nodes.at[tid, 'parent_id']
nodes.at[parent, 'has_fat_child'] = True
is_prim_neurite_end = (~nodes['has_fat_child']) & (
nodes['radius'] == PRIMARY_NEURITE_RADIUS)
prim_neurite_end = nodes.index[is_prim_neurite_end]
if len(prim_neurite_end) is 0:
raise ValueError(f"{neuron.neuron_name} doesn't look like a"
" motor neuron. Exiting.")
elif len(prim_neurite_end) is not 1:
raise ValueError('Multiple primary neurite ends for'
f' {neuron.neuron_name}: {prim_neurite_end}.'
'\nExiting.')
nodes['is_in_vol'] = navis.in_volume(nodes, volume)
# Walk backwards until at a point inside the volume, or at a branch
# point
current_node = prim_neurite_end[0]
parent_node = nodes.at[current_node, 'parent_id']
while (nodes.at[parent_node, 'type'] != 'branch'
and not nodes.at[parent_node, 'is_in_vol']):
current_node = parent_node
if verbose: print(f'Walk back to {current_node}')
parent_node = nodes.at[parent_node, 'parent_id']
if verbose: print(f'Pruning distal to {current_node}')
neuron.prune_distal_to(current_node, inplace=True)
# Start at the first primary neurite node downstream of root
current_node = nodes.index[
(nodes.parent_id == neuron.root[0])
#& (nodes.radius == PRIMARY_NEURITE_RADIUS)][0]
& (nodes.radius > 0)][0]
#Walking downstream is a bit slow, but probably acceptable
while (not nodes.at[current_node, 'is_in_vol']
and nodes.at[current_node, 'type'] == 'slab'):
current_node = nodes.index[nodes.parent_id == current_node][0]
if verbose: print(f'Walk forward to {current_node}')
if not nodes.at[current_node, 'is_in_vol']:
input('WARNING: Hit a branch before hitting the volume for'
f' neuron {neuron.neuron_name}. This is unusual.'
' Press enter to acknowledge.')
if verbose: print(f'Pruning proximal to {current_node}')
neuron.prune_proximal_to(current_node, inplace=True)
elif mode == 'strict':
neuron.prune_by_volume(volume) #This does in-place pruning
if neuron.n_skeletons > 1:
if only_keep_largest_fragment:
print('Neuron has multiple disconnected fragments after'
' pruning. Will only keep the largest fragment.')
frags = morpho.break_fragments(neuron)
neuron.nodes = frags[frags.n_nodes == max(
frags.n_nodes)][0].nodes
#print(neuron)
#else, the neuron will get healed and print a message about being
#healed during upload_neuron, so nothing needs to be done here.
if mode == 'fele':
neuron.annotations.append(
f'pruned (first entry, last exit) by vol {volume_id}')
elif mode == 'strict':
neuron.annotations.append(f'pruned (strict) by vol {volume_id}')
neuron.neuron_name = neuron.neuron_name + f' - pruned by vol {volume_id}'
if verbose: print('\n')
return neurons
