def main():
parser = getparser()
args = parser.parse_args()
img = os.path.abspath(args.img)
try:
img_list = sorted(glob.glob(os.path.join(img, '*.tif')))
temp = img_list[1]
except BaseException:
img_list = sorted(glob.glob(os.path.join(img, '*.tiff')))
if len(img_list) == 0:
print("No images in the specified folder, exiting")
sys.exit()
mode = args.mode
session = args.t
ba_prefix = args.ba_prefix
overlap_list_fn = args.overlap_pkl
frame_index = args.frame_index
dem = args.dem
texture = args.texture
sampling_interval = args.sampling_interval
if args.cam:
cam_folder = args.cam
if args.ba_prefix:
ba_prefix = args.ba_prefix
outfol = args.outfol
if mode == 'video':
# assume for now that we are still operating on a fixed image interval method
# can accomodate different convergence angle function method here.
frame_gdf = skysat.parse_frame_index(frame_index)
# for now hardcording sgm,mgm,kernel params, should accept as inputs.
# Maybe discuss with David with these issues/decisions when the overall
# system is in place
if args.mvs == 1:
job_list = skysat.video_mvs(img,
t=session,
cam_fol=args.cam,
ba_prefix=args.ba_prefix,
dem=args.dem,
sampling_interval=sampling_interval,
texture=texture,
outfol=outfol,
block=args.block,
frame_index=frame_gdf)
else:
if args.full_extent == 1:
full_extent = True
else:
full_extent = False
job_list = skysat.prep_video_stereo_jobs(
img,
t=session,
cam_fol=args.cam,
ba_prefix=args.ba_prefix,
dem=args.dem,
sampling_interval=sampling_interval,
texture=texture,
outfol=outfol,
block=args.block,
frame_index=frame_gdf,
full_extent=full_extent,
entry_point=args.entry_point)
elif mode == 'triplet':
if args.crop_map == 1:
crop_map = True
else:
crop_map = False
job_list = skysat.triplet_stereo_job_list(
t=args.t,
threads=args.threads,
overlap_list=args.overlap_pkl,
img_list=img_list,
ba_prefix=args.ba_prefix,
cam_fol=args.cam,
dem=args.dem,
crop_map=crop_map,
texture=texture,
outfol=outfol,
block=args.block,
entry_point=args.entry_point)
# decide on number of processes
# if block matching, Plieades is able to handle 30-40 4 threaded jobs on bro node
# if MGM/SGM, 25 . This stepup is arbitrariry, research on it more.
# next build should accept no of jobs and stereo threads as inputs
print(job_list[0])
n_cpu = cpu_count()
# no of parallel jobs with user specified threads per job
jobs = int(n_cpu / args.threads)
stereo_log = p_map(asp.run_cmd, ['stereo'] * len(job_list),
job_list,
num_cpus=jobs)
stereo_log_fn = os.path.join(outfol, 'stereo_log.log')
print("Consolidated stereo log saved at {}".format(stereo_log_fn))
#with open(stereo_log_fn,'w') as f:
# for logs in stereo_log:
# f.write(logs)
print("Script is complete")
def main():
parser = getparser()
args = parser.parse_args()
mode = args.mode
session = args.t
img_folder = os.path.abspath(args.img)
outdir = os.path.abspath(args.outdir)
if not os.path.exists(outdir):
try:
os.makedir(outdir)
except:
os.makedirs(outdir)
if mode == 'video':
sampling = args.video_sampling_mode
frame_index = skysat.parse_frame_index(args.frame_index, True)
product_level = 'l1a'
num_samples = len(frame_index)
frames = frame_index.name.values
sampler = args.sampler
outdf = os.path.join(outdir, os.path.basename(args.frame_index))
if sampling == 'sampling_interval':
print(
"Hardcoded sampling interval results in frame exclusion at the end of the video sequence based on step size, better to chose the num_images mode and the program will equally distribute accordingly"
)
idx = np.arange(0, num_samples, sampler)
outdf = '{}_sampling_inteval_{}.csv'.format(
os.path.splitext(outdf)[0], sampler)
else:
print("Sampling {} from {} of the input video sequence".format(
sampler, num_samples))
idx = np.linspace(0, num_samples - 1, sampler, dtype=int)
outdf = '{}_sampling_inteval_aprox{}.csv'.format(
os.path.splitext(outdf)[0], idx[1] - idx[0])
sub_sampled_frames = frames[idx]
sub_df = frame_index[frame_index['name'].isin(
list(sub_sampled_frames))]
sub_df.to_csv(outdf, sep=',', index=False)
#this is camera/gcp initialisation
n = len(sub_sampled_frames)
img_list = [
glob.glob(os.path.join(img_folder, '{}*.tiff'.format(frame)))[0]
for frame in sub_sampled_frames
]
pitch = [1] * n
out_fn = [
os.path.join(outdir, '{}_frame_idx.tsai'.format(frame))
for frame in sub_sampled_frames
]
out_gcp = [
os.path.join(outdir, '{}_frame_idx.gcp'.format(frame))
for frame in sub_sampled_frames
]
frame_index = [args.frame_index] * n
camera = [None] * n
gcp_factor = 4
elif mode == 'triplet':
df = pd.read_pickle(args.overlap_pkl)
img_list = list(
np.unique(np.array(list(df.img1.values) + list(df.img2.values))))
img_list = [
os.path.splitext(os.path.basename(img))[0] for img in img_list
]
cam_list = [
glob.glob(os.path.join(img_folder, '{}*.tif'.format(img)))[0]
for img in img_list
]
n = len(img_list)
if args.product_level == 'l1b':
pitch = [0.8] * n
else:
pitch = [1.0] * n
out_fn = [
os.path.join(outdir, '{}_rpc.tsai'.format(frame))
for frame in img_list
]
out_gcp = [
os.path.join(outdir, '{}_rpc.gcp'.format(frame))
for frame in img_list
]
camera = cam_list
frame_index = [None] * n
img_list = cam_list
gcp_factor = 8
fl = [553846.153846] * n
cx = [1280] * n
cy = [540] * n
dem = args.dem
ht_datum = [malib.get_stats_dict(iolib.fn_getma(dem))['median']
] * n # use this value for height where DEM has no-data
gcp_std = [1] * n
datum = ['WGS84'] * n
refdem = [dem] * n
n_proc = 30
#n_proc = cpu_count()
cam_gen_log = p_map(asp.cam_gen,
img_list,
fl,
cx,
cy,
pitch,
ht_datum,
gcp_std,
out_fn,
out_gcp,
datum,
refdem,
camera,
frame_index,
num_cpus=n_proc)
print("writing gcp with basename removed")
# count expexted gcp
print(f"Total expected GCP {gcp_factor*n}")
asp.clean_gcp(out_gcp, outdir)
# saving subprocess consolidated log file
from datetime import datetime
now = datetime.now()
log_fn = os.path.join(outdir, 'camgen_{}.log'.format(now))
print("saving subprocess camgen log at {}".format(log_fn))
with open(log_fn, 'w') as f:
for log in cam_gen_log:
f.write(log)
print("Script is complete !")
def main():
parser = get_parser()
args = parser.parse_args()
tr = str(args.tr)
tsrs = args.tsrs
dir = os.path.abspath(args.img_folder)
outdir = os.path.abspath(args.out_folder)
images = sorted(glob.glob(os.path.join(dir,'*.tif*')))
if os.path.islink(images[0]):
images = [os.readlink(x) for x in images]
del_opt = args.delete_temporary_files
dem=args.DEM
cam_folder = args.cam
ba_prefix = args.ba_prefix
mode = args.mode
if mode == 'browse':
"""
this block creates low-res orthomosaics from RPC info for browsing purpose only
"""
for_img_list,nadir_img_list,aft_img_list,for_time,nadir_time,aft_time = skysat.sort_img_list(images)
for_out_dir = os.path.join(outdir,'for_map_browse')
nadir_out_dir = os.path.join(outdir,'nadir_map_browse')
aft_out_dir = os.path.join(outdir,'aft_map_browse')
for_out_list = [os.path.join(for_out_dir,os.path.splitext(os.path.basename(img))[0]+'_browse_map.tif') for img in for_img_list]
nadir_out_list = [os.path.join(nadir_out_dir,os.path.splitext(os.path.basename(img))[0]+'_browse_map.tif') for img in nadir_img_list]
aft_out_list = [os.path.join(aft_out_dir,os.path.splitext(os.path.basename(img))[0]+'_browse_map.tif') for img in aft_img_list]
for_count,nadir_count,aft_count = [len(for_img_list), len(nadir_img_list), len(aft_img_list)]
print("Performing orthorectification for forward images {}".format(for_time))
for_map_log = p_map(asp.mapproject,for_img_list,for_out_list,[args.session]*for_count,['WGS84']*for_count,[None]*for_count,['EPSG:4326']*for_count,[None]*for_count,[None]*for_count)
print("Performing orthorectification for nadir images {}".format(nadir_time))
nadir_map_log = p_map(asp.mapproject,nadir_img_list,nadir_out_list,[args.session]*nadir_count,['WGS84']*nadir_count,[None]*nadir_count,['EPSG:4326']*nadir_count,[None]*nadir_count,[None]*nadir_count)
print("Performing orthorectification for aft images {}".format(aft_time))
aft_map_log = p_map(asp.mapproject,aft_img_list,aft_out_list,[args.session]*aft_count,['WGS84']*aft_count,[None]*aft_count,['EPSG:4326']*aft_count,[None]*aft_count,[None]*aft_count)
ortho_log = os.path.join(outdir,'low_res_ortho.log')
print("Orthorectification log saved at {}".format(ortho_log))
with open(ortho_log,'w') as f:
total_ortho_log = for_map_log+nadir_map_log+aft_map_log
for log in itertools.chain.from_iterable(total_ortho_log):
f.write(log)
# after orthorectification, now do mosaic
for_out_mos = os.path.join(outdir,'for_map_mos_{}m.tif'.format(tr))
for_map_list = sorted(glob.glob(os.path.join(for_out_dir,'*.tif')))
nadir_out_mos = os.path.join(outdir,'nadir_map_mos_{}m.tif'.format(tr))
nadir_map_list = sorted(glob.glob(os.path.join(nadir_out_dir,'*.tif')))
aft_out_mos = os.path.join(outdir,'aft_map_mos_{}m.tif'.format(tr))
aft_map_list = sorted(glob.glob(os.path.join(aft_out_dir,'*.tif')))
print("Preparing forward browse orthomosaic")
for_mos_log = asp.dem_mosaic(for_map_list,for_out_mos,tr,tsrs,'first',None)
print("Preparing nadir browse orthomosaic")
nadir_mos_log = asp.dem_mosaic(nadir_map_list, nadir_out_mos, tr, tsrs, 'first',None)
print("Preparing aft browse orthomosaic")
aft_mos_log = asp.dem_mosaic(aft_map_list, aft_out_mos, tr, tsrs, 'first',None)
## delete temporary files
if del_opt:
[shutil.rmtree(x) for x in [for_out_dir,nadir_out_dir,aft_out_dir]]
#Save figure to jpeg ?
fig_title = os.path.basename(images[0]).split('_',15)[0]+'_'+for_time+'_'+nadir_time+'_'+aft_time
fig,ax = plt.subplots(1,3,figsize=(10,10))
pltlib.iv_fn(for_out_mos,full=True,ax=ax[0],cmap='gray',scalebar=True,title='Forward')
pltlib.iv_fn(nadir_out_mos,full=True,ax=ax[1],cmap='gray',scalebar=True,title='NADIR')
pltlib.iv_fn(aft_out_mos,full=True,ax=ax[2],cmap='gray',scalebar=True,title='Aft')
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
fig.suptitle(fig_title)
browse_img_fn = os.path.join(outdir,'browse_img_{}_{}m.jpg'.format(fig_title,tr))
fig.savefig(browse_img_fn,dpi=300,bbox_inches='tight',pad_inches=0.1)
print("Browse figure saved at {}".format(browse_img_fn))
if mode == 'science':
img_list = images
if args.frame_index is not 'None':
frame_index = skysat.parse_frame_index(args.frame_index)
img_list = [glob.glob(os.path.join(dir,'{}*.tiff'.format(frame)))[0] for frame in frame_index.name.values]
print("no of images is {}".format(len(img_list)))
img_prefix = [os.path.splitext(os.path.basename(img))[0] for img in img_list]
out_list = [os.path.join(outdir,img+'_map.tif') for img in img_prefix]
session_list = [args.session]*len(img_list)
dem_list = [dem]*len(img_list)
tr_list = [args.tr]*len(img_list)
if args.frame_index is not 'None':
# this hack is for video
df = skysat.parse_frame_index(args.frame_index)
trunc_df = df[df['name'].isin(img_prefix)]
tr_list = [str(gsd) for gsd in trunc_df.gsd.values]
srs_list = [tsrs]*len(img_list)
if args.session == 'pinhole':
if ba_prefix:
cam_list = [glob.glob(os.path.abspath(ba_prefix)+'-'+os.path.splitext(os.path.basename(x))[0]+'*.tsai')[0] for x in img_list]
print("No of cameras is {}".format(len(cam_list)))
else:
print(os.path.join(os.path.abspath(args.cam),os.path.splitext(os.path.basename(img_list[0]))[0]+'*.tsai'))
cam_list = [glob.glob(os.path.join(os.path.abspath(args.cam),os.path.splitext(os.path.basename(x))[0]+'*.tsai'))[0] for x in img_list]
else:
cam_list = [None]*len(img_list)
if ba_prefix:
# not yet implemented
ba_prefix_list = [ba_prefix]*len(img_list)
print("Mapping given images")
ortho_logs = p_map(asp.mapproject,img_list,out_list,session_list,dem_list,tr_list,srs_list,cam_list,num_cpus=int(cpu_count()/4))
ortho_log = os.path.join(outdir,'ortho.log')
print("Saving Orthorectification log at {}".format(ortho_log))
with open(ortho_log,'w') as f:
for log in ortho_logs:
f.write(log)
if args.copy_rpc == 1:
print("Copying RPC from native image to orthoimage in parallel")
copy_rpc_out = p_map(skysat.copy_rpc,img_list,out_list,num_cpus=cpu_count())
if args.orthomosaic == 1:
print("Will also produce median, weighted average and highest resolution orthomosaic")
if args.data == 'triplet':
for_img_list,nadir_img_list,aft_img_list,for_time,nadir_time,aft_time = skysat.sort_img_list(out_list)
res_sorted_list = skysat.res_sort(out_list)
res_sorted_mosaic = os.path.join(outdir,'{}_{}_{}_finest_orthomosaic.tif'.format(for_time,nadir_time,aft_time))
median_mosaic = os.path.join(outdir,'{}_{}_{}_median_orthomosaic.tif'.format(for_time,nadir_time,aft_time))
wt_avg_mosaic = os.path.join(outdir,'{}_{}_{}_wt_avg_orthomosaic.tif'.format(for_time,nadir_time,aft_time))
print("producing finest resolution on top mosaic, per-pixel median and wt_avg mosaic")
all_3_view_mos_logs = p_map(asp.dem_mosaic, [res_sorted_list]*3, [res_sorted_mosaic,median_mosaic,wt_avg_mosaic], ['None']*3, [None]*3, ['first','median',None],[None]*3,num_cpus=4)
res_sorted_log = asp.dem_mosaic(res_sorted_list,res_sorted_mosaic,tr='None',stats='first')
print("producing idependent mosaic for different views in parallel")
for_mosaic = os.path.join(outdir,'{}_for_first_mosaic.tif'.format(for_time))
nadir_mosaic = os.path.join(outdir,'{}_nadir_first_mosaic.tif'.format(nadir_time))
aft_mosaic = os.path.join(outdir,'{}_aft_first_mosaic.tif'.format(aft_time))
# prepare mosaics in parallel
indi_mos_log = p_map(asp.dem_mosaic,[for_img_list,nadir_img_list,aft_img_list], [for_mosaic,nadir_mosaic,aft_mosaic], ['None']*3, [None]*3, ['first']*3,[None]*3,num_cpus=4)
out_log = os.path.join(outdir,'science_mode_ortho_mos.log')
total_mos_log = all_3_view_mos_logs+indi_mos_log
print("Saving orthomosaic log at {}".format(out_log))
with open(out_log,'w') as f:
for log in itertools.chain.from_iterable(total_mos_log):
f.write(log)
if args.data == 'video':
res_sorted_list = skysat.res_sort(out_list)
print("producing orthomasaic with finest on top")
res_sorted_mosaic = os.path.join(outdir,'video_finest_orthomosaic.tif')
print("producing orthomasaic with per-pixel median stats")
median_mosaic = os.path.join(outdir,'video_median_orthomosaic.tif')
print("producing orthomosaic with weighted average statistics")
wt_avg_mosaic = os.path.join(outdir,'video_wt_avg_orthomosaic.tif')
print("Mosaicing will be done in parallel")
all_3_view_mos_logs = p_map(asp.dem_mosaic, [res_sorted_list]*3, [res_sorted_mosaic,median_mosaic,wt_avg_mosaic], ['None']*3, [None]*3, ['first','median',None],[None]*3)
out_log = os.path.join(outdir,'science_mode_ortho_mos.log')
print("Saving orthomosaic log at {}".format(out_log))
with open(out_log,'w') as f:
for log in all_3_view_mos_logs:
f.write(log)
print("Script is complete!")