def tex_model(optim_scenes, deferred, num_samples=(64, 64), max_bounces=1):
if deferred:
renders = pyredner.render_deferred(scene=optim_scenes)
else:
renders = pyredner.render_pathtracing(scene=optim_scenes,
num_samples=num_samples,
max_bounces=max_bounces)
return renders
def model(initial_verts, initial_normals, offsets, optim_objects,
use_vertex_offsets):
if use_vertex_offsets: # Vertex optim
optim_objects[0].vertices = initial_verts + offsets
else: # Normal optim
off = torch.stack([offsets, offsets, offsets], dim=1)
optim_objects[0].vertices = initial_verts + off * initial_normals
optim_scenes = generate_scenes(camLocs, optim_objects)
renders = pyredner.render_pathtracing(scene=optim_scenes,
num_samples=(64, 64),
max_bounces=1)
return renders
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 tex_model(optim_scenes, num_samples=(64, 64), max_bounces=1):
return pyredner.render_pathtracing(scene = optim_scenes, num_samples=num_samples, max_bounces=max_bounces)
target_objects[2].material = pyredner.Material(diffuse_reflectance=diffuse, specular_reflectance=specular_target, roughness=roughness, normal_map=normal_map, two_sided=True) resolution = (256, 256) num_cameras = 2 radius = float(sys.argv[5]) lightLocs = None camera0 = pyredner.automatic_camera_placement(target_objects, resolution) #camLocs = fibonacci_sphere(num_cameras, False) camLocs = [torch.tensor([-0.1, 0.1, 0.1])] target_scenes = generate_scenes(camLocs, target_objects, None, lightLocs) max_bounces_targets = 4 max_bounces_optim = 4 # Render Targets targets = pyredner.render_pathtracing(scene = target_scenes, num_samples = (512, 0), max_bounces=max_bounces_targets) for ind, img in enumerate(targets): img = img.data.cpu() pyredner.imwrite(img, path + "targets/target_" + str(ind) + ".png") #target_data = pyredner.imread( path + "targets/target_" + str(ind) + ".png") #targets[ind] = target_data target_texture = pyredner.render_albedo(scene = target_scenes, num_samples = (512, 0)) for ind, img in enumerate(target_texture): mask = img.clone() mask = mask.sum(2)/3 mask[mask < 0.8] = 0.0 mask = torch.stack([mask, mask, mask], dim=2)
shapes = []
shapes.append(target_obj1[0])
numShapes = len(shapes)
shapes.extend(lights)
area_lights = []
for i in range(numShapes, len(shapes)):
area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity, light_intensity, light_intensity])))
area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity*10, light_intensity*10, light_intensity*10])))
scene = pyredner.Scene(cam, objects = [shapes[0], shapes[1]],area_lights = [area_lights[0]], envmap = None)
scene_intense = pyredner.Scene(cam, objects = [shapes[0], shapes[1]], area_lights = [area_lights[1]], envmap = None)
target = pyredner.render_pathtracing(scene = [scene], num_samples=(512, 0), max_bounces=1)[0]
pyredner.imwrite(target.cpu(), 'results/shadow_art/high_res/' + step + '/' + str(obj) + '_0.png')
area_lights = []
for i in range(numShapes, len(shapes)):
area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity, light_intensity, light_intensity])))
area_lights.append(pyredner.AreaLight(shape_id = numShapes, intensity = torch.tensor([light_intensity*10, light_intensity*10, light_intensity*10])))
shape0_vertices = shapes[0].vertices.clone()
shapes[0].vertices = \
(shape0_vertices)
scene_3 = pyredner.Scene(cam3, objects=[shapes[0], shapes[2]], area_lights = [area_lights[2]], envmap = None)
target2 = pyredner.render_pathtracing(scene = [scene_3], num_samples=(512, 0), max_bounces=1)[0]
pyredner.imwrite(target2.cpu(), 'results/shadow_art/high_res/' + step + '/' + str(obj) + '_1.png')
up=torch.tensor([0.0, 1.0, 0.0]),
fov=torch.tensor([20.0]),
resolution=resolution)
for i in range(0): # num_views):
print("correcting position {:0>2d}".format(i))
eul_optimizer = torch.optim.SGD([euler], lr=2)
tra_optimizer = torch.optim.SGD([trans], lr=5000)
for t in range(20):
eul_optimizer.zero_grad()
tra_optimizer.zero_grad()
rotation_matrix = pyredner.gen_rotate_matrix(euler)
obj.vertices = (vertices - center) @ torch.t(rotation_matrix) \
+ center + trans * torch.tensor([1., 1., 3.], device=pyredner.get_device())
scene = pyredner.Scene(objects=[obj], camera=cam, envmap=envmap)
img = pyredner.render_pathtracing(scene=scene,
num_samples=(64, 4),
use_secondary_edge_sampling=True)
print('f')
loss = (img - target[i]).pow(2).mean()
loss.backward()
eul_optimizer.step()
tra_optimizer.step()
if t % 2 == 1:
print(' iteration', t, 'loss:{:.6f}'.format(loss),
euler.data.cpu(),
trans.data.cpu() * torch.tensor([1., 1., 3.]))
euler_list.append(euler.data.clone())
trans_list.append(trans.data.clone())
#pyredner.imwrite(img.cpu(), output_path + '/view_positions/{:0>2d}.png'.format(i))
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)