def forward(seed: int, *args):
"""
Forward rendering pass: given a serialized scene and output an image.
"""
args_ctx = unpack_args(seed, args)
area_lights = args_ctx.area_lights
camera = args_ctx.camera
channels = args_ctx.channels
envmap = args_ctx.envmap
materials = args_ctx.materials
num_samples = args_ctx.num_samples
options = args_ctx.options
resolution = args_ctx.resolution
viewport = args_ctx.viewport
scene = args_ctx.scene
shapes = args_ctx.shapes
num_channel_args = args_ctx.num_channel_args
num_channels = redner.compute_num_channels(
channels, scene.max_generic_texture_dimension)
with tf.device(pyredner.get_device_name()):
img_height = viewport[2] - viewport[0]
img_width = viewport[3] - viewport[1]
rendered_image = tf.zeros(shape=[img_height, img_width, num_channels],
dtype=tf.float32)
start = time.time()
redner.render(
scene,
options,
redner.float_ptr(pyredner.data_ptr(rendered_image)),
redner.float_ptr(0), # d_rendered_image
None, # d_scene
redner.float_ptr(0), # translational_gradient_image
redner.float_ptr(0)) # debug_image
time_elapsed = time.time() - start
if get_print_timing():
print('Forward pass, time: %.5f s' % time_elapsed)
ctx = Context()
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
ctx.args = args # important to avoid GC on tf tensors
return rendered_image, ctx
def forward(ctx,
seed,
*args):
"""
Forward rendering pass: given a serialized scene and output an image.
"""
args_ctx = RenderFunction.unpack_args(seed, args)
area_lights = args_ctx.area_lights
camera = args_ctx.camera
channels = args_ctx.channels
envmap = args_ctx.envmap
materials = args_ctx.materials
num_samples = args_ctx.num_samples
options = args_ctx.options
resolution = args_ctx.resolution
viewport = args_ctx.viewport
scene = args_ctx.scene
shapes = args_ctx.shapes
num_channels = redner.compute_num_channels(channels,
scene.max_generic_texture_dimension)
img_height = viewport[2] - viewport[0]
img_width = viewport[3] - viewport[1]
rendered_image = torch.zeros(img_height, img_width, num_channels,
device = pyredner.get_device())
start = time.time()
redner.render(scene,
options,
redner.float_ptr(rendered_image.data_ptr()),
redner.float_ptr(0), # d_rendered_image
None, # d_scene
redner.float_ptr(0), # translational_gradient_image
redner.float_ptr(0)) # debug_image
time_elapsed = time.time() - start
if get_print_timing():
print('Forward pass, time: %.5f s' % time_elapsed)
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 visualize_screen_gradient(grad_img: tf.Tensor,
seed: int,
scene: pyredner.Scene,
num_samples: Union[int, Tuple[int, int]],
max_bounces: int,
channels: List = [redner.channels.radiance],
sampler_type=redner.SamplerType.independent,
use_primary_edge_sampling: bool = True,
use_secondary_edge_sampling: bool = True,
sample_pixel_center: bool = False):
"""
Given a serialized scene and output an 2-channel image,
which visualizes the derivatives of pixel color with respect to
the screen space coordinates.
Args
====
grad_img: Optional[tf.Tensor]
The "adjoint" of the backpropagation gradient. If you don't know
what this means just give None
seed: int
seed for the Monte Carlo random samplers
See serialize_scene for the explanation of the rest of the arguments.
"""
args = serialize_scene(\
scene = scene,
num_samples = num_samples,
max_bounces = max_bounces,
sampler_type = sampler_type,
channels = channels,
sample_pixel_center = sample_pixel_center)
args_ctx = unpack_args(\
seed, args, use_primary_edge_sampling, use_secondary_edge_sampling)
channels = args_ctx.channels
options = args_ctx.options
resolution = args_ctx.resolution
viewport = args_ctx.viewport
scene = args_ctx.scene
buffers = create_gradient_buffers(args_ctx)
num_channels = redner.compute_num_channels(
channels, scene.max_generic_texture_dimension)
with tf.device(pyredner.get_device_name()):
img_height = viewport[2] - viewport[0]
img_width = viewport[3] - viewport[1]
screen_gradient_image = tf.zeros(\
shape = [img_height, img_width, 2],
dtype = tf.float32)
if grad_img is not None:
assert (grad_img.shape[0] == resolution[0])
assert (grad_img.shape[1] == resolution[1])
assert (grad_img.shape[2] == num_channels)
else:
grad_img = tf.ones(\
shape = [img_height, img_width, num_channels],
dtype = tf.float32)
start = time.time()
redner.render(
scene,
options,
redner.float_ptr(0), # rendered_image
redner.float_ptr(pyredner.data_ptr(grad_img)), # d_rendered_image
buffers.d_scene,
redner.float_ptr(pyredner.data_ptr(screen_gradient_image)),
redner.float_ptr(0)) # debug_image
time_elapsed = time.time() - start
if get_print_timing():
print('Visualize gradient, time: %.5f s' % time_elapsed)
return screen_gradient_image
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 forward(seed: int, *args):
"""
Forward rendering pass: given a serialized scene and output an image.
"""
ctx = 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
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)
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)
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
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]):
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
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)
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_channels = int(args[current_index])
current_index += 1
channels = []
for _ in range(__num_channels):
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 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)
num_channels = redner.compute_num_channels(
channels, scene.max_generic_texture_dimension)
with tf.device(pyredner.get_device_name()):
rendered_image = tf.zeros(
shape=[resolution[0], resolution[1], num_channels],
dtype=tf.float32)
start = time.time()
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)
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_channels = __num_channels
ctx.args = args # important to avoid GC on tf tensors
return rendered_image, 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
