def povray_test():
""" Just a purple sphere """
scene = vapory.Scene( vapory.Camera('location', [0.0, 0.5, -4.0],
'direction', [0,0,1.5],
'look_at', [0, 0, 0]),
objects = [
vapory.Background("color", [0.85, 0.75, 0.75]),
vapory.LightSource([0, 0, 0],
'color',[1, 1, 1],
'translate', [-5, 5, -5]),
vapory.LightSource ([0, 0, 0],
'color', [0.25, 0.25, 0.25],
'translate', [600, -600, -600]),
vapory.Box([-0.5, -0.5, -0.5], [0.5, 0.5, 0.5],
vapory.Texture( vapory.Pigment( 'color', [1,0,0]),
vapory.Finish('specular', 0.6),
vapory.Normal('agate', 0.25, 'scale', 0.5)),
'rotate', [45,46,47])
]
)
# We use antialiasing. Remove this option for faster rendering.
scene.render("cube.png", width=300, height=300, antialiasing=0.001)
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 gen_img_settings_quality(l):
""" generate the general povray settings"""
lhalf = 0.5 * l
### sphere radius
sphere_radius = 0.7
### RESOLUTION
img_widthpx = 1024
img_heightpx = 1024
### includes and defaults
povray_includes = ["colors.inc", "textures.inc", "shapes.inc"]
povray_defaults = [vapory.Finish( 'ambient', 0.1, \
'diffuse', 0.65, \
'specular', 0.5, \
'shininess', 0.53, \
'opacity', 1.0)]
### light sources
sun1 = vapory.LightSource([lhalf, lhalf, -1.01 * lhalf], 'color', 'White')
sun2 = vapory.LightSource([lhalf, lhalf, -1.01 * lhalf], 'color',
[0.7, 0.7, 0.7])
### background
background = vapory.Background('color', [1, 1, 1])
### camera
povray_cam = vapory.Camera('location', [lhalf, lhalf, -1.01*lhalf], \
'look_at', [lhalf,lhalf,0], 'angle', 90)
### text
# If desired include this in the povray_objects - array declared in the loop
#text1 = \
#vapory.Text( 'ttf', '"timrom.ttf"' ,'"Division:"', 0.01, 0.0, \
#'scale', [0.5,0.5,0.5],'rotate', \
#[0,90,0], 'translate' , [0.0 , 15.0+2.75-1 , 15.0+1.5], \
#vapory.Pigment('Black') )
### render quality
quality = 10
return sphere_radius, img_widthpx, img_heightpx, povray_includes, \
povray_defaults, sun1, sun2, background, povray_cam, quality
def setGeo(self, SS, SC, dist, North):
SS_xyz = self.XYZ(SS['lon'], SS['lat'])
SC_xyz = self.XYZ(SC['lon'], SC['lat'])
declares = [
'SS_lon = %f; // Subsolar longitude [deg_W]' % SS['lon'],
'SS_lat = %f; // Subsolar latitude [deg_N]' % SS['lat'],
'SC_lon = %f; // Subspacecraft longitude [deg_W]' % SC['lon'],
'SC_lat = %f; // Subspacecraft latitude [deg_N]' % SC['lat'],
'R_Body = %f; // Planetary body radius [km]' %
BODY_RADIUS[self.target]
]
camera = pov.Camera('angle', INST_FOV[self.inst], 'location',
SC_xyz * dist, 'look_at', [0, 0, 0],
'Axis_Rotate_Trans(', SC_xyz, ',', -North, ')')
light = pov.LightSource(SS_xyz * DIST_SUN[self.target], 'color',
'White')
obj = pov.Object('Grid')
self.scene = pov.Scene(
declares=declares,
camera=camera,
objects=[light, obj],
included=['colors.inc', 'transforms.inc', 'Planet_grid.inc'])
return self
def render(self, screen_size):
light = vap.LightSource([3, 3, 3], 'color', [3, 3, 3], 'parallel',
'point_at', [0, 0, 0])
camera = vap.Camera('location', [0.5 * 1, -2 * 1, 3 * 1], 'look_at',
[0, 0, 0], 'rotate', [20, 0, 0])
ground = vap.Plane([0, 0, 1], 0, vap.Texture('T_Stone33'))
walls = [wall.rendered for wall in self.wall]
robots = [bot.rendered for bot in self.robot]
obj = self.obj.rendered
obj_pos_str = '\"{:2.2f}, {:2.2f}, {:2.2f}\"'.format(
*self.obj.body.getPosition())
for ir, robot in enumerate(self.robot):
logger.info('{} - {:2.2f}, {:2.2f}, {:2.2f} - {st}'.format(
ir, *robot.body.getPosition(), st=self.sim_time))
logger.info('{} - {}'.format(obj_pos_str, self.sim_time))
# obj_pos = vap.Text('ttf', '\"timrom.ttf\"', obj_pos_str, 0.1, '0.1 * x', 'rotate',
# '<100,0,10>', 'translate', '-3*x', 'finish',
# '{ reflection .25 specular 1 diffuse 0.1}', 'scale', [0.25, 0.25, 0.25])
scene = vap.Scene(
camera,
[light, ground,
vap.Background('color', [0.2, 0.2, 0.3]), obj] + robots + walls,
included=["colors.inc", "textures.inc", "glass.inc", "stones.inc"])
return scene.render(height=screen_size,
width=screen_size,
antialiasing=0.01,
remove_temp=False)
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 render_povray(scene, filename='ipython', width=600, height=600,
antialiasing=0.01):
'''Render the scene with povray for publication.
:param dict scene: The scene to render
:param string filename: Output filename or 'ipython' to render in the notebook.
:param int width: Width in pixels.
:param int height: Height in pixels.
'''
if not vapory_available:
raise Exception("To render with povray, you need to have the vapory"
" package installed.")
# Camera target
aspect = scene['camera']['aspect']
up = np.dot(rmatrixquaternion(scene['camera']['quaternion']), [0, 1, 0])
v_fov = scene['camera']['vfov'] / 180.0 * np.pi
h_fov = 2.0 * np.arctan(np.tan(v_fov/2.0) * aspect) / np.pi * 180
# Setup camera position
camera = vp.Camera( 'location', scene['camera']['location'],
'direction', [0, 0, -1],
'sky', up,
'look_at', scene['camera']['target'],
'angle', h_fov )
# Lights
light_sources = [vp.LightSource( np.array([2,4,-3]) * 1000, 'color', [1,1,1] ),
vp.LightSource( np.array([-2,-4,3]) * 1000, 'color', [1,1,1] ),
vp.LightSource( np.array([-1,2,3]) * 1000, 'color', [1,1,1] ),
vp.LightSource( np.array([1,-2,-3]) * 1000, 'color', [1,1,1] )]
# Background -- white for now
background = vp.Background([1, 1, 1])
# Things to display
stuff = _generate_objects(scene['representations'])
scene = vp.Scene( camera, objects = light_sources + stuff + [background])
return scene.render(filename, width=width, height=height,
antialiasing = antialiasing)
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 main():
# helpers
color = lambda col : vapory.Texture(vapory.Pigment('color', col))
texture = lambda text : vapory.Texture(text)
# Begin setup
s1 = experiment.ExperimentSphere(argsf1, texture('White_Wood'),
semantic_label=1)
s2 = experiment.ExperimentSphere(argsf2, texture('White_Wood'),
semantic_label=2)
# experiment
global exp
exp = experiment.Experiment(image_shape=image_shape,
num_classes=num_classes,
N=N, data_root=root,
output_format=output_formats,
fps=fps, mode='L')
exp.add_object(vapory.LightSource([0, 5*image_shape[0], 0],
'color', [1,1,1]))
exp.add_object(vapory.LightSource([5*image_shape[0], 0, 0],
'color', [1,1,1]))
# Background
exp.add_object(vapory.Plane(
[0,0,1], 10*max(r1, r2), vapory.Texture(
vapory.Pigment(vapory.ImageMap('png', '"scripts/images/harper.png"')),
'scale', '300', 'translate', [image_shape[0] // 2, 2*image_shape[1] // 3, 0])))
exp.add_object(s1)
exp.add_object(s2)
if debug:
(image, _) , _ = exp.render_scene(0)
plt.imshow(image[:,:,0], cmap='gray')
plt.show()
else:
exp.run()
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 init(self):
"""
Descript. :
"""
self.vapory_camera = vapory.Camera("location", [0, 2, -3], "look_at", [0, 1, 2])
self.vapory_light = vapory.LightSource([2, 4, -3], "color", [1, 1, 1])
self.simulated_loop = SimulatedLoop()
self.simulated_loop.set_position(0, 0, 0)
self.force_update = False
self.image_dimensions = [600, 400]
self.image_type = JpegType()
self.set_is_ready(True)
self.generate_image()
self.image_polling = gevent.spawn(self._do_imagePolling, 1)
def __init__(self,
render_size=DEFAULT_RENDER_SIZE,
camera_pos=DEFAULT_CAMERA_POS):
"""
Initializes VTK objects for rendering.
"""
self.render_size = render_size
self.camera_pos = camera_pos
self.camera_view_count = len(self.camera_pos)
self.cameras = []
for pos in self.camera_pos:
self.cameras.append(
vapory.Camera('location', pos, 'look_at', [0.0, 0.0, 0.0]))
# lighting
self.light = vapory.LightSource([2.0, 3.0, -2.5], 'color',
[1.0, 1.0, 1.0], 'shadowless')
def generateScenes():
delta=0.1
nbcubes=100
light = vapory.LightSource( [2,4,-7], 'color', [2,2,2] )
ambientlight=AmbientLight([1,1,1])
objects=[light]
rotation=[np.random.rand()*180,np.random.rand()*180,np.random.rand()*180]
for k in range(nbcubes):
center=[0+np.random.randn()*3,0+np.random.randn()*2,0+np.random.rand()*2]
#sphere=vapory.Sphere( center, 0.5, vapory.Pigment( 'color', [1,1,1]))
#sphere=vapory.Sphere( center, 0.5, vapory.Pigment( 'color', np.random.rand(3) ),vapory.Finish('phong', 0.8,'reflection', 0.5))
#objects.append(sphere)
#center=[0+np.random.randn()*2,0+np.random.randn()*2,0+np.random.rand()*2]
#objects.append(vapory.Box( [-0.5,-0.5,-0.5], [ 0.5,0.5,0.5 ], 'rotate',rotation , 'translate',center ,vapory.Pigment( 'color', np.random.rand(3) ),vapory.Finish('phong', 0.8,'reflection', 0.0)))
#center=[0+np.random.randn()*2,0+np.random.randn()*2,0+np.random.rand()*1.0]
#sphere=vapory.Sphere( center, 0.5, vapory.Pigment( 'color', [1,1,1]))
#sphere=vapory.Sphere( center, 0.5, vapory.Pigment( 'color', np.random.rand(3) ),vapory.Finish('phong', 0.8,'reflection', 0.5))
#objects.append(sphere)
center=[0+np.random.randn()*3,0+np.random.randn()*2,0+np.random.rand()*2]
#objects.append(vapory.Box( [-0.5,-0.5,-0.5], [ 0.5,0.5,0.5 ], 'rotate',rotation , 'translate',center ,vapory.Pigment( 'color', np.random.rand(3) ),vapory.Finish('phong', 0.8,'reflection', 0.1)))
#objects.append(vapory.Box( [-0.5,-0.5,-0.5], [ 0.5,0.5,0.5 ], 'rotate',rotation , 'translate',center ,vapory.Pigment( 'color',[1,1,1] )))
#objects.append(vapory.Box( [-0.5,-0.5,-0.5], [ 0.5,0.5,0.5 ], 'rotate',rotation , 'translate',center,vapory.Texture('Rosewood')))
objects.append(vapory.Box( [-0.5,-0.5,-0.5], [ 0.5,0.5,0.5 ], 'rotate',rotation , 'translate',center,vapory.Texture('White_Marble')))
#ground = vapory.Plane([0,1,0],0, vapory.Texture('Rosewood'))
#objects.append(ground)
camera_left = vapory.Camera( 'location', [0-delta,0,-5], 'look_at', [0-delta,0,0] ) # <= Increase for better quality
camera_right = vapory.Camera( 'location', [0+delta,0,-5], 'look_at', [0+delta,0,0]) # <= Increase for better quality
scene_left = vapory.Scene( camera_left, objects= objects,included = ["colors.inc", "textures.inc"],)
scene_right = vapory.Scene( camera_right, objects= objects,included = ["colors.inc", "textures.inc"],)
return scene_left,scene_right
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])])
def plot(self, state, iteration, temperature, field, save=False):
"""It is a function that creates the complete scene of the evolve of the
states. It join the two array of the images. Also, it allows to put a text on
the top of the scene.
:param state: It gets the states information from the simulation hdf file.
:type state: list
:param iteration: It gets the number of iterations from the hdf file.
:type iteration: int
:param temperature: It gets the temperature information from the hdf file.
:type temperature: float/list/dict
:param field: It gets the field information from the hdf file.
:type field: float/list/dict
:return: It returns an array of the complete image.
:rtype: array
"""
camera = vapory.Camera(
"location",
self.location,
"look_at",
self.centroid,
"sky",
[0, 0, 1],
"up",
[0, 0, 1],
"right",
[0, 1, 0],
)
background = vapory.Background([1, 1, 1])
light = vapory.LightSource(self.location, "color", [1, 1, 1])
arrows = []
for position, direction in zip(self.positions, state):
color = self.get_rgb(direction, self.mode)
arrows.append(PovrayArrow(position, direction, color))
scene = vapory.Scene(camera, objects=[background, light, *arrows])
scene_image = scene.render(width=self.size,
height=self.size,
antialiasing=0.1)
image = PlotStates.join_images(self.colorbar_image, scene_image)
if self.index == 1:
title = "Initial state"
else:
title = f"T = {temperature:.2f}; H = {field:.2f}; iteration = {iteration}"
draw = ImageDraw.Draw(image)
draw.text((0.2 * image.width, 0), title, (0, 0, 0), font=self.font)
if save:
try:
os.mkdir(self.output)
except FileExistsError:
pass
image.save(f"{self.output}/figure_{self.index}.png")
self.index += 1
return numpy.array(image)
def getScene(self, *, cameraLocation=[100,100,50], cameraTarget=[0,0,0], lightLocation=[100,100,100],
lightColor=[1,1,1], backgroundColor=[0,0,0], objectColor=[0.5,0.5,0.5],
rotationAxis=None, rotationAngle=None):
# POVRay uses a left-handed coordinate system, so we have to flip the Z axis on all geometric vectors
cameraLocation[2] = -cameraLocation[2]
cameraTarget[2] = -cameraTarget[2]
lightLocation[2] = -lightLocation[2]
vertices = self.getUniqueVertices()
if rotationAxis and rotationAngle:
rotationMatrix = rotation_matrix(rotationAxis, rotationAngle)
# Z axis must be flipped in vertex coords as well, before the transform
vertexArgs = [ len(vertices) ] + [ list(np.dot(rotationMatrix, np.array([x,y,-z]))) for x,y,z in vertices ]
else:
vertexArgs = [ len(vertices) ] + [ [x,y,-z] for x,y,z in vertices ] # even if there is no rotation we must flip Z axis
triangleIndices = self.getTriangleIndicesForUniqueVertices()
faceArgs = [ len(triangleIndices) ] + list(map(list, triangleIndices))
normales = np.zeros((len(vertices), 3))
npvertices = np.array(vertices)
for v0, v1, v2 in triangleIndices:
triangleNormale = np.cross(npvertices[v1,:]-npvertices[v0,:], npvertices[v2,:]-npvertices[v0,:])
triangleNormale /= np.linalg.norm(triangleNormale)
triangleArea = np.dot(npvertices[v1,:]-npvertices[v0,:], npvertices[v2,:]-npvertices[v0,:])/2
normales[v0,:] += triangleNormale*triangleArea
normales[v1,:] += triangleNormale*triangleArea
normales[v2,:] += triangleNormale*triangleArea
normales /= np.linalg.norm(normales, axis=1, keepdims=True)
# for i in range(len(vertices)):
# print(f'Vertex {vertices[i]} has normale {normales[i]} (product {np.dot(vertices[i], normales[i])})')
# print(f'{np.dot(vertices[i], normales[i])}')
if rotationAxis and rotationAngle:
rotationMatrix = rotation_matrix(rotationAxis, rotationAngle)
# Z axis must be flipped in vertex coords as well, before the transform
normaleArgs = [ len(vertices) ] + [ list(np.dot(rotationMatrix, np.array([x,y,-z]))) for x,y,z in [ normales[i,:] for i in range(len(vertices)) ] ]
else:
# even if there is no rotation we must flip Z axis
normaleArgs = [ len(vertices) ] + [ [x,y,-z] for x,y,z in [ normales[i,:] for i in range(len(vertices)) ] ]
# print('Rendering with camera at {} and light at {}'.format(str(cameraLocation), str(lightLocation)))
asteroid = vpr.Mesh2(vpr.VertexVectors(*vertexArgs),
vpr.NormalVectors(*normaleArgs),
vpr.FaceIndices(*faceArgs),
vpr.Texture(vpr.Pigment('color', 'rgb', [0.5, 0.5, 0.5]),
vpr.Normal('bumps', 0.75, 'scale', 0.0125),
vpr.Finish('phong', 0.1)
)
)
# vpr.Texture(vpr.Pigment('color', objectColor)))
return vpr.Scene( vpr.Camera('location', cameraLocation, 'look_at', cameraTarget, 'sky', [0,0,-1]),
objects = [ vpr.LightSource(lightLocation, 'color', lightColor),
vpr.Background('color', backgroundColor),
asteroid
],
included = ["colors.inc", "textures.inc"]
# ,defaults = [vpr.Finish( 'ambient', 0.0, 'diffuse', 0.0)]
,global_settings = [ 'ambient_light <0,0,0>' ]
)
def main():
# helpers
color = lambda col: vapory.Texture(vapory.Pigment('color', col))
# initial state, in SI units
global initial, current
initial = {}
initial['x1'] = np.array([x1, y1]) / 100.
initial['v1'] = np.array([vx1, vy1]) / 100.
initial['x2'] = np.array([x2, y2]) / 100.
initial['v2'] = np.array([vx2, vy2]) / 100.
# Calculate initial acceleration with equations of motion
initial['a1'], initial['a2'] = calculate_acceleration(
initial['x1'], initial['x2'])
current = initial.copy()
# Begin setup
s1 = experiment.ExperimentSphere(argsf1,
vapory.Texture('White_Wood'),
semantic_label=1)
s2 = experiment.ExperimentSphere(argsf2,
vapory.Texture('White_Wood'),
semantic_label=2)
# experiment
exp = experiment.Experiment(image_shape=image_shape,
num_classes=num_classes,
N=N,
data_root=root,
output_format=output_formats,
fps=fps,
mode='L')
exp.add_object(
vapory.LightSource([0, 5 * image_shape[0], 0], 'color', [1, 1, 1]))
exp.add_object(
vapory.LightSource([5 * image_shape[0], 0, -2 * image_shape[0]],
'color', [1, 1, 1]))
# Background
# TODO: make this an actually interesting experiment with a background image.
exp.add_object(
vapory.Plane([0, 0, 1], 10 * max(r1, r2),
vapory.Texture(
vapory.Pigment(
vapory.ImageMap('png',
'"scripts/images/harper.png"')),
'scale', '300', 'translate',
[image_shape[0] // 2, 2 * image_shape[1] // 3, 0])))
if do_walls:
global walls
border = min(r1, r2)
walls = np.zeros(4) # top, left, bottom, right
walls[:2] = exp.unproject_to_image_plane((border, border))[:2]
walls[2:] = exp.unproject_to_image_plane(
(image_shape[0] - border, image_shape[1] - border))[:2]
walls /= 100. # convert to meters
exp.add_object(s1)
exp.add_object(s2)
if debug:
(image, _), _ = exp.render_scene(0)
plt.imshow(np.squeeze(image), cmap='gray')
plt.show()
else:
exp.run()
def render_povray(scene,
filename='ipython',
width=600,
height=600,
antialiasing=0.01,
extra_opts={}):
'''Render the scene with povray for publication.
:param dict scene: The scene to render
:param string filename: Output filename or 'ipython' to render in the notebook.
:param int width: Width in pixels.
:param int height: Height in pixels.
:param dict extra_opts: Dictionary to merge/override with the passed scene.
'''
if not vapory_available:
raise Exception("To render with povray, you need to have the vapory"
" package installed.")
# Adding extra options
scene = normalize_scene(scene)
scene.update(extra_opts)
# Camera target
aspect = scene['camera']['aspect']
up = np.dot(rmatrixquaternion(scene['camera']['quaternion']), [0, 1, 0])
v_fov = scene['camera']['vfov'] / 180.0 * np.pi
h_fov = 2.0 * np.arctan(np.tan(v_fov / 2.0) * aspect) / np.pi * 180
# Setup camera position
camera = vp.Camera('location', scene['camera']['location'], 'direction',
[0, 0, -1], 'sky', up, 'look_at',
scene['camera']['target'], 'angle', h_fov)
global_settings = []
# Setup global illumination
if scene.get('radiosity', False):
# Global Illumination
radiosity = vp.Radiosity(
'brightness',
2.0,
'count',
100,
'error_bound',
0.15,
'gray_threshold',
0.0,
'low_error_factor',
0.2,
'minimum_reuse',
0.015,
'nearest_count',
10,
'recursion_limit',
1, #Docs say 1 is enough
'adc_bailout',
0.01,
'max_sample',
0.5,
'media off',
'normal off',
'always_sample',
1,
'pretrace_start',
0.08,
'pretrace_end',
0.01)
light_sources = []
global_settings.append(radiosity)
else:
# Lights
light_sources = [
vp.LightSource(np.array([2, 4, -3]) * 1000, 'color', [1, 1, 1]),
vp.LightSource(np.array([-2, -4, 3]) * 1000, 'color', [1, 1, 1]),
vp.LightSource(np.array([-1, 2, 3]) * 1000, 'color', [1, 1, 1]),
vp.LightSource(np.array([1, -2, -3]) * 1000, 'color', [1, 1, 1])
]
# Background -- white for now
background = vp.Background([1, 1, 1])
# Things to display
stuff = _generate_objects(scene['representations'])
scene = vp.Scene(camera,
objects=light_sources + stuff + [background],
global_settings=global_settings)
return scene.render(filename,
width=width,
height=height,
antialiasing=antialiasing)
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)]))
# experiment sphere parameters
def argsf(t_):
t = t_ * time_step
return ([vx * t + x, 0.5 * g * t**2 + vy * t + y, 0], radius)
ball = experiment.ExperimentSphere(argsf, color('Red'))
# experiment
exp = experiment.Experiment(image_shape=image_shape,
num_classes=num_classes,
N=N,
fname=fname,
output_format=output_formats,
fps=fps,
mode='L')
exp.add_object(
vapory.LightSource([0, 5 * image_shape[0], -5 * image_shape[1]], 'color',
[1, 1, 1]))
exp.add_object(vapory.Plane([0, 1, 0], y - radius, color('White'))) # ground
exp.add_object(vapory.Plane([0, 0, 1], 5 * radius,
color('White'))) # back wall
exp.add_object(ball)
if debug:
image, annotation = exp.render_scene(2 * fps)
plt.imshow(image[:, :, 0], cmap='gray')
plt.show()
else:
exp.run(verbose=True)