def test_point_to_plane_gradICP_raises_value_error(self):
dtype = torch.float32
device = default_to_cpu_if_no_gpu("cuda")
rad = 0.2
transform = torch.tensor(
[
[np.cos(rad), -np.sin(rad), 0.0, 0.05],
[np.sin(rad), np.cos(rad), 0.0, 0.03],
[0.0, 0.0, 1.0, 0.01],
[0.0, 0.0, 0.0, 1.0],
],
device=device,
dtype=dtype,
)
src_pc = torch.rand((1, 5, 3), dtype=dtype, device=device)
tgt_pc = torch.rand((1, 8, 3), dtype=dtype, device=device)
tgt_normals = torch.rand((1, 8, 3), dtype=dtype, device=device)
initial_transform = torch.eye(4, device=device)
with pytest.raises(ValueError):
point_to_plane_gradICP(src_pc.unsqueeze(0), tgt_pc, tgt_normals,
initial_transform)
with pytest.raises(ValueError):
point_to_plane_gradICP(src_pc, tgt_pc.unsqueeze(0), tgt_normals,
initial_transform)
with pytest.raises(ValueError):
point_to_plane_gradICP(src_pc, tgt_pc, tgt_normals.unsqueeze(0),
initial_transform)
with pytest.raises(ValueError):
point_to_plane_gradICP(src_pc, tgt_pc, tgt_normals,
initial_transform.unsqueeze(0))
with pytest.raises(ValueError):
point_to_plane_gradICP(src_pc, tgt_pc, tgt_normals,
initial_transform[:3, :3])
def test_unhomogenize_points(self, device):
device = default_to_cpu_if_no_gpu(device)
# Copied Kornia testcase (and added a few).
# Points to unhomogenize
pts = torch.tensor(
[
[1.0, 2.0, 1.0],
[0.0, 1.0, 2.0],
[2.0, 1.0, 0.0],
[-1.0, -2.0, -1.0],
[0.0, 1.0, -2.0],
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
],
device=device,
)
pts_gt = torch.tensor(
[
[1.0, 2.0],
[0.0, 0.5],
[2.0, 1.0],
[1.0, 2.0],
[0.0, -0.5],
[0.0, 0.0],
[1.0, 0.0],
],
device=device,
)
pts_pred = gs.unhomogenize_points(pts)
assert_allclose(pts_pred, pts_gt)
def test_solve_linear_system_raises_type_error(self):
device = default_to_cpu_if_no_gpu("cuda")
A = torch.tensor(
[
[0.1, 0.7, 0.3, 0.6],
[0.5, 0.2, 0.4, 0.8],
[0.3, 0.9, 0.5, 0.2],
[0.8, 0.2, 0.3, 0.4],
[0.7, 0.9, 0.3, 0.8],
],
dtype=torch.float32,
device=device,
)
b = torch.tensor(
[
[0.7],
[0.2],
[0.9],
[0.2],
[0.9],
],
dtype=torch.float32,
device=device,
)
damp = torch.tensor(1e-8, device=device)
with pytest.raises(TypeError):
x = solve_linear_system(np.ones((5, 4)), b, damp)
with pytest.raises(TypeError):
x = solve_linear_system(A, np.ones((5, 1)), damp)
with pytest.raises(TypeError):
x = solve_linear_system(A, b, 5)
def test_solve_linear_system(self, device):
device = default_to_cpu_if_no_gpu(device)
A = torch.tensor(
[
[0.1, 0.7, 0.3, 0.6],
[0.5, 0.2, 0.4, 0.8],
[0.3, 0.9, 0.5, 0.2],
[0.8, 0.2, 0.3, 0.4],
[0.7, 0.9, 0.3, 0.8],
],
dtype=torch.float32,
device=device,
)
b = torch.tensor(
[
[0.7],
[0.2],
[0.9],
[0.2],
[0.9],
],
dtype=torch.float32,
device=device,
)
damp = 1e-8
x = solve_linear_system(A, b, damp)
res = A @ x
assert res.shape == b.shape
assert_allclose(res, b)
def test_groundtruth_raises_value_error(self, device):
device = default_to_cpu_if_no_gpu(device)
channels_first = False
rgbdimages = TestGroundTruth.init_rgbdimages(
device=device, channels_first=channels_first)
nopose_rgbdimages = TestGroundTruth.init_rgbdimages(device=device)
nopose_rgbdimages.poses = None
batch_rgbdimages = RGBDImages(
rgbdimages.rgb_image.repeat(2, 1, 1, 1, 1),
rgbdimages.depth_image.repeat(2, 1, 1, 1, 1),
rgbdimages.intrinsics.repeat(2, 1, 1, 1),
rgbdimages.poses.repeat(2, 1, 1, 1),
channels_first=channels_first,
).to(device)
tensor = torch.rand(1, 1, 4, 4)
odom = GroundTruthOdometryProvider()
with pytest.raises(ValueError):
odom = odom.provide(rgbdimages[:, 0], nopose_rgbdimages[:, 1])
with pytest.raises(ValueError):
odom = odom.provide(nopose_rgbdimages[:, 0], rgbdimages[:, 1])
with pytest.raises(ValueError):
odom = odom.provide(rgbdimages[:, 0], rgbdimages)
with pytest.raises(ValueError):
odom = odom.provide(rgbdimages, rgbdimages[:, 1])
with pytest.raises(ValueError):
odom = odom.provide(rgbdimages, batch_rgbdimages)
def test_cases_3_and_6(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
pixel_coords = torch.rand(2, 10, lastdim, device=device)
intrinsics_inv = torch.rand(2, 3, 3, device=device)
depths = torch.rand(2, 10, device=device)
cam_coords = gs.unproject_points(pixel_coords, intrinsics_inv, depths)
assert cam_coords.shape == (2, 10, 3)
def test_indexing(self):
device = default_to_cpu_if_no_gpu("cuda:0")
for channels_first in [False, True]:
# rgb_image
rgbdimages, *_ = TestRGBDImages.init_rgbdimages(
channels_first=channels_first, use_poses=True, device=device)
self.assertClose(rgbdimages.rgb_image, rgbdimages.rgb_image)
self.assertClose(rgbdimages[0:2, 0:2].rgb_image,
rgbdimages.rgb_image[0:2, 0:2])
self.assertClose(
rgbdimages[1, 1].rgb_image.squeeze(0).squeeze(0),
rgbdimages.rgb_image[1, 1],
)
# depth_image
self.assertClose(rgbdimages.depth_image, rgbdimages.depth_image)
self.assertClose(rgbdimages[0:2, 0:2].depth_image,
rgbdimages.depth_image[0:2, 0:2])
self.assertClose(
rgbdimages[1, 1].depth_image.squeeze(0).squeeze(0),
rgbdimages.depth_image[1, 1],
)
# intrinsics
self.assertClose(rgbdimages.intrinsics, rgbdimages.intrinsics)
self.assertClose(rgbdimages[0:2, 0:1].intrinsics,
rgbdimages.intrinsics[0:2, 0:1])
self.assertClose(
rgbdimages[1, 0].intrinsics.squeeze(0).squeeze(0),
rgbdimages.intrinsics[1, 0],
)
# poses
self.assertClose(rgbdimages.poses, rgbdimages.poses)
self.assertClose(rgbdimages[0:2, 0:2].poses, rgbdimages.poses[0:2,
0:2])
self.assertClose(rgbdimages[1, 1].poses.squeeze(0).squeeze(0),
rgbdimages.poses[1, 1])
# vertex_map
self.assertClose(rgbdimages.vertex_map, rgbdimages.vertex_map)
self.assertClose(rgbdimages[0:2, 0:2].vertex_map,
rgbdimages.vertex_map[0:2, 0:2])
self.assertClose(
rgbdimages[1, 1].vertex_map.squeeze(0).squeeze(0),
rgbdimages.vertex_map[1, 1],
)
# normal_map
self.assertClose(rgbdimages.normal_map, rgbdimages.normal_map)
self.assertClose(rgbdimages[0:2, 0:2].normal_map,
rgbdimages.normal_map[0:2, 0:2])
self.assertClose(
rgbdimages[1, 1].normal_map.squeeze(0).squeeze(0),
rgbdimages.normal_map[1, 1],
)
def test_vertex_map(self):
device = default_to_cpu_if_no_gpu("cuda:0")
scriptdir = os.path.dirname(os.path.realpath(__file__))
gt_vmap = np.load(
os.path.join(scriptdir, "../data/msrd_b2s3/vertex_map.npy"))
gt_global_vmap = np.load(
os.path.join(scriptdir, "../data/msrd_b2s3/global_vertex_map.npy"))
for use_poses in [False, True]:
for channels_first in [False, True]:
rgbdimages, *_ = TestRGBDImages.init_rgbdimages(
channels_first=channels_first,
use_poses=use_poses,
device=device)
vertex_map = rgbdimages.vertex_map
global_vertex_map = rgbdimages.global_vertex_map
depth_image = rgbdimages.depth_image
intrinsics = rgbdimages.intrinsics
self.assertEqual(vertex_map.ndim, 5)
if channels_first:
vertex_map = vertex_map.permute(0, 1, 3, 4, 2).contiguous()
global_vertex_map = global_vertex_map.permute(
0, 1, 3, 4, 2).contiguous()
depth_image = depth_image.permute(0, 1, 3, 4,
2).contiguous()
self.assertEqual(vertex_map.shape, (2, 3, 120, 160, 3))
self.assertEqual(global_vertex_map.shape, (2, 3, 120, 160, 3))
self.assertEqual(depth_image.shape, (2, 3, 120, 160, 1))
for b in range(2):
for s in range(3):
vmap = vertex_map[b, s]
dmap = depth_image[b, s]
K = intrinsics[b, 0]
test_unproj_res = project_points(vmap, K)
meshgrid = (create_meshgrid(
120, 160, False).squeeze(0).to(device))
meshgrid = torch.cat(
[
meshgrid[..., 1:],
meshgrid[..., 0:1],
],
-1,
)
correct_unproj_res = meshgrid * (dmap != 0).float()
# self.assertClose() fails here, probably because not close enough?
assert (test_unproj_res -
correct_unproj_res).abs().max() < 1e-4
assert ((gt_vmap - vertex_map.cpu().numpy())**2).sum() < 1e-2
if use_poses:
assert ((gt_global_vmap - global_vertex_map.cpu().numpy())
**2).sum() < 1e-2
else:
assert ((gt_vmap - global_vertex_map.cpu().numpy())**
2).sum() < 1e-2
def test_groundtruth_raises_type_error(self, device):
device = default_to_cpu_if_no_gpu(device)
rgbdimages = TestGroundTruth.init_rgbdimages(device=device)
tensor = torch.rand(1, 1, 4, 4)
odom = GroundTruthOdometryProvider()
with pytest.raises(TypeError):
odom = odom.provide(rgbdimages[:, 0], tensor)
with pytest.raises(TypeError):
odom = odom.provide(tensor, rgbdimages[:, 0])
def test_groundtruth_provide(self, device):
device = default_to_cpu_if_no_gpu(device)
rgbdimages = TestGroundTruth.init_rgbdimages(device=device)
odom = GroundTruthOdometryProvider()
t = 0
odom_transform = odom.provide(rgbdimages[:, t], rgbdimages[:, t + 1])
new_pose = rgbdimages[:, t].poses.squeeze() @ odom_transform.squeeze()
assert odom_transform.shape == rgbdimages[:, t + 1].poses.shape
assert_allclose(new_pose.squeeze(), rgbdimages[:,
t + 1].poses.squeeze())
def test_output_shape(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
rand_vals = torch.rand(10, 4, device=device)
intrinsics = torch.zeros(10, lastdim, lastdim, device=device)
intrinsics[..., 0, 0] = rand_vals[:, 0] # fx
intrinsics[..., 1, 1] = rand_vals[:, 1] # fy
intrinsics[..., 0, 2] = rand_vals[:, 2] # cx
intrinsics[..., 1, 2] = rand_vals[:, 3] # cy
intrinsics[..., 2, 2] = 1
intrinsics[..., -1, -1] = 1
test_res = gs.inverse_intrinsics(intrinsics)
assert test_res.shape == intrinsics.shape
def test_type_errors(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
pixel_coords = [1, 2, 3]
intrinsics_inv = [1, 2, 3]
depths = [1, 2, 3]
with pytest.raises(TypeError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
pixel_coords = torch.rand(2, 10, lastdim, device=device)
with pytest.raises(TypeError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
intrinsics_inv = torch.rand(2, 3, 3, device=device)
with pytest.raises(TypeError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
def test_normal_map(self):
device = default_to_cpu_if_no_gpu("cuda:0")
def diff(x, y):
# normals on gpu give slightly different values at some pixels
return (((x - y)**2) < 1e-5).mean() > 0.99
scriptdir = os.path.dirname(os.path.realpath(__file__))
gt_nmap = np.load(
os.path.join(scriptdir, "../data/msrd_b2s3/normal_map.npy"))
gt_global_nmap = np.load(
os.path.join(scriptdir, "../data/msrd_b2s3/global_normal_map.npy"))
for use_poses in [False, True]:
for channels_first in [False, True]:
rgbdimages, *_ = TestRGBDImages.init_rgbdimages(
channels_first=channels_first,
use_poses=use_poses,
device=device)
normal_map = rgbdimages.normal_map
global_normal_map = rgbdimages.global_normal_map
self.assertEqual(normal_map.ndim, 5)
self.assertEqual(global_normal_map.ndim, 5)
remove_missing = global_normal_map * rgbdimages.valid_depth_mask.to(
global_normal_map.dtype)
assert ((global_normal_map - remove_missing)**
2).sum().item() < 1e-5
if channels_first:
normal_map = normal_map.permute(0, 1, 3, 4, 2).contiguous()
global_normal_map = global_normal_map.permute(
0, 1, 3, 4, 2).contiguous()
self.assertEqual(normal_map.shape, (2, 3, 120, 160, 3))
self.assertEqual(global_normal_map.shape, (2, 3, 120, 160, 3))
nmap = normal_map.detach().cpu().numpy()
global_nmap = global_normal_map.detach().cpu().numpy()
assert diff(gt_nmap, nmap)
if use_poses:
# # visualize normals
# import matplotlib.pyplot as plt
# fig, ax = plt.subplots(2, 2)
# ax[0, 0].imshow((nmap[-1, -1] * 255).astype(np.uint8))
# ax[0, 1].imshow((gt_nmap[-1, -1] * 255).astype(np.uint8))
# ax[1, 0].imshow((global_nmap[-1, -1] * 255).astype(np.uint8))
# ax[1, 1].imshow((gt_global_nmap[-1, -1] * 255).astype(np.uint8))
# plt.show()
assert diff(gt_global_nmap, global_nmap)
else:
assert diff(gt_nmap, global_nmap)
def test_value_errors(self, device):
device = default_to_cpu_if_no_gpu(device)
intrinsics = torch.rand(3, device=device)
with pytest.raises(ValueError):
gs.inverse_intrinsics(intrinsics)
intrinsics = torch.rand(2, 3, device=device)
with pytest.raises(ValueError):
gs.inverse_intrinsics(intrinsics)
intrinsics = torch.rand(3, 4, device=device)
with pytest.raises(ValueError):
gs.inverse_intrinsics(intrinsics)
intrinsics = torch.rand(5, 3, 4, device=device)
with pytest.raises(ValueError):
gs.inverse_intrinsics(intrinsics)
def test_simple(self):
device = default_to_cpu_if_no_gpu("cuda:0")
args = [(True, True), (True, False), (False, True), (False, False)]
for arg in args:
res_tuple = TestRGBDImages.init_rgbdimages(use_poses=arg[0],
channels_first=arg[1],
device=device)
rgbdimages, colors, depths, intrinsics, poses = res_tuple
self.assertEqual(rgbdimages.shape, (2, 3, 120, 160))
self.assertEqual(colors.shape, rgbdimages.rgb_image.shape)
self.assertEqual(depths.shape, rgbdimages.depth_image.shape)
self.assertEqual(intrinsics.shape, rgbdimages.intrinsics.shape)
self.assertEqual(colors.shape, rgbdimages.vertex_map.shape)
self.assertEqual(colors.shape, rgbdimages.normal_map.shape)
def test_output_values(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
rand_vals = torch.rand(4, device=device)
intrinsics = torch.zeros(lastdim, lastdim, device=device)
intrinsics[0, 0] = rand_vals[0] # fx
intrinsics[1, 1] = rand_vals[1] # fy
intrinsics[0, 2] = rand_vals[2] # cx
intrinsics[1, 2] = rand_vals[3] # cy
intrinsics[2, 2] = 1
intrinsics[-1, -1] = 1
test_res = gs.inverse_intrinsics(intrinsics)
correct_res = torch.inverse(intrinsics)
assert test_res.shape == intrinsics.shape
assert ((test_res - correct_res).abs().sum() /
correct_res.abs().sum()).item() < 1e-2
def test_gauss_newton_raises_type_error(self):
device = default_to_cpu_if_no_gpu("cuda")
src_pc = torch.tensor(
[
[0.1, 0.7, 0.3],
[0.5, 0.2, 0.4],
[0.3, 0.9, 0.5],
[0.8, 0.2, 0.3],
[0.7, 0.9, 0.3],
],
dtype=torch.float32,
device=device,
)
rad = 0.2
transform = torch.tensor(
[
[np.cos(rad), -np.sin(rad), 0.0, 0.05],
[np.sin(rad), np.cos(rad), 0.0, 0.03],
[0.0, 0.0, 1.0, 0.01],
[0.0, 0.0, 0.0, 1.0],
],
device=device,
dtype=src_pc.dtype,
)
tgt_pc = ((transform[:3, :3] @ src_pc.T) + transform[:-1, -1:]).T
tgt_normals = src_pc.clone()
src_pc = src_pc.unsqueeze(0)
tgt_pc = tgt_pc.unsqueeze(0)
tgt_normals = tgt_normals.unsqueeze(0)
dist_thresh = 0.2
with pytest.raises(TypeError):
x = gauss_newton_solve(src_pc.cpu().detach().numpy(), tgt_pc,
tgt_normals, dist_thresh)
with pytest.raises(TypeError):
x = gauss_newton_solve(src_pc,
tgt_pc.cpu().detach().numpy(), tgt_normals,
dist_thresh)
with pytest.raises(TypeError):
x = gauss_newton_solve(src_pc, tgt_pc,
tgt_normals.cpu().detach().numpy(),
dist_thresh)
with pytest.raises(TypeError):
x = gauss_newton_solve(src_pc, tgt_pc, tgt_normals,
torch.tensor(0.2, device=device))
def test_pointclouds_from_rgbdimages(self, channels_first, device):
device = default_to_cpu_if_no_gpu(device)
colors, depths, intrinsics, poses = load_test_data(channels_first)
rgbdimages = RGBDImages(
colors.to(device),
depths.to(device),
intrinsics.to(device),
poses.to(device),
channels_first=channels_first,
)
pointclouds = pointclouds_from_rgbdimages(rgbdimages[:, 0]).to(device)
projected_pointclouds = pointclouds.pinhole_projection(
intrinsics.to(device).squeeze(1))
proj0 = projected_pointclouds.points_list[0][..., :-1]
meshgrid = (create_meshgrid(rgbdimages.shape[2], rgbdimages.shape[3],
False).to(device).squeeze(0))
meshgrid = torch.cat(
[
meshgrid[..., 1:],
meshgrid[..., 0:1],
],
-1,
)
groundtruth = meshgrid[rgbdimages[0, 0].valid_depth_mask.squeeze()]
assert_allclose(proj0.round().float(), groundtruth.float())
# without filtering missing depths
pointclouds2 = pointclouds_from_rgbdimages(
rgbdimages[:, 0], filter_missing_depths=False).to(device)
for b in range(len(pointclouds)):
filtered_points = pointclouds.points_list[b]
unfiltered_points = pointclouds2.points_list[b]
m = 0
for n in range(len(filtered_points)):
while (not ((filtered_points[n] - unfiltered_points[m])**
2).sum() < 1e-12):
m += 1
assert ((filtered_points[n] - unfiltered_points[m])**
2).sum() < 1e-12
m += 1
def test_output_values_more_dims(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
rand_vals = torch.rand(5, 10, 4, device=device)
intrinsics = torch.zeros(5, 10, lastdim, lastdim, device=device)
intrinsics[..., 0, 0] = rand_vals[..., 0] # fx
intrinsics[..., 1, 1] = rand_vals[..., 1] # fy
intrinsics[..., 0, 2] = rand_vals[..., 2] # cx
intrinsics[..., 1, 2] = rand_vals[..., 3] # cy
intrinsics[..., 2, 2] = 1
intrinsics[..., -1, -1] = 1
test_res = gs.inverse_intrinsics(intrinsics)
correct_res = []
for b in range(5):
res = [torch.inverse(intrinsics[b, s]) for s in range(10)]
correct_res.append(torch.stack(res, 0))
correct_res = torch.stack(correct_res, 0)
assert test_res.shape == intrinsics.shape
assert ((test_res - correct_res).abs().sum() /
correct_res.abs().sum()).item() < 1e-2
def test_downsample_rgbdimages_raises_type_error(self):
device = default_to_cpu_if_no_gpu("cuda")
image = (torch.tensor(
[
[
[0.0, 0.0, 0.0],
[1.0, 1.0, 1.0],
[2.0, 2.0, 2.0],
[3.0, 3.0, 3.0],
],
[
[4.0, 4.0, 4.0],
[5.0, 5.0, 5.0],
[6.0, 6.0, 6.0],
[7.0, 7.0, 7.0],
],
[
[8.0, 8.0, 8.0],
[9.0, 9.0, 9.0],
[10.0, 10.0, 10.0],
[11.0, 11.0, 11.0],
],
],
device=device,
dtype=torch.float,
).unsqueeze(0).unsqueeze(0))
depth = torch.ones_like(image[..., :1])
intrinsics = torch.eye(4).unsqueeze(0).unsqueeze(0).to(device)
poses = torch.eye(4).unsqueeze(0).unsqueeze(0).to(device)
rgbdimages = RGBDImages(image,
depth,
intrinsics,
poses,
channels_first=False).to(device)
ds_ratio = 2
ds_pointclouds = downsample_rgbdimages(rgbdimages, ds_ratio)
with pytest.raises(TypeError):
downsample_rgbdimages("a", ds_ratio)
with pytest.raises(TypeError):
downsample_rgbdimages(rgbdimages, "a")
def test_raises_errors(self, device):
device = default_to_cpu_if_no_gpu(device)
channels_first = False
colors, depths, intrinsics, poses = load_test_data(channels_first)
rgbdimages = RGBDImages(
colors.to(device),
depths.to(device),
intrinsics.to(device),
poses.to(device),
channels_first=channels_first,
) # .to(device)
sigma = 0.6
with pytest.raises(
TypeError,
match="Expected rgbdimages to be of type gradslam.RGBDImages"):
pointclouds = pointclouds_from_rgbdimages(depths).to(device)
with pytest.raises(
ValueError,
match="Expected rgbdimages to have sequence length of 1"):
pointclouds = pointclouds_from_rgbdimages(rgbdimages).to(device)
def test_homogenize_points(self, device):
device = default_to_cpu_if_no_gpu(device)
# Points to homogenize
pts = torch.tensor(
[[1.0, 2.0, 3.0], [3.0, 2.0, 1.0], [-1.0, 0.0, 1.0],
[0.0, 0.0, 0.0]],
device=device,
)
pts_gt = torch.tensor(
[
[1.0, 2.0, 3.0, 1.0],
[3.0, 2.0, 1.0, 1.0],
[-1.0, 0.0, 1.0, 1.0],
[0.0, 0.0, 0.0, 1.0],
],
device=device,
)
pts_pred = gs.homogenize_points(pts)
assert_allclose(pts_pred, pts_gt)
def test_downsample_pointclouds_raises_value_error(self):
device = default_to_cpu_if_no_gpu("cuda")
points = torch.tensor(
[
[5.0, 5.0, 5.0],
[3.0, 3.0, 3.0],
[1.0, 2.0, 3.0],
[3.0, 2.0, 1.0],
[1.0, 0.0, 1.0],
[0.0, 0.0, 0.0],
],
device=device,
dtype=torch.float,
).unsqueeze(0)
normals = points * -1
pc2im_bnhw = torch.tensor(
[
[0, 0, 0, 0],
[0, 1, 4, 2],
[0, 2, 3, 1],
[0, 3, 0, 3],
[0, 4, 3, 3],
[0, 5, 3, 6],
],
device=device,
dtype=torch.int64,
)
pointclouds = Pointclouds(points, normals)
ds_ratio = 3
ds_pointclouds = downsample_pointclouds(pointclouds, pc2im_bnhw,
ds_ratio)
with pytest.raises(ValueError):
downsample_pointclouds(pointclouds, pc2im_bnhw.unsqueeze(1),
ds_ratio)
with pytest.raises(ValueError):
downsample_pointclouds(pointclouds, pc2im_bnhw.repeat(1, 2),
ds_ratio)
def test_solve_linear_system_raises_value_error(self):
device = default_to_cpu_if_no_gpu("cuda")
A = torch.tensor(
[
[0.1, 0.7, 0.3, 0.6],
[0.5, 0.2, 0.4, 0.8],
[0.3, 0.9, 0.5, 0.2],
[0.8, 0.2, 0.3, 0.4],
[0.7, 0.9, 0.3, 0.8],
],
dtype=torch.float32,
device=device,
)
b = torch.tensor(
[
[0.7],
[0.2],
[0.9],
[0.2],
[0.9],
],
dtype=torch.float32,
device=device,
)
damp = torch.tensor(1e-8, device=device)
with pytest.raises(ValueError):
x = solve_linear_system(A.unsqueeze(0), b, damp)
with pytest.raises(ValueError):
x = solve_linear_system(A, b.unsqueeze(0), damp)
with pytest.raises(ValueError):
x = solve_linear_system(A, b, damp.unsqueeze(0))
with pytest.raises(ValueError):
x = solve_linear_system(A, b.repeat(1, 2), damp)
with pytest.raises(ValueError):
x = solve_linear_system(A, b.repeat(2, 1), damp)
def test_value_errors(self, device):
device = default_to_cpu_if_no_gpu(device)
pixel_coords = torch.rand(2, device=device)
intrinsics_inv = torch.rand(3, 3, device=device)
depths = torch.rand(2, 10, device=device)
with pytest.raises(ValueError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
pixel_coords = torch.rand(2, 3, device=device)
intrinsics_inv = torch.rand(3, device=device)
with pytest.raises(ValueError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
intrinsics_inv = torch.rand(3, 3, device=device)
pixel_coords = torch.rand(2, 3, device=device)
depths = torch.rand(1, device=device)
with pytest.raises(ValueError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
pixel_coords = torch.rand(2, 1, 2, 3, device=device)
intrinsics_inv = torch.rand(1, 3, 3, device=device)
with pytest.raises(ValueError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
pixel_coords = torch.rand(2, 1, 2, 3, device=device)
intrinsics_inv = torch.rand(1, 3, 3, device=device)
with pytest.raises(ValueError):
gs.unproject_points(pixel_coords, intrinsics_inv, depths)
def test_value_error_proj_mat_2(self, device, dims):
device = default_to_cpu_if_no_gpu(device)
cam_coords = torch.rand(2, 2, device=device)
proj_mat = torch.rand(dims[0], dims[1], device=device)
with pytest.raises(ValueError):
gs.project_points(cam_coords, proj_mat)
def test_cases_1_and_4(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
cam_coords = torch.rand(10, lastdim, device=device)
proj_mat = torch.rand(4, 4, device=device)
pixel_coords = gs.project_points(cam_coords, proj_mat)
assert pixel_coords.shape == (10, 2)
def test_raises_dim_error(self, device):
device = default_to_cpu_if_no_gpu(device)
pts = torch.rand(3, device=device)
with pytest.raises(ValueError):
gs.unhomogenize_points(pts)
def test_value_error_batchsize_2(self, device):
device = default_to_cpu_if_no_gpu(device)
cam_coords = torch.rand(2, 10, 3, device=device)
proj_mat = torch.rand(1, 4, 4, device=device)
with pytest.raises(ValueError):
gs.project_points(cam_coords, proj_mat)
def test_type_errors(self, device, lastdim):
device = default_to_cpu_if_no_gpu(device)
intrinsics = [1, 2, 3]
with pytest.raises(TypeError):
gs.inverse_intrinsics(intrinsics)
