import slam.io as sio
import numpy as np
import trimesh
###############################################################################
# loading an two unregistered meshes
mesh_1 = sio.load_mesh('../examples/data/example_mesh.gii')
mesh_2 = sio.load_mesh('../examples/data/example_mesh_2.gii')
###############################################################################
# plot them to check the misalignment
joint_mesh = mesh_1 + mesh_2
joint_tex = np.ones((joint_mesh.vertices.shape[0], ))
joint_tex[:mesh_1.vertices.shape[0]] = 10
visb_sc = splt.visbrain_plot(mesh=joint_mesh,
tex=joint_tex,
caption='before registration')
visb_sc.preview()
###############################################################################
# compute ICP registration
transf_mat, cost = trimesh.registration.mesh_other(mesh_1,
mesh_2,
samples=500,
scale=False,
icp_first=10,
icp_final=100)
print(transf_mat)
print(cost)
###############################################################################
###############################################################################
# target object files
target_mesh_file = 'data/example_mesh_2.gii'
target_spherical_mesh_file = 'data/example_mesh_2_spherical.gii'
source_mesh = sio.load_mesh(source_mesh_file)
source_tex = sio.load_texture(source_texture_file)
source_spherical_mesh = sio.load_mesh(source_spherical_mesh_file)
target_mesh = sio.load_mesh(target_mesh_file)
target_spherical_mesh = sio.load_mesh(target_spherical_mesh_file)
interpolated_tex_values = \
srem.spherical_interpolation_nearest_neigbhor(source_spherical_mesh,
target_spherical_mesh,
source_tex.darray[0])
###############################################################################
# plot
visb_sc = splt.visbrain_plot(mesh=source_mesh, tex=source_tex.darray[0],
caption='source with curvature',
cblabel='curvature')
visb_sc = splt.visbrain_plot(mesh=source_spherical_mesh,
tex=source_tex.darray[0],
caption='spherical source mesh',
cblabel='curvature', visb_sc=visb_sc)
visb_sc = splt.visbrain_plot(mesh=target_mesh, tex=interpolated_tex_values,
caption='target mesh with curvature '
'from source mesh',
cblabel='curvature', visb_sc=visb_sc)
visb_sc.preview()
open_mesh = sps.generate_quadric(K, nstep=5)
###############################################################################
# Identify the vertices lying on the boundary of the mesh and order
# them to get a path traveling across boundary vertices
# The output is a list of potentially more than one boudaries
# depending on the topology of the input mesh.
# Here the mesh has a single boundary
open_mesh_boundary = stop.mesh_boundary(open_mesh)
print(open_mesh_boundary)
###############################################################################
# show the result
# WARNING : BrainObj should be added first before
visb_sc = splt.visbrain_plot(mesh=open_mesh, caption='open mesh')
# create points with vispy
for bound in open_mesh_boundary:
points = open_mesh.vertices[bound]
s_rad = SourceObj('rad', points, color='red', symbol='square',
radius_min=10)
visb_sc.add_to_subplot(s_rad)
lines = Line(pos=open_mesh.vertices[bound], width=10, color='b')
# wrap the vispy object using visbrain
l_obj = VispyObj('line', lines)
visb_sc.add_to_subplot(l_obj)
visb_sc.preview()
###############################################################################
# here is how to get the vertices that define the boundary of
# a texture on a mesh
s_mesh = sdg.laplacian_mesh_smoothing(mesh, nb_iter=100, dt=0.1)
# compute the gradient of texture tex
triangle_grad = sdg.triangle_gradient(mesh, tex.darray[0])
print(triangle_grad)
grad = sdg.gradient(mesh, tex.darray[0])
print(grad.values)
norm_grad = sdg.norm_gradient(mesh, tex.darray[0])
print(norm_grad)
# compute the depth potential function
dpf = sdg.depth_potential_function(mesh, tex.darray[0], [0.3])
# plot all that to show the results
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=tex.darray[0],
caption='mesh with curvature',
cblabel='curvature')
visb_sc = splt.visbrain_plot(mesh=s_mesh,
caption='smoothed mesh',
visb_sc=visb_sc)
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=norm_grad,
caption='norm of the gradient of curvature',
cblabel='gradient magnitude',
visb_sc=visb_sc)
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=dpf[0],
caption='depth potential function',
cblabel='dpf',
visb_sc=visb_sc)
visb_sc.preview()
###############################################################################
# Getting the vertex index in specified geo_distance of vert
vert_id = 200
max_geodist = 10
geo_distance = sgeo.compute_gdist(mesh, vert_id)
area_geodist_vi = np.where(geo_distance < max_geodist)[0]
print(area_geodist_vi)
###############################################################################
# Visualization
visb_sc = splt.visbrain_plot(mesh=mesh, tex=geo_distance,
caption='geodesic distance',
cblabel='distance')
visb_sc.preview()
###############################################################################
# Getting the vertex index in specified geo_distance of vert
area_geodist = sgeo.local_gdist_matrix(mesh, max_geodist)
visb_sc2 = splt.visbrain_plot(mesh=mesh,
tex=area_geodist[0].toarray().squeeze(),
caption='local geodesic distance',
cblabel='distance')
visb_sc2.preview()
###############################################################################
# Get the vertex index
import slam.plot as splt
import slam.io as sio
if __name__ == '__main__':
mesh_file = 'data/example_mesh.gii'
texture_file = 'data/example_texture.gii'
mesh = sio.load_mesh(mesh_file)
mesh.apply_transform(mesh.principal_inertia_transform)
tex = sio.load_texture(texture_file)
print(tex.min())
print(tex.max())
visb_sc = splt.visbrain_plot(mesh=mesh, caption='simple mesh')
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=tex.darray[0],
caption='with curvature',
cblabel='curvature',
visb_sc=visb_sc)
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=tex.darray[0],
caption='change cmap',
cblabel='curvature',
cmap='hot',
visb_sc=visb_sc)
visb_sc.preview()
# then save the 3D rendering figure
# visb_sc.screenshot('test.png')
# # most simple mesh visualization
# splt.pyglet_plot(mesh)
import slam.io as sio
import slam.plot as splt
import slam.vertex_voronoi as svv
import numpy as np
if __name__ == '__main__':
mesh = sio.load_mesh('data/example_mesh.gii')
mesh.apply_transform(mesh.principal_inertia_transform)
vert_vor = svv.vertex_voronoi(mesh)
print(mesh.vertices.shape)
print(vert_vor.shape)
print(np.sum(vert_vor) - mesh.area)
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=vert_vor,
caption='vertex voronoi',
cblabel='vertex voronoi')
visb_sc.preview()
mesh = trimesh.Trimesh(faces=faces_tri.simplices,
vertices=coords,
process=False)
return mesh
params = [4, 0.25]
ax = 2
ay = 1
nstep = 50
mesh = boucher_surface(params, ax, ay, nstep)
##########################################################################
# Visualization of the mesh
visb_sc = splt.visbrain_plot(mesh=mesh,
caption='Boucher mesh',
bgcolor=[0.3, 0.5, 0.7])
visb_sc
visb_sc.preview()
##################################
# Compute dpf for various alpha
res = sc.curvatures_and_derivatives(mesh)
mean_curvature = res[0].sum(axis=0)
alphas = [0.001, 0.01, 0.1, 1, 10, 100]
dpfs = sdg.depth_potential_function(mesh,
curvature=mean_curvature,
alphas=alphas)
amplitude_center = []
import slam.generate_parametric_surfaces as sps
import numpy as np
import slam.topology as stop
import slam.plot as splt
import slam.mapping as smap
import slam.distortion as sdst
from vispy.scene import Line
from visbrain.objects import VispyObj, SourceObj
###############################################################################
# Generation of an open mesh
K = [-1, -1]
open_mesh = sps.generate_quadric(K, nstep=[5, 5])
open_mesh_boundary = stop.mesh_boundary(open_mesh)
# Visualization
visb_sc = splt.visbrain_plot(mesh=open_mesh, caption='open mesh')
for bound in open_mesh_boundary:
points = open_mesh.vertices[bound]
s_rad = SourceObj('rad',
points,
color='red',
symbol='square',
radius_min=10)
visb_sc.add_to_subplot(s_rad)
lines = Line(pos=open_mesh.vertices[bound], width=10, color='b')
# wrap the vispy object using visbrain
l_obj = VispyObj('line', lines)
visb_sc.add_to_subplot(l_obj)
visb_sc.preview()
###############################################################################
===================================
example of hinge shaped surface
===================================
"""
# Authors: Julien Lefevre <*****@*****.**>
# License: BSD (3-clause)
# sphinx_gallery_thumbnail_number = 2
###############################################################################
# importation of slam modules
import slam.plot as splt
import slam.curvature as scurv
import slam.generate_parametric_surfaces as sgps
###############################################################################
# Creating an examplar 3-4-...n hinge mesh
hinge_mesh = sgps.generate_hinge(n_hinge=4)
mesh_curvatures = scurv.curvatures_and_derivatives(hinge_mesh)
mean_curvature = 1 / 2 * mesh_curvatures[0].sum(axis=0)
visb_sc = splt.visbrain_plot(mesh=hinge_mesh,
tex=mean_curvature,
caption='hinge',
cblabel='mean curvature')
visb_sc.preview()
import slam.io as sio
import slam.differential_geometry as sdg
import slam.plot as splt
if __name__ == '__main__':
mesh = sio.load_mesh('data/example_mesh.gii')
tex = sio.load_texture('data/example_texture.gii')
triangle_grad = sdg.triangle_gradient(mesh, tex.darray[0])
print(triangle_grad)
grad = sdg.gradient(mesh, tex.darray[0])
print(grad.values)
norm_grad = sdg.norm_gradient(mesh, tex.darray[0])
print(norm_grad)
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=tex.darray[0],
caption='mesh with curvature',
cblabel='curvature')
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=norm_grad,
caption='norm of the gradient of curvature',
cblabel='gradient magnitude',
visb_sc=visb_sc)
visb_sc.preview()
lap, lap_b = sdg.compute_mesh_laplacian(mesh, lap_type='fem')
print(mesh.vertices.shape)
print(lap.shape)
lap, lap_b = sdg.compute_mesh_laplacian(mesh, lap_type='conformal')
lap, lap_b = sdg.compute_mesh_laplacian(mesh, lap_type='meanvalue')
lap, lap_b = sdg.compute_mesh_laplacian(mesh, lap_type='authalic')
# mesh_boundary works fine
# here is how to get the vertices that define the boundary of an open mesh
K = [-1, -1]
open_mesh = sps.generate_quadric(K, nstep=5)
print('================= mesh_boundary =================')
print('Identify the vertices lying on the boundary of the mesh and order'
'them to get a path traveling across boundary vertices')
print('The output is a list of potentially more than one boudaries '
'depending on the topology of the input mesh')
open_mesh_boundary = stop.mesh_boundary(open_mesh)
print(open_mesh_boundary)
print('Here the mesh has a single boundary')
# WARNING : BrainObj should be added first before
visb_sc = splt.visbrain_plot(mesh=open_mesh, caption='open mesh')
# create points with vispy
for bound in open_mesh_boundary:
points = open_mesh.vertices[bound]
s_rad = SourceObj('rad',
points,
color='red',
symbol='square',
radius_min=10)
visb_sc.add_to_subplot(s_rad)
lines = Line(pos=open_mesh.vertices[bound], width=10, color='b')
# wrap the vispy object using visbrain
l_obj = VispyObj('line', lines)
visb_sc.add_to_subplot(l_obj)
visb_sc.preview()
noqq = np.sqrt(np.sum(qq * qq, 1))
nopp = np.sqrt(np.sum(pp * pp, 1))
pp = pp / np.vstack((nopp, np.vstack((nopp, nopp)))).transpose()
qq = qq / np.vstack((noqq, np.vstack((noqq, noqq)))).transpose()
angles_out[:, i] = np.arccos(np.sum(pp * qq, 1))
return angles_out
if __name__ == '__main__':
mesh = sio.load_mesh('data/example_mesh.gii')
sphere, evol = smap.spherical_mapping(mesh,
mapping_type='conformal',
dt=0.01,
nb_it=3000)
visb_sc = splt.visbrain_plot(mesh=mesh, caption='original mesh')
visb_sc = splt.visbrain_plot(mesh=sphere,
caption='spherical representation',
visb_sc=visb_sc)
visb_sc.preview()
angle_diff = sdst.angle_difference(sphere, mesh)
area_diff = sdst.area_difference(sphere, mesh)
edge_diff = sdst.edge_length_difference(sphere, mesh)
aevol = np.array(evol)
f, ax = plt.subplots(1, 3)
ax[0].set_title('angles')
# ax[0].hist(angle_diff.flatten())
ax[0].plot(aevol[:, 0])
ax[0].grid(True)
# Generating a quadrix surface
K = [1, 1]
quadric = sgps.generate_quadric(K,
nstep=20,
ax=3,
ay=1,
random_sampling=True,
ratio=0.3,
random_distribution_type='gamma')
quadric_mean_curv = \
sgps.quadric_curv_mean(K)(np.array(quadric.vertices[:, 0]),
np.array(quadric.vertices[:, 1]))
visb_sc = splt.visbrain_plot(mesh=quadric,
tex=quadric_mean_curv,
caption='quadric',
cblabel='mean curvature')
visb_sc.preview()
###############################################################################
# Generating an ellipsiods
nstep = 50
randomSampling = True
a = 2
b = 1
ellips = sgps.generate_ellipsiod(a, b, nstep, randomSampling)
visb_sc = splt.visbrain_plot(mesh=ellips, caption='ellipsoid', visb_sc=visb_sc)
###############################################################################
# Comptue estimations of principal curvatures
PrincipalCurvatures, PrincipalDir1, PrincipalDir2 = \
scurv.curvatures_and_derivatives(mesh)
###############################################################################
# Comptue Gauss curvature from principal curvatures
gaussian_curv = PrincipalCurvatures[0, :] * PrincipalCurvatures[1, :]
###############################################################################
# Comptue mean curvature from principal curvatures
mean_curv = 0.5 * (PrincipalCurvatures[0, :] + PrincipalCurvatures[1, :])
###############################################################################
# Plot mean curvature
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=mean_curv,
caption='mean curvature',
cblabel='mean curvature')
visb_sc.preview()
###############################################################################
# PLot Gauss curvature
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=gaussian_curv,
caption='Gaussian curvature',
cblabel='Gaussian curvature',
cmap='hot')
visb_sc.preview()
# Importation of slam modules
import slam.distortion as sdst
import slam.differential_geometry as sdg
import slam.plot as splt
import slam.io as sio
import numpy as np
###############################################################################
# Loading an example mesh and a smoothed copy of it
mesh = sio.load_mesh('data/example_mesh.gii')
mesh_s = sdg.laplacian_mesh_smoothing(mesh, nb_iter=50, dt=0.1)
################################################################################
# Visualization of the original mesh
visb_sc = splt.visbrain_plot(mesh=mesh, caption='original mesh')
visb_sc.preview()
###############################################################################
# Visualization of the smoothed mesh
visb_sc = splt.visbrain_plot(mesh=mesh_s,
caption='smoothed mesh',
visb_sc=visb_sc)
visb_sc.preview()
###############################################################################
# Computation of the angle difference between each faces of mesh and mesh_s
angle_diff = sdst.angle_difference(mesh, mesh_s)
angle_diff
###############################################################################
# Comptue estimations of principal curvatures
PrincipalCurvatures, PrincipalDir1, PrincipalDir2 = \
scurv.curvatures_and_derivatives(mesh)
###############################################################################
# Comptue Gauss curvature from principal curvatures
gaussian_curv = PrincipalCurvatures[0, :] * PrincipalCurvatures[1, :]
###############################################################################
# Comptue mean curvature from principal curvatures
mean_curv = 0.5 * (PrincipalCurvatures[0, :] + PrincipalCurvatures[1, :])
###############################################################################
# Plot mean curvature
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=mean_curv,
caption='mean curvature',
cblabel='mean curvature')
visb_sc.preview()
###############################################################################
# Plot Gauss curvature
visb_sc = splt.visbrain_plot(mesh=mesh,
tex=gaussian_curv,
caption='Gaussian curvature',
cblabel='Gaussian curvature',
cmap='hot')
visb_sc.preview()
###############################################################################
# Decomposition of the curvatures into ShapeIndex and Curvedness
# Based on 'Surface shape and curvature scales
