def init_renderer(mesh): obj_fp = mesh.filename pyr.set_print_timing(False) objects = pyr.load_obj(obj_fp, return_objects=True) #camera = pyr.automatic_camera_placement(objects, (256, 256)) camera = pyr.Camera(position=torch.tensor([1.2, 0, 0], dtype=torch.float32), look_at=torch.tensor([0, 0, 0], dtype=torch.float32), up=torch.tensor([0, 1, 0], dtype=torch.float32), fov=torch.tensor([60], dtype=torch.float32), resolution=(256, 256), camera_type=pyr.camera_type.perspective) lights = [ pyr.DirectionalLight(direction=torch.tensor([-1, 0, 0], dtype=torch.float32, device=pyr.get_device()), intensity=torch.tensor([1, 1, 1], dtype=torch.float32, device=pyr.get_device())), pyr.DirectionalLight(direction=torch.tensor([1, 0, 0], dtype=torch.float32, device=pyr.get_device()), intensity=torch.tensor([1, 1, 1], dtype=torch.float32, device=pyr.get_device())) ] return objects, camera, lights
def decimate(obj: pyr.Object, verbose=False): """ Decimates a mesh, reducing the number of faces by 2. This is EXTREMELY inefficient, and not differentiable - use it sparingly! Modifies the input mesh. """ # Let's make a temporary directory intermediate_dir = tempfile.mkdtemp() orig_out = os.path.join(intermediate_dir, "orig.obj") new_out = os.path.join(intermediate_dir, "decim.obj") if verbose: print("Made temp dir:") print(intermediate_dir) # First, let's save the redner pyr.save_obj(obj, orig_out) # Now, let's load in openmesh mesh = openmesh.read_trimesh(orig_out) # Now, decimate by half orig_nfaces = mesh.n_faces() if verbose: print("Original # of faces:", orig_nfaces) decimator = openmesh.TriMeshDecimater(mesh) algorithm = openmesh.TriMeshModQuadricHandle() decimator.add(algorithm) decimator.initialize() decimator.decimate_to_faces(n_faces=round(orig_nfaces / 2)) mesh.garbage_collection() if verbose: print("New # of faces:", mesh.n_faces()) openmesh.write_mesh(new_out, mesh) # Now, we have it. Load it back into redner decim_obj = pyr.load_obj(new_out, return_objects=True)[0] # And set the faces/indices obj.vertices = decim_obj.vertices obj.indices = decim_obj.indices # Recompute normals - the face normals have been broken recompute_normals(obj) # Finally, clean up the dir files_to_delete = os.listdir(intermediate_dir) for each_file in files_to_delete: apath = os.path.join(intermediate_dir, each_file) if verbose: print("Deleting", apath) os.remove(apath) if verbose: print("Deleting", intermediate_dir) os.rmdir(intermediate_dir)
def load_3d(mesh_name): ''' Loads a 3D model, computing vertex normals as needed ''' dpath = os.path.join(mydir, mesh_name) fpath = os.path.join(dpath, "mesh.obj") if os.path.isfile(fpath): obj = pyr.load_obj(fpath, return_objects=True)[0] recompute_normals(obj) texpath = os.path.join(dpath, "texture.png") if os.path.isfile(texpath): tex_img = pyr.imread(texpath) obj.material.diffuse_reflectance = pyr.Texture(tex_img) return obj else: raise FileNotFoundError(f"Could not find {mesh_name}.obj")
def load_obj(cls, path, learn_tex_label, device): mtl_map, mesh_list, _ = pyredner.load_obj(path) mtl_id_map = dict() materials = list() cnt = 0 for k, v in mtl_map.items(): mtl_id_map[k] = cnt cnt += 1 materials.append(v) assert (learn_tex_label in mtl_id_map) learn_tex_idx = mtl_id_map[learn_tex_label] shapes = list() 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=mtl_id_map[mtl_name])) return cls(materials, shapes, learn_tex_idx)
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 # 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) 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 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
z = math.sin(phi) * r points.append([x,y,z]) return points lights = [] num_cameras = 1 fov = 45.0 resolution = 1 look_at = torch.tensor([0.0, 0.0, 0.0]) camLocs = fibonacci_sphere(num_cameras, False) cams = [] target_objects = pyredner.load_obj('resources/monkey.obj', return_objects=True) camera0 = pyredner.automatic_camera_placement(target_objects, resolution) for ind, pos in enumerate(camLocs): pos = torch.tensor([0.5, 0.0, 100.0]) pos = torch.tensor(pos) normal = pos.div(torch.norm(pos)) pos = normal * radius2 lights.append(pyredner.generate_quad_light(position = pos + torch.tensor([0.0,0.0,-15.0]), \ look_at = camera0.look_at, \ size = torch.tensor([2.0, 2.0]), \ intensity = torch.tensor([light_intensity, light_intensity, light_intensity]))) print("LIGHT ONE DONE") for ind, pos in enumerate(camLocs): pos = torch.tensor([100, 0.0, -3.0]) normal = pos.div(torch.norm(pos - torch.tensor([-3.0, 0.0, -3.0]) )) pos = normal * radius2
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) folder_name = 'HDR_Cube_2' #% #material_map, mesh_list, light_map = pyredner.load_obj('ReferenceOutputMeshes/cylinderHighNVO.obj') #material_map1, mesh_list1, light_map1 = pyredner.load_obj('hemisphere.obj') material_map2, mesh_list2, light_map2 = pyredner.load_obj( 'ReferenceOutputMeshes/cubeNVO.obj') #material_map3, mesh_list3, light_map3 = pyredner.load_obj('cone.obj') #%% # The teapot we loaded is relatively low-poly and doesn't have vertex normal. # Fortunately we can compute the vertex normal from the neighbor vertices. # We can use pyredner.compute_vertex_normal for this task: # (Try commenting out the following two lines to see the differences in target images!) #for _, mesh in mesh_list: # mesh.normals = pyredner.compute_vertex_normal(mesh.vertices/2.5, mesh.indices) # print (_) # None #for _, mesh1 in mesh_list1: # mesh1.normals = pyredner.compute_vertex_normal(mesh1.vertices/1, mesh1.indices) # print (_)
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 # <editor-fold desc="LOADING DATA"> os.chdir('..') os.system("rm -rf " + output_path) pyredner.set_print_timing(False) obj = pyredner.load_obj("init/final.obj", return_objects=True)[0] indices = obj.indices.detach().clone() vertices = obj.vertices.detach().clone() v = vertices.clone() ideal_shift = pyredner.smooth(vertices, indices, 0., smooth_scheme, return_shift=True) ideal_quad_shift = pyredner.smooth(ideal_shift, indices, 0., smooth_scheme, return_shift=True) tex = obj.material.diffuse_reflectance.texels texels = pyredner.imresize(tex, (200, 200))
smooth_lmd = args.smooth_lmd output_path = args.output_path num_iters_1 = args.num_iters_1 print(vars(args)) #</editor-fold> os.chdir('..') #os.system("rm -rf " + output_path) pyredner.set_print_timing(False) #shape_mean, shape_basis, triangle_list, color_mean, color_basis = np.load("3dmm.npy", allow_pickle=True) #indices = triangle_list.permute(1, 0).contiguous() #vertices = shape_mean.view(-1, 3) obj = pyredner.load_obj("p_ones30/final.obj", return_objects=True)[0] indices = obj.indices.detach() vertices = obj.vertices.detach() tex = obj.material.diffuse_reflectance.texels texels = pyredner.imresize(tex, (200, 200)) print('texels size: ', texels.size()) texels.requires_grad = True m = pyredner.Material(diffuse_reflectance=texels) vertices.requires_grad = True target_data_path = "generated/dataset_ones30/" cam_poses, cam_look_at, lights_list = np.load(target_data_path + "env_data.npy",
def parse_shape(node, material_dict, shape_id, device, shape_group_dict=None): if node.attrib['type'] == 'obj' or node.attrib['type'] == 'serialized': to_world = torch.eye(4) serialized_shape_id = 0 mat_id = -1 light_intensity = None filename = '' max_smooth_angle = -1 for child in node: if 'name' in child.attrib: if child.attrib['name'] == 'filename': filename = child.attrib['value'] elif child.attrib['name'] == 'toWorld': to_world = parse_transform(child) elif child.attrib['name'] == 'shapeIndex': serialized_shape_id = int(child.attrib['value']) elif child.attrib['name'] == 'maxSmoothAngle': max_smooth_angle = float(child.attrib['value']) if child.tag == 'ref': mat_id = material_dict[child.attrib['id']] elif child.tag == 'emitter': for grandchild in child: if grandchild.attrib['name'] == 'radiance': light_intensity = parse_vector( grandchild.attrib['value']) if light_intensity.shape[0] == 1: light_intensity = torch.tensor(\ [light_intensity[0], light_intensity[0], light_intensity[0]]) if node.attrib['type'] == 'obj': # Load in CPU for rebuild_topology _, mesh_list, _ = pyredner.load_obj(filename, obj_group=False, device=torch.device('cpu')) vertices = mesh_list[0][1].vertices indices = mesh_list[0][1].indices uvs = mesh_list[0][1].uvs normals = mesh_list[0][1].normals uv_indices = mesh_list[0][1].uv_indices normal_indices = mesh_list[0][1].normal_indices else: assert (node.attrib['type'] == 'serialized') mitsuba_tri_mesh = redner.load_serialized(filename, serialized_shape_id) vertices = torch.from_numpy(mitsuba_tri_mesh.vertices) indices = torch.from_numpy(mitsuba_tri_mesh.indices) uvs = torch.from_numpy(mitsuba_tri_mesh.uvs) normals = torch.from_numpy(mitsuba_tri_mesh.normals) if uvs.shape[0] == 0: uvs = None if normals.shape[0] == 0: normals = None uv_indices = None # Serialized doesn't use different indices for UV & normal normal_indices = None # Transform the vertices and normals vertices = torch.cat((vertices, torch.ones(vertices.shape[0], 1)), dim=1) vertices = vertices @ torch.transpose(to_world, 0, 1) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3].contiguous() if normals is not None: normals = normals @ (torch.inverse(torch.transpose(to_world, 0, 1))[:3, :3]) normals = normals.contiguous() assert (vertices is not None) assert (indices is not None) if max_smooth_angle >= 0: if normals is None: normals = torch.zeros_like(vertices) new_num_vertices = redner.rebuild_topology(\ redner.float_ptr(vertices.data_ptr()), redner.int_ptr(indices.data_ptr()), redner.float_ptr(uvs.data_ptr() if uvs is not None else 0), redner.float_ptr(normals.data_ptr() if normals is not None else 0), redner.int_ptr(uv_indices.data_ptr() if uv_indices is not None else 0), int(vertices.shape[0]), int(indices.shape[0]), max_smooth_angle) print('Rebuilt topology, original vertices size: {}, new vertices size: {}'.format(\ int(vertices.shape[0]), new_num_vertices)) vertices.resize_(new_num_vertices, 3) if uvs is not None: uvs.resize_(new_num_vertices, 2) if normals is not None: normals.resize_(new_num_vertices, 3) lgt = None if light_intensity is not None: lgt = pyredner.AreaLight(shape_id, light_intensity) vertices = vertices.to(device) indices = indices.to(device) if uvs is not None: uvs = uvs.to(device) if normals is not None: normals = normals.to(device) if uv_indices is not None: uv_indices = uv_indices.to(device) if normal_indices is not None: normal_indices = normal_indices.to(device) return pyredner.Shape(vertices, indices, uvs=uvs, normals=normals, uv_indices=uv_indices, normal_indices=normal_indices, material_id=mat_id), lgt elif node.attrib['type'] == 'rectangle': indices = torch.tensor([[0, 2, 1], [1, 2, 3]], dtype=torch.int32) vertices = torch.tensor([[-1.0, -1.0, 0.0], [-1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [1.0, 1.0, 0.0]]) uvs = None normals = None to_world = torch.eye(4) mat_id = -1 light_intensity = None for child in node: if 'name' in child.attrib: if child.attrib['name'] == 'toWorld': to_world = parse_transform(child) if child.tag == 'ref': mat_id = material_dict[child.attrib['id']] elif child.tag == 'emitter': for grandchild in child: if grandchild.attrib['name'] == 'radiance': light_intensity = parse_vector( grandchild.attrib['value']) if light_intensity.shape[0] == 1: light_intensity = torch.tensor(\ [light_intensity[0], light_intensity[0], light_intensity[0]]) # Transform the vertices # Transform the vertices and normals vertices = torch.cat((vertices, torch.ones(vertices.shape[0], 1)), dim=1) vertices = vertices @ torch.transpose(to_world, 0, 1) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3].contiguous() if normals is not None: normals = normals @ (torch.inverse(torch.transpose(to_world, 0, 1))[:3, :3]) normals = normals.contiguous() assert (vertices is not None) assert (indices is not None) lgt = None if light_intensity is not None: lgt = pyredner.AreaLight(shape_id, light_intensity) vertices = vertices.to(device) indices = indices.to(device) if uvs is not None: uvs = uvs.to(device) if normals is not None: normals = normals.to(device) return pyredner.Shape(vertices, indices, uvs=uvs, normals=normals, material_id=mat_id), lgt # Add instance support # TODO (simply transform & create a new shape now) elif node.attrib['type'] == 'instance': shape = None for child in node: if 'name' in child.attrib: if child.attrib['name'] == 'toWorld': to_world = parse_transform(child) if child.tag == 'ref': shape = shape_group_dict[child.attrib['id']] # transform instance vertices = shape.vertices normals = shape.normals vector1 = torch.ones(vertices.shape[0], 1, device=vertices.device) to_world = to_world.to(vertices.device) vertices = torch.cat((vertices, vector1), dim=1) vertices = vertices @ torch.transpose(to_world, 0, 1) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3].contiguous() if normals is not None: normals = normals @ (torch.inverse(torch.transpose(to_world, 0, 1))[:3, :3]) normals = normals.contiguous() # assert(vertices is not None) # assert(indices is not None) # lgt = None # if light_intensity is not None: # lgt = pyredner.AreaLight(shape_id, light_intensity) return pyredner.Shape(vertices, shape.indices, uvs=shape.uvs, normals=normals, material_ids=shape.material_id), None else: print('Shape type {} is not supported!'.format(node.attrib['type'])) assert (False)
import pyredner import redner import torch import math # Use GPU if available pyredner.set_use_gpu(torch.cuda.is_available()) # Load from the teapot Wavefront object file material_map, mesh_list, light_map = pyredner.load_obj( '../tutorials/teapot.obj') # Compute shading normal for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices, mesh.indices) # Setup camera cam = pyredner.Camera( position=torch.tensor([0.0, 30.0, 200.0]), look_at=torch.tensor([0.0, 30.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=(256, 256), fisheye=False) # Get a list of shapes shapes = [] for mtl_name, mesh in mesh_list: shapes.append(pyredner.Shape(\ vertices = mesh.vertices, indices = mesh.indices,
def generate_poses(model_path, output_path): # Init logger log = dict() # Load renderer configs material_map, mesh_list, light_map = pyredner.load_obj(model_path) material_id_map = {} materials = [] count = 0 for key, value in material_map.items(): material_id_map[key] = count count += 1 materials.append(value) 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])) envmap = pyredner.EnvironmentMap( torch.tensor(imread('./datasets/envmaps/one/sunsky.exr'), dtype=torch.float32, device=pyredner.get_device())) # Object pose parameters euler_angles = [0.0, 0.0, 0.0] translation = [0.0, -0.75, 0.0] up = [0.0, 1.0, 0.0] distance = 7.0 # Setup base scene to modify during iterations cam_params = camera_parameters(euler_angles, translation, distance, up) camera = pyredner.Camera(position=torch.tensor(cam_params[0], dtype=torch.float32), look_at=torch.tensor(cam_params[1], dtype=torch.float32), up=torch.tensor(cam_params[2], dtype=torch.float32), fov=torch.tensor([45.0]), clip_near=1e-2, resolution=(opt.resolution, opt.resolution), fisheye=False) scene = pyredner.Scene(camera, shapes, materials, area_lights=[], envmap=envmap) # Generate alphamasks for i in range(opt.num_elev): # Set elevation angle elev_pc = i / opt.num_elev elevation = opt.max_elev * elev_pc + opt.min_elev * (1 - elev_pc) euler_angles[1] = elevation # Calculate number of azimuthal iterations num_azimuth = int(opt.num_elev * math.sin(math.pi / 2 - elevation)) for j in range(num_azimuth): # Set azimuthal angle azimuth_pc = j / num_azimuth azimuth = math.pi * 2 * azimuth_pc euler_angles[0] = azimuth print('Params: Elevation - {:.4f}\tAzimuth - {:.4f}'\ .format(elevation, azimuth)) # Set Camera params cam_params = camera_parameters(euler_angles, translation, distance, up) # Update scene params scene.camera = pyredner.Camera( position=torch.tensor(cam_params[0], dtype=torch.float32), look_at=torch.tensor(cam_params[1], dtype=torch.float32), up=torch.tensor(cam_params[2], dtype=torch.float32), fov=torch.tensor([45.0]), clip_near=1e-2, resolution=(opt.resolution, opt.resolution), fisheye=False) args = pyredner.RenderFunction.serialize_scene( scene=scene, num_samples=1, max_bounces=1, channels=[redner.channels.alpha]) out = pyredner.RenderFunction.apply(1, *args) fn = gen_hash(6) imwrite(out, os.path.join(output_path, '{}.png'.format(fn))) log[fn] = {'elevation': elevation, 'azimuth': azimuth} return log
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')
normal_scheme = args.normal_scheme smooth_scheme = args.smooth_scheme smooth_lmd = args.smooth_lmd output_path = args.output_path num_iters_1 = args.num_iters_1 print(vars(args)) os.chdir('..') os.system("rm -rf " + output_path) pyredner.set_print_timing(False) shape_mean, shape_basis, triangle_list, color_mean, color_basis = np.load("3dmm.npy", allow_pickle=True) #indices = triangle_list.permute(1, 0).contiguous() #vertices = shape_mean.view(-1, 3) obj = pyredner.load_obj("new_init.obj", return_objects=True)[0] indices = obj.indices.detach() vertices = obj.vertices.detach() if 0: vertices, indices, uvs, normals = pyredner.generate_sphere(theta_steps=256, phi_steps=512) vertices = vertices * 120 vertices.requires_grad = True target_data_path = "generated/dataset2/" cam_poses, cam_look_at, dir_light_intensity, dir_light_directions = np.load(target_data_path + "env_data.npy", allow_pickle=True) #cam_poses = cam_poses[:1] def model(cam_pos, cam_look_at, vertices, ambient_color, dir_light_intensity, dir_light_direction, normals): # normals = pyredner.compute_vertex_normal(vertices, indices, normal_scheme)
def __init__(self, framework, filename, dims, label_names, normalize_params, background, pose, num_classes, attack_type="benign"): self.NUM_CLASSES = num_classes self.framework = framework.to(pyredner.get_device()) self.image_dims = dims self.label_names = label_names self.framework_params = normalize_params # self.objects = pyredner.load_obj(filename, return_objects=True) self.material_map, mesh_list, self.light_map = pyredner.load_obj( filename) for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal( mesh.vertices, mesh.indices) vertices = [] self.modifiers = [] self.input_adv_list = [] self.input_orig_list = [] self.targeted = False self.clamp_fn = "tanh" self.attack_type = attack_type if attack_type == "CW": for _, mesh in mesh_list: vertices.append(mesh.vertices) modifier = torch.zeros(mesh.vertices.size(), requires_grad=True, device=pyredner.get_device()) self.modifiers.append(modifier) self.input_orig_list.append( tanh_rescale(torch_arctanh(mesh.vertices))) mesh.vertices = tanh_rescale( torch_arctanh(mesh.vertices) + modifier) self.input_adv_list.append(mesh.vertices) mesh.vertices.retain_grad() else: for _, mesh in mesh_list: vertices.append(mesh.vertices) mesh.vertices = Variable(mesh.vertices, requires_grad=True) mesh.vertices.retain_grad() material_id_map = {} self.materials = [] count = 0 for key, value in self.material_map.items(): material_id_map[key] = count count += 1 self.materials.append(value) self.shapes = [] self.cw_shapes = [] for mtl_name, mesh in mesh_list: # assert(mesh.normal_indices is None) self.shapes.append( pyredner.Shape(vertices=mesh.vertices, indices=mesh.indices, material_id=material_id_map[mtl_name], uvs=mesh.uvs, normals=mesh.normals, uv_indices=mesh.uv_indices)) self.camera = pyredner.automatic_camera_placement(self.shapes, resolution=(512, 512)) # Compute the center of the teapot self.center = torch.mean(torch.cat(vertices), 0) self.translation = torch.tensor([0., 0., 0.], device=pyredner.get_device(), requires_grad=True) self.angle_input_adv_list = [] self.angle_input_orig_list = [] self.pose = pose if attack_type == "CW": self.euler_angles_modifier = torch.tensor( [0., 0., 0.], device=pyredner.get_device(), requires_grad=True) if pose == 'forward': self.euler_angles = tanh_rescale( torch_arctanh( torch.tensor([0., 0., 0.], device=pyredner.get_device())) + self.euler_angles_modifier) self.angle_input_orig_list.append( tanh_rescale( torch_arctanh( torch.tensor([0., 0., 0.], device=pyredner.get_device())))) elif pose == 'top': self.euler_angles = tanh_rescale( torch_arctanh( torch.tensor([0.35, 0., 0.], device=pyredner.get_device())) + self.euler_angles_modifier) self.angle_input_orig_list.append( tanh_rescale( torch_arctanh( torch.tensor([0., 0., 0.], device=pyredner.get_device())))) elif pose == 'left': self.euler_angles = tanh_rescale( torch_arctanh( torch.tensor([0., 0.50, 0.], device=pyredner.get_device())) + self.euler_angles_modifier) self.angle_input_orig_list.append( tanh_rescale( torch_arctanh( torch.tensor([0., 0., 0.], device=pyredner.get_device())))) elif pose == 'right': self.euler_angles = tanh_rescale( torch_arctanh( torch.tensor([0., -0.50, 0.], device=pyredner.get_device())) + self.euler_angles_modifier) self.angle_input_orig_list.append( tanh_rescale( torch_arctanh( torch.tensor([0., 0., 0.], device=pyredner.get_device())))) self.angle_input_adv_list.append(self.euler_angles) else: if pose == 'forward': self.euler_angles = torch.tensor([0., 0., 0.], device=pyredner.get_device(), requires_grad=True) elif pose == 'top': self.euler_angles = torch.tensor([0.35, 0., 0.], device=pyredner.get_device(), requires_grad=True) elif pose == 'left': self.euler_angles = torch.tensor([0., 0.50, 0.], device=pyredner.get_device(), requires_grad=True) elif pose == 'right': self.euler_angles = torch.tensor([0., -0.50, 0.], device=pyredner.get_device(), requires_grad=True) self.light_init_vals = torch.tensor([20000.0, 30000.0, 20000.0], device=pyredner.get_device()) if attack_type == "CW": self.light_input_orig_list = [] self.light_input_adv_list = [] delta = 1e-6 # constant for stability self.light_modifier = torch.tensor([0., 0., 0.], device=pyredner.get_device(), requires_grad=True) # redner can't accept negative light intensities, so we have to be a bit creative and work with lighting norms instead and then rescale them afterwards... tanh_factor = tanh_rescale( torch_arctanh(self.light_init_vals / torch.norm(self.light_init_vals)) + self.light_modifier / torch.norm(self.light_modifier + delta)) self.light_intensity = torch.norm( self.light_init_vals) * torch.clamp(tanh_factor, 0, 1) self.light_input_orig_list.append(self.light_init_vals / torch.norm(self.light_init_vals)) self.light_input_adv_list.append(self.light_intensity) self.light = pyredner.PointLight( position=(self.camera.position + torch.tensor( (0.0, 0.0, 100.0))).to(pyredner.get_device()), intensity=self.light_intensity) else: self.light = pyredner.PointLight( position=(self.camera.position + torch.tensor( (0.0, 0.0, 100.0))).to(pyredner.get_device()), intensity=Variable(torch.tensor((20000.0, 30000.0, 20000.0), device=pyredner.get_device()), requires_grad=True)) background = pyredner.imread(background) self.background = background.to(pyredner.get_device())
torch.sub(torch.add(pos, tangent), bitangent) ] for i in range(4): lightPos[i] = lightPos[i] + torch.tensor([10.0, 0.0, -3.0]) lightPos = torch.cat(lightPos, 0) print(lightPos) lights.append(pyredner.Shape(\ vertices = torch.tensor(lightPos, 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)) material_map, mesh_list, light_map = pyredner.load_obj( 'resources/shadow_cube.obj') material_map2, mesh_list2, light_map2 = pyredner.load_obj( 'resources/monkey.obj') #<-- target material_map1, mesh_list1, light_map1 = pyredner.load_obj( 'resources/sphere_subdiv.obj') for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices, mesh.indices) # Setup camera cam = pyredner.Camera( position=torch.tensor([0.0, 0.0, -2.5]), look_at=torch.tensor([0.0, 0.0, 0.0]), up=torch.tensor([0.0, 1.0, 0.0]), camera_type=redner.CameraType.orthographic,
out_channels=channels, groups=channels, kernel_size=kernel_size, bias=False, stride=2, padding=[int((kernel_size - 1) / 2), int((kernel_size - 1) / 2)]) # with torch.no_grad(): gaussian_filter.weight.data = gaussian_kernel gaussian_filter.weight.requires_grad = True return gaussian_filter gaussian_func = getGaussianFilter() target_objects = pyredner.load_obj('resources/bunny-uv.obj', return_objects=True) print(target_objects[0].vertices.shape) diffuse = pyredner.imread('resources/wood_diffuse.jpg') specular = pyredner.imread('resources/wood_specular.jpg') / 100.0 #normal_map = pyredner.imread('resources/GroundForest003_NRM_3K.jpg', gamma=1.0) roughness = (1.0 - specular) / 10.0 normal_map = None target_objects[0].material = pyredner.Material(diffuse_reflectance=diffuse, specular_reflectance=specular, roughness=roughness, normal_map=normal_map) resolution = (256, 256) num_cameras = 32 radius = 1.0
return new_v + vertices * (1 - lmd) def dot(v1, v2): return torch.sum(v1 * v2, dim=1) def squared_length(v): return torch.sum(v * v, dim=1) def length(v): return torch.sqrt(squared_length(v)) def safe_asin(v): # Hack: asin(1)' is infinite, so we want to clamp the contribution return torch.asin(v.clamp(0, 1 - 1e-6)) objs = pyredner.load_obj('smoothed.obj', return_objects=True) obj = objs[0] vertices = obj.vertices indices = obj.indices normals = torch.zeros(vertices.shape, dtype=torch.float32, device=vertices.device) v = [vertices[indices[:, 0].long(), :], # all the 0th vertices of triangles vertices[indices[:, 1].long(), :], # all the 1st vertices of triangles vertices[indices[:, 2].long(), :]] for i in range(3): # 0th, 1st and 2nd v0 = v[i] v1 = v[(i + 1) % 3] v2 = v[(i + 2) % 3] e1 = v1 - v0 e2 = v2 - v0 e1_len = length(e1) # lengths of the first edges
def parse_shape(node, material_dict, shape_id, shape_group_dict=None): if node.attrib['type'] == 'obj' or node.attrib['type'] == 'serialized': to_world = torch.eye(4) serialized_shape_id = 0 mat_id = -1 light_intensity = None filename = '' for child in node: if 'name' in child.attrib: if child.attrib['name'] == 'filename': filename = child.attrib['value'] elif child.attrib['name'] == 'toWorld': to_world = parse_transform(child) elif child.attrib['name'] == 'shapeIndex': serialized_shape_id = int(child.attrib['value']) if child.tag == 'ref': mat_id = material_dict[child.attrib['id']] elif child.tag == 'emitter': for grandchild in child: if grandchild.attrib['name'] == 'radiance': light_intensity = parse_vector( grandchild.attrib['value']) if light_intensity.shape[0] == 1: light_intensity = torch.tensor(\ [light_intensity[0], light_intensity[0], light_intensity[0]]) if node.attrib['type'] == 'obj': _, mesh_list, _ = pyredner.load_obj(filename) vertices = mesh_list[0][1].vertices.cpu() indices = mesh_list[0][1].indices.cpu() uvs = mesh_list[0][1].uvs normals = mesh_list[0][1].normals if uvs is not None: uvs = uvs.cpu() if normals is not None: normals = normals.cpu() else: assert (node.attrib['type'] == 'serialized') mitsuba_tri_mesh = redner.load_serialized(filename, serialized_shape_id) vertices = torch.from_numpy(mitsuba_tri_mesh.vertices) indices = torch.from_numpy(mitsuba_tri_mesh.indices) uvs = torch.from_numpy(mitsuba_tri_mesh.uvs) normals = torch.from_numpy(mitsuba_tri_mesh.normals) if uvs.shape[0] == 0: uvs = None if normals.shape[0] == 0: normals = None # Transform the vertices and normals vertices = torch.cat((vertices, torch.ones(vertices.shape[0], 1)), dim=1) vertices = vertices @ torch.transpose(to_world, 0, 1) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3].contiguous() if normals is not None: normals = normals @ (torch.inverse(torch.transpose(to_world, 0, 1))[:3, :3]) normals = normals.contiguous() assert (vertices is not None) assert (indices is not None) lgt = None if light_intensity is not None: lgt = pyredner.AreaLight(shape_id, light_intensity) if pyredner.get_use_gpu(): # Copy to GPU vertices = vertices.cuda() indices = indices.cuda() if uvs is not None: uvs = uvs.cuda() if normals is not None: normals = normals.cuda() return pyredner.Shape(vertices, indices, uvs, normals, mat_id), lgt elif node.attrib['type'] == 'rectangle': indices = torch.tensor([[0, 2, 1], [1, 2, 3]], dtype=torch.int32) vertices = torch.tensor([[-1.0, -1.0, 0.0], [-1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [1.0, 1.0, 0.0]]) uvs = None normals = None to_world = torch.eye(4) mat_id = -1 light_intensity = None for child in node: if 'name' in child.attrib: if child.attrib['name'] == 'toWorld': to_world = parse_transform(child) if child.tag == 'ref': mat_id = material_dict[child.attrib['id']] elif child.tag == 'emitter': for grandchild in child: if grandchild.attrib['name'] == 'radiance': light_intensity = parse_vector( grandchild.attrib['value']) if light_intensity.shape[0] == 1: light_intensity = torch.tensor(\ [light_intensity[0], light_intensity[0], light_intensity[0]]) # Transform the vertices # Transform the vertices and normals vertices = torch.cat((vertices, torch.ones(vertices.shape[0], 1)), dim=1) vertices = vertices @ torch.transpose(to_world, 0, 1) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3].contiguous() if normals is not None: normals = normals @ (torch.inverse(torch.transpose(to_world, 0, 1))[:3, :3]) normals = normals.contiguous() assert (vertices is not None) assert (indices is not None) lgt = None if light_intensity is not None: lgt = pyredner.AreaLight(shape_id, light_intensity) if pyredner.get_use_gpu(): # Copy to GPU vertices = vertices.cuda() indices = indices.cuda() if uvs is not None: uvs = uvs.cuda() if normals is not None: normals = normals.cuda() return pyredner.Shape(vertices, indices, uvs, normals, mat_id), lgt # Add instance support # TODO (simply transform & create a new shape now) elif node.attrib['type'] == 'instance': shape = None for child in node: if 'name' in child.attrib: if child.attrib['name'] == 'toWorld': to_world = parse_transform(child) if pyredner.get_use_gpu(): to_world = to_world.cuda() if child.tag == 'ref': shape = shape_group_dict[child.attrib['id']] # transform instance vertices = shape.vertices normals = shape.normals vector1 = torch.ones(vertices.shape[0], 1) vertices = torch.cat( (vertices, vector1.cuda() if pyredner.get_use_gpu() else vector1), dim=1) vertices = vertices @ torch.transpose(to_world, 0, 1) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3].contiguous() if normals is not None: normals = normals @ (torch.inverse(torch.transpose(to_world, 0, 1))[:3, :3]) normals = normals.contiguous() # assert(vertices is not None) # assert(indices is not None) # lgt = None # if light_intensity is not None: # lgt = pyredner.AreaLight(shape_id, light_intensity) return pyredner.Shape(vertices, shape.indices, shape.uvs, normals, shape.material_id), None else: print('Shape type {} is not supported!'.format(node.attrib['type'])) assert (False)
# I think this is known and not optimized cam = pyredner.Camera( position=torch.tensor([0.0, 0.0, -5.0]), 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=(256, 256), fisheye=False) folder_name = 'Uranus_lr4_Color' #%% material_map, mesh_list, light_map = pyredner.load_obj('sphere.obj') # The teapot we loaded is relatively low-poly and doesn't have vertex normal. # Fortunately we can compute the vertex normal from the neighbor vertices. # We can use pyredner.compute_vertex_normal for this task: # (Try commenting out the following two lines to see the differences in target images!) for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices / 10, mesh.indices) print(_) # None diffuse_reflectance = torch.tensor([1.0, 1.0, 0.0], device=pyredner.get_device()) mat_grey = pyredner.Material(diffuse_reflectance) # The material list of the scene #
# I think this is known and not optimized cam = pyredner.Camera(position = torch.tensor([0.0, 0.0, -5.0]), 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 = (256, 256), fisheye = False) folder_name= 'Cube_1' material_map, mesh_list, light_map = pyredner.load_obj('ReferenceOutputMeshes/cylinderHighNVO.obj') # The teapot we loaded is relatively low-poly and doesn't have vertex normal. # Fortunately we can compute the vertex normal from the neighbor vertices. # We can use pyredner.compute_vertex_normal for this task: # (Try commenting out the following two lines to see the differences in target images!) for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices, mesh.indices) print (_) # None diffuse_reflectance =torch.tensor([0.0, 0.4, 0.6], device = pyredner.get_device()) mat_grey = pyredner.Material(diffuse_reflectance) # The material list of the scene # materials = [mat_grey]
os.system("rm -rf " + output_path) pyredner.set_print_timing(False) ''' tgt_vertices = torch.tensor([[-5, -1, -3], [0, -5, 2], [0, 4, 3], [4, 0, -4]], dtype=torch.float32, device=pyredner.get_device(), requires_grad=False) vertices = torch.tensor([[-2.4, -2.6, 0.2], [3.1, -1.8, 0], [0, 2.8, 1.1], [4.1, 6.8, 2.1]], dtype=torch.float32, device=pyredner.get_device(), requires_grad=True) indices = torch.tensor([[0, 1, 2], [2, 1, 3]], dtype=torch.int32, device=pyredner.get_device()) ''' obj = pyredner.load_obj('cube.obj', return_objects=True)[0] vertices = obj.vertices * 8. - 4. vertices.requires_grad = True indices = obj.indices tgt_vertices = vertices.detach() * 1.1 + 0.5 * torch.randn(vertices.shape, device=pyredner.get_device()) print(tgt_vertices) cam_poses = torch.tensor([[0, 0, 20], [-12, 0, 16], [12, 0, 16]], dtype=torch.float32, device=pyredner.get_device(), requires_grad=False) cam_look_at = torch.tensor([0, 0, 0], dtype=torch.float32, device=pyredner.get_device(), requires_grad=False) dir_light_direction = torch.tensor([-0.0, -0.0, -1.0], device=pyredner.get_device(), requires_grad=False) dir_light_intensity = torch.ones(3, device=pyredner.get_device(), requires_grad=False) normals = pyredner.compute_vertex_normal(tgt_vertices, indices, normal_scheme) print("finish loading") def model(cam_pos, cam_look_at, vertices, ambient_color, dir_light_intensity, dir_light_direction, normals): #normals = pyredner.compute_vertex_normal(vertices, indices, normal_scheme) m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5]))
gaussian_filter = torch.nn.Conv2d(in_channels=channels, out_channels=channels, groups=channels, kernel_size=kernel_size, bias=False, stride=2, padding=[int((kernel_size - 1)/2), int((kernel_size - 1)/2)]) # with torch.no_grad(): gaussian_filter.weight.data = gaussian_kernel gaussian_filter.weight.requires_grad = True return gaussian_filter gaussian_func = getGaussianFilter() # Parse cmdline path = sys.argv[1] path = path + "/" target_obj_file = sys.argv[2] init_obj_file = sys.argv[3] face_target = int(sys.argv[4]) # Load Target model target_objects = pyredner.load_obj(target_obj_file, return_objects=True) print(target_objects) normal_map = None diffuse = torch.tensor([0.7, 0.0, 0.0]) specular_target = torch.tensor([0.0, 0.0, 0.0]) roughness = torch.tensor([0.6]) diffuse = torch.tensor([0.0, 0.0, 1.0]) target_objects[0].material = pyredner.Material(diffuse_reflectance=diffuse, specular_reflectance=specular_target, roughness=roughness, normal_map=normal_map, two_sided=True) diffuse = torch.tensor([1.0, 0.0, 0.0]) target_objects[1].material = pyredner.Material(diffuse_reflectance=diffuse, specular_reflectance=specular_target, roughness=roughness, normal_map=normal_map, two_sided=True) diffuse = torch.tensor([0.7,0.7,0.7]) target_objects[2].material = pyredner.Material(diffuse_reflectance=diffuse, specular_reflectance=specular_target, roughness=roughness, normal_map=normal_map, two_sided=True)
import pyredner import redner import numpy as np import torch import skimage.transform # Optimize depth and normal of a teapot # Use GPU if available pyredner.set_use_gpu(torch.cuda.is_available()) # Set up the pyredner scene for rendering: material_map, mesh_list, light_map = pyredner.load_obj('scenes/teapot.obj') for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices, mesh.indices) # Setup camera cam = pyredner.Camera( position=torch.tensor([0.0, 30.0, 200.0]), look_at=torch.tensor([0.0, 30.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=(256, 256), fisheye=False) # Setup materials material_id_map = {} materials = [] count = 0 for key, value in material_map.items():
# For loop progress bar. from tqdm import tqdm #from chamferdist.chamferdist import ChamferDistance # GROUND TRUTH. meshfile1 = sys.argv[1] # RECONSTRUCTED. meshfile2 = sys.argv[2] #torch.cuda.init() ########################## LOAD TARGET ######################### print("Loading target: " + meshfile1) _, mesh_list1, _ = pyredner.load_obj(meshfile1) print("Loading target: " + meshfile2) _, mesh_list2, _ = pyredner.load_obj(meshfile2) _, mesh1 = mesh_list1[0] _, mesh2 = mesh_list2[0] print("Putting vertices on GPU...") verts1 = mesh1.vertices.cuda().contiguous() verts2 = mesh2.vertices.cuda().contiguous() print("Done") print("Computing chamfer distance from ground truth -> reconstructed") v12_mins = torch.zeros(verts1.shape[0]) for i in tqdm(range(verts1.shape[0])):
int((kernel_size - 1) / 2)]) # with torch.no_grad(): gaussian_filter.weight.data = gaussian_kernel gaussian_filter.weight.requires_grad = True return gaussian_filter # Load everything in from command line. output_path = sys.argv[1] target_path = sys.argv[2] diffuse_texels_path = sys.argv[3] specular_texels_path = sys.argv[4] gaussian_func = getGaussianFilter() target_objects = pyredner.load_obj(target_path, return_objects=True) print(target_objects[0].vertices.shape) # Load in the mesh colors info. mesh_colors_resolution = 1 diffuse_texels = torch.tensor(torch.load(diffuse_texels_path), device=pyredner.get_device()) specular_texels = torch.tensor(torch.load(specular_texels_path), device=pyredner.get_device()) target_diffuse = pyredner.Texture( diffuse_texels, mesh_colors_resolution=mesh_colors_resolution) target_specular = pyredner.Texture( specular_texels, mesh_colors_resolution=mesh_colors_resolution) target_roughness = torch.tensor([0.6]) # For now, roughness is fixed. target_objects[0].material = pyredner.Material( diffuse_reflectance=target_diffuse,
# Use GPU if available pyredner.set_use_gpu(torch.cuda.is_available()) # Load from the teapot Wavefront object file. # load_obj function returns three lists/dicts # material_map is a dict containing all the materials used in the obj file, # where the key is the name of material, and the value is a pyredner.Material # # mesh_list is a list containing all the meshes in the obj file, grouped by use_mtl calls. # Each element in the list is a tuple with length 2, the first is the name of material, # the second is a pyredner.TriangleMesh with mesh information. # # light_map is a Python dict, where the key is the material names with non zeros Ke, # and the values are the Ke material_map, mesh_list, light_map = pyredner.load_obj('teapot.obj') # The teapot we loaded is relatively low-poly and doesn't have vertex normal. # Fortunately we can compute the vertex normal from the neighbor vertices. # We can use pyredner.compute_vertex_normal for this task: # (Try commenting out the following two lines to see the differences in target images!) for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices, mesh.indices) # Setup camera cam = pyredner.Camera(position = torch.tensor([0.0, 30.0, 200.0]), look_at = torch.tensor([0.0, 30.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 = (256, 256), fisheye = False)
#First, we setup a camera, by constructing a pyredner.Camera object # I think this is known and not optimized cam = pyredner.Camera( position=torch.tensor([0.0, 0.0, -5.0]), 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=(256, 256), fisheye=False) #%% material_map, mesh_list, light_map = pyredner.load_obj('diamond.obj') # The teapot we loaded is relatively low-poly and doesn't have vertex normal. # Fortunately we can compute the vertex normal from the neighbor vertices. # We can use pyredner.compute_vertex_normal for this task: # (Try commenting out the following two lines to see the differences in target images!) for _, mesh in mesh_list: mesh.normals = pyredner.compute_vertex_normal(mesh.vertices / 20, mesh.indices) print(_) # None diffuse_reflectance = torch.tensor([0.0, 1.0, 0.0], device=pyredner.get_device(), requires_grad=True) mat_grey = pyredner.Material(diffuse_reflectance)
#background = pyredner.imread('mandrill.tiff') background = pyredner.imread('Target_Images_Cropped/background_cropped.exr') # Visualize background from matplotlib.pyplot import imshow # %matplotlib inline # Redner's imread automatically gamma decompress the image to linear space. # You'll have to compress it back to sRGB space for display. pyredner.imwrite( torch.pow(background.data, 1.0 / 2.2).cpu(), 'results/' + folder_name + '/background.png') # saves an exr image as png #imshow(torch.pow(background, 1.0/2.2)) # Convert background to current device background = background.to(pyredner.get_device()) objects = pyredner.load_obj('ReferenceOutputMeshes/cubeNVO.obj', return_objects=True) #camera = pyredner.automatic_camera_placement(objects, resolution=(512, 512)) #"""Next, we define a `model` function that takes the objects, camera, and pose parameters, and output an image.""" # Obtain the teapot vertices we want to apply the transformation on. #material_map2, mesh_list2, light_map2 = pyredner.load_obj('ReferenceOutputMeshes/cubeNVO.obj') #for _, mesh2 in mesh_list2: # mesh2.normals = pyredner.compute_vertex_normal(mesh2.vertices/3, mesh2.indices) #%% #diffuse_reflectance_green =torch.tensor([0.65, 0.32, 0.16], device = pyredner.get_device()) #mat_green = pyredner.Material(diffuse_reflectance_green) #materials = [mat_green] #shape_cube = pyredner.Shape(vertices = mesh2.vertices/3,