def run_dataset(data: DataSetBase, input, output):
recs_base = data.load_reconstruction(input)
if len(recs_base) == 0:
return
rec_base = recs_base[0]
tracks_manager = data.load_tracks_manager()
rec_base.add_correspondences_from_tracks_manager(tracks_manager)
images = data.images()
remaining_images = set(images) - set(rec_base.shots)
gcp = data.load_ground_control_points()
report = {}
rec_report = {}
report["extend_reconstruction"] = [rec_report]
rec, rec_report["grow"] = reconstruction.grow_reconstruction(
data,
tracks_manager,
rec_base,
remaining_images,
gcp,
)
rec_report["num_remaining_images"] = len(remaining_images)
report["not_reconstructed_images"] = list(remaining_images)
data.save_reconstruction([rec], output)
data.save_report(io.json_dumps(report), "reconstruction.json")
def run_dataset(data: DataSetBase):
""" Compute the SfM reconstruction. """
tracks_manager = data.load_tracks_manager()
report, reconstructions = reconstruction.incremental_reconstruction(
data, tracks_manager)
data.save_reconstruction(reconstructions)
data.save_report(io.json_dumps(report), "reconstruction.json")
def run_dataset(data: DataSetBase, input: str, output: str):
""" Reconstruct the from a prior reconstruction. """
tracks_manager = data.load_tracks_manager()
rec_prior = data.load_reconstruction(input)
if len(rec_prior) > 0:
report, rec = reconstruction.reconstruct_from_prior(
data, tracks_manager, rec_prior[0])
data.save_reconstruction([rec], output)
data.save_report(io.json_dumps(report), "reconstruction.json")
def run_dataset(data: DataSetBase, input: str, output: str):
""" Reconstruct the from a prior reconstruction. """
tracks_manager = data.load_tracks_manager()
rec_prior = data.load_reconstruction(input)
if len(rec_prior) > 0:
report, rec = reconstruction.reconstruct_from_prior(
data, tracks_manager, rec_prior[0])
# pyre-fixme[61]: `rec` may not be initialized here.
data.save_reconstruction([rec], output)
# pyre-fixme[61]: `report` may not be initialized here.
data.save_report(io.json_dumps(report), "reconstruction.json")
def run_dataset(data: DataSetBase):
""" Add delaunay meshes to the reconstruction. """
tracks_manager = data.load_tracks_manager()
reconstructions = data.load_reconstruction()
all_shot_ids = set(tracks_manager.get_shot_ids())
for r in reconstructions:
for shot in r.shots.values():
if shot.id in all_shot_ids:
vertices, faces = mesh.triangle_mesh(shot.id, r,
tracks_manager)
shot.mesh.vertices = vertices
shot.mesh.faces = faces
data.save_reconstruction(reconstructions,
filename="reconstruction.meshed.json",
minify=True)
def run_dataset(dataset: DataSetBase, input, output):
"""Bundle a reconstructions.
Args:
input: input reconstruction JSON in the dataset
output: input reconstruction JSON in the dataset
"""
reconstructions = dataset.load_reconstruction(input)
camera_priors = dataset.load_camera_models()
gcp = dataset.load_ground_control_points()
tracks_manager = dataset.load_tracks_manager()
# load the tracks manager and add its observations to the reconstruction
# go through all the points and add their shots
for reconstruction in reconstructions:
reconstruction.add_correspondences_from_tracks_manager(tracks_manager)
orec.bundle(reconstruction, camera_priors, gcp, dataset.config)
dataset.save_reconstruction(reconstructions, output)
def grow_reconstruction(
data: DataSetBase,
tracks_manager: pymap.TracksManager,
reconstruction: types.Reconstruction,
images: Set[str],
gcp: List[pymap.GroundControlPoint],
) -> Tuple[types.Reconstruction, Dict[str, Any]]:
"""Incrementally add shots to an initial reconstruction."""
config = data.config
report = {"steps": []}
camera_priors = data.load_camera_models()
rig_camera_priors = data.load_rig_cameras()
paint_reconstruction(data, tracks_manager, reconstruction)
align_reconstruction(reconstruction, gcp, config)
bundle(reconstruction, camera_priors, rig_camera_priors, None, config)
remove_outliers(reconstruction, config)
paint_reconstruction(data, tracks_manager, reconstruction)
should_bundle = ShouldBundle(data, reconstruction)
should_retriangulate = ShouldRetriangulate(data, reconstruction)
while True:
if config["save_partial_reconstructions"]:
paint_reconstruction(data, tracks_manager, reconstruction)
data.save_reconstruction(
[reconstruction],
"reconstruction.{}.json".format(
datetime.datetime.now().isoformat().replace(":", "_")),
)
candidates = reconstructed_points_for_images(tracks_manager,
reconstruction, images)
if not candidates:
break
logger.info("-------------------------------------------------------")
threshold = data.config["resection_threshold"]
min_inliers = data.config["resection_min_inliers"]
for image, _ in candidates:
ok, new_shots, resrep = resect(
data,
tracks_manager,
reconstruction,
image,
threshold,
min_inliers,
)
if not ok:
continue
images -= new_shots
bundle_shot_poses(
reconstruction,
new_shots,
camera_priors,
rig_camera_priors,
data.config,
)
logger.info(
f"Adding {' and '.join(new_shots)} to the reconstruction")
step = {
"images": list(new_shots),
"resection": resrep,
"memory_usage": current_memory_usage(),
}
report["steps"].append(step)
np_before = len(reconstruction.points)
triangulate_shot_features(tracks_manager, reconstruction,
new_shots, config)
np_after = len(reconstruction.points)
step["triangulated_points"] = np_after - np_before
if should_retriangulate.should():
logger.info("Re-triangulating")
align_reconstruction(reconstruction, gcp, config)
b1rep = bundle(reconstruction, camera_priors,
rig_camera_priors, None, config)
rrep = retriangulate(tracks_manager, reconstruction, config)
b2rep = bundle(reconstruction, camera_priors,
rig_camera_priors, None, config)
remove_outliers(reconstruction, config)
step["bundle"] = b1rep
step["retriangulation"] = rrep
step["bundle_after_retriangulation"] = b2rep
should_retriangulate.done()
should_bundle.done()
elif should_bundle.should():
align_reconstruction(reconstruction, gcp, config)
brep = bundle(reconstruction, camera_priors, rig_camera_priors,
None, config)
remove_outliers(reconstruction, config)
step["bundle"] = brep
should_bundle.done()
elif config["local_bundle_radius"] > 0:
bundled_points, brep = bundle_local(
reconstruction,
camera_priors,
rig_camera_priors,
None,
image,
config,
)
remove_outliers(reconstruction, config, bundled_points)
step["local_bundle"] = brep
break
else:
logger.info("Some images can not be added")
break
logger.info("-------------------------------------------------------")
align_reconstruction(reconstruction, gcp, config)
bundle(reconstruction, camera_priors, rig_camera_priors, gcp, config)
remove_outliers(reconstruction, config)
paint_reconstruction(data, tracks_manager, reconstruction)
return reconstruction, report
def grow_reconstruction(data: DataSetBase, tracks_manager, reconstruction,
images, camera_priors, gcp):
"""Incrementally add shots to an initial reconstruction."""
config = data.config
report = {"steps": []}
align_reconstruction(reconstruction, gcp, config)
bundle(reconstruction, camera_priors, None, config)
remove_outliers(reconstruction, config)
should_bundle = ShouldBundle(data, reconstruction)
should_retriangulate = ShouldRetriangulate(data, reconstruction)
while True:
if config["save_partial_reconstructions"]:
paint_reconstruction(data, tracks_manager, reconstruction)
data.save_reconstruction(
[reconstruction],
"reconstruction.{}.json".format(
datetime.datetime.now().isoformat().replace(":", "_")),
)
candidates = reconstructed_points_for_images(tracks_manager,
reconstruction, images)
if not candidates:
break
logger.info("-------------------------------------------------------")
threshold = data.config["resection_threshold"]
min_inliers = data.config["resection_min_inliers"]
for image, _ in candidates:
camera = reconstruction.cameras[data.load_exif(image)["camera"]]
metadata = get_image_metadata(data, image)
ok, resrep = resect(
tracks_manager,
reconstruction,
image,
camera,
metadata,
threshold,
min_inliers,
)
if not ok:
continue
bundle_single_view(reconstruction, image, camera_priors,
data.config)
logger.info("Adding {0} to the reconstruction".format(image))
step = {
"image": image,
"resection": resrep,
"memory_usage": current_memory_usage(),
}
report["steps"].append(step)
images.remove(image)
np_before = len(reconstruction.points)
triangulate_shot_features(tracks_manager, reconstruction, image,
config)
np_after = len(reconstruction.points)
step["triangulated_points"] = np_after - np_before
if should_retriangulate.should():
logger.info("Re-triangulating")
align_reconstruction(reconstruction, gcp, config)
b1rep = bundle(reconstruction, camera_priors, None, config)
rrep = retriangulate(tracks_manager, reconstruction, config)
b2rep = bundle(reconstruction, camera_priors, None, config)
remove_outliers(reconstruction, config)
step["bundle"] = b1rep
step["retriangulation"] = rrep
step["bundle_after_retriangulation"] = b2rep
should_retriangulate.done()
should_bundle.done()
elif should_bundle.should():
align_reconstruction(reconstruction, gcp, config)
brep = bundle(reconstruction, camera_priors, None, config)
remove_outliers(reconstruction, config)
step["bundle"] = brep
should_bundle.done()
elif config["local_bundle_radius"] > 0:
bundled_points, brep = bundle_local(reconstruction,
camera_priors, None, image,
config)
remove_outliers(reconstruction, config, bundled_points)
step["local_bundle"] = brep
break
else:
logger.info("Some images can not be added")
break
logger.info("-------------------------------------------------------")
align_reconstruction(reconstruction, gcp, config)
bundle(reconstruction, camera_priors, gcp, config)
remove_outliers(reconstruction, config)
paint_reconstruction(data, tracks_manager, reconstruction)
return reconstruction, report