def build_keyboard(self): if self.verbose: print('Building Keyboard..') nts = ("C","D","E","F","G","A","B") tol = 0.12 keybsize = 16.5 # in cm, span of one octave wb = keybsize/7 nr_octaves = 7 span = nr_octaves*wb*7 self.vp = Plotter(title='PianoPlayer '+__version__, axes=0, size=(1400,700), bg='lb', verbose=0) #wooden top and base self.vp.box(pos=(span/2+keybsize, 6, 1), length=span+1, height=3, width= 5, texture='wood5') #top self.vp.box(pos=(span/2+keybsize, 0, -1), length=span+1, height=1, width=17, texture='wood5') self.vp.text('PianoPlayer '+__version__, pos=(18, 5.5, 2), depth=.7) self.vp.text('https://github.com/marcomusy/pianoplayer', pos=(105,4.8,2), depth=.7, s=.8) leggio = self.vp.box(pos=(span/1.55,8,10), length=span/2, height=span/8, width=0.08, c=(1,1,0.9)) leggio.rotateX(-20) self.vp.text('Playing\n\n'+self.songname, s=1.2).rotateX(70).pos([49,11,9]) for ioct in range(nr_octaves): for ik in range(7): #white keys x = ik * wb + (ioct+1)*keybsize +wb/2 tb = self.vp.box(pos=(x,-2,0), length=wb-tol, height=1, width=12, c='white') self.KB.update({nts[ik]+str(ioct+1) : tb}) if not nts[ik] in ("E","B"): #black keys tn=self.vp.box(pos=(x+wb/2,0,1), length=wb*.6, height=1, width=8, c='black') self.KB.update({nts[ik]+"#"+str(ioct+1) : tn}) self.vp.show(interactive=0) self.vp.camera.Azimuth(4) self.vp.camera.Elevation(-30)
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.setupUi(self) self.vtkWidget = QVTKRenderWindowInteractor(self) self.vtkLayout.addWidget(self.vtkWidget) self.plt = Plotter(qtWidget=self.vtkWidget, axes=1, bg='white') self.plt += load(datadir + 'shark.ply').c('cyan') self.plt.show()
def render(self): """ """ self.apply_render_style() # Create camera and plotter if brainrender.WHOLE_SCREEN: sz = "full" else: sz = "auto" if brainrender.SHOW_AXES: axes = 4 else: axes = 0 mv = Plotter(N=2, axes=axes, size=sz, pos=brainrender.WINDOW_POS, bg=brainrender.BACKGROUND_COLOR, sharecam=True) actors = [] for scene in self.scenes: scene_actors = scene.get_actors() actors.append(scene_actors) mv.add(scene_actors) mv.show(actors[0], at=0, zoom=1.15, axes=axes, roll=180, interactive=False) mv.show(actors[1], at=1, interactive=False) interactive()
def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.vl = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) vp = Plotter(qtWidget=self.vtkWidget, axes=4, bg='white') vp += Cone() vp.show() # create renderer and add the actors # set-up the rest of the Qt window self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() # <--- show the Qt Window
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow): def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.setupUi(self) self.vtkWidget = QVTKRenderWindowInteractor(self) self.vtkLayout.addWidget(self.vtkWidget) self.plt = Plotter(qtWidget=self.vtkWidget, axes=1, bg='white') self.plt += load(datadir + 'shark.ply').c('cyan') self.plt.show() def onClose(self): print( "Disable the interactor before closing to prevent it from trying to act on a already deleted items" ) self.vtkWidget.close()
def plot_stl_faces_segmentation(struct_seg1, num_segments1, surface_seg1, vertices, title, noize=None): """Функция для прорисовки фасет stl объекта, основанных на цвете по кривизне для каждой фасеты. Исключается шум, заданный пользователем """ struct_seg = np.array([]) num_segments = np.array([]) surface_seg = [] if noize is None: # Если noize не задано - не надо улалять шум, оставляем структуру как есть struct_seg = copy.deepcopy(struct_seg1).astype('int') num_segments = copy.deepcopy(num_segments1) surface_seg = copy.deepcopy(surface_seg1) else: idx = np.where(num_segments1 > noize) if len(idx[0]) > 0: for j in range(len(idx[0])): surface_seg.append([]) t = surface_seg1[idx[0][j]] surface_seg[j] = copy.deepcopy(t) num_segments = np.append(num_segments, num_segments1[idx[0][j]]) struct_seg = np.append(struct_seg, len(idx[0])).astype('int') else: print('Все участки меньше допуска, рисуем все') struct_seg = copy.deepcopy(struct_seg1).astype('int') num_segments = copy.deepcopy(num_segments1[0, :]) surface_seg = copy.deepcopy(surface_seg1) vp = Plotter(title=title, interactive=0, axes=0) # работа с палитрой lab = parula(struct_seg[0]) for num in range(0, struct_seg[0]): mesh = trimesh.Trimesh(vertices=vertices, faces=surface_seg[num], process=False) mesh.visual.face_colors = lab[num, :] vp += mesh vp.show()
def importWindow(fileinput): """Import a whole scene from a Numpy file.""" import numpy as np from vtkplotter import Plotter data = np.load(fileinput, allow_pickle=True)[0] settings.renderPointsAsSpheres = data['renderPointsAsSpheres'] settings.renderLinesAsTubes = data['renderLinesAsTubes'] settings.hiddenLineRemoval = data['hiddenLineRemoval'] settings.visibleGridEdges = data['visibleGridEdges'] settings.interactorStyle = data['interactorStyle'] vp = Plotter(pos=data['position'], size=data['size'], axes=data['axes'], title=data['title'], bg=data['backgrcol'], infinity=data['infinity'], depthpeeling=data['depthpeeling'], ) vp.xtitle = data['xtitle'] vp.ytitle = data['ytitle'] vp.ztitle = data['ztitle'] vp.actors = loadNumpy(data['objects']) return vp
def importWindow(fileinput): """Import a whole scene from a Numpy file. Return ``Plotter`` instance.""" from vtkplotter import Plotter data = np.load(fileinput, allow_pickle=True, encoding="latin1").flatten()[0] if 'renderPointsAsSpheres' in data.keys(): settings.renderPointsAsSpheres = data['renderPointsAsSpheres'] if 'renderLinesAsTubes' in data.keys(): settings.renderLinesAsTubes = data['renderLinesAsTubes'] if 'hiddenLineRemoval' in data.keys(): settings.hiddenLineRemoval = data['hiddenLineRemoval'] if 'visibleGridEdges' in data.keys(): settings.visibleGridEdges = data['visibleGridEdges'] if 'interactorStyle' in data.keys(): settings.interactorStyle = data['interactorStyle'] if 'useParallelProjection' in data.keys(): settings.useParallelProjection = data['useParallelProjection'] axes = data.pop('axes', 4) title = data.pop('title', '') backgrcol = data.pop('backgrcol', "blackboard") vp = Plotter( #size=data['size'], # not necessarily a good idea to set it #shape=data['shape'], axes=axes, title=title, bg=backgrcol, ) vp.xtitle = data.pop('xtitle', 'x') vp.ytitle = data.pop('ytitle', 'y') vp.ztitle = data.pop('ztitle', 'z') if 'objects' in data.keys(): objs = loadNumpy(data['objects']) if not utils.isSequence(objs): objs = [objs] else: colors.printc("Trying to import a that was not exported.", c=1) colors.printc(" -> try to load a single object with load().", c=1) return loadNumpy(fileinput) vp.actors = objs # if vp.shape==(1,1): # vp.actors = loadNumpy(data['objects']) # else: # print(objs, ) # for a in objs: # for ar in a.renderedAt: # print(vp.shape, [a], ar ) # vp.show(a, at=ar) return vp
def importWindow(fileinput): """Import a whole scene from a Numpy file. Return ``Plotter`` instance.""" import numpy as np from vtkplotter import Plotter data = np.load(fileinput, allow_pickle=True)[0] if 'renderPointsAsSpheres' in data.keys(): settings.renderPointsAsSpheres = data['renderPointsAsSpheres'] if 'renderLinesAsTubes' in data.keys(): settings.renderLinesAsTubes = data['renderLinesAsTubes'] if 'hiddenLineRemoval' in data.keys(): settings.hiddenLineRemoval = data['hiddenLineRemoval'] if 'visibleGridEdges' in data.keys(): settings.visibleGridEdges = data['visibleGridEdges'] if 'interactorStyle' in data.keys(): settings.interactorStyle = data['interactorStyle'] if 'useParallelProjection' in data.keys(): settings.useParallelProjection = data['useParallelProjection'] pos = data.pop('position', (0, 0)) axes = data.pop('axes', 4) title = data.pop('title', '') backgrcol = data.pop('backgrcol', "blackboard") vp = Plotter( pos=pos, #size=data['size'], # not necessarily a good idea to set it #shape=data['shape'], axes=axes, title=title, bg=backgrcol, ) vp.xtitle = data.pop('xtitle', 'x') vp.ytitle = data.pop('ytitle', 'y') vp.ztitle = data.pop('ztitle', 'z') objs = loadNumpy(data['objects']) if not utils.isSequence(objs): objs = [objs] vp.actors = objs # if vp.shape==(1,1): # vp.actors = loadNumpy(data['objects']) # else: # print(objs, ) # for a in objs: # for ar in a.renderedAt: # print(vp.shape, [a], ar ) # vp.show(a, at=ar) return vp
def demo3d_hanoi(**kwargs): nr_disks = kwargs.get("nr_disks", 5) interactive = kwargs.get("interactive", 1) hanoi = Hanoi(nr_disks) tower_states = list([hanoi.towers]) for _ in hanoi.moves(): tower_states.append(hanoi.towers) vp = Plotter(axes=0, interactive=0, bg="w", size=(800, 600)) vp.camera.SetPosition([18.5, -20.7, 7.93]) vp.camera.SetFocalPoint([3.0, 0.0, 2.5]) vp.camera.SetViewUp([-0.1, +0.17, 0.977]) cols = makePalette("red", "blue", hanoi.nr_disks + 1, hsv=True) disks = { hanoi.nr_disks - i: Cylinder(pos=[0, 0, 0], r=0.2 * (hanoi.nr_disks - i + 1), c=cols[i]) for i in range(hanoi.nr_disks) } for k in disks: vp += disks[k] vp += Box(pos=(3.0, 0, -.5), length=12.0, width=4.0, height=0.1) vp.show(zoom=1.2) printc("\n Press q to continue, Esc to exit. ", c="y", invert=1) pb = ProgressBar(0, len(tower_states), 1, c="b", ETA=False) for t in pb.range(): pb.print() state = tower_states[t] for tower_nr in range(3): for i, disk in enumerate(state[tower_nr]): disks[disk].pos([3 * tower_nr, 0, i + 0.5]) vp.show(resetcam=0, interactive=interactive, rate=10) vp.show(resetcam=0, interactive=1)
def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.vl = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) vp = Plotter(offscreen=1, interactive=0, axes=2, N=2) cn = Cone() cc = Cube().pos(1, 1, 1).color("pink") ss = Torus() vp.show(cn, cc, at=0) vp.show(ss, at=1, viewup="z") self.start(vp)
def export_for_web(self, filepath='brexport.html'): """ This function is used to export a brainrender scene for hosting it online. It saves an html file that can be opened in a web browser to show an interactive brainrender scene """ if not filepath.endswith('.html'): raise ValueError("Filepath should point to a .html file") # prepare settings settings.notebookBackend = 'k3d' self.jupyter=True self.render() # Create new plotter and save to file plt = Plotter() plt.add(self.get_actors()) plt = plt.show(interactive=False) plt.camera[-2] = -1 print('Ready for exporting. Exporting scenes with many actors might require a few minutes') try: with open(filepath,'w') as fp: fp.write(plt.get_snapshot()) except: raise ValueError("Failed to export scene for web.\n"+ "Try updating k3d and msgpack: \ "+ "pip install -U k3d\n"+ "pip install -U msgpack") print(f"The brainrender scene has been exported for web. The results are saved at {filepath}") # Reset settings settings.notebookBackend = None self.jupyter = False
def render(self, _interactive=True, **kwargs): """ :param _interactive: (Default value = True) :param **kwargs: """ camera = kwargs.pop("camera", None) for scene in self.scenes: scene.apply_render_style() if camera is None: if scene.atlas.default_camera is None: scene_camera = brainrender.CAMERA else: scene_camera = scene.atlas.default_camera else: if camera: scene_camera = camera else: scene_camera = None if scene_camera is not None: set_camera(scene, scene_camera) if self.N > 4: print("Rendering {} scenes. Might take a few minutes.".format(self.N)) mv = Plotter(N=self.N, axes=4, size="auto", sharecam=True, bg=brainrender.BACKGROUND_COLOR) actors = [] for i, scene in enumerate(self.scenes): scene_actors = scene.get_actors() actors.append(scene_actors) mv.add(scene_actors) for i, scene_actors in enumerate(actors): mv.show(scene_actors, at=i, interactive=False) print("Rendering complete") if _interactive: interactive()
if vp: self.vtk_actor = vp.add(Sphere( pos, r=radius, c=color)) # Sphere representing the particle # vp.addTrail(alpha=0.4, maxlength=1, n=50) # Add a trail behind the particle self.vtk_actor.addTrail(alpha=0.4, maxlength=1, n=50) ##################################################################################################### if __name__ == "__main__": # An example simulation of N particles scattering on a charged target. # See e.g. https://en.wikipedia.org/wiki/Rutherford_scattering vp = Plotter(title="Particle Simulator", bg="black", axes=0, interactive=False) vp.camera.Elevation(20) # Initial camera position vp.camera.Azimuth(40) vp.add(Cube(c="white").wire(1)) # a wireframe cube sim = ParticleSim(dt=5e-6, iterations=200) sim.add_particle((-0.4, 0, 0), color="w", charge=3e-6, radius=0.01, fixed=True) # the target positions = np.random.randn(500, 3) / 60 # generate a beam of 500 particles
to add a sphere and some info is printed. """ from vtkplotter import Plotter, printc, Sphere, Text, datadir ############################################################################## def myfnc(key): if not vp.clickedActor or key != "c": printc("click an actor and press c.", c="r") return printc("clicked actor :", vp.clickedActor.legend(), c=4) printc("clicked 3D point:", vp.picked3d, c=4) printc("clicked renderer:", [vp.renderer], c=2) vp.add(Sphere(pos=vp.picked3d, r=0.005, c="v")) vp.show() ############################################################################## vp = Plotter(verbose=0) vp.keyPressFunction = myfnc # make it known to Plotter class vp.load(datadir + "bunny.obj") vp.add(Text(__doc__)) printc("\nPress c to execute myfnc()", c=1) vp.show()
""" Example of boolean operations with actors or polydata """ print(__doc__) from vtkplotter import Plotter, booleanOperation, Sphere # declare the instance of the class vp = Plotter(shape=(2, 2), interactive=0, axes=3) # build to sphere actors s1 = Sphere(pos=[-0.7, 0, 0], c="r", alpha=0.5) s2 = Sphere(pos=[0.7, 0, 0], c="g", alpha=0.5) # make 3 different possible operations: b1 = booleanOperation(s1, "intersect", s2).c('m').legend("intersect") b2 = booleanOperation(s1, "plus", s2).c("b").wireframe(True).legend("plus") b3 = booleanOperation(s1, "minus", s2).legend("minus").addScalarBar(c='w') # show the result in 4 different subwindows 0->3 vp.show(s1, s2, at=0) vp.show(b1, at=1) vp.show(b2, at=2) vp.show(b3, at=3) vp.show(interactive=1)
''' Example usage of align() method: generate two random sets of points as 2 actors and align them using the Iterative Closest Point algorithm. ''' from __future__ import division from random import uniform as u from vtkplotter import Plotter, align, Arrow, Text, Points vp = Plotter(shape=[1, 2], verbose=0, axes=2, bg='w') N1 = 15 # number of points of first set N2 = 15 # number of points of second set x = 1. # add some randomness pts1 = [(u(0, x), u(0, x), u(0, x) + i) for i in range(N1)] pts2 = [(u(0, x) + 3, u(0, x) + i / 2 + 2, u(0, x) + i + 1) for i in range(N2)] act1 = Points(pts1, r=8, c='b').legend('source') act2 = Points(pts2, r=8, c='r').legend('target') vp.show([act1, act2], at=0) # find best alignment between the 2 sets of Points, e.i. find # how to move act1 to best match act2 alpts1 = align(act1, act2).coordinates() vp.add(Points(alpts1, r=8, c='b')) for i in range(N1): # draw arrows to see where points end up vp.add(Arrow(pts1[i], alpts1[i], c='k', s=0.007, alpha=.1))
# Extract the mesh region that has the largest connected surface # from vtkplotter.analysis import extractLargestRegion from vtkplotter.utils import area from vtkplotter import Plotter, printc vp = Plotter(shape=(2,1)) act1 = vp.load('data/embryo.slc', c='y') printc('area1 =', area(act1), c='y') act2 = extractLargestRegion(act1).color('b') printc('area2 =', area(act2), c='b') vp.show(act1, at=0) vp.show(act2, at=1, zoom=1.2, interactive=1)
Natoms = 400 # change this to have more or fewer atoms Nsteps = 350 # nr of steps in the simulation Matom = 4E-3/6E23 # helium mass Ratom = 0.025 # wildly exaggerated size of helium atom RingThickness=0.3 # thickness of the toroid RingRadius=1 k = 1.4E-23 # Boltzmann constant T = 300 # room temperature dt = 1E-5 ############################################################# def reflection(p, pos): n = norm(pos) return np.dot(np.identity(3)-2*n*n[:,np.newaxis], p) vp = Plotter(title='gas in toroid', verbose=0, axes=0) vp.add(torus(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.add(sphere(pos=(x,y,z), r=Ratom, c=i))] ### <--
"""Normal jpg/png pictures can be loaded, cropped, rotated and positioned in 3D """ from vtkplotter import Plotter, datadir vp = Plotter(axes=3) for i in range(5): p = vp.load(datadir + "images/dog.jpg") # returns Picture p.crop(bottom=0.2) # crop 20% p.scale(1 - i / 10.0).alpha(0.8) # picture can be scaled in size p.rotateX(20 * i).pos(0, 0, 30 * i) # (can concatenate methods) vp += __doc__ vp.show()
from vtkplotter import Plotter, Sphere from vtkplotter.analysis import surfaceIntersection vp = Plotter() car = vp.load('data/shapes/porsche.ply', c='gold').alpha(0.1) s = Sphere(r=4, c='v', alpha=0.1).wire(True) # color is violet # Intersect car with Sphere, c=black, lw=line width contour = surfaceIntersection(car, s, lw=4) vp.show([car, contour, s], zoom=1.3)
if vp: self.vtk_actor = vp.add(Sphere( pos, r=radius, c=color)) # Sphere representing the particle # vp.addTrail(alpha=0.4, maxlength=1, n=50) # Add a trail behind the particle self.vtk_actor.addTrail(alpha=0.4, maxlength=1, n=50) ##################################################################################################### if __name__ == "__main__": # An example simulation of N particles scattering on a charged target. # See e.g. https://en.wikipedia.org/wiki/Rutherford_scattering vp = Plotter(title="Particle Simulator", bg="black", axes=0, interactive=False) vp += Cube(c="white").wireframe(1) # a wireframe cube sim = ParticleSim(dt=5e-6, iterations=200) sim.add_particle((-0.4, 0, 0), color="w", charge=3e-6, radius=0.01, fixed=True) # the target positions = np.random.randn(500, 3) / 60 # generate a beam of 500 particles for p in positions: p[0] = -0.5 # Fix x position. Their charge are small/negligible compared to target:
Matom = 4E-3 / 6E23 # helium mass Ratom = 0.025 # wildly exaggerated size of helium atom 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 = norm(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=.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()
""" Make a textured floor, a lamp post, and load a mesh of a car make copies of the car, rotate and move them in a loop. rate=10 limits the speed of the loop to maximum 10 fps """ from __future__ import division, print_function from vtkplotter import Plotter, Plane, Text, datadir vp = Plotter(interactive=0, axes=0) vp.add(Plane(pos=(4, 0, -0.45), sx=12, texture="metalfloor1")) # load and set its position (methods can be concatenated) vp.load(datadir + "lamp.vtk").pos([1.7, -0.4, 2]) a = vp.load(datadir + "porsche.ply", c="r").rotateX(90) a.normalize() # set actor at origin and scale size to 1 for i in range(1, 10): b = a.clone().color("aqua").alpha(0.04 * i) b.rotateX(-20 * i).rotateY(-10 * i).pos([i, i / 2, i / 2]) vp.add(b) # add actor b vp.show(rate=10) # maximum frame rate in hertz print(i, "time:", vp.clock, "s") vp.add(Text(__doc__)) vp.show(interactive=1)
grid_reco = clm.expand(lmax=lmax) # cut "high frequency" components agrid_reco = grid_reco.to_array() 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 = 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
# Add a square button with N possible internal states # to a rendering window that calls an external function. # # Available fonts: arial, courier, times # from vtkplotter import Plotter, printc vp = Plotter(shape=(2, 1), axes=4) act = vp.load('data/shapes/magnolia.vtk', c='v') vp.show(act, at=0) vp.show(act, at=1) # add a button to the current renderer (e.i. nr1) def buttonfunc(): act.alpha(1 - act.alpha()) # toggle mesh transparency bu.switch() # change to next status printc(bu.status(), box='_', dim=True) bu = vp.addButton( buttonfunc, pos=(350, 20), # x,y pixels from bottom left corner states=['press to hide', 'press to show'], c=['w', 'w'], bc=['dg', 'dv'], # colors of states font='courier', size=18, bold=True,
from __future__ import division, print_function from vtkplotter import Plotter, ProgressBar, vector vp = Plotter(title='Spring in viscous medium', verbose=0, axes=3) l_rest = 0.1 # spring x position at rest x0 = 0.85 # initial x-coordinate of the block k = 25 # spring constant m = 20 # block mass b = 0.5 # viscosity friction (proportional to velocity) dt = 0.1 # time step #initial conditions v = vector(0, 0, 0.2) x = vector(x0, 0, 0) xr = vector(l_rest, 0, 0) sx0 = vector(-0.8, 0, 0) offx = vector(0, 0.3, 0) vp.box(pos=(0, -0.1, 0), length=2.0, width=0.02, height=0.5) #surface vp.box(pos=(-.82, .15, 0), length=.04, width=0.50, height=0.3) #wall block = vp.cube(pos=x, length=0.2, c='t') spring = vp.helix(sx0, x, r=.06, thickness=.01, texture='metal1') pb = ProgressBar(0, 500, c='r') for i in pb.range(): F = -k * (x - xr) - b * v # Force and friction a = F / m # acceleration v = v + a * dt # velocity x = x + v * dt + 1 / 2 * a * dt**2 # position
''' In this example we fit spheres to a region of a surface defined by N points that are closest to a given point of the surface. For some of these point we show the fitting sphere. Red lines join the center of the sphere to the surface point. Blue points are the N points used for fitting. Green histogram is the distribution of residuals from the fitting. Red histogram is the distribution of the curvatures (1/r**2). Fitted radius can be accessed from actor.info['radius']. ''' from __future__ import division, print_function from vtkplotter import Plotter, fitSphere, histogram, Points, Line, Text vp = Plotter(verbose=0, axes=0) # load mesh and increase by a lot (N=2) the nr of surface vertices s = vp.load('data/shapes/cow.vtk').alpha(0.3).subdivide(N=2) reds, invr = [], [] for i, p in enumerate(s.coordinates()): if i%1000: continue # skip most points pts = s.closestPoint(p, N=16) # find the N closest points to p sph = fitSphere(pts).alpha(0.05) # find the fitting sphere if sph is None: continue # may fail if all points sit on a plane vp.add(sph) vp.add(Points(pts)) vp.add(Line(sph.info['center'], p, lw=2)) reds.append(sph.info['residue']) invr.append(1/sph.info['radius']**2)
""" Example of drawing objects on different windows and/or subwindows within the same window. We split the main window in a 25 subwindows and draw something in specific windows numbers. Then open an independent window and draw a shape on it. """ print(__doc__) from vtkplotter import Plotter, Text, datadir # this is one instance of the class Plotter with 5 raws and 5 columns vp1 = Plotter(shape=(5, 5), axes=0, bg="white") # having set shape=(n,m), script execution after the show() is not held # set a different background color for a specific subwindow (the last one) vp1.renderers[24].SetBackground(0.8, 0.9, 0.9) # use vtk method SetBackground() # load the actors and give them a name a = vp1.load(datadir + "airboat.vtk").legend("some legend") b = vp1.load(datadir + "cessna.vtk", c="red") c = vp1.load(datadir + "atc.ply") # show a text in each renderer for i in range(25): txt = Text("renderer\nnr." + str(i), c='k', s=0.5, font='arial') vp1.show(txt, at=i, interactive=0) vp1.show(a, at=22) vp1.show(b, at=23)
from __future__ import division, print_function from vtkplotter import Plotter, mag import numpy as np scene = Plotter(title='Lorenz attractor', axes=2, verbose = 0) dt = 0.001 y = [25, -10, -7] # Starting point (initial condition) pts, cols = [], [] scene.point(y, r=20, c='g', alpha=0.3) for t in np.linspace(0,20, int(20/dt)): # Integrate a funny differential equation dydt = np.array([-8/3*y[0]+ y[1]*y[2], -10*(y[1]-y[2]), -y[1]*y[0]+28*y[1]-y[2]]) y = y + dydt * dt c = np.clip( [mag(dydt) * 0.005], 0, 1)[0] # color by speed pts.append(y) cols.append([c,0, 1-c]) scene.points(pts, cols, r=2) scene.show()