def visual_vertex_grad(vertices: torch.Tensor,
indices: torch.Tensor,
cam: pyredner.Camera = None):
if not hasattr(visual_vertex_grad, 'x'):
visual_vertex_grad.x = 0
else:
visual_vertex_grad.x += 1
cam = pyredner.Camera(
position=cam_pos,
look_at=cam_look_at, # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=(1000, 1000))
m = pyredner.Material(use_vertex_color=True)
obj = pyredner.Object(vertices=vertices, indices=indices, material=m)
coe = 500000.
color_reps = torch.tensor([[[1., 0., 0.], [0., -1., -1.]],
[[0., 1., 0.], [-1., 0., -1.]],
[[0., 0., 1.], [-1., -1.,
0.]]]).to(pyredner.get_device())
grad_imgs = []
for d in range(3):
colors = torch.where(
vertices.grad[:, d:d + 1].expand(-1, 3) > 0,
vertices.grad[:, d:d + 1].expand(-1, 3) * color_reps[d, 0],
vertices.grad[:, d:d + 1].expand(-1, 3) * color_reps[d, 1]) * coe
obj.colors = colors
scene = pyredner.Scene(camera=cam, objects=[obj])
grad_imgs.append(pyredner.render_albedo(scene=scene))
for d in range(3):
pyredner.imwrite(
grad_imgs[d].cpu(), output_path +
'/grad_imgs/{:0>2d}{:0>2d}.png'.format(d, visual_vertex_grad.x))
return grad_imgs
def model(cam_pos, cam_look_at, vertices, color_coeffs, ambient_color,
dir_light_intensity, dir_light_direction):
#vertices = (shape_mean + shape_basis @ torch.zeros(199, device=pyredner.get_device())).view(-1, 3)
normals = pyredner.compute_vertex_normal(vertices, indices)
colors = (color_mean + color_basis @ color_coeffs).view(-1, 3)
#m = pyredner.Material(use_vertex_color=True)
m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5]))
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
material=m,
colors=colors)
cam = pyredner.Camera(
position=cam_pos,
look_at=cam_look_at, # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=(512, 512))
scene = pyredner.Scene(camera=cam, objects=[obj])
ambient_light = pyredner.AmbientLight(ambient_color)
dir_light = pyredner.DirectionalLight(dir_light_direction,
dir_light_intensity)
img = pyredner.render_deferred(scene=scene,
lights=[ambient_light, dir_light])
return img, obj
def model(cam_pos, cam_look_at, vertices, indices, ambient_color,
dir_light_intensity, dir_light_direction, normals, colors):
#normals = pyredner.compute_vertex_normal(vertices, indices, normal_scheme)
#m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5]))
m = pyredner.Material(use_vertex_color=True)
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
material=m,
colors=colors)
cam = pyredner.Camera(
position=cam_pos,
look_at=cam_look_at, # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=(1000, 1000))
scene = pyredner.Scene(camera=cam, objects=[obj])
ambient_light = pyredner.AmbientLight(ambient_color)
dir_light = pyredner.DirectionalLight(dir_light_direction,
dir_light_intensity)
img = pyredner.render_deferred(scene=scene,
lights=[ambient_light, dir_light],
aa_samples=1)
return img
def model(cam_poses, cam_look_at, shape_coeffs, color_coeffs, lights_list,
resolution):
vertices = (shape_mean + shape_basis @ shape_coeffs).view(-1, 3)
normals = pyredner.compute_vertex_normal(vertices, indices)
colors = (color_mean + color_basis @ color_coeffs).view(-1, 3)
#m = pyredner.Material(diffuse_reflectance = torch.tensor([0.5, 0.5, 0.5]))
m = pyredner.Material(use_vertex_color=True)
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
material=m,
colors=colors)
imgs = []
for i in range(cam_poses.size(0)):
cam = pyredner.Camera(
position=cam_poses[i],
look_at=cam_look_at, # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=resolution)
scene = pyredner.Scene(camera=cam, objects=[obj])
#ambient_light = pyredner.AmbientLight(ambient_color)
#dir_light = pyredner.DirectionalLight(dir_light_direction, dir_light_intensity)
img = pyredner.render_deferred(scene=scene,
lights=lights_list[i %
len(lights_list)],
aa_samples=1)
imgs.append(img)
return imgs, obj
def grad_image(self):
grads = torch.clone(self.mesh.vertices.grad).detach()
vcolormat = pyr.Material(use_vertex_color=True)
grads_mag = torch.abs(grads)
vcolors = (grads_mag - grads_mag.min()) / (grads_mag.max()-grads_mag.min())
gradobj = pyr.Object(self.mesh.vertices, self.mesh.indices, material=vcolormat, normals=self.mesh.normals, colors=vcolors)
cameras = self.settings[0]
gradscenes = [pyr.Scene(c, objects=[gradobj]) for c in cameras]
grads_rendered = pyr.render_albedo(gradscenes)
return grads_rendered
def generate_quad_light(position: torch.Tensor,
look_at: torch.Tensor,
size: torch.Tensor,
intensity: torch.Tensor,
directly_visible: Optional[bool] = None):
"""
Generate a pyredner.Object that is a quad light source.
Args
====
position: torch.Tensor
1-d tensor of size 3
look_at: torch.Tensor
1-d tensor of size 3
size: torch.Tensor
1-d tensor of size 2
intensity: torch.Tensor
1-d tensor of size 3
directly_visible: Optional[bool]
Can the camera see the light source directly?
Returns
=======
pyredner.Object
quad light source
"""
d = look_at - position
d = d / torch.norm(d)
# ONB -- generate two axes that are orthogonal to d
a = 1 / (1 + d[2])
b = -d[0] * d[1] * a
x = torch.where(d[2] < (-1 + 1e-6),
torch.tensor([0.0, -1.0, 0.0], device = d.device),
torch.stack([1 - d[0] * d[0] * a, b, -d[0]]))
y = torch.where(d[2] < (-1 + 1e-6),
torch.tensor([-1.0, 0.0, 0.0], device = d.device),
torch.stack([b, 1 - d[1] * d[1] * a, -d[1]]))
v0 = position - x * size[0] * 0.5 - y * size[1] * 0.5
v1 = position + x * size[0] * 0.5 - y * size[1] * 0.5
v2 = position - x * size[0] * 0.5 + y * size[1] * 0.5
v3 = position + x * size[0] * 0.5 + y * size[1] * 0.5
vertices = torch.stack((v0, v1, v2, v3), dim = 0).to(d.device)
indices = torch.tensor([[0, 1, 2],[1, 3, 2]],
dtype = torch.int32, device = d.device)
m = pyredner.Material(diffuse_reflectance = torch.tensor([0.0, 0.0, 0.0], device = d.device))
return pyredner.Object(vertices = vertices,
indices = indices,
material = m,
light_intensity = intensity,
directly_visible = directly_visible)
def model(cam_pos, cam_look_at, shape_coeffs, color_coeffs, resolution, center,
all_euler_angles, all_translations):
# First rotate around center, then translation
imgs = []
#obj = pyredner.load_obj('p_ones30/final.obj', return_objects=True)[0]
vertices, indices, uvs, normals = pyredner.generate_sphere(128, 64)
vertices *= 80
m = pyredner.Material(
diffuse_reflectance=torch.ones(2, 2, 3, dtype=torch.float32))
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
uvs=uvs,
material=m)
v = obj.vertices.clone()
for i in range(len(all_translations)):
rotation_matrix = pyredner.gen_rotate_matrix(all_euler_angles[i]).to(
pyredner.get_device())
center = center.to(pyredner.get_device())
# vertices = ((shape_mean + shape_basis @ shape_coeffs).view(-1, 3) - center) @ torch.t(rotation_matrix) + center + all_translations[i].to(pyredner.get_device())
obj.vertices = (v - center) @ torch.t(rotation_matrix) + center
obj.normals = pyredner.compute_vertex_normal(obj.vertices, indices)
# colors = (color_mean + color_basis @ color_coeffs).view(-1, 3)
# m = pyredner.Material(diffuse_reflectance = torch.tensor([0.5, 0.5, 0.5]))
m = pyredner.Material(use_vertex_color=True)
# obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m, colors=colors)
if i == 0:
pyredner.save_obj(obj,
"generated/env_dataset_" + name + '/tgt_obj.obj')
cam = pyredner.Camera(
position=cam_pos,
look_at=cam_look_at, # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=resolution)
scene = pyredner.Scene(camera=cam, objects=[obj], envmap=envmap)
img = pyredner.render_pathtracing(scene=scene, num_samples=(128, 4))
imgs.append(img)
return imgs
def model(cam_poses, cam_look_ats, shape_coeffs, color_coeffs, resolution):
# First rotate around center, then translation
imgs = []
vertices = (shape_mean + shape_basis @ shape_coeffs).view(-1, 3)
normals = pyredner.compute_vertex_normal(vertices, indices)
colors = (color_mean + color_basis @ color_coeffs).view(-1, 3)
m = pyredner.Material(use_vertex_color=False,
specular_reflectance=torch.tensor(
[1., 1., 1.], device=pyredner.get_device()),
roughness=torch.tensor([0.02]))
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
material=m,
colors=colors)
obj = pyredner.load_obj('generated/env_dataset_oness_n/tgt_obj.obj',
return_objects=True)[0]
obj.material.specular_reflectance = pyredner.Texture(
torch.tensor([0.05, 0.05, 0.05], device=pyredner.get_device()))
obj.material.roughness = pyredner.Texture(torch.tensor([0.02]))
pyredner.save_obj(obj, "generated/senv_dataset_" + name + '/tgt_obj.obj')
for i in range(len(cam_poses)):
cam = pyredner.Camera(
position=cam_poses[i],
look_at=cam_look_ats[i %
len(cam_look_ats)], # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=resolution)
scene = pyredner.Scene(camera=cam, objects=[obj], envmap=envmap)
img = pyredner.render_pathtracing(scene=scene, num_samples=(128, 4))
imgs.append(img)
return imgs
def model(cam_poses, cam_look_at, vertices, lights_list, normals, material):
# m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5]))
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
material=material,
uvs=uvs,
uv_indices=uv_indices) # , colors=colors)
imgs = []
for i in range(cam_poses.size(0)):
cam = pyredner.Camera(
position=cam_poses[i],
look_at=cam_look_at, # Center of the vertices
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([45.0]),
resolution=(1000, 1000))
scene = pyredner.Scene(camera=cam, objects=[obj])
img = pyredner.render_deferred(scene=scene,
lights=lights_list[i %
len(lights_list)],
aa_samples=1)
imgs.append(img)
return imgs
def load_obj(filename: str,
obj_group: bool = True,
flip_tex_coords: bool = True,
use_common_indices: bool = False,
return_objects: bool = False):
"""
Load from a Wavefront obj file as PyTorch tensors.
Args
====
obj_group: bool
split the meshes based on materials
flip_tex_coords: bool
flip the v coordinate of uv by applying v' = 1 - v
use_common_indices: bool
Use the same indices for position, uvs, normals.
Not recommended since texture seams in the objects sharing
the same positions would cause the optimization to "tear" the object
return_objects: bool
Output list of Object instead.
If there is no corresponding material for a shape, assign a grey material.
Returns
=======
if return_objects == True, return a list of Object
if return_objects == False, return (material_map, mesh_list, light_map),
material_map -> Map[mtl_name, WavefrontMaterial]
mesh_list -> List[TriangleMesh]
light_map -> Map[mtl_name, torch.Tensor]
"""
vertices_pool = []
uvs_pool = []
normals_pool = []
indices = []
uv_indices = []
normal_indices = []
vertices = []
uvs = []
normals = []
vertices_map = {}
uvs_map = {}
normals_map = {}
material_map = {}
current_mtllib = {}
current_material_name = None
def create_mesh(indices, uv_indices, normal_indices, vertices, uvs,
normals):
indices = torch.tensor(indices,
dtype=torch.int32,
device=pyredner.get_device())
if len(uv_indices) == 0:
uv_indices = None
else:
uv_indices = torch.tensor(uv_indices,
dtype=torch.int32,
device=pyredner.get_device())
if len(normal_indices) == 0:
normal_indices = None
else:
normal_indices = torch.tensor(normal_indices,
dtype=torch.int32,
device=pyredner.get_device())
vertices = torch.tensor(vertices, device=pyredner.get_device())
if len(uvs) == 0:
uvs = None
else:
uvs = torch.tensor(uvs, device=pyredner.get_device())
if len(normals) == 0:
normals = None
else:
normals = torch.tensor(normals, device=pyredner.get_device())
return TriangleMesh(indices, uv_indices, normal_indices, vertices, uvs,
normals)
mesh_list = []
light_map = {}
with open(filename, 'r') as f:
d = os.path.dirname(filename)
cwd = os.getcwd()
if d != '':
os.chdir(d)
for line in f:
line = line.strip()
splitted = re.split('\ +', line)
if splitted[0] == 'mtllib':
current_mtllib = load_mtl(splitted[1])
elif splitted[0] == 'usemtl':
if len(indices) > 0 and obj_group is True:
# Flush
mesh_list.append(
(current_material_name,
create_mesh(indices, uv_indices, normal_indices,
vertices, uvs, normals)))
indices = []
uv_indices = []
normal_indices = []
vertices = []
normals = []
uvs = []
vertices_map = {}
uvs_map = {}
normals_map = {}
mtl_name = splitted[1]
current_material_name = mtl_name
if mtl_name not in material_map:
m = current_mtllib[mtl_name]
if m.map_Kd is None:
diffuse_reflectance = torch.tensor(
m.Kd,
dtype=torch.float32,
device=pyredner.get_device())
else:
diffuse_reflectance = pyredner.imread(m.map_Kd)
if pyredner.get_use_gpu():
diffuse_reflectance = diffuse_reflectance.cuda(
device=pyredner.get_device())
if m.map_Ks is None:
specular_reflectance = torch.tensor(
m.Ks,
dtype=torch.float32,
device=pyredner.get_device())
else:
specular_reflectance = pyredner.imread(m.map_Ks)
if pyredner.get_use_gpu():
specular_reflectance = specular_reflectance.cuda(
device=pyredner.get_device())
if m.map_Ns is None:
roughness = torch.tensor([2.0 / (m.Ns + 2.0)],
dtype=torch.float32,
device=pyredner.get_device())
else:
roughness = 2.0 / (pyredner.imread(m.map_Ks) + 2.0)
if pyredner.get_use_gpu():
roughness = roughness.cuda(
device=pyredner.get_device())
if m.Ke != (0.0, 0.0, 0.0):
light_map[mtl_name] = torch.tensor(m.Ke,
dtype=torch.float32)
material_map[mtl_name] = pyredner.Material(\
diffuse_reflectance, specular_reflectance, roughness)
elif splitted[0] == 'v':
vertices_pool.append([
float(splitted[1]),
float(splitted[2]),
float(splitted[3])
])
elif splitted[0] == 'vt':
u = float(splitted[1])
v = float(splitted[2])
if flip_tex_coords:
v = 1 - v
uvs_pool.append([u, v])
elif splitted[0] == 'vn':
normals_pool.append([
float(splitted[1]),
float(splitted[2]),
float(splitted[3])
])
elif splitted[0] == 'f':
def num_indices(x):
return len(re.split('/', x))
def get_index(x, i):
return int(re.split('/', x)[i])
def parse_face_index(x, i):
f = get_index(x, i)
if f > 0:
f -= 1
return f
assert (len(splitted) <= 5)
def get_vertex_id(indices):
pi = parse_face_index(indices, 0)
uvi = None
if (num_indices(indices) > 1
and re.split('/', indices)[1] != ''):
uvi = parse_face_index(indices, 1)
ni = None
if (num_indices(indices) > 2
and re.split('/', indices)[2] != ''):
ni = parse_face_index(indices, 2)
if use_common_indices:
# vertex, uv, normals share the same indexing
key = (pi, uvi, ni)
if key in vertices_map:
vertex_id = vertices_map[key]
return vertex_id, vertex_id, vertex_id
vertex_id = len(vertices)
vertices_map[key] = vertex_id
vertices.append(vertices_pool[pi])
if uvi is not None:
uvs.append(uvs_pool[uvi])
if ni is not None:
normals.append(normals_pool[ni])
return vertex_id, vertex_id, vertex_id
else:
# vertex, uv, normals use separate indexing
vertex_id = None
uv_id = None
normal_id = None
if pi in vertices_map:
vertex_id = vertices_map[pi]
else:
vertex_id = len(vertices)
vertices.append(vertices_pool[pi])
vertices_map[pi] = vertex_id
if uvi is not None:
if uvi in uvs_map:
uv_id = uvs_map[uvi]
else:
uv_id = len(uvs)
uvs.append(uvs_pool[uvi])
uvs_map[uvi] = uv_id
if ni is not None:
if ni in normals_map:
normal_id = normals_map[ni]
else:
normal_id = len(normals)
normals.append(normals_pool[ni])
normals_map[ni] = normal_id
return vertex_id, uv_id, normal_id
vid0, uv_id0, n_id0 = get_vertex_id(splitted[1])
vid1, uv_id1, n_id1 = get_vertex_id(splitted[2])
vid2, uv_id2, n_id2 = get_vertex_id(splitted[3])
indices.append([vid0, vid1, vid2])
if uv_id0 is not None:
assert (uv_id1 is not None and uv_id2 is not None)
uv_indices.append([uv_id0, uv_id1, uv_id2])
if n_id0 is not None:
assert (n_id1 is not None and n_id2 is not None)
normal_indices.append([n_id0, n_id1, n_id2])
if (len(splitted) == 5):
vid3, uv_id3, n_id3 = get_vertex_id(splitted[4])
indices.append([vid0, vid2, vid3])
if uv_id0 is not None:
assert (uv_id3 is not None)
uv_indices.append([uv_id0, uv_id2, uv_id3])
if n_id0 is not None:
assert (n_id3 is not None)
normal_indices.append([n_id0, n_id2, n_id3])
mesh_list.append((current_material_name,
create_mesh(indices, uv_indices, normal_indices,
vertices, uvs, normals)))
if d != '':
os.chdir(cwd)
if return_objects:
objects = []
for mtl_name, mesh in mesh_list:
if mtl_name in material_map:
m = material_map[mtl_name]
else:
m = pyredner.Material(diffuse_reflectance = \
torch.tensor((0.5, 0.5, 0.5),
device = pyredner.get_device()))
if mtl_name in light_map:
l = light_map[mtl_name]
else:
l = None
objects.append(pyredner.Object(\
vertices = mesh.vertices,
indices = mesh.indices,
material = m,
light_intensity = l,
uvs = mesh.uvs,
normals = mesh.normals,
uv_indices = mesh.uv_indices,
normal_indices = mesh.normal_indices))
return objects
else:
return material_map, mesh_list, light_map
print(t)
texels = pyredner.imresize(texels, scale=2.).detach()
texels.requires_grad = True
tex_optimizer = torch.optim.Adam([texels], lr=0.05)
print(texels.size())
all_losses = torch.stack(all_losses).detach().cpu()
total_losses = torch.stack(total_losses).detach().cpu()
img_losses = torch.stack(img_losses).detach().cpu()
smooth_losses = torch.stack(smooth_losses).detach().cpu()
print()
obj = pyredner.Object(vertices=vertices,
indices=indices,
normals=normals,
material=m,
uvs=uvs,
uv_indices=uv_indices) # , colors=colors)
pyredner.save_obj(obj, output_path + '/final.obj')
# pyredner.imwrite(texels.data.cpu(), output_path + '/texels.png')
import matplotlib.pyplot as plt
plt.figure()
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
plt.suptitle(description + '\n' + str(vars(args))[1:-1].replace("'", ""),
fontsize=13,
color='blue')
plt.sca(ax1)
import torch
import pyredner
vertices, indices, uvs, normals = pyredner.generate_sphere(64, 128)
m = pyredner.Material(diffuse_reflectance=torch.tensor(
(0.5, 0.5, 0.5), device=pyredner.get_device()))
obj = pyredner.Object(vertices=vertices,
indices=indices,
uvs=uvs,
normals=normals,
material=m)
cam = pyredner.automatic_camera_placement([obj], resolution=(480, 640))
scene = pyredner.Scene(objects=[obj], camera=cam)
img = pyredner.render_g_buffer(
scene, channels=[pyredner.channels.uv, pyredner.channels.shading_normal])
uv_img = torch.cat([img[:, :, :2], torch.zeros(480, 640, 1)], dim=2)
normal_img = img[:, :, 2:]
pyredner.imwrite(uv_img, 'results/test_sphere/uv.png')
pyredner.imwrite(normal_img, 'results/test_sphere/normal.png')
total_loss.backward()
ver_optimizer.step()
vertices.data = vertices.data * bound.reshape(-1, 1).expand(-1, 3) + boundary
# normals_optimizer.step()
# normals.data = normals.data / normals.data.norm(dim=1).reshape(-1, 1).expand(-1, 3)
if 1:#smooth_scheme != 'none': # and t > 20:smi
for num_of_smooth in range(2):
pyredner.smooth(vertices, indices, smooth_lmd, smooth_scheme, bound)
pyredner.smooth(vertices, indices, -smooth_lmd, smooth_scheme, bound)
print("{:.^10}total_loss:{:.6f}...img_loss:{:.6f}...smooth_loss:{:.6f}".format(t, total_loss, img_loss, smooth_loss))
print()
m = pyredner.Material(diffuse_reflectance=torch.tensor([0.5, 0.5, 0.5]))
obj = pyredner.Object(vertices=vertices, indices=indices, normals=normals, material=m) # , colors=colors)
pyredner.save_obj(obj, output_path + '/final.obj')
if num_iters_2 > 0:
for t in range(num_iters_2):
total_loss = 0
normals = pyredner.compute_vertex_normal(vertices, indices, normal_scheme)
for i in range(len(cam_poses)):
cam_pos = torch.tensor(cam_poses[i])
dir_light_direction = torch.tensor(dir_light_directions[i % len(dir_light_directions)])
img = model(cam_pos, cam_look_at, vertices, ambient_color, dir_light_intensity, dir_light_direction, normals)
loss = (img - target[i]).pow(2).mean()
losses[i].append(loss.data.item())
total_loss += loss
def render(self, scene, svbrdf):
imgs = []
svbrdf = svbrdf.unsqueeze(0) if len(svbrdf.shape) == 3 else svbrdf
sensor_size = (svbrdf.shape[-1], svbrdf.shape[-2])
for svbrdf_single in torch.split(svbrdf, 1, dim=0):
normals, diffuse, roughness, specular = utils.unpack_svbrdf(
svbrdf_single.squeeze(0))
# Redner expects the normal map to be in range [0, 1]
normals = utils.encode_as_unit_interval(normals)
# Redner expects the roughness to have one channel only.
# We also need to convert from GGX roughness to Blinn-Phong power.
# See: https://github.com/iondune/csc473/blob/master/lectures/07-cook-torrance.md
roughness = torch.mean(torch.clamp(roughness, min=0.001),
dim=0,
keepdim=True)**4
# Convert from [c,h,w] to [h,w,c] for redner
normals = normals.permute(1, 2, 0)
diffuse = diffuse.permute(1, 2, 0)
roughness = roughness.permute(1, 2, 0)
specular = specular.permute(1, 2, 0)
material = pyredner.Material(
diffuse_reflectance=pyredner.Texture(
diffuse.to(self.redner_device)),
specular_reflectance=pyredner.Texture(
specular.to(self.redner_device)),
roughness=pyredner.Texture(roughness.to(self.redner_device)),
normal_map=pyredner.Texture(normals.to(self.redner_device)))
material_patch = pyredner.Object(vertices=self.patch_vertices,
uvs=self.patch_uvs,
indices=self.patch_indices,
material=material)
# Define the camera parameters (focused at the middle of the patch) and make sure we always have a valid 'up' direction
position = np.array(scene.camera.pos)
lookat = np.array([0.0, 0.0, 0.0])
cz = lookat - position # Principal axis
up = np.array([0.0, 0.0, 1.0])
if np.linalg.norm(np.cross(cz, up)) == 0.0:
up = np.array([0.0, 1.0, 0.0])
camera = pyredner.Camera(
position=torch.FloatTensor(position).to(self.redner_device),
look_at=torch.FloatTensor(lookat).to(self.redner_device),
up=torch.FloatTensor(up).to(self.redner_device),
fov=torch.FloatTensor([90]),
resolution=sensor_size,
camera_type=self.camera_type)
# # The deferred rendering path.
# # It does not have a specular model and therefore is of limited usability for us
# full_scene = pyredner.Scene(camera = camera, objects = [material_patch])
# light = pyredner.PointLight(position = torch.tensor(scene.light.pos).to(self.redner_device),
# intensity = torch.tensor(scene.light.color).to(self.redner_device))
# img = pyredner.render_deferred(scene = full_scene, lights = [light])
light = pyredner.generate_quad_light(
position=torch.Tensor(scene.light.pos).to(self.redner_device),
look_at=torch.zeros(3).to(self.redner_device),
size=torch.Tensor([0.6, 0.6]).to(self.redner_device),
intensity=torch.Tensor(scene.light.color).to(
self.redner_device))
full_scene = pyredner.Scene(camera=camera,
objects=[material_patch, light])
img = pyredner.render_pathtracing(full_scene, num_samples=(16, 8))
# Transform the rendered image back to something torch can interprete
imgs.append(img.permute(2, 0, 1).to(svbrdf.device))
return torch.stack(imgs)
checkerboard_texture = pyredner.imread('scenes/teapot.png')
if pyredner.get_use_gpu():
checkerboard_texture = checkerboard_texture.cuda(device = pyredner.get_device())
mat_checkerboard = pyredner.Material(\
diffuse_reflectance = checkerboard_texture)
mat_black = pyredner.Material(\
diffuse_reflectance = torch.tensor([0.0, 0.0, 0.0], device = pyredner.get_device()))
plane = pyredner.Object(vertices = torch.tensor([[-1.0,-1.0, 0.0],
[-1.0, 1.0, 0.0],
[ 1.0,-1.0, 0.0],
[ 1.0, 1.0, 0.0]],
device = pyredner.get_device()),
indices = torch.tensor([[0, 1, 2],
[1, 3, 2]],
dtype = torch.int32,
device = pyredner.get_device()),
uvs = torch.tensor([[0.05, 0.05],
[0.05, 0.95],
[0.95, 0.05],
[0.95, 0.95]], device = pyredner.get_device()),
material = mat_checkerboard)
scene = pyredner.Scene(camera=cam, objects=[plane])
img = pyredner.render_albedo(scene=scene)
pyredner.imwrite(img.cpu(), 'results/test_camera_distortion/target.exr')
pyredner.imwrite(img.cpu(), 'results/test_camera_distortion/target.png')
# Read the target image we just saved.
target = pyredner.imread('results/test_camera_distortion/target.exr')
if pyredner.get_use_gpu():
target = target.cuda(device = pyredner.get_device())
