def __save_ifgs_dict_with_headers_and_epochs(dest_tifs, ifgs_dict, params,
process_tifs):
tmpdir = params[cf.TMPDIR]
if not os.path.exists(tmpdir):
shared.mkdir_p(tmpdir)
preread_ifgs_file = Configuration.preread_ifgs(params)
nifgs = len(dest_tifs)
# add some extra information that's also useful later
gt, md, wkt = shared.get_geotiff_header_info(
process_tifs[0].tmp_sampled_path)
epochlist = algorithm.get_epochs(ifgs_dict)[0]
log.info('Found {} unique epochs in the {} interferogram network'.format(
len(epochlist.dates), nifgs))
ifgs_dict['epochlist'] = epochlist
ifgs_dict['gt'] = gt
ifgs_dict['md'] = md
ifgs_dict['wkt'] = wkt
# dump ifgs_dict file for later use
cp.dump(ifgs_dict, open(preread_ifgs_file, 'wb'))
for k in ['gt', 'epochlist', 'md', 'wkt']:
ifgs_dict.pop(k)
return ifgs_dict
def _write_dem_errors(ifg_paths: list, params: dict,
preread_ifgs: dict) -> None:
"""
Convenience function for writing DEM error (one file) and DEM error correction for each IFG to disc
:param ifg_paths: List of interferogram class objects.
:param params: Dictionary of PyRate configuration parameters.
:param preread_ifgs: Dictionary of interferogram metadata.
"""
tiles = params[C.TILES]
# re-assemble tiles and save into dem_error dir
shape = preread_ifgs[ifg_paths[0]].shape
# save dem error as geotiff file in out directory
gt, md, wkt = shared.get_geotiff_header_info(ifg_paths[0])
md[ifc.DATA_TYPE] = ifc.DEM_ERROR
dem_error = assemble_tiles(shape,
params[C.TMPDIR],
tiles,
out_type='dem_error')
dem_error_file = os.path.join(params[C.DEM_ERROR_DIR], 'dem_error.tif')
shared.remove_file_if_exists(dem_error_file)
shared.write_output_geotiff(md, gt, wkt, dem_error, dem_error_file, np.nan)
# read the average bperp vals for each ifg and each tile
bperp = np.empty(shape=(len(tiles), len(ifg_paths)), dtype=np.float64)
for t in tiles:
bperp_file = Path(
join(params[C.TMPDIR], 'bperp_avg_' + str(t.index) + '.npy'))
arr = np.load(file=bperp_file)
bperp[t.index, :] = arr
# loop over all ifgs
idx = 0
for ifg_path in ifg_paths:
ifg = Ifg(ifg_path)
ifg.open()
shared.nan_and_mm_convert(ifg,
params) # ensure we have phase data in mm
# read dem error correction file from tmpdir
dem_error_correction_ifg = assemble_tiles(
shape,
params[C.TMPDIR],
tiles,
out_type='dem_error_correction',
index=idx)
# calculate average bperp value across all tiles for the ifg
bperp_val = np.nanmean(bperp[:, idx])
dem_error_correction_on_disc = MultiplePaths.dem_error_path(
ifg.data_path, params)
np.save(file=dem_error_correction_on_disc,
arr=dem_error_correction_ifg)
idx += 1
# subtract DEM error from the ifg
ifg.phase_data -= dem_error_correction_ifg
_save_dem_error_corrected_phase(ifg, bperp_val)
def __save_geom_files(ifg_path, dest, array, out_type):
"""
Convenience function to save geometry geotiff files
"""
log.debug('Saving PyRate outputs {}'.format(out_type))
gt, md, wkt = shared.get_geotiff_header_info(ifg_path)
md[ifc.DATA_TYPE] = out_type_md_dict[out_type]
shared.remove_file_if_exists(dest)
log.info(f"Writing geotiff: {dest}")
shared.write_output_geotiff(md, gt, wkt, array, dest, np.nan)
def _create_ifg_dict(dest_tifs, params):
"""
1. Convert ifg phase data into numpy binary files.
2. Save the preread_ifgs dict with information about the ifgs that are
later used for fast loading of Ifg files in IfgPart class
:param list dest_tifs: List of destination tifs
:param dict params: Config dictionary
:param list tiles: List of all Tile instances
:return: preread_ifgs: Dictionary containing information regarding
interferograms that are used later in workflow
:rtype: dict
"""
ifgs_dict = {}
nifgs = len(dest_tifs)
process_tifs = mpiops.array_split(dest_tifs)
for d in process_tifs:
ifg = shared._prep_ifg(d, params)
ifgs_dict[d] = PrereadIfg(path=d,
nan_fraction=ifg.nan_fraction,
master=ifg.master,
slave=ifg.slave,
time_span=ifg.time_span,
nrows=ifg.nrows,
ncols=ifg.ncols,
metadata=ifg.meta_data)
ifg.close()
ifgs_dict = _join_dicts(mpiops.comm.allgather(ifgs_dict))
preread_ifgs_file = join(params[cf.TMPDIR], 'preread_ifgs.pk')
if mpiops.rank == MASTER_PROCESS:
# add some extra information that's also useful later
gt, md, wkt = shared.get_geotiff_header_info(process_tifs[0])
epochlist = algorithm.get_epochs(ifgs_dict)[0]
log.info(
'Found {} unique epochs in the {} interferogram network'.format(
len(epochlist.dates), nifgs))
ifgs_dict['epochlist'] = epochlist
ifgs_dict['gt'] = gt
ifgs_dict['md'] = md
ifgs_dict['wkt'] = wkt
# dump ifgs_dict file for later use
cp.dump(ifgs_dict, open(preread_ifgs_file, 'wb'))
mpiops.comm.barrier()
preread_ifgs = OrderedDict(
sorted(cp.load(open(preread_ifgs_file, 'rb')).items()))
log.debug('Finished converting phase_data to numpy in process {}'.format(
mpiops.rank))
return preread_ifgs
def write_timeseries_geotiff(ifgs, params, tsincr, pr_type):
# setup metadata for writing into result files
gt, md, wkt = get_geotiff_header_info(ifgs[0].data_path)
epochlist = algorithm.get_epochs(ifgs)[0]
for i in range(tsincr.shape[2]):
md[ifc.EPOCH_DATE] = epochlist.dates[i + 1]
md['SEQUENCE_POSITION'] = i + 1 # sequence position
data = tsincr[:, :, i]
dest = join(params[cf.OUT_DIR],
pr_type + "_" + str(epochlist.dates[i + 1]) + ".tif")
md[ifc.DATA_TYPE] = pr_type
write_output_geotiff(md, gt, wkt, data, dest, np.nan)
def write_stackrate_tifs(ifgs, params, res):
rate, error, samples = res
gt, md, wkt = get_geotiff_header_info(ifgs[0].data_path)
epochlist = algorithm.get_epochs(ifgs)[0]
dest = join(params[cf.OUT_DIR], "stack_rate.tif")
md[ifc.EPOCH_DATE] = epochlist.dates
md[ifc.DATA_TYPE] = ifc.STACKRATE
write_output_geotiff(md, gt, wkt, rate, dest, np.nan)
dest = join(params[cf.OUT_DIR], "stack_error.tif")
md[ifc.DATA_TYPE] = ifc.STACKERROR
write_output_geotiff(md, gt, wkt, error, dest, np.nan)
dest = join(params[cf.OUT_DIR], "stack_samples.tif")
md[ifc.DATA_TYPE] = ifc.STACKSAMP
write_output_geotiff(md, gt, wkt, samples, dest, np.nan)
write_stackrate_numpy_files(error, rate, samples, params)
def write_linrate_tifs(ifgs, params, res):
# log.info('Writing linrate results')
rate, error, samples = res
gt, md, wkt = get_geotiff_header_info(ifgs[0].data_path)
epochlist = algorithm.get_epochs(ifgs)[0]
dest = join(params[cf.OUT_DIR], "linrate.tif")
md[ifc.EPOCH_DATE] = epochlist.dates
md[ifc.DATA_TYPE] = ifc.LINRATE
write_output_geotiff(md, gt, wkt, rate, dest, np.nan)
dest = join(params[cf.OUT_DIR], "linerror.tif")
md[ifc.DATA_TYPE] = ifc.LINERROR
write_output_geotiff(md, gt, wkt, error, dest, np.nan)
dest = join(params[cf.OUT_DIR], "linsamples.tif")
md[ifc.DATA_TYPE] = ifc.LINSAMP
write_output_geotiff(md, gt, wkt, samples, dest, np.nan)
write_linrate_numpy_files(error, rate, samples, params)
