def main():
filenames = [filename for filename in sys.argv[1:]]
assert len(filenames) == 2
fromfile, tofile = filenames
print("Converting '%s' to '%s'" % (fromfile, tofile))
image = imread(fromfile)
imwrite(image, tofile)
def image_obj(self):
print("Loading object image")
if self.filename_obj:
image = imread(self.filename_obj, True)
if self.resolution_limit != 0:
image = limit_size(image, self.resolution_limit)
else:
image = np.zeros_like(self.image_holo)
return image
def image_obj(self):
print("Loading object image")
if self.filename_obj:
image = imread(self.filename_obj, True)
if self.resolution_limit != 0:
image = limit_size(image, self.resolution_limit)
else:
image = np.zeros_like(self.image_holo)
return image
def image_ref(self):
print("Loading reference image")
if self.filename_ref:
image = imread(self.filename_ref, True)
if self.resolution_limit != 0:
image = limit_size(image, self.resolution_limit)
else:
image = np.zeros_like(self.image_holo)
return image
def image_ref(self):
print("Loading reference image")
if self.filename_ref:
image = imread(self.filename_ref, True)
if self.resolution_limit != 0:
image = limit_size(image, self.resolution_limit)
else:
image = np.zeros_like(self.image_holo)
return image
def main():
filenames = sys.argv[1:]
if len(filenames) < 2:
print("Se requieren al menos dos ficheros para operar la sustracción.")
return 1
files = [(filename, imread(filename)) for filename in filenames]
name, left = files.pop(0)
for right_name, right in files:
left = subtract(left, right)
filename_tail = path.split(right_name)[1]
name += "-%s" % filename_tail
print("Writting to %s" % name)
imwrite(left, name)
def main():
filenames = sys.argv[1:]
if len(filenames) < 2:
print("Se requieren al menos dos ficheros para operar la sustracción.")
return 1
files = [(filename, imread(filename)) for filename in filenames]
name, left = files.pop(0)
for right_name, right in files:
left = subtract(left, right)
filename_tail = path.split(right_name)[1]
name += "-%s" % filename_tail
print("Writting to %s" % name)
imwrite(left, name)
def main():
"""
Le main rutine
"""
# TODO: se puede automatizar los mejores paramétros para quitar las pertubaciones del fondo
images = [(filename, imread(filename, False)) for filename in sys.argv[1:]]
if not images:
lena = misc.lena()
images = [("lena", lena)]
def sigmoid(x):
result = np.abs(1 / (1 + np.exp(-x)))
return result
for filename, image in images:
print("Original %s:" % filename)
def processor(t_sigma, t_level, equalize_level):
t_sigma = sigmoid(t_sigma) * 20 + 1
t_level = sigmoid(t_level)
equalize_level = sigmoid(equalize_level)
channels = []
for ndim in range(3):
channel = image[:, :, ndim]
local_context = gaussian_filter(channel, t_sigma)
# local_context = median_filter(channel, t_sigma)
tonemapped = channel - local_context * t_level
tonemapped = tonemapped.astype(int)
tonemapped /= 1 - t_level
equalized = equalize(tonemapped) * equalize_level
equalized += tonemapped * (1 - equalize_level)
channels.append(equalized)
final = np.array(channels).swapaxes(0, 1).swapaxes(1, 2)
final = normalize(final).astype(np.uint8)
return final
amoeba = Amoeba(processor)
amoeba.iterate(distance=1)
print(amoeba.points)
def main():
"""
Le main rutine
"""
#TODO: se puede automatizar los mejores paramétros para quitar las pertubaciones del fondo
images = [(filename, imread(filename, False)) for filename in sys.argv[1:]]
if not images:
lena = misc.lena()
images = [("lena", lena)]
def sigmoid(x):
result = np.abs(1 / (1 + np.exp(-x)))
return result
for filename, image in images:
print("Original %s:" % filename)
def processor(t_sigma, t_level, equalize_level):
t_sigma = sigmoid(t_sigma) * 20 + 1
t_level = sigmoid(t_level)
equalize_level = sigmoid(equalize_level)
channels = []
for ndim in range(3):
channel = image[:, :, ndim]
local_context = gaussian_filter(channel, t_sigma)
# local_context = median_filter(channel, t_sigma)
tonemapped = channel - local_context * t_level
tonemapped = tonemapped.astype(int)
tonemapped /= 1 - t_level
equalized = equalize(tonemapped) * equalize_level
equalized += tonemapped * (1 - equalize_level)
channels.append(equalized)
final = np.array(channels).swapaxes(0, 1).swapaxes(1, 2)
final = normalize(final).astype(np.uint8)
return final
amoeba = Amoeba(processor)
amoeba.iterate(distance=1)
print(amoeba.points)
max_bounces = 6)
render = render_pytorch.RenderFunction.apply
# img = render(0, *args)
# image.imwrite(img.data.numpy(), 'test/results/bunny_box/target.exr')
bunny_vertices = shapes[-1].vertices.clone()
bunny_translation = Variable(torch.from_numpy(\
np.array([0.1,0.4,0.1],dtype=np.float32)), requires_grad=True)
bunny_rotation = Variable(torch.from_numpy(\
np.array([-0.2,0.1,-0.1],dtype=np.float32)), requires_grad=True)
#bunny_translation = Variable(torch.from_numpy(\
# np.array([0.0485, -0.1651, -0.0795],dtype=np.float32)), requires_grad=True)
#bunny_rotation = Variable(torch.from_numpy(\
# np.array([-0.2,0.1,-0.1],dtype=np.float32)), requires_grad=True)
target = Variable(
torch.from_numpy(image.imread('test/results/bunny_box/target.exr')))
optimizer = torch.optim.Adam([bunny_translation, bunny_rotation], lr=1e-2)
for t in range(200):
print('iteration:', t)
optimizer.zero_grad()
# Forward pass: render the image
bunny_rotation_matrix = transform.torch_rotate_matrix(bunny_rotation)
shapes[-1].vertices = \
(bunny_vertices-torch.mean(bunny_vertices, 0))@torch.t(bunny_rotation_matrix) + \
torch.mean(bunny_vertices, 0) + bunny_translation
args=render_pytorch.RenderFunction.serialize_scene(\
cam, materials, shapes, lights, resolution,
num_samples = 4,
max_bounces = 6)
def image_holo(self):
print("Loading hologram image")
image = imread(self.filename_holo, True)
if self.resolution_limit != 0:
image = limit_size(image, self.resolution_limit)
return image
shapes = [shape_triangle, shape_light]
light_intensity=torch.from_numpy(\
np.array([20,20,20],dtype=np.float32))
light = light.Light(1, light_intensity)
lights = [light]
args=render_pytorch.RenderFunction.serialize_scene(\
cam,materials,shapes,lights,resolution,256,1)
# To apply our Function, we use Function.apply method. We alias this as 'render'.
render = render_pytorch.RenderFunction.apply
img = render(0, *args)
image.imwrite(img.data.numpy(), 'test/results/test_single_triangle/target.exr')
image.imwrite(img.data.numpy(), 'test/results/test_single_triangle/target.png')
target = Variable(
torch.from_numpy(
image.imread('test/results/test_single_triangle/target.exr')))
shape_triangle.vertices = Variable(torch.from_numpy(\
np.array([[-2.0,1.5,0.3], [0.9,1.2,-0.3], [-0.4,-1.4,0.2]],dtype=np.float32)),
requires_grad=True)
args=render_pytorch.RenderFunction.serialize_scene(\
cam,materials,shapes,lights,resolution,16,1)
img = render(1, *args)
image.imwrite(img.data.numpy(), 'test/results/test_single_triangle/init.png')
diff = torch.abs(target - img)
image.imwrite(diff.data.numpy(),
'test/results/test_single_triangle/init_diff.png')
optimizer = torch.optim.Adam([shape_triangle.vertices], lr=5e-2)
for t in range(200):
optimizer.zero_grad()
# Forward pass: render the image
up = Variable(torch.from_numpy(np.array([0, 1, 0], dtype=np.float32)))
fov = Variable(torch.from_numpy(np.array([45.0], dtype=np.float32)))
clip_near = Variable(torch.from_numpy(np.array([0.01], dtype=np.float32)))
clip_far = Variable(torch.from_numpy(np.array([10000.0], dtype=np.float32)))
cam = camera.Camera(position=position,
look_at=look_at,
up=up,
cam_to_world=None,
fov=fov,
clip_near=clip_near,
clip_far=clip_far,
resolution=resolution)
mat_grey=material.Material(\
diffuse_reflectance=torch.from_numpy(np.array([0.5,0.5,0.5],dtype=np.float32)))
mat_checker_board=material.Material(\
diffuse_reflectance=torch.from_numpy(image.imread('test/results/test_texture/checker_board.exr')))
materials = [mat_grey, mat_checker_board]
vertices=Variable(torch.from_numpy(\
np.array([[-1.0,-1.0,0.0], [-1.0,1.0,0.0], [1.0,-1.0,0.0], [1.0,1.0,0.0]],dtype=np.float32)))
indices = torch.from_numpy(np.array([[0, 1, 2], [1, 3, 2]], dtype=np.int32))
uvs = torch.from_numpy(
np.array([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]],
dtype=np.float32))
shape_plane = shape.Shape(vertices, indices, uvs, None, 1)
light_vertices=Variable(torch.from_numpy(\
np.array([[-1,-1,-7],[1,-1,-7],[-1,1,-7],[1,1,-7]],dtype=np.float32)))
light_indices=torch.from_numpy(\
np.array([[0,1,2],[1,3,2]],dtype=np.int32))
shape_light = shape.Shape(light_vertices, light_indices, None, None, 0)
shapes = [shape_plane, shape_light]
light_intensity=torch.from_numpy(\
optimizer = torch.optim.Adam([light_translation], lr=5e-2)
for t in range(200):
print('iteration:', t)
shape_light.vertices = light_vertices + light_translation
args = render_pytorch.RenderFunction.serialize_scene(
cam, materials, shapes, lights, resolution, 4, 1)
# To apply our Function, we use Function.apply method. We alias this as 'render'.
render = render_pytorch.RenderFunction.apply
optimizer.zero_grad()
# Forward pass: render the image
img = render(t, *args)
image.imwrite(img.data.numpy(),
'test/results/test_glossy/iter_{}.png'.format(t))
target = Variable(
torch.from_numpy(image.imread('test/results/test_glossy/target.exr')))
loss = (img - target).pow(2).sum()
print('loss:', loss.item())
loss.backward()
print('grad:', light_translation.grad)
optimizer.step()
print('light_translation:', light_translation)
print('shape_light.vertices:', shape_light.vertices)
from subprocess import call
call([
"ffmpeg", "-framerate", "24", "-i", "test/results/test_glossy/iter_%d.png",
"-vb", "20M", "test/results/test_glossy/out.mp4"
def parse_material(node, two_sided=False):
node_id = None
if 'id' in node.attrib:
node_id = node.attrib['id']
if node.attrib['type'] == 'diffuse':
diffuse_reflectance = Variable(torch.from_numpy(\
np.array([0.5, 0.5, 0.5], dtype=np.float32)))
diffuse_uv_scale = Variable(torch.from_numpy(\
np.array([1.0, 1.0], dtype=np.float32)))
specular_reflectance = Variable(torch.from_numpy(\
np.array([0.0, 0.0, 0.0], dtype=np.float32)))
specular_uv_scale = Variable(torch.from_numpy(\
np.array([1.0, 1.0], dtype=np.float32)))
roughness = Variable(torch.from_numpy(\
np.array([1.0], dtype=np.float32)))
for child in node:
if child.attrib['name'] == 'reflectance':
if child.tag == 'texture':
for grandchild in child:
if grandchild.attrib['name'] == 'filename':
diffuse_reflectance = Variable(torch.from_numpy(\
image.imread(grandchild.attrib['value'])))
elif grandchild.attrib['name'] == 'uscale':
diffuse_uv_scale.data[0] = float(
grandchild.attrib['value'])
elif grandchild.attrib['name'] == 'vscale':
diffuse_uv_scale.data[1] = float(
grandchild.attrib['value'])
elif child.tag == 'rgb':
diffuse_reflectance = \
Variable(torch.from_numpy(\
parse_vector(child.attrib['value'])))
elif child.attrib['name'] == 'specular':
if child.tag == 'texture':
for grandchild in child:
if grandchild.attrib['name'] == 'filename':
specular_reflectance = Variable(torch.from_numpy(\
image.imread(grandchild.attrib['value'])))
elif grandchild.attrib['name'] == 'uscale':
specular_uv_scale.data[0] = float(
grandchild.attrib['value'])
elif grandchild.attrib['name'] == 'vscale':
specular_uv_scale.data[1] = float(
grandchild.attrib['value'])
elif child.tag == 'rgb':
specular_reflectance = \
Variable(torch.from_numpy(\
parse_vector(child.attrib['value'])))
elif child.attrib['name'] == 'roughness':
roughness = \
Variable(torch.from_numpy(\
float(child.attrib['value'])))
return (node_id,
material.Material(diffuse_reflectance,
diffuse_uv_scale=diffuse_uv_scale,
specular_reflectance=specular_reflectance,
specular_uv_scale=specular_uv_scale,
roughness=roughness,
two_sided=two_sided))
elif node.attrib['type'] == 'twosided':
ret = parse_material(node[0], True)
return (node_id, ret[1])
shape_light = shape.Shape(light_vertices, light_indices, None, None, 2)
shapes = [shape_floor, shape_light, shape_blocker]
light_intensity=torch.from_numpy(\
np.array([0.5,0.5,0.5],dtype=np.float32))
light = light.Light(1, light_intensity)
lights = [light]
render = render_pytorch.RenderFunction.apply
# args=render_pytorch.RenderFunction.serialize_scene(\
# cam,materials,shapes,lights,resolution,256,1)
# img = render(0, *args)
# image.imwrite(img.data.numpy(), 'test/results/test_shadow_glossy/target.exr')
# image.imwrite(img.data.numpy(), 'test/results/test_shadow_glossy/target.png')
target = Variable(
torch.from_numpy(
image.imread('test/results/test_shadow_glossy/target.exr')))
img = image.imread('test/results/test_shadow_glossy/final.exr')
image.imwrite(np.abs(target.data.numpy() - img),
'test/results/test_shadow_glossy/final_diff.png')
from subprocess import call
call([
"ffmpeg", "-framerate", "24", "-i",
"test/results/test_shadow_glossy/iter_%d.png", "-vb", "20M",
"test/results/test_shadow_glossy/out.mp4"
])
exit()
shape_blocker.vertices=Variable(torch.from_numpy(\
np.array([[-0.6,0.9,0.4],[-0.8,3.3,0.7],[0.2,1.1,0.6],[0.3,3.2,0.4]],dtype=np.float32)),
requires_grad=True)
args=render_pytorch.RenderFunction.serialize_scene(\
cam_position = cam.position
cam_translation = Variable(torch.from_numpy(\
np.array([-0.1,0.1,-0.1],dtype=np.float32)), requires_grad=True)
materials[-1].diffuse_reflectance = \
Variable(torch.from_numpy(np.array([0.5, 0.5, 0.5], dtype=np.float32)),
requires_grad = True)
materials[-1].specular_reflectance = \
Variable(torch.from_numpy(np.array([0.5, 0.5, 0.5], dtype=np.float32)),
requires_grad = True)
materials[-1].roughness = \
Variable(torch.from_numpy(np.array([0.2], dtype=np.float32)),
requires_grad = True)
target = Variable(
torch.from_numpy(
image.imread('test/results/teapot_reflectance/target.exr')))
image.imwrite(target.data.numpy(),
'test/results/teapot_reflectance/target.png')
cam = camera.Camera(position=cam_position + cam_translation,
look_at=cam.look_at,
up=cam.up,
cam_to_world=None,
fov=cam.fov,
clip_near=cam.clip_near,
clip_far=cam.clip_far,
resolution=resolution,
fisheye=False)
args = render_pytorch.RenderFunction.serialize_scene(cam, materials, shapes,
lights, resolution, 256,
2)
img = render(1, *args)
shapes = [shape_floor, shape_blocker, shape_light]
light_intensity=torch.from_numpy(\
np.array([5000,5000,5000],dtype=np.float32))
light = light.Light(2, light_intensity)
lights = [light]
args = render_pytorch.RenderFunction.serialize_scene(cam, materials, shapes,
lights, resolution, 256,
1)
render = render_pytorch.RenderFunction.apply
img = render(0, *args)
image.imwrite(img.data.numpy(), 'test/results/test_shadow_camera/target.exr')
image.imwrite(img.data.numpy(), 'test/results/test_shadow_camera/target.png')
target = Variable(
torch.from_numpy(
image.imread('test/results/test_shadow_camera/target.exr')))
position = Variable(torch.from_numpy(np.array([-2, 7, 2], dtype=np.float32)),
requires_grad=True)
cam = camera.Camera(position=position,
look_at=look_at,
up=up,
cam_to_world=None,
fov=fov,
clip_near=clip_near,
clip_far=clip_far,
resolution=resolution)
args = render_pytorch.RenderFunction.serialize_scene(cam, materials, shapes,
lights, resolution, 256,
1)
img = render(1, *args)
image.imwrite(img.data.numpy(), 'test/results/test_shadow_camera/init.png')
materials[-1].diffuse_reflectance = \
Variable(torch.from_numpy(np.array([0.15, 0.2, 0.15], dtype=np.float32)))
materials[-1].specular_reflectance = \
Variable(torch.from_numpy(np.array([0.8, 0.8, 0.8], dtype=np.float32)))
materials[-1].roughness = \
Variable(torch.from_numpy(np.array([0.0001], dtype=np.float32)))
args=render_pytorch.RenderFunction.serialize_scene(\
cam, materials, shapes, lights, resolution,
num_samples = 256,
max_bounces = 2)
render = render_pytorch.RenderFunction.apply
# img = render(0, *args)
# image.imwrite(img.data.numpy(), 'test/results/teapot_specular/target.exr')
target = Variable(
torch.from_numpy(image.imread('test/results/teapot_specular/target.exr')))
image.imwrite(target.data.numpy(), 'test/results/teapot_specular/target.png')
ref_pos = shapes[-1].vertices
translation = Variable(torch.from_numpy(
np.array([20.0, 0.0, 2.0], dtype=np.float32)),
requires_grad=True)
shapes[-1].vertices = ref_pos + translation
args=render_pytorch.RenderFunction.serialize_scene(\
cam, materials, shapes, lights, resolution,
num_samples = 256,
max_bounces = 2)
# img = render(1, *args)
# image.imwrite(img.data.numpy(), 'test/results/teapot_specular/init.png')
# diff = torch.abs(target - img)
# image.imwrite(diff.data.numpy(), 'test/results/teapot_specular/init_diff.png')
for i in range(len(materials)):
materials[i].diffuse_reflectance = torch.sigmoid(
diffuse_reflectance_bases[i])
for i in range(len(lights)):
lights[i].intensity = torch.abs(500 * lgt_intensity_bases[i])
args=render_pytorch.RenderFunction.serialize_scene(\
cam, materials, shapes, lights, resolution,
num_samples = 625,
max_bounces = 1)
img = render(1, *args)
image.imwrite(img.data.numpy(), 'test/results/room_0/init.exr')
image.imwrite(img.data.numpy(), 'test/results/room_0/init.png')
target = Variable(
torch.from_numpy(image.imread('test/results/room_0/target.exr')))
mat_optimizer = torch.optim.Adam(mat_variables, lr=5e-3)
lgt_optimizer = torch.optim.Adam(lgt_variables, lr=5e-3)
for t in range(2000):
print('iteration:', t)
mat_optimizer.zero_grad()
lgt_optimizer.zero_grad()
for i in range(len(materials)):
materials[i].diffuse_reflectance = torch.sigmoid(
diffuse_reflectance_bases[i])
for i in range(len(lights)):
lights[i].intensity = torch.abs(500 * lgt_intensity_bases[i])
args=render_pytorch.RenderFunction.serialize_scene(\
cam, materials, shapes, lights, resolution,
diffuse_reflectance_bases[i])
materials[i].specular_reflectance = torch.sigmoid(
specular_reflectance_bases[i])
materials[i].roughness = torch.sigmoid(roughness_bases[i])
for i in range(len(lights)):
lights[i].intensity = torch.abs(lgt_intensity_bases[i] * 10.0)
#args=render_pytorch.RenderFunction.serialize_scene(\
# cam, materials, shapes, lights, cam.resolution,
# num_samples = 16384,
# max_bounces = 16)
#img = render(0, *args)
#image.imwrite(img.data.numpy(), 'test/results/perception_lab/init.exr')
#exit()
print('load target')
org_target = image.imread(
'test/scenes/perception_lab/off_monitor_30_final.hdr')
#target = image.imread('test/results/perception_lab/target.exr')
num_scales = 1
for scale in range(num_scales):
# linearly scale from 32x32 to 512x512
downscale_factor = 512.0 / ((512.0 / num_scales) * scale + 32.0)
print('downscale_factor', downscale_factor)
res = round(512 / downscale_factor)
print('scaling target')
if scale < num_scales - 1:
target = scipy.ndimage.interpolation.zoom(
org_target, (1.0 / downscale_factor, 1.0 / downscale_factor, 1.0),
order=1)
else:
downscale_factor = 1
res = 512
shape_light = shape.Shape(light_vertices, light_indices, None, None, 1)
shapes = [shape_floor, shape_blocker, shape_light]
light_intensity=torch.from_numpy(\
np.array([1000,1000,1000],dtype=np.float32))
light = light.Light(2, light_intensity)
lights = [light]
args = render_pytorch.RenderFunction.serialize_scene(cam, materials, shapes,
lights, resolution, 256,
1)
render = render_pytorch.RenderFunction.apply
img = render(0, *args)
image.imwrite(img.data.numpy(), 'test/results/test_shadow/target.exr')
image.imwrite(img.data.numpy(), 'test/results/test_shadow/target.png')
target = Variable(
torch.from_numpy(image.imread('test/results/test_shadow/target.exr')))
shape_blocker.vertices=Variable(torch.from_numpy(\
np.array([[-0.2,3.5,-0.8],[-0.8,3.0,0.3],[0.4,2.8,-0.8],[0.3,3.2,1.0]],dtype=np.float32)),
requires_grad=True)
args = render_pytorch.RenderFunction.serialize_scene(cam, materials, shapes,
lights, resolution, 256,
1)
img = render(1, *args)
image.imwrite(img.data.numpy(), 'test/results/test_shadow/init.png')
diff = torch.abs(target - img)
image.imwrite(diff.data.numpy(), 'test/results/test_shadow/init_diff.png')
optimizer = torch.optim.Adam([shape_blocker.vertices], lr=1e-2)
for t in range(200):
print('iteration:', t)
# To apply our Function, we use Function.apply method. We alias this as 'render'.
def image_holo(self):
print("Loading hologram image")
image = imread(self.filename_holo, True)
if self.resolution_limit != 0:
image = limit_size(image, self.resolution_limit)
return image
np.array([10000,10000,10000],dtype=np.float32))
light = light.Light(3, light_intensity)
lights = [light]
optimizer = torch.optim.Adam([light_rotation], lr=1e-2)
for t in range(100):
print('iteration:', t)
print('light_rotation', light_rotation)
light_rotation_matrix = transform.torch_rotate_matrix(light_rotation)
shape_light.vertices = light_vertices @ torch.t(
light_rotation_matrix) + light_translation
args = render_pytorch.RenderFunction.serialize_scene(
cam, materials, shapes, lights, resolution, 4, 32)
# To apply our Function, we use Function.apply method. We alias this as 'render'.
render = render_pytorch.RenderFunction.apply
optimizer.zero_grad()
# Forward pass: render the image
img = render(t, *args)
image.imwrite(img.data.numpy(), 'results/test_gi/iter_{}.png'.format(t))
target = Variable(
torch.from_numpy(image.imread('results/test_gi/target.exr')))
loss = (img - target).pow(2).sum()
print('loss:', loss.data[0])
loss.backward()
print('grad:', light_rotation.grad)
optimizer.step()
image.imwrite(img.data.numpy(), 'test/results/test_two_triangles/target.png')
shape_tri0.vertices = Variable(torch.from_numpy(\
np.array([[-1.3,1.5,0.1], [1.5,0.7,-0.2], [-0.8,-1.1,0.2]],dtype=np.float32)),
requires_grad=True)
shape_tri1.vertices = Variable(torch.from_numpy(\
np.array([[-0.5,1.2,1.2], [0.3,1.7,1.0], [0.5,-1.8,1.3]],dtype=np.float32)),
requires_grad=True)
args=render_pytorch.RenderFunction.serialize_scene(\
cam,materials,shapes,lights,resolution,256,1)
img = render(1, *args)
image.imwrite(img.data.numpy(), 'test/results/test_two_triangles/init.png')
args=render_pytorch.RenderFunction.serialize_scene(\
cam,materials,shapes,lights,resolution,4,1)
target = Variable(
torch.from_numpy(
image.imread('test/results/test_two_triangles/target.exr')))
diff = torch.abs(target - img)
image.imwrite(diff.data.numpy(),
'test/results/test_two_triangles/init_diff.png')
optimizer = torch.optim.Adam([shape_tri0.vertices, shape_tri1.vertices],
lr=1e-2)
for t in range(200):
# To apply our Function, we use Function.apply method. We alias this as 'render'.
render = render_pytorch.RenderFunction.apply
optimizer.zero_grad()
# Forward pass: render the image
img = render(t + 1, *args)
image.imwrite(img.data.numpy(),
'test/results/test_two_triangles/iter_{}.png'.format(t))
