def compute_uvs(vertices, indices, print_progress = True): """ Args: vertices -- N x 3 float tensor indices -- M x 3 int tensor Return: uvs & uvs_indices """ vertices = vertices.cpu() indices = indices.cpu() uv_trimesh = redner.UVTriMesh(redner.float_ptr(vertices.data_ptr()), redner.int_ptr(indices.data_ptr()), redner.float_ptr(0), redner.int_ptr(0), int(vertices.shape[0]), 0, int(indices.shape[0])) atlas = redner.TextureAtlas() num_uv_vertices = redner.automatic_uv_map([uv_trimesh], atlas, print_progress)[0] uvs = torch.zeros(num_uv_vertices, 2, dtype=torch.float32) uv_indices = torch.zeros_like(indices) uv_trimesh.uvs = redner.float_ptr(uvs.data_ptr()) uv_trimesh.uv_indices = redner.int_ptr(uv_indices.data_ptr()) uv_trimesh.num_uv_vertices = num_uv_vertices redner.copy_texture_atlas(atlas, [uv_trimesh]) if pyredner.get_use_gpu(): vertices = vertices.cuda(device = pyredner.get_device()) indices = indices.cuda(device = pyredner.get_device()) uvs = uvs.cuda(device = pyredner.get_device()) uv_indices = uv_indices.cuda(device = pyredner.get_device()) return uvs, uv_indices
def compute_uvs(vertices, indices, print_progress = True): """ Compute UV coordinates of a given mesh using a charting algorithm with least square conformal mapping. This calls the `xatlas <https://github.com/jpcy/xatlas>`_ library. Args ==== vertices: tf.Tensor 3D position of vertices float32 tensor with size num_vertices x 3 indices: tf.Tensor vertex indices of triangle faces. int32 tensor with size num_triangles x 3 Returns ======= tf.Tensor uv vertices pool, float32 Tensor with size num_uv_vertices x 3 tf.Tensor uv indices, int32 Tensor with size num_triangles x 3 """ with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): vertices = tf.identity(vertices) indices = tf.identity(indices) uv_trimesh = redner.UVTriMesh(redner.float_ptr(pyredner.data_ptr(vertices)), redner.int_ptr(pyredner.data_ptr(indices)), redner.float_ptr(0), redner.int_ptr(0), int(vertices.shape[0]), 0, int(indices.shape[0])) atlas = redner.TextureAtlas() num_uv_vertices = redner.automatic_uv_map([uv_trimesh], atlas, print_progress)[0] uvs = tf.zeros([num_uv_vertices, 2], dtype=tf.float32) uv_indices = tf.zeros_like(indices) uv_trimesh.uvs = redner.float_ptr(pyredner.data_ptr(uvs)) uv_trimesh.uv_indices = redner.int_ptr(pyredner.data_ptr(uv_indices)) uv_trimesh.num_uv_vertices = num_uv_vertices redner.copy_texture_atlas(atlas, [uv_trimesh]) with tf.device(pyredner.get_device_name()): vertices = tf.identity(vertices) indices = tf.identity(indices) uvs = tf.identity(uvs) uv_indices = tf.identity(uv_indices) return uvs, uv_indices
def compute_uvs(vertices, indices, print_progress=True): """ Compute UV coordinates of a given mesh using a charting algorithm with least square conformal mapping. This calls the `xatlas <https://github.com/jpcy/xatlas>`_ library. Args ==== vertices: torch.Tensor 3D position of vertices float32 tensor with size num_vertices x 3 indices: torch.Tensor vertex indices of triangle faces. int32 tensor with size num_triangles x 3 Returns ======= torch.Tensor uv vertices pool, float32 Tensor with size num_uv_vertices x 3 torch.Tensor uv indices, int32 Tensor with size num_triangles x 3 """ device = vertices.device vertices = vertices.cpu() indices = indices.cpu() uv_trimesh = redner.UVTriMesh(redner.float_ptr(vertices.data_ptr()), redner.int_ptr(indices.data_ptr()), redner.float_ptr(0), redner.int_ptr(0), int(vertices.shape[0]), 0, int(indices.shape[0])) atlas = redner.TextureAtlas() num_uv_vertices = redner.automatic_uv_map([uv_trimesh], atlas, print_progress)[0] uvs = torch.zeros(num_uv_vertices, 2, dtype=torch.float32) uv_indices = torch.zeros_like(indices) uv_trimesh.uvs = redner.float_ptr(uvs.data_ptr()) uv_trimesh.uv_indices = redner.int_ptr(uv_indices.data_ptr()) uv_trimesh.num_uv_vertices = num_uv_vertices redner.copy_texture_atlas(atlas, [uv_trimesh]) vertices = vertices.to(device) indices = indices.to(device) uvs = uvs.to(device) uv_indices = uv_indices.to(device) return uvs, uv_indices
def forward(ctx, seed, *args): """ Forward rendering pass: given a scene and output an image. """ # Unpack arguments current_index = 0 num_shapes = args[current_index] current_index += 1 num_materials = args[current_index] current_index += 1 num_lights = args[current_index] current_index += 1 cam_to_world = args[current_index] current_index += 1 world_to_cam = args[current_index] current_index += 1 fov_factor = args[current_index] current_index += 1 clip_near = args[current_index] current_index += 1 resolution = args[current_index] current_index += 1 fisheye = args[current_index] current_index += 1 assert (cam_to_world.is_contiguous()) assert (world_to_cam.is_contiguous()) camera = redner.Camera(resolution[1], resolution[0], redner.float_ptr(cam_to_world.data_ptr()), redner.float_ptr(world_to_cam.data_ptr()), fov_factor.item(), clip_near, fisheye) shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 material_id = args[current_index] current_index += 1 light_id = args[current_index] current_index += 1 assert (vertices.is_contiguous()) assert (indices.is_contiguous()) if uvs is not None: assert (uvs.is_contiguous()) if normals is not None: assert (normals.is_contiguous()) shapes.append(redner.Shape(\ 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), int(vertices.shape[0]), int(indices.shape[0]), material_id, light_id)) materials = [] for i in range(num_materials): diffuse_reflectance = args[current_index] current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 specular_reflectance = args[current_index] current_index += 1 specular_uv_scale = args[current_index] current_index += 1 roughness = args[current_index] current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 assert (diffuse_reflectance.is_contiguous()) if diffuse_reflectance.dim() == 1: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), 0, 0, 0, redner.float_ptr(diffuse_uv_scale.data_ptr())) else: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), int(diffuse_reflectance.shape[2]), # width int(diffuse_reflectance.shape[1]), # height int(diffuse_reflectance.shape[0]), # num levels redner.float_ptr(diffuse_uv_scale.data_ptr())) assert (specular_reflectance.is_contiguous()) if specular_reflectance.dim() == 1: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), 0, 0, 0, redner.float_ptr(specular_uv_scale.data_ptr())) else: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), int(specular_reflectance.shape[2]), # width int(specular_reflectance.shape[1]), # height int(specular_reflectance.shape[0]), # num levels redner.float_ptr(specular_uv_scale.data_ptr())) assert (roughness.is_contiguous()) if roughness.dim() == 1: roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), 0, 0, 0, redner.float_ptr(roughness_uv_scale.data_ptr())) else: roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), int(roughness.shape[2]), # width int(roughness.shape[1]), # height int(roughness.shape[0]), # num levels redner.float_ptr(roughness_uv_scale.data_ptr())) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, two_sided)) lights = [] for i in range(num_lights): shape_id = args[current_index] current_index += 1 intensity = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 lights.append( redner.Light(shape_id, redner.float_ptr(intensity.data_ptr()), two_sided)) scene = redner.Scene(camera, shapes, materials, lights, pyredner.get_use_gpu()) num_samples = args[current_index] current_index += 1 max_bounces = args[current_index] current_index += 1 options = redner.RenderOptions(seed, num_samples, max_bounces) rendered_image = torch.zeros(resolution[0], resolution[1], 3, device=pyredner.get_device()) redner.render(scene, options, redner.float_ptr(rendered_image.data_ptr()), redner.float_ptr(0), None, redner.float_ptr(0)) # # For debugging # debug_img = torch.zeros(256, 256, 3) # redner.render(scene, # options, # redner.float_ptr(rendered_image.data_ptr()), # redner.float_ptr(0), # None, # redner.float_ptr(debug_img.data_ptr())) # pyredner.imwrite(debug_img, 'debug.exr') # exit() ctx.shapes = shapes ctx.materials = materials ctx.lights = lights ctx.scene = scene ctx.options = options return rendered_image
def unpack_args(seed, args, use_primary_edge_sampling=None, use_secondary_edge_sampling=None): """ Given a list of serialized scene arguments, unpack all information into a Context. """ # Unpack arguments current_index = 0 num_shapes = int(args[current_index]) current_index += 1 num_materials = int(args[current_index]) current_index += 1 num_lights = int(args[current_index]) current_index += 1 # Camera arguments cam_position = args[current_index] current_index += 1 cam_look_at = args[current_index] current_index += 1 cam_up = args[current_index] current_index += 1 cam_to_world = args[current_index] current_index += 1 world_to_cam = args[current_index] current_index += 1 intrinsic_mat_inv = args[current_index] current_index += 1 intrinsic_mat = args[current_index] current_index += 1 clip_near = float(args[current_index]) current_index += 1 resolution = args[current_index].numpy() # Tuple[int, int] current_index += 1 viewport = args[current_index].numpy() # Tuple[int, int, int, int] current_index += 1 camera_type = RednerCameraType.asCameraType( args[current_index]) # FIXME: Map to custom type current_index += 1 with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): if is_empty_tensor(cam_to_world): camera = redner.Camera( resolution[1], resolution[0], redner.float_ptr(pyredner.data_ptr(cam_position)), redner.float_ptr(pyredner.data_ptr(cam_look_at)), redner.float_ptr(pyredner.data_ptr(cam_up)), redner.float_ptr(0), # cam_to_world redner.float_ptr(0), # world_to_cam redner.float_ptr(pyredner.data_ptr(intrinsic_mat_inv)), redner.float_ptr(pyredner.data_ptr(intrinsic_mat)), clip_near, camera_type, redner.Vector2i(viewport[1], viewport[0]), redner.Vector2i(viewport[3], viewport[2])) else: camera = redner.Camera( resolution[1], resolution[0], redner.float_ptr(0), redner.float_ptr(0), redner.float_ptr(0), redner.float_ptr(pyredner.data_ptr(cam_to_world)), redner.float_ptr(pyredner.data_ptr(world_to_cam)), redner.float_ptr(pyredner.data_ptr(intrinsic_mat_inv)), redner.float_ptr(pyredner.data_ptr(intrinsic_mat)), clip_near, camera_type, redner.Vector2i(viewport[1], viewport[0]), redner.Vector2i(viewport[3], viewport[2])) with tf.device(pyredner.get_device_name()): shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 uv_indices = args[current_index] current_index += 1 normal_indices = args[current_index] current_index += 1 colors = args[current_index] current_index += 1 material_id = int(args[current_index]) current_index += 1 light_id = int(args[current_index]) current_index += 1 shapes.append(redner.Shape(\ redner.float_ptr(pyredner.data_ptr(vertices)), redner.int_ptr(pyredner.data_ptr(indices)), redner.float_ptr(pyredner.data_ptr(uvs) if not is_empty_tensor(uvs) else 0), redner.float_ptr(pyredner.data_ptr(normals) if not is_empty_tensor(normals) else 0), redner.int_ptr(pyredner.data_ptr(uv_indices) if not is_empty_tensor(uv_indices) else 0), redner.int_ptr(pyredner.data_ptr(normal_indices) if not is_empty_tensor(normal_indices) else 0), redner.float_ptr(pyredner.data_ptr(colors) if not is_empty_tensor(colors) else 0), int(vertices.shape[0]), int(uvs.shape[0]) if not is_empty_tensor(uvs) else 0, int(normals.shape[0]) if not is_empty_tensor(normals) else 0, int(indices.shape[0]), material_id, light_id)) materials = [] with tf.device(pyredner.get_device_name()): for i in range(num_materials): num_levels = int(args[current_index]) current_index += 1 diffuse_reflectance = [] for j in range(num_levels): diffuse_reflectance.append(args[current_index]) current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 num_levels = int(args[current_index]) current_index += 1 specular_reflectance = [] for j in range(num_levels): specular_reflectance.append(args[current_index]) current_index += 1 specular_uv_scale = args[current_index] current_index += 1 num_levels = int(args[current_index]) current_index += 1 roughness = [] for j in range(num_levels): roughness.append(args[current_index]) current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 num_levels = int(args[current_index]) current_index += 1 generic_texture = [] if num_levels > 0: for j in range(num_levels): generic_texture.append(args[current_index]) current_index += 1 generic_uv_scale = args[current_index] current_index += 1 else: generic_uv_scale = None num_levels = int(args[current_index]) current_index += 1 normal_map = [] if num_levels > 0: for j in range(num_levels): normal_map.append(args[current_index]) current_index += 1 normal_map_uv_scale = args[current_index] current_index += 1 else: normal_map_uv_scale = None compute_specular_lighting = bool(args[current_index]) current_index += 1 two_sided = bool(args[current_index]) current_index += 1 use_vertex_color = bool(args[current_index]) current_index += 1 if get_tensor_dimension(diffuse_reflectance[0]) == 1: diffuse_reflectance = redner.Texture3(\ [redner.float_ptr(pyredner.data_ptr(diffuse_reflectance[0]))], [0], [0], 3, redner.float_ptr(pyredner.data_ptr(diffuse_uv_scale))) else: assert (get_tensor_dimension(diffuse_reflectance[0]) == 3) diffuse_reflectance = redner.Texture3(\ [redner.float_ptr(pyredner.data_ptr(x)) for x in diffuse_reflectance], [x.shape[1] for x in diffuse_reflectance], [x.shape[0] for x in diffuse_reflectance], 3, redner.float_ptr(pyredner.data_ptr(diffuse_uv_scale))) if get_tensor_dimension(specular_reflectance[0]) == 1: specular_reflectance = redner.Texture3(\ [redner.float_ptr(pyredner.data_ptr(specular_reflectance[0]))], [0], [0], 3, redner.float_ptr(pyredner.data_ptr(specular_uv_scale))) else: assert (get_tensor_dimension(specular_reflectance[0]) == 3) specular_reflectance = redner.Texture3(\ [redner.float_ptr(pyredner.data_ptr(x)) for x in specular_reflectance], [x.shape[1] for x in specular_reflectance], [x.shape[0] for x in specular_reflectance], 3, redner.float_ptr(pyredner.data_ptr(specular_uv_scale))) if get_tensor_dimension(roughness[0]) == 1: roughness = redner.Texture1(\ [redner.float_ptr(pyredner.data_ptr(roughness[0]))], [0], [0], 1, redner.float_ptr(pyredner.data_ptr(roughness_uv_scale))) else: assert (get_tensor_dimension(roughness[0]) == 3) roughness = redner.Texture1(\ [redner.float_ptr(pyredner.data_ptr(x)) for x in roughness], [x.shape[1] for x in roughness], [x.shape[0] for x in roughness], 3, redner.float_ptr(pyredner.data_ptr(roughness_uv_scale))) if len(generic_texture) > 0: generic_texture = redner.TextureN(\ [redner.float_ptr(pyredner.data_ptr(x)) for x in generic_texture], [x.shape[1] for x in generic_texture], [x.shape[0] for x in generic_texture], generic_texture[0].shape[2], redner.float_ptr(pyredner.data_ptr(generic_uv_scale))) else: generic_texture = redner.TextureN(\ [], [], [], 0, redner.float_ptr(0)) if len(normal_map) > 0: normal_map = redner.Texture3(\ [redner.float_ptr(pyredner.data_ptr(x)) for x in normal_map], [x.shape[1] for x in normal_map], [x.shape[0] for x in normal_map], normal_map[0].shape[2], redner.float_ptr(pyredner.data_ptr(normal_map_uv_scale))) else: normal_map = redner.Texture3(\ [], [], [], 0, redner.float_ptr(0)) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, generic_texture, normal_map, compute_specular_lighting, two_sided, use_vertex_color)) with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): area_lights = [] for i in range(num_lights): shape_id = int(args[current_index]) current_index += 1 intensity = args[current_index] current_index += 1 two_sided = bool(args[current_index]) current_index += 1 directly_visible = bool(args[current_index]) current_index += 1 area_lights.append( redner.AreaLight( shape_id, redner.float_ptr(pyredner.data_ptr(intensity)), two_sided, directly_visible)) envmap = None if not is_empty_tensor(args[current_index]): num_levels = args[current_index] current_index += 1 values = [] for j in range(num_levels): values.append(args[current_index]) current_index += 1 envmap_uv_scale = args[current_index] current_index += 1 env_to_world = args[current_index] current_index += 1 world_to_env = args[current_index] current_index += 1 sample_cdf_ys = args[current_index] current_index += 1 sample_cdf_xs = args[current_index] current_index += 1 pdf_norm = float(args[current_index]) current_index += 1 directly_visible = bool(args[current_index]) current_index += 1 assert isinstance(pdf_norm, float) with tf.device(pyredner.get_device_name()): sample_cdf_ys = redner.float_ptr(pyredner.data_ptr(sample_cdf_ys)) sample_cdf_xs = redner.float_ptr(pyredner.data_ptr(sample_cdf_xs)) with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): env_to_world = redner.float_ptr(pyredner.data_ptr(env_to_world)) world_to_env = redner.float_ptr(pyredner.data_ptr(world_to_env)) with tf.device(pyredner.get_device_name()): values = redner.Texture3(\ [redner.float_ptr(pyredner.data_ptr(x)) for x in values], [x.shape[1] for x in values], # width [x.shape[0] for x in values], # height 3, # channels redner.float_ptr(pyredner.data_ptr(envmap_uv_scale))) envmap = redner.EnvironmentMap(\ values, env_to_world, world_to_env, sample_cdf_ys, sample_cdf_xs, pdf_norm, directly_visible) else: current_index += 1 # Options num_samples = args[current_index] current_index += 1 if len(num_samples.shape) == 0 or num_samples.shape[0] == 1: num_samples = int(num_samples) else: assert (num_samples.shape[0] == 2) num_samples = (int(num_samples[0]), int(num_samples[1])) max_bounces = int(args[current_index]) current_index += 1 num_channel_args = int(args[current_index]) current_index += 1 channels = [] for _ in range(num_channel_args): ch = args[current_index] ch = RednerChannels.asChannel(ch) channels.append(ch) current_index += 1 sampler_type = args[current_index] sampler_type = RednerSamplerType.asSamplerType(sampler_type) current_index += 1 use_primary_edge_sampling = args[current_index] current_index += 1 use_secondary_edge_sampling = args[current_index] current_index += 1 sample_pixel_center = args[current_index] current_index += 1 start = time.time() scene = redner.Scene(camera, shapes, materials, area_lights, envmap, pyredner.get_use_gpu(), pyredner.get_gpu_device_id(), use_primary_edge_sampling, use_secondary_edge_sampling) time_elapsed = time.time() - start if get_print_timing(): print('Scene construction, time: %.5f s' % time_elapsed) # check that num_samples is a tuple if isinstance(num_samples, int): num_samples = (num_samples, num_samples) options = redner.RenderOptions(seed, num_samples[0], max_bounces, channels, sampler_type, sample_pixel_center) ctx = Context() ctx.channels = channels ctx.options = options ctx.resolution = resolution ctx.viewport = viewport ctx.scene = scene ctx.camera = camera ctx.shapes = shapes ctx.materials = materials ctx.area_lights = area_lights ctx.envmap = envmap ctx.scene = scene ctx.options = options ctx.num_samples = num_samples ctx.num_channel_args = num_channel_args return ctx
def forward(seed: int, *args): """ Forward rendering pass: given a scene and output an image. """ global __ctx ctx = __ctx # Unpack arguments current_index = 0 num_shapes = int(args[current_index]) current_index += 1 num_materials = int(args[current_index]) current_index += 1 num_lights = int(args[current_index]) current_index += 1 # Camera arguments cam_position = args[current_index] current_index += 1 cam_look_at = args[current_index] current_index += 1 cam_up = args[current_index] current_index += 1 ndc_to_cam = args[current_index] current_index += 1 cam_to_ndc = args[current_index] current_index += 1 clip_near = float(args[current_index]) current_index += 1 resolution = args[current_index].numpy() # Tuple[int, int] current_index += 1 camera_type = pyredner.RednerCameraType.asCameraType( args[current_index]) # FIXME: Map to custom type current_index += 1 with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): camera = redner.Camera( resolution[1], resolution[0], redner.float_ptr(pyredner.data_ptr(cam_position)), redner.float_ptr(pyredner.data_ptr(cam_look_at)), redner.float_ptr(pyredner.data_ptr(cam_up)), redner.float_ptr(pyredner.data_ptr(ndc_to_cam)), redner.float_ptr(pyredner.data_ptr(cam_to_ndc)), clip_near, camera_type) with tf.device(pyredner.get_device_name()): shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 material_id = int(args[current_index]) current_index += 1 light_id = int(args[current_index]) current_index += 1 shapes.append(redner.Shape(\ redner.float_ptr(pyredner.data_ptr(vertices)), redner.int_ptr(pyredner.data_ptr(indices)), redner.float_ptr(pyredner.data_ptr(uvs) if uvs is not None else 0), redner.float_ptr(pyredner.data_ptr(normals) if normals is not None else 0), int(vertices.shape[0]), int(indices.shape[0]), material_id, light_id)) materials = [] with tf.device(pyredner.get_device_name()): for i in range(num_materials): diffuse_reflectance = args[current_index] current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 specular_reflectance = args[current_index] current_index += 1 specular_uv_scale = args[current_index] current_index += 1 roughness = args[current_index] current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 normal_map = args[current_index] current_index += 1 normal_map_uv_scale = args[current_index] current_index += 1 two_sided = bool(args[current_index]) current_index += 1 diffuse_reflectance_ptr = redner.float_ptr( pyredner.data_ptr(diffuse_reflectance)) specular_reflectance_ptr = redner.float_ptr( pyredner.data_ptr(specular_reflectance)) roughness_ptr = redner.float_ptr(pyredner.data_ptr(roughness)) if normal_map.shape[0] > 0: normal_map_ptr = redner.float_ptr( pyredner.data_ptr(normal_map)) diffuse_uv_scale_ptr = redner.float_ptr( pyredner.data_ptr(diffuse_uv_scale)) specular_uv_scale_ptr = redner.float_ptr( pyredner.data_ptr(specular_uv_scale)) roughness_uv_scale_ptr = redner.float_ptr( pyredner.data_ptr(roughness_uv_scale)) if normal_map.shape[0] > 0: normal_map_uv_scale_ptr = redner.float_ptr( pyredner.data_ptr(normal_map_uv_scale)) if get_tensor_dimension(diffuse_reflectance) == 1: diffuse_reflectance = redner.Texture3(diffuse_reflectance_ptr, 0, 0, 0, diffuse_uv_scale_ptr) else: diffuse_reflectance = redner.Texture3(\ diffuse_reflectance_ptr, int(diffuse_reflectance.shape[2]), # width int(diffuse_reflectance.shape[1]), # height int(diffuse_reflectance.shape[0]), # num levels diffuse_uv_scale_ptr) if get_tensor_dimension(specular_reflectance) == 1: specular_reflectance = redner.Texture3( specular_reflectance_ptr, 0, 0, 0, specular_uv_scale_ptr) else: specular_reflectance = redner.Texture3(\ specular_reflectance_ptr, int(specular_reflectance.shape[2]), # width int(specular_reflectance.shape[1]), # height int(specular_reflectance.shape[0]), # num levels specular_uv_scale_ptr) if get_tensor_dimension(roughness) == 1: roughness = redner.Texture1(roughness_ptr, 0, 0, 0, roughness_uv_scale_ptr) else: assert (get_tensor_dimension(roughness) == 4) roughness = redner.Texture1(\ roughness_ptr, int(roughness.shape[2]), # width int(roughness.shape[1]), # height int(roughness.shape[0]), # num levels roughness_uv_scale_ptr) if normal_map.shape[0] > 0: normal_map = redner.Texture3(\ normal_map_ptr, int(normal_map.shape[2]), int(normal_map.shape[1]), int(normal_map.shape[0]), normal_map_uv_scale_ptr) else: normal_map = redner.Texture3(\ redner.float_ptr(0), 0, 0, 0, redner.float_ptr(0)) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, normal_map, two_sided)) with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): area_lights = [] for i in range(num_lights): shape_id = int(args[current_index]) current_index += 1 intensity = args[current_index] current_index += 1 two_sided = bool(args[current_index]) current_index += 1 area_lights.append( redner.AreaLight( shape_id, redner.float_ptr(pyredner.data_ptr(intensity)), two_sided)) envmap = None if not is_empty_tensor(args[current_index]): values = args[current_index] current_index += 1 envmap_uv_scale = args[current_index] current_index += 1 env_to_world = args[current_index] current_index += 1 world_to_env = args[current_index] current_index += 1 sample_cdf_ys = args[current_index] current_index += 1 sample_cdf_xs = args[current_index] current_index += 1 pdf_norm = float(args[current_index]) current_index += 1 assert isinstance(pdf_norm, float) with tf.device(pyredner.get_device_name()): values_ptr = redner.float_ptr(pyredner.data_ptr(values)) sample_cdf_ys = redner.float_ptr(pyredner.data_ptr(sample_cdf_ys)) sample_cdf_xs = redner.float_ptr(pyredner.data_ptr(sample_cdf_xs)) envmap_uv_scale = redner.float_ptr( pyredner.data_ptr(envmap_uv_scale)) with tf.device('/device:cpu:' + str(pyredner.get_cpu_device_id())): env_to_world = redner.float_ptr(pyredner.data_ptr(env_to_world)) world_to_env = redner.float_ptr(pyredner.data_ptr(world_to_env)) values = redner.Texture3( values_ptr, int(values.shape[2]), # width int(values.shape[1]), # height int(values.shape[0]), # num levels envmap_uv_scale) envmap = redner.EnvironmentMap(\ values, env_to_world, world_to_env, sample_cdf_ys, sample_cdf_xs, pdf_norm) else: current_index += 7 # Options num_samples = int(args[current_index]) current_index += 1 max_bounces = int(args[current_index]) current_index += 1 __num_channels = int(args[current_index]) current_index += 1 channels = [] for _ in range(__num_channels): ch = args[current_index] ch = pyredner.RednerChannels.asChannel(ch) channels.append(ch) current_index += 1 sampler_type = args[current_index] sampler_type = pyredner.RednerSamplerType.asSamplerType(sampler_type) current_index += 1 use_primary_edge_sampling = args[current_index] current_index += 1 use_secondary_edge_sampling = args[current_index] current_index += 1 scene = redner.Scene(camera, shapes, materials, area_lights, envmap, pyredner.get_use_gpu(), pyredner.get_gpu_device_id(), use_primary_edge_sampling, use_secondary_edge_sampling) # check that num_samples is a tuple if isinstance(num_samples, int): num_samples = (num_samples, num_samples) options = redner.RenderOptions(seed, num_samples[0], max_bounces, channels, sampler_type) num_channels = redner.compute_num_channels(channels) with tf.device(pyredner.get_device_name()): rendered_image = tf.zeros( shape=[resolution[0], resolution[1], num_channels], dtype=tf.float32) start = time.time() # pdb.set_trace() redner.render(scene, options, redner.float_ptr(pyredner.data_ptr(rendered_image)), redner.float_ptr(0), None, redner.float_ptr(0)) time_elapsed = time.time() - start if print_timing: print('Forward pass, time: %.5f s' % time_elapsed) # # For debugging # debug_img = tf.zeros((256, 256, 3), dtype=tf.float32) # redner.render(scene, # options, # redner.float_ptr(pyredner.data_ptr(rendered_image)), # redner.float_ptr(0), # None, # redner.float_ptr(pyredner.data_ptr(debug_img))) # pyredner.imwrite(debug_img, 'debug.png') # exit() # import pdb; pdb.set_trace() ctx.shapes = shapes ctx.materials = materials ctx.area_lights = area_lights ctx.envmap = envmap ctx.scene = scene ctx.options = options ctx.num_samples = num_samples ctx.num_channels = __num_channels return rendered_image
def forward(ctx, seed, *args): """ Forward rendering pass: given a scene and output an image. """ # Unpack arguments current_index = 0 num_shapes = args[current_index] current_index += 1 num_materials = args[current_index] current_index += 1 num_lights = args[current_index] current_index += 1 cam_position = args[current_index] current_index += 1 cam_look_at = args[current_index] current_index += 1 cam_up = args[current_index] current_index += 1 ndc_to_cam = args[current_index] current_index += 1 cam_to_ndc = args[current_index] current_index += 1 clip_near = args[current_index] current_index += 1 resolution = args[current_index] current_index += 1 fisheye = args[current_index] current_index += 1 camera = redner.Camera(resolution[1], resolution[0], redner.float_ptr(cam_position.data_ptr()), redner.float_ptr(cam_look_at.data_ptr()), redner.float_ptr(cam_up.data_ptr()), redner.float_ptr(ndc_to_cam.data_ptr()), redner.float_ptr(cam_to_ndc.data_ptr()), clip_near, fisheye) shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 material_id = args[current_index] current_index += 1 light_id = args[current_index] current_index += 1 assert (vertices.is_contiguous()) assert (indices.is_contiguous()) if uvs is not None: assert (uvs.is_contiguous()) if normals is not None: assert (normals.is_contiguous()) shapes.append(redner.Shape(\ 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), int(vertices.shape[0]), int(indices.shape[0]), material_id, light_id)) materials = [] for i in range(num_materials): diffuse_reflectance = args[current_index] current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 specular_reflectance = args[current_index] current_index += 1 specular_uv_scale = args[current_index] current_index += 1 roughness = args[current_index] current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 assert (diffuse_reflectance.is_contiguous()) if diffuse_reflectance.dim() == 1: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), 0, 0, 0, redner.float_ptr(diffuse_uv_scale.data_ptr())) else: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), int(diffuse_reflectance.shape[2]), # width int(diffuse_reflectance.shape[1]), # height int(diffuse_reflectance.shape[0]), # num levels redner.float_ptr(diffuse_uv_scale.data_ptr())) assert (specular_reflectance.is_contiguous()) if specular_reflectance.dim() == 1: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), 0, 0, 0, redner.float_ptr(specular_uv_scale.data_ptr())) else: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), int(specular_reflectance.shape[2]), # width int(specular_reflectance.shape[1]), # height int(specular_reflectance.shape[0]), # num levels redner.float_ptr(specular_uv_scale.data_ptr())) assert (roughness.is_contiguous()) if roughness.dim() == 1: roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), 0, 0, 0, redner.float_ptr(roughness_uv_scale.data_ptr())) else: assert (roughness.dim() == 4) roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), int(roughness.shape[2]), # width int(roughness.shape[1]), # height int(roughness.shape[0]), # num levels redner.float_ptr(roughness_uv_scale.data_ptr())) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, two_sided)) area_lights = [] for i in range(num_lights): shape_id = args[current_index] current_index += 1 intensity = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 area_lights.append(redner.AreaLight(\ shape_id, redner.float_ptr(intensity.data_ptr()), two_sided)) envmap = None if args[current_index] is not None: values = args[current_index] current_index += 1 envmap_uv_scale = args[current_index] current_index += 1 env_to_world = args[current_index] current_index += 1 world_to_env = args[current_index] current_index += 1 sample_cdf_ys = args[current_index] current_index += 1 sample_cdf_xs = args[current_index] current_index += 1 pdf_norm = args[current_index] current_index += 1 values = redner.Texture3(\ redner.float_ptr(values.data_ptr()), int(values.shape[2]), # width int(values.shape[1]), # height int(values.shape[0]), # num levels redner.float_ptr(envmap_uv_scale.data_ptr())) envmap = redner.EnvironmentMap(\ values, redner.float_ptr(env_to_world.data_ptr()), redner.float_ptr(world_to_env.data_ptr()), redner.float_ptr(sample_cdf_ys.data_ptr()), redner.float_ptr(sample_cdf_xs.data_ptr()), pdf_norm) else: current_index += 7 # Options num_samples = args[current_index] current_index += 1 max_bounces = args[current_index] current_index += 1 channels = args[current_index] current_index += 1 sampler_type = args[current_index] current_index += 1 use_primary_edge_sampling = args[current_index] current_index += 1 use_secondary_edge_sampling = args[current_index] current_index += 1 start = time.time() scene = redner.Scene( camera, shapes, materials, area_lights, envmap, pyredner.get_use_gpu(), pyredner.get_device().index if pyredner.get_device().index is not None else -1, use_primary_edge_sampling, use_secondary_edge_sampling) time_elapsed = time.time() - start if print_timing: print('Scene construction, time: %.5f s' % time_elapsed) # check that num_samples is a tuple if isinstance(num_samples, int): num_samples = (num_samples, num_samples) options = redner.RenderOptions(seed, num_samples[0], max_bounces, channels, sampler_type) num_channels = redner.compute_num_channels(channels) rendered_image = torch.zeros(resolution[0], resolution[1], num_channels, device=pyredner.get_device()) start = time.time() redner.render(scene, options, redner.float_ptr(rendered_image.data_ptr()), redner.float_ptr(0), None, redner.float_ptr(0)) time_elapsed = time.time() - start if print_timing: print('Forward pass, time: %.5f s' % time_elapsed) # # For debugging # debug_img = torch.zeros(256, 256, 3) # redner.render(scene, # options, # redner.float_ptr(rendered_image.data_ptr()), # redner.float_ptr(0), # None, # redner.float_ptr(debug_img.data_ptr())) # pyredner.imwrite(debug_img, 'debug.exr') # exit() ctx.shapes = shapes ctx.materials = materials ctx.area_lights = area_lights ctx.envmap = envmap ctx.scene = scene ctx.options = options ctx.num_samples = num_samples return rendered_image
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)
def parse_shape(node, material_dict, shape_id): if node.attrib['type'] == 'obj' or node.attrib['type'] == 'serialized': to_world = tf.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 = tf.constant([ light_intensity[0], light_intensity[0], light_intensity[0] ]) if node.attrib['type'] == 'obj': _, mesh_list, _ = pyredner.load_obj(filename) # Convert to CPU for rebuild_topology 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 uv_indices = mesh_list[0][1].uv_indices normal_indices = mesh_list[0][1].normal_indices if uvs is not None: uvs = uvs.cpu() if normals is not None: normals = normals.cpu() if uv_indices is not None: uv_indices = uv_indices.cpu() else: assert (node.attrib['type'] == 'serialized') mitsuba_tri_mesh = redner.load_serialized(filename, serialized_shape_id) vertices = tf.convert_to_tensor(mitsuba_tri_mesh.vertices) indices = tf.convert_to_tensor(mitsuba_tri_mesh.indices) uvs = tf.convert_to_tensor(mitsuba_tri_mesh.uvs) normals = tf.convert_to_tensor(mitsuba_tri_mesh.normals) if uvs.shape[0] == 0: uvs = None if normals.shape[0] == 0: normals = None # Transform the vertices and normals vertices = tf.concat( (vertices, tf.ones([vertices.shape[0], 1], dtype=tf.float32)), axis=1) vertices = vertices @ tf.transpose(to_world, [0, 1]) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3] if normals is not None: normals = normals @ (tf.linalg.inv(tf.transpose(to_world, [0, 1]))[:3, :3]) assert (vertices is not None) assert (indices is not None) if max_smooth_angle >= 0: if normals is None: normals = tf.zeros_like(vertices) new_num_vertices = redner.rebuild_topology(\ redner.float_ptr(pyredner.data_ptr(vertices)), redner.int_ptr(pyredner.data_ptr(indices)), redner.float_ptr(pyredner.data_ptr(uvs) if uvs is not None else 0), redner.float_ptr(pyredner.data_ptr(normals) if normals is not None else 0), redner.int_ptr(pyredner.data_ptr(uv_indices) 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) return pyredner.Shape(vertices=vertices, indices=indices, uvs=uvs, normals=normals, material_id=mat_id), lgt elif node.attrib['type'] == 'rectangle': indices = tf.constant([[0, 2, 1], [1, 2, 3]], dtype=tf.int32) vertices = tf.constant([[-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 = tf.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 = tf.constant([ light_intensity[0], light_intensity[0], light_intensity[0] ]) # Transform the vertices and normals vertices = tf.concat( (vertices, tf.convert_to_tensor(np.ones(vertices.shape[0], 1), dtype=tf.float32)), axis=1) vertices = vertices @ tf.transpose(to_world, [0, 1]) vertices = vertices / vertices[:, 3:4] vertices = vertices[:, 0:3] if normals is not None: normals = normals @ (tf.linalg.inv(tf.transpose(to_world, [0, 1]))[:3, :3]) assert (vertices is not None) assert (indices is not None) lgt = None if light_intensity is not None: lgt = pyrender.Light(shape_id, light_intensity) return pyredner.Shape(vertices=vertices, indices=indices, uvs=uvs, normals=normals, material_id=mat_id), lgt else: assert (False)
def unpack_args(seed, args, use_primary_edge_sampling = None, use_secondary_edge_sampling = None): """ Given a list of serialized scene arguments, unpack all information into a Context. """ current_index = 0 num_shapes = args[current_index] current_index += 1 num_materials = args[current_index] current_index += 1 num_lights = args[current_index] current_index += 1 cam_position = args[current_index] current_index += 1 cam_look_at = args[current_index] current_index += 1 cam_up = args[current_index] current_index += 1 cam_to_world = args[current_index] current_index += 1 world_to_cam = args[current_index] current_index += 1 intrinsic_mat_inv = args[current_index] current_index += 1 intrinsic_mat = args[current_index] current_index += 1 clip_near = args[current_index] current_index += 1 resolution = args[current_index] current_index += 1 viewport = args[current_index] current_index += 1 camera_type = args[current_index] current_index += 1 if cam_to_world is None: camera = redner.Camera(resolution[1], resolution[0], redner.float_ptr(cam_position.data_ptr()), redner.float_ptr(cam_look_at.data_ptr()), redner.float_ptr(cam_up.data_ptr()), redner.float_ptr(0), # cam_to_world redner.float_ptr(0), # world_to_cam redner.float_ptr(intrinsic_mat_inv.data_ptr()), redner.float_ptr(intrinsic_mat.data_ptr()), clip_near, camera_type, redner.Vector2i(viewport[1], viewport[0]), redner.Vector2i(viewport[3], viewport[2])) else: camera = redner.Camera(resolution[1], resolution[0], redner.float_ptr(0), # cam_position redner.float_ptr(0), # cam_look_at redner.float_ptr(0), # cam_up redner.float_ptr(cam_to_world.data_ptr()), redner.float_ptr(world_to_cam.data_ptr()), redner.float_ptr(intrinsic_mat_inv.data_ptr()), redner.float_ptr(intrinsic_mat.data_ptr()), clip_near, camera_type, redner.Vector2i(viewport[1], viewport[0]), redner.Vector2i(viewport[3], viewport[2])) shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 uv_indices = args[current_index] current_index += 1 normal_indices = args[current_index] current_index += 1 colors = args[current_index] current_index += 1 material_id = args[current_index] current_index += 1 light_id = args[current_index] current_index += 1 assert(vertices.is_contiguous()) assert(indices.is_contiguous()) if uvs is not None: assert(uvs.is_contiguous()) if normals is not None: assert(normals.is_contiguous()) if uv_indices is not None: assert(uv_indices.is_contiguous()) if normal_indices is not None: assert(normal_indices.is_contiguous()) shapes.append(redner.Shape(\ 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), redner.int_ptr(normal_indices.data_ptr() if normal_indices is not None else 0), redner.float_ptr(colors.data_ptr() if colors is not None else 0), int(vertices.shape[0]), int(uvs.shape[0]) if uvs is not None else 0, int(normals.shape[0]) if normals is not None else 0, int(indices.shape[0]), material_id, light_id)) materials = [] for i in range(num_materials): num_levels = args[current_index] current_index += 1 diffuse_reflectance = [] for j in range(num_levels): diffuse_reflectance.append(args[current_index]) current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 num_levels = args[current_index] current_index += 1 specular_reflectance = [] for j in range(num_levels): specular_reflectance.append(args[current_index]) current_index += 1 specular_uv_scale = args[current_index] current_index += 1 num_levels = args[current_index] current_index += 1 roughness = [] for j in range(num_levels): roughness.append(args[current_index]) current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 num_levels = args[current_index] current_index += 1 generic_texture = [] if num_levels > 0: for j in range(num_levels): generic_texture.append(args[current_index]) current_index += 1 generic_uv_scale = args[current_index] current_index += 1 else: generic_uv_scale = None num_levels = args[current_index] current_index += 1 normal_map = [] if num_levels > 0: for j in range(num_levels): normal_map.append(args[current_index]) current_index += 1 normal_map_uv_scale = args[current_index] current_index += 1 else: normal_map_uv_scale = None compute_specular_lighting = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 use_vertex_color = args[current_index] current_index += 1 if diffuse_reflectance[0].dim() == 1: # Constant texture diffuse_reflectance = redner.Texture3(\ [redner.float_ptr(diffuse_reflectance[0].data_ptr())], [0], [0], 3, redner.float_ptr(diffuse_uv_scale.data_ptr())) else: assert(diffuse_reflectance[0].dim() == 3) diffuse_reflectance = redner.Texture3(\ [redner.float_ptr(x.data_ptr()) for x in diffuse_reflectance], [x.shape[1] for x in diffuse_reflectance], [x.shape[0] for x in diffuse_reflectance], 3, redner.float_ptr(diffuse_uv_scale.data_ptr())) if specular_reflectance[0].dim() == 1: # Constant texture specular_reflectance = redner.Texture3(\ [redner.float_ptr(specular_reflectance[0].data_ptr())], [0], [0], 3, redner.float_ptr(specular_uv_scale.data_ptr())) else: assert(specular_reflectance[0].dim() == 3) specular_reflectance = redner.Texture3(\ [redner.float_ptr(x.data_ptr()) for x in specular_reflectance], [x.shape[1] for x in specular_reflectance], [x.shape[0] for x in specular_reflectance], 3, redner.float_ptr(specular_uv_scale.data_ptr())) if roughness[0].dim() == 1: # Constant texture roughness = redner.Texture1(\ [redner.float_ptr(roughness[0].data_ptr())], [0], [0], 1, redner.float_ptr(roughness_uv_scale.data_ptr())) else: assert(roughness[0].dim() == 3) roughness = redner.Texture1(\ [redner.float_ptr(x.data_ptr()) for x in roughness], [x.shape[1] for x in roughness], [x.shape[0] for x in roughness], 1, redner.float_ptr(roughness_uv_scale.data_ptr())) if len(generic_texture) > 0: assert(generic_texture[0].dim() == 3) generic_texture = redner.TextureN(\ [redner.float_ptr(x.data_ptr()) for x in generic_texture], [x.shape[1] for x in generic_texture], [x.shape[0] for x in generic_texture], generic_texture[0].shape[2], redner.float_ptr(generic_uv_scale.data_ptr())) else: generic_texture = redner.TextureN(\ [], [], [], 0, redner.float_ptr(0)) if len(normal_map) > 0: assert(normal_map[0].dim() == 3) normal_map = redner.Texture3(\ [redner.float_ptr(x.data_ptr()) for x in normal_map], [x.shape[1] for x in normal_map], [x.shape[0] for x in normal_map], 3, redner.float_ptr(normal_map_uv_scale.data_ptr())) else: normal_map = redner.Texture3(\ [], [], [], 0, redner.float_ptr(0)) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, generic_texture, normal_map, compute_specular_lighting, two_sided, use_vertex_color)) area_lights = [] for i in range(num_lights): shape_id = args[current_index] current_index += 1 intensity = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 directly_visible = args[current_index] current_index += 1 area_lights.append(redner.AreaLight(\ shape_id, redner.float_ptr(intensity.data_ptr()), two_sided, directly_visible)) envmap = None if args[current_index] is not None: num_levels = args[current_index] current_index += 1 values = [] for j in range(num_levels): values.append(args[current_index]) current_index += 1 envmap_uv_scale = args[current_index] current_index += 1 env_to_world = args[current_index] current_index += 1 world_to_env = args[current_index] current_index += 1 sample_cdf_ys = args[current_index] current_index += 1 sample_cdf_xs = args[current_index] current_index += 1 pdf_norm = args[current_index] current_index += 1 directly_visible = args[current_index] current_index += 1 values = redner.Texture3(\ [redner.float_ptr(x.data_ptr()) for x in values], [x.shape[1] for x in values], # width [x.shape[0] for x in values], # height 3, # channels redner.float_ptr(envmap_uv_scale.data_ptr())) envmap = redner.EnvironmentMap(\ values, redner.float_ptr(env_to_world.data_ptr()), redner.float_ptr(world_to_env.data_ptr()), redner.float_ptr(sample_cdf_ys.data_ptr()), redner.float_ptr(sample_cdf_xs.data_ptr()), pdf_norm, directly_visible) else: current_index += 1 # Options num_samples = args[current_index] current_index += 1 max_bounces = args[current_index] current_index += 1 channels = args[current_index] current_index += 1 sampler_type = args[current_index] current_index += 1 use_primary_edge_sampling_ = args[current_index] current_index += 1 use_secondary_edge_sampling_ = args[current_index] current_index += 1 sample_pixel_center = args[current_index] current_index += 1 if use_primary_edge_sampling is None: use_primary_edge_sampling = use_primary_edge_sampling_ if use_secondary_edge_sampling is None: use_secondary_edge_sampling = use_secondary_edge_sampling_ start = time.time() scene = redner.Scene(camera, shapes, materials, area_lights, envmap, pyredner.get_use_gpu(), pyredner.get_device().index if pyredner.get_device().index is not None else -1, use_primary_edge_sampling, use_secondary_edge_sampling) time_elapsed = time.time() - start if get_print_timing(): print('Scene construction, time: %.5f s' % time_elapsed) # check that num_samples is a tuple if isinstance(num_samples, int): num_samples = (num_samples, num_samples) options = redner.RenderOptions(seed, num_samples[0], max_bounces, channels, sampler_type, sample_pixel_center) ctx = Context() ctx.channels = channels ctx.options = options ctx.resolution = resolution ctx.viewport = viewport ctx.scene = scene ctx.camera = camera ctx.shapes = shapes ctx.materials = materials ctx.area_lights = area_lights ctx.envmap = envmap ctx.scene = scene ctx.options = options ctx.num_samples = num_samples return ctx
def forward(ctx, seed, *args): """ Forward rendering pass: given a serialized scene and output an image. """ # Unpack arguments current_index = 0 num_shapes = args[current_index] current_index += 1 num_materials = args[current_index] current_index += 1 num_lights = args[current_index] current_index += 1 cam_position = args[current_index] current_index += 1 cam_look_at = args[current_index] current_index += 1 cam_up = args[current_index] current_index += 1 cam_to_world = args[current_index] current_index += 1 world_to_cam = args[current_index] current_index += 1 intrinsic_mat_inv = args[current_index] current_index += 1 intrinsic_mat = args[current_index] current_index += 1 clip_near = args[current_index] current_index += 1 resolution = args[current_index] current_index += 1 camera_type = args[current_index] current_index += 1 if cam_to_world is None: camera = redner.Camera( resolution[1], resolution[0], redner.float_ptr(cam_position.data_ptr()), redner.float_ptr(cam_look_at.data_ptr()), redner.float_ptr(cam_up.data_ptr()), redner.float_ptr(0), # cam_to_world redner.float_ptr(0), # world_to_cam redner.float_ptr(intrinsic_mat_inv.data_ptr()), redner.float_ptr(intrinsic_mat.data_ptr()), clip_near, camera_type) else: camera = redner.Camera( resolution[1], resolution[0], redner.float_ptr(0), # cam_position redner.float_ptr(0), # cam_look_at redner.float_ptr(0), # cam_up redner.float_ptr(cam_to_world.data_ptr()), redner.float_ptr(world_to_cam.data_ptr()), redner.float_ptr(intrinsic_mat_inv.data_ptr()), redner.float_ptr(intrinsic_mat.data_ptr()), clip_near, camera_type) shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 uv_indices = args[current_index] current_index += 1 normal_indices = args[current_index] current_index += 1 colors = args[current_index] current_index += 1 material_id = args[current_index] current_index += 1 light_id = args[current_index] current_index += 1 assert (vertices.is_contiguous()) assert (indices.is_contiguous()) if uvs is not None: assert (uvs.is_contiguous()) if normals is not None: assert (normals.is_contiguous()) if uv_indices is not None: assert (uv_indices.is_contiguous()) if normal_indices is not None: assert (normal_indices.is_contiguous()) shapes.append(redner.Shape(\ 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), redner.int_ptr(normal_indices.data_ptr() if normal_indices is not None else 0), redner.float_ptr(colors.data_ptr() if colors is not None else 0), int(vertices.shape[0]), int(uvs.shape[0]) if uvs is not None else 0, int(normals.shape[0]) if normals is not None else 0, int(indices.shape[0]), material_id, light_id)) materials = [] for i in range(num_materials): diffuse_reflectance = args[current_index] current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 diffuse_mesh_colors_resolution = args[current_index] current_index += 1 specular_reflectance = args[current_index] current_index += 1 specular_uv_scale = args[current_index] current_index += 1 specular_mesh_colors_resolution = args[current_index] current_index += 1 roughness = args[current_index] current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 roughness_mesh_colors_resolution = args[current_index] current_index += 1 generic_texture = args[current_index] current_index += 1 generic_uv_scale = args[current_index] current_index += 1 generic_mesh_colors_resolution = args[current_index] current_index += 1 normal_map = args[current_index] current_index += 1 normal_map_uv_scale = args[current_index] current_index += 1 normal_map_mesh_colors_resolution = args[current_index] current_index += 1 compute_specular_lighting = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 use_vertex_color = args[current_index] current_index += 1 assert (diffuse_reflectance.is_contiguous()) if diffuse_reflectance.dim() == 1: num_levels = 0 height = 0 if diffuse_mesh_colors_resolution > 0: num_levels = 1 height = int(diffuse_reflectance.size()[0] / 3 / int( ((diffuse_mesh_colors_resolution + 1) * (diffuse_mesh_colors_resolution + 2)) / 2)) diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), 0, height, 3, num_levels, diffuse_mesh_colors_resolution, redner.float_ptr(diffuse_uv_scale.data_ptr())) else: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), int(diffuse_reflectance.shape[2]), # width int(diffuse_reflectance.shape[1]), # height int(diffuse_reflectance.shape[3]), # channels int(diffuse_reflectance.shape[0]), # num levels 0, # mesh_colors_resolution redner.float_ptr(diffuse_uv_scale.data_ptr())) assert (specular_reflectance.is_contiguous()) if specular_reflectance.dim() == 1: num_levels = 0 height = 0 if specular_mesh_colors_resolution > 0: num_levels = 1 height = int(specular_reflectance.size()[0] / 3 / int( ((specular_mesh_colors_resolution + 1) * (specular_mesh_colors_resolution + 2)) / 2)) specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), 0, height, 3, num_levels, specular_mesh_colors_resolution, redner.float_ptr(specular_uv_scale.data_ptr())) else: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), int(specular_reflectance.shape[2]), # width int(specular_reflectance.shape[1]), # height int(specular_reflectance.shape[3]), # channels int(specular_reflectance.shape[0]), # num levels 0, # mesh_colors_resolution redner.float_ptr(specular_uv_scale.data_ptr())) assert (roughness.is_contiguous()) if roughness.dim() == 1: num_levels = 0 height = 0 if roughness_mesh_colors_resolution > 0: num_levels = 1 height = int(roughness.size()[0] / int( ((roughness_mesh_colors_resolution + 1) * (roughness_mesh_colors_resolution + 2)) / 2)) roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), 0, height, 1, num_levels, roughness_mesh_colors_resolution, redner.float_ptr(roughness_uv_scale.data_ptr())) else: assert (roughness.dim() == 4) roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), int(roughness.shape[2]), # width int(roughness.shape[1]), # height int(roughness.shape[3]), # channels int(roughness.shape[0]), # num levels 0, # mesh_colors_resolution redner.float_ptr(roughness_uv_scale.data_ptr())) if generic_texture is not None: if generic_texture.dim() == 1: num_levels = 0 height = 0 if generic_mesh_colors_resolution > 0: num_levels = 1 height = int( roughness.size()[0] / int(generic_texture.shape[3]) / int( ((generic_mesh_colors_resolution + 1) * (generic_mesh_colors_resolution + 2)) / 2)) generic_texture = redner.TextureN(\ redner.float_ptr(generic_texture.data_ptr()), 0, height, int(generic_texture.shape[3]), num_levels, generic_mesh_colors_resolution, redner.float_ptr(generic_uv_scale.data_ptr())) else: assert (generic_texture.dim() == 4) generic_texture = redner.TextureN(\ redner.float_ptr(generic_texture.data_ptr()), int(generic_texture.shape[2]), # width int(generic_texture.shape[1]), # height int(generic_texture.shape[3]), # channels int(generic_texture.shape[0]), # num levels 0, # mesh_colors_resolution redner.float_ptr(generic_uv_scale.data_ptr())) else: generic_texture = redner.TextureN(\ redner.float_ptr(0), 0, 0, 0, 0, 0, redner.float_ptr(0)) if normal_map is not None: if normal_map.dim() == 1: num_levels = 0 height = 0 if normal_map_mesh_colors_resolution > 0: num_levels = 1 height = int(normal_map.size()[0] / 3 / int( ((normal_map_mesh_colors_resolution + 1) * (normal_map_mesh_colors_resolution + 2)) / 2)) normal_map = redner.Texture3(\ redner.float_ptr(normal_map.data_ptr()), 0, height, 3, num_levels, normal_map_mesh_colors_resolution, redner.float_ptr(normal_map_uv_scale.data_ptr())) else: assert (normal_map.dim() == 4) normal_map = redner.Texture3(\ redner.float_ptr(normal_map.data_ptr()), int(normal_map.shape[2]), # width int(normal_map.shape[1]), # height int(normal_map.shape[3]), # channels int(normal_map.shape[0]), # num levels 0, # mesh_colors_resolution redner.float_ptr(normal_map_uv_scale.data_ptr())) else: normal_map = redner.Texture3(\ redner.float_ptr(0), 0, 0, 0, 0, 0, redner.float_ptr(0)) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, generic_texture, normal_map, compute_specular_lighting, two_sided, use_vertex_color)) area_lights = [] for i in range(num_lights): shape_id = args[current_index] current_index += 1 intensity = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 area_lights.append(redner.AreaLight(\ shape_id, redner.float_ptr(intensity.data_ptr()), two_sided)) envmap = None if args[current_index] is not None: values = args[current_index] current_index += 1 envmap_uv_scale = args[current_index] current_index += 1 env_to_world = args[current_index] current_index += 1 world_to_env = args[current_index] current_index += 1 sample_cdf_ys = args[current_index] current_index += 1 sample_cdf_xs = args[current_index] current_index += 1 pdf_norm = args[current_index] current_index += 1 values = redner.Texture3(\ redner.float_ptr(values.data_ptr()), int(values.shape[2]), # width int(values.shape[1]), # height 0, # channels int(values.shape[0]), # num levels 0, #mesh_colors_resolution redner.float_ptr(envmap_uv_scale.data_ptr())) envmap = redner.EnvironmentMap(\ values, redner.float_ptr(env_to_world.data_ptr()), redner.float_ptr(world_to_env.data_ptr()), redner.float_ptr(sample_cdf_ys.data_ptr()), redner.float_ptr(sample_cdf_xs.data_ptr()), pdf_norm) else: current_index += 7 # Options num_samples = args[current_index] current_index += 1 max_bounces = args[current_index] current_index += 1 channels = args[current_index] current_index += 1 sampler_type = args[current_index] current_index += 1 use_primary_edge_sampling = args[current_index] current_index += 1 use_secondary_edge_sampling = args[current_index] current_index += 1 start = time.time() scene = redner.Scene( camera, shapes, materials, area_lights, envmap, pyredner.get_use_gpu(), pyredner.get_device().index if pyredner.get_device().index is not None else -1, use_primary_edge_sampling, use_secondary_edge_sampling) time_elapsed = time.time() - start if print_timing: print('Scene construction, time: %.5f s' % time_elapsed) # check that num_samples is a tuple if isinstance(num_samples, int): num_samples = (num_samples, num_samples) options = redner.RenderOptions(seed, num_samples[0], max_bounces, channels, sampler_type) num_channels = redner.compute_num_channels( channels, scene.max_generic_texture_dimension) rendered_image = torch.zeros(resolution[0], resolution[1], num_channels, device=pyredner.get_device()) start = time.time() redner.render(scene, options, redner.float_ptr(rendered_image.data_ptr()), redner.float_ptr(0), None, redner.float_ptr(0)) time_elapsed = time.time() - start if print_timing: print('Forward pass, time: %.5f s' % time_elapsed) # # For debugging # debug_img = torch.zeros(256, 256, 3) # redner.render(scene, # options, # redner.float_ptr(rendered_image.data_ptr()), # redner.float_ptr(0), # None, # redner.float_ptr(debug_img.data_ptr())) # pyredner.imwrite(debug_img, 'debug.exr') # exit() ctx.camera = camera ctx.shapes = shapes ctx.materials = materials ctx.area_lights = area_lights ctx.envmap = envmap ctx.scene = scene ctx.options = options ctx.num_samples = num_samples ctx.args = args # Important to prevent GC from deallocating the tensors return rendered_image
def forward(ctx, seed, *args): """ Forward rendering pass: given a scene and output an image. """ # Unpack arguments current_index = 0 num_shapes = args[current_index] current_index += 1 num_materials = args[current_index] current_index += 1 num_lights = args[current_index] current_index += 1 cam_position = args[current_index] current_index += 1 cam_look_at = args[current_index] current_index += 1 cam_up = args[current_index] current_index += 1 ndc_to_cam = args[current_index] current_index += 1 cam_to_ndc = args[current_index] current_index += 1 clip_near = args[current_index] current_index += 1 resolution = args[current_index] current_index += 1 fisheye = args[current_index] current_index += 1 camera = redner.Camera(resolution[1], resolution[0], redner.float_ptr(cam_position.data_ptr()), redner.float_ptr(cam_look_at.data_ptr()), redner.float_ptr(cam_up.data_ptr()), redner.float_ptr(ndc_to_cam.data_ptr()), redner.float_ptr(cam_to_ndc.data_ptr()), clip_near, fisheye) shapes = [] for i in range(num_shapes): vertices = args[current_index] current_index += 1 indices = args[current_index] current_index += 1 uvs = args[current_index] current_index += 1 normals = args[current_index] current_index += 1 material_id = args[current_index] current_index += 1 light_id = args[current_index] current_index += 1 assert(vertices.is_contiguous()) assert(indices.is_contiguous()) if uvs is not None: assert(uvs.is_contiguous()) if normals is not None: assert(normals.is_contiguous()) shapes.append(redner.Shape(\ 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), int(vertices.shape[0]), int(indices.shape[0]), material_id, light_id)) materials = [] for i in range(num_materials): diffuse_reflectance = args[current_index] current_index += 1 diffuse_uv_scale = args[current_index] current_index += 1 specular_reflectance = args[current_index] current_index += 1 specular_uv_scale = args[current_index] current_index += 1 roughness = args[current_index] current_index += 1 roughness_uv_scale = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 assert(diffuse_reflectance.is_contiguous()) if diffuse_reflectance.dim() == 1: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), 0, 0, 0, redner.float_ptr(diffuse_uv_scale.data_ptr())) else: diffuse_reflectance = redner.Texture3(\ redner.float_ptr(diffuse_reflectance.data_ptr()), int(diffuse_reflectance.shape[2]), # width int(diffuse_reflectance.shape[1]), # height int(diffuse_reflectance.shape[0]), # num levels redner.float_ptr(diffuse_uv_scale.data_ptr())) assert(specular_reflectance.is_contiguous()) if specular_reflectance.dim() == 1: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), 0, 0, 0, redner.float_ptr(specular_uv_scale.data_ptr())) else: specular_reflectance = redner.Texture3(\ redner.float_ptr(specular_reflectance.data_ptr()), int(specular_reflectance.shape[2]), # width int(specular_reflectance.shape[1]), # height int(specular_reflectance.shape[0]), # num levels redner.float_ptr(specular_uv_scale.data_ptr())) assert(roughness.is_contiguous()) if roughness.dim() == 1: roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), 0, 0, 0, redner.float_ptr(roughness_uv_scale.data_ptr())) else: assert(roughness.dim() == 4) roughness = redner.Texture1(\ redner.float_ptr(roughness.data_ptr()), int(roughness.shape[2]), # width int(roughness.shape[1]), # height int(roughness.shape[0]), # num levels redner.float_ptr(roughness_uv_scale.data_ptr())) materials.append(redner.Material(\ diffuse_reflectance, specular_reflectance, roughness, two_sided)) area_lights = [] for i in range(num_lights): shape_id = args[current_index] current_index += 1 intensity = args[current_index] current_index += 1 two_sided = args[current_index] current_index += 1 area_lights.append(redner.AreaLight(\ shape_id, redner.float_ptr(intensity.data_ptr()), two_sided)) envmap = None if args[current_index] is not None: values = args[current_index] current_index += 1 envmap_uv_scale = args[current_index] current_index += 1 env_to_world = args[current_index] current_index += 1 world_to_env = args[current_index] current_index += 1 sample_cdf_ys = args[current_index] current_index += 1 sample_cdf_xs = args[current_index] current_index += 1 pdf_norm = args[current_index] current_index += 1 values = redner.Texture3(\ redner.float_ptr(values.data_ptr()), int(values.shape[2]), # width int(values.shape[1]), # height int(values.shape[0]), # num levels redner.float_ptr(envmap_uv_scale.data_ptr())) envmap = redner.EnvironmentMap(\ values, redner.float_ptr(env_to_world.data_ptr()), redner.float_ptr(world_to_env.data_ptr()), redner.float_ptr(sample_cdf_ys.data_ptr()), redner.float_ptr(sample_cdf_xs.data_ptr()), pdf_norm) else: current_index += 7 start = time.time() scene = redner.Scene(camera, shapes, materials, area_lights, envmap, pyredner.get_use_gpu(), pyredner.get_device().index if pyredner.get_device().index is not None else -1) time_elapsed = time.time() - start if print_timing: print('Scene construction, time: %.5f s' % time_elapsed) num_samples = args[current_index] current_index += 1 max_bounces = args[current_index] current_index += 1 channels = args[current_index] current_index += 1 sampler_type = args[current_index] current_index += 1 # check that num_samples is a tuple if isinstance(num_samples, int): num_samples = (num_samples, num_samples) options = redner.RenderOptions(seed, num_samples[0], max_bounces, channels, sampler_type) num_channels = redner.compute_num_channels(channels) rendered_image = torch.zeros(resolution[0], resolution[1], num_channels, device = pyredner.get_device()) start = time.time() redner.render(scene, options, redner.float_ptr(rendered_image.data_ptr()), redner.float_ptr(0), None, redner.float_ptr(0)) time_elapsed = time.time() - start if print_timing: print('Forward pass, time: %.5f s' % time_elapsed) # # For debugging # debug_img = torch.zeros(256, 256, 3) # redner.render(scene, # options, # redner.float_ptr(rendered_image.data_ptr()), # redner.float_ptr(0), # None, # redner.float_ptr(debug_img.data_ptr())) # pyredner.imwrite(debug_img, 'debug.exr') # exit() ctx.shapes = shapes ctx.materials = materials ctx.area_lights = area_lights ctx.envmap = envmap ctx.scene = scene ctx.options = options ctx.num_samples = num_samples return rendered_image