def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
outputs['large'] = len(photos) > args.split
if outputs['large']:
# Split-merge is on, always use --use_fixed_camera_params
log.ODM_INFO("--use-fixed-camera-params will be turned ON")
args.use_fixed_camera_params = True
# If we have a cluster address, we'll use a distributed workflow
local_workflow = not bool(args.sm_cluster)
octx = OSFMContext(tree.opensfm)
split_done_file = octx.path("split_done.txt")
if not io.file_exists(split_done_file) or self.rerun():
orig_max_concurrency = args.max_concurrency
if not local_workflow:
args.max_concurrency = max(1, args.max_concurrency - 1)
log.ODM_INFO(
"Setting max-concurrency to %s to better handle remote splits"
% args.max_concurrency)
log.ODM_INFO(
"Large dataset detected (%s photos) and split set at %s. Preparing split merge."
% (len(photos), args.split))
config = [
"submodels_relpath: ../submodels/opensfm",
"submodel_relpath_template: ../submodels/submodel_%04d/opensfm",
"submodel_images_relpath_template: ../submodels/submodel_%04d/images",
"submodel_size: %s" % args.split,
"submodel_overlap: %s" % args.split_overlap,
]
octx.setup(args,
tree.dataset_raw,
photos,
gcp_path=reconstruction.gcp.gcp_path,
append_config=config,
rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(5)
if local_workflow:
octx.feature_matching(self.rerun())
self.update_progress(20)
# Create submodels
if not io.dir_exists(tree.submodels_path) or self.rerun():
if io.dir_exists(tree.submodels_path):
log.ODM_WARNING(
"Removing existing submodels directory: %s" %
tree.submodels_path)
shutil.rmtree(tree.submodels_path)
octx.run("create_submodels")
else:
log.ODM_WARNING(
"Submodels directory already exist at: %s" %
tree.submodels_path)
# Find paths of all submodels
mds = metadataset.MetaDataSet(tree.opensfm)
submodel_paths = [
os.path.abspath(p) for p in mds.get_submodel_paths()
]
for sp in submodel_paths:
sp_octx = OSFMContext(sp)
# Copy filtered GCP file if needed
# One in OpenSfM's directory, one in the submodel project directory
if reconstruction.gcp and reconstruction.gcp.exists():
submodel_gcp_file = os.path.abspath(
sp_octx.path("..", "gcp_list.txt"))
submodel_images_dir = os.path.abspath(
sp_octx.path("..", "images"))
if reconstruction.gcp.make_filtered_copy(
submodel_gcp_file, submodel_images_dir):
log.ODM_DEBUG("Copied filtered GCP file to %s" %
submodel_gcp_file)
io.copy(
submodel_gcp_file,
os.path.abspath(sp_octx.path("gcp_list.txt")))
else:
log.ODM_DEBUG(
"No GCP will be copied for %s, not enough images in the submodel are referenced by the GCP"
% sp_octx.name())
# Reconstruct each submodel
log.ODM_INFO(
"Dataset has been split into %s submodels. Reconstructing each submodel..."
% len(submodel_paths))
self.update_progress(25)
if local_workflow:
for sp in submodel_paths:
log.ODM_INFO("Reconstructing %s" % sp)
OSFMContext(sp).reconstruct(self.rerun())
else:
lre = LocalRemoteExecutor(args.sm_cluster, self.rerun())
lre.set_projects([
os.path.abspath(os.path.join(p, ".."))
for p in submodel_paths
])
lre.run_reconstruction()
self.update_progress(50)
# Align
octx.align_reconstructions(self.rerun())
self.update_progress(55)
# Aligned reconstruction is in reconstruction.aligned.json
# We need to rename it to reconstruction.json
remove_paths = []
for sp in submodel_paths:
sp_octx = OSFMContext(sp)
aligned_recon = sp_octx.path('reconstruction.aligned.json')
unaligned_recon = sp_octx.path(
'reconstruction.unaligned.json')
main_recon = sp_octx.path('reconstruction.json')
if io.file_exists(main_recon) and io.file_exists(
unaligned_recon) and not self.rerun():
log.ODM_INFO("Submodel %s has already been aligned." %
sp_octx.name())
continue
if not io.file_exists(aligned_recon):
log.ODM_WARNING(
"Submodel %s does not have an aligned reconstruction (%s). "
"This could mean that the submodel could not be reconstructed "
" (are there enough features to reconstruct it?). Skipping."
% (sp_octx.name(), aligned_recon))
remove_paths.append(sp)
continue
if io.file_exists(main_recon):
shutil.move(main_recon, unaligned_recon)
shutil.move(aligned_recon, main_recon)
log.ODM_DEBUG("%s is now %s" % (aligned_recon, main_recon))
# Remove invalid submodels
submodel_paths = [
p for p in submodel_paths if not p in remove_paths
]
# Run ODM toolchain for each submodel
if local_workflow:
for sp in submodel_paths:
sp_octx = OSFMContext(sp)
log.ODM_INFO("========================")
log.ODM_INFO("Processing %s" % sp_octx.name())
log.ODM_INFO("========================")
argv = get_submodel_argv(args.name,
tree.submodels_path,
sp_octx.name())
# Re-run the ODM toolchain on the submodel
system.run(" ".join(map(quote, argv)),
env_vars=os.environ.copy())
else:
lre.set_projects([
os.path.abspath(os.path.join(p, ".."))
for p in submodel_paths
])
lre.run_toolchain()
# Restore max_concurrency value
args.max_concurrency = orig_max_concurrency
octx.touch(split_done_file)
else:
log.ODM_WARNING('Found a split done file in: %s' %
split_done_file)
else:
log.ODM_INFO("Normal dataset, will process all at once.")
self.progress = 0.0
def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
outputs['large'] = len(photos) > args.split
if outputs['large']:
# If we have a cluster address, we'll use a distributed workflow
local_workflow = not bool(args.sm_cluster)
octx = OSFMContext(tree.opensfm)
split_done_file = octx.path("split_done.txt")
if not io.file_exists(split_done_file) or self.rerun():
orig_max_concurrency = args.max_concurrency
if not local_workflow:
args.max_concurrency = max(1, args.max_concurrency - 1)
log.ODM_INFO(
"Setting max-concurrency to %s to better handle remote splits"
% args.max_concurrency)
log.ODM_INFO(
"Large dataset detected (%s photos) and split set at %s. Preparing split merge."
% (len(photos), args.split))
config = [
"submodels_relpath: " +
os.path.join("..", "submodels", "opensfm"),
"submodel_relpath_template: " + os.path.join(
"..", "submodels", "submodel_%04d", "opensfm"),
"submodel_images_relpath_template: " +
os.path.join("..", "submodels", "submodel_%04d", "images"),
"submodel_size: %s" % args.split,
"submodel_overlap: %s" % args.split_overlap,
]
octx.setup(args,
tree.dataset_raw,
reconstruction=reconstruction,
append_config=config,
rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(5)
if local_workflow:
octx.feature_matching(self.rerun())
self.update_progress(20)
# Create submodels
if not io.dir_exists(tree.submodels_path) or self.rerun():
if io.dir_exists(tree.submodels_path):
log.ODM_WARNING(
"Removing existing submodels directory: %s" %
tree.submodels_path)
shutil.rmtree(tree.submodels_path)
octx.run("create_submodels")
else:
log.ODM_WARNING(
"Submodels directory already exist at: %s" %
tree.submodels_path)
# Find paths of all submodels
mds = metadataset.MetaDataSet(tree.opensfm)
submodel_paths = [
os.path.abspath(p) for p in mds.get_submodel_paths()
]
for sp in submodel_paths:
sp_octx = OSFMContext(sp)
# Copy filtered GCP file if needed
# One in OpenSfM's directory, one in the submodel project directory
if reconstruction.gcp and reconstruction.gcp.exists():
submodel_gcp_file = os.path.abspath(
sp_octx.path("..", "gcp_list.txt"))
submodel_images_dir = os.path.abspath(
sp_octx.path("..", "images"))
if reconstruction.gcp.make_filtered_copy(
submodel_gcp_file, submodel_images_dir):
log.ODM_INFO("Copied filtered GCP file to %s" %
submodel_gcp_file)
io.copy(
submodel_gcp_file,
os.path.abspath(sp_octx.path("gcp_list.txt")))
else:
log.ODM_INFO(
"No GCP will be copied for %s, not enough images in the submodel are referenced by the GCP"
% sp_octx.name())
# Reconstruct each submodel
log.ODM_INFO(
"Dataset has been split into %s submodels. Reconstructing each submodel..."
% len(submodel_paths))
self.update_progress(25)
if local_workflow:
for sp in submodel_paths:
log.ODM_INFO("Reconstructing %s" % sp)
OSFMContext(sp).reconstruct(self.rerun())
else:
lre = LocalRemoteExecutor(args.sm_cluster, self.rerun())
lre.set_projects([
os.path.abspath(os.path.join(p, ".."))
for p in submodel_paths
])
lre.run_reconstruction()
self.update_progress(50)
# TODO: this is currently not working and needs a champion to fix it
# https://community.opendronemap.org/t/filenotfound-error-cameras-json/6047/2
# resplit_done_file = octx.path('resplit_done.txt')
# if not io.file_exists(resplit_done_file) and bool(args.split_multitracks):
# submodels = mds.get_submodel_paths()
# i = 0
# for s in submodels:
# template = octx.path("../aligned_submodels/submodel_%04d")
# with open(s+"/reconstruction.json", "r") as f:
# j = json.load(f)
# for k in range(0, len(j)):
# v = j[k]
# path = template % i
# #Create the submodel path up to opensfm
# os.makedirs(path+"/opensfm")
# os.makedirs(path+"/images")
# #symlinks for common data
# images = os.listdir(octx.path("../images"))
# for image in images:
# os.symlink("../../../images/"+image, path+"/images/"+image)
# os.symlink("../../../opensfm/exif", path+"/opensfm/exif")
# os.symlink("../../../opensfm/features", path+"/opensfm/features")
# os.symlink("../../../opensfm/matches", path+"/opensfm/matches")
# os.symlink("../../../opensfm/reference_lla.json", path+"/opensfm/reference_lla.json")
# os.symlink("../../../opensfm/camera_models.json", path+"/opensfm/camera_models.json")
# shutil.copy(s+"/../cameras.json", path+"/cameras.json")
# shutil.copy(s+"/../images.json", path+"/images.json")
# with open(octx.path("config.yaml")) as f:
# doc = yaml.safe_load(f)
# dmcv = "depthmap_min_consistent_views"
# if dmcv in doc:
# if len(v["shots"]) < doc[dmcv]:
# doc[dmcv] = len(v["shots"])
# print("WARNING: Reduced "+dmcv+" to accommodate short track")
# with open(path+"/opensfm/config.yaml", "w") as f:
# yaml.dump(doc, f)
# #We need the original tracks file for the visualsfm export, since
# #there may still be point matches between the tracks
# shutil.copy(s+"/tracks.csv", path+"/opensfm/tracks.csv")
# #Create our new reconstruction file with only the relevant track
# with open(path+"/opensfm/reconstruction.json", "w") as o:
# json.dump([v], o)
# #Create image lists
# with open(path+"/opensfm/image_list.txt", "w") as o:
# o.writelines(list(map(lambda x: "../images/"+x+'\n', v["shots"].keys())))
# with open(path+"/img_list.txt", "w") as o:
# o.writelines(list(map(lambda x: x+'\n', v["shots"].keys())))
# i+=1
# os.rename(octx.path("../submodels"), octx.path("../unaligned_submodels"))
# os.rename(octx.path("../aligned_submodels"), octx.path("../submodels"))
# octx.touch(resplit_done_file)
mds = metadataset.MetaDataSet(tree.opensfm)
submodel_paths = [
os.path.abspath(p) for p in mds.get_submodel_paths()
]
# Align
octx.align_reconstructions(self.rerun())
self.update_progress(55)
# Aligned reconstruction is in reconstruction.aligned.json
# We need to rename it to reconstruction.json
remove_paths = []
for sp in submodel_paths:
sp_octx = OSFMContext(sp)
aligned_recon = sp_octx.path('reconstruction.aligned.json')
unaligned_recon = sp_octx.path(
'reconstruction.unaligned.json')
main_recon = sp_octx.path('reconstruction.json')
if io.file_exists(main_recon) and io.file_exists(
unaligned_recon) and not self.rerun():
log.ODM_INFO("Submodel %s has already been aligned." %
sp_octx.name())
continue
if not io.file_exists(aligned_recon):
log.ODM_WARNING(
"Submodel %s does not have an aligned reconstruction (%s). "
"This could mean that the submodel could not be reconstructed "
" (are there enough features to reconstruct it?). Skipping."
% (sp_octx.name(), aligned_recon))
remove_paths.append(sp)
continue
if io.file_exists(main_recon):
shutil.move(main_recon, unaligned_recon)
shutil.move(aligned_recon, main_recon)
log.ODM_INFO("%s is now %s" % (aligned_recon, main_recon))
# Remove invalid submodels
submodel_paths = [
p for p in submodel_paths if not p in remove_paths
]
# Run ODM toolchain for each submodel
if local_workflow:
for sp in submodel_paths:
sp_octx = OSFMContext(sp)
log.ODM_INFO("========================")
log.ODM_INFO("Processing %s" % sp_octx.name())
log.ODM_INFO("========================")
argv = get_submodel_argv(args, tree.submodels_path,
sp_octx.name())
# Re-run the ODM toolchain on the submodel
system.run(" ".join(map(double_quote, map(str, argv))),
env_vars=os.environ.copy())
else:
lre.set_projects([
os.path.abspath(os.path.join(p, ".."))
for p in submodel_paths
])
lre.run_toolchain()
# Restore max_concurrency value
args.max_concurrency = orig_max_concurrency
octx.touch(split_done_file)
else:
log.ODM_WARNING('Found a split done file in: %s' %
split_done_file)
else:
log.ODM_INFO("Normal dataset, will process all at once.")
self.progress = 0.0
def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
if not photos:
log.ODM_ERROR('Not enough photos in photos array to start OpenSfM')
exit(1)
octx = OSFMContext(tree.opensfm)
# TODO REMOVE
# octx.setup(args, tree.dataset_raw, reconstruction=reconstruction, rerun=False)
octx.setup(args, tree.dataset_raw, reconstruction=reconstruction, rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(20)
octx.feature_matching(self.rerun())
self.update_progress(30)
octx.reconstruct(self.rerun())
octx.extract_cameras(tree.path("cameras.json"), self.rerun())
self.update_progress(70)
def cleanup_disk_space():
if args.optimize_disk_space:
for folder in ["features", "matches", "exif", "reports"]:
folder_path = octx.path(folder)
if os.path.exists(folder_path):
if os.path.islink(folder_path):
os.unlink(folder_path)
else:
shutil.rmtree(folder_path)
# If we find a special flag file for split/merge we stop right here
if os.path.exists(octx.path("split_merge_stop_at_reconstruction.txt")):
log.ODM_INFO("Stopping OpenSfM early because we found: %s" % octx.path("split_merge_stop_at_reconstruction.txt"))
self.next_stage = None
cleanup_disk_space()
return
# Stats are computed in the local CRS (before geoprojection)
if not args.skip_report:
# TODO: this will fail to compute proper statistics if
# the pipeline is run with --skip-report and is subsequently
# rerun without --skip-report a --rerun-* parameter (due to the reconstruction.json file)
# being replaced below. It's an isolated use case.
octx.export_stats(self.rerun())
self.update_progress(75)
# We now switch to a geographic CRS
geocoords_flag_file = octx.path("exported_geocoords.txt")
if reconstruction.is_georeferenced() and (not io.file_exists(geocoords_flag_file) or self.rerun()):
octx.run('export_geocoords --reconstruction --proj \'%s\' --offset-x %s --offset-y %s' %
(reconstruction.georef.proj4(), reconstruction.georef.utm_east_offset, reconstruction.georef.utm_north_offset))
# Destructive
shutil.move(tree.opensfm_geocoords_reconstruction, tree.opensfm_reconstruction)
octx.touch(geocoords_flag_file)
else:
log.ODM_WARNING("Will skip exporting %s" % tree.opensfm_geocoords_reconstruction)
self.update_progress(80)
updated_config_flag_file = octx.path('updated_config.txt')
# Make sure it's capped by the depthmap-resolution arg,
# since the undistorted images are used for MVS
outputs['undist_image_max_size'] = max(
gsd.image_max_size(photos, args.orthophoto_resolution, tree.opensfm_reconstruction, ignore_gsd=args.ignore_gsd, has_gcp=reconstruction.has_gcp()),
get_depthmap_resolution(args, photos)
)
if not io.file_exists(updated_config_flag_file) or self.rerun():
octx.update_config({'undistorted_image_max_size': outputs['undist_image_max_size']})
octx.touch(updated_config_flag_file)
# Undistorted images will be used for texturing / MVS
alignment_info = None
primary_band_name = None
largest_photo = None
undistort_pipeline = []
def undistort_callback(shot_id, image):
for func in undistort_pipeline:
image = func(shot_id, image)
return image
def resize_thermal_images(shot_id, image):
photo = reconstruction.get_photo(shot_id)
if photo.is_thermal():
return thermal.resize_to_match(image, largest_photo)
else:
return image
def radiometric_calibrate(shot_id, image):
photo = reconstruction.get_photo(shot_id)
if photo.is_thermal():
return thermal.dn_to_temperature(photo, image)
else:
return multispectral.dn_to_reflectance(photo, image, use_sun_sensor=args.radiometric_calibration=="camera+sun")
def align_to_primary_band(shot_id, image):
photo = reconstruction.get_photo(shot_id)
# No need to align if requested by user
if args.skip_band_alignment:
return image
# No need to align primary
if photo.band_name == primary_band_name:
return image
ainfo = alignment_info.get(photo.band_name)
if ainfo is not None:
return multispectral.align_image(image, ainfo['warp_matrix'], ainfo['dimension'])
else:
log.ODM_WARNING("Cannot align %s, no alignment matrix could be computed. Band alignment quality might be affected." % (shot_id))
return image
if reconstruction.multi_camera:
largest_photo = find_largest_photo(photos)
undistort_pipeline.append(resize_thermal_images)
if args.radiometric_calibration != "none":
undistort_pipeline.append(radiometric_calibrate)
image_list_override = None
if reconstruction.multi_camera:
# Undistort only secondary bands
image_list_override = [os.path.join(tree.dataset_raw, p.filename) for p in photos] # if p.band_name.lower() != primary_band_name.lower()
# We backup the original reconstruction.json, tracks.csv
# then we augment them by duplicating the primary band
# camera shots with each band, so that exports, undistortion,
# etc. include all bands
# We finally restore the original files later
added_shots_file = octx.path('added_shots_done.txt')
if not io.file_exists(added_shots_file) or self.rerun():
primary_band_name = multispectral.get_primary_band_name(reconstruction.multi_camera, args.primary_band)
s2p, p2s = multispectral.compute_band_maps(reconstruction.multi_camera, primary_band_name)
if not args.skip_band_alignment:
alignment_info = multispectral.compute_alignment_matrices(reconstruction.multi_camera, primary_band_name, tree.dataset_raw, s2p, p2s, max_concurrency=args.max_concurrency)
else:
log.ODM_WARNING("Skipping band alignment")
alignment_info = {}
log.ODM_INFO("Adding shots to reconstruction")
octx.backup_reconstruction()
octx.add_shots_to_reconstruction(p2s)
octx.touch(added_shots_file)
undistort_pipeline.append(align_to_primary_band)
octx.convert_and_undistort(self.rerun(), undistort_callback, image_list_override)
self.update_progress(95)
if reconstruction.multi_camera:
octx.restore_reconstruction_backup()
# Undistort primary band and write undistorted
# reconstruction.json, tracks.csv
octx.convert_and_undistort(self.rerun(), undistort_callback, runId='primary')
if not io.file_exists(tree.opensfm_reconstruction_nvm) or self.rerun():
octx.run('export_visualsfm --points')
else:
log.ODM_WARNING('Found a valid OpenSfM NVM reconstruction file in: %s' %
tree.opensfm_reconstruction_nvm)
if reconstruction.multi_camera:
log.ODM_INFO("Multiple bands found")
# Write NVM files for the various bands
for band in reconstruction.multi_camera:
nvm_file = octx.path("undistorted", "reconstruction_%s.nvm" % band['name'].lower())
if not io.file_exists(nvm_file) or self.rerun():
img_map = {}
if primary_band_name is None:
primary_band_name = multispectral.get_primary_band_name(reconstruction.multi_camera, args.primary_band)
if p2s is None:
s2p, p2s = multispectral.compute_band_maps(reconstruction.multi_camera, primary_band_name)
for fname in p2s:
# Primary band maps to itself
if band['name'] == primary_band_name:
img_map[fname + '.tif'] = fname + '.tif'
else:
band_filename = next((p.filename for p in p2s[fname] if p.band_name == band['name']), None)
if band_filename is not None:
img_map[fname + '.tif'] = band_filename + '.tif'
else:
log.ODM_WARNING("Cannot find %s band equivalent for %s" % (band, fname))
nvm.replace_nvm_images(tree.opensfm_reconstruction_nvm, img_map, nvm_file)
else:
log.ODM_WARNING("Found existing NVM file %s" % nvm_file)
# Skip dense reconstruction if necessary and export
# sparse reconstruction instead
if args.fast_orthophoto:
output_file = octx.path('reconstruction.ply')
if not io.file_exists(output_file) or self.rerun():
octx.run('export_ply --no-cameras --point-num-views')
else:
log.ODM_WARNING("Found a valid PLY reconstruction in %s" % output_file)
cleanup_disk_space()
if args.optimize_disk_space:
os.remove(octx.path("tracks.csv"))
if io.file_exists(octx.recon_backup_file()):
os.remove(octx.recon_backup_file())
if io.dir_exists(octx.path("undistorted", "depthmaps")):
files = glob.glob(octx.path("undistorted", "depthmaps", "*.npz"))
for f in files:
os.remove(f)
# Keep these if using OpenMVS
if args.fast_orthophoto:
files = [octx.path("undistorted", "tracks.csv"),
octx.path("undistorted", "reconstruction.json")
]
for f in files:
if os.path.exists(f):
os.remove(f)
def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
if not photos:
log.ODM_ERROR('Not enough photos in photos array to start OpenSfM')
exit(1)
octx = OSFMContext(tree.opensfm)
octx.setup(args,
tree.dataset_raw,
photos,
gcp_path=reconstruction.gcp.gcp_path,
rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(20)
octx.feature_matching(self.rerun())
self.update_progress(30)
octx.reconstruct(self.rerun())
self.update_progress(70)
# If we find a special flag file for split/merge we stop right here
if os.path.exists(octx.path("split_merge_stop_at_reconstruction.txt")):
log.ODM_INFO("Stopping OpenSfM early because we found: %s" %
octx.path("split_merge_stop_at_reconstruction.txt"))
self.next_stage = None
return
if args.fast_orthophoto:
output_file = octx.path('reconstruction.ply')
elif args.use_opensfm_dense:
output_file = tree.opensfm_model
else:
output_file = tree.opensfm_reconstruction
updated_config_flag_file = octx.path('updated_config.txt')
if not io.file_exists(updated_config_flag_file) or self.rerun():
octx.update_config({
'undistorted_image_max_size':
gsd.image_max_size(photos,
args.orthophoto_resolution,
tree.opensfm_reconstruction,
ignore_gsd=args.ignore_gsd)
})
octx.touch(updated_config_flag_file)
# These will be used for texturing
undistorted_images_path = octx.path("undistorted")
if not io.dir_exists(undistorted_images_path) or self.rerun():
octx.run('undistort')
else:
log.ODM_WARNING("Found an undistorted directory in %s" %
undistorted_images_path)
self.update_progress(80)
if not io.file_exists(tree.opensfm_reconstruction_nvm) or self.rerun():
octx.run('export_visualsfm --undistorted')
else:
log.ODM_WARNING(
'Found a valid OpenSfM NVM reconstruction file in: %s' %
tree.opensfm_reconstruction_nvm)
self.update_progress(85)
# Skip dense reconstruction if necessary and export
# sparse reconstruction instead
if args.fast_orthophoto:
if not io.file_exists(output_file) or self.rerun():
octx.run('export_ply --no-cameras')
else:
log.ODM_WARNING("Found a valid PLY reconstruction in %s" %
output_file)
elif args.use_opensfm_dense:
if not io.file_exists(output_file) or self.rerun():
octx.run('compute_depthmaps')
else:
log.ODM_WARNING("Found a valid dense reconstruction in %s" %
output_file)
# check if reconstruction was exported to bundler before
octx.export_bundler(tree.opensfm_bundle_list, self.rerun())
self.update_progress(90)
if reconstruction.is_georeferenced() and (not io.file_exists(
tree.opensfm_transformation) or self.rerun()):
octx.run('export_geocoords --transformation --proj \'%s\'' %
reconstruction.georef.proj4())
else:
log.ODM_WARNING("Will skip exporting %s" %
tree.opensfm_transformation)
def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
if not photos:
log.ODM_ERROR('Not enough photos in photos array to start OpenSfM')
exit(1)
octx = OSFMContext(tree.opensfm)
octx.setup(args,
tree.dataset_raw,
photos,
reconstruction=reconstruction,
rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(20)
octx.feature_matching(self.rerun())
self.update_progress(30)
octx.reconstruct(self.rerun())
octx.extract_cameras(tree.path("cameras.json"), self.rerun())
self.update_progress(70)
# If we find a special flag file for split/merge we stop right here
if os.path.exists(octx.path("split_merge_stop_at_reconstruction.txt")):
log.ODM_INFO("Stopping OpenSfM early because we found: %s" %
octx.path("split_merge_stop_at_reconstruction.txt"))
self.next_stage = None
return
if args.fast_orthophoto:
output_file = octx.path('reconstruction.ply')
elif args.use_opensfm_dense:
output_file = tree.opensfm_model
else:
output_file = tree.opensfm_reconstruction
updated_config_flag_file = octx.path('updated_config.txt')
# Make sure it's capped by the depthmap-resolution arg,
# since the undistorted images are used for MVS
outputs['undist_image_max_size'] = max(
gsd.image_max_size(photos,
args.orthophoto_resolution,
tree.opensfm_reconstruction,
ignore_gsd=args.ignore_gsd,
has_gcp=reconstruction.has_gcp()),
args.depthmap_resolution)
if not io.file_exists(updated_config_flag_file) or self.rerun():
octx.update_config({
'undistorted_image_max_size':
outputs['undist_image_max_size']
})
octx.touch(updated_config_flag_file)
# These will be used for texturing / MVS
undistorted_images_path = octx.path("undistorted", "images")
if not io.dir_exists(undistorted_images_path) or self.rerun():
octx.run('undistort')
else:
log.ODM_WARNING("Found an undistorted directory in %s" %
undistorted_images_path)
self.update_progress(80)
if reconstruction.multi_camera:
# Dump band image lists
log.ODM_INFO("Multiple bands found")
for band in reconstruction.multi_camera:
log.ODM_INFO("Exporting %s band" % band['name'])
image_list_file = octx.path("image_list_%s.txt" %
band['name'].lower())
if not io.file_exists(image_list_file) or self.rerun():
with open(image_list_file, "w") as f:
f.write("\n".join([p.filename
for p in band['photos']]))
log.ODM_INFO("Wrote %s" % image_list_file)
else:
log.ODM_WARNING(
"Found a valid image list in %s for %s band" %
(image_list_file, band['name']))
nvm_file = octx.path(
"undistorted",
"reconstruction_%s.nvm" % band['name'].lower())
if not io.file_exists(nvm_file) or self.rerun():
octx.run('export_visualsfm --points --image_list "%s"' %
image_list_file)
os.rename(tree.opensfm_reconstruction_nvm, nvm_file)
else:
log.ODM_WARNING(
"Found a valid NVM file in %s for %s band" %
(nvm_file, band['name']))
if not io.file_exists(tree.opensfm_reconstruction_nvm) or self.rerun():
octx.run('export_visualsfm --points')
else:
log.ODM_WARNING(
'Found a valid OpenSfM NVM reconstruction file in: %s' %
tree.opensfm_reconstruction_nvm)
self.update_progress(85)
# Skip dense reconstruction if necessary and export
# sparse reconstruction instead
if args.fast_orthophoto:
if not io.file_exists(output_file) or self.rerun():
octx.run('export_ply --no-cameras')
else:
log.ODM_WARNING("Found a valid PLY reconstruction in %s" %
output_file)
elif args.use_opensfm_dense:
if not io.file_exists(output_file) or self.rerun():
octx.run('compute_depthmaps')
else:
log.ODM_WARNING("Found a valid dense reconstruction in %s" %
output_file)
self.update_progress(90)
if reconstruction.is_georeferenced() and (not io.file_exists(
tree.opensfm_transformation) or self.rerun()):
octx.run('export_geocoords --transformation --proj \'%s\'' %
reconstruction.georef.proj4())
else:
log.ODM_WARNING("Will skip exporting %s" %
tree.opensfm_transformation)
def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
if not photos:
log.ODM_ERROR('Not enough photos in photos array to start OpenSfM')
exit(1)
octx = OSFMContext(tree.opensfm)
octx.setup(args,
tree.dataset_raw,
photos,
gcp_path=tree.odm_georeferencing_gcp,
rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(20)
octx.feature_matching(self.rerun())
self.update_progress(30)
octx.reconstruct(self.rerun())
self.update_progress(70)
# If we find a special flag file for split/merge we stop right here
if os.path.exists(octx.path("split_merge_stop_at_reconstruction.txt")):
log.ODM_INFO("Stopping OpenSfM early because we found: %s" %
octx.path("split_merge_stop_at_reconstruction.txt"))
self.next_stage = None
return
if args.fast_orthophoto:
output_file = octx.path('reconstruction.ply')
elif args.use_opensfm_dense:
output_file = tree.opensfm_model
else:
output_file = tree.opensfm_reconstruction
# Always export VisualSFM's reconstruction and undistort images
# as we'll use these for texturing (after GSD estimation and resizing)
if not args.ignore_gsd:
image_scale = gsd.image_scale_factor(args.orthophoto_resolution,
tree.opensfm_reconstruction)
else:
image_scale = 1.0
if not io.file_exists(tree.opensfm_reconstruction_nvm) or self.rerun():
octx.run(
'export_visualsfm --image_extension png --scale_focal %s' %
image_scale)
else:
log.ODM_WARNING(
'Found a valid OpenSfM NVM reconstruction file in: %s' %
tree.opensfm_reconstruction_nvm)
# These will be used for texturing
undistorted_images_path = octx.path("undistorted")
if not io.dir_exists(undistorted_images_path) or self.rerun():
octx.run('undistort --image_format png --image_scale %s' %
image_scale)
else:
log.ODM_WARNING("Found an undistorted directory in %s" %
undistorted_images_path)
self.update_progress(80)
# Skip dense reconstruction if necessary and export
# sparse reconstruction instead
if args.fast_orthophoto:
if not io.file_exists(output_file) or self.rerun():
octx.run('export_ply --no-cameras')
else:
log.ODM_WARNING("Found a valid PLY reconstruction in %s" %
output_file)
elif args.use_opensfm_dense:
# Undistort images at full scale in JPG
# (TODO: we could compare the size of the PNGs if they are < than depthmap_resolution
# and use those instead of re-exporting full resolution JPGs)
if not io.file_exists(output_file) or self.rerun():
octx.run('undistort')
octx.run('compute_depthmaps')
else:
log.ODM_WARNING("Found a valid dense reconstruction in %s" %
output_file)
# check if reconstruction was exported to bundler before
octx.export_bundler(tree.opensfm_bundle_list, self.rerun())
self.update_progress(90)
if reconstruction.georef and (not io.file_exists(
tree.opensfm_transformation) or self.rerun()):
octx.run('export_geocoords --transformation --proj \'%s\'' %
reconstruction.georef.projection.srs)
else:
log.ODM_WARNING("Will skip exporting %s" %
tree.opensfm_transformation)
def process(self, args, outputs):
tree = outputs['tree']
reconstruction = outputs['reconstruction']
photos = reconstruction.photos
if not photos:
log.ODM_ERROR('Not enough photos in photos array to start OpenSfM')
exit(1)
octx = OSFMContext(tree.opensfm)
octx.setup(args,
tree.dataset_raw,
photos,
reconstruction=reconstruction,
rerun=self.rerun())
octx.extract_metadata(self.rerun())
self.update_progress(20)
octx.feature_matching(self.rerun())
self.update_progress(30)
octx.reconstruct(self.rerun())
octx.extract_cameras(tree.path("cameras.json"), self.rerun())
self.update_progress(70)
if args.optimize_disk_space:
for folder in ["features", "matches", "exif", "reports"]:
folder_path = octx.path(folder)
if os.path.islink(folder_path):
os.unlink(folder_path)
else:
shutil.rmtree(folder_path)
# If we find a special flag file for split/merge we stop right here
if os.path.exists(octx.path("split_merge_stop_at_reconstruction.txt")):
log.ODM_INFO("Stopping OpenSfM early because we found: %s" %
octx.path("split_merge_stop_at_reconstruction.txt"))
self.next_stage = None
return
if args.fast_orthophoto:
output_file = octx.path('reconstruction.ply')
elif args.use_opensfm_dense:
output_file = tree.opensfm_model
else:
output_file = tree.opensfm_reconstruction
updated_config_flag_file = octx.path('updated_config.txt')
# Make sure it's capped by the depthmap-resolution arg,
# since the undistorted images are used for MVS
outputs['undist_image_max_size'] = max(
gsd.image_max_size(photos,
args.orthophoto_resolution,
tree.opensfm_reconstruction,
ignore_gsd=args.ignore_gsd,
has_gcp=reconstruction.has_gcp()),
get_depthmap_resolution(args, photos))
if not io.file_exists(updated_config_flag_file) or self.rerun():
octx.update_config({
'undistorted_image_max_size':
outputs['undist_image_max_size']
})
octx.touch(updated_config_flag_file)
# These will be used for texturing / MVS
if args.radiometric_calibration == "none":
octx.convert_and_undistort(self.rerun())
else:
def radiometric_calibrate(shot_id, image):
photo = reconstruction.get_photo(shot_id)
return multispectral.dn_to_reflectance(
photo,
image,
use_sun_sensor=args.radiometric_calibration ==
"camera+sun")
octx.convert_and_undistort(self.rerun(), radiometric_calibrate)
self.update_progress(80)
if reconstruction.multi_camera:
# Dump band image lists
log.ODM_INFO("Multiple bands found")
for band in reconstruction.multi_camera:
log.ODM_INFO("Exporting %s band" % band['name'])
image_list_file = octx.path("image_list_%s.txt" %
band['name'].lower())
if not io.file_exists(image_list_file) or self.rerun():
with open(image_list_file, "w") as f:
f.write("\n".join([p.filename
for p in band['photos']]))
log.ODM_INFO("Wrote %s" % image_list_file)
else:
log.ODM_WARNING(
"Found a valid image list in %s for %s band" %
(image_list_file, band['name']))
nvm_file = octx.path(
"undistorted",
"reconstruction_%s.nvm" % band['name'].lower())
if not io.file_exists(nvm_file) or self.rerun():
octx.run('export_visualsfm --points --image_list "%s"' %
image_list_file)
os.rename(tree.opensfm_reconstruction_nvm, nvm_file)
else:
log.ODM_WARNING(
"Found a valid NVM file in %s for %s band" %
(nvm_file, band['name']))
if not io.file_exists(tree.opensfm_reconstruction_nvm) or self.rerun():
octx.run('export_visualsfm --points')
else:
log.ODM_WARNING(
'Found a valid OpenSfM NVM reconstruction file in: %s' %
tree.opensfm_reconstruction_nvm)
self.update_progress(85)
# Skip dense reconstruction if necessary and export
# sparse reconstruction instead
if args.fast_orthophoto:
if not io.file_exists(output_file) or self.rerun():
octx.run('export_ply --no-cameras')
else:
log.ODM_WARNING("Found a valid PLY reconstruction in %s" %
output_file)
elif args.use_opensfm_dense:
if not io.file_exists(output_file) or self.rerun():
octx.run('compute_depthmaps')
else:
log.ODM_WARNING("Found a valid dense reconstruction in %s" %
output_file)
self.update_progress(90)
if reconstruction.is_georeferenced() and (not io.file_exists(
tree.opensfm_transformation) or self.rerun()):
octx.run('export_geocoords --transformation --proj \'%s\'' %
reconstruction.georef.proj4())
else:
log.ODM_WARNING("Will skip exporting %s" %
tree.opensfm_transformation)
if args.optimize_disk_space:
os.remove(octx.path("tracks.csv"))
if io.dir_exists(octx.path("undistorted", "depthmaps")):
files = glob.glob(
octx.path("undistorted", "depthmaps", "*.npz"))
for f in files:
os.remove(f)
# Keep these if using OpenMVS
if args.fast_orthophoto or args.use_opensfm_dense:
files = [
octx.path("undistorted", "tracks.csv"),
octx.path("undistorted", "reconstruction.json")
]
for f in files:
if os.path.exists(f):
os.remove(f)
