def test_homography_i_H_ref(batch_size, device_type): # generate input data device = torch.device(device_type) image_height, image_width = 32., 32. cx, cy = image_width / 2, image_height / 2 fx, fy = 1., 1. rx, ry, rz = 0., 0., 0. tx, ty, tz = 0., 0., 0. offset_x = 10. # we will apply a 10units offset to `i` camera eps = 1e-6 pinhole_ref = utils.create_pinhole(fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx, ty, tz) pinhole_ref = pinhole_ref.repeat(batch_size, 1).to(device) pinhole_i = utils.create_pinhole(fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx + offset_x, ty, tz) pinhole_i = pinhole_i.repeat(batch_size, 1).to(device) # compute homography from ref to i i_H_ref = tgm.homography_i_H_ref(pinhole_i, pinhole_ref) + eps i_H_ref_inv = torch.inverse(i_H_ref) # compute homography from i to ref ref_H_i = tgm.homography_i_H_ref(pinhole_ref, pinhole_i) + eps assert utils.check_equal_torch(i_H_ref_inv, ref_H_i) # evaluate function gradient assert gradcheck(tgm.homography_i_H_ref, ( utils.tensor_to_gradcheck_var(pinhole_ref) + eps, utils.tensor_to_gradcheck_var(pinhole_i) + eps, ), raise_exception=True)
def test_homography_i_H_ref(self): # generate input data image_height, image_width = 32., 32. cx, cy = image_width / 2, image_height / 2 fx, fy = 1., 1. rx, ry, rz = 0., 0., 0. tx, ty, tz = 0., 0., 0. offset_x = 10. # we will apply a 10units offset to `i` camera pinhole_ref = utils.create_pinhole(fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx, ty, tz) pinhole_i = utils.create_pinhole(fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx + offset_x, ty, tz) # compute homography from ref to i i_H_ref = tgm.homography_i_H_ref(pinhole_i, pinhole_ref) i_H_ref_inv = tgm.inverse(i_H_ref) # compute homography from i to ref ref_H_i = tgm.homography_i_H_ref(pinhole_ref, pinhole_i) res = utils.check_equal_torch(i_H_ref_inv, ref_H_i) self.assertTrue(res)
def test_homography_i_H_ref_gradcheck(self): # generate input data image_height, image_width = 32., 32. cx, cy = image_width / 2, image_height / 2 fx, fy = 1., 1. rx, ry, rz = 0., 0., 0. tx, ty, tz = 0., 0., 0. offset_x = 10. # we will apply a 10units offset to `i` camera pinhole_ref = utils.create_pinhole(fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx, ty, tz) pinhole_ref = utils.tensor_to_gradcheck_var(pinhole_ref) # to var pinhole_i = utils.create_pinhole(fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx + offset_x, ty, tz) pinhole_i = utils.tensor_to_gradcheck_var(pinhole_ref) # to var # evaluate function gradient res = gradcheck(tgm.homography_i_H_ref, ( pinhole_i, pinhole_ref, ), raise_exception=True) self.assertTrue(res)
def test_inverse_pinhole_matrix(batch_size, device_type): # generate input data image_height, image_width = 32., 32. cx, cy = image_width / 2, image_height / 2 fx, fy = 1., 1. rx, ry, rz = 0., 0., 0. tx, ty, tz = 0., 0., 0. offset_x = 10. # we will apply a 10units offset to `i` camera eps = 1e-6 pinhole = utils.create_pinhole( fx, fy, cx, cy, image_height, image_width, rx, ry, rx, tx, ty, tz) pinhole = pinhole.repeat(batch_size, 1).to(torch.device(device_type)) pinhole_matrix = tgm.inverse_pinhole_matrix(pinhole) ones = torch.ones(batch_size) assert utils.check_equal_torch(pinhole_matrix[:, 0, 0], (1. / fx) * ones) assert utils.check_equal_torch(pinhole_matrix[:, 1, 1], (1. / fy) * ones) assert utils.check_equal_torch( pinhole_matrix[:, 0, 2], (-1. * cx / fx) * ones) assert utils.check_equal_torch( pinhole_matrix[:, 1, 2], (-1. * cy / fx) * ones) # functional assert tgm.InversePinholeMatrix()(pinhole).shape == (batch_size, 4, 4) # evaluate function gradient pinhole = utils.tensor_to_gradcheck_var(pinhole) # to var assert gradcheck(tgm.pinhole_matrix, (pinhole,), raise_exception=True)
def test_depth_warper(self): # generate input data batch_size = 1 height, width = 8, 8 cx, cy = width / 2, height / 2 fx, fy = 1., 1. rx, ry, rz = 0., 0., 0. tx, ty, tz = 0., 0., 0. offset = 1. # we will apply a 1unit offset to `i` camera pinhole_ref = utils.create_pinhole(fx, fy, cx, cy, height, width, rx, ry, rx, tx, ty, tz) pinhole_ref = pinhole_ref.expand(batch_size, -1) pinhole_i = utils.create_pinhole(fx, fy, cx, cy, height, width, rx, ry, rx, tx + offset, ty + offset, tz) pinhole_i = pinhole_i.expand(batch_size, -1) # create checkerboard board = utils.create_checkerboard(height, width, 4) patch_i = torch.from_numpy(board).view(1, 1, height, width).expand( batch_size, 1, height, width) # instantiate warper and compute relative homographies warper = tgm.DepthWarper(pinhole_i) warper.compute_homographies(pinhole_ref, scale=torch.ones(batch_size, 1)) # generate synthetic inverse depth inv_depth_ref = torch.ones(batch_size, 1, height, width) # warpd source patch by depth patch_ref = warper(inv_depth_ref, patch_i) # compute error res = utils.check_equal_torch( patch_ref[..., :int(height - offset), :int(width - offset)], patch_i[..., int(offset):, int(offset):]) self.assertTrue(res) # test functional patch_ref_functional = tgm.depth_warp(pinhole_i, pinhole_ref, inv_depth_ref, patch_i) res = utils.check_equal_torch(patch_ref, patch_ref_functional) self.assertTrue(res)