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
