def test_bandpass_run(): ''' Check if bandpass_insar runs without crashing. ''' # load yaml file test_yaml = os.path.join(iscetest.data, 'bandpass_test.yaml') with open(test_yaml) as fh_test_yaml: test_yaml = fh_test_yaml.read().replace('@ISCETEST@', iscetest.data).\ replace('@TEST_OUTPUT@', 'rifg_bandpass.h5').\ replace('@TEST_PRODUCT_TYPES@', 'RIFG') # Create CLI input namespace with yaml text instead of filepath args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # Initialize runconfig object runconfig = InsarRunConfig(args) runconfig.geocode_common_arg_load() h5_prep.run(runconfig.cfg) # insar.run(runconfig.cfg) out_paths = h5_prep.run(runconfig.cfg) persist = Persistence(restart=True) persist.run_steps['dense_offsets'] = False insar.run(runconfig.cfg, out_paths, persist.run_steps)
def test_run(): ''' run gcov with same rasters and DEM as geocodeSlc test ''' test_yaml = os.path.join(iscetest.data, 'geocode/test_gcov.yaml') # load text then substitude test directory paths since data dir is read only with open(test_yaml) as fh_test_yaml: test_yaml = ''.join([ line.replace('@ISCETEST@', iscetest.data) for line in fh_test_yaml ]) # create CLI input namespace with yaml text instead of file path args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # init runconfig object runconfig = GCOVRunConfig(args) runconfig.geocode_common_arg_load() # geocode same rasters as C++/pybind geocodeCov for axis in input_axis: # iterate thru geocode modes for key, value in geocode_modes.items(): runconfig.cfg['product_path_group'][ 'sas_output_file'] = f'{axis}_{key}.h5' # prepare output hdf5 h5_prep.run(runconfig.cfg) # geocode test raster gcov.run(runconfig.cfg)
def test_run(): ''' run gslc with same rasters and DEM as geocodeSlc test ''' test_yaml = os.path.join(iscetest.data, 'geocodeslc/test_gslc.yaml') # load text then substitude test directory paths since data dir is read only with open(test_yaml) as fh_test_yaml: test_yaml = ''.join([ line.replace('@ISCETEST@', iscetest.data) for line in fh_test_yaml ]) # create CLI input namespace with yaml text instead of file path args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # init runconfig object runconfig = GSLCRunConfig(args) runconfig.geocode_common_arg_load() # geocode same 2 rasters as C++/pybind geocodeSlc for xy in ['x', 'y']: # adjust runconfig to match just created raster runconfig.cfg['product_path_group']['sas_output_file'] = f'{xy}_out.h5' # prepare output hdf5 h5_prep.run(runconfig.cfg) # geocode test raster gslc.run(runconfig.cfg)
def run(cfg: dict, out_paths: dict, run_steps: dict): ''' Run INSAR workflow with parameters in cfg dictionary ''' info_channel = journal.info("insar.run") info_channel.log("starting INSAR") t_all = time.time() if run_steps['bandpass_insar']: bandpass_insar.run(cfg) if run_steps['h5_prep']: h5_prep.run(cfg) if run_steps['rdr2geo']: rdr2geo.run(cfg) if run_steps['geo2rdr']: geo2rdr.run(cfg) if run_steps['coarse_resample']: resample_slc.run(cfg, 'coarse') if (run_steps['dense_offsets']) and \ (cfg['processing']['dense_offsets']['enabled']): dense_offsets.run(cfg) if run_steps['rubbersheet'] and \ cfg['processing']['rubbersheet']['enabled']: rubbersheet.run(cfg, out_paths['RIFG']) # If enabled, run fine_resampling if run_steps['fine_resample'] and \ cfg['processing']['fine_resample']['enabled']: resample_slc.run(cfg, 'fine') # If fine_resampling is enabled, use fine-coregistered SLC # to run crossmul if run_steps['crossmul']: if cfg['processing']['fine_resample']['enabled']: crossmul.run(cfg, out_paths['RIFG'], 'fine') else: crossmul.run(cfg, out_paths['RIFG'], 'coarse') # Run insar_filter only if run_steps['filter_interferogram'] and \ cfg['processing']['filter_interferogram']['filter_type'] != 'no_filter': filter_interferogram.run(cfg, out_paths['RIFG']) if run_steps['unwrap'] and 'RUNW' in out_paths: unwrap.run(cfg, out_paths['RIFG'], out_paths['RUNW']) if run_steps['geocode'] and 'GUNW' in out_paths: geocode_insar.run(cfg, out_paths['RUNW'], out_paths['GUNW']) t_all_elapsed = time.time() - t_all info_channel.log(f"successfully ran INSAR in {t_all_elapsed:.3f} seconds")
def test_crossmul_run(): ''' Check if crossmul runs without crashing. ''' # load yaml file test_yaml = os.path.join(iscetest.data, 'insar_test.yaml') with open(test_yaml) as fh_test_yaml: test_yaml = fh_test_yaml.read().replace('@ISCETEST@', iscetest.data).\ replace('@TEST_OUTPUT@', 'rifg.h5').\ replace('@TEST_PRODUCT_TYPES@', 'RIFG').\ replace('@TEST_RDR2GEO_FLAGS@', 'True') # Create CLI input namespace with yaml text instead of filepath args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # Initialize runconfig object runconfig = CrossmulRunConfig(args) runconfig.geocode_common_arg_load() h5_prep.run(runconfig.cfg) crossmul.run(runconfig.cfg)
def test_unwrap_run(): ''' Test if phase unwrapping runs smoothly ''' test_yaml = os.path.join(iscetest.data, 'insar_test.yaml') with open(test_yaml) as fh_test_yaml: test_yaml = fh_test_yaml.read().replace('@ISCETEST@', iscetest.data). \ replace('@TEST_OUTPUT@', 'runw.h5'). \ replace('@TEST_PRODUCT_TYPES@', 'RUNW').\ replace('@TEST_RDR2GEO_FLAGS@', 'True') # Create CLI input name space with yaml instead of filepath args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # Initialize runconfig object runconfig = UnwrapRunConfig(args) runconfig.geocode_common_arg_load() out_paths = h5_prep.run(runconfig.cfg) product_path = 'science/LSAR/RIFG/swaths/frequencyA/interferogram/HH' # Modify interferogram and correlation with h5py.File(out_paths['RIFG'], "a", libver='latest', swmr=True) as h_rifg: ds = h_rifg[os.path.join(product_path, 'wrappedInterferogram')] nrows, ncols = ds.shape # Generate a ramp x, y = np.meshgrid(np.arange(ncols), np.arange(nrows)) ref_igram = np.exp(1j * x) # Generate all 1 coherence ref_coh = np.ones([nrows, ncols]) # Save reference datasets in RIFG h_rifg[os.path.join(product_path, 'wrappedInterferogram')][:, :] = ref_igram h_rifg[os.path.join(product_path, 'coherenceMagnitude')][:, :] = ref_coh h_rifg.close() # Run unwrapping unwrap.run(runconfig.cfg, out_paths['RIFG'], out_paths['RUNW'])
def test_insar_run(): ''' Run InSAR run ''' # load yaml file path_test_yaml = os.path.join(iscetest.data, 'insar_test.yaml') for prod_type in ['RIFG', 'RUNW', 'GUNW']: test_output = f'{prod_type}.h5' # Load text and substitute directory path with open(path_test_yaml) as fh_test_yaml: test_yaml = fh_test_yaml.read().replace('@ISCETEST@', iscetest.data). \ replace('@TEST_OUTPUT@', test_output). \ replace('@TEST_PRODUCT_TYPES@', prod_type). \ replace('@TEST_RDR2GEO_FLAGS@', 'False') # create CLI input namespace args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # Initialize runconfig object insar_runcfg = InsarRunConfig(args) insar_runcfg.geocode_common_arg_load() insar_runcfg.yaml_check() out_paths = h5_prep.run(insar_runcfg.cfg) persist = Persistence(restart=True) # No CPU dense offsets. Turn off dense_offsets, # rubbersheet, and fine_resample to avoid test failure persist.run_steps['dense_offsets'] = False persist.run_steps['rubbersheet'] = False persist.run_steps['fine_resample'] = False # run insar for prod_type insar.run(insar_runcfg.cfg, out_paths, persist.run_steps) # check if test_output exists assert os.path.isfile( test_output), f"{test_output} for {prod_type} not found."
def test_filter_interferogram_run(): ''' Check if insar_filtering runs without crashing ''' # Load yaml file test_yaml = os.path.join(iscetest.data, 'insar_test.yaml') with open(test_yaml) as fh_test_yaml: test_yaml = fh_test_yaml.read().replace('@ISCETEST@', iscetest.data). \ replace('@TEST_OUTPUT@', 'RIFG.h5'). \ replace('@TEST_PRODUCT_TYPES@', 'RIFG'). \ replace('@TEST_RDR2GEO_FLAGS@', 'True'). \ replace('interferogram_path:', 'interferogram_path: RIFG.h5') # Create CLI input namespace with yaml text instead of filepath args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # Initialize runconfig object runconfig = FilterInterferogramRunConfig(args) runconfig.geocode_common_arg_load() out_paths = h5_prep.run(runconfig.cfg) # Modify the interferogram data to have something meaningful product_path = '/science/LSAR/RIFG/swaths/frequencyA/interferogram/HH' with h5py.File(out_paths['RIFG'], "a", libver='latest', swmr=True) as h_rifg: ds = h_rifg[os.path.join(product_path, 'wrappedInterferogram')] nrows, ncols = ds.shape # Generate a ramp and add some noise x, y = np.meshgrid(np.arange(ncols), np.arange(nrows)) igram = np.exp(1j * (x + y)) h_rifg[os.path.join(product_path, 'wrappedInterferogram')][:, :] = igram h_rifg.close() # Set interferogram_path for stand-alone usage of insar_filtering filter_interferogram.run(runconfig.cfg, out_paths['RIFG'])
def test_geocode_run(): ''' Test if phase geocodeping runs smoothly ''' test_yaml_path = os.path.join(iscetest.data, 'insar_test.yaml') for pu in ['cpu', 'gpu']: # Skip GPU geocode insar if cuda not included if pu == 'gpu' and not hasattr(isce3, 'cuda'): continue with open(test_yaml_path) as fh_test_yaml: test_yaml = fh_test_yaml.read().replace('@ISCETEST@', iscetest.data). \ replace('@TEST_OUTPUT@', f'{pu}_gunw.h5'). \ replace('@TEST_PRODUCT_TYPES@', 'GUNW'). \ replace('@TEST_RDR2GEO_FLAGS@', 'True') if pu == 'gpu': test_yaml = test_yaml.replace('gpu_enabled: False', 'gpu_enabled: True') # Create CLI input name space with yaml instead of filepath args = argparse.Namespace(run_config_path=test_yaml, log_file=False) # Initialize runconfig object runconfig = GeocodeInsarRunConfig(args) runconfig.geocode_common_arg_load() # save geogrid for later validation geogrid = runconfig.cfg['processing']['geocode']['geogrids']['A'] geo_tx = np.array([ geogrid.start_x, geogrid.spacing_x, 0, geogrid.start_y, 0, geogrid.spacing_y ]) geo_tx.tofile('gunw_geogrid.txt', sep=',') # prepare HDF5 outputs out_paths = h5_prep.run(runconfig.cfg) # insert rdr2geo outputs into RUNW HDF5 rdr2geo_dict = {'x': 'unwrappedPhase', 'y': 'coherenceMagnitude'} runw_product_path = 'science/LSAR/RUNW/swaths/frequencyA/interferogram/HH' az_looks = runconfig.cfg['processing']['crossmul']['azimuth_looks'] rg_looks = runconfig.cfg['processing']['crossmul']['range_looks'] with h5py.File(out_paths['RUNW'], 'a', libver='latest', swmr=True) as h_runw: for axis, ds_name in rdr2geo_dict.items(): # extract rdr2geo raster to array f_rdr2geo = f'rdr2geo/freqA/{axis}.rdr' ds = gdal.Open(f_rdr2geo, gdal.GA_ReadOnly) arr = ds.GetRasterBand(1).ReadAsArray() ds = None # decimate array (take center pixel of mlook grid) and save to HDF5 sz_x, sz_y = arr.shape arr_mlook = arr[az_looks // 2:sz_x - az_looks // 2:az_looks, az_looks // 2:sz_y - az_looks // 2:az_looks] h_runw[f'{runw_product_path}/{ds_name}'][:, :] = arr_mlook # disable unused runw dataset runconfig.cfg['processing']['geocode']['datasets'][ 'connected_components'] = False # run geocodeing of runw geocode_insar.run(runconfig.cfg, out_paths['RUNW'], out_paths['GUNW'])
spacing_x=radar_grid_cubes_geogrid.spacing_x, spacing_y=radar_grid_cubes_geogrid.spacing_y, width=int(radar_grid_cubes_geogrid.width), length=int(radar_grid_cubes_geogrid.length), epsg=radar_grid_cubes_geogrid.epsg) cube_group_name = '/science/LSAR/GSLC/metadata/radarGrid' native_doppler.bounds_error = False ''' The native-Doppler LUT bounds error is turned off to computer cubes values outside radar-grid boundaries ''' add_radar_grid_cubes_to_hdf5(dst_h5, cube_group_name, cube_geogrid, radar_grid_cubes_heights, radar_grid, orbit, native_doppler, image_grid_doppler, threshold_geo2rdr, iteration_geo2rdr) t_all_elapsed = time.time() - t_all info_channel.log( f"successfully ran geocode SLC in {t_all_elapsed:.3f} seconds") if __name__ == "__main__": yaml_parser = YamlArgparse() args = yaml_parser.parse() gslc_runcfg = GSLCRunConfig(args) h5_prep.run(gslc_runcfg.cfg) run(gslc_runcfg.cfg)
err_str = "Not a valid unwrapping algorithm" error_channel.log(err_str) raise ValueError(err_str) return unwrap if __name__ == "__main__": ''' Run phase unwrapping from command line ''' # Load command line args unwrap_parser = YamlArgparse() args = unwrap_parser.parse() # Get a runconfig dictionary from command line args unwrap_runconfig = UnwrapRunConfig(args) # Prepare RUNW HDF5 unwrap_runconfig.cfg['primary_executable'][ 'product_type'] = 'RUNW_STANDALONE' out_paths = h5_prep.run(unwrap_runconfig.cfg) # Use RIFG from crossmul_path rifg_h5 = unwrap_runconfig.cfg['processing']['phase_unwrap'][ 'crossmul_path'] # Run phase unwrapping run(unwrap_runconfig.cfg, rifg_h5, out_paths['RUNW'])
continue add_radar_grid_cube(cfg, freq, radar_grid, slc.getOrbit(), dst_h5) t_all_elapsed = time.time() - t_all info_channel.log(f"Successfully ran geocode in {t_all_elapsed:.3f} seconds") if __name__ == "__main__": """ run geocode from command line """ # load command line args geocode_insar_parser = YamlArgparse() args = geocode_insar_parser.parse() # Get a runconfig dictionary from command line args geocode_insar_runconfig = GeocodeInsarRunConfig(args) # prepare RIFG HDF5 geocode_insar_runconfig.cfg['primary_executable']['product_type'] = 'GUNW_STANDALONE' out_paths = h5_prep.run(geocode_insar_runconfig.cfg) runw_path = geocode_insar_runconfig.cfg['processing']['geocode'][ 'runw_path'] if runw_path is not None: out_paths['RUNW'] = runw_path # Run geocode run(geocode_insar_runconfig.cfg, out_paths["RUNW"], out_paths["GUNW"])
Frequency to process (A or B) pol: str Polarization to process (HH, HV, VH, VV) """ path = f'science/LSAR/RIFG/swaths/frequency{freq}/pixelOffsets/{pol}/' offset_layer = ['slantRangeOffset', 'alongTrackOffset'] for layer in offset_layer: offset_path = f'{path}/{layer}' offset_dataset = h5_ds[offset_path] offset_raster = isce3.io.Raster( f"IH5:::ID={offset_dataset.id.id}".encode("utf-8")) compute_stats_real_data(offset_raster, offset_dataset) if __name__ == "__main__": ''' run crossmul from command line ''' # load command line args crossmul_parser = YamlArgparse(resample_type=True) args = crossmul_parser.parse() # extract resample type resample_type = args.resample_type # get a runconfig dict from command line args crossmul_runconfig = CrossmulRunConfig(args, resample_type) # prepare RIFG HDF5 out_paths = h5_prep.run(crossmul_runconfig.cfg) # run crossmul run(crossmul_runconfig.cfg, out_paths['RIFG'], resample_type)
<PixelFunctionType>{function_name}</PixelFunctionType> <SimpleSource> <SourceFilename>{file1}</SourceFilename> </SimpleSource> <SimpleSource> <SourceFilename>{file2}</SourceFilename> </SimpleSource> </VRTRasterBand> </VRTDataset>''' with open(out_vrt, 'w') as fid: fid.write(vrttmpl) if __name__ == "__main__": ''' Run rubbersheet to filter out outliers in the slant range and azimuth offset fields. Fill no data values left by outliers holes and resample culled offsets to reference RSLC shape. ''' # Prepare rubbersheet parser & runconfig rubbersheet_parser = YamlArgparse() args = rubbersheet_parser.parse() rubbersheet_runconfig = RubbersheetRunConfig(args) # Prepare RIFG. Culled offsets will be # allocated in RIFG product out_paths = h5_prep.run(rubbersheet_runconfig.cfg) run(rubbersheet_runconfig.cfg, out_paths['RIFG'])
elif stats_real_imag_vector is not None: stats_obj = stats_real_imag_vector[band] dset.attrs.create('min_real_value', data=stats_obj.min_real) dset.attrs.create('mean_real_value', data=stats_obj.mean_real) dset.attrs.create('max_real_value', data=stats_obj.max_real) dset.attrs.create('sample_standard_deviation_real', data=stats_obj.sample_stddev_real) dset.attrs.create('min_imag_value', data=stats_obj.min_imag) dset.attrs.create('mean_imag_value', data=stats_obj.mean_imag) dset.attrs.create('max_imag_value', data=stats_obj.max_imag) dset.attrs.create('sample_standard_deviation_imag', data=stats_obj.sample_stddev_imag) if valid_min is not None: dset.attrs.create('valid_min', data=valid_min) if valid_max is not None: dset.attrs.create('valid_max', data=valid_max) del gdal_ds if __name__ == "__main__": yaml_parser = YamlArgparse() args = yaml_parser.parse() gcov_runcfg = GCOVRunConfig(args) h5_prep.run(gcov_runcfg.cfg) run(gcov_runcfg.cfg)