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()
