def model(cam_pos, cam_look_at, vertices, indices, ambient_color, dir_light_intensity, dir_light_direction, normals, colors): #normals = pyredner.compute_vertex_normal(vertices, indices, normal_scheme) #m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5])) m = pyredner.Material(use_vertex_color=True) obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m, colors=colors) cam = pyredner.Camera( position=cam_pos, look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=(1000, 1000)) scene = pyredner.Scene(camera=cam, objects=[obj]) ambient_light = pyredner.AmbientLight(ambient_color) dir_light = pyredner.DirectionalLight(dir_light_direction, dir_light_intensity) img = pyredner.render_deferred(scene=scene, lights=[ambient_light, dir_light], aa_samples=1) return img
def visual_vertex_grad(vertices: torch.Tensor, indices: torch.Tensor, cam: pyredner.Camera = None): if not hasattr(visual_vertex_grad, 'x'): visual_vertex_grad.x = 0 else: visual_vertex_grad.x += 1 cam = pyredner.Camera( position=cam_pos, look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=(1000, 1000)) m = pyredner.Material(use_vertex_color=True) obj = pyredner.Object(vertices=vertices, indices=indices, material=m) coe = 500000. color_reps = torch.tensor([[[1., 0., 0.], [0., -1., -1.]], [[0., 1., 0.], [-1., 0., -1.]], [[0., 0., 1.], [-1., -1., 0.]]]).to(pyredner.get_device()) grad_imgs = [] for d in range(3): colors = torch.where( vertices.grad[:, d:d + 1].expand(-1, 3) > 0, vertices.grad[:, d:d + 1].expand(-1, 3) * color_reps[d, 0], vertices.grad[:, d:d + 1].expand(-1, 3) * color_reps[d, 1]) * coe obj.colors = colors scene = pyredner.Scene(camera=cam, objects=[obj]) grad_imgs.append(pyredner.render_albedo(scene=scene)) for d in range(3): pyredner.imwrite( grad_imgs[d].cpu(), output_path + '/grad_imgs/{:0>2d}{:0>2d}.png'.format(d, visual_vertex_grad.x)) return grad_imgs
def generate_scenes(camLocs,objects,envmap=None, lightLocs=None): scenes = [] up = torch.tensor([0.0, 1.0, 0.0]) offset_factor = 0.0 light_intensity = 100.0 for ind, loc in enumerate(camLocs): camera = pyredner.Camera(position = loc, look_at = torch.tensor([0.0, 0.0, 0.0]), up = camera0.up, fov = torch.tensor([90.0]), #fov = camera0.fov, resolution = camera0.resolution) normal = camera.position.div(torch.norm(camera.position)) tangent = torch.cross(normal, up) tangent = tangent.div(torch.norm(tangent)) bitangent = torch.cross(normal, tangent) bitangent = bitangent.div(torch.norm(bitangent)) offsets = [offset_factor * tangent] lightLocs = [(camera.position + offset) for offset in offsets] lights = [pyredner.generate_quad_light(position = lightPos, look_at = camera0.look_at, size = torch.tensor([0.1, 0.1]), intensity = torch.tensor([light_intensity, light_intensity, light_intensity])) for lightPos in lightLocs] scene_objects = objects #objects.append(lights[0]) scenes.append(pyredner.Scene(camera = camera, objects = [objects[0], objects[1], objects[2], lights[0]], envmap=None)) return scenes
def model(cam_pos, cam_look_at, vertices, color_coeffs, ambient_color, dir_light_intensity, dir_light_direction): #vertices = (shape_mean + shape_basis @ torch.zeros(199, device=pyredner.get_device())).view(-1, 3) normals = pyredner.compute_vertex_normal(vertices, indices) colors = (color_mean + color_basis @ color_coeffs).view(-1, 3) #m = pyredner.Material(use_vertex_color=True) m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5])) obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m, colors=colors) cam = pyredner.Camera( position=cam_pos, look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=(512, 512)) scene = pyredner.Scene(camera=cam, objects=[obj]) ambient_light = pyredner.AmbientLight(ambient_color) dir_light = pyredner.DirectionalLight(dir_light_direction, dir_light_intensity) img = pyredner.render_deferred(scene=scene, lights=[ambient_light, dir_light]) return img, obj
def model(cam_poses, cam_look_at, shape_coeffs, color_coeffs, lights_list, resolution): vertices = (shape_mean + shape_basis @ shape_coeffs).view(-1, 3) normals = pyredner.compute_vertex_normal(vertices, indices) colors = (color_mean + color_basis @ color_coeffs).view(-1, 3) #m = pyredner.Material(diffuse_reflectance = torch.tensor([0.5, 0.5, 0.5])) m = pyredner.Material(use_vertex_color=True) obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m, colors=colors) imgs = [] for i in range(cam_poses.size(0)): cam = pyredner.Camera( position=cam_poses[i], look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=resolution) scene = pyredner.Scene(camera=cam, objects=[obj]) #ambient_light = pyredner.AmbientLight(ambient_color) #dir_light = pyredner.DirectionalLight(dir_light_direction, dir_light_intensity) img = pyredner.render_deferred(scene=scene, lights=lights_list[i % len(lights_list)], aa_samples=1) imgs.append(img) return imgs, obj
def make_scenes(mesh, settings): ''' Make redner scenes with the given mesh, and the (camera, lights) settings ''' cameras, lights = settings if not isinstance(mesh, list): mesh = [mesh] scenes = [pyr.Scene(camera=c, objects=mesh) for c in cameras] return scenes
def grad_image(self): grads = torch.clone(self.mesh.vertices.grad).detach() vcolormat = pyr.Material(use_vertex_color=True) grads_mag = torch.abs(grads) vcolors = (grads_mag - grads_mag.min()) / (grads_mag.max()-grads_mag.min()) gradobj = pyr.Object(self.mesh.vertices, self.mesh.indices, material=vcolormat, normals=self.mesh.normals, colors=vcolors) cameras = self.settings[0] gradscenes = [pyr.Scene(c, objects=[gradobj]) for c in cameras] grads_rendered = pyr.render_albedo(gradscenes) return grads_rendered
def parse_scene(node): cam = None resolution = None materials = [] material_dict = {} shapes = [] lights = [] shape_group_dict = {} envmap = None for child in node: if child.tag == 'sensor': cam = parse_camera(child) elif child.tag == 'bsdf': node_id, material = parse_material(child) if node_id is not None: material_dict[node_id] = len(materials) materials.append(material) # shapegroup for instancing elif child.tag == 'shape' and child.attrib['type'] == 'shapegroup': for child_s in child: if child_s.tag == 'shape': shape_group_dict[child.attrib['id']] = parse_shape( child_s, material_dict, None)[0] elif child.tag == 'shape': shape, light = parse_shape( child, material_dict, len(shapes), shape_group_dict if child.attrib['type'] == 'instance' else None) if isinstance(shape, list): shapes = shapes + shape else: shapes.append(shape) if light is not None: lights.append(light) # Add envmap loading support elif child.tag == 'emitter' and child.attrib['type'] == 'envmap': # read envmap params from xml scale = 1.0 envmap_filename = None to_world = torch.eye(4) for child_s in child: if child_s.attrib['name'] == 'scale': assert child_s.tag == 'float' scale = float(child_s.attrib['value']) if child_s.attrib['name'] == 'filename': assert child_s.tag == 'string' envmap_filename = child_s.attrib['value'] if child_s.attrib['name'] == 'toWorld': to_world = parse_transform(child_s) # load envmap envmap = scale * pyredner.imread(envmap_filename) if pyredner.get_use_gpu(): envmap = envmap.cuda() envmap = pyredner.EnvironmentMap(envmap, env_to_world=to_world) return pyredner.Scene(cam, shapes, materials, lights, envmap)
def model(translation, euler_angles): # Get the rotation matrix from Euler angles rotation_matrix = pyredner.gen_rotate_matrix(euler_angles) # Shift the vertices to the center, apply rotation matrix, # shift back to the original space, then apply the translation. for obj, v in zip(objects, vertices): obj.vertices = ( v - center) @ torch.t(rotation_matrix) + center + translation # Assemble the 3D scene. scene = pyredner.Scene(camera=camera, objects=objects) # Render the scene. img = pyredner.render_albedo(scene) return img
def generate_scenes(camLocs, objects, envmap=None, lightLocs=None): scenes = [] up = torch.tensor([0.0, 1.0, 0.0]) offset_factor = 2.0 light_intensity = 10000.0 for ind, loc in enumerate(camLocs): multiplier = 1.0 look_at_offset = torch.tensor([0.0, 0.0, 0.0]) camera = pyredner.Camera(position=camera0.look_at + radius * loc * multiplier, look_at=camera0.look_at + look_at_offset, up=camera0.up, fov=camera0.fov, resolution=camera0.resolution) normal = camera.position.div(torch.norm(camera.position)) tangent = torch.cross(normal, up) tangent = tangent.div(torch.norm(tangent)) bitangent = torch.cross(normal, tangent) bitangent = bitangent.div(torch.norm(bitangent)) offsets = [offset_factor * tangent] #, offset_factor * normal] lightLocs = [(camera.position + offset) for offset in offsets] #else: # lightPos = lightLocs[ind] lights = [ pyredner.generate_quad_light(position=lightPos, look_at=camera0.look_at, size=torch.tensor([0.1, 0.1]), intensity=torch.tensor([ light_intensity, light_intensity, light_intensity ])) for lightPos in lightLocs ] # Camera data for voxel carving print( str(ind) + " " + str(camera.position.data[0].item()) + " " + str(camera.position.data[1].item()) + " " + str(camera.position.data[2].item()) + " " + str(camera.look_at.data[0].item()) + " " + str(camera.look_at.data[1].item()) + " " + str(camera.look_at.data[2].item())) for light in lights: scenes.append( pyredner.Scene(camera=camera, objects=[objects[0], light], envmap=None)) return scenes
def parse_scene(node, device, param_dict): cam = None # resolution = None materials = [] material_dict = {} shapes = [] lights = [] shape_group_dict = {} shape_id = {} envmap = None cam, materials, material_dict, shapes, shape_id, lights, shape_group_dict, envmap = \ parse_xml(node, device, param_dict, cam, materials, material_dict, shapes, shape_id, lights, shape_group_dict, envmap) return pyredner.Scene(cam, shapes, shape_id, materials, lights, envmap)
def model(cam_pos, cam_look_at, shape_coeffs, color_coeffs, resolution, center, all_euler_angles, all_translations): # First rotate around center, then translation imgs = [] #obj = pyredner.load_obj('p_ones30/final.obj', return_objects=True)[0] vertices, indices, uvs, normals = pyredner.generate_sphere(128, 64) vertices *= 80 m = pyredner.Material( diffuse_reflectance=torch.ones(2, 2, 3, dtype=torch.float32)) obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, uvs=uvs, material=m) v = obj.vertices.clone() for i in range(len(all_translations)): rotation_matrix = pyredner.gen_rotate_matrix(all_euler_angles[i]).to( pyredner.get_device()) center = center.to(pyredner.get_device()) # vertices = ((shape_mean + shape_basis @ shape_coeffs).view(-1, 3) - center) @ torch.t(rotation_matrix) + center + all_translations[i].to(pyredner.get_device()) obj.vertices = (v - center) @ torch.t(rotation_matrix) + center obj.normals = pyredner.compute_vertex_normal(obj.vertices, indices) # colors = (color_mean + color_basis @ color_coeffs).view(-1, 3) # m = pyredner.Material(diffuse_reflectance = torch.tensor([0.5, 0.5, 0.5])) m = pyredner.Material(use_vertex_color=True) # obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m, colors=colors) if i == 0: pyredner.save_obj(obj, "generated/env_dataset_" + name + '/tgt_obj.obj') cam = pyredner.Camera( position=cam_pos, look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=resolution) scene = pyredner.Scene(camera=cam, objects=[obj], envmap=envmap) img = pyredner.render_pathtracing(scene=scene, num_samples=(128, 4)) imgs.append(img) return imgs
def parse_scene(node): cam = None resolution = None materials = [] material_dict = {} shapes = [] lights = [] for child in node: if child.tag == 'sensor': cam = parse_camera(child) elif child.tag == 'bsdf': node_id, material = parse_material(child) if node_id is not None: material_dict[node_id] = len(materials) materials.append(material) elif child.tag == 'shape': shape, light = parse_shape(child, material_dict, len(shapes)) shapes.append(shape) if light is not None: lights.append(light) return pyredner.Scene(cam, shapes, materials, lights)
def _model(self): # Get the rotation matrix from Euler angles rotation_matrix = pyredner.gen_rotate_matrix(self.euler_angles) self.euler_angles.retain_grad() # Shift the vertices to the center, apply rotation matrix, # shift back to the original space, then apply the translation. vertices = [] if self.attack_type == "CW": for m, shape in zip(self.modifiers, self.shapes): shape_v = tanh_rescale( torch_arctanh(shape.vertices.clone().detach()) - m.clone().detach() + m) shape.vertices = (shape_v - self.center) @ torch.t( rotation_matrix) + self.center + self.translation shape.vertices.retain_grad() shape.vertices.register_hook(set_grad(shape.vertices)) shape.normals = pyredner.compute_vertex_normal( shape.vertices, shape.indices) vertices.append(shape.vertices.clone().detach()) else: for shape in self.shapes: shape_v = shape.vertices.clone().detach() shape.vertices = (shape_v - self.center) @ torch.t( rotation_matrix) + self.center + self.translation shape.vertices.retain_grad() shape.vertices.register_hook(set_grad(shape.vertices)) shape.normals = pyredner.compute_vertex_normal( shape.vertices, shape.indices) vertices.append(shape.vertices.clone().detach()) self.center = torch.mean(torch.cat(vertices), 0) # Assemble the 3D scene. scene = pyredner.Scene(camera=self.camera, shapes=self.shapes, materials=self.materials) # Render the scene. img = pyredner.render_deferred(scene, lights=[self.light], alpha=True) return img
def model(cam_poses, cam_look_ats, shape_coeffs, color_coeffs, resolution): # First rotate around center, then translation imgs = [] vertices = (shape_mean + shape_basis @ shape_coeffs).view(-1, 3) normals = pyredner.compute_vertex_normal(vertices, indices) colors = (color_mean + color_basis @ color_coeffs).view(-1, 3) m = pyredner.Material(use_vertex_color=False, specular_reflectance=torch.tensor( [1., 1., 1.], device=pyredner.get_device()), roughness=torch.tensor([0.02])) obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m, colors=colors) obj = pyredner.load_obj('generated/env_dataset_oness_n/tgt_obj.obj', return_objects=True)[0] obj.material.specular_reflectance = pyredner.Texture( torch.tensor([0.05, 0.05, 0.05], device=pyredner.get_device())) obj.material.roughness = pyredner.Texture(torch.tensor([0.02])) pyredner.save_obj(obj, "generated/senv_dataset_" + name + '/tgt_obj.obj') for i in range(len(cam_poses)): cam = pyredner.Camera( position=cam_poses[i], look_at=cam_look_ats[i % len(cam_look_ats)], # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=resolution) scene = pyredner.Scene(camera=cam, objects=[obj], envmap=envmap) img = pyredner.render_pathtracing(scene=scene, num_samples=(128, 4)) imgs.append(img) return imgs
def generate_scenes(camLocs, objects, envmap=None): scenes = [] up = torch.tensor([0.0, 1.0, 0.0]) offset_factor = 2.0 light_intensity = 500.0 for ind, loc in enumerate(camLocs): camera = pyredner.Camera(position=camera0.look_at + radius * loc, look_at=camera0.look_at, up=camera0.up, fov=camera0.fov, resolution=camera0.resolution) normal = camera.position.div(torch.norm(camera.position)) tangent = torch.cross(normal, up) tangent = tangent.div(torch.norm(tangent)) bitangent = torch.cross(normal, tangent) bitangent = bitangent.div(torch.norm(bitangent)) lightPos = camera.position + offset_factor * tangent light = pyredner.generate_quad_light(position=lightPos, look_at=camera0.look_at, size=torch.tensor([0.1, 0.1]), intensity=torch.tensor([ light_intensity, light_intensity, light_intensity ])) # Camera data for voxel carving #print(str(ind) + " " + str(camera.position.data[0].item()) + " " + str(camera.position.data[1].item()) + " " + str(camera.position.data[2].item()) + " " + str(camera.look_at.data[0].item()) + " " + str(camera.look_at.data[1].item()) + " " + str(camera.look_at.data[2].item())) scenes.append( pyredner.Scene(camera=camera, objects=[objects[0], light], envmap=envmap)) return scenes
def model(cam_poses, cam_look_at, vertices, lights_list, normals, material): # m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5])) obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=material, uvs=uvs, uv_indices=uv_indices) # , colors=colors) imgs = [] for i in range(cam_poses.size(0)): cam = pyredner.Camera( position=cam_poses[i], look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), resolution=(1000, 1000)) scene = pyredner.Scene(camera=cam, objects=[obj]) img = pyredner.render_deferred(scene=scene, lights=lights_list[i % len(lights_list)], aa_samples=1) imgs.append(img) return imgs
target_obj1[0].material = pyredner.Material(diffuse_reflectance=torch.tensor([1.0, 1.0, 1.0]), two_sided=True) target_obj1[0].normals = pyredner.compute_vertex_normal(target_obj1[0].vertices, target_obj1[0].indices) shapes = [] shapes.append(target_obj1[0]) numShapes = len(shapes) shapes.extend(lights) area_lights = [] for i in range(numShapes, len(shapes)): area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity, light_intensity, light_intensity]))) area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity*10, light_intensity*10, light_intensity*10]))) scene = pyredner.Scene(cam, objects = [shapes[0], shapes[1]],area_lights = [area_lights[0]], envmap = None) scene_intense = pyredner.Scene(cam, objects = [shapes[0], shapes[1]], area_lights = [area_lights[1]], envmap = None) target = pyredner.render_pathtracing(scene = [scene], num_samples=(512, 0), max_bounces=1)[0] pyredner.imwrite(target.cpu(), 'results/shadow_art/high_res/' + step + '/' + str(obj) + '_0.png') area_lights = [] for i in range(numShapes, len(shapes)): area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity, light_intensity, light_intensity]))) area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity*10, light_intensity*10, light_intensity*10]))) shape0_vertices = shapes[0].vertices.clone() shapes[0].vertices = \ (shape0_vertices) scene_3 = pyredner.Scene(cam3, objects=[shapes[0], shapes[2]], area_lights = [area_lights[2]], envmap = None)
materials = [mat_grey] vertices, indices, uvs, normals = pyredner.generate_sphere(128, 64) shape_sphere = pyredner.Shape(\ vertices = vertices, indices = indices, uvs = uvs, normals = normals, material_id = 0) shapes = [shape_sphere] envmap = pyredner.imread('sunsky.exr') if pyredner.get_use_gpu(): envmap = envmap.cuda(device=pyredner.get_device()) envmap = pyredner.EnvironmentMap(envmap) scene = pyredner.Scene(cam, shapes, materials, [], envmap) scene_args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 256, max_bounces = 1) render = pyredner.RenderFunction.apply img = render(0, *scene_args) pyredner.imwrite(img.cpu(), 'results/test_envmap/target.exr') pyredner.imwrite(img.cpu(), 'results/test_envmap/target.png') target = pyredner.imread('results/test_envmap/target.exr') if pyredner.get_use_gpu(): target = target.cuda() envmap_texels = torch.tensor( 0.5 * torch.ones([32, 64, 3], device=pyredner.get_device()), requires_grad=True)
pyredner.AreaLight(shape_id=numShapes, intensity=torch.tensor([ lightIntensity * 10, lightIntensity * 10, lightIntensity * 10 ]))) # FOR SCENE DEBUGGING envmap = pyredner.imread('sunsky.exr') if pyredner.get_use_gpu(): envmap = envmap.cuda() envmap = pyredner.EnvironmentMap(envmap) envmap = None # ALL SCENES scene = pyredner.Scene(cam, [shapes[0], shapes[1], shapes[2]], materials, area_lights=[area_lights[0]], envmap=None) scene_intense = pyredner.Scene(cam, [shapes[0], shapes[1], shapes[2]], materials, area_lights=[area_lights[1]], envmap=None) render = pyredner.RenderFunction.apply # SET UP SCENES maker_translation_params0 = torch.tensor([0.0, 0.0, -3.0], device=pyredner.get_device()) shape0_vertices = shapes[0].vertices.clone() shape1_vertices = shapes[1].vertices.clone()
import pyredner import torch # Test the sample pixel center flag pyredner.set_use_gpu(torch.cuda.is_available()) objects = pyredner.load_obj('scenes/teapot.obj', return_objects=True) camera = pyredner.automatic_camera_placement(objects, resolution=(128, 128)) scene = pyredner.Scene(camera=camera, objects=objects) img = pyredner.render_albedo(scene, sample_pixel_center=True) pyredner.imwrite(img.cpu(), 'results/test_sample_pixel_center/img_no_aa.exr') img = pyredner.render_albedo(scene, sample_pixel_center=False) pyredner.imwrite(img.cpu(), 'results/test_sample_pixel_center/img_with_aa.exr')
tri_vertices = torch.cat( (tri_vertices_2d, torch.zeros(tri_vertices_2d.shape[0], 1, device=pyredner.get_device())), dim=1).contiguous() quad_indices = torch.tensor([[0, 1, 2], [1, 2, 3]], dtype=torch.int32, device=pyredner.get_device()) tri_indices = torch.tensor([[0, 1, 2]], dtype=torch.int32, device=pyredner.get_device()) shape_quad = pyredner.Shape(quad_vertices, quad_indices, None, None, 0) shape_tri = pyredner.Shape(tri_vertices, tri_indices, None, None, 1) shapes = [shape_quad, shape_tri] # Setup the scene. We don't need lights. scene = pyredner.Scene(cam, shapes, materials, []) # We output the shape id, so that we can shape it later args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 16, # Set max bounces to 0, we don't need lighting. max_bounces = 0, # Use the diffuse color as the output channels = [redner.channels.diffuse_reflectance]) # Render the scene as our target image. render = pyredner.RenderFunction.apply img = render(0, *args) pyredner.imwrite(img.cpu(), 'results/two_d_mesh/target.exr') pyredner.imwrite(img.cpu(), 'results/two_d_mesh/target.png') target = pyredner.imread('results/two_d_mesh/target.exr')
coeffs[:, 9:9 + 7] * math.pow(math.sin(math.pi * 3.0 / window) / (math.pi * 3.0 / window), 4.0) return deringed_coeffs deringed_coeffs = deringing(coeffs, 6.0) res = (128, 128) # We call the utility function SH_reconstruct to rasterize the coefficients into an envmap envmap = pyredner.SH_reconstruct(deringed_coeffs, res) # Save the target envmap pyredner.imwrite(envmap.cpu(), 'results/joint_material_envmap_sh/target_envmap.exr') # Convert the PyTorch tensor into pyredner compatible envmap envmap = pyredner.EnvironmentMap(envmap) # Setup the scene scene = pyredner.Scene(camera=cam, shapes=shapes, materials=materials, envmap=envmap) # Serialize the scene scene_args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 512, max_bounces = 1) # Render the target render = pyredner.RenderFunction.apply img = render(0, *scene_args) # Save the target image pyredner.imwrite(img.cpu(), 'results/joint_material_envmap_sh/target.exr') pyredner.imwrite(img.cpu(), 'results/joint_material_envmap_sh/target.png') # Read the target image back target = pyredner.imread('results/joint_material_envmap_sh/target.exr') if pyredner.get_use_gpu():
torch.zeros(tri_vertices_2d.shape[0], 1, device = pyredner.get_device())), dim=1).contiguous() quad_indices = torch.tensor([[0, 1, 2], [1, 2, 3]], dtype = torch.int32, device = pyredner.get_device()) tri_indices = torch.tensor([[0, 1, 2]], dtype = torch.int32, device = pyredner.get_device()) shape_quad = pyredner.Shape(\ vertices = quad_vertices, indices = quad_indices, material_id = 0) shape_tri = pyredner.Shape(\ vertices = tri_vertices, indices = tri_indices, material_id = 1) shapes = [shape_quad, shape_tri] # Setup the scene. We don't need lights. scene = pyredner.Scene(camera = cam, shapes = shapes, materials = materials) # We output the shape id, so that we can shape it later args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 16, # Set max bounces to 0, we don't need lighting. max_bounces = 0, # Use the diffuse color as the output channels = [redner.channels.diffuse_reflectance]) # Render the scene as our target image. render = pyredner.RenderFunction.apply img = render(0, *args) pyredner.imwrite(img.cpu(), 'results/two_d_mesh/target.exr') pyredner.imwrite(img.cpu(), 'results/two_d_mesh/target.png')
materials.append(value) # Setup geometries shapes = [] for mtl_name, mesh in mesh_list: shapes.append(pyredner.Shape(\ vertices = mesh.vertices, indices = mesh.indices, uvs = mesh.uvs, normals = mesh.normals, material_id = material_id_map[mtl_name])) # We don't setup any light source here # Construct the scene scene = pyredner.Scene(cam, shapes, materials, area_lights=[], envmap=None) # Serialize the scene # Here we specify the output channels as "depth", "shading_normal" scene_args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 16, max_bounces = 0, channels = [redner.channels.depth, redner.channels.shading_normal]) # Render the scene as our target image. render = pyredner.RenderFunction.apply # Render. The first argument is the seed for RNG in the renderer. img = render(0, *scene_args) # Save the images. depth = img[:, :, 0] normal = img[:, :, 1:4]
import torch import pyredner vertices, indices, uvs, normals = pyredner.generate_sphere(64, 128) m = pyredner.Material(diffuse_reflectance=torch.tensor( (0.5, 0.5, 0.5), device=pyredner.get_device())) obj = pyredner.Object(vertices=vertices, indices=indices, uvs=uvs, normals=normals, material=m) cam = pyredner.automatic_camera_placement([obj], resolution=(480, 640)) scene = pyredner.Scene(objects=[obj], camera=cam) img = pyredner.render_g_buffer( scene, channels=[pyredner.channels.uv, pyredner.channels.shading_normal]) uv_img = torch.cat([img[:, :, :2], torch.zeros(480, 640, 1)], dim=2) normal_img = img[:, :, 2:] pyredner.imwrite(uv_img, 'results/test_sphere/uv.png') pyredner.imwrite(normal_img, 'results/test_sphere/normal.png')
position=cam_pos, look_at=cam_look_at, # Center of the vertices up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([20.0]), resolution=resolution) for i in range(0): # num_views): print("correcting position {:0>2d}".format(i)) eul_optimizer = torch.optim.SGD([euler], lr=2) tra_optimizer = torch.optim.SGD([trans], lr=5000) for t in range(20): eul_optimizer.zero_grad() tra_optimizer.zero_grad() rotation_matrix = pyredner.gen_rotate_matrix(euler) obj.vertices = (vertices - center) @ torch.t(rotation_matrix) \ + center + trans * torch.tensor([1., 1., 3.], device=pyredner.get_device()) scene = pyredner.Scene(objects=[obj], camera=cam, envmap=envmap) img = pyredner.render_pathtracing(scene=scene, num_samples=(64, 4), use_secondary_edge_sampling=True) print('f') loss = (img - target[i]).pow(2).mean() loss.backward() eul_optimizer.step() tra_optimizer.step() if t % 2 == 1: print(' iteration', t, 'loss:{:.6f}'.format(loss), euler.data.cpu(), trans.data.cpu() * torch.tensor([1., 1., 3.])) euler_list.append(euler.data.clone()) trans_list.append(trans.data.clone())
def render(self, scene, svbrdf): imgs = [] svbrdf = svbrdf.unsqueeze(0) if len(svbrdf.shape) == 3 else svbrdf sensor_size = (svbrdf.shape[-1], svbrdf.shape[-2]) for svbrdf_single in torch.split(svbrdf, 1, dim=0): normals, diffuse, roughness, specular = utils.unpack_svbrdf( svbrdf_single.squeeze(0)) # Redner expects the normal map to be in range [0, 1] normals = utils.encode_as_unit_interval(normals) # Redner expects the roughness to have one channel only. # We also need to convert from GGX roughness to Blinn-Phong power. # See: https://github.com/iondune/csc473/blob/master/lectures/07-cook-torrance.md roughness = torch.mean(torch.clamp(roughness, min=0.001), dim=0, keepdim=True)**4 # Convert from [c,h,w] to [h,w,c] for redner normals = normals.permute(1, 2, 0) diffuse = diffuse.permute(1, 2, 0) roughness = roughness.permute(1, 2, 0) specular = specular.permute(1, 2, 0) material = pyredner.Material( diffuse_reflectance=pyredner.Texture( diffuse.to(self.redner_device)), specular_reflectance=pyredner.Texture( specular.to(self.redner_device)), roughness=pyredner.Texture(roughness.to(self.redner_device)), normal_map=pyredner.Texture(normals.to(self.redner_device))) material_patch = pyredner.Object(vertices=self.patch_vertices, uvs=self.patch_uvs, indices=self.patch_indices, material=material) # Define the camera parameters (focused at the middle of the patch) and make sure we always have a valid 'up' direction position = np.array(scene.camera.pos) lookat = np.array([0.0, 0.0, 0.0]) cz = lookat - position # Principal axis up = np.array([0.0, 0.0, 1.0]) if np.linalg.norm(np.cross(cz, up)) == 0.0: up = np.array([0.0, 1.0, 0.0]) camera = pyredner.Camera( position=torch.FloatTensor(position).to(self.redner_device), look_at=torch.FloatTensor(lookat).to(self.redner_device), up=torch.FloatTensor(up).to(self.redner_device), fov=torch.FloatTensor([90]), resolution=sensor_size, camera_type=self.camera_type) # # The deferred rendering path. # # It does not have a specular model and therefore is of limited usability for us # full_scene = pyredner.Scene(camera = camera, objects = [material_patch]) # light = pyredner.PointLight(position = torch.tensor(scene.light.pos).to(self.redner_device), # intensity = torch.tensor(scene.light.color).to(self.redner_device)) # img = pyredner.render_deferred(scene = full_scene, lights = [light]) light = pyredner.generate_quad_light( position=torch.Tensor(scene.light.pos).to(self.redner_device), look_at=torch.zeros(3).to(self.redner_device), size=torch.Tensor([0.6, 0.6]).to(self.redner_device), intensity=torch.Tensor(scene.light.color).to( self.redner_device)) full_scene = pyredner.Scene(camera=camera, objects=[material_patch, light]) img = pyredner.render_pathtracing(full_scene, num_samples=(16, 8)) # Transform the rendered image back to something torch can interprete imgs.append(img.permute(2, 0, 1).to(svbrdf.device)) return torch.stack(imgs)
[-1.0, 1.0, -7.0], [ 2.0, 1.0, -7.0]], device = pyredner.get_device()), indices = torch.tensor([[0, 1, 2],[1, 3, 2]], dtype = torch.int32, device = pyredner.get_device()), uvs = None, normals = None, material_id = 0) # The shape list of our scene contains two shapes: shapes = [shape_diamond, shape_light] light = pyredner.AreaLight(shape_id=1, intensity=torch.tensor([200.0, 200.0, 200.0])) area_lights = [light] # Finally we construct our scene using all the variables we setup previously. scene = pyredner.Scene(cam, shapes, materials, area_lights) #shapes = [] #for _, mesh in mesh_list: # assert(mesh.normal_indices is None) # shapes.append(pyredner.Shape(\ # vertices = mesh.vertices, # indices = mesh.indices, # uvs = None, # normals = mesh.normals, # material_id=0)) # The previous tutorial used a mesh area light for the scene lighting, # here we use an environment light, # which is a texture representing infinitely far away light sources in # spherical coordinates.
[0.5, 0.5, 0.5], device=pyredner.get_device())) #sphere = pyredner.Object(vertices = mesh2.vertices/3, indices = mesh2.indices, uvs = None, # normals = mesh2.normals, material = m) #cam = pyredner.automatic_camera_placement(shapes=[sphere], resolution=(background.shape[0], background.shape[1])) cam = pyredner.Camera( position=torch.tensor([0.0, -0.0, -5.0]), # -8.5 look_at=torch.tensor([0.0, 0.0, 0.0]), up=torch.tensor([0.0, 1.0, 0.0]), fov=torch.tensor([45.0]), # in degree clip_near=1e-2, # needs to > 0 resolution=(1650, 2843), fisheye=False) scene = pyredner.Scene(camera=cam, objects=objects) #[sphere]) lights = [ pyredner.PointLight( cam.position.to(pyredner.get_device()), torch.tensor([10.0, 10.0, 10.0], device=pyredner.get_device())) ] img = pyredner.render_albedo(scene) #img = pyredner.render_deferred(scene=scene, lights=lights, alpha=True) imshow(torch.pow(img, 1.0 / 2.2).cpu()) pyredner.imwrite( torch.pow(img, 1.0 / 2.2).cpu(), 'results/' + folder_name + '/init_load.png') #%% vertices = [] for obj in objects: