# Example usage of addTrail() # from vtkplotter import Plotter, sin vp = Plotter(axes=6) s = vp.sphere(c='green', res=24) vp.cutPlane(s, [-0.9, 0, 0], showcut=True) #cut left part of sphere p = vp.point([1, 1, 1], r=12) # add a trail to point p with maximum length 0.5 and 50 segments p.addTrail(c='k', lw=3, maxlength=0.5, n=50) for i in range(200): p.pos([-2 + i / 100., sin(i / 5.) / 15, 0]) vp.render() vp.camera.Azimuth(-0.2) vp.show(resetcam=0)
phidot = 0 # (try -1 and +1 to get first and second pattern) # ############################################################ g, r = 9.81, Lshaft/2 I3 = 1/2*M*R**2 # moment of inertia, I, of gyroscope about its own axis I1 = M*r**2 + 1/2*I3 # I about a line through the support, perpendicular to axis phi = psi = thetadot = 0 x = vector(theta, phi, psi) # Lagrangian coordinates v = vector(thetadot, phidot, psidot) # ############################################################ the scene vp = Plotter(verbose=0, axes=3, interactive=0) shaft = vp.cylinder([[0,0,0], [Lshaft,0,0]], r=.03, c='dg') rotor = vp.cylinder([[Lshaft/2.2,0,0],[Lshaft/1.8,0,0]], r=R, texture='marble') base = vp.sphere([ 0, 0, 0], c='dg', r=.03) tip = vp.sphere([Lshaft, 0, 0], c='dg', r=.03) gyro = vp.makeAssembly([shaft, rotor, base, tip]) # group relevant actors pedestal = vp.box([0,-0.63,0], height=.1, length=.1, width=1, texture='wood5') pedbase = vp.box([0,-1.13,0], height=.5, length=.5, width=.05, texture='wood5') pedpin = vp.pyramid([0,-.08,0], axis=[0,1,0], s=.05, height=.12, texture='wood5') formulas = vp.load('data/images/gyro_formulas.png', alpha=.9).scale(.003).pos([-1,-1,-1.1]) # ############################################################ the physics pb = ProgressBar(0, 4, dt, c='b') for i, t in enumerate(pb.range()): st, ct, sp, cp = sin(x[0]), cos(x[0]), sin(x[1]), cos(x[1]) thetadot, phidot, psidot = v # unpack atheta = st*ct*phidot**2 + (M*g*r*st-I3*(psidot+phidot*ct)*phidot*st)/I1
vp.ring(c='g', r=RingRadius, thickness=RingThickness, alpha=.1, wire=1) ### <-- Atoms = [] poslist = [] plist, mlist, rlist = [], [], [] mass = Matom * Ratom**3 / Ratom**3 pavg = np.sqrt(2. * 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) * .9 y = RingRadius * np.sin(alpha) * .9 z = 0 Atoms = Atoms + [vp.sphere(pos=(x, y, z), r=Ratom, c=i)] ### <-- theta = np.pi * random() phi = 2 * np.pi * random() px = pavg * np.sin(theta) * np.cos(phi) py = pavg * np.sin(theta) * np.sin(phi) pz = pavg * np.cos(theta) poslist.append((x, y, z)) plist.append((px, py, pz)) mlist.append(mass) rlist.append(Ratom) pos = np.array(poslist) poscircle = pos p = np.array(plist) m = np.array(mlist) m.shape = (Natoms, 1)
# Shrink the triangulation of a mesh to make the inside visible # from vtkplotter import Plotter vp = Plotter() vp.load('data/shapes/teapot.vtk').shrink(0.8) vp.sphere(r=0.2).pos([0, 0, -0.5]) vp.show(viewup='z', zoom=1.2)
a2 = a1.subdivide(method=0) # Increasing the number of points of the mesh coords2 = a2.coordinates() pts2 = vp.points(coords2, r=1, legend='#points = ' + str(len(coords2))) vp.show([a2, pts2], at=1, interactive=True) ######################################################################################## # Draw a bunch of simple objects on separate parts of the rendering window: # split window to best accomodate 9 renderers vp = Plotter(N=9, title='basic shapes') vp.sharecam = False # each object can be moved independently vp.show(at=0, actors=vp.arrow([0, 0, 0], [1, 1, 1]), legend='arrow') vp.show(at=1, actors=vp.line([0, 0, 0], [1, 1, 1]), legend='line') vp.show(at=2, actors=vp.points([[0, 0, 0], [1, 1, 1]]), legend='points') vp.show(at=3, actors=vp.text('Hello!')) vp.show(at=4, actors=vp.sphere()) vp.show(at=5, actors=vp.cube(), legend='cube') vp.show(at=6, actors=vp.ring(), legend='ring') vp.show(at=7, actors=vp.helix(), legend='helix') vp.show(at=8, actors=vp.cylinder(), legend='cylinder', interactive=1) ######################################################################################## # Draw a bunch of objects from various mesh formats. Loading is automatic. vp = Plotter(shape=(3, 3), title='mesh formats') # split window in 3 rows and 3 columns vp.sharecam = False # each object can be moved independently vp.show('data/beethoven.ply', at=0, c=0, axes=0, ruler=1) # dont show axes, add a ruler vp.show('data/cow.g', at=1, c=1, zoom=1.15) # make it 15% bigger vp.show('data/limb.pcd', at=2, c=2) vp.show('data/ring.gmsh', at=3, c=3, wire=1)
ListPos.append(PossiblePos[n]) del PossiblePos[n] Pos = np.array(ListPos) # Create an array with all the radius and a list with all the masses Radius = np.concatenate((np.array([Rb]), np.array([Rs] * (Nsp - 1)))) Mass = [1.0] + [Ms] * (Nsp - 1) # Create the initial array of velocities at random with big sphere at rest ListVel = [(0., 0.)] for s in range(1, Nsp): ListVel.append((Rb * random.uniform(-1, 1), Rb * random.uniform(-1, 1))) Vel = np.array(ListVel) # Create the spheres Spheres = [vp.sphere(pos=(Pos[0][0], Pos[0][1], 0), r=Radius[0], c='red')] for s in range(1, Nsp): a = vp.sphere(pos=(Pos[s][0], Pos[s][1], 0), r=Radius[s], c='blue') Spheres.append(a) vp.grid(sx=screen_w, sy=screen_w) # Auxiliary variables Id = np.identity(Nsp) Dij = (Radius + Radius[:, np.newaxis])**2 # Matrix Dij=(Ri+Rj)**2 # The main loop pb = ProgressBar(0, 2000, c='r') for i in pb.range(): # Update all positions np.add(Pos, Vel * Dt, Pos) # Fast version of Pos = Pos + Vel*Dt
# ############################################################ g, r = 9.81, Lshaft / 2 I3 = 1 / 2 * M * R**2 # moment of inertia, I, of gyroscope about its own axis I1 = M * r**2 + 1 / 2 * I3 # I about a line through the support, perpendicular to axis phi = psi = thetadot = 0 x = vector(theta, phi, psi) # Lagrangian coordinates v = vector(thetadot, phidot, psidot) # ############################################################ the scene vp = Plotter(verbose=0, axes=0, interactive=0) shaft = vp.cylinder([[0, 0, 0], [Lshaft, 0, 0]], r=.03, c='dg') rotor = vp.cylinder([[Lshaft / 2.2, 0, 0], [Lshaft / 1.8, 0, 0]], r=R, texture='marble') base = vp.sphere([0, 0, 0], c='dg', r=.03) tip = vp.sphere([Lshaft, 0, 0], c='dg', r=.03) gyro = vp.Assembly([shaft, rotor, base, tip]) # group relevant actors pedestal = vp.box([0, -0.63, 0], height=.1, length=.1, width=1, texture='wood5') pedbase = vp.box([0, -1.13, 0], height=.5, length=.5, width=.05, texture='wood5') pedpin = vp.pyramid([0, -.08, 0], axis=[0, 1, 0],
# Work with vtkVolume objects and surfaces. # from vtkplotter import vtkio, Plotter from vtkplotter.actors import Volume vp = Plotter() # Load a 3D voxel dataset (returns a vtkImageData object): img = vtkio.loadImageData('data/embryo.slc', spacing=[1, 1, 1]) # Build a vtkVolume object. # A set of transparency values - of any length - can be passed # to define the opacity transfer function in the range of the scalar. # E.g.: setting alphas=[0, 0, 0, 1, 0, 0, 0] would make visible # only voxels with value close to 98.5 (see print output). vol = Volume(img, c='green', alphas=[0, 0.4, 0.9, 1]) # vtkVolume # can relocate volume in space: #vol.scale(0.3).pos([10,100,0]).rotate(90, axis=[0,1,1]) sph = vp.sphere(pos=[100, 100, 100], r=20) # add a dummy surface vp.show([vol, sph], zoom=1.4) # show both vtkVolume and vtkActor
pts = [] for i, longs in enumerate(agrid_reco): ilat = grid_reco.lats()[i] for j, value in enumerate(longs): ilong = grid_reco.lons()[j] th = (90 - ilat)/57.3 ph = ilong/57.3 r = value + rbias p = np.array([sin(th)*cos(ph), sin(th)*sin(ph), cos(th)])*r pts.append(p) return pts vp = Plotter(shape=[2,2], verbose=0, axes=3, interactive=0) shape1 = vp.sphere(alpha=0.2) shape2 = vp.load('data/shapes/icosahedron.vtk').normalize().lineWidth(1) agrid1, actorpts1 = makegrid(shape1, N) vp.show(at=0, actors=[shape1, actorpts1]) agrid2, actorpts2 = makegrid(shape2, N) vp.show(at=1, actors=[shape2, actorpts2]) 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()
# Example of boolean operations with actors or polydata # from vtkplotter import Plotter from vtkplotter.analysis import booleanOperation # declare the instance of the class vp = Plotter(shape=(2,2), interactive=0, axes=3) # build to sphere actors s1 = vp.sphere(pos=[-.7,0,0], c='r', alpha=0.5) s2 = vp.sphere(pos=[0.7,0,0], c='g', alpha=0.5) # make 3 different possible operations: b1 = booleanOperation(s1, s2, 'intersect', c='m') b2 = booleanOperation(s1, s2, 'plus', c='b', wire=True) b3 = booleanOperation(s1, s2, 'minus', c=None) # show the result in 4 different subwindows 0->3 vp.show([s1,s2], at=0, legend='2 spheres') vp.show(b1, at=1, legend='intersect') vp.show(b2, at=2, legend='plus') vp.show(b3, at=3, legend='minus') vp.addScalarBar() # adds a scalarbar to the last actor vp.show(interactive=1)
y_dot = [0] * (N + 1) for k in range(1, N + 1): alpha = np.pi / 5 * k / 10 bob_x.append(bob_x[k - 1] + np.cos(alpha) + np.random.normal(0, .1)) bob_y.append(bob_y[k - 1] + np.sin(alpha) + np.random.normal(0, .1)) # Create the bobs vp = Plotter(title="Multiple Pendulum", axes=0, verbose=0) vp.box(pos=(bob_x[0], bob_y[0], 0), length=12, width=12, height=.7, c='k', wire=1) bob = [vp.sphere(pos=(bob_x[0], bob_y[0], 0), r=R / 2, c='gray')] for k in range(1, N + 1): bob.append(vp.cylinder(pos=(bob_x[k], bob_y[k], 0), r=R, height=.3, c=k)) # Create the springs out of N links link = [0] * N for k in range(N): p0 = bob[k].pos() p1 = bob[k + 1].pos() link[k] = vp.helix(p0, p1, thickness=.015, r=R / 3, c='gray') # Create some auxiliary variables x_dot_m = [0] * (N + 1) y_dot_m = [0] * (N + 1) dij = [0] * (N + 1) # array with distances to previous bob dij_m = [0] * (N + 1)
# Example use of addTrail() and updateTrail() # from vtkplotter import Plotter, sin vp = Plotter(axes=1, interactive=0) c = vp.cube() vp.cutPlane(c, [-0.4, 0, 0]) #cut away the left face s = vp.sphere([1, 1, 1], r=.03, c='db') # add a trail to last created actor with max 50 segments vp.addTrail(c='k', lw=3, maxlength=.5, n=50) for i in range(200): s.pos([-2. + i / 100., sin(i / 5.) / 10., 0]).updateTrail() vp.render() vp.camera.Azimuth(-.3) vp.show(interactive=1)