"""
Show a cube for each available texture name
any jpg file can be used as texture.
"""
from vtkplotter import Plotter, Cube, Text
from vtkplotter.settings import textures, textures_path
print(__doc__)
print(textures_path)
print(textures)
vp = Plotter(N=len(textures), axes=0)
for i, txt in enumerate(textures):
cb = Cube().texture(txt)
tname = Text(txt, pos=3)
vp.show(cb, tname, at=i)
vp.show(interactive=1)
noise is added to its vertices.
2. the point cloud is smoothened with MLS
(see moving_least_squares.py)
3. clean(actor) imposes a minimum distance
among mesh points where 'tol' is the
fraction of the actor size.
4. a triangular mesh is extracted from
this set of sparse Points, 'bins' is the
number of voxels of the subdivision
'''
from __future__ import division, print_function
from vtkplotter import Plotter, recoSurface, smoothMLS2D, Points, Text
import numpy as np
vp = Plotter(shape=(1, 5), axes=0)
vp.show(Text(__doc__), at=4)
act = vp.load('data/shapes/pumpkin.vtk')
vp.show(act, at=0)
noise = np.random.randn(act.N(), 3) * 0.05
act_pts0 = Points(act.coordinates() + noise, r=3) # add noise
act_pts1 = act_pts0.clone() # make a copy to modify
vp.show(act_pts0, at=1, legend='noisy cloud')
smoothMLS2D(act_pts1, f=0.4) # smooth cloud, input actor is modified
print('Nr of points before cleaning polydata:', act_pts1.N())
act_pts1.clean(tol=0.01) # impose a min distance among mesh points
print(' after cleaning polydata:', act_pts1.N())
"""
Normal jpg/png images can be loaded,
cropped and rendered as any vtkImageActor
"""
from vtkplotter import Plotter, Text, datadir
vp = Plotter(axes=3, verbose=0)
for i in range(5):
a = vp.load(datadir+"images/dog.jpg").crop(bottom=0.2) # crop 20%
a.scale(1-i/10.0).alpha(0.8) # image can be scaled in size
a.rotateX(20*i).pos(0,0,30*i) # (can concatenate methods)
vp += Text(__doc__)
vp.show()
import numpy as np # np.random.seed(0) # a small set of points for which the scalar is given x, y, z = np.random.rand(3, 20) scals = z # scalar value is just z component # build the interpolator itr = Rbf(x, y, z, scals) # Radial Basis Function interpolator # itr = Near(list(zip(x,y,z)), scals) # Nearest-neighbour interpolator # generate a new set of points t = np.linspace(0, 7, 100) xi, yi, zi = [np.sin(t) / 10 + 0.5, np.cos(t) / 5 + 0.5, (t - 1) / 5] # an helix # interpolate scalar values on the new set scalsi = itr(xi, yi, zi) from vtkplotter import Plotter, Points, Text vp = Plotter(axes=1, bg="w") vp += Points([x, y, z], r=10, alpha=0.5).pointColors(scals) vp += Points([xi, yi, zi]).pointColors(scalsi) vp += Text(__doc__, pos=1, c="dr") vp.show(viewup="z")
"""Lock an object orientation to the scene camera.
"""
from vtkplotter import Sphere, Text, Plotter
plt = Plotter(axes=1, interactive=0)
sp = Sphere().wireframe()
tx1 = Text("Fixed point", sp.getPoint(10), s=0.07, c="lb")
tx2 = Text("Follow point", sp.getPoint(144), s=0.07, c="lg")
# a camera must exist prior to calling followCamera()
plt.show(sp)
tx2.followCamera() # a vtkCamera can also be passed as argument
plt.show(sp, tx1, tx2, Text(__doc__), interactive=1)
generate 3 random sets of points
and align them using vtkProcrustesAlignmentFilter.
"""
from __future__ import division, print_function
from random import uniform as u
from vtkplotter import Plotter, alignProcrustes, Text, Points
vp = Plotter(shape=[1, 2], verbose=0, axes=2, sharecam=0, bg="w")
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)]
act1 = Points(pts1, c="r").legend("set1")
act2 = Points(pts2, c="g").legend("set2")
act3 = Points(pts3, c="b").legend("set3")
vp.show(act1, act2, act3, at=0)
# find best alignment among the n sets of Points,
# return an Assembly formed by the aligned sets
aligned = alignProcrustes([act1, act2, act3])
# print(aligned.info['transform'])
vp.show(aligned, Text(__doc__), at=1, interactive=1)
"""Read and show meshio objects"""
import meshio
from vtkplotter import datadir, show, Actor, Text, printc
mesh = meshio.read(datadir + 'shuttle.obj')
# vtkplotter understands meshio format:
printc(mesh, c='y')
show(mesh, Text(__doc__))
# or explicitly convert it to an Actor object:
a = Actor(mesh).lineWidth(1).color('tomato')
show(a)
Find the closest point
on the mesh to each random point
"""
import trimesh
import numpy as np
from vtkplotter import Text, show, Arrows
mesh = trimesh.load_remote(
'https://github.com/mikedh/trimesh/raw/master/models/cycloidal.ply')
points = mesh.bounding_box_oriented.sample_volume(count=30)
# find the closest point on the mesh to each random point
closest_points, distances, triangle_id = mesh.nearest.on_surface(points)
#print('Distance from point to surface of mesh:\n{}'.format(distances))
# create a PointCloud object out of each (n,3) list of points
cloud_original = trimesh.points.PointCloud(points)
cloud_close = trimesh.points.PointCloud(closest_points)
# create a unique color for each point
cloud_colors = np.array([trimesh.visual.random_color() for i in points])
# set the colors on the random point and its nearest point to be the same
cloud_original.vertices_color = cloud_colors
cloud_close.vertices_color = cloud_colors
arrs = Arrows(cloud_original.vertices, cloud_close.vertices, c='w')
## create a scene containing the mesh and two sets of points
show(mesh, cloud_original, cloud_close, arrs, Text(__doc__))
"""
Create a set of transparencies
which can be passed to method pointColors()
"""
from vtkplotter import load, show, Text, datadir
mesh = load(datadir + "beethoven.ply")
# pick y coordinates of vertices and use them as scalars
scals = mesh.getPoints()[:, 1]
# define opacities in the range of the scalar,
# at min(scals) alpha is 0.1,
# at max(scals) alpha is 0.9:
alphas = [0.1, 0.1, 0.3, 0.4, 0.9]
mesh.pointColors(scals, alpha=alphas, cmap="copper")
# print(mesh.scalars('pointColors_copper')) # retrieve scalars
show(mesh, Text(__doc__), axes=9)
'''
Intersect a vtkImageData (voxel dataset) with planes.
'''
from vtkplotter import show, loadImageData, probeLine, vector, Text
img = loadImageData('data/embryo.slc')
pos = img.GetCenter()
lines = []
for i in range(60): # probe scalars on 60 parallel lines
step = (i - 30) * 2
p1, p2 = pos + vector(-100, step, step), pos + vector(100, step, step)
a = probeLine(img, p1, p2, res=200)
a.alpha(0.5).lineWidth(6)
lines.append(a)
#print(a.scalars(0)) # numpy scalars can be access here
#print(a.scalars('vtkValidPointMask')) # the mask of valid points
show(lines + [Text(__doc__)], axes=4, verbose=0, bg='w')
This make a simultaneus fit in 4D (space+time).
smoothMLS3D method returns a vtkActor where points
are color coded in bins of fitted time.
Data itself can suggest a meaningful time separation
based on the spatial distribution of points.
The nr neighbours in the local 4D fitting must be specified.
"""
from vtkplotter import Plotter, Sphere, smoothMLS3D, Points, Text
vp = Plotter(N=2, axes=0, bg="w")
# generate uniform points on sphere (tol separates points by 2% of actor size)
cc = Sphere(res=200).clean(tol=0.02).coordinates()
a, b, noise = 0.2, 0.4, 0.1 # some random warping paramenters, and noise factor
sets = []
for i in range(5): # generate a time sequence of 5 shapes
cs = cc + a * i * cc**2 + b * i * cc**3 # warp sphere in weird ways
# set absolute time of points actor, and add 1% noise on positions
ap = Points(cs, c=i, alpha=0.5).addGaussNoise(1.0).time(0.2 * i)
sets.append(ap)
vp.show(Text(__doc__, c="k"), at=0)
vp.show(sets, at=0, zoom=1.4) # show input clouds as func(time)
asse = smoothMLS3D(sets, neighbours=50)
vp.addScalarBar3D(asse, at=1, pos=(-2, 0, -1)) # color indicates fitted time
vp.show(asse, at=1, zoom=1.4, axes=4, interactive=1)
"""
Using normal vtk commands to load a xml vti file
then use vtkplotter to show the resulting 3d image.
"""
import vtk
# Create the reader for the data.
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName("data/vase.vti")
reader.Update()
img = reader.GetOutput()
# specify the data array in the file to process
# img.GetPointData().SetActiveAttribute('SLCImage', 0)
#################################
from vtkplotter import Volume, load, show, Text
# can set colors and transparencies along the scalar range
vol = Volume(img,
c=["gray", "fuchsia", "dg", (0, 0, 1)],
alphas=[0.1, 0.2, 0.3, 0.8])
# load command returns an isosurface (vtkActor) of the 3d image
iso = load("data/vase.vti", threshold=140).wire(True).alpha(0.1)
# show command creates and returns an instance of class Plotter
show([vol, iso, Text(__doc__)], verbose=0, bg="w")
ph = np.deg2rad(long)
p = spher2cart(agrid_reco[j][i], th, ph)
pts1.append(p)
ll.append((lat, long))
radii = agrid_reco.T.ravel()
n = 500j
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 + 1j)]
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)
act1 = Points(pts1, r=5, c="b", alpha=1)
act1_col = Points(pts1colored, r=8, c="k", alpha=0.5)
act2 = Points(pts2, r=3, c="r", alpha=0.5)
act2.clean(0.01) # impose point separation of 1% of the bounding box size
comment = Text('spherical harmonics\nexpansion of order ' + str(lmax))
show(act2, comment, at=1, interactive=True)
"""
Intersect a vtkImageData (voxel dataset) with planes
"""
from vtkplotter import show, loadImageData, probePlane, vector, Text, datadir
img = loadImageData(datadir + "embryo.slc")
planes = []
for i in range(6):
print("probing slice plane #", i)
pos = img.GetCenter() + vector(0, 0, (i - 3) * 25.0)
a = probePlane(img, origin=pos, normal=(0, 0, 1)).alpha(0.2)
planes.append(a)
# print(max(a.scalars(0))) # access scalars this way, 0 means first
show(planes + [Text(__doc__)], axes=4, verbose=0, bg="w")
""" How to share the same color map across different meshes. """ from vtkplotter import load, Text, show, datadir ##################################### man1 = load(datadir + "man.vtk") scals = man1.coordinates()[:, 2] * 5 + 27 # pick z coordinates [18->34] man1.pointColors(scals, cmap="jet", vmin=18, vmax=44) ##################################### man2 = load(datadir + "man.vtk") scals = man2.coordinates()[:, 2] * 5 + 37 # pick z coordinates [28->44] man2.pointColors(scals, cmap="jet", vmin=18, vmax=44) show([[man1, Text(__doc__)], man2], N=2, elevation=-40)
""" Example usage of removeOutliers() and cluster() methods. """ from vtkplotter import show, cluster, removeOutliers, Text import numpy as np # generate 4 random sets of N points in space N = 2000 f = 0.6 noise1 = np.random.rand(N, 3) * f + np.array([1, 1, 0]) noise2 = np.random.rand(N, 3) * f + np.array([1, 0, 1.2]) noise3 = np.random.rand(N, 3) * f + np.array([0, 1, 1]) noise4 = np.random.randn(N, 3) * f / 8 + np.array([1, 1, 1]) noise4 = removeOutliers(noise4, 0.05) # merge points to lose their identity pts = noise1.tolist() + noise2.tolist() + noise3.tolist() + noise4.tolist() # find back their identity through clustering cl = cluster(pts, radius=0.1) # returns a vtkAssembly show(cl, Text(__doc__), axes=1, viewup='z')
"""
Intersect a Volume (voxel dataset) with planes
"""
from vtkplotter import show, load, probePlane, vector, Text, datadir
vol = load(datadir+"embryo.slc")
planes = []
for i in range(6):
print("probing slice plane #", i)
pos = vol.imagedata().GetCenter() + vector(0, 0, (i - 3) * 25.0)
a = probePlane(vol, origin=pos, normal=(0, 0, 1)).alpha(0.2)
planes.append(a)
# print(max(a.scalars(0))) # access scalars this way, 0 means first
show(planes, Text(__doc__), axes=4, bg="w")
"""
Using normal vtk commands to load a xml vti file
then use vtkplotter to show the resulting 3d image.
"""
import vtk
from vtkplotter import datadir
# Create the reader for the data.
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(datadir+"vase.vti")
reader.Update()
img = reader.GetOutput()
# specify the data array in the file to process
# img.GetPointData().SetActiveAttribute('SLCImage', 0)
#################################
from vtkplotter import Volume, load, show, Text
# can set colors and transparencies along the scalar range
vol = Volume(img, c=["gray", "fuchsia", "dg", (0, 0, 1)], alphas=[0.1, 0.2, 0.3, 0.8])
# load command returns an isosurface (vtkActor) of the 3d image
iso = load("data/vase.vti", threshold=140).wire(True).alpha(0.1)
# show command creates and returns an instance of class Plotter
show(vol, iso, Text(__doc__), verbose=0, bg="w")
generate a scalar field by the signed distance from a polydata,
save it to stack.tif file,
then extract an isosurface from the 3d image.
'''
from vtkplotter import Plotter, Points, Text
vp = Plotter(verbose=0)
act = vp.load("data/290.vtk").normalize().subdivide().computeNormals()
# Generate signed distance function and contour it
import vtk
dist = vtk.vtkSignedDistance()
dist.SetInputData(act.polydata())
dist.SetRadius(0.2) #how far out to propagate distance calculation
dist.SetBounds(-2, 2, -2, 2, -2, 2)
dist.SetDimensions(80, 80, 80)
dist.Update()
# vp.write(dist.GetOutput(), 'stack.tif')
fe = vtk.vtkExtractSurface()
fe.SetInputConnection(dist.GetOutputPort())
fe.SetRadius(0.2) # this should match the signed distance radius
fe.Update()
pts = Points(act.coordinates())
vp.show([fe.GetOutput(), pts, Text(__doc__)])
'''
Set a jpeg background image on a vtkRenderingWindow layer,
after the first rendering it can be zoomed to fill the window.
'''
from vtkplotter import Plotter, load, Polygon, Text
doc = Text(__doc__, c='k', bg='w')
vp = Plotter(N=2,
size=(400, 800),
axes=4,
sharecam=0,
bg='data/images/tropical.jpg')
a1 = load('data/shapes/flamingo.3ds').rotateX(-90)
a2 = Polygon()
vp.show([a1, doc], at=0)
vp.backgroundRenderer.GetActiveCamera().Zoom(2.5)
vp.show(a2, at=1, interactive=1)
"""Closing the Rendering Window
Press q:
Control returns to terminal,
window will not close but become unresponsive"""
from vtkplotter import Text, Paraboloid, Hyperboloid, Plotter, show
mesh = Paraboloid()
vp1 = show(mesh, Text(__doc__), title='First Plotter instance')
# Now press 'q' to exit the window interaction,
# windows stays open but not reactive anymore.
# You can go back to interavtion mode by simply calling:
#show()
input(
'\nControl returned to terminal shell:\nwindow is now unresponsive (press Enter)'
)
vp1.closeWindow()
# window should now close, the Plotter instance becomes unusable
# but mesh objects still exist in it:
print("First Plotter actors:", vp1.actors)
vp1.show() # THIS HAS NO EFFECT: window does not exist anymore. Cannot reopen.
##################################################################
# Can now create a brand new Plotter and show the old object in it
'''
Shrink the triangulation of a mesh to make the inside visible.
'''
from vtkplotter import load, Sphere, show, Text
pot = load('data/shapes/teapot.vtk').shrink(0.75)
s = Sphere(r=0.2).pos(0, 0, -0.5)
show([pot, s, Text(__doc__)], viewup='z')
reader.SetFileName(datadir + "vase.vti")
reader.Update()
img = reader.GetOutput() # vtkImageData object
# NB: the above lines could be reduced to:
#img = load(datadir+"vase.vti").imagedata()
#################################
from vtkplotter import Volume, show, Text
# can set colors and transparencies along the scalar range
# from minimum to maximum value. In this example voxels with
# the smallest value will be completely transparent (and white)
# while voxels with highest value of the scalar will get alpha=0.8
# and color will be=(0,0,1)
vol1 = Volume(img, mode=0) # composite rendering
vol1.color(["white", "fuchsia", "dg", (0, 0, 1)])
#vol1.color('jet') # a matplotlib colormap name is also accepted
vol1.alpha([0.0, 0.2, 0.3, 0.8])
# a transparency for the GRADIENT of the scalar can also be set:
# in this case when the scalar is ~constant the gradient is ~zero
# and the voxel are made transparent:
vol1.alphaGradient([0.0, 0.5, 0.9])
# mode = 1 is maximum-projection volume rendering
vol2 = load(datadir + "vase.vti").mode(1).addPos(60, 0, 0)
# show command creates and returns an instance of class Plotter
show(vol1, vol2, Text(__doc__), bg="w", axes=1)
"""
Using normal vtk commands to load a xml vti file
then use vtkplotter to show the resulting 3d image.
"""
import vtk
from vtkplotter import datadir
# Create the reader for the data.
reader = vtk.vtkXMLImageDataReader()
reader.SetFileName(datadir + "vase.vti")
reader.Update()
img = reader.GetOutput()
# specify the data array in the file to process
# img.GetPointData().SetActiveAttribute('SLCImage', 0)
#################################
from vtkplotter import Volume, load, show, Text
# can set colors and transparencies along the scalar range
vol = Volume(img,
c=["gray", "fuchsia", "dg", (0, 0, 1)],
alpha=[0.1, 0.2, 0.3, 0.8])
# load command returns an isosurface (vtkActor) of the 3d image
iso = load(datadir + "vase.vti", threshold=140).wire(True).alpha(0.1)
# show command creates and returns an instance of class Plotter
show(vol, iso, Text(__doc__), bg="w")
"""
Intersect a Volume (voxel dataset) with planes.
"""
from vtkplotter import show, loadVolume, probeLine, vector, Text, datadir
vol = loadVolume(datadir+"embryo.slc")
pos = vol.imagedata().GetCenter()
lines = []
for i in range(60): # probe scalars on 60 parallel lines
step = (i - 30) * 2
p1, p2 = pos + vector(-100, step, step), pos + vector(100, step, step)
a = probeLine(vol, p1, p2, res=200)
a.alpha(0.5).lineWidth(6)
lines.append(a)
# print(a.scalars(0)) # numpy scalars can be access here
# print(a.scalars('vtkValidPointMask')) # the mask of valid points
show(lines, Text(__doc__), axes=4, bg="w")
""" Shrink the triangulation of a mesh to make the inside visible. """ from vtkplotter import load, Sphere, show, Text, datadir pot = load(datadir+"teapot.vtk").shrink(0.75) s = Sphere(r=0.2).pos(0, 0, -0.5) show(pot, s, Text(__doc__), viewup="z")
'''
Extracts the cells where scalar value satisfies a threshold criterion.
'''
from vtkplotter import load, Text, show
doc = Text(__doc__)
man = load('data/shapes/man.vtk')
scals = man.coordinates()[:, 1] + 37 # pick y coords of vertices
man.pointColors(scals, cmap='cool')
man.addScalarBar(title='threshold', horizontal=True)
# make a copy and threshold the mesh
cutman = man.clone().threshold(scals, vmin=36.9, vmax=37.5)
# distribute the actors on 2 renderers
show([[man, doc], cutman], N=2, elevation=-30)
'''
Mirror a mesh along one of the Cartesian axes.
'''
from vtkplotter import Plotter, Text
vp = Plotter(axes=2)
myted1 = vp.load('data/shapes/teddy.vtk')
myted2 = myted1.clone().mirror('y').pos([0, 3, 0]).color('green')
vp.show([myted1, myted2, Text(__doc__)], viewup='z')
RingThickness = 0.3 # thickness of the toroid
RingRadius = 1
k = 1.4e-23 # Boltzmann constant
T = 300 # room temperature
dt = 1.5e-5
#############################################################
def reflection(p, pos):
n = versor(pos)
return np.dot(np.identity(3) - 2 * n * n[:, np.newaxis], p)
vp = Plotter(title="gas in toroid", interactive=0, axes=0, bg="w")
vp.add(Text(__doc__))
vp.add(Torus(c="g", r=RingRadius, thickness=RingThickness, alpha=0.1).wire(1)) ### <--
Atoms = []
poslist = []
plist, mlist, rlist = [], [], []
mass = Matom * Ratom ** 3 / Ratom ** 3
pavg = np.sqrt(2.0 * mass * 1.5 * k * T) # average kinetic energy p**2/(2mass) = (3/2)kT
for i in range(Natoms):
alpha = 2 * np.pi * random()
x = RingRadius * np.cos(alpha) * 0.9
y = RingRadius * np.sin(alpha) * 0.9
z = 0
Atoms = Atoms + [vp.add(Sphere(pos=(x, y, z), r=Ratom, c=i))] ### <--
from vtkplotter import Cube, Text, show, collection
from vtkplotter.settings import fonts
Text("List of available fonts:")
Cube().c('white').rotateX(20).rotateZ(20)
for i, f in enumerate(fonts):
Text(f + ': The quick fox jumps over the lazy dog.',
pos=(5, i * 40 + 20),
font=f,
c=i % 3)
show(collection(), axes=False)