def make_circular_spherical_lens(roc1, roc2, thickness, radius, n, *args):
sag1 = functions.calc_sphere_sag(roc1, radius)
sag2 = functions.calc_sphere_sag(roc2, radius)
sections = []
surface1 = vp.Sphere([0, 0, roc1], abs(roc1))
if roc1 > 0:
sections.append(
vp.Intersection(surface1,
vp.Cylinder([0, 0, 0], [0, 0, sag1], radius)))
elif roc1 < 0:
sections.append(
vp.Difference(vp.Cylinder([0, 0, sag1], [0, 0, 0], radius),
surface1))
sections.append(
vp.Cylinder([0, 0, max(sag1, 0)], [0, 0, thickness + min(sag2, 0)],
radius))
surface2 = vp.Sphere([0, 0, thickness + roc2], abs(roc2))
if roc2 < 0:
sections.append(
vp.Intersection(
surface2,
vp.Cylinder([0, 0, thickness + sag2], [0, 0, thickness],
radius)))
elif roc2 > 0:
sections.append(
vp.Difference(
vp.Cylinder([0, 0, thickness], [0, 0, thickness + sag2],
radius), surface2))
lens = vp.Union(*sections, vp.Texture('T_Glass3'), vp.Interior('ior', n),
*args)
return lens
def povray_cells(goodArguments):
with h5py.File(goodArguments.vbl_simulation_output_filename, 'r') as f:
h5_cells_grp = f[goodArguments.grp_pattern + "/cells"]
pos = h5_cells_grp['cell_center_pos']
pos = np.asarray(pos)
rad = h5_cells_grp['cell_radii']
rad = np.asarray(rad)
o2 = h5_cells_grp['o2']
o2 = np.asarray(o2)
x_min= np.min(pos[:,0])
x_max = np.max(pos[:,0])
center_x = x_min+0.5*(x_max-x_min)
y_min= np.min(pos[:,1])
y_max = np.max(pos[:,1])
center_y = x_min+0.5*(y_max-y_min)
z_min= np.min(pos[:,2])
z_max = np.max(pos[:,2])
center_z = z_min+0.5*(z_max-z_min)
print('x: [%f,%f]' % (x_min, x_max))
print('y: [%f,%f]' % (y_min, y_max))
print('z: [%f,%f]' % (z_min, z_max))
print('%f, %f, %f' %(center_x,center_y,center_z))
#o2 = o2/np.max(o2)
# x = pos[:,0]
# y = pos[:,1]
# z = pos[:,2]
# s = rad[:,0]
camera = vapory.Camera('location', [700,700,-700], 'look_at', [0,0,0])
light = vapory.LightSource([1000,-1000,-1000], 'color', [1, 1, 1])
light2 = vapory.LightSource([0,0,0], 'color',[1, 1, 1], 'translate', [1000,-1000,-1000] )
light3 = vapory.LightSource([500,-1000,500], 'color', [1, 1, 1] )
myObjectList = []
myObjectList.append(light)
myObjectList.append(light2)
myObjectList.append(light3)
cuttingY = vapory.Plane([0,1,0], 0,)
cuttingX = vapory.Plane([1,0,0], -1,)
max_rad = np.max(rad)
max_o2 = np.max(o2)
n= 10000
for (aPosition, aRadius, aO2Value) in zip(pos[0:n], rad[0:n], o2[0:n]):
thisSphere = vapory.Sphere( aPosition, aRadius[0])
color = matplotlib.cm.hsv(aO2Value[0]/max_o2)
#print(color[0:3])
#cuttedSphere = vapory.Intersection(thisSphere, cuttingY, vapory.Texture( vapory.Pigment( 'color', color[0:3] )))
#cuttedSphere = vapory.Intersection(thisSphere, cuttingY, cuttingX)
#cuttedSphere = thisSphere
#myObjectList.append(cuttedSphere)
#myObjectList.append(thisSphere)
# myObjectList.append(vapory.Sphere( aPosition, aRadius[0], vapory.Texture( vapory.Pigment( 'color', matplotlib.cm.Blues(aO2Value[0]/max_o2) ))))
myObjectList.append(vapory.Sphere( aPosition, aRadius[0], vapory.Texture( vapory.Pigment( 'color', [1,0,0] ))))
scene = vapory.Scene( camera, objects= myObjectList, defaults = [vapory.Finish( 'ambient', 1.5)],)
scene.render("purple_sphere.png", width=400, height=300, antialiasing=0.01, remove_temp=True)
def _generate_objects(representations):
objects = []
for rep in representations:
if rep['type'] == 'spheres':
for (x, y, z), r, c in zip(rep['options']['coordinates'],
rep['options']['radii'],
rep['options']['colors']):
# Generate the shape
sphere = vp.Sphere( [x,y,z] , r, vp.Texture( vp.Pigment( 'color', hex2rgb(c)) ))
objects.append(sphere)
elif rep['type'] == 'points':
# Render points as small spheres
for (x, y, z), c, s in zip(rep['options']['coordinates'],
rep['options']['colors'],
rep['options']['sizes']):
# Point = sphere with a small radius
sphere = vp.Sphere( [x,y,z] , s * 0.15,
vp.Texture( vp.Pigment( 'color', hex2rgb(c)) ))
objects.append(sphere)
elif rep['type'] == 'surface':
verts = rep['options']['verts']
faces = rep['options']['faces']
color = rep['options']['color']
triangles = verts.take(faces, axis=0)
for v1, v2, v3 in triangles:
povt = vp.Triangle(v1.tolist(),
v2.tolist(),
v3.tolist(),
vp.Texture(vp.Pigment('color', hex2rgb(color))))
objects.append(povt)
elif rep['type'] == 'cylinders':
start = rep['options']['startCoords']
end = rep['options']['endCoords']
radii = rep['options']['radii']
colors = rep['options']['colors']
for s, e, r, c in zip(start, end, radii, colors):
cylinder = vp.Cylinder(s.tolist(), e.tolist(), r,
vp.Texture(vp.Pigment('color', hex2rgb(c))))
objects.append(cylinder)
else:
print("No support for representation type: %s" % rep['type'])
return objects
def make_cali_img_pairs(w,
h,
loc,
look_at,
direct1,
direct2,
rotate=[0, 0, 0],
trans=[0, 0, 0],
ctype=None,
rand_amount=1):
cali_dir = os.path.join(CFD, "caliimg")
light = vp.LightSource(
# [2,4,-3],
[0, 0, -10000],
'color',
"White",
'rotate',
[30, 0, 0],
'rotate',
[0, 88, 0]) # White light
background = vp.Background("color", "White") # White background
center = np.array(look_at) + (np.random.rand(3) - 0.5) * rand_amount
sphere = vp.Sphere(
center,
0.1, # center, radius
vp.Texture(vp.Pigment('color', "Black"))) # Black point
l_camera = vp.Camera('location', loc, 'direction', direct1, 'up',
[0, 1, 0], 'right', [1 * w / h, 0, 0], 'look_at',
look_at)
l_scene = vp.Scene(l_camera,
objects=[background, light, sphere],
included=["colors.inc"])
l_img_path = os.path.join(cali_dir, "left.png")
l_scene.render(l_img_path, width=w, height=h, auto_camera_angle=False)
r_camera = vp.Camera('location', loc, 'direction', direct2, 'up',
[0, 1, 0], 'right', [1 * w / h, 0, 0], 'look_at',
look_at, 'rotate', rotate, 'translate', trans)
r_scene = vp.Scene(r_camera,
objects=[background, light, sphere],
included=["colors.inc"])
r_img_path = os.path.join(cali_dir, "right.png")
r_scene.render(r_img_path, width=w, height=h, auto_camera_angle=False)
with open(os.path.join(cali_dir, "left.pov"), "wb") as f:
f.write(l_scene.__str__())
with open(os.path.join(cali_dir, "right.pov"), "wb") as f:
f.write(r_scene.__str__())
return cv2.imread(l_img_path), cv2.imread(r_img_path)
def make_square_spherical_lens(roc1: float, roc2: float, thickness: float,
side_length: float, n: float, *args):
radius = side_length / 2**0.5
sag1 = functions.calc_sphere_sag(roc1, radius)
sag2 = functions.calc_sphere_sag(roc2, radius)
hsl = side_length / 2
sections = []
if np.isfinite(roc1):
surface1 = vp.Sphere([0, 0, roc1], abs(roc1))
if roc1 > 0:
sections.append(
vp.Intersection(surface1,
vp.Box([-hsl, -hsl, 0], [hsl, hsl, sag1])))
elif roc1 < 0:
sections.append(
vp.Difference(vp.Box([-hsl, -hsl, sag1], [hsl, hsl, 0]),
surface1))
sections.append(
vp.Box([-hsl, -hsl, max(sag1, 0)],
[hsl, hsl, thickness + min(sag2, 0)]))
surface2 = vp.Sphere([0, 0, thickness + roc2], abs(roc2))
if np.isfinite(roc2):
if roc2 < 0:
sections.append(
vp.Intersection(
surface2,
vp.Box([-hsl, -hsl, thickness + sag2],
[hsl, hsl, thickness])))
elif roc2 > 0:
sections.append(
vp.Difference(
vp.Box([-hsl, -hsl, thickness],
[hsl, hsl, thickness + sag2]), surface2))
lens = vp.Union(
*sections, vp.Texture('T_Glass2'), vp.Interior('ior', n),
*args) # , *args) vp.Texture( vp.Pigment( 'color', [1,0,1] ))
return lens
def scene(t):
"""
Returns the scene at time 't' (in seconds)
"""
head_location = np.array(location) - np.array([0, 0, head_size])
import vapory
light = vapory.LightSource([15, 15, 1], 'color',
[light_intensity] * 3)
background = vapory.Box(
[0, 0, 0], [1, 1, 1],
vapory.Texture(
vapory.Pigment(
vapory.ImageMap('png',
'"../files/VISUEL_104.png"', 'once')),
vapory.Finish('ambient', 1.2)), 'scale',
[self.background_depth, self.background_depth, 0], 'translate',
[
-self.background_depth / 2, -.45 * self.background_depth,
-self.background_depth / 2
])
me = vapory.Sphere(
head_location, head_size,
vapory.Texture(vapory.Pigment('color', [1, 0, 1])))
self.t = t
self.update()
objects = [background, me, light]
for i_lame in range(self.N_lame):
#print(i_lame, self.lame_length[i_lame], self.lame_width[i_lame])
objects.append(
vapory.Box(
[
-self.lame_length[i_lame] / 2, 0,
-self.lame_width[i_lame] / 2
],
[
self.lame_length[i_lame] / 2, self.lames_height,
self.lame_width[i_lame] / 2
],
vapory.Pigment('color', [1, 1, 1]),
vapory.Finish('phong', 0.8, 'reflection', reflection),
'rotate',
(0, -self.lames[2, i_lame] * 180 / np.pi, 0), #HACK?
'translate',
(self.lames[0, i_lame], 0, self.lames[1, i_lame])))
objects.append(light)
return vapory.Scene(vapory.Camera('angle', fov, "location",
location, "look_at", look_at),
objects=objects,
included=["glass.inc"])
def PovrayArrow(position, direction, color):
"""
This function creates the arrow with the library vapory
(https://pypi.org/project/Vapory/). It helps to process the image.
:param position: It is the position where the object is going to be ubicated.
:type position: list
:param direction: It is the course along which the object moves.
:type direction: list
:param color: It is representes by the RGB color model. It is an additive color
model in which red, green, and blue light are added together in various ways to
reproduce a broad array of colors.
:type color: list
:return: It returns an ``Union()`` of three 3D figures, that represent the
``PovrayArrow()``.
:rtype: ``Union()``
"""
position = numpy.array(position)
direction = numpy.array(direction) * 0.9
base_point_cylinder = position - 0.5 * direction
cap_point_cone = position + 0.7 * direction
cap_point_cylinder = base_point_cone = base_point_cylinder + 0.7 * direction
radius_cylinder = 1 / 20
base_radius_cone = 1 / 6
texture = vapory.Texture(vapory.Pigment("color", color),
vapory.Finish("roughness", 0, "ambient", 0.2))
cylinder = vapory.Cylinder(base_point_cylinder, cap_point_cylinder,
radius_cylinder, texture)
cone = vapory.Cone(base_point_cone, base_radius_cone, cap_point_cone, 0.0,
texture)
sphere = vapory.Sphere(
position,
2 * radius_cylinder,
vapory.Texture(vapory.Pigment("color", [0, 0, 0])),
)
return vapory.Union(sphere, vapory.Union(cone, cylinder))
def renderPopSpheres():
nb_spheres = 50
R = 5.
centers = np.random.randint(100, size=(nb_spheres, 3))
radius = np.random.randn(nb_spheres) * R + R
couleurs = np.random.randint(255, size=(nb_spheres, 4)) / 255.
camera = vapory.Camera('location', [150, 150, 150], 'look_at', [0, 0, 0])
bg = vapory.Background('color', [1, 1, 1])
light = vapory.LightSource([100, 100, 100], 'color', [1, 1, 1])
light3 = vapory.LightSource([0, 0, 0], 'color', [1, 1, 1])
light2 = vapory.LightSource([50, 50, 50], 'color', [1, 1, 1])
obj = [light, light2, light3, bg]
for i in range(nb_spheres):
sphere = vapory.Sphere(
centers[i, ], radius[i],
vapory.Texture(
vapory.Finish('ambient', 0, 'reflection', 0, 'specular', 0,
'diffuse', 1),
vapory.Pigment('color', couleurs[i, ])))
obj.append(sphere)
scene = vapory.Scene(camera, objects=obj)
scene.render("spheres.png", width=3000, height=3000)
def plot_frames(beads, sim, ti, tf, savebase, colorid):
""" plot frames within the specified time window"""
### define the color for the spheres
print 'defining colors'
if colorid == "id":
sphere_rgbcolor = gen_colors_based_on_id(sim.nbeads, sim.npols,
beads.pid)
elif colorid == "orient":
sphere_rgbcolor = gen_colors_based_on_orient(sim.nbeads, sim.npols,
beads.ori)
### create povray settings
print 'creating povray settings'
sphere_radius, img_widthpx, img_heightpx, povray_includes, \
povray_defaults, sun1, sun2, background, povray_cam, quality \
= gen_img_settings_quality(sim.lx)
zi = np.zeros((sim.nbeads), dtype=np.float32)
### set general plot properties
os.system("mkdir -p " + savebase)
savebase = data_separator.gen_folder_path(savebase, '_', sim.phaseparams)
os.system("mkdir -p " + savebase)
### plot the frames
for step in range(ti, tf):
time = step * sim.dt
print 'Step / Total : ', step, tf
### create povray items
print 'generating povray item'
particles = vapory.Object( \
vapory.Union( \
*[ vapory.Sphere([beads.xi[step, 0, j], beads.xi[step, 1, j],zi[j]], \
sphere_radius, vapory.Texture( \
vapory.Pigment('color', sphere_rgbcolor[j]), \
vapory.Finish('phong',1)) ) for j in range(0, sim.nbeads ) ] ) )
### generate povray objects
print 'generating povray objects'
povray_objects = [sun1, sun2, background, particles]
### create the scene
scene = vapory.Scene(camera=povray_cam,
objects=povray_objects,
included=povray_includes,
defaults=povray_defaults)
### render image
print 'rendering scene'
savename = "pov-frame-" + "{0:05d}".format(int(step)) + ".png"
scene.render(outfile=savename, width=img_widthpx, height=img_heightpx, \
antialiasing=0.001, quality=quality, remove_temp=True)
### move the image to the correct destination
os.system('mv ' + savename + ' ' + savebase)
return
def rendered(self):
return vap.Sphere(
list(self.body.getPosition()), self._radius,
vap.Texture(
vap.Pigment('color',
self._color if self._color else [1, 0, 1])))
def scene(pack,
cmap=None,
rot=0,
camera_height=0.7,
camera_dist=1.5,
angle=None,
lightstrength=1.1,
orthographic=False,
pad=None,
floater_color=(.6, .6, .6),
bgcolor=(1, 1, 1),
box_color=(.5, .5, .5),
group_indexes=None,
clip=False):
"""
Render a 3D scene.
Requires `vapory` package, which requires the `povray` binary.
Parameters
----------
cmap : a colormap
box_color : Color to draw the box. 'None' => don't draw box.
floater_color : Color for floaters. 'None' => same color as non-floaters (use cmap).
group_indexes : a list of indexes for each "group" that should remain
together on the same side of the box.
clip : clip the spheres at the edge of the box.
Returns
-------
scene : vapory.Scene, which can be rendered using its `.render()` method.
"""
import vapory
import numpy as np
try:
import matplotlib as mpl
import matplotlib.cm as mcm
vmin, vmax = min(pack.diameters), max(pack.diameters)
sm = mcm.ScalarMappable(norm=mpl.colors.Normalize(vmin, vmax),
cmap=cmap)
cols = [sm.to_rgba(s) for s in pack.diameters]
except ImportError:
if not isinstance(cmap, list):
raise ValueError(
"matplotlib could not be imported, and cmap not recognizeable as a list"
)
cols = list(cmap)
except TypeError:
if not isinstance(cmap, list):
raise ValueError(
"matplotlib could not convert cmap to a colormap," +
" and cmap not recognizeable as a list")
cols = list(cmap)
if floater_color is not None:
ix, _ = pack.backbone()
ns, = np.nonzero(~ix)
for n in ns:
cols[n] = floater_color
mod_add = .5 if not clip else 0.
rs = np.remainder(pack.rs + mod_add, 1) - mod_add
if group_indexes is not None:
for ix in group_indexes:
xs = pack.rs[ix, :]
com = np.mean(xs, axis=0)
comdiff = (np.remainder(com + mod_add, 1) - mod_add) - com
rs[ix, :] = xs + comdiff
if clip:
spheres = []
cube = vapory.Box((-.5, -.5, -.5), (.5, .5, .5))
dxs = [-1., 0.]
drs = np.array([(dx, dy, dz) for dx in dxs for dy in dxs
for dz in dxs])
maxr = 0
for xyz, s, col in zip(rs, pack.diameters, cols):
for dr in drs:
r = dr + xyz
if np.any(abs(r) - s / 2. > .5):
# not in the box
continue
sphere = vapory.Sphere(r, s / 2.)
cutsphere = vapory.Intersection(
cube, sphere,
vapory.Texture(vapory.Pigment('color', col[:3])))
spheres.append(cutsphere)
if np.amax(r) > maxr:
maxr = np.amax(r)
else:
spheres = [
vapory.Sphere(xyz, s / 2.,
vapory.Texture(vapory.Pigment('color', col[:3])))
for xyz, s, col in zip(rs, pack.diameters, cols)
]
maxr = np.amax(np.amax(np.abs(rs), axis=1) + pack.diameters / 2.)
extent = (-.5, .5)
corners = [
np.array((x, y, z)) for x in extent for y in extent for z in extent
]
pairs = [(c1, c2) for c1 in corners for c2 in corners
if np.allclose(np.sum((c1 - c2)**2), 1) and sum(c1 - c2) > 0]
radius = 0.01
cyls, caps = [], []
if box_color is not None:
col = vapory.Texture(vapory.Pigment('color', box_color))
cyls = [vapory.Cylinder(c1, c2, 0.01, col) for c1, c2 in pairs]
caps = [vapory.Sphere(c, radius, col) for c in corners]
light_locs = [[8., 5., -3.], [-6., 6., -5.], [-6., -7., -4.],
[10., -5., 7.]]
rotlocs = [[
x * np.cos(rot) - z * np.sin(rot), y,
z * np.cos(rot) + x * np.sin(rot)
] for x, y, z in light_locs]
lights = [
# vapory.LightSource( [2,3,5], 'color', [1,1,1] ),
vapory.LightSource(loc, 'color', [lightstrength] * 3)
for loc in rotlocs
]
cloc = [
np.cos(rot) * camera_dist, camera_dist * camera_height,
np.sin(rot) * camera_dist
]
# mag = sqrt(sum([d**2 for d in cloc]))
# direction = [-v*2/mag for v in cloc]
if angle is None:
if pad is None:
pad = max(pack.diameters)
w = sqrt(2) * maxr + pad
angle = float(np.arctan2(w, 2 * camera_dist)) * 2 * 180 / np.pi
camera = vapory.Camera('location', cloc, 'look_at', [0, 0, 0], 'angle',
angle)
# vapory.Camera('orthographic', 'location', cloc, 'direction',
# direction, 'up', [0,2,0], 'right', [2,0,0])
return vapory.Scene(camera,
objects=(lights + spheres + cyls + caps +
[vapory.Background("color", bgcolor)]))
def _generate_objects(representations):
objects = []
for rep in representations:
if rep['rep_type'] == 'spheres':
for i, (x, y, z) in enumerate(rep['options']['coordinates']):
r = rep['options']['radii'][i]
c = rep['options']['colors'][i]
# Generate the shape
sphere = vp.Sphere([x, y, z], r,
vp.Texture(vp.Pigment('color', hex2rgb(c))))
objects.append(sphere)
elif rep['rep_type'] == 'points':
# Render points as small spheres
for i, (x, y, z) in enumerate(rep['options']['coordinates']):
c = rep['options']['colors'][i]
s = rep['options']['sizes'][i]
if not 'alpha' in rep['options']:
t = 1.0
else:
t = rep['options']['alpha'][i]
# Point = sphere with a small radius
sphere = vp.Sphere([x, y, z], s * 0.15,
vp.Texture(
vp.Pigment('color', 'rgbf',
hex2rgb(c) + (1 - t, ))),
vp.Interior('ior', 1.0))
objects.append(sphere)
elif rep['rep_type'] == 'surface':
verts = rep['options']['verts']
faces = rep['options']['faces']
color = rep['options']['color']
triangles = verts.take(faces, axis=0)
for v1, v2, v3 in triangles:
povt = vp.Triangle(
v1.tolist(), v2.tolist(), v3.tolist(),
vp.Texture(vp.Pigment('color', hex2rgb(color))))
objects.append(povt)
elif rep['rep_type'] == 'cylinders':
start = rep['options']['startCoords']
end = rep['options']['endCoords']
colors = rep['options']['colors']
for i, (s, e) in enumerate(zip(start, end)):
r = rep['options']['radii'][i]
c = rep['options']['colors'][i]
t = _get_transparency(rep['options'], i)
cylinder = vp.Cylinder(
s.tolist(), e.tolist(), r,
vp.Texture(
vp.Pigment('color', 'rgbf',
hex2rgb(c) + (1 - t, ))))
objects.append(cylinder)
elif rep['rep_type'] == 'lines':
start = rep['options']['startCoords']
end = rep['options']['endCoords']
colors = rep['options']['startColors']
for i, (s, e) in enumerate(zip(start, end)):
#r = rep['options']['radii'][i]
r = 0.02
c = colors[i]
t = _get_transparency(rep['options'], i)
cylinder = vp.Cylinder(
s.tolist(), e.tolist(), r,
vp.Texture(
vp.Pigment('color', 'rgbf',
hex2rgb(c) + (1 - t, ))))
objects.append(cylinder)
else:
raise ValueError("No support for representation rep_type: %s" %
rep['rep_type'])
return objects
def scene(pack,
cmap=None,
rot=0,
camera_height=0.7,
camera_dist=1.5,
angle=None,
lightstrength=1.1,
orthographic=False,
pad=None,
floatercolor=(.6, .6, .6)):
"""
Render a scene.
Requires `vapory` package, which requires the `povray` binary.
Parameters
----------
cmap : a colormap
Returns
-------
scene : vapory.Scene, which can be rendered using its `.render()` method.
"""
import vapory
import numpy as np
try:
import matplotlib as mpl
import matplotlib.cm as mcm
vmin, vmax = min(pack.sigmas), max(pack.sigmas)
sm = mcm.ScalarMappable(norm=mpl.colors.Normalize(vmin, vmax),
cmap=cmap)
cols = [sm.to_rgba(s) for s in pack.sigmas]
except ImportError:
if not isinstance(cmap, list):
raise ValueError(
"matplotlib could not be imported, and cmap not recognizeable as a list"
)
cols = list(cmap)
except TypeError:
if not isinstance(cmap, list):
raise ValueError(
"matplotlib could not convert cmap to a colormap, and cmap not recognizeable as a list"
)
cols = list(cmap)
if floatercolor is not None:
ix, _ = pack.backbone()
ns, = np.nonzero(~ix)
for n in ns:
cols[n] = floatercolor
rs = np.remainder(pack.rs + .5, 1) - .5
spheres = [
vapory.Sphere(xyz, s / 2.,
vapory.Texture(vapory.Pigment('color', col[:3])))
for xyz, s, col in zip(rs, pack.sigmas, cols)
]
extent = (-.5, .5)
corners = [
np.array((x, y, z)) for x in extent for y in extent for z in extent
]
pairs = [(c1, c2) for c1 in corners for c2 in corners
if np.allclose(np.sum((c1 - c2)**2), 1) and sum(c1 - c2) > 0]
radius = 0.01
col = vapory.Texture(vapory.Pigment('color', [.5, .5, .5]))
cyls = [vapory.Cylinder(c1, c2, 0.01, col) for c1, c2 in pairs]
caps = [vapory.Sphere(c, radius, col) for c in corners]
light_locs = [[8., 5., -3.], [-6., 6., -5.], [-6., -7., -4.],
[10., -5., 7.]]
rotlocs = [[
x * np.cos(rot) - z * np.sin(rot), y,
z * np.cos(rot) + x * np.sin(rot)
] for x, y, z in light_locs]
lights = [
#vapory.LightSource( [2,3,5], 'color', [1,1,1] ),
vapory.LightSource(loc, 'color', [lightstrength] * 3)
for loc in rotlocs
]
cloc = [
np.cos(rot) * camera_dist, camera_dist * camera_height,
np.sin(rot) * camera_dist
]
mag = sqrt(sum([d**2 for d in cloc]))
direction = [-v * 2 / mag for v in cloc]
if angle is None:
if pad is None: pad = max(pack.sigmas)
w = sqrt(2) + pad
angle = float(np.arctan2(w, 2 * camera_dist)) * 2 * 180 / np.pi
camera = vapory.Camera('location', cloc, 'look_at', [0, 0, 0], 'angle',
angle)
# vapory.Camera('orthographic', 'location', cloc, 'direction', direction, 'up', [0,2,0], 'right', [2,0,0])
return vapory.Scene(camera,
objects=lights + spheres + cyls + caps +
[vapory.Background("color", [1, 1, 1])])