def run_scene_optimizer() -> None:
""" """
with initialize_config_module(config_module="gtsfm.configs"):
# config is relative to the gtsfm module
cfg = compose(config_name="default_lund_door_set1_config.yaml")
scene_optimizer: SceneOptimizer = instantiate(cfg.SceneOptimizer)
loader = OlssonLoader(os.path.join(DATA_ROOT, "set1_lund_door"),
image_extension="JPG")
sfm_result_graph = scene_optimizer.create_computation_graph(
num_images=len(loader),
image_pair_indices=loader.get_valid_pairs(),
image_graph=loader.create_computation_graph_for_images(),
camera_intrinsics_graph=loader.
create_computation_graph_for_intrinsics(),
gt_pose_graph=loader.create_computation_graph_for_poses(),
)
# create dask client
cluster = LocalCluster(n_workers=2, threads_per_worker=4)
with Client(cluster), performance_report(filename="dask-report.html"):
sfm_result = sfm_result_graph.compute()
assert isinstance(sfm_result, GtsfmData)
def test_get_camera_intrinsics_exif(self):
"""Tests getter for intrinsics when explicit numpy arrays are absent and we fall back on exif."""
loader = OlssonLoader(EXIF_FOLDER,
image_extension="JPG",
use_gt_intrinsics=False)
computed = loader.get_camera_intrinsics(5)
expected = Cal3Bundler(fx=2378.983, k1=0, k2=0, u0=648.0, v0=968.0)
self.assertTrue(expected.equals(computed, 1e-3))
def construct_loader(self) -> LoaderBase:
loader = OlssonLoader(
self.parsed_args.dataset_root,
image_extension=self.parsed_args.image_extension,
max_frame_lookahead=self.parsed_args.max_frame_lookahead,
max_resolution=self.parsed_args.max_resolution,
)
return loader
def test_exhaustive_retriever_door(self) -> None:
"""Test the Exhaustive retriever on 12 frames of the Lund Door Dataset."""
loader = OlssonLoader(folder=DOOR_DATA_ROOT, image_extension="JPG")
retriever = ExhaustiveRetriever()
# create dask client
cluster = LocalCluster(n_workers=1, threads_per_worker=4)
pairs_graph = retriever.create_computation_graph(loader=loader)
with Client(cluster):
pairs = pairs_graph.compute()
# {12 \choose 2} = (12 * 11) / 2 = 66
self.assertEqual(len(pairs), 66)
for (i1, i2) in pairs:
self.assertTrue(i1 < i2)
def test_create_computation_graph(self):
"""Will test Dask multi-processing capabilities and ability to serialize all objects."""
self.loader = OlssonLoader(str(DATA_ROOT_PATH / "set1_lund_door"),
image_extension="JPG")
with hydra.initialize_config_module(config_module="gtsfm.configs"):
# config is relative to the gtsfm module
cfg = hydra.compose(
config_name="scene_optimizer_unit_test_config.yaml")
scene_optimizer: SceneOptimizer = instantiate(cfg.SceneOptimizer)
# generate the dask computation graph
delayed_sfm_result, delayed_io = scene_optimizer.create_computation_graph(
num_images=len(self.loader),
image_pair_indices=self.loader.get_valid_pairs(),
image_graph=self.loader.create_computation_graph_for_images(),
all_intrinsics=self.loader.get_all_intrinsics(),
image_shapes=self.loader.get_image_shapes(),
absolute_pose_priors=self.loader.get_absolute_pose_priors(),
relative_pose_priors=self.loader.get_relative_pose_priors(
self.loader.get_valid_pairs()),
cameras_gt=self.loader.get_gt_cameras(),
gt_wTi_list=self.loader.get_gt_poses(),
)
# create dask client
cluster = LocalCluster(n_workers=1, threads_per_worker=4)
with Client(cluster):
sfm_result, *io = dask.compute(delayed_sfm_result, *delayed_io)
self.assertIsInstance(sfm_result, GtsfmData)
# compare the camera poses
computed_poses = sfm_result.get_camera_poses()
# get active cameras from largest connected component, may be <len(self.loader)
connected_camera_idxs = sfm_result.get_valid_camera_indices()
expected_poses = [
self.loader.get_camera_pose(i) for i in connected_camera_idxs
]
self.assertTrue(
comp_utils.compare_global_poses(computed_poses,
expected_poses,
trans_err_atol=1.0,
trans_err_rtol=0.1))
def test_sequential_retriever(self) -> None:
"""Assert that we get 30 total matches with a lookahead of 3 frames on the Door Dataset."""
max_frame_lookahead = 3
loader = OlssonLoader(str(DEFAULT_FOLDER),
image_extension="JPG",
max_frame_lookahead=max_frame_lookahead)
retriever = SequentialRetriever(
max_frame_lookahead=max_frame_lookahead)
pairs = retriever.run(loader=loader)
expected_pairs = [
(0, 1),
(0, 2),
(0, 3),
(1, 2),
(1, 3),
(1, 4),
(2, 3),
(2, 4),
(2, 5),
(3, 4),
(3, 5),
(3, 6),
(4, 5),
(4, 6),
(4, 7),
(5, 6),
(5, 7),
(5, 8),
(6, 7),
(6, 8),
(6, 9),
(7, 8),
(7, 9),
(7, 10),
(8, 9),
(8, 10),
(8, 11),
(9, 10),
(9, 11),
(10, 11),
]
self.assertEqual(pairs, expected_pairs)
# all images have 3 potential forward match pairs, except last three
# which have only 2, 1, and 0 such forward pairs
self.assertEqual(len(pairs), (9 * 3) + 2 + 1)
def testSimpleTriangulationOnDoorDataset(self):
"""Test the tracks of the door dataset using simple triangulation initialization. Using computed tracks with
ground truth camera params.
Expecting failures on 2 tracks which have incorrect matches."""
with open(DOOR_TRACKS_PATH, "rb") as handle:
tracks = pickle.load(handle)
loader = OlssonLoader(DOOR_DATASET_PATH, image_extension="JPG")
camera_dict = {
i: PinholeCameraCal3Bundler(loader.get_camera_pose(i),
loader.get_camera_intrinsics(i))
for i in range(len(loader))
}
initializer = Point3dInitializer(camera_dict,
TriangulationParam.NO_RANSAC,
reproj_error_thresh=1e5)
# tracks which have expected failures
# (both tracks have incorrect measurements)
expected_failures = [
SfmTrack2d(measurements=[
SfmMeasurement(i=1,
uv=np.array([1252.22729492, 1487.29431152])),
SfmMeasurement(i=2,
uv=np.array([1170.96679688, 1407.35876465])),
SfmMeasurement(i=4, uv=np.array([263.32104492, 1489.76965332
])),
]),
SfmTrack2d(measurements=[
SfmMeasurement(i=6, uv=np.array([1142.34545898, 735.92169189
])),
SfmMeasurement(i=7, uv=np.array([1179.84155273, 763.04095459
])),
SfmMeasurement(i=9, uv=np.array([216.54107666, 774.74017334])),
]),
]
for track_2d in tracks:
triangulated_track, _, _ = initializer.triangulate(track_2d)
if triangulated_track is None:
# assert we have failures which are already expected
self.assertIn(track_2d, expected_failures)
def test_lund_door(self):
"""Unit Test on the door dataset."""
loader = OlssonLoader(str(DATA_ROOT_PATH / "set1_lund_door"),
image_extension="JPG")
# we will use ground truth poses to generate relative rotations and relative unit translations
wTi_expected_list = [
loader.get_camera_pose(x) for x in range(len(loader))
]
wRi_list = [x.rotation() for x in wTi_expected_list]
wti_expected_list = [x.translation() for x in wTi_expected_list]
i2Ui1_dict = dict()
for (i1, i2) in loader.get_valid_pairs():
i2Ti1 = wTi_expected_list[i2].between(wTi_expected_list[i1])
i2Ui1_dict[(i1, i2)] = Unit3((i2Ti1.translation()))
self.__execute_test(i2Ui1_dict, wRi_list, wti_expected_list)
def test_create_computation_graph(self):
"""Will test Dask multi-processing capabilities and ability to serialize all objects."""
self.loader = OlssonLoader(str(DATA_ROOT_PATH / "set1_lund_door"),
image_extension="JPG")
with initialize_config_module(config_module="gtsfm.configs"):
# config is relative to the gtsfm module
cfg = compose(config_name="scene_optimizer_unit_test_config.yaml")
obj: SceneOptimizer = instantiate(cfg.SceneOptimizer)
# generate the dask computation graph
sfm_result_graph = obj.create_computation_graph(
len(self.loader),
self.loader.get_valid_pairs(),
self.loader.create_computation_graph_for_images(),
self.loader.create_computation_graph_for_intrinsics(),
gt_pose_graph=self.loader.create_computation_graph_for_poses(),
)
# create dask client
cluster = LocalCluster(n_workers=1, threads_per_worker=4)
with Client(cluster):
sfm_result = dask.compute(sfm_result_graph)[0]
self.assertIsInstance(sfm_result, GtsfmData)
# compare the camera poses
computed_poses = sfm_result.get_camera_poses()
computed_rotations = [x.rotation() for x in computed_poses]
computed_translations = [x.translation() for x in computed_poses]
# get active cameras from largest connected component, may be <len(self.loader)
connected_camera_idxs = sfm_result.get_valid_camera_indices()
expected_poses = [
self.loader.get_camera_pose(i) for i in connected_camera_idxs
]
self.assertTrue(
comp_utils.compare_global_poses(expected_poses,
expected_poses))
def view_scene(args: argparse.Namespace) -> None:
"""Read Olsson Dataset ground truth from a data.mat file and render the scene to the GUI.
Args:
args: rendering options.
"""
loader = OlssonLoader(
args.dataset_root,
image_extension=args.image_extension,
max_frame_lookahead=DUMMY_MAX_FRAME_LOOKAHEAD,
max_resolution=args.max_resolution,
)
open3d_vis_utils.draw_scene_open3d(
point_cloud=loader._point_cloud,
rgb=np.ones_like(loader._point_cloud).astype(np.uint8),
wTi_list=loader._wTi_list,
calibrations=[loader.get_camera_intrinsics_full_res(0)] *
loader._num_imgs,
args=args,
)
def setUp(self):
self.descriptor = DummyDescriptor()
self.loader = OlssonLoader(str(TEST_DATA_PATH), image_extension="JPG")
def test_get_camera_pose_missing(self):
"""Tests that the camera pose is None, because it is missing on disk."""
loader = OlssonLoader(str(NO_EXTRINSICS_FOLDER), image_extension="JPG")
fetched_pose = loader.get_camera_pose(5)
self.assertIsNone(fetched_pose)
def setUp(self):
"""Set up the loader for the test."""
super().setUp()
self.loader = OlssonLoader(str(DEFAULT_FOLDER), image_extension="JPG")
def test_get_camera_intrinsics_missing(self):
"""Tests getter for intrinsics when explicit numpy arrays are absent and we fall back on exif."""
loader = OlssonLoader(NO_EXIF_FOLDER, image_extension="JPG")
computed = loader.get_camera_intrinsics(5)
self.assertIsNone(computed)
def setUp(self) -> None:
self.loader = OlssonLoader(str(DATA_ROOT_PATH / "set1_lund_door"),
image_extension="JPG")
assert len(self.loader)
def setUp(self):
super().setUp()
self.detector = DummyDetector()
self.loader = OlssonLoader(TEST_DATA_PATH, image_extension="JPG")