def axes_scene(rotation=[1, 0, 0, 0]):
x = np.array([[6, 0, 0], [6, -1, -1], [6, -1, 1], [6, 1, -1], [6, 1, 1],
[6, -0.5, -0.5], [6, -0.5, 0.5], [6, 0.5, -0.5],
[6, 0.5, 0.5]])
x_lines_prim = draw.Lines(start_points=np.array([[0, 0, 0], *x[1:5]]),
end_points=np.array([x[0]] * 5),
widths=0.5 * np.ones(5),
colors=[[1, 0, 0, 1]] * 5,
cap_mode=1)
y = np.array([[0, 6, 0], [1, 6, 1], [-1, 6, 1], [0, 6, -1], [0.5, 6, 0.5],
[-0.5, 6, 0.5], [0, 6, -0.5]])
y_lines_prim = draw.Lines(start_points=np.array([[0, 0, 0], *y[1:4]]),
end_points=np.array([y[0]] * 4),
widths=0.5 * np.ones(4),
colors=[[0, 1, 0, 1]] * 4,
cap_mode=1)
z = np.array([[0, 0, 6], [-1, 1, 6], [1, 1, 6], [-1, -1, 6], [1, -1, 6],
[-0.5, -1, 6], [0, -1, 6], [0.5, -1, 6], [-0.5, 1, 6],
[0, 1, 6], [0.5, 1, 6], [-0.5, -0.5, 6], [0.5, 0.5, 6]])
z_lines_prim = draw.Lines(start_points=np.array([[0, 0, 0], *z[1:4]]),
end_points=np.array([z[0], *z[2:5]]),
widths=0.5 * np.ones(4),
colors=[[0, 0, 1, 1]] * 4,
cap_mode=1)
scene = draw.Scene([x_lines_prim, y_lines_prim, z_lines_prim],
rotation=rotation)
return scene
def simple_2d(seed=13, num_particles=2):
np.random.seed(seed)
positions = np.random.uniform(0, 3, (num_particles, 2))
colors = np.random.rand(num_particles, 4)
orientations = np.random.rand(num_particles, 4)
orientations[:, 1:3] = 0
orientations /= np.linalg.norm(orientations, axis=-1, keepdims=True)
thetas = np.linspace(0, 2*np.pi, 5, endpoint=False)
vertices = np.array([np.cos(thetas), np.sin(thetas)]).T
prim1 = draw.Arrows2D(positions=positions, colors=colors*.5,
orientations=orientations, magnitudes=[.25, .5])
prim1.vertices = prim1.vertices - (-.5, 0)
prim2 = draw.Disks(outline=.05, positions=positions,
colors=colors, diameters=np.ones((num_particles,)))
prim3 = draw.Polygons(positions=-positions, colors=colors, vertices=vertices,
outline=.05, orientations=orientations)
prim4 = draw.Spheropolygons(positions=-positions, colors=colors,
vertices=vertices, outline=.05,
orientations=orientations)
prim4.radius = .1
prim4.positions = prim3.positions + (3, 2)
scene = draw.Scene([prim2, prim3, prim4, prim1], zoom=4, features=dict(pan=True))
return scene
def convex_polyhedra(seed=16, num_particles=3):
np.random.seed(seed)
positions = np.random.uniform(0, 9, (num_particles, 3))
colors = np.random.uniform(.75, .9, (num_particles, 4))**1.5
colors[:, 3] = 0.7
orientations = np.random.rand(num_particles, 4)
orientations /= np.linalg.norm(orientations, axis=-1, keepdims=True)
vertices = np.array([(1, 1, 1), (-1, 1, 1), (1, -1, 1), (1, 1, -1)],
dtype=np.float32)
prim = draw.ConvexPolyhedra(positions=positions,
colors=colors,
orientations=orientations,
vertices=vertices,
radius=.1)
prim2 = prim.copy(prim)
prim2.vertices = np.concatenate([prim2.vertices, -prim2.vertices], axis=0)
prim2.positions = -prim2.positions
prims = [prim, prim2]
features = dict(ambient_light=.25,
directional_light=(-.1, -.15, -1),
translucency=True)
scene = draw.Scene(prims, zoom=2, clip_scale=10, features=features)
return scene
def meshes():
vertices = plato.geometry.fibonacciPositions(64)
vertices, faces = plato.mesh.convexHull(vertices)
# distance from y axis
x = vertices[:, 0]
y = vertices[:, 1]
z = vertices[:, 2]
d = np.sqrt(x * x + y * y)
# deform y
vertices[:, 2] -= 1 * (1 - d) * z
colors = np.tile([[0.25, 0.25, 0.7, 1.0]], (len(vertices), 1))
colors[:, 0] = vertices[:, 0]
colors[:, 0] -= np.min(colors[:, 0])
colors[:, 0] /= np.max(colors[:, 0])
positions = [[-1, 0, 0], [1, 0, 0.0]]
orientations = np.tile([[1, 0, 0, 0]],
(len(positions), 1)).astype(np.float32)
halftheta = -np.pi / 5
orientations[0] = (np.cos(halftheta), 0, np.sin(halftheta), 0)
prim = draw.Mesh(vertices=vertices,
indices=faces,
colors=colors,
positions=positions,
orientations=orientations)
prim.shape_colors = [(0, .5, 0, 1), (0, 0, .5, 1)]
prim.shape_color_fraction = .5
features = dict(ambient_light=.25, directional_light=(-.1, -.15, -1))
return draw.Scene(prim, zoom=10, features=features)
def field_scene(N=10, use='ellipsoids'):
features = dict(ambient_light=.4)
(positions, units) = example_vector_field(5)
normalized_z = positions[:, 2].copy()
normalized_z -= np.min(normalized_z)
normalized_z /= np.max(normalized_z)
colors = plato.cmap.cubehelix(normalized_z, h=1.4)
colors[:, :3] = .5 * (colors[:, :3] + plato.cmap.cubeellipse(
np.arctan2(positions[:, 1], positions[:, 0])))
if use == 'ellipsoids':
orientations = rowan.vector_vector_rotation([(1, 0, 0)], units)
prim = draw.Ellipsoids(positions=positions,
orientations=orientations,
colors=colors,
a=.5,
b=.125,
c=.125)
elif use == 'lines':
features['ambient_light'] = 1
starts = positions - units / 2
ends = positions + units / 2
prim = draw.Lines(start_points=starts,
end_points=ends,
colors=colors,
widths=np.ones(len(positions)) * .25)
else:
raise NotImplementedError('Unknown primitive {}'.format(use))
rotation = [0.8126942, 0.35465172, -0.43531808, 0.15571932]
scene = draw.Scene(prim, zoom=4, features=features, rotation=rotation)
return scene
def simple_cubes_octahedra(N=4):
xs = np.linspace(-N / 2, N / 2, N)
positions = np.array(list(itertools.product(xs, xs, xs)))
cube_positions = positions[::2]
oct_positions = positions[1::2]
cube_colors = np.ones((len(cube_positions), 4))
cube_colors[:] = (.5, .6, .7, 1)
oct_colors = np.ones((len(oct_positions), 4))
oct_colors[:] = (.7, .5, .6, 1)
cube_vertices = list(itertools.product(*(3 * [[-.5, .5]])))
oct_vertices = [
np.roll((0, 0, v), i)
for (i, v) in itertools.product(range(3), [-.5, .5])
]
cubes = draw.ConvexPolyhedra(vertices=cube_vertices,
positions=cube_positions,
colors=cube_colors,
orientations=np.ones_like(cube_colors) *
(1, 0, 0, 0))
octahedra = draw.ConvexPolyhedra(vertices=oct_vertices,
positions=oct_positions,
outline=.025,
colors=oct_colors,
orientations=np.ones_like(oct_colors) *
(1, 0, 0, 0))
rotation = [0.99795496, 0.01934275, -0.06089295, 0.00196485]
scene = draw.Scene([cubes, octahedra], rotation=rotation, zoom=5.5)
return scene
def test_basic_size(self):
test_size = (40, 50)
test_pixel_scale = 32
scene = draw.Scene(size=test_size, pixel_scale=test_pixel_scale)
np.testing.assert_allclose(scene.size, test_size)
np.testing.assert_allclose(
np.array(scene.size) * test_pixel_scale, scene.size_pixels)
def axes_scene(rotation=[1, 0, 0, 0]):
x = np.array([[6, 0, 0],
[6, -1, -1],
[6, -1, 1],
[6, 1, -1],
[6, 1, 1],
[6, -0.5, -0.5],
[6, -0.5, 0.5],
[6, 0.5, -0.5],
[6, 0.5, 0.5]])
x_sphere_prim = draw.Spheres(positions=x,
radii=0.25*np.ones(len(x)),
colors=[[1, 0, 0, 1]]*len(x))
x_lines_prim = draw.Lines(start_points=np.array([[0, 0, 0], *x[1:5]]),
end_points=np.array([x[0]]*5),
widths=0.5*np.ones(5),
colors=[[1, 0, 0, 1]]*5)
y = np.array([[0, 6, 0],
[1, 6, 1],
[-1, 6, 1],
[0, 6, -1],
[0.5, 6, 0.5],
[-0.5, 6, 0.5],
[0, 6, -0.5]])
y_sphere_prim = draw.Spheres(positions=y,
radii=0.25*np.ones(len(y)),
colors=[[0, 1, 0, 1]]*len(y))
y_lines_prim = draw.Lines(start_points=np.array([[0, 0, 0], *y[1:4]]),
end_points=np.array([y[0]]*4),
widths=0.5*np.ones(4),
colors=[[0, 1, 0, 1]]*4)
z = np.array([[0, 0, 6],
[-1, 1, 6],
[1, 1, 6],
[-1, -1, 6],
[1, -1, 6],
[-0.5, -1, 6],
[0, -1, 6],
[0.5, -1, 6],
[-0.5, 1, 6],
[0, 1, 6],
[0.5, 1, 6],
[-0.5, -0.5, 6],
[0.5, 0.5, 6]])
z_sphere_prim = draw.Spheres(positions=z,
radii=0.25*np.ones(len(z)),
colors=[[0, 0, 1, 1]]*len(z))
z_lines_prim = draw.Lines(start_points=np.array([[0, 0, 0], *z[1:4]]),
end_points=np.array([z[0], *z[2:5]]),
widths=0.5*np.ones(4),
colors=[[0, 0, 1, 1]]*4)
scene = draw.Scene([x_sphere_prim, x_lines_prim,
y_sphere_prim, y_lines_prim,
z_sphere_prim, z_lines_prim],
rotation=rotation)
return scene
def test_transform_identity(self):
scene = draw.Scene(translation=(-1, 2, -3),
rotation=(1. / np.sqrt(2), 1. / np.sqrt(2), 0, 0),
zoom=5)
vecs = [(0, 0), (5, 7)]
for space in ['pixels_gui', 'pixels', 'ndc', 'scene']:
transformed = scene.transform(vecs, space, space)
np.testing.assert_allclose(vecs, transformed, atol=1e-4)
def draw_plato(self):
import plato, plato.draw as draw
bonds = np.concatenate(self._data_cache[self._last_data_key], axis=0)
prim = draw.SpherePoints(points=bonds,
on_surface=self.arguments['on_surface'])
scene = draw.Scene(prim,
size=(3, 3),
pixel_scale=100,
features=dict(additive_rendering=dict(invert=True)))
return scene
def ellipsoids():
prim0 = draw.Ellipsoids()
primx = draw.Ellipsoids(positions=(2, 0, 0), a=1.5, b=1.25)
primy = draw.Ellipsoids(positions=(0, 2, 0), b=1.5, c=2)
primz = draw.Ellipsoids(positions=(0, 0, 2), c=1.5)
prims = [prim0, primx, primy, primz]
features = dict(ambient_light=.25, directional_light=(-.1, -.15, -1))
return draw.Scene(prims, zoom=4.6, features=features,
rotation=[0.88047624, 0.27984814, 0.3647052, 0.1159169])
def test_indexing(self):
prim0 = draw.Spheres()
prim1 = draw.ConvexPolyhedra()
scene = draw.Scene([prim0, prim1])
self.assertIs(scene[0], prim0)
self.assertIs(scene[-1], prim1)
self.assertEqual(scene[:2], [prim0, prim1])
self.assertEqual(scene[:3], [prim0, prim1])
with self.assertRaises(IndexError):
scene[5]
def disk_union(seed=15, num_unions=5):
np.random.seed(seed)
points = np.array([[1.0, 0.0], [-0.5, 0.866], [-0.5, -0.866]])
positions = np.random.uniform(-3, 3, (num_unions, 2))*2
angles = np.random.uniform(0, 2*np.pi, 4)
colors = np.random.rand(len(points), 4)
radii = np.random.uniform(0.5, 1.0, (len(points), 1))
prim1 = draw.DiskUnions(positions=positions, angles=angles, colors=colors,
points=points, radii=radii, outline=.125)
scene = draw.Scene([prim1], zoom=2, features=dict(pan=True))
return scene
def voronoi_with_disks(seed=13, num_points=32):
np.random.seed(seed)
positions = np.random.uniform(-3, 3, (num_points, 2))
colors = np.random.rand(num_points, 4)
colors[:, 3] = 1
invbox = np.linalg.inv([[6, 0], [0, 6]])*2
prim = draw.Voronoi(positions=positions, colors=colors, clip_extent=invbox)
prim2 = draw.Disks(positions=positions, colors=colors,
diameters=np.ones((num_points,))*.5, outline=.125)
scene = draw.Scene([prim, prim2], zoom=4, features=dict(pan=True))
return scene
def lines_cube():
vertices = np.array(list(itertools.product(*(3*[[-1, 1]]))), dtype=np.float32)
edge_indices = np.array([0, 1, 1, 3, 3, 2, 2, 0, 0, 4, 1, 5, 3, 7, 2, 6, 4,
5, 5, 7, 7, 6, 6, 4], dtype=np.uint32).reshape((12, 2))
widths = np.ones((12,))*.1
colors = plato.cmap.cubehelix(edge_indices[:, 0].astype(np.float32)/8)
prim = draw.Lines(start_points=vertices[edge_indices[:, 0]],
end_points=vertices[edge_indices[:, 1]],
widths=widths, colors=colors)
features = dict(ambient_light=.25, directional_light=dict(lights=(-.1, -.15, -1)))
rotation = [ 9.9774611e-01, 2.3801494e-02, -6.2734932e-02, 5.5756618e-04]
return draw.Scene(prim, features=features, rotation=rotation, zoom=11)
def draw_plato(self):
min_length = min(*self.box[:3])
pixel_scale = 600 / min_length
size = (min_length * 4. / 3, min_length)
box_args = dict(zip(['Lx', 'Ly', 'Lz', 'xy', 'xz', 'yz'], self.box))
box_prim = draw.Box(**box_args)
box_prim.width = min_length * .05
if self.arguments['density']:
box_prim.color = (1, 1, 1, 1)
color_scale = (self.arguments['color_scale'] *
len(self.positions) / len(self.projected_positions))
prim = draw.Spheres(positions=self.projected_positions,
diameters=.05)
colors = np.zeros((len(prim.positions), 4))
colors[:, :3] = plato.cmap.cubeellipse(
self.projected_types.astype(np.float32))
prim.colors = colors * color_scale
features = dict(ambient_light=0,
directional_light=(0, 0, -1),
additive_rendering=True)
scene = draw.Scene([box_prim, prim], features=features)
else:
colors = np.ones((len(self.positions), 4))
colors[:, :3] = plato.cmap.cubeellipse(
self.types.astype(np.float32))
prim = draw.Spheres(positions=self.positions, colors=colors)
scene = draw.Scene([box_prim, prim])
scene.size = size
scene.pixel_scale = pixel_scale
return scene
def colored_spheres(num_per_side=6):
xs = np.arange(num_per_side).astype(np.float32)
rs = np.array(list(itertools.product(*(3*[xs]))))
rs = np.concatenate([rs, rs + .5], axis=0)
colors = np.ones((rs.shape[0], 4))
colors[:, :3] = rs/(num_per_side - 1)
diameters = np.ones((rs.shape[0],))/np.sqrt(2)
rs -= np.mean(rs, axis=0, keepdims=True)
prim = draw.Spheres(positions=rs, colors=colors, diameters=diameters, outline=.02)
features = dict(ambient_light=.25)
features['directional_light'] = .5*np.array([(.5, .25, -.5), (0, -.25, -.25)])
rotation = [0.43797198, -0.4437895 , 0.08068451, 0.7776423]
return draw.Scene(prim, features=features, zoom=4, rotation=rotation)
def test_transform_center(self):
scene = draw.Scene(translation=(-1, 2, -3),
rotation=(1. / np.sqrt(2), 1. / np.sqrt(2), 0, 0),
zoom=7)
centers = dict(
pixels_gui=np.array(scene.size) * scene.pixel_scale / 2,
pixels=np.array(scene.size) * scene.pixel_scale / 2,
ndc=(0, 0),
scene=-scene.translation[:2],
)
for (dest_name, val) in centers.items():
transformed = scene.transform([(0, 0)], 'ndc', dest_name)
np.testing.assert_allclose([val], transformed, atol=1e-4)
def translate_usable_scenes(draw):
result = []
for scene_fun in ALL_TEST_SCENES:
draw_name = draw.__name__.split('.')[-1]
scene = scene_fun()
usable = all(hasattr(draw, type(prim).__name__) for prim in scene)
usable = usable and scene_fun not in EXCLUDED_SCENES[draw_name]
if usable:
primitives = [getattr(draw, type(prim).__name__).copy(prim) for prim in scene]
new_scene = draw.Scene(primitives, features=scene._enabled_features,
size=scene.size, translation=scene.translation,
rotation=scene.rotation, zoom=scene.zoom,
pixel_scale=scene.pixel_scale)
result.append((scene_fun.__name__, new_scene))
return result
def test_transform_corner(self):
scene = draw.Scene(translation=(-1, 2, -3),
rotation=(1. / np.sqrt(2), 1. / np.sqrt(2), 0, 0),
zoom=9)
# top right corner for each coordinate space
corners = dict(
pixels_gui=(scene.size[0] * scene.pixel_scale, 0),
pixels=scene.size * scene.pixel_scale,
ndc=(1, 1),
scene=(0.5 * scene.size / scene.zoom - scene.translation[:2]),
)
for (dest_name, val) in corners.items():
transformed = scene.transform([(1, 1)], 'ndc', dest_name)
np.testing.assert_allclose([val], transformed, atol=1e-4)
def many_3d_primitives(seed=15, num_particles=3):
np.random.seed(seed)
positions = np.random.uniform(0, 3, (num_particles, 3))
colors = np.random.uniform(.75, .9, (num_particles, 4))**1.5
orientations = np.random.rand(num_particles, 4)
orientations /= np.linalg.norm(orientations, axis=-1, keepdims=True)
vertices = np.random.rand(12, 3)
vertices -= np.mean(vertices, axis=0, keepdims=True)
diameters = np.random.rand(num_particles)
prim = draw.ConvexSpheropolyhedra(positions=positions,
colors=colors,
orientations=orientations,
vertices=vertices,
radius=.1)
prim2 = draw.ConvexPolyhedra.copy(prim)
prim2.positions = (-1, -1, -1) - prim2.positions
prim3 = draw.Spheres.copy(prim)
prim3.diameters = diameters
prim3.positions = (1, -1, 1) - prim.positions
prim4 = draw.Lines(start_points=prim.positions,
end_points=prim2.positions,
colors=np.random.rand(num_particles, 4),
widths=np.ones((num_particles, )) * .1)
(vertices, faces) = plato.geometry.convexHull(vertices)
vertices -= (-1, 1, -1)
indices = list(plato.geometry.fanTriangleIndices(faces))
colors = np.random.rand(len(vertices), 4)
colors[:] = .5
prim5 = draw.Mesh(vertices=vertices, indices=indices, colors=colors)
prim6 = draw.Ellipsoids.copy(prim)
prim6.b = 1.05
prim6.c = 0.8
prim6.positions = (-1, 1, -1) - prim6.positions
prims = [prim, prim2, prim3, prim4, prim5, prim6]
features = dict(ambient_light=.25,
directional_light=(-.1, -.15, -1),
translucency=True)
scene = draw.Scene(prims, zoom=5, clip_scale=10, features=features)
return scene
def sphere_points(seed=14, num_points=128):
np.random.seed(seed)
phi = .5*(1 + np.sqrt(5))
# vertices of a regular dodecahedron
vertices = np.array(list(itertools.product(*(3*[[-1, 1]])))).tolist()
for (i, x, y) in itertools.product(range(3), [-phi, phi], [-1/phi, 1/phi]):
vertices.append(np.roll([0, x, y], i))
positions = np.concatenate([v + np.random.normal(scale=1e-1, size=(num_points, 3))
for v in vertices], axis=0)
prim = draw.SpherePoints(points=positions, blur=10, intensity=1e3)
features = dict(ambient_light=.25, directional_light=dict(lights=(-.1, -.15, -1)),
additive_rendering=dict(invert=True))
rotation = [ 0.7696833 , 0.27754638, 0.4948657 , -0.29268363]
scene = draw.Scene(prim, zoom=10, features=features, rotation=rotation)
return scene
def disks_and_lines():
thetas = np.linspace(0, 2*np.pi, 6, endpoint=False)
extra_positions = np.array([np.cos(thetas), np.sin(thetas)]).T*1.1
positions = np.array([[0, 0]] + extra_positions.tolist())
colors = np.tile([[.25, .25, .8, 1]], (len(positions), 1))
diameters = np.ones((len(positions),))
prim1 = draw.Disks(positions=positions, colors=colors, diameters=diameters)
positions_3d = np.pad(positions, ((0, 0), (0, 1)), 'constant')
colors = np.tile([[.1, .1, .1, 1]], (6, 1))
prim2 = draw.Lines(start_points=np.tile(positions_3d[:1], (6, 1)),
end_points=positions_3d[1:],
widths=np.ones((6,))*.25, colors=colors)
return draw.Scene([prim2, prim1], zoom=10)
def sphere_union(seed=15, num_unions=5):
np.random.seed(seed)
points = np.array([[0.5, 0.5, 0.5],[0.5, -0.5, -0.5],[-0.5, 0.5, -0.5], [-0.5, -0.5, 0.5]])
positions = np.random.uniform(-3, 3, (num_unions, 3))*2
orientations = np.random.rand(num_unions, 4)
orientations /= np.linalg.norm(orientations, axis=-1, keepdims=True)
colors = np.random.rand(len(points), 4)
radii = np.random.uniform(0.5, 1.0, (len(points), 1))
prim1 = draw.SphereUnions(positions=positions, orientations=orientations,colors=colors,
points=points, radii=radii, outline=.10)
features = dict(ambient_light=.25)
features['directional_light'] = .5*np.array([(.5, .25, -.5), (0, -.25, -.25)])
rotation = [ 0.7696833 , 0.27754638, 0.4948657 , -0.29268363]
scene = draw.Scene([prim1], zoom=2, features=features, rotation=rotation)
return scene
def boxes_2d():
prim = draw.Box(Lx=5,
Ly=5,
Lz=0,
xy=0.2,
xz=0.4,
yz=0,
width=0.2,
color=[0, 0.2, 0.6, 1])
prim2 = draw.Box.from_box({
'Lx': 3,
'Ly': 2.5,
'xy': -0.3
},
width=0.15,
color=[0.9, 0.9, 0.2, 1])
prim3 = draw.Box.from_box([2, 1.5], width=0.1, color=[0.5, 0.5, 0.5, 1])
return draw.Scene((prim, prim2, prim3), zoom=3)
def low_poly_stanford_bunny():
"""Low-poly Stanford Bunny 3D model.
Model data from https://www.thingiverse.com/thing:151081 by johnny6, licensed CC BY-NC 4.0.
This example shows a mesh with nonzero outline width and vertex colors.
"""
data = np.load(
os.path.join(DATA_DIR, "low_poly_stanford_bunny", "data.npz"))
vertices = data["vertices"]
indices = data["indices"]
colors = data["colors"]
prim = draw.Mesh(vertices=vertices,
indices=indices,
colors=colors,
outline=2e-2)
rotation = [-0.795798, 0.58683366, -0.12027311, -0.08869123]
return draw.Scene(prim, rotation=rotation, zoom=2)
def spoly_cubes_tetrahedra(seed=13, num_per_side=7):
np.random.seed(seed)
xs = np.arange(num_per_side).astype(np.float32)
rs = np.array(list(itertools.product(*(3 * [xs]))))
rs -= np.mean(rs, axis=0, keepdims=True)
indices = np.arange(rs.shape[0])
types = (indices % 3).astype(np.int32)
colors = plato.cmap.cubehelix(np.linspace(.3, .7, rs.shape[0]), r=3)
orientations = np.tile([(1, 0, 0, 0)], (rs.shape[0], 1)).astype(np.float32)
for i in range(3):
half_angles = 0.5 * np.random.randint(0, 3, rs.shape[0]) * np.pi / 2
new_rotation = np.zeros_like(orientations)
new_rotation[:, 0] = np.cos(half_angles)
new_rotation[:, 1 + i] = np.sin(half_angles)
orientations = plato.math.quatquat(orientations, new_rotation)
tet_verts = np.array([(1, 1, -1), (1, -1, 1), (-1, 1, 1), (-1, -1, -1)],
dtype=np.float32) / 3
cube_verts = np.concatenate([tet_verts, -tet_verts], axis=0)
filt = types == 0
prim1 = draw.ConvexSpheropolyhedra(vertices=tet_verts,
radius=1 / 6,
positions=rs[filt],
orientations=orientations[filt],
colors=colors[filt])
filt = types == 1
prim2 = draw.ConvexSpheropolyhedra(vertices=cube_verts,
radius=1 / 6,
positions=rs[filt],
orientations=orientations[filt],
colors=colors[filt])
rotation = [0.94578046, 0.0234278, 0.32349595, 0.01735411]
features = dict(ambient_light=.25, directional_light=(-.1, -.15, -1))
scene = draw.Scene([prim1, prim2],
zoom=4,
features=features,
rotation=rotation)
return scene
def sunflower_2d(seed=13):
center_disk = draw.Disks(outline=.05, positions=np.zeros((1, 2)),
colors=np.array([0.225, 0.1, 0., 1]),
diameters=np.sqrt(3))
thetas = np.linspace(0, 2*np.pi, 6, endpoint=False)
vertices = np.array([np.cos(thetas), np.sin(thetas)]).T
orientations = np.array([[np.cos(np.pi/12), 0, 0, np.sin(np.pi/12)]] * 6)
petals = draw.Polygons(positions=np.sqrt(3)*vertices, colors=np.array([[0.9, 0.7, 0, 1]]*6),
vertices=vertices, outline=.05, orientations=orientations)
"""
prim2 = draw.Disks(outline=.05, positions=positions,
colors=colors, diameters=np.ones((num_particles,)))
prim3 = draw.Polygons(positions=-positions, colors=colors, vertices=vertices,
outline=.05, orientations=orientations)
"""
scene = draw.Scene([center_disk, petals], zoom=4, features=dict(pan=True))
return scene
def boxes_3d():
prim = draw.Box(Lx=5,
Ly=5,
Lz=6,
xy=0.2,
xz=0.4,
yz=0,
width=0.2,
color=[0, 0.2, 0.6, 1])
prim2 = draw.Box.from_box([3, 2.5, 4, 0.1, -0.2, 0.5],
width=0.15,
color=[0.9, 0.9, 0.2, 1])
prim3 = draw.Box.from_box(box=[2, 1.5, 2, 0.8, 0.1, -0.2],
width=0.1,
color=[0.5, 0.5, 0.5, 1])
features = dict(ambient_light=.25,
directional_light=dict(lights=(-.1, -.15, -1)))
rotation = [9.9774611e-01, 2.3801494e-02, -6.2734932e-02, 5.5756618e-04]
return draw.Scene((prim, prim2, prim3),
features=features,
rotation=rotation,
zoom=3)
def test_features(self):
scene = draw.Scene(
features=dict(test1=13, test2=dict(test_name='test2')))
self.assertIn('test1', scene.enabled_features)
self.assertIn('test2', scene.enabled_features)
self.assertNotIn('test3', scene.enabled_features)
self.assertEqual(scene.get_feature_config('test1'), {'value': 13})
self.assertEqual(scene.get_feature_config('test2'),
{'test_name': 'test2'})
self.assertEqual(scene.get_feature_config('test3'), None)
scene.enable('test3',
'auto_value',
value='discard',
another_value=None)
self.assertIn('test3', scene.enabled_features)
self.assertEqual(scene.get_feature_config('test3'), {
'value': 'auto_value',
'another_value': None
})
