def _make_root(self, rootpath):
"""
Creates a root mesh by merging the mesh corresponding to each neuron,
then saves it as an obj file at rootpath
"""
raise NotImplementedError(
"Create root method not supported yet, sorry")
print(f"Creating root mesh for atlas {self.atlas_name}")
temp_scene = Scene(
atlas=Celegans,
add_root=False,
display_inset=False,
atlas_kwargs=dict(data_folder=self.data_folder),
)
temp_scene.add_neurons(self.neurons_names)
temp_scene.render(interactive=False)
temp_scene.close()
root = merge(*temp_scene.actors["neurons"]).clean().cap()
# root = mesh2Volume(root, spacing=(0.02, 0.02, 0.02)).isosurface()
points = Points(root.points()).smoothMLS2D(f=0.8).clean(tol=0.005)
root = recoSurface(points, dims=100, radius=0.2)
# Save
write(root, rootpath)
del temp_scene
return root
def update():
global spline, points
plt.resetcam = False
plt.remove([spline, points], render=False)
points = Points(cpoints).c('violet')
spline = None
if len(cpoints) > 1:
spline = KSpline(cpoints).c('yellow').alpha(0.5)
plt.add([spline, points])
def makeGrid(shape, N):
rmax = 2.0 # line length
agrid, pts = [], []
for th in np.linspace(0, np.pi, N, endpoint=True):
lats = []
for ph in np.linspace(0, 2 * np.pi, N, endpoint=True):
p = np.array([sin(th) * cos(ph), sin(th) * sin(ph), cos(th)]) * rmax
intersections = shape.intersectWithLine([0, 0, 0], p)
if len(intersections):
value = mag(intersections[0])
lats.append(value - rbias)
pts.append(intersections[0])
else:
lats.append(rmax - rbias)
pts.append(p)
agrid.append(lats)
agrid = np.array(agrid)
actor = Points(pts, c="k", alpha=0.4, r=1)
return agrid, actor
def display_lidar(path, num_points=None):
file = laspy.file.File(path, mode='r')
point_cloud = np.stack([file.X, file.Y, file.Z], axis=-1)
scale = file.get_header().get_scale()
offset = file.get_header().get_offset()
point_cloud = point_cloud * scale + offset
rgb = np.stack([file.Red, file.Green, file.Blue], axis=-1) / 256
alpha = np.ones((len(point_cloud), 1)) * 255
rgba = np.concatenate([rgb, alpha], axis=-1)
if num_points:
idx = np.random.choice(list(range(len(point_cloud))),
num_points,
replace=False)
point_cloud = point_cloud[idx]
rgba = rgba[idx]
point_vedo = Points(point_cloud, c=rgba)
show(point_vedo, axes=True)
def f4(x, y, z, x1, y1, z1, c):
x1[c] = 0.5 * x[c] + 1 / 4.0
y1[c] = 0.5 * y[c] + 1.0 / 4
z1[c] = 0.5 * z[c] + np.sqrt(3) / 4
functions = [f1, f2, f3, f4]
probabilities = [1 / 4.0] * 4
assert len(functions) == len(probabilities)
X, Y, Z = x, y, z
for i in range(20):
# pick indices for each function to be applied
r = np.random.choice(len(probabilities), size=N, p=probabilities)
for i, f in enumerate(functions):
f(x, y, z, x1, y1, z1, r == i)
x, x1 = x1, x
y, y1 = y1, y
z, z1 = z1, z
if i > 0:
X, Y, Z = np.hstack([X, x]), np.hstack([Y, y]), np.hstack([Z, z])
# how much memory are we using, how many points there are
print("used mem, Npts=", 3 * X.nbytes // 1024**2, "MB", X.shape[0])
from vedo import Points
Points([X, Y, Z], c="tomato").show(axes=1)
"""delaunay2D() and cellCenters() functions"""
from vedo import Plotter, delaunay2D, Points, datadir
vp = Plotter(shape=(1, 2), interactive=0)
d0 = vp.load(datadir + "250.vtk").rotateY(-90).legend("original mesh")
coords = d0.points() # get the coordinates of the mesh vertices
# Build a mesh starting from points in space
# (points must be projectable on the XY plane)
d1 = delaunay2D(coords, mode='fit')
d1.color("r").wireframe(True).legend("delaunay mesh")
cents = d1.cellCenters()
ap = Points(cents).legend("cell centers")
vp.show(d0, d1, __doc__, at=0) # NB: d0 and d1 are slightly different
vp.show(d1, ap, at=1, interactive=1)
""" MAGIC-LAT estimate """
latEst = magicLAT(vertices, faces, TrIdx, TrCoord, TrVal, EDGE_THRESHOLD)
magicDE = metrics.deltaE(TstVal, latEst[TstIdx], MINLAT, MAXLAT)
x.append(m)
y.append(magicDE)
if magicDE > maxDE:
maxDE = magicDE
ymax = math.ceil(magicDE / 10) * 10
with open(meanFile, 'a') as fid:
fid.write('\n')
fid.write('{:<20}{:<20.6f}'.format(m, magicDE))
verPoints = Points(TrCoord, r=5).cmap('rainbow_r',
TrVal,
vmin=MINLAT,
vmax=MAXLAT).addScalarBar()
estPoints = Points(vertices, r=5).cmap('rainbow_r',
latEst,
vmin=MINLAT,
vmax=MAXLAT).addScalarBar()
coloredMesh = Mesh([vertices, faces])
coloredMesh.interpolateDataFrom(estPoints,
N=1).cmap('rainbow_r',
vmin=MINLAT,
vmax=MAXLAT).addScalarBar()
# dEPoints = Points(np.array(dE), r=5).c('black')
vplt0 = Plotter(N=1,
bg='black',
''' Voronoi in 3D with Voro++ library. ''' from vedo import voronoi3D, Points, show import numpy as np #from vedo import settings #settings.voro_path = '/g/sharpeba/software/bin' N = 2000 nuclei = np.random.rand(N, 3) - (0.5, 0.5, 0.5) ncl = Points(nuclei).clean(0.1) # clean makes points evenly spaced nuclei = ncl.points() mesh = voronoi3D(nuclei, tol=.001) #print(len(mesh.info['cells']), mesh.info['volumes']) pts_inside = mesh.insidePoints(nuclei) inpts = Points(pts_inside, r=50, c='r', alpha=0.2) show(mesh, inpts)
at=0,
N=2)
show(grid1,
self.morphed_source,
self.target,
mlines,
f"morphed source (green) vs target (red)\nNDF = {2*self.npts}",
at=1,
interactive=True).close()
#################################
if __name__ == "__main__":
# make up a source random cloud
pts_s = np.random.randn(25, 2)
pts_t = pts_s + np.sin(2 * pts_s) / 5 # and distort it
mr = Morpher()
mr.source = Points(pts_s, r=20, c="g", alpha=0.5)
mr.target = Points(pts_t, r=10, c="r", alpha=1.0)
mr.bound = 2 # limits the x and y shift
mr.npts = 6 # allow move only a subset of points (implicitly sets the NDF of the fit)
mr.sigma = 1. # stiffness of the mesh (1=max stiffness)
mr.morph()
#now mr.msource contains the modified/morphed source.
mr.draw_shapes()
# Generate photons and trace them through the optical elements
lines = []
source = Grid(resx=20, resy=20).points() # a numpy array
for pt in source:
λ = np.random.uniform(low=450, high=750) * 1e-09 # nanometers
ray = Ray(pt, direction=(0, 0, 1), wave_length=λ)
line = ray.trace(elements).asLine(min_hits=4,
cmap_amplitudes="Blues") # vedo.Line
lines.append(line)
lines = list(filter(
None, lines)) # remove possible None to add a scalar bar to lines[0]
lines[0].addScalarBar("Ampl.")
# Grab the coords of photons exiting the conic lens3 (hits_type==-1)
cone_hits = Points(lens3.hits[lens3.hits_type == -1], r=8, c="green1")
# Show everything
show(
__doc__,
elements,
lines,
lens5.boundaries().lw(2),
cone_hits,
azimuth=-90,
elevation=-89,
zoom=2,
size=(1500, 700),
bg='k2',
bg2='k9',
axes=dict(
# extract the columns into separate vectors:
g0, g1, g2, g3, g4 = data.T # unpack genes
n0, n1, n2, n3, n4 = names
# now create and show histograms of the gene expressions
h0 = histogram(g0, xtitle=n0, c=0)
h1 = histogram(g1, xtitle=n1, c=1)
h2 = histogram(g2, xtitle=n2, c=2)
h3 = histogram(g3, xtitle=n3, c=3, logscale=True)
h4 = histogram(g4, xtitle=n4, c=4)
# this is where you choose what variables to show as 3D points
pts = np.c_[g4, g2, g3] # form an array of 3d points from the columns
pts_1 = pts[g0 > 0] # select only points that have g0>0
p1 = Points(pts_1, r=4, c='red') # create the vedo object
print("after selection nr. of points is", len(pts_1))
pts_2 = pts[(g0 < 0) & (g1 > .5)] # select excluded points that have g1>0.5
p2 = Points(pts_2, r=8, c='green') # create the vedo object
axes = (p1 + p2).buildAxes(xtitle='gene4',
ytitle='gene2',
ztitle='gene3',
c='k')
# Show the two clouds superposed on a new plotter window:
show(
[h0, h1, h2, h3, h4, (p1, p2, axes, __doc__)],
shape="1/5", # 1 spaces above and 5 below
sharecam=0,
th = np.deg2rad(90 - lat)
ph = np.deg2rad(long)
p = spher2cart(agrid_reco[j][i], th, ph)
ll.append((lat, long))
radii = agrid_reco.T.ravel()
n = 200j
lnmin, lnmax = np.array(ll).min(axis=0), np.array(ll).max(axis=0)
grid = np.mgrid[lnmax[0]:lnmin[0]:n, lnmin[1]:lnmax[1]:n]
grid_x, grid_y = grid
agrid_reco_finer = griddata(ll, radii, (grid_x, grid_y), method='cubic')
pts2 = []
for i, long in enumerate(
np.linspace(0, 360, num=agrid_reco_finer.shape[1], endpoint=False)):
for j, lat in enumerate(
np.linspace(90, -90, num=agrid_reco_finer.shape[0],
endpoint=True)):
th = np.deg2rad(90 - lat)
ph = np.deg2rad(long)
p = spher2cart(agrid_reco_finer[j][i], th, ph)
pts2.append(p)
mesh2 = Points(pts2, r=2, c="r", alpha=0.5)
# mesh2.clean(0.01) # impose point separation of 1% of the bounding box size
show(mesh2,
'Spherical harmonics\nexpansion of order ' + str(lmax),
at=1,
interactive=True)
mapIdx = [i for i in range(n)]
mapCoord = [vertices[i] for i in mapIdx]
# Map the LAT samples to nearest mesh vertices
allLatIdx, allLatCoord, allLatVal = utils.mapSamps(mapIdx, mapCoord,
OrigLatCoords, OrigLatVals)
M = len(allLatIdx)
# For colorbar ranges
MINLAT = math.floor(min(allLatVal) / 10) * 10
MAXLAT = math.ceil(max(allLatVal) / 10) * 10
allPoints = Points(allLatCoord, r=10).cmap('gist_rainbow',
allLatVal,
vmin=MINLAT,
vmax=MAXLAT).addScalarBar(c='white')
vplt = Plotter(N=1, axes=0, interactive=True)
for i in range(M):
idx = allLatIdx[i]
coord = allLatCoord[i]
val = allLatVal[i]
# plot current point as larger than the others
testPoint = Point(coord, r=20).cmap('gist_rainbow', [val],
vmin=MINLAT,
vmax=MAXLAT).addScalarBar(c='white')
vplt.show(mesh,
allPoints,
testPoint,
sin(state[2]) * cosa + M2 * L2 * state[3] * state[3] * sina -
(M1 + M2) * G * sin(state[0])) / den1
dydx[2] = state[3]
den2 = (L2 / L1) * den1
dydx[3] = (-M2 * L2 * state[3] * state[3] * sina * cosa +
(M1 + M2) * G * sin(state[0]) * cosa -
(M1 + M2) * L1 * state[1] * state[1] * sina -
(M1 + M2) * G * sin(state[2])) / den2
return dydx
t = np.arange(0.0, 10.0, dt)
state = np.radians([th1, w1, th2, w2])
y = integrate.odeint(derivs, state, t)
P1 = np.dstack([L1 * sin(y[:, 0]), -L1 * cos(y[:, 0])]).squeeze()
P2 = P1 + np.dstack([L2 * sin(y[:, 2]), -L2 * cos(y[:, 2])]).squeeze()
ax = Axes(xrange=(-2, 2), yrange=(-2, 1), htitle=__doc__)
pb = ProgressBar(0, len(t), c="b")
for i in pb.range():
j = max(i - 5, 0)
k = max(i - 10, 0)
l1 = Line([[0, 0], P1[i], P2[i]]).lw(7).c("blue2")
l2 = Line([[0, 0], P1[j], P2[j]]).lw(6).c("blue2", 0.3)
l3 = Line([[0, 0], P1[k], P2[k]]).lw(5).c("blue2", 0.1)
pt = Points([P1[i], P2[i], P1[j], P2[j], P1[k], P2[k]],
r=8).c("blue2", 0.2)
show(l1, l2, l3, pt, ax, interactive=False, size=(900, 700), zoom=1.4)
pb.print()
"""Voronoi tessellation of a pointcloud on a grid"""
from vedo import dataurl, Points, Grid, voronoi, show
pts0 = Points(dataurl + 'rios.xyz').color('k')
pts1 = pts0.clone().smoothLloyd2D()
grid = Grid([14500, 61700], sx=22000, sy=24000, resx=30, resy=30).ps(1)
allpts = pts1.points().tolist() + grid.points().tolist()
msh = voronoi(allpts, method='scipy')
msh.lw(0.1).wireframe(False).cmap('terrain_r', 'VoronoiID', on='cells')
centers = Points(msh.cellCenters(), c='k')
show(msh, pts0, __doc__, axes=dict(digits=3))
vp = Plotter(shape=[2, 2], axes=3, interactive=0)
shape1 = Sphere(alpha=0.2)
shape2 = vp.load(datadir + "icosahedron.vtk").normalize().lineWidth(1)
agrid1, actorpts1 = makeGrid(shape1, N)
vp.show(shape1, actorpts1, at=0)
agrid2, actorpts2 = makeGrid(shape2, N)
vp.show(shape2, actorpts2, at=1)
vp.camera.Zoom(1.2)
vp.interactive = False
clm1 = pyshtools.SHGrid.from_array(agrid1).expand()
clm2 = pyshtools.SHGrid.from_array(agrid2).expand()
# clm1.plot_spectrum2d() # plot the value of the sph harm. coefficients
# clm2.plot_spectrum2d()
for t in np.arange(0, 1, 0.005):
act21 = Points(morph(clm2, clm1, t, lmax), c="r", r=4)
act12 = Points(morph(clm1, clm2, t, lmax), c="g", r=4)
vp.show(act21, at=2, resetcam=0)
vp.show(act12, at=3)
vp.camera.Azimuth(2)
vp.show(interactive=1)
for colony in colonies:
newcells = []
for cell in colony.cells:
if cell.dieAt(t):
continue
if cell.divideAt(t):
newc = cell.split() # make daughter cell
plt += Line(cell.pos, newc.pos, c="k", lw=3, alpha=0.5)
newcells.append(newc)
newcells.append(cell)
colony.cells = newcells
pts = [c.pos for c in newcells] # draw all points at once
plt += Points(pts, c=colony.color, r=5, alpha=0.80) # nucleus
plt += Points(pts, c=colony.color, r=15, alpha=0.05) # halo
msg += str(len(colony.cells)) + ","
pb.print(msg + str(int(t)))
plt.show(resetcam=0)
if plt.escaped: exit(0) # if ESC is hit during the loop
# draw the oriented ellipsoid that contains 50% of the cells
for colony in colonies:
pts = [c.pos for c in colony.cells]
a = pcaEllipsoid(pts, pvalue=0.5)
a.color(colony.color).alpha(0.3)
a.legend("1/rate=" + str(colony.cells[0].tdiv) + "h")
plt += a
for i in range(6):
g.addChild(i) # add one child node to node i
for i in range(3):
g.addChild(i)
for i in range(3):
g.addChild(i)
for i in range(7, 9):
g.addChild(i)
for i in range(3):
g.addChild(12) # add 3 children to node 12
g.build()
dgraph = g.unpack(0).lineWidth(4) # get the graph lines
nodes = dgraph.points() # get the 3d points of the nodes
pts = Points(nodes, r=12).c('red').alpha(0.5)
v1 = ['node' + str(n) for n in range(len(nodes))]
v2 = [sin(x) for x in range(len(nodes))]
labs1 = pts.labels(v1, scale=.04, italic=True).addPos(.05, 0.04, 0).c('green')
labs2 = pts.labels(v2, scale=.04, precision=3).addPos(.05, -.04, 0).c('red')
# Interpolate the node value to color the edges:
dgraph.clean().pointColors(v2, cmap='viridis').addScalarBar()
# This would colorize the edges directly with solid color based on the v3 array:
# v3 = [sin(x) for x in range(dgraph.NCells())]
# dgraph.cellColors(v3, cmap='jet').addScalarBar()
show(pts, dgraph, labs1, labs2, __doc__, axes=9)
Example shows how to share the same vtkCamera
between different Plotter windows.
"""
from vedo import Plotter, Points, Arrows, show, Text2D
import numpy as np
ls = np.linspace(0, 10, 8)
X, Y, Z = np.meshgrid(ls, ls, ls)
xr, yr, zr = X.ravel(), Y.ravel(), Z.ravel()
positions = np.vstack([xr, yr, zr])
sources = [(5, 8, 5), (8, 5, 5), (5, 2, 5)]
deltas = [(1, 1, 0.2), (1, 0, -0.8), (1, -1, 0.2)]
apos = Points(positions, r=2)
# for p in apos.points(): ####### Uncomment to fix some points.
# if abs(p[2]-5) > 4.999: # differences btw RBF and thinplate
# sources.append(p) # will become much smaller.
# deltas.append(np.zeros(3))
sources = np.array(sources)
deltas = np.array(deltas)
src = Points(sources, c="r", r=12)
trs = Points(sources + deltas, c="v", r=12)
arr = Arrows(sources, sources + deltas)
################################################# Thin Plate Splines
warped = apos.clone().thinPlateSpline(sources, sources + deltas)
warped.alpha(0.4).color("lg").pointSize(10)
"""Generate 3 random sets of points and align
them using Procrustes method.
"""
from __future__ import division, print_function
from random import uniform as u
from vedo import Plotter, procrustesAlignment, Points
vp = Plotter(shape=[1, 2], axes=2, sharecam=0)
N = 15 # number of points
x = 1.0 # add some randomness
pts1 = [(u(0, x), u(0, x), u(0, x) + i) for i in range(N)]
pts2 = [(u(0, x) + 3, u(0, x) + i / 2 + 2, u(0, x) + i + 1) for i in range(N)]
pts3 = [(u(0, x) + 4, u(0, x) + i / 4 - 3, u(0, x) + i - 2) for i in range(N)]
vpts1 = Points(pts1, c="r").legend("set1")
vpts2 = Points(pts2, c="g").legend("set2")
vpts3 = Points(pts3, c="b").legend("set3")
vp.show(vpts1, vpts2, vpts3, __doc__, at=0)
# find best alignment among the n sets of Points,
# return an Assembly object formed by the aligned sets
aligned = procrustesAlignment([vpts1, vpts2, vpts3])
# print(aligned.info['transform'])
vp.show(aligned, at=1, interactive=1)
"""Voronoi convex tiling of the plane from a set of random points"""
from vedo import Points, voronoi, show
import numpy as np
points = np.random.random((500, 2))
pts = Points(points).clean(0.02) # impose a min distance of 2%
vor = voronoi(pts, pad=0.01)
vor.cmap('Set3', "VoronoiID", on='cells').wireframe(False)
# lab = vor.labels("VoronoiID", cells=True, scale=0.01)
lab = None
show(pts, vor, lab, __doc__, zoom=1.3)
"""Generate a denser point cloud.
The new points are created in such a way that
all points in any local neighborhood are
within a target distance of one another"""
from vedo import Points, printc, show
import numpy as np
npts = 50 # nr. of points
coords = np.random.rand(npts, 3) # range is [0, 1]
scals = np.abs(coords[:, 1]) # let the scalar be the y of the point itself
pts = Points(coords, r=9)
pts.pointdata["scals"] = scals
densecloud = pts.densify(0.1, closest=10,
niter=1) # return a new pointcloud.Points
printc('nr. points increased', pts.N(), '\rightarrow ', densecloud.N(), c='lg')
show([(pts, __doc__), densecloud], N=2, axes=1).close()
th = np.deg2rad(90 - lat)
ph = np.deg2rad(long)
p = spher2cart(agrid_reco[j][i], th, ph)
ll.append((lat, long))
radii = agrid_reco.T.ravel()
n = 200j
lnmin, lnmax = np.array(ll).min(axis=0), np.array(ll).max(axis=0)
grid = np.mgrid[lnmax[0]:lnmin[0]:n, lnmin[1]:lnmax[1]:n]
grid_x, grid_y = grid
agrid_reco_finer = griddata(ll, radii, (grid_x, grid_y), method='cubic')
pts2 = []
for i, long in enumerate(
np.linspace(0, 360, num=agrid_reco_finer.shape[1], endpoint=False)):
for j, lat in enumerate(
np.linspace(90, -90, num=agrid_reco_finer.shape[0],
endpoint=True)):
th = np.deg2rad(90 - lat)
ph = np.deg2rad(long)
p = spher2cart(agrid_reco_finer[j][i], th, ph)
pts2.append(p)
mesh2 = Points(pts2, r=2, c="r", alpha=0.5)
mesh2.clean(0.01) # impose point separation of 1% of the bounding box size
show(mesh2,
'Spherical harmonics\nexpansion of order ' + str(lmax),
at=1,
interactive=True)
def update(evt):
global t
t += 0.005
P_ = np.zeros((n, 3))
cos_t = 1.5 * np.cos(2 * np.pi * t)
sin_t = 1.5 * np.sin(2 * np.pi * t)
for i in range(n):
x, y = P[i]
f = intensity[i] * 50
dx = noise4(scale * x, scale * y, cos_t, sin_t, 2) * f
dy = noise4(100 + scale * x, 200 + scale * y, cos_t, sin_t, 2) * f
P_[i] = [x + dx, y + dy, np.sqrt(dx * dx + dy * dy) / 2]
pts.points(P_)
plt.render()
pts = Points([X, Y], r=3).alpha(0.8)
cir = Circle(pos=(width / 2, height / 2, -5), r=radius * 1.05)
txt1 = Text2D("\Lambda L I E N L I F E", s=2.8, pos="top-center")
txt2 = Text2D("Original idea by Necessary Disorder",
s=0.9,
pos="bottom-center")
plt = Plotter()
plt.show(pts, cir, txt1, txt2, elevation=-35, zoom=1.2, interactive=False)
plt.addCallback("timer", update)
plt.timerCallback("create")
interactive()
def display_point_cloud(point_cloud, label):
point_vedo = Points(point_cloud[['X', 'Y', 'Z']])
labels = label
cmap = get_cmap('Spectral')
point_vedo.cmap(cmap, labels)
show(point_vedo, axes=True)
# G = networkx.gnm_random_graph(n=20, m=35)
# for i, j in G.edges(): g.addEdge(j,i)
##################### Manually create nodes and edges
for i in range(6): g.addChild(i) # add one child node to node i
for i in range(3): g.addChild(i)
for i in range(3): g.addChild(i)
for i in range(7,9): g.addChild(i)
for i in range(3): g.addChild(12) # add 3 children to node 12
g.addEdge(1,16)
##################### build and draw
graph = g.build().unpack(0).lineWidth(4) # get the vedo 3d graph lines
nodes = graph.points() # get the 3d points of the nodes
pts = Points(nodes, r=10).lighting('off')
v1 = ['node'+str(n) for n in range(len(nodes))]
v2 = [sin(x) for x in range(len(nodes))]
labs1 = pts.labels(v1, scale=.04, italic=True).addPos(.05,0.04,0).c('green')
labs2 = pts.labels(v2, scale=.04, precision=3).addPos(.05,-.04,0).c('red')
# Interpolate the node value to color the edges:
graph.cmap('viridis', v2).addScalarBar3D(c='k').addPos(.3,0,0)
pts.cmap('viridis', v2)
# This would colorize the edges directly with solid color based on a v3 array:
# v3 = [sin(x) for x in range(graph.NCells())]
# graph.cmap('jet', v3).addScalarBar()
show(pts, graph, labs1, labs2, __doc__, axes=9)
"""Customizing axes style
(40+ control parameters!)
Title font: """
from vedo import Box, Lines, Points, Spline, show, settings
settings.defaultFont = 'Theemim'
# an invisible box:
world = Box(pos=(2.7, 0, 0), size=(12, 10, 8), alpha=0)
# a dummy spline with its shadow on the xy plane
pts = Points([(-2, -3.2, -1.5), (3, -1.2, -2), (7, 3, 4)], r=12)
spl = Spline(pts,
res=50).addShadow(z=-4) # make spline and add its shadow at z=-4
lns = Lines(spl, spl.shadow) # join spline points with its own shadow
# make a dictionary of axes options
axes_opts = dict(
xtitle=
'My variable \Omega^\lowerxi_lm in units of \mum^3', # latex-style syntax
ytitle='This is my highly\ncustomized y-axis',
ztitle=
'z in units of Å', # many unicode chars are supported (type: vedo -r fonts)
yValuesAndLabels=[(-3.2, 'Mark^a_-3.2'), (-1.2, 'Carmen^b_-1.2'),
(3, 'John^c_3')],
textScale=1.3, # make all text 30% bigger
numberOfDivisions=5, # approximate number of divisions on longest axis
axesLineWidth=2,
gridLineWidth=1,
zxGrid2=True, # show zx plane on opposite side of the bounding box
yzGrid2=True, # show yz plane on opposite side of the bounding box
"""Thin Plate Spline transformations describe a nonlinear warp
transform defined by a set of source and target landmarks.
Any point on the mesh close to a source landmark will
be moved to a place close to the corresponding target landmark.
The points in between are interpolated using Bookstein's algorithm"""
from vedo import Mesh, Points, show, dataurl
import numpy as np
np.random.seed(1)
mesh = Mesh(dataurl + "shuttle.obj").c('silver')
# pick 4 random points
indxs = np.random.randint(0, mesh.N(), 4)
pts = mesh.points()[indxs]
# and move them randomly by a little
ptsource, pttarget = [], []
for ptold in pts:
ptnew = ptold + np.random.rand(3) * 0.2
ptsource.append(ptold)
pttarget.append(ptnew)
# print(ptold,'->',ptnew)
warped = mesh.clone().thinPlateSpline(ptsource, pttarget).color("b", 0.4)
apts = Points(ptsource, r=15, c="r")
show(mesh, warped, apts, __doc__, viewup="z", axes=1)
"""Plot streamlines of the 2D field:
u(x,y) = -1 - x\^2 + y
v(x,y) = 1 + x - y\^2
"""
from vedo import Points, show
from vedo.pyplot import streamplot
import numpy as np
# a grid with a vector field (U,V):
X, Y = np.mgrid[-5:5 :15j, -4:4 :15j]
U = -1 - X**2 + Y
V = 1 + X - Y**2
# optionally, pick some random points as seeds:
prob_pts = np.random.rand(200, 2)*8 - [4,4]
sp = streamplot(X,Y, U,V,
lw=0.001, # line width in abs. units
direction='forward', # 'both' or 'backward'
probes=prob_pts,
)
pts = Points(prob_pts, r=5, c='white')
show(sp, pts, __doc__, axes=1, bg='bb')
latNN[i] = mapLAT[i]
updatedFaces = magicLAT.updateFaces(vertices, faces, latNN, TrCoord,
EDGE_THRESHOLD)
latEst = magicLAT.magicLAT(vertices, faces, TrIdx, TrCoord, TrVal,
EDGE_THRESHOLD)
mesh = Mesh([vertices, faces])
# mesh.backColor('white').lineColor('black').lineWidth(0.25)
mesh.c('grey')
size = (100, 800)
fontSize = 35
verPoints = Points(vertices, r=10, c='white')
origLatPoints = Points(OrigLatCoords, r=10).cmap('gist_rainbow',
OrigLatVals,
vmin=MINLAT,
vmax=MAXLAT).addScalarBar(
c='white',
title='LAT (ms) ',
titleFontSize=fontSize,
size=size)
allLatPoints = Points(allLatCoord, r=10).cmap('gist_rainbow',
allLatVal,
vmin=MINLAT,
vmax=MAXLAT).addScalarBar(
c='white',
title='LAT (ms) ',
titleFontSize=fontSize,
