def test_orbital_correction_legacy_equality_orbfit_method_2(self):
correct._copy_mlooked(self.params)
correct._create_ifg_dict(self.params)
remove_orbital_error(self.new_data_paths, self.params)
onlyfiles = [f for f in os.listdir(SML_TEST_LEGACY_ORBITAL_DIR)
if os.path.isfile(os.path.join(SML_TEST_LEGACY_ORBITAL_DIR, f))
and f.endswith('.csv') and f.__contains__('_method2_')]
count = 0
for i, f in enumerate(onlyfiles):
legacy_phase_data = np.genfromtxt(os.path.join(
SML_TEST_LEGACY_ORBITAL_DIR, f), delimiter=',')
for k, j in enumerate(self.new_data_paths):
if os.path.basename(j).split('_unw.')[0] == os.path.basename(f).split('_method2_')[1].split('.')[0]:
count += 1
ifg = Ifg(j)
ifg.open()
# all numbers equal
# Note this changed as the nodata mask in the gdal_python.gdal_average changed to nan from 0
# np.testing.assert_array_almost_equal(legacy_phase_data, ifg.phase_data, decimal=3)
# number of nans must equal
assert np.sum(np.isnan(legacy_phase_data)) == np.sum(np.isnan(ifg.phase_data))
# ensure that we have expected number of matches
assert count == len(self.new_data_paths)
def test_orbital_error_method2_dummy(self):
"""
does not test anything except that the method is working
"""
# change to orbital error correction method 2
self.params[cf.ORBITAL_FIT_METHOD] = NETWORK_METHOD
self.params[cf.ORBITAL_FIT_LOOKS_X] = 2
self.params[cf.ORBITAL_FIT_LOOKS_Y] = 2
correct._copy_mlooked(self.params)
correct._create_ifg_dict(self.params)
remove_orbital_error(self.new_data_paths, self.params)
onlyfiles = [f for f in os.listdir(SML_TEST_LEGACY_ORBITAL_DIR)
if os.path.isfile(os.path.join(SML_TEST_LEGACY_ORBITAL_DIR, f))
and f.endswith('.csv') and f.__contains__('_method2_')]
count = 0
for i, f in enumerate(onlyfiles):
legacy_phase_data = np.genfromtxt(os.path.join(SML_TEST_LEGACY_ORBITAL_DIR, f), delimiter=',')
for k, j in enumerate(self.new_data_paths):
if os.path.basename(j).split('_unw.')[0] == os.path.basename(f).split('_method2_')[1].split('.')[0]:
count += 1
ifg = Ifg(j)
ifg.open()
# number of nans must equal
assert np.sum(np.isnan(legacy_phase_data)) == np.sum(np.isnan(ifg.phase_data))
# ensure that we have expected number of matches
assert count == len(self.new_data_paths)
def test_vcm_legacy_vs_mpi(mpisync, tempdir, roipac_or_gamma_conf):
params = configuration.Configuration(roipac_or_gamma_conf).__dict__
LEGACY_VCM_DIR = os.path.join(SML_TEST_DIR, 'vcm')
legacy_vcm = np.genfromtxt(os.path.join(LEGACY_VCM_DIR, 'vcmt.csv'),
delimiter=',')
tmpdir = Path(mpiops.run_once(tempdir))
params[C.OUT_DIR] = tmpdir.joinpath('out')
params[C.PARALLEL] = 0
output_conf = Path(tmpdir).joinpath('conf.cfg')
pyrate.configuration.write_config_file(params=params,
output_conf_file=output_conf)
params = configuration.Configuration(output_conf).__dict__
# dest_paths = [p.sampled_path for p in params[cf.INTERFEROGRAM_FILES]]
# run conv2tif and prepifg, create the dest_paths files
conv2tif.main(params)
params = configuration.Configuration(output_conf).__dict__
prepifg.main(params)
params = configuration.Configuration(output_conf).__dict__
params[C.ORBFIT_OFFSET] = True
correct._copy_mlooked(params=params)
correct._update_params_with_tiles(params)
correct._create_ifg_dict(params=params)
pyrate.core.refpixel.ref_pixel_calc_wrapper(params)
pyrate.core.orbital.orb_fit_calc_wrapper(params)
pyrate.core.ref_phs_est.ref_phase_est_wrapper(params)
maxvar, vcmt = pyrate.core.covariance.maxvar_vcm_calc_wrapper(params)
# phase data after ref pixel has changed due to commit bf2f7ebd
# Legacy tests won't match anymore
np.testing.assert_array_almost_equal(maxvar, legacy_maxvar, decimal=4)
np.testing.assert_array_almost_equal(legacy_vcm, vcmt, decimal=3)
mpiops.run_once(shutil.rmtree, tmpdir)
def test_dem_error_used_from_disc_on_rerun(self):
correct._copy_mlooked(self.params)
correct._update_params_with_tiles(self.params)
times_written = self.__run_once()
assert len(times_written) == len(self.ifg_paths)
times_written_1 = self.__run_once()
np.testing.assert_array_equal(times_written_1, times_written)
def test_plot_closure(mexico_cropa_params):
config = Configuration(MEXICO_CROPA_CONF)
params = config.__dict__
check_call(f"mpirun -n 3 pyrate prepifg -f {MEXICO_CROPA_CONF}",
shell=True)
correct._copy_mlooked(params)
correct.__validate_correct_steps(params)
# house keeping
correct._update_params_with_tiles(params)
correct._create_ifg_dict(params)
params[C.REFX_FOUND], params[
C.REFY_FOUND] = correct.ref_pixel_calc_wrapper(params)
# run through the correct steps in user specified sequence
for step in steps:
if step == 'phase_closure':
correct.correct_steps[step](params, config)
else:
correct.correct_steps[step](params)
closure_plot_file = Path(config.phase_closure_dir).joinpath(
f'closure_loops_iteration_1_fig_0.png')
assert closure_plot_file.exists()
shutil.rmtree(params[C.OUT_DIR], ignore_errors=True)
def setup_class(cls):
params = Configuration(common.TEST_CONF_ROIPAC).__dict__
params[cf.TEMP_MLOOKED_DIR] = os.path.join(params[cf.OUT_DIR], cf.TEMP_MLOOKED_DIR)
conv2tif.main(params)
prepifg.main(params)
params[cf.REF_EST_METHOD] = 2
xlks, _, crop = cf.transform_params(params)
dest_paths, headers = common.repair_params_for_correct_tests(params[cf.OUT_DIR], params)
correct._copy_mlooked(params)
copied_dest_paths = [os.path.join(params[cf.TEMP_MLOOKED_DIR], os.path.basename(d)) for d in dest_paths]
del dest_paths
# start run_pyrate copy
ifgs = pre_prepare_ifgs(copied_dest_paths, params)
mst_grid = tests.common.mst_calculation(copied_dest_paths, params)
refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(params)
params[cf.REFX] = refx
params[cf.REFY] = refy
params[cf.ORBFIT_OFFSET] = True
# Estimate and remove orbit errors
pyrate.core.orbital.remove_orbital_error(ifgs, params)
ifgs = prepare_ifgs_without_phase(copied_dest_paths, params)
for ifg in ifgs:
ifg.close()
correct._update_params_with_tiles(params)
_, ifgs = pyrate.core.ref_phs_est.ref_phase_est_wrapper(params)
ifgs[0].open()
r_dist = vcm_module.RDist(ifgs[0])()
ifgs[0].close()
maxvar = [vcm_module.cvd(i, params, r_dist)[0] for i in copied_dest_paths]
for ifg in ifgs:
ifg.open()
vcmt = vcm_module.get_vcmt(ifgs, maxvar)
for ifg in ifgs:
ifg.close()
ifg.open()
# Calculate stacked rate map
params[cf.PARALLEL] = 1
cls.rate, cls.error, cls.samples = tests.common.calculate_stack_rate(ifgs, params, vcmt, mst_mat=mst_grid)
# Calculate stacked rate map
params[cf.PARALLEL] = 0
cls.rate_s, cls.error_s, cls.samples_s = tests.common.calculate_stack_rate(ifgs, params, vcmt, mst_mat=mst_grid)
stackrate_dir = os.path.join(SML_TEST_DIR, 'stackrate')
cls.rate_container = np.genfromtxt(os.path.join(stackrate_dir, 'stackmap.csv'), delimiter=',')
cls.error_container = np.genfromtxt(os.path.join(stackrate_dir, 'errormap.csv'), delimiter=',')
cls.samples_container = np.genfromtxt(os.path.join(stackrate_dir, 'coh_sta.csv'), delimiter=',')
for ifg in ifgs:
ifg.close()
cls.params = params
def setup_class(cls):
cls.conf = TEST_CONF_GAMMA
params = Configuration(cls.conf).__dict__
conv2tif.main(params)
params = Configuration(cls.conf).__dict__
prepifg.main(params)
cls.params = Configuration(cls.conf).__dict__
correct._copy_mlooked(cls.params)
correct._create_ifg_dict(cls.params)
def __run_once(self):
tiles = self.params[cf.TILES]
mst_files = [Configuration.mst_path(self.params, t.index) for t in tiles]
correct._copy_mlooked(self.params)
correct._create_ifg_dict(self.params)
save_numpy_phase(self.ifg_paths, self.params)
mst.mst_calc_wrapper(self.params)
assert all(m.exists() for m in mst_files)
return [os.stat(o).st_mtime for o in mst_files]
def setup_method(cls):
cls.conf = TEST_CONF_GAMMA
params = Configuration(cls.conf).__dict__
conv2tif.main(params)
params = Configuration(cls.conf).__dict__
prepifg.main(params)
params = Configuration(cls.conf).__dict__
correct._copy_mlooked(params)
cls.params = params
def setup_class(cls):
roipac_params = Configuration(TEST_CONF_ROIPAC).__dict__
from copy import deepcopy
params = deepcopy(roipac_params)
shared.mkdir_p(params[C.TMPDIR])
params[C.REF_EST_METHOD] = 2
conv2tif.main(params)
params = deepcopy(roipac_params)
prepifg.main(params)
params = deepcopy(roipac_params)
base_ifg_paths = [
c.unwrapped_path for c in params[C.INTERFEROGRAM_FILES]
]
dest_paths = [c.converted_path for c in params[C.INTERFEROGRAM_FILES]]
params[C.INTERFEROGRAM_FILES] = [
MultiplePaths(d, params) for d in dest_paths
]
for p in params[C.INTERFEROGRAM_FILES]: # hack
p.sampled_path = p.converted_path
for i in dest_paths:
Path(i).chmod(
0o664
) # assign write permission as conv2tif output is readonly
ifgs = common.pre_prepare_ifgs(dest_paths, params)
correct._copy_mlooked(params)
correct._update_params_with_tiles(params)
correct._create_ifg_dict(params)
pyrate.core.refpixel.ref_pixel_calc_wrapper(params)
params[C.ORBFIT_OFFSET] = True
pyrate.core.orbital.remove_orbital_error(ifgs, params)
ifgs = prepare_ifgs_without_phase(dest_paths, params)
for ifg in ifgs:
ifg.close()
for p in params[C.INTERFEROGRAM_FILES]: # hack
p.tmp_sampled_path = p.sampled_path
_, cls.ifgs = pyrate.core.ref_phs_est.ref_phase_est_wrapper(params)
ifgs[0].open()
r_dist = RDist(ifgs[0])()
ifgs[0].close()
# Calculate interferogram noise
cls.maxvar = [
cvd(i,
params,
r_dist,
calc_alpha=True,
save_acg=True,
write_vals=True)[0] for i in dest_paths
]
cls.vcmt = get_vcmt(ifgs, cls.maxvar)
for ifg in ifgs:
ifg.close()
cls.params = params
def setup_method(cls):
cls.conf = TEST_CONF_GAMMA
params = Configuration(cls.conf).__dict__
conv2tif.main(params)
params = Configuration(cls.conf).__dict__
prepifg.main(params)
cls.params = Configuration(cls.conf).__dict__
correct._copy_mlooked(cls.params)
correct._create_ifg_dict(cls.params)
multi_paths = cls.params[cf.INTERFEROGRAM_FILES]
cls.ifg_paths = [p.tmp_sampled_path for p in multi_paths]
def __run_once(self):
dem_files = [
MultiplePaths.dem_error_path(i, self.params)
for i in self.ifg_paths
]
correct._copy_mlooked(self.params)
correct._update_params_with_tiles(self.params)
correct._create_ifg_dict(self.params)
save_numpy_phase(self.ifg_paths, self.params)
dem_error_calc_wrapper(self.params)
assert all(m.exists() for m in dem_files)
return [os.stat(o).st_mtime for o in dem_files]
def test_calc_dem_errors(self):
# validate output of current version of the code with saved files from an independent test run
# only the reference phase and dem_error are used in this test
# saved dem_error.tif (expected)
dem_error_tif_exp = join(dem_error_path, 'dem_error.tif')
dem = DEM(dem_error_tif_exp)
dem_error_exp = dem.data
# run relevant parts of the 'correct' step
correct._copy_mlooked(self.params)
correct._update_params_with_tiles(self.params)
correct._create_ifg_dict(self.params)
save_numpy_phase(self.ifg_paths, self.params)
# subtract the reference phase to enable comparison with a 'normal' pyrate run
ref_phase_est_wrapper(self.params)
dem_error_calc_wrapper(self.params)
# dem_error.tif from this run (result)
dem_error_tif_res = join(self.params[C.DEM_ERROR_DIR], 'dem_error.tif')
dem = DEM(dem_error_tif_res)
dem_error_res = dem.data
# check equality
np.testing.assert_allclose(dem_error_exp, dem_error_res)
# ifg correction files in subdirectory out/dem_error/
# three different ifgs:
# ifg1 -> short_baseline_ifg: 20180106-20180319 (ca. 3 m)
# ifg2 -> long_baseline_ifg: 20180130-20180412(ca. 108 m)
# ifg3 -> medium_baseline_ifg: 20180412-20180518 (ca. 48 m)
# load saved files
dem_error_ifg1_path = join(dem_error_path,
'20180106-20180319_ifg_20_dem_error.npy')
dem_error_ifg1_exp = np.load(dem_error_ifg1_path)
dem_error_ifg2_path = join(dem_error_path,
'20180130-20180412_ifg_20_dem_error.npy')
dem_error_ifg2_exp = np.load(dem_error_ifg2_path)
dem_error_ifg3_path = join(dem_error_path,
'20180412-20180518_ifg_20_dem_error.npy')
dem_error_ifg3_exp = np.load(dem_error_ifg3_path)
# load correction values saved from this run (result)
dem_error_ifg1_path = Path(self.params[C.DEM_ERROR_DIR]).joinpath(
'20180106-20180319_ifg_20_dem_error.npy')
dem_error_ifg1_res = np.load(dem_error_ifg1_path)
dem_error_ifg2_path = Path(self.params[C.DEM_ERROR_DIR]).joinpath(
'20180130-20180412_ifg_20_dem_error.npy')
dem_error_ifg2_res = np.load(dem_error_ifg2_path)
dem_error_ifg3_path = Path(self.params[C.DEM_ERROR_DIR]).joinpath(
'20180412-20180518_ifg_20_dem_error.npy')
dem_error_ifg3_res = np.load(dem_error_ifg3_path)
# check equality
np.testing.assert_allclose(dem_error_ifg1_exp, dem_error_ifg1_res)
np.testing.assert_allclose(dem_error_ifg2_exp, dem_error_ifg2_res)
np.testing.assert_allclose(dem_error_ifg3_exp, dem_error_ifg3_res)
def setup_method(cls):
cls.conf = common.TEST_CONF_GAMMA
params = Configuration(cls.conf).__dict__
conv2tif.main(params)
params = Configuration(cls.conf).__dict__
prepifg.main(params)
cls.params = Configuration(cls.conf).__dict__
correct._copy_mlooked(cls.params)
correct._update_params_with_tiles(cls.params)
correct._create_ifg_dict(cls.params)
multi_paths = cls.params[cf.INTERFEROGRAM_FILES]
cls.ifg_paths = [p.tmp_sampled_path for p in multi_paths]
cls.ifgs = [shared.Ifg(i) for i in cls.ifg_paths]
for i in cls.ifgs:
i.open()
shared.save_numpy_phase(cls.ifg_paths, cls.params)
correct.mst_calc_wrapper(cls.params)
def test_orbital_correction_legacy_equality(self):
from pyrate import correct
from pyrate.configuration import MultiplePaths
multi_paths = [MultiplePaths(p, params=self.params) for p in self.ifg_paths]
for m in multi_paths: # cheat
m.sampled_path = m.converted_path
self.params[cf.INTERFEROGRAM_FILES] = multi_paths
self.params['rows'], self.params['cols'] = 2, 3
Path(self.BASE_DIR).joinpath('tmpdir').mkdir(exist_ok=True, parents=True)
correct._copy_mlooked(self.params)
correct._update_params_with_tiles(self.params)
correct._create_ifg_dict(self.params)
correct._copy_mlooked(self.params)
pyrate.core.orbital.orb_fit_calc_wrapper(self.params)
onlyfiles = [f for f in os.listdir(SML_TEST_LEGACY_ORBITAL_DIR)
if os.path.isfile(os.path.join(SML_TEST_LEGACY_ORBITAL_DIR, f))
and f.endswith('.csv') and f.__contains__('_method1_')]
count = 0
for i, f in enumerate(onlyfiles):
ifg_data = np.genfromtxt(os.path.join(SML_TEST_LEGACY_ORBITAL_DIR, f), delimiter=',')
for k, j in enumerate([m.tmp_sampled_path for m in multi_paths]):
ifg = Ifg(j)
ifg.open()
print(f)
print(j)
if os.path.basename(j).split('_ifg.')[0] == os.path.basename(f).split(
'_orb_planar_1lks_method1_geo_')[1].split('.')[0]:
count += 1
# all numbers equal
np.testing.assert_array_almost_equal(ifg_data, ifg.phase_data, decimal=2)
# means must also be equal
assert np.nanmean(ifg_data) == pytest.approx(np.nanmean(ifg.phase_data), abs=1e-2)
# number of nans must equal
assert np.sum(np.isnan(ifg_data)) == np.sum(np.isnan(ifg.phase_data))
ifg.close()
# ensure that we have expected number of matches
assert count == len(self.ifg_paths)
def __run_once(self):
ref_phs_file = Configuration.ref_phs_file(self.params)
correct._copy_mlooked(self.params)
multi_paths = self.params[cf.INTERFEROGRAM_FILES]
ifg_paths = [p.tmp_sampled_path for p in multi_paths]
ifgs = [Ifg(i) for i in ifg_paths]
self.params[cf.REFX_FOUND], self.params[
cf.REFY_FOUND] = ref_pixel_calc_wrapper(self.params)
correct._create_ifg_dict(self.params)
ref_phase_est_wrapper(self.params)
for i in ifgs:
i.open()
phase_prev = [i.phase_data for i in ifgs]
# assert ref_ph_file present
assert ref_phs_file.exists()
time_written = os.stat(ref_phs_file).st_mtime
for i in ifgs:
i.close()
return phase_prev, time_written
def setup_class(cls):
cls.params = Configuration(common.MEXICO_CROPA_CONF).__dict__
# run prepifg
prepifg.main(cls.params)
# copy IFGs to temp folder
correct._copy_mlooked(cls.params)
# read radar azimuth, range and dem tif files
geom_files = Configuration.geometry_files(cls.params)
rdc_az_file = geom_files['rdc_azimuth']
geom_az = Geometry(rdc_az_file)
cls.az = geom_az.data
rdc_rg_file = geom_files['rdc_range']
geom_rg = Geometry(rdc_rg_file)
cls.rg = geom_rg.data
dem_file = join(cls.params[C.GEOMETRY_DIR], 'dem.tif')
dem_data = DEM(dem_file)
cls.dem = dem_data.data
# calc bperp using pyrate funcs
cls.pbperp = cls.pyrate_bperp()
def test_ref_phase_used_from_disc_on_rerun(self, ref_est_method):
self.params = Configuration(self.conf).__dict__
self.params[C.REF_EST_METHOD] = ref_est_method
correct._copy_mlooked(self.params)
correct._update_params_with_tiles(self.params)
phase_prev, time_written = self.__run_once()
# run again
phase_now, time_written_1 = self.__run_once()
# and once more
phase_again, time_written_2 = self.__run_once()
# assert no new file was written
assert time_written_1 == time_written
assert time_written_2 == time_written
# assert phase data is unchanged after applying ref_ph correction from disc
np.testing.assert_array_equal(phase_now, phase_prev)
np.testing.assert_array_equal(phase_now, phase_again)
def test_orb_error_multiple_run_does_not_change_phase_data(self, orbfit_method, orbfit_degrees):
self.params[cf.ORBITAL_FIT_METHOD] = orbfit_method
self.params[cf.ORBITAL_FIT_DEGREE] = orbfit_degrees
remove_orbital_error(self.ifg_paths, self.params)
ifgs = [Ifg(i) for i in self.ifg_paths]
for i in ifgs:
i.open()
phase_prev = [i.phase_data for i in ifgs]
# orb correct once more
correct._copy_mlooked(self.params)
remove_orbital_error(self.ifg_paths, self.params)
# and again
correct._copy_mlooked(self.params)
remove_orbital_error(self.ifg_paths, self.params)
ifgs = [Ifg(i) for i in self.ifg_paths]
for i in ifgs:
i.open()
phase_now = [i.phase_data for i in ifgs]
np.testing.assert_array_equal(phase_now, phase_prev)
def setup_class(cls):
params = Configuration(common.TEST_CONF_ROIPAC).__dict__
params[cf.TEMP_MLOOKED_DIR] = os.path.join(params[cf.OUT_DIR],
cf.TEMP_MLOOKED_DIR)
conv2tif.main(params)
prepifg.main(params)
params[cf.REF_EST_METHOD] = 2
xlks, _, crop = cf.transform_params(params)
dest_paths, headers = common.repair_params_for_correct_tests(
params[cf.OUT_DIR], params)
correct._copy_mlooked(params)
copied_dest_paths = [
os.path.join(params[cf.TEMP_MLOOKED_DIR], os.path.basename(d))
for d in dest_paths
]
del dest_paths
# start run_pyrate copy
ifgs = common.pre_prepare_ifgs(copied_dest_paths, params)
mst_grid = common.mst_calculation(copied_dest_paths, params)
refx, refy = pyrate.core.refpixel.ref_pixel_calc_wrapper(params)
params[cf.REFX] = refx
params[cf.REFY] = refy
params[cf.ORBFIT_OFFSET] = True
# Estimate and remove orbit errors
pyrate.core.orbital.remove_orbital_error(ifgs, params)
ifgs = common.prepare_ifgs_without_phase(copied_dest_paths, params)
for ifg in ifgs:
ifg.close()
correct._update_params_with_tiles(params)
_, ifgs = pyrate.core.ref_phs_est.ref_phase_est_wrapper(params)
ifgs[0].open()
r_dist = covariance.RDist(ifgs[0])()
ifgs[0].close()
# Calculate interferogram noise
maxvar = [
covariance.cvd(i, params, r_dist)[0] for i in copied_dest_paths
]
for ifg in ifgs:
ifg.open()
vcmt = covariance.get_vcmt(ifgs, maxvar)
for ifg in ifgs:
ifg.close()
ifg.open()
ifg.nodata_value = 0.0
params[cf.TIME_SERIES_METHOD] = 2
params[cf.PARALLEL] = 1
# Calculate time series
cls.tsincr, cls.tscum, _ = common.calculate_time_series(ifgs,
params,
vcmt,
mst=mst_grid)
params[cf.PARALLEL] = 0
# Calculate time series serailly by the pixel
cls.tsincr_0, cls.tscum_0, _ = common.calculate_time_series(
ifgs, params, vcmt, mst=mst_grid)
# copy legacy data
SML_TIME_SERIES_DIR = os.path.join(common.SML_TEST_DIR, 'time_series')
tsincr_path = os.path.join(SML_TIME_SERIES_DIR,
'ts_incr_interp0_method2.csv')
ts_incr = np.genfromtxt(tsincr_path)
tscum_path = os.path.join(SML_TIME_SERIES_DIR,
'ts_cum_interp0_method2.csv')
ts_cum = np.genfromtxt(tscum_path)
cls.ts_incr = np.reshape(ts_incr,
newshape=cls.tsincr_0.shape,
order='F')
cls.ts_cum = np.reshape(ts_cum, newshape=cls.tscum_0.shape, order='F')
cls.params = params
def setup_class(cls):
cls.params = Configuration(common.MEXICO_CROPA_CONF).__dict__
# run prepifg
prepifg.main(cls.params)
# copy IFGs to temp folder
correct._copy_mlooked(cls.params)
def setup_class(cls):
gamma_conf = common.TEST_CONF_GAMMA
from tests.common import manipulate_test_conf
rate_types = ['stack_rate', 'stack_error', 'stack_samples']
cls.tif_dir = Path(tempfile.mkdtemp())
params = manipulate_test_conf(gamma_conf, cls.tif_dir)
from pyrate.configuration import Configuration
# change the required params
params[C.PROCESSES] = 4
params[C.PROCESSOR] = 1 # gamma
params[C.IFG_FILE_LIST] = os.path.join(common.GAMMA_SML_TEST_DIR,
'ifms_17')
params[C.PARALLEL] = 1
params[C.APS_CORRECTION] = 0
params[C.REFX], params[C.REFY] = -1, -1
rows, cols = params["rows"], params["cols"]
output_conf_file = 'gamma.conf'
output_conf = cls.tif_dir.joinpath(output_conf_file).as_posix()
pyrate.configuration.write_config_file(params=params,
output_conf_file=output_conf)
config = Configuration(output_conf)
params = config.__dict__
common.sub_process_run(f"pyrate conv2tif -f {output_conf}")
common.sub_process_run(f"pyrate prepifg -f {output_conf}")
cls.sampled_paths = [
p.tmp_sampled_path for p in params[C.INTERFEROGRAM_FILES]
]
ifgs = common.small_data_setup()
correct._copy_mlooked(params)
tiles = pyrate.core.shared.get_tiles(cls.sampled_paths[0], rows, cols)
correct.correct_ifgs(config)
pyrate.main.timeseries(config)
pyrate.main.stack(config)
cls.refpixel_p, cls.maxvar_p, cls.vcmt_p = \
(params[C.REFX], params[C.REFY]), params[C.MAXVAR], params[
C.VCMT]
cls.mst_p = common.reconstruct_mst(ifgs[0].shape, tiles,
params[C.OUT_DIR])
cls.rate_p, cls.error_p, cls.samples_p = \
[common.reconstruct_stack_rate(ifgs[0].shape, tiles, params[C.TMPDIR], t) for t in rate_types]
common.remove_tifs(params[C.OUT_DIR])
# now create the non parallel version
cls.tif_dir_s = Path(tempfile.mkdtemp())
params = manipulate_test_conf(gamma_conf, cls.tif_dir_s)
params[C.PROCESSES] = 4
params[C.PROCESSOR] = 1 # gamma
params[C.IFG_FILE_LIST] = os.path.join(common.GAMMA_SML_TEST_DIR,
'ifms_17')
params[C.PARALLEL] = 0
params[C.APS_CORRECTION] = 0
params[C.REFX], params[C.REFY] = -1, -1
output_conf_file = 'gamma.conf'
output_conf = cls.tif_dir_s.joinpath(output_conf_file).as_posix()
pyrate.configuration.write_config_file(params=params,
output_conf_file=output_conf)
config = Configuration(output_conf)
params = config.__dict__
common.sub_process_run(f"pyrate conv2tif -f {output_conf}")
common.sub_process_run(f"pyrate prepifg -f {output_conf}")
correct._copy_mlooked(params)
correct.correct_ifgs(config)
pyrate.main.timeseries(config)
pyrate.main.stack(config)
cls.refpixel, cls.maxvar, cls.vcmt = \
(params[C.REFX], params[C.REFY]), params[C.MAXVAR], params[
C.VCMT]
cls.mst = common.reconstruct_mst(ifgs[0].shape, tiles,
params[C.OUT_DIR])
cls.rate, cls.error, cls.samples = \
[common.reconstruct_stack_rate(ifgs[0].shape, tiles, params[C.TMPDIR], t) for t in rate_types]
cls.params = params
