def add_ground(self, device): self.materials.append( pyredner.Material( diffuse_reflectance=torch.tensor([0.8, 0.8, 0.8], dtype=torch.float32, device=device), specular_reflectance=torch.tensor([0.1, 0.1, 0.1], dtype=torch.float32, device=device), roughness=torch.tensor([0.5], dtype=torch.float32, device=device))) self.shapes.append( pyredner.Shape( vertices=torch.tensor([[-100, 0, -100], [-100, 0, 100], [100, 0, -100], [100, 0, 100]], dtype=torch.float32, device=device), indices=torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int32, device=device), normals=torch.tensor([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=torch.float32, device=device), uvs=torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32, device=device), material_id=len(self.materials) - 1, )) self.ground_idx = (len(self.materials) - 1, len(self.shapes) - 1)
def __init__(self, camera: pyredner.Camera, shapes: List[pyredner.Shape] = [], shape_id=dict(), materials: List[pyredner.Material] = [], area_lights: List[pyredner.AreaLight] = [], objects: Optional[List[pyredner.Object]] = None, envmap: Optional[pyredner.EnvironmentMap] = None): self.camera = camera self.envmap = envmap self.shape_id = shape_id if objects is None: self.shapes = shapes self.materials = materials self.area_lights = area_lights else: # Convert objects to shapes/materials/lights shapes = [] materials = [] area_lights = [] material_dict = {} current_material_id = 0 for obj in objects: mid = -1 if obj.material in material_dict: mid = material_dict[obj.material] else: mid = current_material_id material_dict[obj.material] = current_material_id materials.append(obj.material) current_material_id += 1 if obj.light_intensity is not None: current_shape_id = len(shapes) area_light = pyredner.AreaLight( shape_id=current_shape_id, intensity=obj.light_intensity, two_sided=obj.light_two_sided) area_lights.append(area_light) shape = pyredner.Shape(vertices=obj.vertices, indices=obj.indices, material_id=mid, uvs=obj.uvs, normals=obj.normals, uv_indices=obj.uv_indices, normal_indices=obj.normal_indices, colors=obj.colors) shapes.append(shape) self.shapes = shapes #self.shape_id = shape_id self.materials = materials self.area_lights = area_lights
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)
mat_red = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.75, 0.35, 0.35], device = pyredner.get_device())) mat_black = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.0, 0.0, 0.0], device = pyredner.get_device())) materials = [mat_green,mat_red,mat_black] tri0_vertices = torch.tensor(\ [[-1.7,1.0,0.0], [1.0,1.0,0.0], [-0.5,-1.0,0.0]], device = pyredner.get_device()) tri1_vertices = torch.tensor(\ [[-1.0,1.5,1.0], [0.2,1.5,1.0], [0.2,-1.5,1.0]], device = pyredner.get_device()) tri0_indices = torch.tensor([[0, 1, 2]], dtype = torch.int32, device = pyredner.get_device()) tri1_indices = torch.tensor([[0, 1, 2]], dtype = torch.int32, device = pyredner.get_device()) shape_tri0 = pyredner.Shape(tri0_vertices, tri0_indices, None, None, 0) shape_tri1 = pyredner.Shape(tri1_vertices, tri1_indices, None, None, 1) light_vertices = torch.tensor(\ [[-1.0,-1.0,-7.0],[1.0,-1.0,-7.0],[-1.0,1.0,-7.0],[1.0,1.0,-7.0]], device = pyredner.get_device()) light_indices = torch.tensor([[0,1,2],[1,3,2]], dtype = torch.int32, device = pyredner.get_device()) shape_light = pyredner.Shape(light_vertices, light_indices, None, None, 2) shapes = [shape_tri0, shape_tri1, shape_light] light_intensity = torch.tensor([20.0,20.0,20.0]) # The first argument is the shape id of the light light = pyredner.AreaLight(2, light_intensity) area_lights = [light] scene = pyredner.Scene(cam, shapes, materials, area_lights) args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 256,
fisheye=False) mat_grey = pyredner.Material(\ diffuse_reflectance = \ torch.tensor([0.4, 0.4, 0.4], device = pyredner.get_device()), specular_reflectance = \ torch.tensor([0.5, 0.5, 0.5], device = pyredner.get_device()), roughness = \ torch.tensor([0.05], device = pyredner.get_device())) 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)
cam = pyredner.Camera(position = position, look_at = look_at, up = up, fov = fov, clip_near = clip_near, resolution = resolution) mat_grey = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.5, 0.5, 0.5], device = pyredner.get_device())) materials = [mat_grey] vertices = torch.tensor([[-1.7,1.0,0.0], [1.0,1.0,0.0], [-0.5,-1.0,0.0]], device = pyredner.get_device()) indices = torch.tensor([[0, 1, 2]], dtype = torch.int32, device = pyredner.get_device()) shape_triangle = pyredner.Shape(vertices, indices, None, None, 0) light_vertices = torch.tensor([[-1.0,-1.0,-9.0],[1.0,-1.0,-9.0],[-1.0,1.0,-9.0],[1.0,1.0,-9.0]], device = pyredner.get_device()) light_indices = torch.tensor([[0,1,2],[1,3,2]], dtype = torch.int32, device = pyredner.get_device()) shape_light = pyredner.Shape(light_vertices, light_indices, None, None, 0) shapes = [shape_triangle, shape_light] light_intensity = torch.tensor([30.0,30.0,30.0]) light = pyredner.Light(1, light_intensity) lights = [light] scene = pyredner.Scene(cam, shapes, materials, lights) args = pyredner.RenderFunction.serialize_scene(\ scene = scene, num_samples = 16, max_bounces = 1)
# 3D objects in redner are called "Shape". # All shapes in the scene are stored in a Python list, # the index of a shape in the list is its shape id. # Right now, a shape is always a triangle mesh, which has a list of # triangle vertices and a list of triangle indices. # The vertices are a Nx3 torch float tensor, # and the indices are a Mx3 torch integer tensor. # Optionally, for each vertex you can specify its UV coordinate for texture mapping, # and a normal for Phong interpolation. # Each shape also needs to be assigned a material using material id, # which is the index of the material in the material array. # If you are using GPU, make sure to copy all tensors of the shape to GPU memory. shape_triangle = pyredner.Shape(\ vertices = torch.tensor([[-1.7, 1.0, 0.0], [1.0, 1.0, 0.0], [-0.5, -1.0, 0.0]], device = pyredner.get_device()), indices = torch.tensor([[0, 1, 2]], dtype = torch.int32, device = pyredner.get_device()), uvs = None, normals = None, material_id = 0) # Merely having a single triangle is not enough for physically-based rendering. # We need to have a light source. Here we setup the shape of a quad area light source, # similary to the previous triangle. shape_light = pyredner.Shape(\ vertices = torch.tensor([[-1.0, -1.0, -7.0], [ 1.0, -1.0, -7.0], [-1.0, 1.0, -7.0], [ 1.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,
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)
mat_checkerboard = pyredner.Material(\ diffuse_reflectance = checkerboard_texture) mat_black = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.0, 0.0, 0.0], device = pyredner.get_device())) materials = [mat_checkerboard, mat_black] 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]], device=pyredner.get_device()) indices = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int32, device=pyredner.get_device()) uvs = torch.tensor([[0.05, 0.05], [0.05, 0.95], [0.95, 0.05], [0.95, 0.95]], device=pyredner.get_device()) shape_plane = pyredner.Shape(vertices=vertices, indices=indices, uvs=uvs, material_id=0) light_vertices = torch.tensor([[-1.0, -1.0, -7.0], [1.0, -1.0, -7.0], [-1.0, 1.0, -7.0], [1.0, 1.0, -7.0]], device=pyredner.get_device()) light_indices = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int32, device=pyredner.get_device()) shape_light = pyredner.Shape(light_vertices, light_indices, 1) shapes = [shape_plane, shape_light] light_intensity = torch.tensor([20.0, 20.0, 20.0]) # The first argument is the shape id of the light light = pyredner.AreaLight(1, light_intensity) area_lights = [light] scene = pyredner.Scene(cam, shapes, materials, area_lights) args = pyredner.RenderFunction.serialize_scene(\
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())
bitangent = bitangent.div(torch.norm(bitangent)) lightPos = [ torch.add(torch.sub(pos, tangent), bitangent), torch.add(torch.add(pos, tangent), bitangent), torch.sub(torch.sub(pos, tangent), bitangent), torch.sub(torch.add(pos, tangent), bitangent) ] for i in range(4): lightPos[i] = lightPos[i] + torch.tensor([0.0, 0.0, -15.0]) lightPos = torch.cat(lightPos, 0) print(lightPos) lights.append(pyredner.Shape(\ vertices = torch.tensor(lightPos, device = pyredner.get_device()), indices = torch.tensor([[0, 2,1],[1, 2, 3]], dtype = torch.int32, device = pyredner.get_device()), uvs = None, normals = None, material_id = 0)) for ind, pos in enumerate(camLocs): #-4.5, 0.0, 0.1 - 2.5 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 up = torch.tensor([0.0, 1.0, 0.0]) tangent = torch.cross(normal, up) tangent = tangent.div(torch.norm(tangent)) bitangent = torch.cross(normal, tangent)
[[-0.3, 0.5], [0.2, 0.6], [-0.5, -0.3], [0.5, -0.4]], device = pyredner.get_device()) tri_vertices_2d = torch.tensor(\ [[-0.6, 0.3], [0.4, 0.5], [-0.1, -0.2]], device = pyredner.get_device()) # We need to pad the depth coordinates for these vertices # We'll assign depth = 1 for the quad, depth = 0 for the triangle, # so the triangle will block the quad. quad_vertices = torch.cat((quad_vertices_2d, torch.ones(quad_vertices_2d.shape[0], 1, device = pyredner.get_device())), dim=1).contiguous() 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(\ 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,
# 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) # mesh = mesh_list[0][1] shapes = [pyredner.Shape(\ vertices = mesh.vertices, indices = mesh.indices, uvs = mesh.uvs, normals = mesh.normals, material_id = 0)] tex_path = '../tutorials/teapot.png' tex_tensor = pyredner.imread(tex_path) if pyredner.get_use_gpu(): tex_tensor = tex_tensor.cuda(device=pyredner.get_device()) diffuse_reflectance = tex_tensor materials = [pyredner.Material(diffuse_reflectance=diffuse_reflectance)] # Construct the scene. # Don't setup any light sources, only use primary visibility. scene = pyredner.Scene(cam, shapes, materials, area_lights=[], envmap=None)
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
mat_checkerboard = pyredner.Material(\ diffuse_reflectance = checkerboard_texture) mat_black = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.0, 0.0, 0.0], device = pyredner.get_device())) materials = [mat_checkerboard, mat_black] 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]], device=pyredner.get_device()) indices = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int32, device=pyredner.get_device()) uvs = torch.tensor([[0.05, 0.05], [0.05, 0.95], [0.95, 0.05], [0.95, 0.95]], device=pyredner.get_device()) shape_plane = pyredner.Shape(vertices, indices, uvs, None, 0) light_vertices = torch.tensor([[-1.0, -1.0, -7.0], [1.0, -1.0, -7.0], [-1.0, 1.0, -7.0], [1.0, 1.0, -7.0]], device=pyredner.get_device()) light_indices = torch.tensor([[0, 1, 2], [1, 3, 2]], dtype=torch.int32, device=pyredner.get_device()) shape_light = pyredner.Shape(light_vertices, light_indices, None, None, 1) shapes = [shape_plane, shape_light] light_intensity = torch.tensor([20.0, 20.0, 20.0]) # The first argument is the shape id of the light light = pyredner.AreaLight(1, light_intensity) area_lights = [light] scene = pyredner.Scene(cam, shapes, materials, area_lights) args = pyredner.RenderFunction.serialize_scene(\ scene = scene,
clip_near = clip_near, resolution = resolution) mat_grey = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.5, 0.5, 0.5], device = pyredner.get_device())) mat_black = pyredner.Material(\ diffuse_reflectance = torch.tensor([0.0, 0.0, 0.0], device = pyredner.get_device())) materials = [mat_grey, mat_black] floor_vertices = torch.tensor([[-20.0,0.0,-20.0],[-20.0,0.0,20.0],[20.0,0.0,-20.0],[20.0,0.0,20.0]], device = pyredner.get_device()) floor_indices = torch.tensor([[0,1,2], [1,3,2]], device = pyredner.get_device(), dtype = torch.int32) shape_floor = pyredner.Shape(floor_vertices, floor_indices, 0) blocker_vertices = torch.tensor(\ [[-0.5,10.0,-0.5],[-0.5,10.0,0.5],[0.5,10.0,-0.5],[0.5,10.0,0.5]], device = pyredner.get_device()) blocker_indices = torch.tensor([[0,1,2], [1,3,2]], device = pyredner.get_device(), dtype = torch.int32) shape_blocker = pyredner.Shape(blocker_vertices, blocker_indices, 0) light_vertices = torch.tensor(\ [[-0.1,15,-0.1],[-0.1,15,0.1],[0.1,15,-0.1],[0.1,15,0.1]], device = pyredner.get_device()) light_indices = torch.tensor([[0,2,1], [1,2,3]], device = pyredner.get_device(), dtype = torch.int32) shape_light = pyredner.Shape(light_vertices, light_indices, 1) shapes = [shape_floor, shape_blocker, shape_light] light_intensity = torch.tensor([5000.0, 5000.0, 5000.0]) # The first argument is the shape id of the light
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)) # Set "use_vertex_color = True" to use vertex color mat_vertex_color = pyredner.Material(use_vertex_color=True) materials = [mat_vertex_color] vertices, indices, uvs, normals = pyredner.generate_sphere(128, 64) # For the target we randomize the vertex color. vertex_color = torch.zeros_like(vertices).uniform_(0.0, 1.0) shape_sphere = pyredner.Shape(\ vertices = vertices, indices = indices, uvs = uvs, normals = normals, colors = vertex_color, # use the 'colors' field in Shape to store the color 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, channels = [redner.channels.radiance, redner.channels.vertex_color])
# Setup materials material_id_map = {} materials = [] count = 0 for key, value in material_map.items(): material_id_map[key] = count count += 1 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])
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)
def parse_shape(node, material_dict, shape_id, shape_group_dict=None): if node.attrib['type'] == 'obj' or node.attrib['type'] == 'serialized': print(node.attrib['id']) to_world = torch.eye(4) serialized_shape_id = 0 mat_id = -1 light_intensity = None filename = '' mat_name2id = {} 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']] if 'name' in child.attrib.keys( ) and child.attrib['name'] != 'bsdf': mat_name2id[child.attrib['name']] = child.attrib['id'] elif child.tag == 'bsdf': #TODO hack! use default diffuse if countering internal declaration bsdf mat_id = 0 # node_id, material = parse_material(child) # if node_id is not None: # material_dict[node_id] = len(materials) # materials.append(material) 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.load_obj_fast( filename, is_load_mtl=False) shape_list = [] for mesh in mesh_list: mat_name = mesh[0] vertices = mesh[1].vertices.cpu() indices = mesh[1].indices.cpu() uvs = mesh[1].uvs normals = mesh[1].normals if uvs is not None: uvs = uvs.cpu() if normals is not None: normals = normals.cpu() # 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() # Assign material if mat_name != '' and mat_name is not None: # skip no material mesh mat_id = material_dict[mat_name2id[mat_name]] shape_list.append( pyredner.Shape(vertices, indices, uvs, normals, mat_id)) return shape_list, lgt 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']] shape_list = [] for shape in list(shape_): # 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) shape_list.append( pyredner.Shape(vertices, shape.indices, shape.uvs, normals, shape.material_id)) return shape_list, None else: print('Shape type {} is not supported!'.format(node.attrib['type'])) assert (False)
# so the triangle will block the quad. quad_vertices = torch.cat( (quad_vertices_2d, torch.ones(quad_vertices_2d.shape[0], 1, device=pyredner.get_device())), dim=1).contiguous() 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.
device=pyredner.get_device(), requires_grad=True) mat_grey = pyredner.Material(diffuse_reflectance) # The material list of the scene # materials = [mat_grey] # Now we build a list of shapes using the list loaded from the Wavefront object file. # Meshes loaded from .obj files may have different indices for uvs and normals, # we use mesh.uv_indices and mesh.normal_indices to access them. # This mesh does not have normal_indices so the value is None. shape_diamond = pyredner.Shape(vertices=mesh.vertices / 20, indices=mesh.indices, uvs=None, normals=mesh.normals, material_id=0) shape_light = pyredner.Shape(\ vertices = torch.tensor([[-1.0, -1.0, -7.0], [ 2.0, -1.0, -7.0], [-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:
# 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, uvs = mesh.uvs, normals = mesh.normals, material_id = 0)) # Set all materials to the generic texture render = pyredner.RenderFunction.apply tex_path = '../tutorials/teapot.png' tex_tensor = pyredner.imread(tex_path) if pyredner.get_use_gpu(): tex_tensor = tex_tensor.cuda(device=pyredner.get_device()) ### TEST 1: regular 3-channels texture rasterization generic_texture = tex_tensor materials = [pyredner.Material(generic_texture=generic_texture)]