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 __init__(self, pos, charge, mass, radius, color, vel, fixed,
negligible):
""" Creates a new particle with specified properties (in SI units)
pos: XYZ starting position of the particle, in meters
charge: charge of the particle, in Coulombs
mass: mass of the particle, in kg
radius: radius of the particle, in meters. No effect on simulation
color: color of the particle. If None, a default color will be chosen
vel: initial velocity vector, in m/s
fixed: if True, particle will remain fixed in place
negligible: assume charge is small wrt other charges to speed up calculation
"""
self.pos = vector(pos)
self.radius = radius
self.charge = charge
self.mass = mass
self.vel = vector(vel)
self.fixed = fixed
self.negligible = negligible
self.color = color
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)
def test_neuron():
s = Scene(title="BR")
neuron = s.add(Neuron("tests/files/neuron1.swc"))
s.add(Neuron(Actor(neuron.mesh)))
s.add(Neuron(neuron.mesh))
Neuron(Sphere())
with pytest.raises(ValueError):
Neuron(1)
with pytest.raises(FileExistsError):
Neuron("tests/files/neuronsfsfs.swc")
with pytest.raises(NotImplementedError):
Neuron("tests/files/random_cells.h5")
del s
def __init__(self,
pos,
radius=100,
color="blackboard",
alpha=1,
res=25,
name=None):
"""
Creates an actor representing a single point
:param pos: list or np.ndarray with coordinates
:param radius: float
:param color: str,
:param alpha: float
:param res: int, resolution of mesh
:param name: str, actor name
"""
mesh = Sphere(pos=pos, r=radius, c=color, alpha=alpha, res=res)
name = name or "Point"
Actor.__init__(self, mesh, name=name, br_class="Point")
"""Interpolate the arrays of a source Mesh (RandomHills)
onto another (ellipsoid) by averaging closest point values"""
from vedo import ParametricShape, Sphere, show
# RandomHills already contains the height as a scalar defined on vertices
h = ParametricShape('RandomHills')
h.cmap('hsv', vmin=0, vmax=6)
h.addScalarBar3D(title='RandomHills height scalar value')
# interpolate such values on a completely different Mesh.
# pick N=4 closest points and assign an ave value based on shepard kernel.
s = Sphere().scale([1, 1, 0.5]).pos(-.1, 1.5, 0.3).alpha(1).lw(0.1)
s.interpolateDataFrom(h, N=4, kernel='gaussian')
s.cmap('hsv', vmin=0, vmax=6)
show(h, s, __doc__, axes=1).close()
"""Customizing Axes.
Cartesian planes can be displaced
from their lower-range default position"""
from vedo import Sphere, Axes, precision, show
sph = Sphere().scale([4, 3, 2]).shift(5, 6, 7).c('green2', 0.1)
axs = Axes(
sph, # build axes for object sph
xtitle="x axis",
ytitle="y axis",
ztitle="z axis",
htitle='An ellipsoid at ' + precision(sph.centerOfMass(), 2),
hTitleFont=1,
hTitleColor='red3',
zxGrid=True,
xyFrameLine=2,
yzFrameLine=2,
zxFrameLine=2,
xyFrameColor='red3',
yzFrameColor='green3',
zxFrameColor='blue3',
xyShift=0.2, # move xy plane 20% along z
yzShift=0.2, # move yz plane 20% along x
zxShift=0.2, # move zx plane 20% along y
)
show(sph, axs, __doc__)
def make_actor_label(
atlas,
actors,
labels,
size=300,
color=None,
radius=100,
xoffset=0,
yoffset=-500,
zoffset=0,
):
"""
Adds a 2D text ancored to a point on the actor's mesh
to label what the actor is
:param kwargs: key word arguments can be passed to determine
text appearance and location:
- size: int, text size. Default 300
- color: str, text color. A list of colors can be passed
if None the actor's color is used. Default None.
- xoffset, yoffset, zoffset: integers that shift the label position
- radius: radius of sphere used to denote label anchor. Set to 0 or None to hide.
"""
offset = [-yoffset, -zoffset, xoffset]
default_offset = np.array([0, -200, 100])
new_actors = []
for n, (actor, label) in enumerate(zip(listify(actors), listify(labels))):
# Get label color
if color is None:
color = actor.c()
# Get mesh's highest point
points = actor.points().copy()
point = points[np.argmin(points[:, 1]), :]
point += np.array(offset) + default_offset
try:
if atlas.hemisphere_from_coords(point, as_string=True) == "left":
point = atlas.mirror_point_across_hemispheres(point)
except IndexError:
pass
# Create label
txt = Text(label, point, s=size, c=color)
txt._kwargs = dict(
size=size,
color=color,
radius=radius,
xoffset=xoffset,
yoffset=yoffset,
zoffset=zoffset,
)
new_actors.append(txt)
# Mark a point on Mesh that corresponds to the label location
if radius is not None:
pt = actor.closestPoint(point)
sphere = Sphere(pt, r=radius, c=color)
sphere.ancor = pt
new_actors.append(sphere)
return new_actors
"""
Example usage of addTrail().
Add a trailing line to a moving object.
"""
print(__doc__)
from vedo import Plotter, sin, Sphere, Point
vp = Plotter(axes=6, interactive=False)
s = Sphere().c("green").bc("tomato")
s.cutWithPlane([-0.9, 0, 0]) # cut left part of sphere
p = Point([1, 1, 1], r=12, c="black")
# add a trail to point p with max length 0.5 and 50 segments
p.addTrail(lw=3, maxlength=0.5, n=50)
# add meshes to Plotter list
vp += [s, p]
for i in range(200):
p.pos(-2 + i / 100.0, sin(i / 5.0) / 15, 0)
vp.camera.Azimuth(-0.2)
vp.show()
vp.show(interactive=True)
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, 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 = [
Sphere(pos=(Pos[0][0], Pos[0][1], 0), r=Radius[0], c="red",
res=12).phong()
]
for s in range(1, Nsp):
a = Sphere(pos=(Pos[s][0], Pos[s][1], 0), r=Radius[s], c="blue",
res=6).phong()
Spheres.append(a)
# vp += a
vp += Spheres
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")
def make_actor_label(
atlas,
actors,
labels,
size=300,
color=None,
radius=100,
xoffset=0,
yoffset=0,
zoffset=0,
):
"""
Adds a 2D text ancored to a point on the actor's mesh
to label what the actor is
:param kwargs: key word arguments can be passed to determine
text appearance and location:
- size: int, text size. Default 300
- color: str, text color. A list of colors can be passed
if None the actor's color is used. Default None.
- xoffset, yoffset, zoffset: integers that shift the label position
- radius: radius of sphere used to denote label anchor. Set to 0 or None to hide.
"""
# Check args
if not isinstance(actors, (tuple, list)):
actors = [actors]
if not isinstance(labels, (tuple, list)):
labels = [labels]
if atlas.atlas_name == "ABA":
offset = [-yoffset, -zoffset, xoffset]
default_offset = np.array([0, -200, 100])
else:
offset = [xoffset, yoffset, zoffset]
default_offset = np.array([100, 0, -200])
new_actors = []
for n, (actor, label) in enumerate(zip(actors, labels)):
if not isinstance(actor, Mesh):
raise ValueError(
f"Mesh must be an instance of Mesh, not {type(actor)}")
if not isinstance(label, str):
raise ValueError(f"Label must be a string, not {type(label)}")
# Get label color
if color is None:
color = actor.c()
elif isinstance(color, (list, tuple)):
color = color[n]
# Get mesh's highest point
points = actor.points().copy()
point = points[np.argmin(points[:, 1]), :]
point += np.array(offset) + default_offset
try:
if atlas.hemisphere_from_coords(point, as_string=True) == "left":
point = atlas.mirror_point_across_hemispheres(point)
except IndexError:
pass
# Create label
txt = Text(label, point, s=size, c=color)
txt._original_actor = actor
txt._label = label
txt._kwargs = dict(
size=size,
color=color,
radius=radius,
xoffset=xoffset,
yoffset=yoffset,
zoffset=zoffset,
)
new_actors.append(txt)
# Mark a point on Mesh that corresponds to the label location
if radius is not None:
pt = actor.closestPoint(point)
sphere = Sphere(pt, r=radius, c=color)
sphere.ancor = pt
new_actors.append(sphere)
return new_actors
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, 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 = [Sphere(pos=(Pos[0][0], Pos[0][1], 0), r=Radius[0], c="red")]
for s in range(1, Nsp):
a = Sphere(pos=(Pos[s][0], Pos[s][1], 0), r=Radius[s], c="blue")
Spheres.append(a)
# vp += a
vp += Spheres
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
from vedo import Cone, Sphere, merge, Volume
import numpy as np
import vtk
print('---------------------------------')
print('vtkVersion', vtk.vtkVersion().GetVTKVersion())
print('---------------------------------')
#####################################
cone = Cone(res=48)
sphere = Sphere(res=24)
carr = cone.cellCenters()[:, 2]
parr = cone.points()[:, 0]
cone.addCellArray(carr, 'carr')
cone.addPointArray(parr, 'parr')
carr = sphere.cellCenters()[:, 2]
parr = sphere.points()[:, 0]
sphere.addCellArray(carr, 'carr')
sphere.addPointArray(parr, 'parr')
sphere.addPointArray(np.sin(sphere.points()), 'pvectors')
sphere.addElevationScalars()
cone.computeNormals()
sphere.computeNormals()
###################################### test clone()
c2 = cone.clone()
assert cone.N() == c2.N()
from vedo import Cone, Sphere, merge, Volume
import numpy as np
import vtk
print('---------------------------------')
print('vtkVersion', vtk.vtkVersion().GetVTKVersion())
print('---------------------------------')
#####################################
cone = Cone(res=48)
sphere = Sphere(res=24)
carr = cone.cellCenters()[:, 2]
parr = cone.points()[:, 0]
cone.addCellArray(carr, 'carr')
cone.addPointArray(parr, 'parr')
carr = sphere.cellCenters()[:, 2]
parr = sphere.points()[:, 0]
sphere.addCellArray(carr, 'carr')
sphere.addPointArray(parr, 'parr')
sphere.addPointArray(np.sin(sphere.points()), 'pvectors')
sphere.addElevationScalars()
cone.computeNormals()
sphere.computeNormals()
###################################### test clone()
"""Compute the (signed) distance of one mesh to another"""
from vedo import Sphere, Cube, show
s1 = Sphere().x(10)
s2 = Cube(c='grey4').scale([2, 1, 1]).x(14)
s1.distanceTo(s2, signed=False)
s1.cmap('hot').addScalarBar('Signed\nDistance')
# print(s1.pointdata["Distance"]) # numpy array
show(s1, s2, __doc__, axes=1, size=(1000, 500), zoom=1.5).close()
from vedo import Cone, Sphere, merge, Volume
import numpy as np
import vtk
print('---------------------------------')
print('vtkVersion', vtk.vtkVersion().GetVTKVersion())
print('---------------------------------')
#####################################
cone = Cone(res=48)
sphere = Sphere(res=24)
carr = cone.cellCenters()[:, 2]
parr = cone.points()[:, 0]
cone.pointdata["parr"] = parr
cone.celldata["carr"] = carr
carr = sphere.cellCenters()[:, 2]
parr = sphere.points()[:, 0]
sphere.pointdata["parr"] = parr
sphere.celldata["carr"] = carr
sphere.pointdata["pvectors"] = np.sin(sphere.points())
sphere.addElevationScalars()
cone.computeNormals()
sphere.computeNormals()
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 = np.deg2rad(90 - ilat)
ph = np.deg2rad(ilong)
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], axes=3, interactive=0)
shape1 = Sphere(alpha=0.2)
shape2 = vp.load(datadir + "icosahedron.vtk").normalize().lineWidth(1)
agrid1, actorpts1 = makeGrid(shape1, N)
vp.show(shape1, actorpts1, at=0)
agrid2, actorpts2 = makeGrid(shape2, N)
vp.show(shape2, actorpts2, at=1)
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
"""Computes the signed distance
from one mesh to another.
"""
from vedo import Sphere, Cube, show
s1 = Sphere()
s2 = Cube(pos=[1, 0, 0], c='white', alpha=0.4)
s1.distanceToMesh(s2, signed=True, negate=False)
s1.addScalarBar(title='Signed\nDistance')
#print(s1.getPointArray("Distance"))
show(s1, s2, __doc__)
"""Simulation of an optical system with lenses and mirrors of arbitrary shapes and orientations
(points mark the exit locations of photons, many from total internal reflections)"""
from vedo import Grid, Sphere, Cube, Cone, Points, show
from optics_base import Lens, Ray, Mirror, Screen # see file ./optics_base.py
import numpy as np
# Create meshes as ordinary vedo objects
sm = Sphere(r=8).z(-8.1)
sp = Sphere(r=8).z(+8.1)
shape1 = Sphere(r=0.9, res=53).cutWithPlane().cap().rotateY(-90).pos(0, 0, 0.5)
shape2 = Cube(side=2).triangulate().boolean('-', sm).boolean("-", sp).z(3)
shape3 = Cone().rotateY(-90).z(6)
shape4 = Cube().scale([1.7, 1, 0.2]).rotateY(70).pos(-0.3, 0, 8)
shape5 = Sphere(r=2).boolean("intersect",
Sphere(r=2).z(3.5)).rotateX(10).pos(0.8, 0, 7.5)
shape6 = Grid(resx=1, resy=1).rotateY(-60).rotateX(30).pos(0, -1, 11)
# Build lenses (with their refractive indices), and mirrors, using those meshes
lens1 = Lens(shape1, ref_index=1.35).c("blue9") # constant refr. index
lens2 = Lens(shape2, ref_index="glass").c("blue7")
lens3 = Lens(shape3, ref_index="glass").c("green9")
lens4 = Lens(shape4, ref_index="glass").c("purple9").lineWidth(1)
lens5 = Lens(shape5, ref_index="glass").c("orange9")
mirror = Mirror(shape6)
screen = Screen(4, 4).rotateY(20).pos(1, 0, 12)
elements = [lens1, lens2, lens3, lens4, lens5, mirror, screen]
# Generate photons and trace them through the optical elements
lines = []
source = Grid(resx=20, resy=20).points() # a numpy array
for pt in source:
plt += Torus(c="g", r=RingRadius, thickness=RingThickness,
alpha=0.1).wireframe(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
atm = Sphere(pos=(x, y, z), r=Ratom, c=i, res=6).phong()
plt += atm
Atoms = Atoms + [atm] ### <--
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)
# 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")
plt += link[k]
"""Build a custom colormap, including
out-of-range and NaN colors and labels"""
from vedo import buildLUT, Sphere, show, settings
# settings.useDepthPeeling = True # might help with transparencies
# generate a sphere and stretch it, so it sits between z=-2 and z=+2
mesh = Sphere(quads=True).scale([1,1,2]).lineWidth(0.1)
# create some dummy data array to be associated to points
data = mesh.points()[:,2] # pick z-coords, use them as scalar data
data[10:70] = float('nan') # make some values invalid by setting to NaN
data[300:600] = 100 # send some values very far above-scale
# build a custom LookUp Table of colors:
# value, color, alpha
lut = buildLUT([
#(-2, 'pink' ), # up to -2 is pink
(0.0, 'pink' ), # up to 0 is pink
(0.4, 'green', 0.5), # up to 0.4 is green with alpha=0.5
(0.7, 'darkblue' ),
#( 2, 'darkblue' ),
],
vmin=-1.2, belowColor='lightblue',
vmax= 0.7, aboveColor='grey',
nanColor='red',
interpolate=False,
)
# 3D scalarbar:
mesh.cmap(lut, data).addScalarBar3D(title='My 3D scalarbar', c='white')
mesh.scalarbar.scale(1.5).rotateX(90).y(1) # make it bigger and place it
"""Non blocking interactive rendering window,
python flow is not blocked
but displayed objects cannot be accessed"""
import time, os
from multiprocessing import Process
from vedo import Sphere, show, printc
printc("..starting main", c='g')
sphere = Sphere().alpha(0.1).lw(0.1)
# ------ instead of (typical):
#show(sphere, __doc__, axes=1)
# ------ spawn an independent subprocess:
def spawn():
show(sphere, __doc__, axes=1)
Process(target=spawn).start()
printc("..python flow is not blocked, wait 1 sec..", c='y')
time.sleep(1)
printc("..continuing in main", c='r')
os._exit(0) # this exits immediately with no cleanup or buffer flushing
data.append(['U.S.A.\n', 0.9, 1.4, conf_us, deat_us, reco_us])
return (date, data, csvdata['Confirmed'].sum(), csvdata['Deaths'].sum(),
csvdata['Recovered'].sum())
# -------------------------------------------------------------------------
# Create the scene:
from vedo import spher2cart, Sphere, Text2D, Earth, merge, show
date, data, allconf, alldeat, allreco = load_data()
s1, s2, vigs = [], [], []
for place, theta, phi, confirmed, deaths, recos in data:
pos = spher2cart(1, theta, phi)
fl = 'cases: ' + str(confirmed) + '\ndeaths: ' + str(deaths)
radius = np.power(confirmed, 1 / 3) / 2000
sph1 = Sphere(pos, radius, alpha=0.4, res=12).flag(place + fl)
if deaths > 5000:
sph1.flag(fl)
anchorpt = sph1.pos() * (1 + radius)
vig = sph1.vignette(place, anchorpt, font="Kanopus")
vig.c('k').scale(1.5 * (1 + radius)).followCamera()
vigs.append(vig)
s1.append(sph1)
s2.append(
Sphere(pos, np.power(deaths, 1 / 3) / 2000, alpha=0.4, c='k', res=10))
tx = Text2D('COVID-19 spread on ' + date + '\n# cases : ' + str(allconf) +
'\n# deaths: ' + str(alldeat) + '\n# recovd: ' + str(allreco) +
'\n(hover mouse for local info)',
font="VictorMono")
def plot(
data,
names=None,
colors=None,
lines=None,
targets=None,
arrows=None,
text=None,
boxes=None,
points=None,
interactive=True,
):
"""
A vedo wrapper for quicly visualizing well trajectories for QAQC purposes.
Parameters
----------
data: a trimesh.Trimesh object or a list of trimesh.Trimesh
objects or a trmiesh.scene object
names: list of strings (default: None)
A list of names, index aligned to the list of well meshes.
colors: list of strings (default: None)
A list of color or colors. If a single color is listed then this is
applied to all meshes in data, otherwise the list of colors is
indexed to the list of meshes.
"""
if isinstance(data, trimesh.scene.scene.Scene):
meshes = [v for k, v in data.geometry.items()]
if names is None:
names = list(data.geometry.keys())
# handle a single mesh being passed
elif isinstance(data, trimesh.Trimesh):
meshes = [data]
else:
meshes = data
if names is not None:
assert len(names) == len(data), \
"Names must be length of meshes list else None"
if colors is not None:
if len(colors) == 1:
colors = colors * len(names)
else:
assert len(colors) == len(names), \
"Colors must be length of meshes list, 1 else None"
if points is not None:
points = [Sphere(p, r=30, c='grey') for p in points]
meshes_vedo = []
for i, mesh in enumerate(meshes):
if i == 0:
vertices = np.array(mesh.vertices)
start_locations = np.array([mesh.vertices[0]])
else:
vertices = np.concatenate((vertices, np.array(mesh.vertices)),
axis=0)
start_locations = np.concatenate(
(start_locations, np.array([mesh.vertices[0]])), axis=0)
# convert to vedo mesh
m_vedo = trimesh2vedo(mesh)
if colors is not None:
m_vedo.c(colors[i])
if names is not None:
m_vedo.flag(names[i])
meshes_vedo.append(m_vedo)
w = get_bb(vertices)
axes = get_axes(w.world)
# try and figure out a nice start camera position
pos = w.bb_center
vec1 = pos - [w.length, w.width, 0]
vec2 = np.array([vec1[1], vec1[0], 0])
pos_new = [pos[0], pos[1], -4000] + vec2 * 3
camera_opts = dict(pos=pos_new, focalPoint=pos, viewup=[0., 0., -1.])
show(meshes_vedo,
w.world,
lines,
targets,
arrows,
boxes,
axes,
points,
bg='lightgrey',
bg2='lavender',
camera=camera_opts,
interactorStyle=10,
resetcam=True,
interactive=True,
verbose=True,
title=f'welleng {VERSION}')
# 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)
y_dot_m = np.zeros(N + 1)
dij = np.zeros(N + 1) # array with distances to previous bob
"""Click a sphere to highlight it"""
from vedo import Text2D, Sphere, Plotter
import numpy as np
spheres = []
for i in range(25):
p = np.random.rand(2)
s = Sphere(r=0.05).pos(p).color('k5')
s.name = f"sphere nr.{i} at {p}"
spheres.append(s)
def func(evt):
if not evt.actor: return
sil = evt.actor.silhouette().lineWidth(6).c('red5')
msg.text("You clicked: " + evt.actor.name)
plt.remove(silcont.pop()).add(sil)
silcont.append(sil)
silcont = [None]
msg = Text2D("", pos="bottom-center", c='k', bg='r9', alpha=0.8)
plt = Plotter(axes=1, bg='black')
plt.addCallback('mouse click', func)
plt.show(spheres, msg, __doc__, zoom=1.2).close()
from vedo import makeLUT, Sphere
mesh = Sphere().lineWidth(0.1)
# create some data array to be associated to points
data = mesh.points()[:, 2]
data[10:20] = float('nan')
# Build a lookup table of colors:
# scalar color alpha
lut = makeLUT(
[
(-0.80, 'pink'),
(-0.33, 'green', 0.8),
(0.67, 'red'),
],
vmin=-1,
vmax=1,
aboveColor='grey',
belowColor='white',
interpolate=False,
)
mesh.cmap(lut, data).addScalarBar()
mesh.show(axes=1, viewup='z')
"""Click a sphere to highlight it"""
from vedo import Sphere, Plotter
import numpy as np
pts = np.random.rand(30, 2) * 20
spheres = [Sphere().pos(p).color('k5') for p in pts]
def func(evt):
if not evt.actor: return
sil = evt.actor.silhouette().lineWidth(6).c('red5')
plt.remove(silcont.pop()).add(sil)
silcont.append(sil)
silcont = [None]
plt = Plotter(axes=1, bg='black')
plt.addCallback('mouse click', func)
plt.show(spheres, __doc__, zoom=1.2)
