def incremental_reconstruction(data, tracks_manager):
"""Run the entire incremental reconstruction pipeline."""
logger.info("Starting incremental reconstruction")
report = {}
chrono = Chronometer()
images = tracks_manager.get_shot_ids()
if not data.reference_lla_exists():
data.invent_reference_lla(images)
remaining_images = set(images)
camera_priors = data.load_camera_models()
gcp = data.load_ground_control_points()
common_tracks = tracking.all_common_tracks(tracks_manager)
reconstructions = []
pairs = compute_image_pairs(common_tracks, camera_priors, data)
chrono.lap("compute_image_pairs")
report["num_candidate_image_pairs"] = len(pairs)
report["reconstructions"] = []
for im1, im2 in pairs:
if im1 in remaining_images and im2 in remaining_images:
rec_report = {}
report["reconstructions"].append(rec_report)
_, p1, p2 = common_tracks[im1, im2]
reconstruction, rec_report["bootstrap"] = bootstrap_reconstruction(
data, tracks_manager, camera_priors, im1, im2, p1, p2
)
if reconstruction:
remaining_images.remove(im1)
remaining_images.remove(im2)
reconstruction, rec_report["grow"] = grow_reconstruction(
data,
tracks_manager,
reconstruction,
remaining_images,
camera_priors,
gcp,
)
reconstructions.append(reconstruction)
reconstructions = sorted(reconstructions, key=lambda x: -len(x.shots))
rec_report["stats"] = compute_statistics(reconstruction)
logger.info(rec_report["stats"])
for k, r in enumerate(reconstructions):
logger.info(
"Reconstruction {}: {} images, {} points".format(
k, len(r.shots), len(r.points)
)
)
logger.info("{} partial reconstructions in total.".format(len(reconstructions)))
chrono.lap("compute_reconstructions")
report["wall_times"] = dict(chrono.lap_times())
report["not_reconstructed_images"] = list(remaining_images)
return report, reconstructions
def common_tracks_double_dict(tracks_manager):
"""List of track ids observed by each image pair.
Return a dict, ``res``, such that ``res[im1][im2]`` is the list of
common tracks between ``im1`` and ``im2``.
"""
common_tracks_per_pair = tracking.all_common_tracks(tracks_manager,
include_features=False)
res = {image: {} for image in tracks_manager.get_shot_ids()}
for (im1, im2), v in common_tracks_per_pair.items():
res[im1][im2] = v
res[im2][im1] = v
return res
def incremental_reconstruction(data, graph):
"""Run the entire incremental reconstruction pipeline."""
logger.info("Starting incremental reconstruction")
report = {}
chrono = Chronometer()
tracks, images = tracking.tracks_and_images(graph)
chrono.lap('load_tracks_graph')
if not data.reference_lla_exists():
data.invent_reference_lla(images)
remaining_images = set(images)
gcp = data.load_ground_control_points()
common_tracks = tracking.all_common_tracks(graph, tracks)
reconstructions = []
pairs = compute_image_pairs(common_tracks, data)
chrono.lap('compute_image_pairs')
report['num_candidate_image_pairs'] = len(pairs)
report['reconstructions'] = []
for im1, im2 in pairs:
if im1 in remaining_images and im2 in remaining_images:
rec_report = {}
report['reconstructions'].append(rec_report)
tracks, p1, p2 = common_tracks[im1, im2]
reconstruction, graph_inliers, rec_report[
'bootstrap'] = bootstrap_reconstruction(
data, graph, im1, im2, p1, p2)
if reconstruction:
remaining_images.remove(im1)
remaining_images.remove(im2)
reconstruction, rec_report['grow'] = grow_reconstruction(
data, graph, graph_inliers, reconstruction,
remaining_images, gcp)
reconstructions.append(reconstruction)
reconstructions = sorted(reconstructions,
key=lambda x: -len(x.shots))
rec_report['stats'] = compute_statistics(
reconstruction, graph_inliers)
logger.info(rec_report['stats'])
for k, r in enumerate(reconstructions):
logger.info("Reconstruction {}: {} images, {} points".format(
k, len(r.shots), len(r.points)))
logger.info("{} partial reconstructions in total.".format(
len(reconstructions)))
chrono.lap('compute_reconstructions')
report['wall_times'] = dict(chrono.lap_times())
report['not_reconstructed_images'] = list(remaining_images)
return report, reconstructions
def common_tracks_double_dict(graph):
"""List of track ids observed by each image pair.
Return a dict, ``res``, such that ``res[im1][im2]`` is the list of
common tracks between ``im1`` and ``im2``.
"""
tracks, images = tracking.tracks_and_images(graph)
common_tracks_per_pair = tracking.all_common_tracks(
graph, tracks, include_features=False)
res = {image: {} for image in images}
for (im1, im2), v in iteritems(common_tracks_per_pair):
res[im1][im2] = v
res[im2][im1] = v
return res
def incremental_reconstruction(data, graph):
"""Run the entire incremental reconstruction pipeline."""
logger.info("Starting incremental reconstruction")
report = {}
chrono = Chronometer()
tracks, images = tracking.tracks_and_images(graph)
chrono.lap('load_tracks_graph')
if not data.reference_lla_exists():
data.invent_reference_lla(images)
remaining_images = set(images)
gcp = None
if data.ground_control_points_exist():
gcp = data.load_ground_control_points()
common_tracks = tracking.all_common_tracks(graph, tracks)
reconstructions = []
pairs = compute_image_pairs(common_tracks, data)
chrono.lap('compute_image_pairs')
report['num_candidate_image_pairs'] = len(pairs)
report['reconstructions'] = []
for im1, im2 in pairs:
if im1 in remaining_images and im2 in remaining_images:
rec_report = {}
report['reconstructions'].append(rec_report)
tracks, p1, p2 = common_tracks[im1, im2]
reconstruction, rec_report['bootstrap'] = bootstrap_reconstruction(
data, graph, im1, im2, p1, p2)
if reconstruction:
remaining_images.remove(im1)
remaining_images.remove(im2)
reconstruction, rec_report['grow'] = grow_reconstruction(
data, graph, reconstruction, remaining_images, gcp)
reconstructions.append(reconstruction)
reconstructions = sorted(reconstructions,
key=lambda x: -len(x.shots))
for k, r in enumerate(reconstructions):
logger.info("Reconstruction {}: {} images, {} points".format(
k, len(r.shots), len(r.points)))
logger.info("{} partial reconstructions in total.".format(
len(reconstructions)))
chrono.lap('compute_reconstructions')
report['wall_times'] = dict(chrono.lap_times())
report['not_reconstructed_images'] = list(remaining_images)
return report, reconstructions
def compute_depthmaps(data, graph, reconstruction):
"""Compute and refine depthmaps for all shots."""
logger.info('Computing neighbors')
processes = data.config.get('processes', 1)
num_neighbors = data.config['depthmap_num_neighbors']
tracks, _ = tracking.tracks_and_images(graph)
common_tracks = tracking.all_common_tracks(graph,
tracks,
include_features=False)
neighbors = {}
for shot in reconstruction.shots.values():
neighbors[shot.id] = find_neighboring_images(shot, common_tracks,
reconstruction,
num_neighbors)
arguments = []
for shot in reconstruction.shots.values():
if len(neighbors[shot.id]) <= 1:
continue
min_depth, max_depth = compute_depth_range(graph, reconstruction, shot)
arguments.append(
(data, neighbors[shot.id], min_depth, max_depth, shot))
parallel_map(compute_depthmap_catched, arguments, processes)
arguments = []
for shot in reconstruction.shots.values():
if len(neighbors[shot.id]) <= 1:
continue
arguments.append((data, neighbors[shot.id], shot))
parallel_map(clean_depthmap_catched, arguments, processes)
arguments = []
for shot in reconstruction.shots.values():
if len(neighbors[shot.id]) <= 1:
continue
arguments.append((data, neighbors[shot.id], shot))
parallel_map(prune_depthmap_catched, arguments, processes)
merge_depthmaps(data, reconstruction)
