def incremental_reconstruction(data): """Run the entire incremental reconstruction pipeline.""" logger.info("Starting incremental reconstruction") data.invent_reference_lla() graph = data.load_tracks_graph() tracks, images = matching.tracks_and_images(graph) remaining_images = set(images) gcp = None if data.ground_control_points_exist(): gcp = data.load_ground_control_points() common_tracks = matching.all_common_tracks(graph, tracks) reconstructions = [] pairs = compute_image_pairs(common_tracks, data.config) for im1, im2 in pairs: if im1 in remaining_images and im2 in remaining_images: tracks, p1, p2 = common_tracks[im1, im2] reconstruction = bootstrap_reconstruction(data, graph, im1, im2, p1, p2) if reconstruction: remaining_images.remove(im1) remaining_images.remove(im2) reconstruction = grow_reconstruction(data, graph, reconstruction, remaining_images, gcp) reconstructions.append(reconstruction) reconstructions = sorted(reconstructions, key=lambda x: -len(x.shots)) data.save_reconstruction(reconstructions) 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)))
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, _ = matching.tracks_and_images(graph) common_tracks = matching.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, reconstruction, neighbors, min_depth, max_depth, shot)) parallel_run(compute_depthmap, arguments, processes) arguments = [] for shot in reconstruction.shots.values(): if len(neighbors[shot.id]) <= 1: continue arguments.append((data, reconstruction, neighbors, shot)) parallel_run(clean_depthmap, arguments, processes) merge_depthmaps(data, graph, reconstruction, neighbors)
def incremental_reconstruction(data, graph=None, common_tracks=None, my_init=False): """Run the entire incremental reconstruction pipeline.""" logger.info("Starting incremental reconstruction") if (not data.config['use_dummy_camera']): data.invent_reference_lla() if (graph == None): graph = data.load_tracks_graph() tracks, images = matching.tracks_and_images(graph) remaining_images = set(images) gcp = None if data.ground_control_points_exist(): gcp = data.load_ground_control_points() if (common_tracks == None): common_tracks = matching.all_common_tracks(graph, tracks) reconstructions = [] data.config['five_point_algo_threshold'] = 0.5 if (not my_init): pairs = compute_image_pairs(common_tracks, data.config) else: pairs = compute_image_pairs_new(common_tracks, data.config, step=5) for im1, im2 in pairs: if im1 in remaining_images and im2 in remaining_images: tracks, p1, p2 = common_tracks[im1, im2] reconstruction = bootstrap_reconstruction(data, graph, im1, im2, p1, p2, my_init) """ Add a visualization to check the result """ # my_canvas = vispy_util_persp.MyCanvas(reconstruction, data.image_files, has_color=0) if reconstruction: remaining_images.remove(im1) remaining_images.remove(im2) # reconstruction = grow_reconstruction( # data, graph, reconstruction, remaining_images, gcp, my_canvas) reconstruction = grow_reconstruction(data, graph, reconstruction, remaining_images, gcp) # my_canvas.update_data(reconstruction) reconstructions.append(reconstruction) reconstructions = sorted(reconstructions, key=lambda x: -len(x.shots)) data.save_reconstruction(reconstructions) 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)))
def incremental_reconstruction(data): """Run the entire incremental reconstruction pipeline.""" logger.info("Starting incremental reconstruction") # load the exif information from the images and convert to internal format data.invent_reference_lla() # return an nx graph, with two kind of nodes, images, and tracks. features are keypoint locations graph = data.load_tracks_graph() # all tracks and images stored in two lists tracks, images = matching.tracks_and_images(graph) remaining_images = set(images) gcp = None # otherwise explictly written a ground control point, no such file exists. if data.ground_control_points_exist(): gcp = data.load_ground_control_points() # returns a [im1, im2] -> (tracks, im1_features, im2_features) common_tracks = matching.all_common_tracks(graph, tracks) reconstructions = [] # return a list of image pairs that sorted by decreasing favorability pairs = compute_image_pairs(common_tracks, data.config) if len(pairs)==0: print("no image pairs available, use all combinations instead") pairs = combinations(sorted(remaining_images), 2) for im1, im2 in pairs: # each time choose two images that both are not in the collection # after adding them into the reconstruction, removing them from the set # if this if is entered multiple times, then it indicates that multiple # reconstructions are found, which is not good. if im1 in remaining_images and im2 in remaining_images: tracks, p1, p2 = common_tracks[im1, im2] # TODO: we have to carefully select which image pairs to use # This is only called once reconstruction = bootstrap_reconstruction(data, graph, im1, im2, p1, p2) if reconstruction: remaining_images.remove(im1) remaining_images.remove(im2) # The main growing process, it doesn't only add in one image, it add in all. reconstruction = grow_reconstruction( data, graph, reconstruction, remaining_images, gcp) reconstructions.append(reconstruction) reconstructions = sorted(reconstructions, key=lambda x: -len(x.shots)) data.save_reconstruction(reconstructions) else: print("reconstruction for image %s and %s failed" % (im1, im2)) 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)))
def incremental_reconstruction(data): """Run the entire incremental reconstruction pipeline.""" logger.info("Starting incremental reconstruction") report = {} chrono = Chronometer() if not data.reference_lla_exists(): data.invent_reference_lla() graph = data.load_tracks_graph() tracks, images = matching.tracks_and_images(graph) chrono.lap('load_tracks_graph') remaining_images = set(images) gcp = None if data.ground_control_points_exist(): gcp = data.load_ground_control_points() common_tracks = matching.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)) data.save_reconstruction(reconstructions) 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
def incremental_reconstruction(data): """Run the entire incremental reconstruction pipeline.""" logger.info("Starting incremental reconstruction") report = {} chrono = Chronometer() if not data.reference_lla_exists(): data.invent_reference_lla() graph = data.load_tracks_graph() tracks, images = matching.tracks_and_images(graph) chrono.lap('load_tracks_graph') remaining_images = set(images) gcp = None if data.ground_control_points_exist(): gcp = data.load_ground_control_points() common_tracks = matching.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)) data.save_reconstruction(reconstructions) 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
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, _ = matching.tracks_and_images(graph) common_tracks = matching.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, graph, reconstruction, neighbors)