def plot_3D(self, type, fname):
x = self.data['XWIN']
y = self.data['YWIN']
oceta = self.data['O-Ceta']
oxi = self.data['O-Cxi']
resids = [(((oceta[i]**2) + (oxi[i]**2))**.5)
for i in range(len(oceta))]
if type == 'trisurf':
z = resids
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.set_xlabel('XWIN')
ax.set_ylabel('YWIN')
ax.set_zlabel('magnitude of residual')
ax.plot_trisurf(x, y, z, cmap='magma')
plt.savefig(os.path.join(self.directory, fname + '.png'))
plt.show()
elif type == 'quiver':
x = np.array(x)
y = np.array(y)
over = self.searchhighestresids(90)
#x = [self.data['XWIN'][i] for i in over]
#y = [self.data['YWIN'][i] for i in over]
z = np.array(resids)
u = np.array(self.data['O-Ceta'])
v = np.array(self.data['O-Cxi'])
w = np.array([0 for i in range(len(v))])
p3.clear()
quiver = p3.quiver(x, y, z, u, v, w, size=3)
#p3.savefig(os.path.join(self.directory, fname + '.png'))
p3.show()
def plot_mesh(value_mesh_list, w1_mesh, w2_mesh, save, show_box, show_axes):
ipv.clear()
figs = []
for mesh in value_mesh_list:
fig = ipv.pylab.figure()
fig.camera.up = (0, 0, 1)
fig.camera.position = (-2, 1, -0.5)
fig.camera_control = "trackball"
if not show_axes:
ipv.style.box_off()
else:
ipv.xlabel("w1")
ipv.ylabel("w2")
ipv.zlabel("f_lambda")
if not show_box:
ipv.pylab.style.axes_off()
ipv.pylab.zlim(mesh.min(), mesh.max())
ptp = (mesh - mesh.min()).ptp()
col = []
for m in mesh:
znorm = (m - m.min()) / (m.max() - m.min() + 1e-8)
color = np.asarray([[interpolate(darker(colors_alpha[0], 1.5 * x + 0.75),
darker(colors_alpha[1], 1.5 * (1 - x) + 0.75), x) for x in y] for y in
znorm])
col.append(color)
color = np.array(col)
surf = ipv.plot_surface(w1_mesh, w2_mesh, mesh, color=color[..., :3])
ipv.animation_control(surf, interval=400)
figs.append(fig)
ipv.show()
if save:
ipv.save(f'renders/{datetime.datetime.now().strftime("%m%d-%H%M")}.html', offline=True)
return figs
def browse_history(history,
coords=["x", "y", "z"],
start=None,
stop=None,
size=None,
**draw_specs_kw):
times = history.slice(start, stop, size)
num_frames = times.size
draw_specs = sheet_spec()
spec_updater(draw_specs, draw_specs_kw)
sheet = history.retrieve(0)
ipv.clear()
fig, meshes = sheet_view(sheet, coords, **draw_specs_kw)
lim_inf = sheet.vert_df[sheet.coords].min().min()
lim_sup = sheet.vert_df[sheet.coords].max().max()
ipv.xyzlim(lim_inf, lim_sup)
def set_frame(i=0):
fig.animation = 0
t = times[i]
meshes = _get_meshes(history.retrieve(t), coords, draw_specs)
update_view(fig, meshes)
ipv.show()
interact(set_frame, i=(0, num_frames - 1))
def complete(final_solution: Solution,
correct_solution: Solution = None) -> None:
"""
Will print result in 3D world
:return: Noting
"""
# init of plot-output #1
figure = plot.figure()
axes = figure.add_subplot(111, projection='3d')
for part in final_solution.partitions:
color = random.choice(list_of_colors)
marker = random.choice(list_of_marker)
for p in part:
axes.scatter(p.x, p.y, p.z, marker=marker, c=color)
axes.set_xlabel("X Achse")
axes.set_ylabel("Y Achse")
axes.set_zlabel("Z Achse")
plot.show()
# init 3D view
ipv.current.containers.clear()
ipv.current.figures.clear()
extra_figures = list()
# create correct solution
if correct_solution is not None:
figure_correct = ipv.figure("correct")
ipv.pylab.xyzlim(-1, 11)
for part in correct_solution.partitions:
marker = random.choice(list_of_IPYVmarker)
color = random.choice(list_of_colors)
ipv.scatter(*convert.partition_to_IpyVolume(part),
marker=marker,
color=color)
extra_figures.append(figure_correct)
figure_result = ipv.figure("result")
container = ipv.gcc()
ipv.current.container = widgets.HBox(container.children)
ipv.current.containers["result"] = ipv.current.container
# crate computed solution
for part in final_solution.partitions:
marker = random.choice(list_of_IPYVmarker)
color = random.choice(list_of_colors)
ipv.scatter(*convert.partition_to_IpyVolume(part),
marker=marker,
color=color)
ipv.pylab.xyzlim(-1, 11)
ipv.current.container.children = list(
ipv.current.container.children) + extra_figures
ipv.show()
# save in a separate file
ipv.save("example.html")
# destroy 3D views
ipv.clear()
def plot_clusters(self, threshold, rcut=28, size=5.):
ipv.clear()
s = self.trace <= threshold
xyz = self.stress_coord[s]
x, y, z = xyz[:, 0], xyz[:, 1], xyz[:, 2]
clustering = DBSCAN(eps=rcut, min_samples=1).fit(xyz)
labels = np.unique(clustering.labels_)
counts, edges = np.histogram(clustering.labels_,
bins=np.arange(labels.min(),
labels.max() + 1))
largest = edges[counts.argmax()]
color_dict = {}
for l in labels:
color_dict[l] = tuple(np.random.uniform(0, 1, size=3))
color_dict[largest] = (1, 1, 1)
colors = np.array([color_dict[c] for c in clustering.labels_])
color = np.array([(x - x.min()) / x.ptp(),
np.ones_like(x),
np.ones_like(x)]).T
ipv.scatter(x, y, z, size=size, marker="sphere", color=colors)
ipv.show()
def scatter_nd(xs: t.Tensor):
xs = full_detach(xs)
if xs.shape[1] == 1:
plt.hist(xs[:, 0], bins=100)
elif xs.shape[1] == 2:
plt.scatter(*xs.T, s=.1)
elif xs.shape[1] == 3:
ipv.clear()
ipv.scatter(*xs.T)
ipv.show()
else:
assert False, f"Wrong dimensionality: {xs.shape=}"
def __init__(self, eptm, **draw_specs):
plt.ioff()
ipv.clear()
self.fig3D, self.mesh = sheet_view(eptm, mode="3D", **draw_specs)
self.graph_widget = widgets.Output()
with self.graph_widget:
self.fig2D, (self.ax0, self.ax1) = plt.subplots(
2, 1, sharey=True, sharex=True
)
apical = eptm.get_sub_sheet("apical")
apical.reset_index()
apical.reset_topo()
apical.face_df["visible"] = apical.face_df["y"] > 0
_ = sheet_view(
apical,
mode="2D",
coords=["z", "x"],
ax=self.ax0,
edge={"visible": False},
face={"visible": True, "color": apical.face_df.area},
)
basal = eptm.get_sub_sheet("basal")
basal.reset_index()
basal.reset_topo()
basal.face_df["visible"] = basal.face_df["y"] > 0
_ = sheet_view(
basal,
mode="2D",
coords=["z", "x"],
ax=self.ax1,
edge={"visible": False},
face={"visible": True, "color": basal.face_df.area},
)
self.ax0.set_title("Apical mesh")
self.ax1.set_title("Basal mesh")
self.ax0.set_axis_off()
self.ax1.set_axis_off()
self.fig2D.set_size_inches(5, 8)
plt.close(self.fig2D)
display(self.fig2D)
super().__init__([self.fig3D, self.graph_widget])
def test_sheet_view():
sheet = Sheet("test", *three_faces_sheet())
SheetGeometry.update_all(sheet)
face_spec = {
"color": pd.Series(range(3)),
"color_range": (0, 3),
"visible": True,
"colormap": "Blues",
"epsilon": 0.1,
}
color = pd.DataFrame(np.zeros((sheet.Ne, 3)),
index=sheet.edge_df.index,
columns=["R", "G", "B"])
color.loc[0, "R"] = 0.8
edge_spec = {"color": color, "visible": True}
fig, (edge_mesh, face_mesh) = sheet_view(sheet,
face=face_spec,
edge=edge_spec)
assert face_mesh.color.shape == (39, 3)
assert face_mesh.triangles.shape == (18, 3)
assert face_mesh.lines is None
assert edge_mesh.triangles is None
assert edge_mesh.lines.shape == (18, 2)
sheet.face_df["visible"] = False
sheet.face_df.loc[0, "visible"] = True
ipv.clear()
fig, (edge_mesh, face_mesh) = sheet_view(sheet,
face=face_spec,
edge=edge_spec)
assert face_mesh.triangles.shape == (6, 3)
ipv.clear()
edge_spec = {"color": lambda sheet: sheet.edge_df["dx"], "visible": True}
face_spec = {"color": lambda sheet: sheet.face_df["area"], "visible": True}
fig, (edge_mesh, face_mesh) = sheet_view(sheet,
face=face_spec,
edge=edge_spec)
assert face_mesh.color.shape == (13, 3)
def show_attention_volume(
scan,
attention_maps,
tasks=[],
show_ct=True,
show_pet=False,
downscale=1,
exam_id="",
movie_dir=None,
colormap=None,
flip_axes=None,
):
colors = plt.get_cmap("Set1").colors
widgets = []
def add_controls(volume, name, color=None):
"""
"""
level = FloatLogSlider(
base=10, min=-0.5, max=0, step=0.01, description=f"{name} level:"
)
opacity = FloatLogSlider(
base=10, min=-2, max=0.6, step=0.01, description=f"{name} opacity:"
)
jslink((volume.tf, "level1"), (level, "value"))
jslink((volume.tf, "level2"), (level, "value"))
jslink((volume.tf, "level3"), (level, "value"))
jslink((volume, "opacity_scale"), (opacity, "value"))
button = Button(description=name)
if color is not None:
button.style.button_color = color
controls = HBox([button, level, opacity])
widgets.append(controls)
ipv.clear()
f = ipv.figure()
for idx, task in enumerate(tasks):
attention_map = attention_maps[task]
attention_map = attention_map.cpu().detach().numpy()
attention_map = np.mean(attention_map, axis=1)
attention_map = attention_map[0, :, ::].squeeze()
# scale volume up
scan_shape = scan[:, :, :, :, 0].squeeze().shape
for dim_idx, scan_dim in enumerate(scan_shape):
repeat = np.round(scan_dim / attention_map.shape[dim_idx])
attention_map = np.repeat(attention_map, repeat, axis=dim_idx)
# set color
if colormap is None:
color = np.array(colors[idx % len(colors)])
else:
color = np.array(colormap[task]) / 256
opacity = color * 0.2
color = "#%02x%02x%02x" % tuple(map(int, color * 255))
attention_map = attention_map[::downscale, ::downscale, ::downscale]
if flip_axes is not None:
for flip_axis in flip_axes:
attention_map = np.flip(attention_map, axis=flip_axis)
saliency_vol = ipv.volshow(
attention_map,
level=(1.0, 1.0, 1.0),
opacity=opacity,
controls=True,
extent=[
[0, attention_map.shape[0]],
[0, attention_map.shape[1]],
[0, attention_map.shape[2]],
],
)
add_controls(saliency_vol, name=task, color=color)
if show_ct:
ct = scan[:, :, :, :, 0].squeeze()
ct = ct[::downscale, ::downscale, ::downscale]
if flip_axes is not None:
for flip_axis in flip_axes:
ct = np.flip(ct, axis=flip_axis)
ct_vol = ipv.volshow(
ct,
downscale=100,
level=(0.7, 0.7, 0.7),
opacity=(0.2, 0.2, 0.2),
extent=[[0, ct.shape[0]], [0, ct.shape[1]], [0, ct.shape[2]]],
)
add_controls(ct_vol, name="ct")
if show_pet:
pet = scan[:, :, :, :, 1].squeeze()
pet = pet[::downscale, ::downscale, ::downscale]
if flip_axes is not None:
for flip_axis in flip_axes:
pet = np.flip(pet, axis=flip_axis)
color = np.array(colors[0 % len(colors)])
opacity = color * 0.2
pet_vol = ipv.volshow(
pet, downscale=100, level=(0.7, 0.7, 0.7), opacity=opacity
)
add_controls(pet_vol, name="pet")
# ipv.xlim(0,attention_map.shape[0])
# ipv.ylim(0,attention_map.shape[1])
# ipv.zlim(0,attention_map.shape[2])
# ipv.squarelim()
# f.camera.up = (-1, -1, -1)
# f.camera.lookAt = (0, 0, 0)
ipv.pylab.view(0, 0, 0)
if movie_dir is not None:
ipv.pylab.movie(f=os.path.join(movie_dir, f"{exam_id}.gif"))
ipv.style.use("minimal")
widgets.append(ipv.gcf())
return VBox(widgets)
def _default_plotter(self, **kwargs):
"""
Basic plot function to be used if no custom function is specified.
This is called by plot, you shouldn't call it directly.
"""
self.lengths = np.array([length(x) for x in self.lines2use_])
if not ("grayscale" in kwargs and kwargs["grayscale"]):
self.colors = np.array([color(x) for x in self.lines2use_])
else:
self.colors = np.zeros((len(self.lines2use_), 3), dtype=np.float16)
self.colors[:] = [0.5, 0.5, 0.5]
self.state = {"threshold": 0, "indices": []}
width = 600
height = 600
perc = 80
if "width" in kwargs:
width = kwargs["width"]
if "height" in kwargs:
height = kwargs["height"]
if "percentile" in kwargs:
perc = kwargs["percentile"]
ipv.clear()
fig = ipv.figure(width=width, height=height)
self.state["fig"] = fig
with fig.hold_sync():
x, y, z, indices, colors, self.line_pointers = self._create_mesh()
limits = np.array(
[
min([x.min(), y.min(), z.min()]),
max([x.max(), y.max(), z.max()]),
]
)
mesh = ipv.Mesh(x=x, y=y, z=z, lines=indices, color=colors)
fig.meshes = [mesh]
if "style" not in kwargs:
fig.style = {
"axes": {
"color": "black",
"label": {"color": "black"},
"ticklabel": {"color": "black"},
"visible": False,
},
"background-color": "white",
"box": {"visible": False},
}
else:
fig.style = kwargs["style"]
ipv.pylab._grow_limits(limits, limits, limits)
fig.camera_fov = 1
ipv.show()
interact(
self._plot_lines,
state=fixed(self.state),
threshold=widgets.FloatSlider(
value=np.percentile(self.lengths, perc),
min=self.lengths.min() - 1,
max=self.lengths.max() - 1,
continuous_update=False,
),
)
def visualize_objects(self,
train_idxs=None,
test_idxs=None,
max_time_steps=None,
train_sim=False,
test_sim=True,
train_marker_size=4,
test_marker_size=6):
"""
train_idxs - numpy array из индексов объектов (sat_id) тренировочной выборки,
которые надо визуализировать. Если None - берем все объекты
test_idxs - numpy array из индексов объектов (sat_id) тренировочной выборки,
которые надо визуализировать. Если None - берем train_idxs
max_time_steps - максимальное количество измерений для одного объекта (sat_id)
train_sim - если False - используем реальные данные (колонки без приставки sim)
test_sim - если False - используем реальные (предсказанные) данные
(для этого в датафрейм нужно добавить приставки колонки с предсказаниями без приставки sim,
как в трейне)
"""
ipv.clear()
if train_idxs is None:
train_idxs = np.array(self.train_data['sat_id'].unique())
if test_idxs is None:
test_idxs = train_idxs
if max_time_steps is None:
max_time_steps_train = self.train_data.groupby(
'sat_id').count()['epoch'].max()
max_time_steps_test = self.test_data.groupby(
'sat_id').count()['epoch'].max()
max_time_steps = max(max_time_steps_train, max_time_steps_test)
## подготовка трейна и теста
stream_train = self._prepare_stream('train', train_idxs,
max_time_steps, train_sim)
stream_test = self._prepare_stream('test', test_idxs, max_time_steps,
test_sim)
## визуализация
stream = np.dstack([stream_train[:, :, :], stream_test[:, :, :]])
selected = stream_train.shape[2] + test_idxs
self.q = ipv.quiver(*stream[:, :, :],
color="green",
color_selected='red',
size=train_marker_size,
size_selected=test_marker_size,
selected=selected)
## Чтобы можно было менять размеры и цвета
size = FloatSlider(min=1, max=15, step=0.2)
size_selected = FloatSlider(min=1, max=15, step=0.2)
color = ColorPicker()
color_selected = ColorPicker()
jslink((self.q, 'size'), (size, 'value'))
jslink((self.q, 'size_selected'), (size_selected, 'value'))
jslink((self.q, 'color'), (color, 'value'))
jslink((self.q, 'color_selected'), (color_selected, 'value'))
# ipv.style.use('seaborn-darkgrid')
ipv.animation_control(self.q, interval=75)
ipv.show(
[VBox([ipv.gcc(), size, size_selected, color, color_selected])])
def ipv_prepare(ipv, dark_background=True):
ipv.clear()
if dark_background is True:
ipv.style.set_style_dark()
def _default_plotter(self, **kwargs):
"""
Basic plot function to be used if no custom function is specified.
This is called by plot, you shouldn't call it directly.
"""
self.lengths = np.array([length(x) for x in self.lines2use_])
if not ('grayscale' in kwargs and kwargs['grayscale']):
self.colors = np.array([color(x) for x in self.lines2use_])
else:
self.colors = np.zeros((len(self.lines2use_), 3), dtype=np.float16)
self.colors[:] = [0.5, 0.5, 0.5]
self.state = {'threshold': 0, 'indices': []}
width = 600
height = 600
perc = 80
if 'width' in kwargs:
width = kwargs['width']
if 'height' in kwargs:
height = kwargs['height']
if 'percentile' in kwargs:
perc = kwargs['percentile']
ipv.clear()
fig = ipv.figure(width=width, height=height)
self.state['fig'] = fig
with fig.hold_sync():
x, y, z, indices, colors, self.line_pointers = self._create_mesh()
limits = np.array([
min([x.min(), y.min(), z.min()]),
max([x.max(), y.max(), z.max()])
])
mesh = ipv.Mesh(x=x, y=y, z=z, lines=indices, color=colors)
fig.meshes = [mesh]
if 'style' not in kwargs:
fig.style = {
'axes': {
'color': 'black',
'label': {
'color': 'black'
},
'ticklabel': {
'color': 'black'
},
'visible': False
},
'background-color': 'white',
'box': {
'visible': False
}
}
else:
fig.style = kwargs['style']
ipv.pylab._grow_limits(limits, limits, limits)
fig.camera_fov = 1
ipv.show()
interact(self._plot_lines,
state=fixed(self.state),
threshold=widgets.FloatSlider(value=np.percentile(
self.lengths, perc),
min=self.lengths.min() - 1,
max=self.lengths.max() - 1,
continuous_update=False))
def clear():
"""Call ipyvolume.clear()."""
ipv.clear()
def plot_multiple_proofread_neuron(
segment_ids,
split_indexes = None,
cell_type = None,
original_mesh = None,
plot_proofread_skeleton = False,
proofread_mesh_color = "green",
proofread_mesh_alpha = None,
proofread_skeleton_color = "black",
plot_nucleus = True,
nucleus_size = 1,
nucleus_color = "proofread_mesh_color",
plot_synapses = True,
synapses_size = 0.05,
synapse_plot_type = "spine_bouton",#"compartment"# "valid_error"
synapse_compartments = None,
synapse_spine_bouton_labels = None,
plot_error_synapses = False,
valid_synapses_color = "orange",
error_synapses_color = "aliceblue",
synapse_queries = None,
synapse_queries_colors = None,
plot_error_mesh = False,
error_mesh_color = "black",
error_mesh_alpha = 1,
compartments = None,
#compartments = ["apical_total"]
#compartments= ["axon","dendrite"]
plot_compartment_meshes = True,
compartment_mesh_alpha = 0.3,
plot_compartment_skeletons = True,
# for adding new scatter points:
scatters = None,
scatter_size = 0.2,
scatters_colors = "yellow",
verbose = False,
print_spine_colors = True,
print_compartment_colors = True,
):
import ipyvolume as ipv
ipv.clear()
su.ignore_warnings()
segment_ids = nu.convert_to_array_like(segment_ids)
if verbose:
print(f"segment_ids = {segment_ids}")
proofread_mesh_color = nu.convert_to_array_like(proofread_mesh_color)
if len(proofread_mesh_color) != len(segment_ids):
proofread_mesh_color = proofread_mesh_color*len(segment_ids)
if split_indexes is None:
split_indexes = [0]*len(segment_ids)
for j,(seg_id,sp_idx,proof_col) in enumerate(zip(segment_ids,
split_indexes,
proofread_mesh_color,
)):
if verbose:
print(f"\n{seg_id}_{sp_idx}: {proof_col}")
curr_scatters = None
curr_scatter_size = None
curr_scatters_colors = None
if j == len(segment_ids)-1:
show_at_end = True
append_figure = True
print_spine_colors_curr = print_spine_colors
print_compartment_colors_curr = print_compartment_colors
curr_scatters = scatters
curr_scatter_size = scatter_size
curr_scatters_colors = scatters_colors
elif j == 0:
show_at_end = False
append_figure = False
print_spine_colors_curr = False
print_compartment_colors_curr = False
else:
show_at_end = False
append_figure = True
print_spine_colors_curr = False
print_compartment_colors_curr = False
#print(f"{curr_scatters,curr_scatter_size,curr_scatters_colors}")
pv.plot_proofread_neuron(
seg_id,
sp_idx,
cell_type = cell_type,
original_mesh = original_mesh,
plot_proofread_skeleton=plot_proofread_skeleton,
proofread_mesh_color = proof_col,
proofread_mesh_alpha = proofread_mesh_alpha,
proofread_skeleton_color = proofread_skeleton_color,
plot_nucleus = plot_nucleus,
nucleus_size = nucleus_size,
nucleus_color = nucleus_color,
plot_synapses = plot_synapses,
synapses_size = synapses_size,
synapse_plot_type = synapse_plot_type,#"compartment"# "valid_error"
synapse_compartments = synapse_compartments,
synapse_spine_bouton_labels = synapse_spine_bouton_labels,
plot_error_synapses = plot_error_synapses,
valid_synapses_color = valid_synapses_color,
error_synapses_color = error_synapses_color,
synapse_queries = synapse_queries,
synapse_queries_colors = synapse_queries_colors,
plot_error_mesh = plot_error_mesh,
error_mesh_color = error_mesh_color,
error_mesh_alpha = error_mesh_alpha,
compartments = compartments,
#compartments = ["apical_total"]
#compartments= ["axon","dendrite"]
plot_compartment_meshes = plot_compartment_meshes,
compartment_mesh_alpha = compartment_mesh_alpha,
plot_compartment_skeletons = plot_compartment_skeletons,
verbose = verbose,
print_spine_colors = print_spine_colors_curr,
print_compartment_colors = print_compartment_colors_curr,
show_at_end = show_at_end,
append_figure = append_figure,
scatters = curr_scatters,
scatter_sizes = curr_scatter_size,
scatters_colors = curr_scatters_colors,
)
def show_saliency_volume(
saliency_maps, tasks=[], show_ct=True, show_pet=False, colormap=None
):
colors = plt.get_cmap("Set1").colors
widgets = []
def add_controls(volume, name, color=None):
"""
"""
level = FloatLogSlider(
base=10, min=-0.5, max=0, step=0.0002, description=f"{name} level:"
)
opacity = FloatLogSlider(
base=10, min=-2, max=1.0, step=0.01, description=f"{name} opacity:"
)
jslink((volume.tf, "level1"), (level, "value"))
jslink((volume.tf, "level2"), (level, "value"))
jslink((volume.tf, "level3"), (level, "value"))
jslink((volume, "opacity_scale"), (opacity, "value"))
button = Button(description=name)
if color is not None:
button.style.button_color = color
controls = HBox([button, level, opacity])
widgets.append(controls)
ipv.clear()
ipv.figure()
data = {}
for idx, task in enumerate(tasks):
saliency_map = saliency_maps[task]
scan_grad = saliency_map["scan_grad"]
scan_grad = torch.max(scan_grad, dim=4)[0].unsqueeze(0)
scan_grad = (
scan_grad.squeeze()
) # torch.nn.functional.max_pool3d(scan_grad, kernel_size=(7, 21, 21)).squeeze()
scan_grad = scan_grad.numpy()
scan_grad = scan_grad - scan_grad.min()
scan_grad /= scan_grad.max()
saliency_tensor = scan_grad
saliency_tensor -= saliency_tensor.min()
saliency_tensor /= saliency_tensor.max()
if colormap is None:
color = np.array(colors[idx % len(colors)])
else:
color = np.array(colormap[task]) / 256
opacity = color * 0.2
color = "#%02x%02x%02x" % tuple(map(int, color * 256))
saliency_vol = ipv.volshow(
saliency_tensor,
downscale=100,
level=(0.5, 0.5, 0.5),
opacity=opacity,
controls=True,
)
data[task] = saliency_tensor
add_controls(saliency_vol, name=task, color=color)
scan = saliency_map["scan"].numpy()
if show_ct:
ct = scan[:, :, :, :, 0].squeeze()
data["ct"] = ct
ct_vol = ipv.volshow(
ct, downscale=100, level=(1.0, 1.0, 1.0), opacity=(0.2, 0.2, 0.2)
)
add_controls(ct_vol, name="ct")
if show_pet:
pet = scan[:, :, :, :, 1].squeeze()
data["pet"] = pet
opacity = (np.array((228, 26, 28)) / 256) * 0.2
pet_vol = ipv.volshow(
pet, downscale=100, level=(0.7, 0.7, 0.7), opacity=opacity
)
add_controls(pet_vol, name="pet")
ipv.style.use("minimal")
widgets.append(ipv.gcf())
return VBox(widgets), data
def plot_proofread_neuron(
segment_id,
split_index = 0,
cell_type = None,
original_mesh = None,
plot_proofread_skeleton = False,
proofread_mesh_color = "green",
proofread_mesh_alpha = None,
proofread_skeleton_color = "black",
plot_nucleus = True,
nucleus_size = 1,
nucleus_color = "proofread_mesh_color",#"black",
plot_synapses = True,
synapses_size = 0.05,
synapse_plot_type = "spine_bouton",#"compartment"# "valid_error" #"valid_presyn_postsyn"
synapse_compartments = None,
synapse_spine_bouton_labels = None,
plot_error_synapses = False,
valid_synapses_color = "orange",
error_synapses_color = "aliceblue",
synapse_queries = None,
synapse_queries_colors = None,
plot_error_mesh = False,
error_mesh_color = "black",
error_mesh_alpha = 1,
compartments = None,
#compartments = ["apical_total"]
#compartments= ["axon","dendrite"]
plot_compartment_meshes = True,
compartment_mesh_alpha = 0.3,
plot_compartment_skeletons = True,
verbose = False,
print_spine_colors = True,
print_compartment_colors = True,
#arguments for plotting more scatters
scatters = None,
scatter_sizes = 0.2,
scatters_colors = "yellow",
show_at_end = True,
append_figure = False,
):
"""
Purpose: Will plot the saved
proofread information of a neuron
Ex:
#trying on inhibitory
segment_id,split_index = (864691134917559306,0)
original_mesh = du.fetch_segment_id_mesh(segment_id)
pv.plot_proofread_neuron(
segment_id,
split_index,
original_mesh=original_mesh,
plot_error_mesh=False,
verbose = True)
"""
if not append_figure:
import ipyvolume as ipv
ipv.clear()
su.ignore_warnings()
if type(segment_id) == str:
segment_id,split_index = pv.segment_id_and_split_index_from_node_name(segment_id)
if verbose:
print(f"Plotting {segment_id}_{split_index} (nucleus_id={pv.nucleus_id_from_segment_id(segment_id,split_index)})")
if cell_type is None:
cell_type = pv.cell_type_from_segment_id(segment_id,split_index)
if verbose:
print(f"cell_type = {cell_type}")
if synapse_compartments is None:
synapse_compartments = apu.compartments_to_plot(cell_type)
if synapse_spine_bouton_labels is None:
synapse_spine_bouton_labels = spu.spine_bouton_labels_to_plot()
if compartments is None:
compartments = apu.compartments_to_plot(cell_type)
meshes = []
meshes_colors = []
skeletons = []
skeletons_colors = []
meshes_alpha = []
if scatters is not None:
scatters_colors = nu.convert_to_array_like(scatters_colors)
if len(scatters_colors) == 1:
scatters_colors = scatters_colors*len(scatters)
scatter_sizes = nu.convert_to_array_like(scatter_sizes)
if len(scatter_sizes) == 1:
scatter_sizes = scatter_sizes*len(scatters)
else:
scatters = []
scatters_colors = []
scatter_sizes = []
if original_mesh is None:
original_mesh = du.fetch_segment_id_mesh(segment_id)
compartment_color_dict = dict(valid_mesh=proofread_mesh_color)
proof_mesh,error_mesh = pv.fetch_proofread_mesh(segment_id,
split_index = split_index,
original_mesh=original_mesh,
return_error_mesh=True)
if plot_proofread_skeleton:
proof_skeleton = pv.fetch_proofread_skeleton(segment_id,
split_index,
plot_skeleton=False,
#original_mesh=original_mesh
)
else:
proof_skeleton = None
if plot_error_mesh:
meshes.append(error_mesh)
meshes_colors.append(error_mesh_color)
meshes_alpha.append(error_mesh_alpha)
compartment_color_dict["error_mesh"] = error_mesh_color
if plot_nucleus:
nuc_center = pv.nucleus_center_from_segment_id(segment_id,
split_index)
if nucleus_color == "proofread_mesh_color":
nucleus_color = proofread_mesh_color
if nuc_center is None:
print(f"No nucleus to plot")
else:
scatters += [nuc_center.reshape(-1,3)]
scatters_colors += [nucleus_color]
scatter_sizes += [nucleus_size]
#get the synapse groups
if plot_synapses:
synapses_objs = pv.syanpse_objs_from_segment_id(segment_id,split_index)
(syn_scatters,
syn_colors,
syn_sizes) = syu.synapse_plot_items_by_type_or_query(
synapses_objs,
synapses_size = synapses_size,
synapse_plot_type = synapse_plot_type,#"compartment"# "valid_error"
synapse_compartments = synapse_compartments,
synapse_spine_bouton_labels = synapse_spine_bouton_labels,
plot_error_synapses = plot_error_synapses,
valid_synapses_color = valid_synapses_color,
error_synapses_color = error_synapses_color,
synapse_queries = synapse_queries,
synapse_queries_colors = synapse_queries_colors,
verbose = verbose,
print_spine_colors = print_spine_colors)
scatters += syn_scatters
scatters_colors += syn_colors
scatter_sizes += syn_sizes
if compartments is not None and len(compartments) > 0:
comp_colors = apu.colors_from_compartments(compartments)
if plot_compartment_meshes:
comp_meshes = pv.fetch_compartments_meshes(compartments,
segment_id,
split_index,
original_mesh = original_mesh,
)
meshes += comp_meshes
meshes_colors += comp_colors
meshes_alpha += [compartment_mesh_alpha]*len(comp_meshes)
if plot_compartment_skeletons:
comp_sk = pv.fetch_compartments_skeletons(compartments,
segment_id,
split_index,
)
skeletons += comp_sk
skeletons_colors += comp_colors
compartment_color_dict.update({k:v for k,v in zip(compartments,comp_colors)})
if print_compartment_colors:
print(f"\nCompartment Colors:")
for k,v in compartment_color_dict.items():
print(f" {k}:{v}")
# print(f"proof_mesh== {proof_mesh}")
# print(f"proof_skeleton = {proof_skeleton}")
# if len(proof_skeleton) == 0:
# proof_skeleton = None
# print(f"skeletons = {skeletons}")
# print(f"meshes = {meshes}")
# print(f"scatters = {scatters}")
nviz.plot_objects(main_mesh = proof_mesh,
main_mesh_alpha=proofread_mesh_alpha,
main_mesh_color=proofread_mesh_color,
main_skeleton=proof_skeleton,
main_skeleton_color=proofread_skeleton_color,
skeletons=skeletons,
skeletons_colors=skeletons_colors,
meshes=meshes,
meshes_colors=meshes_colors,
mesh_alpha=meshes_alpha,
scatters=scatters,
scatter_size=scatter_sizes,
scatters_colors=scatters_colors,
show_at_end = show_at_end,
append_figure = append_figure,
)
