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 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 generate_image(self): self.vapory_sene = vapory.Scene( self.vapory_camera, objects=[self.vapory_light, self.simulated_loop.loop_object]) image_array = self.vapory_sene.render("/tmp/vapory_tmp_image.png", width=self.image_dimensions[0], height=self.image_dimensions[1]) self.qimage = QImage("/tmp/vapory_tmp_image.png") self.emit("imageReceived", self.qimage, self.qimage.width(), self.qimage.height(), self.force_update)
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 _render_scene(self, camera, objects): """ Renders the window to 2D grayscale image Called from render function for each viewpoint """ scene = vapory.Scene(camera=camera, objects=objects) img = scene.render(width=self.render_size[0], height=self.render_size[1], quality=3) img = rgb2gray(img) return img
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 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 render_scene(self, t=None): """Renders a single scene, applying the various perturbations on each object/light source in the Experiment. :returns: `(example, annotation)` pair. TODO: Call the make_targets() function, implemented by subclasses, that uses the object locations, orientations, etc. set by render_scene, to calculate the targets. """ dynamic_objects = [obj(t) for obj in self.dynamic_objects] experiment_objects = [obj(t) for obj in self.experiment_objects] all_objects = self.static_objects + dynamic_objects + experiment_objects vap_scene = vapory.Scene(self.camera, all_objects, included=self.included) # image, annotation ndarrays of np.uint8s. image = vap_scene.render(height=self.image_shape[0], width=self.image_shape[1]) if self.mode == 'L': image = img.grayscale(image) # Add noise if self.noisify: peak = 5000 # TODO: make fps dependent. image = np.random.poisson(image.astype(np.float64) / 255. * peak) image = (image / peak * 255.).astype(np.uint8) # compute annotation, label using most recently used args, produced by the # render call annotation, label = self.annotate_and_label() return (image, label), annotation
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 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 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])])