def test_chamfer_is_better_after_fit(self):
d = load_test_files()
dist_orig = metrics.chamfer_distance(d[0], d[1], scale=0.1)
vg_fit = fit.icp(d[1], d[0], scale=0.1)
dist_fit = metrics.chamfer_distance(d[0], vg_fit, scale=0.1)
self.assertLess(dist_fit, dist_orig,
"Distance was not lower after fitting with icp")
def test_voxelgrid_to_pointcloud_on_large_data(self):
d = load_test_files()
for i, vg_orig in enumerate(d):
pt_cloud = voxelgrid_to_pointcloud(vg_orig)
vg_new = pointcloud_to_voxelgrid(pt_cloud,
add_leading_dim=True,
add_trailing_dim=True)
self.assertTrue((vg_orig == vg_new).all(),
"Failed on point cloud {}".format(i))
def test_highest_match_using_fit_and_iou(self):
d = load_test_files()
base = d[0]
def m(vg1, vg2):
vg_fit = fit.icp(vg2, vg1, scale=0.1, max_iter=10, downsample=2)
return metrics.iou(vg1, vg_fit)
ind, elem = metrics.highest_match(base, d, m)
self.assertEqual(0, ind)
def test_highest_match_using_fit_and_chamfer_distance(self):
d = load_test_files()
base = d[2]
def m(vg1, vg2):
vg_fit = fit.icp(vg2, vg1, scale=0.1, max_iter=10, downsample=2)
return -metrics.chamfer_distance(vg1, vg_fit, scale=0.1, downsample=2)
ind, elem = metrics.highest_match(base, d, m)
self.assertEqual(2, ind)
def test_highest_match(self):
"""
Note that this test assumes that metric(a,b) is maximized when a==b
"""
d = load_test_files()
for i in range(3):
test_vg = d[i]
best_ind, best_elem = metrics.highest_match(test_vg, d)
self.assertEqual(i, best_ind, "Wrong index returned")
self.assertTrue((best_elem == d[i]).all(), "Returned element is not the best element")
def test_voxelgrid_to_pointcloud_with_scaling(self):
vg_orig = load_test_files()[0]
for scale in [0.01, 1.0, 10., 10000.]:
pt_cloud = voxelgrid_to_pointcloud(vg_orig, scale=scale)
vg_new = pointcloud_to_voxelgrid(pt_cloud,
scale=scale,
add_leading_dim=True,
add_trailing_dim=True,
shape=(64, 64, 64))
self.assertTrue((vg_orig == vg_new).all(),
"Failed on scaling {}".format(scale))
def test_get_aabb_returns_correct_shape_and_no_repeats(self):
vg_orig = load_test_files()[0]
bounds = bounding_box.get_aabb(vg_orig)
self.assertEqual((8, 3), bounds.shape)
pts = []
for pt in bounds:
self.assertFalse(tuple(pt) in pts)
pts.append(tuple(pt))
for vals in bounds.transpose():
self.assertEqual(2, len(set(vals)))
def test_transform_voxelgrid_is_invertable(self):
"""
Note, this is not necessarily true for rotation or fractional translation, as converting to a voxelgrid
effectively truncates to an int so there is a loss of precision
@return:
"""
T = make_transform(thetas=[0.0, 0, np.pi / 2], translation=[1, 2, 3])
T_inv = np.linalg.inv(T)
scale = 0.5
self.assertTrue((np.dot(T, T_inv) == np.eye(4)).all())
vg_orig = load_test_files()[0]
vg_rot = transform_voxelgrid(vg_orig, T, scale=scale)
self.assertFalse((vg_orig == vg_rot).all())
vg_new = transform_voxelgrid(vg_rot, T_inv, scale=scale)
self.assertTrue((vg_orig == vg_new).all())
def test_chamfer_distance_voxelgrid_on_real(self):
d = load_test_files()
self.assertEqual(0.0, metrics.chamfer_distance(d[0], d[0], scale=0.1))
self.assertGreater(metrics.chamfer_distance(d[0], d[1], scale=0.1),
0.0)
def test_iou_on_shapes(self):
d = load_test_files()
self.assertEqual(metrics.iou(d[0], d[0]), 1.0)
self.assertLess(metrics.iou(d[0], d[1]), 1.0)
self.assertEqual(metrics.iou(d[0], d[1]), metrics.iou(d[1], d[0]))
def test_transform_voxelgrid_using_identity(self):
vg_orig = load_test_files()[0]
T = np.eye(4)
vg_new = transform_voxelgrid(vg_orig, T)
self.assertTrue((vg_new == vg_orig).all())
