def run_dataset(data: DataSetBase, input, output) -> None:
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 write_report(data: DataSetBase, preport, pairs, wall_time) -> None:
report = {
"wall_time": wall_time,
"num_pairs": len(pairs),
"pairs": pairs,
}
report.update(preport)
data.save_report(io.json_dumps(report), "matches.json")
def run_dataset(data: DataSetBase, input: str, output: str) -> None:
"""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 write_report(data: DataSetBase, wall_time: float):
image_reports = []
for image in data.images():
try:
txt = data.load_report("features/{}.json".format(image))
image_reports.append(io.json_loads(txt))
except IOError:
logger.warning("No feature report image {}".format(image))
report = {"wall_time": wall_time, "image_reports": image_reports}
data.save_report(io.json_dumps(report), "features.json")
def run_dataset(data: DataSetBase,
algorithm: reconstruction.ReconstructionAlgorithm) -> None:
"""Compute the SfM reconstruction."""
tracks_manager = data.load_tracks_manager()
if algorithm == reconstruction.ReconstructionAlgorithm.INCREMENTAL:
report, reconstructions = reconstruction.incremental_reconstruction(
data, tracks_manager)
elif algorithm == reconstruction.ReconstructionAlgorithm.TRIANGULATION:
report, reconstructions = reconstruction.triangulation_reconstruction(
data, tracks_manager)
else:
raise RuntimeError(
f"Unsupported algorithm for reconstruction {algorithm}")
data.save_reconstruction(reconstructions)
data.save_report(io.json_dumps(report), "reconstruction.json")
def write_report(data: DataSetBase, tracks_manager, features_time,
matches_time, tracks_time) -> None:
view_graph = [
(k[0], k[1], v)
for k, v in tracks_manager.get_all_pairs_connectivity().items()
]
report = {
"wall_times": {
"load_features": features_time,
"load_matches": matches_time,
"compute_tracks": tracks_time,
},
"wall_time": features_time + matches_time + tracks_time,
"num_images": tracks_manager.num_shots(),
"num_tracks": tracks_manager.num_tracks(),
"view_graph": view_graph,
}
data.save_report(io.json_dumps(report), "tracks.json")
def detect(
image: str,
image_array: np.ndarray,
segmentation_array: Optional[np.ndarray],
instances_array: Optional[np.ndarray],
data: DataSetBase,
force: bool = False,
) -> None:
log.setup()
need_words = (
data.config["matcher_type"] == "WORDS"
or data.config["matching_bow_neighbors"] > 0
)
has_words = not need_words or data.words_exist(image)
has_features = data.features_exist(image)
if not force and has_features and has_words:
logger.info(
"Skip recomputing {} features for image {}".format(
data.feature_type().upper(), image
)
)
return
logger.info(
"Extracting {} features for image {}".format(data.feature_type().upper(), image)
)
start = timer()
p_unmasked, f_unmasked, c_unmasked = features.extract_features(
image_array, data.config, is_high_res_panorama(data, image, image_array)
)
# Load segmentation and bake it in the data
if data.config["features_bake_segmentation"]:
exif = data.load_exif(image)
s_unsorted, i_unsorted = bake_segmentation(
image_array, p_unmasked, segmentation_array, instances_array, exif
)
p_unsorted = p_unmasked
f_unsorted = f_unmasked
c_unsorted = c_unmasked
# Load segmentation, make a mask from it mask and apply it
else:
s_unsorted, i_unsorted = None, None
fmask = masking.load_features_mask(data, image, p_unmasked)
p_unsorted = p_unmasked[fmask]
f_unsorted = f_unmasked[fmask]
c_unsorted = c_unmasked[fmask]
if len(p_unsorted) == 0:
logger.warning("No features found in image {}".format(image))
size = p_unsorted[:, 2]
order = np.argsort(size)
p_sorted = p_unsorted[order, :]
f_sorted = f_unsorted[order, :]
c_sorted = c_unsorted[order, :]
if s_unsorted is not None:
semantic_data = features.SemanticData(
s_unsorted[order],
i_unsorted[order] if i_unsorted is not None else None,
data.segmentation_labels(),
)
else:
semantic_data = None
features_data = features.FeaturesData(p_sorted, f_sorted, c_sorted, semantic_data)
data.save_features(image, features_data)
if need_words:
bows = bow.load_bows(data.config)
n_closest = data.config["bow_words_to_match"]
closest_words = bows.map_to_words(
f_sorted, n_closest, data.config["bow_matcher_type"]
)
data.save_words(image, closest_words)
end = timer()
report = {
"image": image,
"num_features": len(p_sorted),
"wall_time": end - start,
}
data.save_report(io.json_dumps(report), "features/{}.json".format(image))