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 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 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 _set_camera(self): """Sets the camera dimensions of the Experiment so that the output image has `image_shape`. Also sets the camera projection matrix. Should only be called by __init__(). """ camera_distance = self.image_shape[0] * self.camera_multiplier location = [0, 0, -camera_distance] direction = [0, 0, 1] # POV-Ray direction vector aspect_ratio = self.image_shape[0] / self.image_shape[ 1] # aspect ratio right = [aspect_ratio, 0, 0] # POV-Ray vector half_angle_radians = np.arctan(1 / (2 * self.camera_multiplier)) # (Szeliski 53) focal_length = self.image_shape[1] / (2 * np.tan(half_angle_radians)) # Set the camera projection matrix. K = np.array( [[focal_length, 0, self.image_shape[0] / 2], [0, aspect_ratio * focal_length, self.image_shape[1] / 2], [0, 0, 1]]) T = np.array([[0], [0], [camera_distance]]) R = np.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]]) P = K @ np.concatenate((R, T), axis=1) self._camera_WtoI = np.concatenate((P, [[0, 0, 0, 1]]), axis=0) self._camera_ItoW = np.linalg.inv(self._camera_WtoI) self.camera_location = np.array(location) self.camera = vapory.Camera('location', location, 'direction', direction, 'right', right, 'angle', 2 * np.degrees(half_angle_radians))
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 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 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 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 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 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 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 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 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 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 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 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 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])])