def test_t265_db_only(self):
kapture_data = import_colmap_database(self._database_filepath,
self._kapture_dirpath,
no_geometric_filtering=True)
# check the numbers
self.assertEqual(2, len(kapture_data.sensors))
self.assertEqual(6, len(kapture_data.trajectories))
self.assertEqual(6, len(kapture_data.records_camera))
# check camera ids
camera_ids_expected = set(['cam_00001', 'cam_00002'
]) # may evolve in future, not crucial
camera_ids_actual = set(kapture_data.sensors.keys())
self.assertEqual(camera_ids_expected, camera_ids_actual)
# check camera ids consistent in trajectories
camera_ids_trajectories = set(
cam_id
for _, cam_id, _ in kapture.flatten(kapture_data.trajectories))
self.assertEqual(camera_ids_actual, camera_ids_trajectories)
# check camera ids consistent in records_camera
camera_ids_records = set(
cam_id
for _, cam_id, _ in kapture.flatten(kapture_data.records_camera))
self.assertEqual(camera_ids_actual, camera_ids_records)
# check camera parameters
cam1 = kapture_data.sensors['cam_00001']
self.assertIsInstance(cam1, kapture.Camera)
self.assertEqual('camera', cam1.sensor_type)
self.assertEqual(kapture.CameraType.OPENCV_FISHEYE, cam1.camera_type)
params_expected = [
848.0, 800.0, 284.468, 285.51, 424.355, 393.742, 0.0008, 0.031,
-0.03, 0.005
]
self.assertAlmostEqual(params_expected, cam1.camera_params)
# check records
timestamp, cam_id, image = next(
kapture.flatten(kapture_data.records_camera, is_sorted=True))
self.assertEqual(1, timestamp)
self.assertEqual('cam_00002', cam_id)
self.assertEqual('rightraw/frame_000000001.jpg', image)
# check trajectories
timestamp, cam_id, pose = next(
kapture.flatten(kapture_data.trajectories, is_sorted=True))
self.assertEqual(1, timestamp)
self.assertEqual('cam_00002', cam_id)
pose_expected = kapture.PoseTransform(
r=[
0.9540331248716523, -0.03768128483784883, -0.2972570621910482,
-0.0062565444214723875
],
t=[2.7109402281860904, 0.13236653865769618, -2.868626176500939])
self.assertTrue(equal_poses(pose_expected, pose))
# this sample has no keypoints, descriptors nor matches
self.assertFalse(
path.exists(path.join(self._kapture_dirpath, 'reconstruction')))
def test_maupertuis_import_db_only(self):
kapture_data = import_colmap_database(self._database_filepath, self._temp_dirpath,
no_geometric_filtering=True)
# check the numbers
self.assertIsNone(kapture_data.trajectories)
self.assertIsNone(kapture_data.points3d)
self.assertIsNone(kapture_data.records_lidar)
self.assertIsNone(kapture_data.records_wifi)
self.assertIsNone(kapture_data.records_gnss)
self.assertEqual(1, len(kapture_data.sensors))
self.assertEqual(4, len(kapture_data.records_camera))
self.assertEqual(4, len(kapture_data.keypoints))
self.assertEqual(4, len(kapture_data.descriptors))
self.assertEqual(6, len(kapture_data.matches))
# check camera
camera = kapture_data.sensors['cam_00001']
self.assertEqual(kapture.SENSOR_TYPE_CAMERA, camera.sensor_type)
self.assertEqual(kapture.CameraType.SIMPLE_PINHOLE, camera.camera_type)
self.assertAlmostEqual(camera.camera_params, [1919.0, 1079.0, 2302.7999999999997, 959.5, 539.5])
# check snapshots
snapshots = kapture_data.records_camera
self.assertTrue(all('cam_00001' in ts for ts in snapshots.values()))
self.assertEqual(['00.jpg', '01.jpg', '02.jpg', '03.jpg'],
[filename for _, _, filename in kapture.flatten(snapshots, True)])
# check keypoints
keypoints = kapture_data.keypoints
self.assertEqual(np.float32, keypoints.dtype)
self.assertEqual(6, keypoints.dsize)
self.assertEqual({'00.jpg', '01.jpg', '02.jpg', '03.jpg'}, keypoints)
keypoints_filepaths_actual = kapture.io.features.keypoints_to_filepaths(keypoints, self._temp_dirpath)
keypoints_filepaths_expected = {
f'{i:02d}.jpg': path_secure(f'{self._temp_dirpath}/reconstruction/keypoints/{i:02d}.jpg.kpt')
for i in [0, 1, 2, 3]}
self.assertDictEqual(keypoints_filepaths_actual, keypoints_filepaths_expected)
# check a keypoints file
image_keypoints_filepaths = sorted(
kapture.io.features.keypoints_to_filepaths(keypoints, self._temp_dirpath).values())
image_keypoints = image_keypoints_from_file(image_keypoints_filepaths[0], keypoints.dtype, keypoints.dsize)
self.assertEqual((6424, 6), image_keypoints.shape)
self.assertAlmostEqual([1290.908447265625, 4.156360626220703, -1.3475048542022705,
1.4732409715652466, -1.4732409715652466, -1.3475048542022705],
image_keypoints[0].tolist())
self.assertAlmostEqual([1381.316650390625, 668.8056640625, 59.981021881103516,
46.423213958740234, -46.423213958740234, 59.981021881103516],
image_keypoints[-1].tolist())
# check descriptors
descriptors = kapture_data.descriptors
self.assertEqual(np.uint8, descriptors.dtype)
self.assertEqual(128, descriptors.dsize)
self.assertEqual({'00.jpg', '01.jpg', '02.jpg', '03.jpg'}, descriptors)
descriptors_filepaths_actual = kapture.io.features.descriptors_to_filepaths(descriptors, self._temp_dirpath)
descriptors_filepaths_expected = {
f'{i:02d}.jpg': path_secure(f'{self._temp_dirpath}/reconstruction/descriptors/{i:02d}.jpg.desc')
for i in [0, 1, 2, 3]}
self.assertDictEqual(descriptors_filepaths_actual, descriptors_filepaths_expected)
# check a descriptors file
image_descriptors_filepaths = sorted(kapture.io.features.descriptors_to_filepaths(
descriptors, self._temp_dirpath).values())
image_descriptors = image_descriptors_from_file(
image_descriptors_filepaths[0], descriptors.dtype, descriptors.dsize)
self.assertEqual(image_keypoints.shape[0], image_descriptors.shape[0])
# check matches
matches = kapture_data.matches
self.assertEqual({('01.jpg', '03.jpg'), ('00.jpg', '02.jpg'),
('00.jpg', '03.jpg'), ('02.jpg', '03.jpg'),
('00.jpg', '01.jpg'), ('01.jpg', '02.jpg')},
set(matches))