def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.layout = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) # Create vedo renderer and add objects and callbacks self.vp = Plotter(qtWidget=self.vtkWidget) self.cbid = self.vp.addCallback("key press", self.onKeypress) self.imgActor = Picture( "https://icatcare.org/app/uploads/2018/07/Helping-your-new-cat-or-kitten-settle-in-1.png" ) self.text2d = Text2D("Use slider to change contrast") self.slider = Qt.QSlider(1) self.slider.valueChanged.connect(self.onSlider) self.layout.addWidget(self.vtkWidget) self.layout.addWidget(self.slider) self.frame.setLayout(self.layout) self.setCentralWidget(self.frame) self.vp.show(self.imgActor, self.text2d, mode='image') # build the vedo rendering self.show() # show the Qt Window
class MainWindow(Qt.QMainWindow): 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) # create renderer and add the actors self.vp = Plotter(qtWidget=self.vtkWidget) self.vp += Cone().rotateX(20) self.vp.show(interactorStyle=0) # set-up the rest of the Qt window button = Qt.QPushButton("My Button makes the cone red") button.setToolTip('This is an example button') button.clicked.connect(self.onClick) self.vl.addWidget(button) self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() # <--- show the Qt Window def onClose(self): #Disable the interactor before closing to prevent it #from trying to act on already deleted items self.vtkWidget.close() @Qt.pyqtSlot() def onClick(self): self.vp.actors[0].color('red').rotateZ(40) self.vp.interactor.Render()
def __init__(self, simulation: Simulation, max_fps: float, title: str = 'Simulation', size_multiplier: float = 0.02, trail_length: float = 2.0, show_trails: bool = True): self._simulation = simulation self._min_step_time = 1.0 / max_fps # display setup self._plotter = Plotter(interactive=False, title=title, axes=4) # bodies setup sizes = simulation.masses * size_multiplier self._bodies = [ Sphere(pos, r=r, c='black') for pos, r in zip(simulation.positions, sizes) ] self._plotter += self._bodies # trails if show_trails: for body in self._bodies: body.addTrail(alpha=0.3, lw=1, maxlength=trail_length, n=100) self._plotter.show(resetcam=True)
def plot_nii_gz(file_path: Path): vp = Plotter() image = vp.load(str(file_path)) print(np.max(image.getDataArray()), np.sum(image.getDataArray() == 3), np.sum(image.getDataArray() == 2), np.sum(image.getDataArray() == 1), np.sum(image.getDataArray() == 0), np.sum(image.getDataArray() == 255), np.mean(image.getDataArray()[image.getDataArray() > 0]))
def __init__( self, verbose, display_inset, camera, screenshot_kwargs, use_default_key_bindings, ): """ Creates and manages a Plotter instance :param add_root: if False a rendered outline of the whole brain is added to the scene (default value None) :param verbose: if False less feedback is printed to screen (default value True) :param display_inset: if False the inset displaying the brain's outline is not rendered (but the root is added to the scene) (default value None) :param camera: name of the camera parameters setting to use (controls the orientation of the rendered scene) :param screenshot_kwargs: pass a dictionary with keys: - 'folder' -> str, path to folder where to save screenshots - 'name' -> str, filename to prepend to screenshots files :param use_default_key_bindings: if True the defualt keybindings from vedo are used, otherwise a custom function that can be used to take screenshots with the parameter above. """ # Setup a few rendering options self.verbose = verbose self.display_inset = (display_inset if display_inset is not None else brainrender.DISPLAY_INSET) if vedosettings.notebookBackend == "k3d": self.jupyter = True else: self.jupyter = False if self.display_inset and self.jupyter: print("Setting 'display_inset' to False as this feature is not \ available in juputer notebooks") self.display_inset = False # Camera parameters self.camera = get_scene_camera(camera, self.atlas) # Create vedo plotter self.plotter = Plotter(**get_scene_plotter_settings(self.jupyter)) # SCreenshots and keypresses variables self.screenshots_folder = Path( screenshot_kwargs.pop("folder", self.atlas.output_screenshots)) self.screenshots_name = screenshot_kwargs.pop( "name", brainrender.DEFAULT_SCREENSHOT_NAME) if not use_default_key_bindings: self.plotter.keyPressFunction = self.keypress self.verbose = False if not brainrender.SCREENSHOT_TRANSPARENT_BACKGROUND: vedosettings.screenshotTransparentBackground = False vedosettings.useFXAA = True
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) self.plt += load(datadir + 'shark.ply').c('cyan') self.plt.show(interactorStyle=0)
def _get_plotter(self): # Make a vedo plotter self.plotter = Plotter( axes=self._make_axes() if settings.SHOW_AXES else None, pos=(0, 0), title="brainrender", bg=settings.BACKGROUND_COLOR, offscreen=settings.OFFSCREEN, size="full" if settings.WHOLE_SCREEN else "auto", ) self.plotter.keyPressFunction = self.keypress
def render(self, _interactive=True): """ """ mv = Plotter( N=2, axes=4 if brainrender.SHOW_AXES else 0, size="full" if brainrender.WHOLE_SCREEN else "auto", pos=brainrender.WINDOW_POS, bg=brainrender.BACKGROUND_COLOR, sharecam=True, ) actors = [] for scene in self.scenes: scene.apply_render_style() actors.append(scene.actors) mv.add(scene.actors) mv.show( actors[0], at=0, zoom=1.15, axes=4 if brainrender.SHOW_AXES else 0, roll=180, interactive=False, ) mv.show(actors[1], at=1, interactive=False) if _interactive: interactive()
class Visualization: """ Visualization of a 3D N-Body simulation. """ def __init__(self, simulation: Simulation, max_fps: float, title: str = 'Simulation', size_multiplier: float = 0.02, trail_length: float = 2.0, show_trails: bool = True): self._simulation = simulation self._min_step_time = 1.0 / max_fps # display setup self._plotter = Plotter(interactive=False, title=title, axes=4) # bodies setup sizes = simulation.masses * size_multiplier self._bodies = [ Sphere(pos, r=r, c='black') for pos, r in zip(simulation.positions, sizes) ] self._plotter += self._bodies # trails if show_trails: for body in self._bodies: body.addTrail(alpha=0.3, lw=1, maxlength=trail_length, n=100) self._plotter.show(resetcam=True) def run(self): """ Runs the visualization of the simulation. """ last_timestamp = time.time() for positions, velocities, accelerations in self._simulation.simulate( ): # throttle the simulation delta_time = time.time() - last_timestamp if delta_time < self._min_step_time: time.sleep(self._min_step_time - delta_time) last_timestamp = time.time() # update bodies for body, pos in zip(self._bodies, positions): body.pos(pos) # update display self._plotter.show(resetcam=False)
def setup_plotter(self): """ Changes the scene's default plotter with one attached to the qtWidget in the pyqt application. """ # Get embedded plotter new_plotter = Plotter(qtWidget=self.vtkWidget) self.scene.plotter = new_plotter # Get axes if self.axes: ax = addons.buildAxes( self.scene.root, xtitle="x [um]", xLabelOffset=0.07, xTitleOffset=0.1, xTitleJustify="bottom-left", ytitle="y [um]", yLabelOffset=0.025, yTitleOffset=0.1, yTitleJustify="bottom-left", ztitle="z [um]", zLabelOffset=0.025, zTitleOffset=0.1, zTitleJustify="bottom-left", ) for a in ax.unpack(): if "xtitle" in a.name or "xNumericLabel" in a.name: a.RotateZ(180) self.scene.add_actor(ax) # Fix camera set_camera(self.scene, self.scene.camera)
def draw(m, backend=False, **kwargs): """Visualize meshes.""" import vedo vedo.embedWindow(backend) from vedo import Plotter, UGrid vp = Plotter() grid = None with tempfile.NamedTemporaryFile() as tmp: m.save(tmp.name + '.vtk', encode_cell_data=False, encode_point_data=True, **kwargs) grid = UGrid(tmp.name + '.vtk') # save these for further use grid.show = lambda: vp.show([grid.tomesh()]).close() grid.plotter = vp return grid
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 vedosettings.notebookBackend = "k3d" # Create new plotter and save to file plt = Plotter() plt.add(self.actors) plt = plt.show(interactive=False) plt.camera[-2] = -1 if self.verbose: print( "Ready for exporting. Exporting scenes with many actors might require a few minutes" ) with open(filepath, "w") as fp: fp.write(plt.get_snapshot()) if self.verbose: print( f"The brainrender scene has been exported for web. The results are saved at {filepath}" ) # Reset settings vedosettings.notebookBackend = None self.jupyter = False
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) vp += Cone() vp.show(interactorStyle=0) # 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) self.plt += load(datadir + 'shark.ply').c('cyan') self.plt.show(interactorStyle=0) def onClose(self): print( "Disable the interactor before closing to prevent it from trying to act on a already deleted items" ) self.vtkWidget.close()
class MainWindow(Qt.QMainWindow): def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.layout = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) # Create renderer and add the vedo objects and callbacks self.vp = Plotter(qtWidget=self.vtkWidget) self.id1 = self.vp.addCallback("mouse click", self.onMouseClick) self.id2 = self.vp.addCallback("key press", self.onKeypress) self.vp += Cone().rotateX(20) self.vp.show() # <--- show the vedo rendering # Set-up the rest of the Qt window button = Qt.QPushButton("My Button makes the cone red") button.setToolTip('This is an example button') button.clicked.connect(self.onClick) self.layout.addWidget(self.vtkWidget) self.layout.addWidget(button) self.frame.setLayout(self.layout) self.setCentralWidget(self.frame) self.show() # <--- show the Qt Window def onMouseClick(self, evt): printc("You have clicked your mouse button. Event info:\n", evt, c='y') def onKeypress(self, evt): printc("You have pressed key:", evt.keyPressed, c='b') @Qt.pyqtSlot() def onClick(self): printc("..calling onClick") self.vp.actors[0].color('red').rotateZ(40) self.vp.interactor.Render() def onClose(self): #Disable the interactor before closing to prevent it #from trying to act on already deleted items printc("..calling onClose") self.vtkWidget.close()
def __init__(self, mesh1, mesh2, n): ############################### init self.n = n # desired nr. of intermediate shapes self.mode = '2d' self.mesh1 = mesh1 self.mesh2 = mesh2 self.merged_meshes = merge(mesh1, mesh2) self.mesh1.lw(4).c('grey2').pickable(False) self.mesh2.lw(4).c('grey1').pickable(False) self.arrow_starts = [] self.arrow_stops = [] self.dottedln = None self.toggle = False self.instructions = ( "Click to add arrows interactively on the left panel\n" "right-click to remove last arrow. Then press:\n" "- m to morph the plane\n" "- c to clear\n" "- g to generate interpolation") self.msg1 = Text2D(self.instructions, pos='top-left', font="VictorMono", bg='g2', alpha=0.6) self.msg2 = Text2D('[output will show here]', pos='top-left', font="VictorMono") sz = self.merged_meshes.diagonalSize() self.plane1 = Grid(sx=sz, sy=sz, resx=50, resy=50).pos(self.merged_meshes.centerOfMass()) self.plane1.wireframe(False).alpha(1).lineWidth(0.1).c('white').lc( 'grey5') self.plane2 = self.plane1.clone().pickable(False) self.plotter = Plotter(N=2, bg='light blue', size=(2000, 1000)) self.plotter.addCallback('left click', self.onleftclick) self.plotter.addCallback('right click', self.onrightclick) self.plotter.addCallback('key press', self.onkeypress)
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) # create renderer and add the actors self.vp = Plotter(qtWidget=self.vtkWidget) self.vp += Cone().rotateX(20) self.vp.show(interactorStyle=0) # set-up the rest of the Qt window button = Qt.QPushButton("My Button makes the cone red") button.setToolTip('This is an example button') button.clicked.connect(self.onClick) self.vl.addWidget(button) self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() # <--- show the Qt Window
def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.layout = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) # Create renderer and add the vedo objects and callbacks self.vp = Plotter(qtWidget=self.vtkWidget) self.id1 = self.vp.addCallback("mouse click", self.onMouseClick) self.id2 = self.vp.addCallback("key press", self.onKeypress) self.vp += Cone().rotateX(20) self.vp.show() # <--- show the vedo rendering # Set-up the rest of the Qt window button = Qt.QPushButton("My Button makes the cone red") button.setToolTip('This is an example button') button.clicked.connect(self.onClick) self.layout.addWidget(self.vtkWidget) self.layout.addWidget(button) self.frame.setLayout(self.layout) self.setCentralWidget(self.frame) self.show() # <--- show the Qt Window
def setup_plotter(self): """ Changes the scene's default plotter with one attached to the qtWidget in the pyqt application. """ # Get embedded plotter new_plotter = Plotter(qtWidget=self.vtkWidget) self.scene.plotter = new_plotter # Get axes if self.axes: self.axes = self._make_axes() # self.scene.add_actor(ax) else: self.axes = None # Fix camera set_camera(self.scene, self.scene.plotter.camera)
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(qtWidget=self.vtkWidget, 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", interactorStyle=0) self.start(vp)
class MainWindow(Qt.QMainWindow): def __init__(self, parent=None): Qt.QMainWindow.__init__(self, parent) self.frame = Qt.QFrame() self.layout = Qt.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) # Create vedo renderer and add objects and callbacks self.vp = Plotter(qtWidget=self.vtkWidget) self.cbid = self.vp.addCallback("key press", self.onKeypress) self.imgActor = Picture( "https://icatcare.org/app/uploads/2018/07/Helping-your-new-cat-or-kitten-settle-in-1.png" ) self.text2d = Text2D("Use slider to change contrast") self.slider = Qt.QSlider(1) self.slider.valueChanged.connect(self.onSlider) self.layout.addWidget(self.vtkWidget) self.layout.addWidget(self.slider) self.frame.setLayout(self.layout) self.setCentralWidget(self.frame) self.vp.show(self.imgActor, self.text2d, mode='image') # build the vedo rendering self.show() # show the Qt Window def onSlider(self, value): self.imgActor.window(value * 10) # change image contrast self.text2d.text(f"window level is now: {value*10}") self.vp.render() def onKeypress(self, evt): printc("You have pressed key:", evt.keyPressed, c='b') if evt.keyPressed == 'q': self.vp.close() self.vtkWidget.close() exit() def onClose(self): self.vtkWidget.close()
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) mv = Plotter( N=self.N, axes=4 if brainrender.SHOW_AXES else 0, size="full" if brainrender.WHOLE_SCREEN else "auto", sharecam=True, bg=brainrender.BACKGROUND_COLOR, ) actors = [] for i, scene in enumerate(self.scenes): scene.apply_render_style() 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()
def export(self, savepath): """ Exports the scene to a .html file for online renderings. :param savepath: str, Path to a .html file to save the export """ logger.debug(f"Exporting scene to {savepath}") _backend = self.backend if not self.is_rendered: self.render(interactive=False) path = Path(savepath) if path.suffix != ".html": raise ValueError("Savepath should point to a .html file") # prepare settings vsettings.notebookBackend = "k3d" # Create new plotter and save to file plt = Plotter() plt.add(self.renderables) plt = plt.show(interactive=False) plt.camera[-2] = -1 with open(path, "w") as fp: fp.write(plt.get_snapshot()) print( f"The brainrender scene has been exported for web. The results are saved at {path}" ) # Reset settings vsettings.notebookBackend = None self.backend = _backend return str(path)
gamma = 0.1 # some friction Dt = 0.03 # time step # Create the initial positions and velocitites (0,0) of the bobs bob_x = [0] bob_y = [0] x_dot = np.zeros(N + 1) # velocities y_dot = np.zeros(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, 0.1)) bob_y.append(bob_y[k - 1] + np.sin(alpha) + np.random.normal(0, 0.1)) # Create the bobs plt = Plotter(title="Multiple Pendulum", axes=0, interactive=0, bg2='ly') plt += Box(pos=(0, -5, 0), length=12, width=12, height=0.7, c="k").wireframe(1) sph = Sphere(pos=(bob_x[0], bob_y[0], 0), r=R / 2, c="gray") plt += sph bob = [sph] for k in range(1, N + 1): c = Cylinder(pos=(bob_x[k], bob_y[k], 0), r=R, height=0.3, c=k) plt += c bob.append(c) # Create the springs out of N links link = [None] * N for k in range(N): p0 = bob[k].pos() p1 = bob[k + 1].pos() link[k] = Spring(p0, p1, thickness=0.015, r=R / 3, c="gray")
"""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)
gamma = 0.1 # some friction Dt = 0.03 # time step # Create the initial positions and velocitites (0,0) of the bobs bob_x = [0] bob_y = [0] x_dot = np.zeros(N + 1) # velocities y_dot = np.zeros(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, 0.1)) bob_y.append(bob_y[k - 1] + np.sin(alpha) + np.random.normal(0, 0.1)) # Create the bobs vp = Plotter(title="Multiple Pendulum", axes=0, interactive=0) vp += Box(pos=(0, -5, 0), length=12, width=12, height=0.7, c="k").wireframe(1) bob = [vp.add(Sphere(pos=(bob_x[0], bob_y[0], 0), r=R / 2, c="gray"))] for k in range(1, N + 1): bob.append( vp.add(Cylinder(pos=(bob_x[k], bob_y[k], 0), r=R, height=0.3, c=k))) # Create the springs out of N links link = [None] * N for k in range(N): p0 = bob[k].pos() p1 = bob[k + 1].pos() link[k] = vp.add(Spring(p0, p1, thickness=0.015, r=R / 3, c="gray")) # Create some auxiliary variables x_dot_m = np.zeros(N + 1)
yield from self.move_disks(self.nr_disks, 0, 1) nr_disks = 5 hanoi = Hanoi(nr_disks) tower_states = list([hanoi.towers]) for _ in hanoi.moves(): tower_states.append(hanoi.towers) disks = { hanoi.nr_disks - i: Cylinder(r=0.2 * (hanoi.nr_disks - i + 1), c=i) for i in range(hanoi.nr_disks) } plt = Plotter(interactive=False, size=(800, 600), bg='wheat', bg2='lb') plt += disks.values() plt += Box(pos=(3, 0, -0.5), size=(12, 4, 0.1)) cam = dict( pos=(14.60, -20.56, 7.680), focalPoint=(3.067, 0.5583, 1.910), viewup=(-0.1043, 0.2088, 0.9724), ) plt.show(camera=cam) pb = ProgressBar(0, len(tower_states), 1, c="y") 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]):
if vp: self.vsphere = 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.vsphere.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:
"""Mesh smoothing with two different methods""" from vedo import Plotter, dataurl plt = Plotter(N=2) # Load a mesh and show it vol = plt.load(dataurl + "embryo.tif") m0 = vol.isosurface().normalize().lw(0.1).c("violet") plt.show(m0, __doc__ + "\nOriginal Mesh:", at=0) plt.background([0.8, 1, 1], at=0) # set first renderer color # Smooth the mesh m1 = m0.clone().smooth(niter=20).color("lg") plt.show(m1, "Polygons are smoothed:", at=1, viewup='z', zoom=1.5, interactive=True).close()