def test_full_cell_with_links(full_cell_mesh, full_cell_merge_log, tmp_path,
monkeypatch):
class MyChunkedGraph(object):
def __init__(a, **kwargs):
pass
def get_merge_log(self, atomic_id):
return full_cell_merge_log
monkeypatch.setattr(trimesh_io.trimesh_repair.chunkedgraph,
'ChunkedGraphClient', MyChunkedGraph)
full_cell_mesh.add_link_edges('test', 5)
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh)
eval_actor_image([mesh_actor],
'full_cell_with_links.png',
tmp_path,
scale=1)
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh,
opacity=1.0,
show_link_edges=True)
m1 = np.array(full_cell_merge_log['merge_edge_coords'][0])
ctr = np.mean(m1, axis=0)
camera = trimesh_vtk.oriented_camera(ctr,
backoff=5,
up_vector=(0, 0, 1),
backoff_vector=(0, 1, 0))
eval_actor_image([mesh_actor],
'full_cell_show_links.png',
tmp_path,
camera=camera)
def test_full_cell_with_links(full_cell_mesh, full_cell_merge_log, tmp_path):
full_cell_mesh.add_link_edges(merge_log=full_cell_merge_log,
base_resolution=[1, 1, 1])
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh)
eval_actor_image([mesh_actor],
'full_cell_with_links.png',
tmp_path,
scale=1)
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh,
opacity=1.0,
show_link_edges=True)
m1 = np.array(full_cell_merge_log['merge_edge_coords'][0])
ctr = np.mean(m1, axis=0)
camera = trimesh_vtk.oriented_camera(ctr,
backoff=5,
up_vector=(0, 0, 1),
backoff_vector=(0, 1, 0))
eval_actor_image([mesh_actor],
'full_cell_show_links.png',
tmp_path,
camera=camera)
def test_vertex_colors(full_cell_mesh, tmp_path):
d = np.linalg.norm(full_cell_mesh.vertices - full_cell_mesh.centroid,
axis=1)
cmap = np.array(cm.viridis.colors)
vclrs = trimesh_vtk.values_to_colors(d, cmap, 0, 80000)
clr_mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh,
vertex_colors=vclrs,
opacity=1.0)
eval_actor_image([clr_mesh_actor], 'full_cell_colors.png', tmp_path)
vclrs = trimesh_vtk.values_to_colors(d, cmap)
clr_mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh,
vertex_colors=vclrs,
opacity=1.0)
eval_actor_image([clr_mesh_actor], 'full_cell_auto_colors.png', tmp_path)
def set_vtk_window(self):
self.curId = get_filename(self)
filename_local = self.meshdirectoryline.text(
) + '/' + self.curId + '/' + 'locmesh_' + self.curFilenumber + '.off'
filename_spine = self.meshdirectoryline.text(
) + '/' + self.curId + '/' + 'spine_' + self.curFilenumber + '.off'
self.curUniqueId = self.curId + '_' + self.curFilenumber
if self.curUniqueId in self.LABELS.keys():
labeltext = "Current Label = %s" % self.LABELS[self.curUniqueId][0]
else:
labeltext = "No Current Label"
currentIndex = "Current Index: " + str(self.curIndex)
self.filenameline.setText(filename_local + ", " + filename_spine +
", " + labeltext + ", " + currentIndex)
print("this is filename")
print(filename_local + ", " + filename_spine)
# Create an actor for local mesh
local_mesh = trimesh.exchange.load.load_mesh(filename_local)
actor_local = trimesh_vtk.mesh_actor(local_mesh)
if self.curUniqueId in self.LABELS.keys():
actor_local.GetProperty().SetColor(0.0, 0.8, 0.0)
else:
actor_local.GetProperty().SetColor(1.0, 0.0, 0.0)
actor_local.GetProperty().SetOpacity(float(self.opacityline.text()))
print(actor_local.GetProperty().GetColor())
# Create an actor for spine mesh
spine_mesh = trimesh.exchange.load.load_mesh(filename_spine)
actor_spine = trimesh_vtk.mesh_actor(spine_mesh)
if self.curUniqueId in self.LABELS.keys():
actor_spine.GetProperty().SetColor(1.0, 0.0, 0.0)
else:
actor_spine.GetProperty().SetColor(0.0, 1.0, 0.0)
actor_spine.GetProperty().SetOpacity(float(self.opacityline.text()))
print(actor_spine.GetProperty().GetColor())
#render
self.ren.RemoveActor(self.curActor1)
self.ren.RemoveActor(self.curActor2)
self.curActor1 = actor_local
self.curActor2 = actor_spine
self.ren.AddActor(actor_local)
self.ren.AddActor(actor_spine)
self.ren.ResetCamera()
self.ren.SetBackground((.1, .1, .1))
self.iren.Initialize()
self.iren.Start()
def test_filter_two_points(full_cell_mesh, full_cell_soma_pt, tmp_path):
pt_down = full_cell_soma_pt + np.array([0, 50000, 0])
is_large = mesh_filters.filter_largest_component(full_cell_mesh)
full_cell_mesh = full_cell_mesh.apply_mask(is_large)
on_ais = mesh_filters.filter_two_point_distance(
full_cell_mesh, [full_cell_soma_pt, pt_down], 2000)
ais_mesh = full_cell_mesh.apply_mask(on_ais)
ais_actor = trimesh_vtk.mesh_actor(ais_mesh)
fname = 'full_cell_ais.png'
filepath = os.path.join(tmp_path, fname)
trimesh_vtk.render_actors([ais_actor],
back_color=(1, 1, 1),
do_save=True,
filename=filepath,
scale=1)
compare_img_to_test_file(filepath)
pts_end = np.array([full_cell_soma_pt, pt_down])
ais_sloppy = mesh_filters.filter_close_to_line(full_cell_mesh, pts_end,
4000)
assert (np.sum(ais_sloppy) == 12961)
def test_full_cell_movie(full_cell_mesh, full_cell_soma_pt, tmp_path):
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh)
camera = trimesh_vtk.oriented_camera(full_cell_soma_pt, backoff=100)
eval_actor_360([mesh_actor],
'full_cell_movie',
tmp_path,
camera=camera,
scale=1)
def test_ngl_state(full_cell_mesh, tmp_path):
with open('test/test_files/view_state.json', 'r') as fp:
ngl_state = json.load(fp)
camera = trimesh_vtk.camera_from_ngl_state(ngl_state)
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh)
eval_actor_image([mesh_actor],
'full_cell_ngl_view.png',
tmp_path,
camera=camera)
def test_basic_mesh_actor(cube_verts_faces):
verts, faces = cube_verts_faces
mesh = trimesh_io.Mesh(verts, faces, process=False)
mesh_actor = trimesh_vtk.mesh_actor(mesh)
mesh_actor.GetMapper().Update()
pd = mesh_actor.GetMapper().GetInput()
verts_out, faces_out, tmp = trimesh_vtk.poly_to_mesh_components(pd)
assert (np.all(verts == verts_out))
assert (np.all(faces_out == faces))
def loadmeshes(i):
spine1_file = r'Meshes/' + str(
spines_df['cell id'][i]) + '/' + str(i) + '/spine_' + str(
spines_df['spine 1 index'][i]) + '.off'
spinemesh1 = trimesh.exchange.load.load_mesh(spine1_file)
spinemesh1_mp = meshparty.trimesh_io.Mesh(vertices=spinemesh1.vertices,
faces=spinemesh1.faces)
spinemesh1_actor = trimesh_vtk.mesh_actor(spinemesh1,
color=(0, 0, 1),
opacity=0.2)
spine2_file = r'Meshes/' + str(
spines_df['cell id'][i]) + '/' + str(i) + '/spine_' + str(
spines_df['spine 2 index'][i]) + '.off'
spinemesh2 = trimesh.exchange.load.load_mesh(spine2_file)
spinemesh2_mp = meshparty.trimesh_io.Mesh(vertices=spinemesh2.vertices,
faces=spinemesh2.faces)
spinemesh2_actor = trimesh_vtk.mesh_actor(spinemesh2,
color=(1, 0, 0),
opacity=0.2)
return spinemesh1_mp, spinemesh2_mp, spinemesh1_actor, spinemesh2_actor
def set_vtk_window(self):
self.curId = self.allids[self.curIndex]
filename = self.meshdirectoryline.text() + '/' + self.curId + '.h5'
label_dir = self.labelline.text()
if len(label_dir) > 0:
label_file = os.path.join(label_dir, self.curId + ".h5")
with h5py.File(label_file, "r") as f:
labels = np.array(f['mask'])
print(labels.shape)
else:
labels = None
if self.curId in self.LABELS.keys():
labeltext = "Current Label = %s" % self.LABELS[self.curId]
else:
labeltext = "No Current Label"
self.filenameline.setText(filename + ", " + labeltext)
print("this is filename")
print(filename)
cvpath = 'https://storage.googleapis.com/neuroglancer/basil_v0/basil_full/seg-aug'
mm = trimesh_io.MeshMeta()
mesh = mm.mesh(filename=filename)
print(mesh.vertices.shape)
print(labels.dtype)
#mesh_poly = trimesh_vtk.trimesh_to_vtk(mesh.vertices, mesh.faces, mesh.mesh_edges)
#reader = vtk.vtkDataReader()
#reader.SetFileName(filename)
#mapper = vtk.vtkPolyDataMapper()
#mapper.SetInputConnection(mesh_poly.GetOutputPort())
# Create an actor
# actor = vtk.vtkActor()
actor = trimesh_vtk.mesh_actor(mesh,
vertex_colors=labels.astype(np.float64),
opacity=float(self.opacityline.text()))
if self.curId in self.LABELS.keys():
actor.GetProperty().SetColor(0.5, 0.5, 0.0)
else:
actor.GetProperty().SetColor(0.0, 0.5, 0.5)
# actor.GetProperty().SetOpacity(float(self.opacityline.text()))
# actor.SetMapper(mapper)
#render
self.ren.RemoveActor(self.curActor)
self.curActor = actor
self.ren.AddActor(actor)
self.ren.ResetCamera()
cam1 = self.ren.GetActiveCamera()
cam1.Zoom(1.4)
self.ren.SetBackground((1.0, 1.0, 1.0))
self.iren.Initialize()
self.iren.Start()
def test_full_cell_camera(full_cell_mesh, full_cell_soma_pt, tmp_path):
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh)
camera = trimesh_vtk.oriented_camera(full_cell_soma_pt, backoff=100)
eval_actor_image([mesh_actor],
'full_cell_orient_camera.png',
tmp_path,
camera=camera,
scale=1)
scale_bar_actor = trimesh_vtk.scale_bar_actor(
full_cell_soma_pt - [15000, 0, 0], camera)
eval_actor_image([mesh_actor, scale_bar_actor],
'full_cell_scale_bar.png',
tmp_path,
camera=camera,
scale=1)
def test_point_cloud(full_cell_mesh, full_cell_synapses, full_cell_soma_pt,
tmp_path):
mesh_actor = trimesh_vtk.mesh_actor(full_cell_mesh)
camera = trimesh_vtk.oriented_camera(full_cell_soma_pt, backoff=300)
sizes = full_cell_synapses['sizes']
# size points by size, fixed color
syn_actor = trimesh_vtk.point_cloud_actor(full_cell_synapses['positions'],
size=sizes,
color=(1, 0, 0))
eval_actor_image([mesh_actor, syn_actor],
'full_cell_with_synapes_size_scaled.png',
tmp_path,
camera=camera)
# color points by size, mapping sizes
syn_actor = trimesh_vtk.point_cloud_actor(full_cell_synapses['positions'],
size=500,
color=np.clip(sizes, 0, 1000))
eval_actor_image([mesh_actor, syn_actor],
'full_cell_synapes_colored_size.png',
tmp_path,
camera=camera)
# color and size points
syn_actor = trimesh_vtk.point_cloud_actor(full_cell_synapses['positions'],
size=sizes,
color=np.clip(sizes, 0, 1000))
eval_actor_image([mesh_actor, syn_actor],
'full_cell_synapes_colored_and_size.png',
tmp_path,
camera=camera)
# random colors
x = np.linspace(0, 1.0, len(sizes))
rand_colors = np.hstack([
x[:, np.newaxis],
np.abs(x - .5)[:, np.newaxis], (1 - x)[:, np.newaxis]
])
syn_actor = trimesh_vtk.point_cloud_actor(full_cell_synapses['positions'],
size=500,
color=rand_colors)
eval_actor_image([mesh_actor, syn_actor],
'full_cell_synapes_random_colors.png',
tmp_path,
camera=camera)
# random colors uint8
rand_colors_uint8 = np.uint8(rand_colors * 255)
syn_actor = trimesh_vtk.point_cloud_actor(full_cell_synapses['positions'],
size=500,
color=rand_colors_uint8)
eval_actor_image([mesh_actor, syn_actor],
'full_cell_synapes_random_colors_uint8.png',
tmp_path,
camera=camera)
# test failure modes
with pytest.raises(ValueError) as e:
syn_actor = trimesh_vtk.point_cloud_actor(
full_cell_synapses['positions'],
size=np.random.rand(10, 10),
color=(1, 0, 0))
with pytest.raises(ValueError) as e:
syn_actor = trimesh_vtk.point_cloud_actor(
full_cell_synapses['positions'],
size=300,
color=np.random.rand(len(x), 2))
# Import dually innervated spines list
spines_file = 'dually-innervated_reindexed.pkl'
spines_df = pd.read_pickle(spines_file)
# Choose which pair of meshes to work with (i corresponds to index in list of pairs)
i = 39344
# Load meshes and create mesh actors for each mesh
spine1_file = r'Meshes/' + str(
spines_df['cell id'][i]) + '/' + str(i) + '/spine_' + str(
spines_df['spine 1 index'][i]) + '.off'
spinemesh1 = trimesh.exchange.load.load_mesh(spine1_file)
spinemesh1_mp = meshparty.trimesh_io.Mesh(vertices=spinemesh1.vertices,
faces=spinemesh1.faces)
spinemesh1_actor = trimesh_vtk.mesh_actor(spinemesh1,
color=(0, 0, 1),
opacity=0.2)
spine2_file = r'Meshes/' + str(
spines_df['cell id'][i]) + '/' + str(i) + '/spine_' + str(
spines_df['spine 2 index'][i]) + '.off'
spinemesh2 = trimesh.exchange.load.load_mesh(spine2_file)
spinemesh2_mp = meshparty.trimesh_io.Mesh(vertices=spinemesh2.vertices,
faces=spinemesh2.faces)
spinemesh2_actor = trimesh_vtk.mesh_actor(spinemesh2,
color=(1, 0, 0),
opacity=0.2)
# Find synapse location and make a point cloud actor for the synapse of each mesh
synapse1_loc = [
spines_df['spine 1 synapse'][i][0] * 4,
spines_df['spine 1 synapse'][i][1] * 4,
#from PyQt5.QtWidgets import QShortcut , QApplication, QWidget, QPushButton, QVBoxLayout, QLabel, QLineEdit, QGridLayout, QMessageBox
#from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
import csv
import json
import os
import pickle
import pandas as pd
import numpy as np
#import moviepy
import trimesh
import meshparty
from meshparty import trimesh_io, trimesh_vtk
# Create a set of 120 png images vizualizing the full rotation of each mesh
# Change mesh filename manually
spinemesh1 = trimesh.exchange.load.load_mesh(r'data\PSS_meshes\27.off')
spinemesh1_actor = trimesh_vtk.mesh_actor(spinemesh1,
color=(0, 1, 0),
opacity=0.6)
locmesh1 = trimesh.exchange.load.load_mesh(r'data\local_meshes\27.off')
locmesh1_actor = trimesh_vtk.mesh_actor(locmesh1, color=(1, 1, 1), opacity=0.1)
renderer1 = trimesh_vtk.render_actors(
actors=[spinemesh1_actor, locmesh1_actor], do_save=False)
# When vtk window appears with PSS and local mesh actors, manually rotate meshes to desired orientation
cam = renderer1.GetActiveCamera()
trimesh_vtk.render_actors_360(actors=[spinemesh1_actor, locmesh1_actor],
camera_start=cam,
directory='pss_images\pt27',
nframes=120,
do_save=True)
shaft1openings = shaft1.submesh([shaft1broken], append=True)
#shaft1_actor = trimesh_vtk.mesh_actor(shaft1)
#trimesh_vtk.render_actors([shaft1_actor])
#shaft1openings_actor = trimesh_vtk.mesh_actor(shaft1openings)
#trimesh_vtk.render_actors([shaft1openings_actor])
print(shaft1openings.body_count)
#shaft 2
shaft2 = trimesh.exchange.load.load_mesh(
r'data\meshes\EXPT1\137732862037\spine_1676.off')
shaft2broken = trimesh.repair.broken_faces(shaft2)
shaft2openings = shaft2.submesh([shaft2broken], append=True)
#shaft2_actor = trimesh_vtk.mesh_actor(shaft2,color=(0,0,1),opacity=0.2)
#trimesh_vtk.render_actors([shaft2_actor])
shaft2openings_actor = trimesh_vtk.mesh_actor(shaft2openings,
color=(0, 0, 1),
opacity=0.2)
trimesh_vtk.render_actors([shaft2openings_actor])
print(shaft2openings.body_count)
#spine 1
spine1 = trimesh.exchange.load.load_mesh(
r'data\meshes\EXPT1\134025041739\spine_599.off')
spine1broken = trimesh.repair.broken_faces(spine1)
spine1openings = spine1.submesh([spine1broken], append=True)
#spine1_actor = trimesh_vtk.mesh_actor(spine1)
#trimesh_vtk.render_actors([spine1_actor])
#spine1openings_actor = trimesh_vtk.mesh_actor(spine1openings)
#trimesh_vtk.render_actors([spine1openings_actor])
print(spine1openings.body_count)
