def reconstruction_from_metadata(data: DataSetBase, images: Iterable[str]) -> types.Reconstruction:
"""Initialize a reconstruction by using EXIF data for constructing shot poses and cameras."""
data.init_reference()
rig_assignments = rig.rig_assignments_per_image(data.load_rig_assignments())
reconstruction = types.Reconstruction()
reconstruction.reference = data.load_reference()
reconstruction.cameras = data.load_camera_models()
for image in images:
camera_id = data.load_exif(image)["camera"]
if image in rig_assignments:
rig_instance_id, rig_camera_id, _ = rig_assignments[image]
else:
rig_instance_id = image
rig_camera_id = camera_id
reconstruction.add_rig_camera(pymap.RigCamera(pygeometry.Pose(), rig_camera_id))
reconstruction.add_rig_instance(pymap.RigInstance(rig_instance_id))
shot = reconstruction.create_shot(
shot_id=image,
camera_id=camera_id,
rig_camera_id=rig_camera_id,
rig_instance_id=rig_instance_id,
)
shot.metadata = get_image_metadata(data, image)
if not shot.metadata.gps_position.has_value:
reconstruction.remove_shot(image)
continue
gps_pos = shot.metadata.gps_position.value
shot.pose.set_rotation_matrix(rotation_from_shot_metadata(shot))
shot.pose.set_origin(gps_pos)
shot.scale = 1.0
return reconstruction
def match_candidates_from_metadata(
images_ref: List[str],
images_cand: List[str],
exifs: Dict[str, Any],
data: DataSetBase,
config_override: Dict[str, Any],
) -> Tuple[List[Tuple[str, str]], Dict[str, Any]]:
"""Compute candidate matching pairs between between images_ref and images_cand
Returns a list of pairs (im1, im2) such that (im1 in images_ref) is true.
Returned pairs are unique given that (i, j) == (j, i).
"""
overriden_config = data.config.copy()
overriden_config.update(config_override)
max_distance = overriden_config["matching_gps_distance"]
gps_neighbors = overriden_config["matching_gps_neighbors"]
graph_rounds = overriden_config["matching_graph_rounds"]
time_neighbors = overriden_config["matching_time_neighbors"]
order_neighbors = overriden_config["matching_order_neighbors"]
bow_neighbors = overriden_config["matching_bow_neighbors"]
bow_gps_distance = overriden_config["matching_bow_gps_distance"]
bow_gps_neighbors = overriden_config["matching_bow_gps_neighbors"]
bow_other_cameras = overriden_config["matching_bow_other_cameras"]
vlad_neighbors = overriden_config["matching_vlad_neighbors"]
vlad_gps_distance = overriden_config["matching_vlad_gps_distance"]
vlad_gps_neighbors = overriden_config["matching_vlad_gps_neighbors"]
vlad_other_cameras = overriden_config["matching_vlad_other_cameras"]
data.init_reference()
reference = data.load_reference()
if not all(map(has_gps_info, exifs.values())):
if gps_neighbors != 0:
logger.warn(
"Not all images have GPS info. " "Disabling matching_gps_neighbors."
)
gps_neighbors = 0
max_distance = 0
graph_rounds = 0
images_ref.sort()
if (
max_distance
== gps_neighbors
== time_neighbors
== order_neighbors
== bow_neighbors
== vlad_neighbors
== graph_rounds
== 0
):
# All pair selection strategies deactivated so we match all pairs
d = set()
t = set()
g = set()
o = set()
b = set()
v = set()
pairs = {sorted_pair(i, j) for i in images_ref for j in images_cand if i != j}
else:
d = match_candidates_by_distance(
images_ref, images_cand, exifs, reference, gps_neighbors, max_distance
)
g = match_candidates_by_graph(
images_ref, images_cand, exifs, reference, graph_rounds
)
t = match_candidates_by_time(images_ref, images_cand, exifs, time_neighbors)
o = match_candidates_by_order(images_ref, images_cand, order_neighbors)
b = match_candidates_with_bow(
data,
images_ref,
images_cand,
exifs,
reference,
bow_neighbors,
bow_gps_distance,
bow_gps_neighbors,
bow_other_cameras,
)
v = match_candidates_with_vlad(
data,
images_ref,
images_cand,
exifs,
reference,
vlad_neighbors,
vlad_gps_distance,
vlad_gps_neighbors,
vlad_other_cameras,
{},
)
pairs = d | g | t | o | set(b) | set(v)
pairs = ordered_pairs(pairs, images_ref)
report = {
"num_pairs_distance": len(d),
"num_pairs_graph": len(g),
"num_pairs_time": len(t),
"num_pairs_order": len(o),
"num_pairs_bow": len(b),
"num_pairs_vlad": len(v),
}
return pairs, report
def get_image_metadata(data: DataSetBase, image: str) -> pymap.ShotMeasurements:
"""Get image metadata as a ShotMetadata object."""
exif = data.load_exif(image)
reference = data.load_reference()
return exif_to_metadata(exif, data.config["use_altitude_tag"], reference)
