def test_save_obj(self): vertices, faces = neural_renderer.load_obj('./tests/data/teapot.obj') neural_renderer.save_obj('./tests/data/teapot2.obj', vertices, faces) vertices2, faces2 = neural_renderer.load_obj('./tests/data/teapot.obj') os.remove('./tests/data/teapot2.obj') assert np.allclose(vertices, vertices2) assert np.allclose(faces, faces2)
def test_texture(self): position, rotation = position_rotation_from_angles(2, 15, 30) camera = nr.Camera(position=position, rotation=rotation) renderer = nr.Renderer(camera=camera) vertices, faces, textures = nr.load_obj(os.path.join( data_dir, '1cde62b063e14777c9152a706245d48/model.obj'), load_texture=True) images = renderer(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]).permute( 0, 2, 3, 1).detach().cpu().numpy() image = (images[0] * 255).astype(np.uint8) imsave(os.path.join(data_dir, 'car.png'), image) vertices, faces, textures = nr.load_obj(os.path.join( data_dir, '4e49873292196f02574b5684eaec43e9/model.obj'), load_texture=True, texture_size=16) position, rotation = position_rotation_from_angles(2, 15, -90) renderer.camera.position = position renderer.camera.rotation = rotation images = renderer(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]).permute( 0, 2, 3, 1).detach().cpu().numpy() image = (images[0] * 255).astype(np.uint8) imsave(os.path.join(data_dir, 'display.png'), image)
def test_texture(self): renderer = neural_renderer.Renderer() vertices, faces, textures = neural_renderer.load_obj( './tests/data/1cde62b063e14777c9152a706245d48/model.obj', load_texture=True) vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) renderer.eye = neural_renderer.get_points_from_angles(2, 15, 30) images = renderer.render(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]).data.get() scipy.misc.imsave('./tests/data/car.png', scipy.misc.toimage(images[0])) vertices, faces, textures = neural_renderer.load_obj( './tests/data/4e49873292196f02574b5684eaec43e9/model.obj', load_texture=True, texture_size=16) vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) renderer.eye = neural_renderer.get_points_from_angles(2, 15, -90) images = renderer.render(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]).data.get() scipy.misc.imsave('./tests/data/display.png', scipy.misc.toimage(images[0]))
def test_texture(self): renderer = nr.Renderer(camera_mode='look_at') vertices, faces, textures = nr.load_obj(os.path.join( data_dir, '1cde62b063e14777c9152a706245d48/model.obj'), load_texture=True) renderer.eye = nr.get_points_from_angles(2, 15, 30) images, depth, silhouette = renderer.render( vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]) images = images.permute(0, 2, 3, 1).detach().cpu().numpy() silhouette = silhouette.detach().cpu().numpy() depth = depth.detach().cpu().numpy() imsave(os.path.join(data_dir, 'car.png'), images[0]) cv2.imshow("r", images[0, :, :, ::-1]) cv2.imshow("d", ColorizeDepth(depth[0], 1.5, 2.5)) cv2.imshow("s", silhouette[0]) cv2.waitKey() vertices, faces, textures = nr.load_obj(os.path.join( data_dir, '4e49873292196f02574b5684eaec43e9/model.obj'), load_texture=True, texture_size=16) renderer.eye = nr.get_points_from_angles(2, 15, -90) images, _, _ = renderer.render(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]) images = images.permute(0, 2, 3, 1).detach().cpu().numpy() imsave(os.path.join(data_dir, 'display.png'), images[0])
def test_save_obj(self): vertices, faces = neural_renderer.load_obj('./tests/data/teapot.obj') neural_renderer.save_obj('./tests/data/teapot2.obj', vertices, faces) vertices2, faces2 = neural_renderer.load_obj('./tests/data/teapot.obj') os.remove('./tests/data/teapot2.obj') assert np.allclose(vertices, vertices2) assert np.allclose(faces, faces2)
def test_save_obj(self): teapot = os.path.join(data_dir, 'teapot.obj') teapot2 = os.path.join(data_dir, 'teapot2.obj') vertices, faces = nr.load_obj(teapot) nr.save_obj(teapot2, vertices, faces) vertices2, faces2 = nr.load_obj(teapot2) os.remove(teapot2) assert torch.allclose(vertices, vertices2) assert torch.allclose(faces, faces2)
def __init__(self, render_type, n_channel): super().__init__() primitive_type = render_type self.n_channel = n_channel if primitive_type == 'sphere': v, f = nr.load_obj('controllable_gan/templates/sphere_114.obj') elif primitive_type == 'cuboid': v, f = nr.load_obj('controllable_gan/templates/cube.obj', False) else: raise AttributeError self.n_latent = 128 self.v = v self.f = f
def test_tetrahedron(self): vertices_ref = np.array( [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 0.]], 'float32') faces_ref = np.array([[1, 3, 2], [3, 1, 0], [2, 0, 1], [0, 2, 3]], 'int32') obj_file = os.path.join(data_dir, 'tetrahedron.obj') vertices, faces = nr.load_obj(obj_file, False) assert (np.allclose(vertices_ref, vertices)) assert (np.allclose(faces_ref, faces)) vertices, faces = nr.load_obj(obj_file, True) assert (np.allclose(vertices_ref * 2 - 1.0, vertices)) assert (np.allclose(faces_ref, faces))
def test_tetrahedron(self): vertices_ref = np.array( [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 0.]], 'float32') faces_ref = np.array([[1, 3, 2], [3, 1, 0], [2, 0, 1], [0, 2, 3]], 'int32') vertices, faces = neural_renderer.load_obj( './tests/data/tetrahedron.obj', False) assert (np.allclose(vertices_ref, vertices)) assert (np.allclose(faces_ref, faces)) vertices, faces = neural_renderer.load_obj( './tests/data/tetrahedron.obj', True) assert (np.allclose(vertices_ref * 2 - 1.0, vertices)) assert (np.allclose(faces_ref, faces))
def main(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--filename_input', type=str, default=os.path.join(data_dir, 'teapot.obj')) parser.add_argument('-o', '--filename_output', type=str, default=os.path.join(data_dir, 'example1.gif')) parser.add_argument('-g', '--gpu', type=int, default=0) args = parser.parse_args() # other settings camera_distance = 2.732 elevation = 30 texture_size = 2 # load .obj vertices, faces = nr.load_obj(args.filename_input) vertices = vertices[None, :, :] # [num_vertices, XYZ] -> [batch_size=1, num_vertices, XYZ] faces = faces[None, :, :] # [num_faces, 3] -> [batch_size=1, num_faces, 3] # create texture [batch_size=1, num_faces, texture_size, texture_size, texture_size, RGB] textures = torch.ones(1, faces.shape[1], texture_size, texture_size, texture_size, 3, dtype=torch.float32).cuda() # to gpu # create renderer renderer = nr.Renderer(camera_mode='look_at') # draw object loop = tqdm.tqdm(range(0, 360, 4)) writer = imageio.get_writer(args.filename_output, mode='I') for num, azimuth in enumerate(loop): loop.set_description('Drawing') renderer.eye = nr.get_points_from_angles(camera_distance, elevation, azimuth) images = renderer(vertices, faces, textures) # [batch_size, RGB, image_size, image_size] image = images.detach().cpu().numpy()[0].transpose((1, 2, 0)) # [image_size, image_size, RGB] writer.append_data((255*image).astype(np.uint8)) writer.close()
def __init__(self, filename_obj, filename_ref): super(Model, self).__init__() vertices, faces = nr.load_obj(filename_obj) self.register_buffer('vertices', vertices[None, :, :]) self.register_buffer('faces', faces[None, :, :]) # create textures texture_size = 4 textures = torch.zeros(1, self.faces.shape[1], texture_size, texture_size, texture_size, 3, dtype=torch.float32) self.textures = nn.Parameter(textures) # load reference image image_ref = torch.from_numpy( imread(filename_ref).astype('float32') / 255.).permute(2, 0, 1)[None, ::] self.register_buffer('image_ref', image_ref) # setup renderer renderer = nr.Renderer(camera_mode='look_at') renderer.perspective = False renderer.light_intensity_directional = 0.0 renderer.light_intensity_ambient = 1.0 self.renderer = renderer
def __init__(self, dim_in=512, scaling=1., filename_obj='./data/obj/sphere_642.obj'): super(BasicShapeDecoder, self).__init__() with self.init_scope(): self.vertices_base, self.faces = neural_renderer.load_obj( filename_obj) self.num_vertices = self.vertices_base.shape[0] self.num_faces = self.faces.shape[0] self.obj_scale = 0.5 self.object_size = 1.0 self.scaling = scaling dim_hidden = [4096, 4096] init = chainer.initializers.HeNormal() self.linear1 = cl.Linear(dim_in, dim_hidden[0], initialW=init) self.linear2 = cl.Linear(dim_hidden[0], dim_hidden[1], initialW=init) self.linear_bias = cl.Linear(dim_hidden[1], self.num_vertices * 3, initialW=init) self.laplacian = get_graph_laplacian(self.faces, self.num_vertices)
def __init__(self, dim_in=512, scaling=1., filename_obj='./data/obj/sphere_642.obj'): super(BasicSymmetricShapeDecoder, self).__init__() with self.init_scope(): self.vertices_base, self.faces = neural_renderer.load_obj( filename_obj) self.num_vertices = self.vertices_base.shape[0] self.num_faces = self.faces.shape[0] self.obj_scale = 0.5 self.object_size = 1.0 self.scaling = scaling self.vertices_base, self.vertices_matrix = self.compute_vertices_matrix( ) # [642 * 3, 337 * 3] dim_out = self.vertices_matrix.shape[1] dim_hidden = [4096, 4096] init = chainer.initializers.HeNormal() self.linear1 = cl.Linear(dim_in, dim_hidden[0], initialW=init) self.linear2 = cl.Linear(dim_hidden[0], dim_hidden[1], initialW=init) self.linear_bias = cl.Linear(dim_hidden[1], dim_out, initialW=init) self.laplacian = get_graph_laplacian(self.faces, self.num_vertices) self.degrees = self.xp.histogram( self.faces, self.xp.arange(self.num_vertices + 1))[0].astype('int32')
def stest_forward_case2(self): data = [[ './tests/data/4e49873292196f02574b5684eaec43e9/model.obj', neural_renderer.get_points_from_angles(2.5, 10, -90), './tests/data/4e49873292196f02574b5684eaec43e9.png', ], [ './tests/data/1cde62b063e14777c9152a706245d48/model.obj', neural_renderer.get_points_from_angles(2.5, 10, 60), './tests/data/1cde62b063e14777c9152a706245d48.png', ]] renderer = neural_renderer.Renderer() renderer.draw_backside = False for i, (filename, viewpoint, reference) in enumerate(data): renderer.viewpoints = viewpoint ref = neural_renderer.imread(reference) vertices, faces, vertices_t, faces_t, textures = neural_renderer.load_obj( filename, load_textures=True) vertices, faces, vertices_t, faces_t, textures = neural_renderer.to_gpu( (vertices[None, :, :], faces, vertices_t[None, :, :], faces_t, textures[None, :, :, :])) images = renderer.render(vertices, faces, vertices_t, faces_t, textures).data image = images[0].transpose((1, 2, 0)) # imageio.toimage(image.get(), cmin=0, cmax=1).save(reference) chainer.testing.assert_allclose(ref, image, atol=1e-2)
def fromobj(cls, filename_obj, normalization=True, load_texture=False, texture_size=4): ''' Create a Mesh object from a .obj file ''' if load_texture: vertices, faces, textures = nr.load_obj(filename_obj, normalization=normalization, texture_size=texture_size, load_texture=True) else: vertices, faces = nr.load_obj(filename_obj, normalization=normalization, texture_size=texture_size, load_texture=False) textures = None return cls(vertices, faces, textures, texture_size)
def __init__(self, filename_obj, filename_ref): super(Model, self).__init__() # load .obj vertices, faces = nr.load_obj(filename_obj) self.vertices = nn.Parameter(vertices[None, :, :]) self.register_buffer('faces', faces[None, :, :]) # create textures texture_size = 2 textures = torch.ones(1, self.faces.shape[1], texture_size, texture_size, texture_size, 3, dtype=torch.float32) self.register_buffer('textures', textures) # load reference image image_ref = torch.from_numpy( imread(filename_ref).astype(np.float32).mean(-1) / 255.)[None, ::] self.register_buffer('image_ref', image_ref) # setup renderer renderer = nr.Renderer(camera_mode='look_at') self.renderer = renderer
def exec_main(): obj_file = 'birds3d/external/neural_renderer/examples/data/teapot.obj' vertices, faces = neural_renderer.load_obj(obj_file) renderer = NMR() renderer.to_gpu(device=0) masks = renderer.forward_mask(vertices[None, :, :], faces[None, :, :]) print(np.sum(masks)) print(masks.shape) grad_masks = masks * 0 + 1 vert_grad = renderer.backward_mask(grad_masks) print(np.sum(vert_grad)) print(vert_grad.shape) # Torch API mask_renderer = NeuralRenderer() vertices_var = torch.autograd.Variable(torch.from_numpy( vertices[None, :, :]).cuda(device=0), requires_grad=True) faces_var = torch.autograd.Variable( torch.from_numpy(faces[None, :, :]).cuda(device=0)) for ix in range(100): masks_torch = mask_renderer.forward(vertices_var, faces_var) vertices_var.grad = None masks_torch.backward(torch.from_numpy(grad_masks).cuda(device=0)) print(torch.sum(masks_torch)) print(masks_torch.shape) print(torch.sum(vertices_var.grad))
def __init__(self, filename_obj, filename_ref=None): super(Model, self).__init__() with self.init_scope(): # load .obj vertices, faces = neural_renderer.load_obj(filename_obj) self.vertices = vertices[None, :, :] self.faces = faces[None, :, :] # create textures texture_size = 2 textures = np.ones((1, self.faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') self.textures = textures # load reference image if filename_ref is not None: self.image_ref = (scipy.misc.imread(filename_ref).max(-1) != 0).astype('float32') else: self.image_ref = None # camera parameters self.camera_position = chainer.Parameter(np.array([6, 10, -14], 'float32')) # setup renderer renderer = neural_renderer.Renderer() renderer.eye = self.camera_position self.renderer = renderer
def __init__(self, filename_obj, filename_ref): super(Model, self).__init__() with self.init_scope(): # load .obj vertices, faces = neural_renderer.load_obj(filename_obj) self.vertices = vertices[None, :, :] self.faces = faces[None, :, :] # create textures texture_size = 4 textures = np.zeros((1, self.faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') self.textures = chainer.Parameter(textures) # load reference image self.image_ref = scipy.misc.imread(filename_ref).astype( 'float32') / 255. # setup renderer renderer = neural_renderer.Renderer() renderer.perspective = False renderer.light_intensity_directional = 0.0 renderer.light_intensity_ambient = 1.0 self.renderer = renderer
def buffer_all(self): # if preset_uv_path: # self.v_attr, self.f_attr = nr.load_obj(cur_obj_fp, normalization = False) if self.cfg.DATASET_FVV.PRELOAD_MESHS: print(" Buffering meshs...") self.objs = {} for keep_idx in self.keep_idxs: frame_idx = self.frame_idxs[keep_idx] if frame_idx in self.objs: continue cur_obj_fp = self.cfg.DATASET_FVV.MESH_DIR%(frame_idx) obj_data = {} obj_data['v_attr'] , obj_data['f_attr'] = nr.load_obj(cur_obj_fp, normalization = False, use_cuda = False) self.objs[frame_idx] = obj_data if self.cfg.VERBOSE: print(' Loading mesh: ' + str(int(frame_idx)) + ' ' + cur_obj_fp) if self.cfg.DATASET_FVV.PRELOAD_VIEWS: # Buffer files print("Buffering files...") self.views_all = [] for i in range(self.__len__()): if not i % 50: print('Data', i) self.views_all.append(self.read_view(i))
def __init__(self, filename_obj, filename_ref): super(Model, self).__init__() with self.init_scope(): # load .obj vertices, faces = neural_renderer.load_obj(filename_obj) self.vertices = chainer.Parameter(vertices[None, :, :]) self.faces = faces[None, :, :] # create textures texture_size = 2 textures = np.ones((1, self.faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') self.textures = textures # load reference image #self.image_ref = scipy.misc.imread(filename_ref).astype('float32').mean(-1) / 255. image_ref = scipy.misc.imread(filename_ref).astype('float32').mean( -1) / 255. h = image_ref.shape[0] w = image_ref.shape[1] hcrop = wcrop = self.image_size = 256 #np.min(image_ref.shape[:1]) top = int(math.floor((h - hcrop) / 2.0)) bottom = int(math.ceil((h + hcrop) / 2.0)) left = int(math.floor((w - wcrop) / 2.0)) right = int(math.ceil((w + wcrop) / 2.0)) if len(image_ref.shape) > 2: self.image_ref = image_ref[top:bottom, left:right, :] else: self.image_ref = image_ref[top:bottom, left:right] # setup renderer renderer = neural_renderer.Renderer() self.renderer = renderer
def __init__(self, filename_obj, filename_ref=None): super(Model, self).__init__() # load .obj vertices, faces = nr.load_obj(filename_obj) self.register_buffer('vertices', vertices[None, :, :]) self.register_buffer('faces', faces[None, :, :]) # create textures texture_size = 2 textures = torch.ones(1, self.faces.shape[1], texture_size, texture_size, texture_size, 3, dtype=torch.float32) self.register_buffer('textures', textures) # load reference image image_ref = torch.from_numpy( (imread(filename_ref).max(-1) != 0).astype(np.float32)) self.register_buffer('image_ref', image_ref) # camera parameters self.camera_position = nn.Parameter( torch.from_numpy(np.array([6, 10, -14], dtype=np.float32))) # setup renderer renderer = nr.Renderer(camera_mode='look_at') renderer.eye = self.camera_position self.renderer = renderer
def __init__(self, filename_obj, dim_in=512, centroid_scale=0.1, bias_scale=1.0, centroid_lr=0.1, bias_lr=1.0): super(Decoder, self).__init__() with self.init_scope(): self.vertices_base, self.faces = neural_renderer.load_obj( filename_obj) self.num_vertices = self.vertices_base.shape[0] self.num_faces = self.faces.shape[0] self.centroid_scale = centroid_scale self.bias_scale = bias_scale self.obj_scale = 0.5 dim = 1024 dim_hidden = [dim, dim * 2] self.linear1 = cl.Linear(dim_in, dim_hidden[0]) self.linear2 = cl.Linear(dim_hidden[0], dim_hidden[1]) self.linear_centroids = cl.Linear(dim_hidden[1], 3) self.linear_bias = cl.Linear(dim_hidden[1], self.num_vertices * 3) self.linear_centroids.W.lr = centroid_lr self.linear_centroids.b.lr = centroid_lr self.linear_bias.W.lr = bias_lr self.linear_bias.b.lr = bias_lr
def __init__(self, filename_obj, filename_ref=None): super(Model, self).__init__() with self.init_scope(): # load .obj vertices, faces = neural_renderer.load_obj(filename_obj) self.vertices = vertices[None, :, :] self.faces = faces[None, :, :] # create textures texture_size = 2 textures = np.ones((1, self.faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') self.textures = textures # load reference image if filename_ref is not None: self.image_ref = (scipy.misc.imread(filename_ref).max(-1) != 0).astype('float32') else: self.image_ref = None # camera parameters self.camera_position = chainer.Parameter( np.array([6, 10, -14], 'float32')) # setup renderer renderer = neural_renderer.Renderer() renderer.eye = self.camera_position self.renderer = renderer
def __init__(self, filename_obj, dim_in=512, centroid_scale=0.1, bias_scale=1.0, centroid_lr=0.1, bias_lr=1.0): super(Decoder, self).__init__() # load .obj vertices_base, faces = nr.load_obj(filename_obj) # faces = faces[:, list(reversed(list(range(faces.shape[-1]))))] self.register_buffer('vertices_base', vertices_base) self.register_buffer('faces', faces) self.laplacian_loss = LaplacianFaceLoss(vertices_base, faces) self.nv = self.vertices_base.size(0) self.nf = self.faces.size(0) self.centroid_scale = centroid_scale self.bias_scale = bias_scale self.obj_scale = 0.5 dim = 1024 dim_hidden = [dim, dim * 2] self.fc1 = nn.Linear(dim_in, dim_hidden[0]) self.fc2 = nn.Linear(dim_hidden[0], dim_hidden[1]) self.fc_centroid = nn.Linear(dim_hidden[1], 3) self.fc_bias = nn.Linear(dim_hidden[1], self.nv * 3)
def __init__(self, filename_obj, dim_in=512, centroid_scale=0.1, bias_scale=1.0, centroid_lr=0.1, bias_lr=1.0): super(Decoder, self).__init__() self.vertices_base, self.faces = nr.load_obj(filename_obj) self.vertices_base = self.vertices_base.to(device) self.faces = self.faces.to(device) self.num_vertices = self.vertices_base.shape[0] self.num_faces = self.faces.shape[ 0] # ToDO: add centroid_lr and bias_lr self.centroid_scale = centroid_scale self.bias_scale = bias_scale self.obj_scale = 0.5 dim = 1024 dim_hidden = [dim, dim * 2] self.linear1 = nn.Linear(dim_in, dim_hidden[0]) self.linear2 = nn.Linear(dim_hidden[0], dim_hidden[1]) self.linear_centroids = nn.Linear(dim_hidden[1], 3) self.linear_bias = nn.Linear(dim_hidden[1], self.num_vertices * 3)
def run(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--filename_input', type=str, default='./examples/data/teapot.obj') parser.add_argument('-o', '--filename_output', type=str, default='./examples/data/example1.gif') parser.add_argument('-g', '--gpu', type=int, default=0) args = parser.parse_args() working_directory = os.path.dirname(args.filename_output) # other settings camera_distance = 2.732 elevation = 30 texture_size = 2 # load .obj vertices, faces = neural_renderer.load_obj(args.filename_input) vertices = vertices[ None, :, :] # [num_vertices, XYZ] -> [batch_size=1, num_vertices, XYZ] faces = faces[None, :, :] # [num_faces, 3] -> [batch_size=1, num_faces, 3] # create texture [batch_size=1, num_faces, texture_size, texture_size, texture_size, RGB] textures = np.ones( (1, faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') # to gpu chainer.cuda.get_device_from_id(args.gpu).use() vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) # create renderer renderer = neural_renderer.Renderer() # draw object for num, azimuth in enumerate(range(0, 360, 4)): renderer.eye = neural_renderer.get_points_from_angles( camera_distance, elevation, azimuth) images = renderer.render( vertices, faces, textures) # [batch_size, RGB, image_size, image_size] image = images.data.get()[0].transpose( (1, 2, 0)) # [image_size, image_size, RGB] scipy.misc.imsave('%s/_tmp_%04d.png' % (working_directory, num), image) # generate gif (need ImageMagick) options = '-delay 8 -loop 0 -layers optimize' subprocess.call('convert %s %s/_tmp_*.png %s' % (options, working_directory, args.filename_output), shell=True) # remove temporary files for filename in glob.glob('%s/_tmp_*.png' % working_directory): os.remove(filename)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--filename_input', type=str, default=os.path.join(data_dir, 'teapot.obj')) parser.add_argument('-o', '--filename_output', type=str, default=os.path.join(data_dir, 'example1.gif')) parser.add_argument('-g', '--gpu', type=int, default=0) args = parser.parse_args() # other settings camera_distance = 2.732 elevation = 30 texture_size = 2 # load .obj vertices, faces = nr.load_obj(args.filename_input) vertices = torch.FloatTensor([[0, 0, 0], [0, 1.5, 0], [1, 0, 0]]).cuda() faces = torch.IntTensor([[0, 1, 2]]).cuda() # self.register_buffer('vertices', vertices[None, :, :]) # self.register_buffer('faces', faces[None, :, :]) vertices = vertices[ None, :, :] # [num_vertices, XYZ] -> [batch_size=1, num_vertices, XYZ] faces = faces[None, :, :] # [num_faces, 3] -> [batch_size=1, num_faces, 3] # create texture [batch_size=1, num_faces, texture_size, texture_size, texture_size, RGB] textures = torch.ones(1, faces.shape[1], texture_size, texture_size, texture_size, 3, dtype=torch.float32).cuda() # to gpu # create renderer renderer = nr.Renderer(camera_mode='canonical') # draw object loop = tqdm.tqdm(range(0, 360, 4)) writer = imageio.get_writer(args.filename_output, mode='I') for num, azimuth in enumerate(loop): loop.set_description('Drawing') renderer.eye = [0, 0, -5] images, _, _ = renderer( vertices, faces, textures) # [batch_size, RGB, image_size, image_size] image = images.detach().cpu().numpy()[0].transpose( (1, 2, 0)) # [image_size, image_size, RGB] imsave('./examples/tmp/_tmp_test.png', image) # writer.append_data((255*image).astype(np.uint8)) writer.close()
def load_teapot_batch(batch_size=4, target_num=2): vertices, faces = neural_renderer.load_obj('./tests/data/teapot.obj') textures = np.ones((faces.shape[0], 4, 4, 4, 3), 'float32') vertices, faces, textures = to_minibatch((vertices, faces, textures), batch_size, target_num) vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) return vertices, faces, textures
def init_rasterizer(self, obj_path, global_RT): self.cur_obj_path = obj_path obj_data = {} obj_data['v_attr'] , obj_data['f_attr'] = nr.load_obj(obj_path, normalization = False, use_cuda = False) self.rasterizer = network.Rasterizer(self.cfg, obj_data = obj_data, # preset_uv_path = cfg.DATASET_FVV.UV_PATH, global_RT = global_RT) self.rasterizer.cuda()
def load_teapot_batch(batch_size=4, target_num=2): vertices, faces = neural_renderer.load_obj('./tests/data/teapot.obj') textures = np.ones((faces.shape[0], 4, 4, 4, 3), 'float32') vertices, faces, textures = to_minibatch((vertices, faces, textures), batch_size, target_num) vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) return vertices, faces, textures
def __init__(self, filename_obj, batch_size=10, image_size=256): super(VertexPredictor, self).__init__() vertices, faces = nr.load_obj(filename_obj) vertices[:,1] = - vertices[:,1] vertices = vertices[None, :, :] vertices = np.tile(vertices, (batch_size,1,1)) faces = faces[None, :, :] faces = np.tile(faces, (batch_size,1,1)) self.vertices = nn.Parameter(torch.from_numpy(vertices)) self.register_buffer('faces', torch.from_numpy(faces))
def run(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--filename_input', type=str, default='./examples/data/teapot.obj') parser.add_argument('-o', '--filename_output', type=str, default='./examples/data/example1.gif') parser.add_argument('-g', '--gpu', type=int, default=0) args = parser.parse_args() working_directory = os.path.dirname(args.filename_output) # other settings camera_distance = 2.732 elevation = 30 # load .obj # vertices: [num_vertices, XYZ] # faces: # [num_faces, 3] vertices, faces = neural_renderer.load_obj(args.filename_input) vertices = vertices[None, :, :] # -> [batch_size=1, num_vertices, XYZ] # to gpu chainer.cuda.get_device_from_id(args.gpu).use() vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) # create renderer renderer = neural_renderer.Renderer() # draw object loop = tqdm.tqdm(range(0, 360, 4)) for num, azimuth in enumerate(loop): loop.set_description('Drawing') renderer.viewpoints = neural_renderer.get_points_from_angles( camera_distance, elevation, azimuth) images = renderer.render_silhouettes( vertices, faces) # [batch_size, RGB, image_size, image_size] image = images.data.get()[0] # [image_size, image_size] scipy.misc.toimage(image, cmin=0, cmax=1).save( '%s/_tmp_%04d.png' % (working_directory, num)) # generate gif (need ImageMagick) options = '-delay 8 -loop 0 -layers optimize' subprocess.call('convert %s %s/_tmp_*.png %s' % (options, working_directory, args.filename_output), shell=True) # remove temporary files for filename in glob.glob('%s/_tmp_*.png' % working_directory): os.remove(filename)
def test_texture(self): renderer = neural_renderer.Renderer() vertices, faces, textures = neural_renderer.load_obj( './tests/data/1cde62b063e14777c9152a706245d48/model.obj', load_texture=True) vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) renderer.eye = neural_renderer.get_points_from_angles(2, 15, 30) images = renderer.render(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]).data.get() scipy.misc.imsave('./tests/data/car.png', scipy.misc.toimage(images[0])) vertices, faces, textures = neural_renderer.load_obj( './tests/data/4e49873292196f02574b5684eaec43e9/model.obj', load_texture=True, texture_size=16) vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) renderer.eye = neural_renderer.get_points_from_angles(2, 15, -90) images = renderer.render(vertices[None, :, :], faces[None, :, :], textures[None, :, :, :, :, :]).data.get() scipy.misc.imsave('./tests/data/display.png', scipy.misc.toimage(images[0]))
def test_tetrahedron(self): vertices_ref = np.array( [ [1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 0.]], 'float32') faces_ref = np.array( [ [1, 3, 2], [3, 1, 0], [2, 0, 1], [0, 2, 3]], 'int32') vertices, faces = neural_renderer.load_obj('./tests/data/tetrahedron.obj', False) assert (np.allclose(vertices_ref, vertices)) assert (np.allclose(faces_ref, faces)) vertices, faces = neural_renderer.load_obj('./tests/data/tetrahedron.obj', True) assert (np.allclose(vertices_ref * 2 - 1.0, vertices)) assert (np.allclose(faces_ref, faces))
def __init__(self, filename_obj, texture_size=4, normalization=True): super(Mesh, self).__init__() with self.init_scope(): # load .obj vertices, faces = neural_renderer.load_obj(filename_obj, normalization) self.vertices = chainer.Parameter(vertices) self.faces = faces self.num_vertices = self.vertices.shape[0] self.num_faces = self.faces.shape[0] # create textures init = chainer.initializers.Normal() shape = (self.num_faces, texture_size, texture_size, texture_size, 3) self.textures = chainer.Parameter(init, shape) self.texture_size = texture_size
def run(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--filename_input', type=str, default='./examples/data/teapot.obj') parser.add_argument('-o', '--filename_output', type=str, default='./examples/data/example1.gif') parser.add_argument('-g', '--gpu', type=int, default=0) args = parser.parse_args() working_directory = os.path.dirname(args.filename_output) # other settings camera_distance = 2.732 elevation = 30 texture_size = 2 # load .obj vertices, faces = neural_renderer.load_obj(args.filename_input) vertices = vertices[None, :, :] # [num_vertices, XYZ] -> [batch_size=1, num_vertices, XYZ] faces = faces[None, :, :] # [num_faces, 3] -> [batch_size=1, num_faces, 3] # create texture [batch_size=1, num_faces, texture_size, texture_size, texture_size, RGB] textures = np.ones((1, faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') # to gpu chainer.cuda.get_device_from_id(args.gpu).use() vertices = chainer.cuda.to_gpu(vertices) faces = chainer.cuda.to_gpu(faces) textures = chainer.cuda.to_gpu(textures) # create renderer renderer = neural_renderer.Renderer() # draw object loop = tqdm.tqdm(range(0, 360, 4)) for num, azimuth in enumerate(loop): loop.set_description('Drawing') renderer.eye = neural_renderer.get_points_from_angles(camera_distance, elevation, azimuth) images = renderer.render(vertices, faces, textures) # [batch_size, RGB, image_size, image_size] image = images.data.get()[0].transpose((1, 2, 0)) # [image_size, image_size, RGB] scipy.misc.toimage(image, cmin=0, cmax=1).save('%s/_tmp_%04d.png' % (working_directory, num)) # generate gif (need ImageMagick) options = '-delay 8 -loop 0 -layers optimize' subprocess.call('convert %s %s/_tmp_*.png %s' % (options, working_directory, args.filename_output), shell=True) # remove temporary files for filename in glob.glob('%s/_tmp_*.png' % working_directory): os.remove(filename)
def __init__(self, filename_obj, filename_ref): super(Model, self).__init__() with self.init_scope(): # load .obj vertices, faces = neural_renderer.load_obj(filename_obj) self.vertices = vertices[None, :, :] self.faces = faces[None, :, :] # create textures texture_size = 4 textures = np.zeros((1, self.faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') self.textures = chainer.Parameter(textures) # load reference image self.image_ref = scipy.misc.imread(filename_ref).astype('float32') / 255. # setup renderer renderer = neural_renderer.Renderer() renderer.perspective = False renderer.light_intensity_directional = 0.0 renderer.light_intensity_ambient = 1.0 self.renderer = renderer
def test_teapot(self): vertices, faces = neural_renderer.load_obj('./tests/data/teapot.obj') assert (faces.shape[0] == 2464) assert (vertices.shape[0] == 1292)
def run(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--filename_input', type=str, default='./examples/data/teapot.obj') parser.add_argument('-bs', '--batch_size', type=int, default=1) parser.add_argument('-is', '--image_size', type=int, default=256) parser.add_argument('-us', '--unsafe', type=int, default=0) parser.add_argument('-g', '--gpu', type=int, default=0) args = parser.parse_args() # other settings camera_distance = 2.732 elevation = 30 texture_size = 2 # load .obj vertices, faces = neural_renderer.load_obj(args.filename_input) vertices = vertices[None, :, :] # [num_vertices, XYZ] -> [batch_size=1, num_vertices, XYZ] faces = faces[None, :, :] # [num_faces, 3] -> [batch_size=1, num_faces, 3] # create texture [batch_size=1, num_faces, texture_size, texture_size, texture_size, RGB] textures = np.ones((1, faces.shape[1], texture_size, texture_size, texture_size, 3), 'float32') # tile to minibatch vertices = np.tile(vertices, (args.batch_size, 1, 1)) faces = np.tile(faces, (args.batch_size, 1, 1)) textures = np.tile(textures, (args.batch_size, 1, 1, 1, 1, 1)) # to gpu chainer.cuda.get_device_from_id(args.gpu).use() vertices = chainer.Variable(chainer.cuda.to_gpu(vertices)) faces = chainer.cuda.to_gpu(faces) textures = chainer.Variable(chainer.cuda.to_gpu(textures)) # create renderer renderer = neural_renderer.Renderer() renderer.image_size = args.image_size # draw object times_forward = [] times_backward = [] loop = tqdm.tqdm(range(0, 360, 15)) for num, azimuth in enumerate(loop): loop.set_description('Drawing') renderer.eye = neural_renderer.get_points_from_angles(camera_distance, elevation, azimuth) time_start = time.time() images = renderer.render_silhouettes(vertices, faces) # [batch_size, image_size, image_size] _ = images.data[0, 0, 0].get() time_end = time.time() times_forward.append(time_end - time_start) loss = chainer.functions.sum(images) _ = loss.data.get() time_start = time.time() loss.backward() time_end = time.time() times_backward.append(time_end - time_start) print 'silhouette forward time: %.3f ms' % (np.sum(times_forward[1:]) / len(times_forward[1:])) print 'silhouette backward time: %.3f ms' % (np.sum(times_backward[1:]) / len(times_backward[1:])) # draw object times_forward = [] times_backward = [] loop = tqdm.tqdm(range(0, 360, 15)) for num, azimuth in enumerate(loop): loop.set_description('Drawing') renderer.eye = neural_renderer.get_points_from_angles(camera_distance, elevation, azimuth) time_start = time.time() images = renderer.render(vertices, faces, textures) # [batch_size, RGB, image_size, image_size] _ = images.data[0, 0, 0, 0].get() time_end = time.time() times_forward.append(time_end - time_start) loss = chainer.functions.sum(images) _ = loss.data.get() time_start = time.time() loss.backward() time_end = time.time() times_backward.append(time_end - time_start) print 'texture forward time: %.3f ms' % (np.sum(times_forward[1:]) / len(times_forward[1:])) print 'texture backward time: %.3f ms' % (np.sum(times_backward[1:]) / len(times_backward[1:]))