def run_dataset(data, list_path, bundle_path, undistorted):
""" Export reconstruction to bundler format.
Args:
list_path: txt list of images to export
bundle_path : output path
undistorted : export undistorted reconstruction
"""
udata = dataset.UndistortedDataSet(data, 'undistorted')
default_path = os.path.join(data.data_path, 'bundler')
list_file_path = list_path if list_path else default_path
bundle_file_path = bundle_path if bundle_path else default_path
if undistorted:
reconstructions = udata.load_undistorted_reconstruction()
track_manager = udata.load_undistorted_tracks_manager()
images = reconstructions[0].shots.keys()
else:
reconstructions = data.load_reconstruction()
track_manager = data.load_tracks_manager()
images = data.images()
io.export_bundler(images, reconstructions, track_manager, bundle_file_path,
list_file_path)
def run_dataset(data: DataSet, reconstruction, reconstruction_index, tracks,
output):
"""Export reconstruction to NVM_V3 format from VisualSfM
Args:
reconstruction: reconstruction to undistort
reconstruction_index: index of the reconstruction component to undistort
tracks: tracks graph of the reconstruction
output: undistorted
"""
undistorted_data_path = os.path.join(data.data_path, output)
udata = dataset.UndistortedDataSet(data,
undistorted_data_path,
io_handler=data.io_handler)
reconstructions = data.load_reconstruction(reconstruction)
if data.tracks_exists(tracks):
tracks_manager = data.load_tracks_manager(tracks)
else:
tracks_manager = None
if reconstructions:
r = reconstructions[reconstruction_index]
undistort.undistort_reconstruction_and_images(tracks_manager, r, data,
udata)
def run_dataset(data, no_cameras, no_points, depthmaps):
""" Export reconstruction to PLY format
Args:
no_cameras: do not save camera positions
no_points: do not save points
depthmaps: export per-image depthmaps as pointclouds
"""
reconstructions = data.load_reconstruction()
no_cameras = no_cameras
no_points = no_points
if reconstructions:
data.save_ply(reconstructions[0], None, no_cameras, no_points)
if depthmaps and reconstructions:
udata = dataset.UndistortedDataSet(data, 'undistorted')
for id, shot in reconstructions[0].shots.items():
rgb = udata.load_undistorted_image(id)
for t in ('clean', 'raw'):
path_depth = udata._depthmap_file(id, t + '.npz')
if not os.path.exists(path_depth):
continue
depth = np.load(path_depth)['depth']
rgb = scale_down_image(rgb, depth.shape[1], depth.shape[0])
ply = depthmap_to_ply(shot, depth, rgb)
with io.open_wt(udata._depthmap_file(id, t + '.ply')) as fout:
fout.write(ply)
def run(self, args):
data = dataset.DataSet(args.dataset)
reconstructions = data.load_reconstruction()
no_cameras = args.no_cameras
no_points = args.no_points
_all = args.all
path_all = args.dataset + "/reconstruction_files/"
if reconstructions and not _all:
data.save_ply(reconstructions[0], None, no_cameras, no_points)
elif reconstructions and _all:
if not os.path.isdir(path_all):
os.mkdir(path_all)
for r in range(len(reconstructions)):
data.save_ply(
reconstructions[r],
"reconstruction_files/reconstruction_" + str(r) + ".ply",
no_cameras, no_points)
if args.depthmaps and reconstructions:
udata = dataset.UndistortedDataSet(data, 'undistorted')
for id, shot in reconstructions[0].shots.items():
rgb = udata.load_undistorted_image(id)
for t in ('clean', 'raw'):
path_depth = udata._depthmap_file(id, t + '.npz')
if not os.path.exists(path_depth):
continue
depth = np.load(path_depth)['depth']
rgb = scale_down_image(rgb, depth.shape[1], depth.shape[0])
ply = depthmap_to_ply(shot, depth, rgb)
with io.open_wt(udata._depthmap_file(id,
t + '.ply')) as fout:
fout.write(ply)
def run_dataset(
data: DataSet,
reconstruction: Optional[str] = None,
reconstruction_index: int = 0,
tracks: Optional[str] = None,
output: str = "undistorted",
skip_images: bool = False,
) -> None:
"""Export reconstruction to NVM_V3 format from VisualSfM
Args:
reconstruction: reconstruction to undistort
reconstruction_index: index of the reconstruction component to undistort
tracks: tracks graph of the reconstruction
output: undistorted
skip_images: do not undistort images
"""
undistorted_data_path = os.path.join(data.data_path, output)
udata = dataset.UndistortedDataSet(data,
undistorted_data_path,
io_handler=data.io_handler)
reconstructions = data.load_reconstruction(reconstruction)
if data.tracks_exists(tracks):
tracks_manager = data.load_tracks_manager(tracks)
else:
tracks_manager = None
if reconstructions:
r = reconstructions[reconstruction_index]
undistort.undistort_reconstruction_with_images(tracks_manager, r, data,
udata, skip_images)
def run(self, args):
data = dataset.DataSet(args)
udata = dataset.UndistortedDataSet(data, 'undistorted')
data.config['interactive'] = args
reconstructions = udata.load_undistorted_reconstruction()
graph = udata.load_undistorted_tracks_graph()
dense.compute_depthmaps(udata, graph, reconstructions[0])
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, args.subfolder)
data.config['interactive'] = args.interactive
reconstructions = udata.load_undistorted_reconstruction()
tracks_manager = udata.load_undistorted_tracks_manager()
dense.compute_depthmaps(udata, tracks_manager, reconstructions[0])
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, 'undistorted')
reconstructions = udata.load_undistorted_reconstruction()
graph = udata.load_undistorted_tracks_graph()
if reconstructions:
self.export(reconstructions[0], graph, data)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, 'undistorted')
reconstructions = udata.load_undistorted_reconstruction()
tracks_manager = udata.load_undistorted_tracks_manager()
if reconstructions:
self.export(reconstructions[0], tracks_manager, udata, data)
def run_dataset(data):
""" Export reconstruction to OpenMVS format. """
udata = dataset.UndistortedDataSet(data, 'undistorted')
reconstructions = udata.load_undistorted_reconstruction()
tracks_manager = udata.load_undistorted_tracks_manager()
if reconstructions:
export(reconstructions[0], tracks_manager, udata, data)
def run_dataset(data, points, image_list, output, undistorted):
"""Export reconstruction to PLY format
Args:
points: export points
image_list: export only the shots included in this file (path to .txt file)
output: output pmvs directory
undistorted: export the undistorted reconstruction
"""
udata = dataset.UndistortedDataSet(data)
base_output_path = output if output else os.path.join(
data.data_path, "pmvs")
io.mkdir_p(base_output_path)
logger.info("Converting dataset [%s] to PMVS dir [%s]" %
(data.data_path, base_output_path))
if undistorted:
reconstructions = udata.load_undistorted_reconstruction()
else:
reconstructions = data.load_reconstruction()
# load tracks for vis.dat
try:
if undistorted:
tracks_manager = udata.load_undistorted_tracks_manager()
else:
tracks_manager = data.load_tracks_manager()
image_graph = tracking.as_weighted_graph(tracks_manager)
except IOError:
image_graph = None
export_only = None
if image_list:
export_only = {}
with open(image_list, "r") as f:
for image in f:
export_only[image.strip()] = True
for h, reconstruction in enumerate(reconstructions):
export(
reconstruction,
h,
image_graph,
tracks_manager,
base_output_path,
data,
undistorted,
udata,
points,
export_only,
)
def run(self, args):
data = dataset.DataSet(args)
udata = dataset.UndistortedDataSet(data, 'undistorted')
reconstructions = data.load_reconstruction(args)
if data.tracks_exists(args):
graph = data.load_tracks_graph(args)
else:
graph = None
if reconstructions:
self.undistort_reconstruction(graph, reconstructions[0], data, udata)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, args.output)
reconstructions = data.load_reconstruction(args.reconstruction)
if data.tracks_exists(args.tracks):
tracks_manager = data.load_tracks_manager(args.tracks)
else:
tracks_manager = None
if reconstructions:
r = reconstructions[args.reconstruction_index]
self.undistort_reconstruction(tracks_manager, r, data, udata)
def run(self, args):
print(args)
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, args.output)
reconstructions = data.load_reconstruction(args.reconstruction)
if data.tracks_exists(args.tracks):
graph = data.load_tracks_graph(args.tracks)
else:
graph = None
if reconstructions:
r = reconstructions[args.reconstruction_index]
self.undistort_reconstruction(graph, r, data, udata)
def run_dataset(data, subfolder, interactive):
""" Compute depthmap on a dataset with has SfM ran already.
Args:
subfolder: dataset's subfolder where to store results
interactive : display plot of computed depthmaps
"""
udataset = dataset.UndistortedDataSet(data, subfolder)
data.config['interactive'] = interactive
reconstructions = udataset.load_undistorted_reconstruction()
tracks_manager = udataset.load_undistorted_tracks_manager()
dense.compute_depthmaps(udataset, tracks_manager, reconstructions[0])
def run_dataset(data: DataSet, subfolder, interactive) -> None:
"""Compute depthmap on a dataset with has SfM ran already.
Args:
subfolder: dataset's subfolder where to store results
interactive : display plot of computed depthmaps
"""
udata_path = os.path.join(data.data_path, subfolder)
udataset = dataset.UndistortedDataSet(data, udata_path, io_handler=data.io_handler)
data.config["interactive"] = interactive
reconstructions = udataset.load_undistorted_reconstruction()
tracks_manager = udataset.load_undistorted_tracks_manager()
dense.compute_depthmaps(udataset, tracks_manager, reconstructions[0])
def run_dataset(data, proj, transformation, image_positions, reconstruction,
dense, output):
""" Export reconstructions in geographic coordinates
Args:
proj: PROJ.4 projection string
transformation : print cooordinate transformation matrix'
image_positions : export image positions
reconstruction : export reconstruction.json
dense : export dense point cloud (depthmaps/merged.ply)
output : path of the output file relative to the dataset
"""
if not (transformation or image_positions or reconstruction or dense):
logger.info('Nothing to do. At least on of the options: ')
logger.info(
' --transformation, --image-positions, --reconstruction, --dense')
reference = data.load_reference()
projection = pyproj.Proj(proj)
transformation = _get_transformation(reference, projection)
if transformation:
output = output or 'geocoords_transformation.txt'
output_path = os.path.join(data.data_path, output)
_write_transformation(transformation, output_path)
if image_positions:
reconstructions = data.load_reconstruction()
output = output or 'image_geocoords.tsv'
output_path = os.path.join(data.data_path, output)
_transform_image_positions(reconstructions, transformation,
output_path)
if reconstruction:
reconstructions = data.load_reconstruction()
for r in reconstructions:
_transform_reconstruction(r, transformation)
output = output or 'reconstruction.geocoords.json'
data.save_reconstruction(reconstructions, output)
if dense:
output = output or 'undistorted/depthmaps/merged.geocoords.ply'
output_path = os.path.join(data.data_path, output)
udata = dataset.UndistortedDataSet(data, 'undistorted')
_transform_dense_point_cloud(udata, transformation, output_path)
def run_dataset(data, image_list):
""" Export reconstruction to OpenMVS format. """
udata = dataset.UndistortedDataSet(data)
reconstructions = udata.load_undistorted_reconstruction()
tracks_manager = udata.load_undistorted_tracks_manager()
export_only = None
if image_list:
export_only = {}
with open(image_list, "r") as f:
for image in f:
export_only[image.strip()] = True
if reconstructions:
export(reconstructions[0], tracks_manager, udata, data, export_only)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, args.subfolder)
data.config['interactive'] = args.interactive
graph, neighbors_dict = None, None
reconstructions = udata.load_undistorted_reconstruction()
neighbors_path: Path = Path(data.data_path) / "neighbors.json"
if neighbors_path.exists():
with io.open_rt(neighbors_path) as fp:
neighbors_dict = io.json_load(fp)
else:
graph = udata.load_undistorted_tracks_graph()
dense.compute_depthmaps(udata, graph, reconstructions[0],
neighbors_dict)
def run_dataset(data, points, image_list):
udata = dataset.UndistortedDataSet(data, 'undistorted')
validate_image_names(data, udata)
reconstructions = udata.load_undistorted_reconstruction()
tracks_manager = udata.load_undistorted_tracks_manager()
export_only = None
if image_list:
export_only = {}
with open(image_list, 'r') as f:
for image in f:
export_only[image.strip()] = True
if reconstructions:
export(reconstructions[0], tracks_manager, udata, points, export_only)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, 'undistorted')
reconstructions = udata.load_undistorted_reconstruction()
graph = udata.load_undistorted_tracks_graph()
export_only = None
if args.image_list:
export_only = {}
with open(args.image_list, 'r') as f:
for image in f:
export_only[image.strip()] = True
if reconstructions:
self.export(reconstructions[0], graph, udata, args.points,
export_only)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, 'undistorted')
self.validate_image_names(data, udata)
reconstructions = udata.load_undistorted_reconstruction()
tracks_manager = udata.load_undistorted_tracks_manager()
export_only = None
if args.image_list:
export_only = {}
with open(args.image_list, 'r') as f:
for image in f:
export_only[image.strip()] = True
if reconstructions:
self.export(reconstructions[0], tracks_manager, udata, args.points,
export_only)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, 'undistorted')
default_path = os.path.join(data.data_path, 'bundler')
list_file_path = args.list_path if args.list_path else default_path
bundle_file_path = args.bundle_path if args.bundle_path else default_path
if args.undistorted:
reconstructions = udata.load_undistorted_reconstruction()
track_manager = udata.load_undistorted_tracks_manager()
images = reconstructions[0].shots.keys()
else:
reconstructions = data.load_reconstruction()
track_manager = data.load_tracks_manager()
images = data.images()
io.export_bundler(images, reconstructions, track_manager,
bundle_file_path, list_file_path)
def run_dataset(data, reconstruction, reconstruction_index, tracks, output):
"""Export reconstruction to NVM_V3 format from VisualSfM
Args:
reconstruction: reconstruction to undistort
reconstruction_index: index of the reconstruction component to undistort
tracks: tracks graph of the reconstruction
output: undistorted
"""
udata = dataset.UndistortedDataSet(data, output)
reconstructions = data.load_reconstruction(reconstruction)
if data.tracks_exists(tracks):
tracks_manager = data.load_tracks_manager(tracks)
else:
tracks_manager = None
if reconstructions:
r = reconstructions[reconstruction_index]
undistort_reconstruction(tracks_manager, r, data, udata)
def run(self, args):
if not (args.transformation or args.image_positions
or args.reconstruction or args.dense):
print('Nothing to do. At least on of the options: ')
print(
' --transformation, --image-positions, --reconstruction, --dense'
)
data = dataset.DataSet(args.dataset)
reference = data.load_reference()
projection = pyproj.Proj(args.proj)
transformation = self._get_transformation(reference, projection)
if args.transformation:
output = args.output or 'geocoords_transformation.txt'
output_path = os.path.join(data.data_path, output)
self._write_transformation(transformation, output_path)
if args.image_positions:
reconstructions = data.load_reconstruction()
output = args.output or 'image_geocoords.tsv'
output_path = os.path.join(data.data_path, output)
self._transform_image_positions(reconstructions, transformation,
output_path)
if args.reconstruction:
reconstructions = data.load_reconstruction()
for r in reconstructions:
self._transform_reconstruction(r, transformation)
output = args.output or 'reconstruction.geocoords.json'
data.save_reconstruction(reconstructions, output)
if args.dense:
output = args.output or 'undistorted/depthmaps/merged.geocoords.ply'
output_path = os.path.join(data.data_path, output)
udata = dataset.UndistortedDataSet(data, 'undistorted')
self._transform_dense_point_cloud(udata, transformation,
output_path)
def run(self, args):
data = dataset.DataSet(args.dataset)
udata = dataset.UndistortedDataSet(data, 'undistorted')
base_output_path = args.output if args.output else os.path.join(data.data_path, 'pmvs')
io.mkdir_p(base_output_path)
logger.info("Converting dataset [%s] to PMVS dir [%s]" % (
data.data_path, base_output_path))
if args.undistorted:
reconstructions = udata.load_undistorted_reconstruction()
else:
reconstructions = data.load_reconstruction()
# load tracks for vis.dat
try:
if args.undistorted:
tracks_manager = udata.load_undistorted_tracks_manager()
else:
tracks_manager = data.load_tracks_manager()
image_graph = tracking.as_weighted_graph(tracks_manager)
except IOError:
image_graph = None
export_only = None
if args.image_list:
export_only = {}
with open(args.image_list, 'r') as f:
for image in f:
export_only[image.strip()] = True
for h, reconstruction in enumerate(reconstructions):
self.export(reconstruction, h,
image_graph, tracks_manager,
base_output_path, data,
args.undistorted, udata,
args.points, export_only)
def run_dataset(data: DataSet, no_cameras, no_points, depthmaps,
point_num_views):
"""Export reconstruction to PLY format
Args:
no_cameras: do not save camera positions
no_points: do not save points
depthmaps: export per-image depthmaps as pointclouds
point_num_views: Export the number of views associated with each point
"""
reconstructions = data.load_reconstruction()
tracks_manager = data.load_tracks_manager()
no_cameras = no_cameras
no_points = no_points
point_num_views = point_num_views
if reconstructions:
data.save_ply(reconstructions[0], tracks_manager, None, no_cameras,
no_points, point_num_views)
if depthmaps:
udata = dataset.UndistortedDataSet(data)
urec = udata.load_undistorted_reconstruction()[0]
for shot in urec.shots.values():
rgb = udata.load_undistorted_image(shot.id)
for t in ("clean", "raw"):
path_depth = udata.depthmap_file(shot.id, t + ".npz")
if not os.path.exists(path_depth):
continue
depth = np.load(path_depth)["depth"]
rgb = scale_down_image(rgb, depth.shape[1], depth.shape[0])
ply = depthmap_to_ply(shot, depth, rgb)
with io.open_wt(udata.depthmap_file(shot.id,
t + ".ply")) as fout:
fout.write(ply)
print("Whoops! Cannot find %s (we need that!)" % coords_file)
exit(1)
with open(coords_file) as f:
line = f.readline() # discard
# second line is a northing/easting offset
line = f.readline().rstrip()
dem_offset_x, dem_offset_y = map(float, line.split(" "))
print("DEM offset: (%s, %s)" % (dem_offset_x, dem_offset_y))
print("DEM dimensions: %sx%s pixels" % (w, h))
# Read reconstruction
udata = dataset.UndistortedDataSet(
dataset.DataSet(os.path.join(dataset_path, "opensfm")))
reconstructions = udata.load_undistorted_reconstruction()
if len(reconstructions) == 0:
raise Exception("No reconstructions available")
max_workers = multiprocessing.cpu_count()
print("Using %s threads" % max_workers)
reconstruction = reconstructions[0]
for shot in reconstruction.shots.values():
if len(target_images) == 0 or shot.id in target_images:
print("Processing %s..." % shot.id)
shot_image = udata.load_undistorted_image(shot.id)
r = shot.pose.get_rotation_matrix().T
print("Whoops! Cannot find %s (we need that!)" % coords_file)
exit(1)
with open(coords_file) as f:
l = f.readline() # discard
# second line is a northing/easting offset
l = f.readline().rstrip()
dem_offset_x, dem_offset_y = map(float, l.split(" "))
print("DEM offset: (%s, %s)" % (dem_offset_x, dem_offset_y))
print("DEM dimensions: %sx%s pixels" % (w, h))
# Read reconstruction
udata = dataset.UndistortedDataSet(dataset.DataSet(os.path.join(dataset_path, "opensfm")), undistorted_data_path=os.path.join(dataset_path, "opensfm", "undistorted"))
reconstructions = udata.load_undistorted_reconstruction()
if len(reconstructions) == 0:
raise Exception("No reconstructions available")
max_workers = args.threads
print("Using %s threads" % max_workers)
reconstruction = reconstructions[0]
for shot in reconstruction.shots.values():
if len(target_images) == 0 or shot.id in target_images:
print("Processing %s..." % shot.id)
shot_image = udata.load_undistorted_image(shot.id)
r = shot.pose.get_rotation_matrix()
def main():
parser = argparse.ArgumentParser(
description='Convert COLMAP database to OpenSfM dataset')
parser.add_argument('database', help='path to the database to be processed')
parser.add_argument('images', help='path to the images')
args = parser.parse_args()
logger.info(f"Converting {args.database} to COLMAP format")
p_db = Path(args.database)
assert p_db.is_file()
export_folder = p_db.parent / EXPORT_DIR_NAME
export_folder.mkdir(exist_ok=True)
images_path = export_folder / 'images'
if not images_path.exists():
os.symlink(os.path.abspath(args.images), images_path, target_is_directory=True)
# Copy the config if this is an colmap export of an opensfm export
if p_db.parent.name == 'colmap_export' and not (export_folder/'config.yaml').exists():
os.symlink(p_db.parent.parent / 'config.yaml', export_folder / 'config.yaml')
data = dataset.DataSet(export_folder)
db = sqlite3.connect(p_db.as_posix())
camera_map, image_map = import_cameras_images(db, data)
# Create image_list.txt
with open(export_folder / 'image_list.txt', 'w') as f:
for _, (filename, _) in image_map.items():
f.write('images/' + filename + '\n')
data.load_image_list()
keypoints = import_features(db, data, image_map, camera_map)
import_matches(db, data, image_map)
rec_cameras = p_db.parent / 'cameras.bin'
rec_points = p_db.parent / 'points3D.bin'
rec_images = p_db.parent / 'images.bin'
if rec_cameras.exists() and rec_images.exists() and rec_points.exists():
reconstruction = types.Reconstruction()
import_cameras_reconstruction(rec_cameras, reconstruction)
import_points_reconstruction(rec_points, reconstruction)
tracks_manager, _ = import_images_reconstruction(rec_images,
keypoints,
reconstruction)
data.save_reconstruction([reconstruction])
data.save_tracks_manager(tracks_manager)
# Save undistorted reconstruction as well
udata = dataset.UndistortedDataSet(data, 'undistorted')
urec = compute_and_save_undistorted_reconstruction(reconstruction, tracks_manager, data, udata)
# Project colmap's fused pointcloud to save depths in opensfm format
path_ply = p_db.parent / 'dense/fused.ply'
if path_ply.is_file():
rec_cameras = p_db.parent / 'dense/sparse/cameras.bin'
rec_images = p_db.parent / 'dense/sparse/images.bin'
rec_points = p_db.parent / 'points3D.bin'
reconstruction = types.Reconstruction()
import_cameras_reconstruction(rec_cameras, reconstruction)
import_points_reconstruction(rec_points, reconstruction)
_, image_ix_to_shot_id = import_images_reconstruction(rec_images,
keypoints,
reconstruction)
logger.info(f"Projecting {path_ply} to depth images")
import_depthmaps_from_fused_pointcloud(udata, urec, image_ix_to_shot_id, path_ply)
else:
logger.info("Not importing dense reconstruction: Didn't find {}".format(path_ply))
else:
logger.info("Didn't find some of the reconstruction files at {}".format(p_db.parent))
db.close()
