def run_dataset(data: DataSet, 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 = data.undistorted_dataset()
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, 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 = data.undistorted_dataset()
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,
# pyre-fixme[61]: `tracks_manager` may not be initialized here.
tracks_manager,
base_output_path,
data,
undistorted,
udata,
points,
export_only,
)
def run_dataset(
data: DataSet,
proj: str,
transformation: bool,
image_positions: bool,
reconstruction: bool,
dense : bool,
output: str,
) -> None:
"""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)
t = _get_transformation(reference, projection)
if transformation:
output = output or "geocoords_transformation.txt"
output_path = os.path.join(data.data_path, output)
_write_transformation(t, 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, t, output_path)
if reconstruction:
reconstructions = data.load_reconstruction()
for r in reconstructions:
_transform_reconstruction(r, t)
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 = data.undistorted_dataset()
_transform_dense_point_cloud(udata, t, output_path)
def run_dataset(data: DataSet, image_list):
""" Export reconstruction to OpenMVS format. """
udata = data.undistorted_dataset()
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, export_only)
def run_dataset(data: DataSet, points, image_list):
udata = data.undistorted_dataset()
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_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 = data.undistorted_dataset()
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)
