def transform(infile, outfile, posting=90): # read DEM parameter file par = ReadPar(infile + ".par") # transform corner coordinate to UTM utm = UTM(infile + ".par") if os.path.isfile(outfile + ".par"): os.remove(outfile + ".par") if os.path.isfile(outfile): os.remove(outfile) # determine false northing from parameter file coordinates falsenorthing = "10000000." if "-" in par.corner_lat else "0" # create new DEM parameter file with UTM projection details inlist = [ "UTM", "WGS84", 1, utm.zone, falsenorthing, outfile, "", "", "", "", "", "-" + str(posting) + " " + str(posting), "" ] run(["create_dem_par", outfile + ".par"], inlist=inlist) # transform dem run([ "dem_trans", infile + ".par", infile, outfile + ".par", outfile, "-", "-", "-", 1 ])
def mosaic(demlist, outname, byteorder=1, gammapar=True): nodata = str(raster.Raster(demlist[0]).nodata) run( dissolve([ "gdalwarp", "-q", "-of", "ENVI", "-srcnodata", nodata, "-dstnodata", nodata, demlist, outname ])) if byteorder == 1: swap(outname, outname + "_swap") for item in [outname, outname + ".hdr", outname + ".aux.xml"]: os.remove(item) os.rename(outname + "_swap", outname) os.rename(outname + "_swap.hdr", outname + ".hdr") if gammapar: dempar(outname)
def dempar(dem, logpath=None): rast = raster.Raster(dem) # determine data type dtypes = {"Int16": "INTEGER*2", "UInt16": "INTEGER*2", "Float32": "REAL*4"} if rast.dtype not in dtypes: raise IOError("data type not supported") else: dtype = dtypes[rast.dtype] # format pixel posting and top left coordinate posting = str(rast.geotransform["yres"]) + " " + str( rast.geotransform["xres"]) latlon = str(rast.geotransform["ymax"]) + " " + str( rast.geotransform["xmin"]) # evaluate projection projections = {"longlat": "EQA", "utm": "UTM"} if rast.proj4args["proj"] not in projections: raise IOError("projection not supported (yet)") else: projection = projections[rast.proj4args["proj"]] # get ellipsoid ellipsoid = rast.proj4args[ "ellps"] if "ellps" in rast.proj4args else rast.proj4args["datum"] if ellipsoid != "WGS84": raise IOError("ellipsoid not supported (yet)") # create list for GAMMA command input parlist = [ projection, ellipsoid, 1, os.path.basename(dem), dtype, 0, 1, rast.cols, rast.rows, posting, latlon ] # execute GAMMA command run(["create_dem_par", os.path.splitext(dem)[0] + ".par"], os.path.dirname(dem), logpath, inlist=parlist)
def fill(dem, dem_out, logpath, replace=False): width = ReadPar(dem + ".par").width path_dem = os.path.dirname(dem_out) rpl_flg = 0 dtype = 4 # replace values value = 0 new_value = 1 run([ "replace_values", dem, value, new_value, dem + "_temp", width, rpl_flg, dtype ], path_dem, logpath) value = -32768 new_value = 0 run([ "replace_values", dem + "_temp", value, new_value, dem + "_temp2", width, rpl_flg, dtype ], path_dem, logpath) # interpolate missing values r_max = 9 np_min = 40 np_max = 81 w_mode = 2 run([ "interp_ad", dem + "_temp2", dem_out, width, r_max, np_min, np_max, w_mode, dtype ], path_dem, logpath) # remove temporary files os.remove(dem + "_temp") os.remove(dem + "_temp2") # duplicate parameter file for newly created dem shutil.copy(dem + ".par", dem_out + ".par") # create ENVI header file hdr(dem_out + ".par") if replace: for item in [ dem + x for x in ["", ".par", ".hdr", ".aux.xml"] if os.path.isfile(dem + x) ]: os.remove(item)
raise IOError("no appropriate file found") for scene in scenes: print "----------" # read leader file for meta information with open(os.path.join(scene, "LEA_01.001"), "r") as infile: text = [line for line in infile] text = "".join(text) # extract frame id frame_index = re.search("FRAME=", text).end() frame = text[frame_index:frame_index+4] tempname = os.path.join(os.getcwd(), "temp") print "importing..." run(["par_ESA_ERS", "LEA_01.001", tempname+".par", "DAT_01.001", tempname], scene, path_log, [""]) par = ReadPar(tempname+".par") date = "".join([format(int(x), "02d") for x in par.date[0:3]]) timestamp = date+"T"+time.strftime("%H%M%S", time.gmtime(round(float(par.center_time[0])))) outname = par.sensor+"_"+frame+"_"+timestamp+"_VV_slc" path_out = os.path.join(os.getcwd(), outname[:-7]) if not os.path.exists(path_out): print outname os.makedirs(path_out) os.rename(tempname, os.path.join(path_out, outname)) os.rename(tempname+".par", os.path.join(path_out, outname+".par")) else: print "scene", outname, "already imported; removing temporary files" os.remove(tempname) os.remove(tempname+".par")
if len(list_int) > 0: print "#############################################" print "interferogram flattening started..." for name_int in list_int: slc_par = finder(os.getcwd(), [ re.findall("[A-Z0-9_]{10}[0-9T]{15}_[HV]{2}_slc(?:_cal)", name_int)[0] ])[0] + ".par" name_off = name_int[:-3] + "off" if not os.path.isfile(name_off): raise IOError("offset file missing") if os.path.isfile(name_int[:-3] + "base_refine"): name_base = name_int[:-3] + "base_refine" elif os.path.isfile(name_int[:-3] + "base_init"): name_base = name_int[:-3] + "base_init" else: raise IOError("baseline file missing") name_flt = name_int[:-3] + "flt" print os.path.basename(name_flt) run([ "ph_slope_base", name_int, slc_par, name_off, name_base, name_flt ], path_out, path_log) print "...done" print "#############################################" else: print "#############################################" print "no interferograms found" print "#############################################"
# create list of scene tuple objects tuples = grouping() print "#############################################" print "creating huynen decomposition..." counter = 0 for scene in tuples: if len( union(["HH_slc", "VV_slc", "HV_slc", "t11", "t12", "t13"], scene.__dict__.keys())) == 6: print scene.basename for i in range(1, 4): run([ "HUYNEN_DEC", scene.HH_slc, scene.HV_slc, scene.VV_slc, scene.t11, scene.t12, scene.t13, ReadPar(scene.HH_slc + ".par").range_samples, scene.basename, str(i) ], os.path.dirname(scene.t11), path_log) counter += 1 if counter == 0: print "no appropriate scenes with existing coherence matrix found" else: # rename files to consistent pattern for pattern in ["*.t*", "*.im", "*.re"]: for filename in finder(os.getcwd(), [pattern]): os.rename( filename, filename.replace(pattern.strip("*"), pattern.strip("*").replace(".", "_"))) print "...done"
tuples = grouping() print "#############################################" print "transforming scenes..." for scene in tuples: if len(set(["HH_slc", "VV_slc", "HV_slc"]) & set(scene.__dict__.keys())) == 3: print scene.basename path_out = os.path.join(os.path.dirname(scene.HH_slc), "POL/") if not os.path.exists(path_out): os.makedirs(path_out) run([ "lin_comb_cpx", "3", scene.HH_slc, scene.VV_slc, scene.HV_slc, par.constant_r, par.constant_i, par.factorHH_r, par.factorHH_i, par.factorVV_r, par.factorVV_i, par.factorHV_r, par.factorHV_i, scene.basename + "_rr", ReadPar(scene.HH_slc + ".par").range_samples, "", "", par.pixav_x, par.pixav_y, "1" ], path_out, path_log) run([ "lin_comb_cpx", "3", scene.VV_slc, scene.HH_slc, scene.HV_slc, par.constant_r, par.constant_i, par.factorVV_r, par.factorVV_i, par.factorHH_r, par.factorHH_i, par.factorHV_r, par.factorHV_i, scene.basename + "_ll", ReadPar(scene.HH_slc + ".par").range_samples, "", "", par.pixav_x, par.pixav_y, "1" ], path_out, path_log) run([ "lin_comb_cpx", "2", scene.HH_slc, scene.VV_slc, par.constant_r, par.constant_i, par.factorHH_r, par.factorHH_i, par.factorVV_r, par.factorVV_i, scene.basename + "_rl",
name_mli = finder(os.getcwd(), ["*" + id_pwr[0] + "_mli"])[0] # name_rmli = finder(os.getcwd(), ["*"+id_pwr[1]+"_reg_mli"])[0] name_rmli = name_flt[: -8] + "reg_mli" if differential else name_flt[: -3] + "reg_mli" except: raise IOError("multilooked images missing") # concatenate coherence image name name_cc = name_flt + "_cc_ad" if not os.path.isfile(name_cc): print os.path.basename(name_cc) # read image samples samples = str(ISPPar(name_mli + ".par").range_samples) # run gamma command run([ 'cc_ad', name_flt, name_mli, name_rmli, "-", "-", name_cc, samples, par.box_min, par.box_max, par.wgt_ad ], path_out, path_log) else: print "coherence image", name_cc, "already exists" print "...estimation finished" print "#############################################" else: print "#############################################" print "no {0} interferograms found".format( "differential" if differential else "flattened") print "#############################################"
# create list of scene tuple objects tuples = grouping() print "#############################################" print "creating krogager decomposition..." for scene in tuples: if len( set(["HH_slc", "rl", "ll", "rr", "HH_mli"]) & set(scene.__dict__.keys())) == 5: print scene.basename path_out = os.path.dirname(scene.rl) mlipar = scene.HH_mli + ".par" rlks = ReadPar(mlipar).range_looks azlks = ReadPar(mlipar).azimuth_looks run([ "multi_look", scene.rl, scene.HH_slc + ".par", scene.basename + "_sphere", mlipar, rlks, azlks ], path_out, path_log) run([ "diplane_helix", scene.ll, scene.rr, scene.HH_slc + ".par", scene.basename + "_diplane", scene.basename + "_helix", mlipar, rlks, azlks, "-", "-", "-" ], path_out, path_log) for tag in ["_sphere", "_helix", "_diplane"]: hdr(scene.HH_mli + ".par", os.path.join(path_out, scene.basename) + tag + ".hdr") print "...done" print "#############################################"
print "#############################################" print "creating cloude decomposition..." counter = 0 for scene in tuples: if len({"HH_slc", "VV_slc", "HV_slc", "t12", "t13", "HH_mli"} & set(scene.__dict__.keys())) == 6: counter += 1 print scene.basename rlks = ReadPar(scene.HH_mli + ".par").range_looks azlks = ReadPar(scene.HH_mli + ".par").azimuth_looks run([ "CLOUDE_DEC", scene.HH_slc, scene.HV_slc, scene.VV_slc, scene.t12, scene.t13, ReadPar(scene.HH_slc + ".par").range_samples, scene.basename, rlks, azlks ], os.path.dirname(scene.t12), path_log) # create envi header files (note: number of lines must be reduced by 1 on import into envi) for i in range(1, 4): hdr( scene.HH_mli + ".par", os.path.join(os.path.dirname(scene.t12), scene.basename) + "_ctd_" + str(i) + "_mag.hdr") if counter == 0: print "no scenes with required scattering and coherency matrix elements found" # rename files to consistent pattern for pattern in ["*.ctd*", "*.mag", "*.pha"]: for filename in finder(os.getcwd(), [pattern]):
print "#############################################" print "interferogram generation started..." for name_off in offsets: name_int = name_off[:-3] + "int" print os.path.basename(name_int) slc = finder(os.getcwd(), [ re.findall("[A-Z0-9_]{10}[0-9T]{15}_[HV]{2}_slc(?:_cal)?", name_int)[0] ])[0] # rslc = finder(os.getcwd(), [re.findall("[A-Z0-9_]{10}[0-9T]{15}_[HV]{2}_slc(?:_cal)", name_int)[1]+"_reg"])[0] rslc = name_off[:-3] + "reg" # read the master mli parameter file for multilooking factors try: par_mli = ReadPar(slc + "_mli.par") except IOError: print "MLI for the primary SLC missing" run([ "SLC_intf", slc, rslc, slc + ".par", rslc + ".par", name_off, name_int, par_mli.range_looks, par_mli.azimuth_looks, "0", "-", par.sps_flg, par.azf_flg, par.rp1_flg, par.rp2_flg ], path_out, path_log) print "...done" print "#############################################" else: print "#############################################" print "no coregistration offset files found" print "#############################################"
from ancillary import grouping, run, finder, ReadPar path_log = os.path.join(os.getcwd(), "LOG/LAT/") if not os.path.exists(path_log): os.makedirs(path_log) par = ReadPar(os.path.join(os.getcwd(), "PAR/mat_cov.par")) # create list of scene tuple objects tuples = grouping() print "#############################################" print "creating covariance matrices..." for scene in tuples: if len(set(["HH_slc", "VV_slc", "HV_slc", "HH_mli"]) & set(scene.__dict__.keys())) == 4: print scene.basename rlks = ReadPar(scene.HH_mli+".par").range_looks azlks = ReadPar(scene.HH_mli+".par").azimuth_looks path_out = os.path.join(os.path.dirname(scene.HH_slc), "POL/") if not os.path.exists(path_out): os.makedirs(path_out) run(["polcovar", scene.HH_slc, scene.HV_slc, scene.VV_slc, scene.HH_slc+".par", scene.HV_slc+".par", scene.VV_slc+".par", os.path.basename(scene.basename), os.path.basename(scene.basename)+"_mat_cov.par", rlks, azlks], path_out, path_log) # rename files to consistent pattern for filename in finder(os.getcwd(), ["*.c*"]): os.rename(filename, filename.replace(".c", "_c")) print "...done" print "#############################################"
name_base = os.path.basename(slc1) + "_" + os.path.basename(slc2) + "_" name_coffs = name_base + "coffs" name_coffsets = name_base + "coffsets" name_off = name_base + "off" name_offs = name_base + "offs" name_offsets = name_base + "offsets" name_snr = name_base + "snr" name_reg = name_base + "reg" print "#############################################" print os.path.basename(slc1), "->", os.path.basename(slc2) print "----------" print "coregistration started..." run([ "create_offset", slc1 + ".par", slc2 + ".par", name_off, par.algorithm, 1, 1, 0 ], path_out, path_log) print "...estimation of initial range and azimuth offsets" # first estimation using orbit data (most important in case of very large offsets) run(["init_offset_orbit", slc1 + ".par", slc2 + ".par", name_off], path_out, path_log) # repeated offset estimation using different levels of multilooking isp = ReadPar(slc1 + ".par") mlk = Spacing(isp) for factor in [4, 2, 1]: run([ "init_offset", slc1, slc2, slc1 + ".par", slc2 + ".par", name_off,
# pix = basename+"_pix" # psi = basename+"_psi" sim_map = basename+"_sim_map" sim_rdc = basename+"_sim_rdc" snr = basename+"_snr" slope = basename+"_u" aspect = basename+"_v" # define parameter file of the master masterpar = master + ".par" # perform forward geocoding if the corresponding refined lookup table does not yet exist if not os.path.isfile(lut_fine): print"creating initial lookup table" run(["gc_map", masterpar, "-", dem + ".par", dem, dem_sub + ".par", dem_sub, lut_rough, "-", "-", sim_map, slope, aspect, inc, "-", "-", ls_map, par.frame, 2], path_out, path_log) hdr(dem_sub+".par", inc+".hdr") hdr(dem_sub+".par", ls_map+".hdr") hdr(dem_sub+".par", slope+".hdr") hdr(dem_sub+".par", aspect+".hdr") if tnorm: print "initial pixel area estimation" topo_base = os.path.join(path_out, os.path.basename(master)) pix_gamma = topo_base+"_pix_gamma" parfile = master+".par" run(["pixel_area", parfile, dem_sub+".par", dem_sub, lut_rough, ls_map, inc, "-", pix_gamma], path_out, path_log) # read additional parameters samples_dem = ReadPar(dem_sub + ".par").width
os.makedirs(path_log) par = ReadPar(os.path.join(os.getcwd(), "PAR/mat_coh.par")) tuples = grouping() print "#############################################" print "creating coherence matrices..." for scene in tuples: if len( set([ "pauli_alpha_slc", "pauli_beta_slc", "pauli_gamma_slc", "HH_mli" ]) & set(scene.__dict__.keys())) == 4: print scene.basename rlks = ReadPar(scene.HH_mli + ".par").range_looks azlks = ReadPar(scene.HH_mli + ".par").azimuth_looks run([ "polcoh", scene.pauli_alpha_slc, scene.pauli_beta_slc, scene.pauli_gamma_slc, scene.pauli_alpha_slc + ".par", scene.pauli_beta_slc + ".par", scene.pauli_gamma_slc + ".par", scene.basename, scene.basename + "_mat_coh.par", rlks, azlks ], os.path.dirname(scene.pauli_alpha_slc), path_log) # rename files to consistent pattern for filename in finder(os.getcwd(), ["*.t*"]): os.rename(filename, filename.replace(".t", "_t")) print "...done" print "#############################################"
name_off = name_int[:-3] + "off" name_base_init = name_int[:-3] + "base_init" name_base_refine = name_int[:-3] + "base_refine" name_base_res = name_int[:-3] + "base_res" par_dem = ReadPar(dem_map + ".par") par_mli = ReadPar(primary + "_mli.par") ph_sim = name_int[:-3] + "ph_sim" if not os.path.isfile(dem_map): print "DEM", dem_map, "missing" continue if not os.path.isfile(dem_rdc): print "...transforming DEM to range-doppler coordinates" run([ "geocode", lut_fine, dem_map, par_dem.width, dem_rdc, par_mli.range_samples, par_mli.azimuth_lines, "2" ], os.path.dirname(dem_map), path_log) else: print "...found DEM in range-doppler coordinates" print "...initial DEM interferogram simulation" run([ "phase_sim", primary + ".par", name_off, name_base_init, dem_rdc, ph_sim ], os.path.dirname(name_int), path_log) print "...initial differential interferogram generation" run([ "SLC_diff_intf", primary, secondary, primary + ".par", secondary + ".par", name_off, ph_sim, diff_int, par_mli.range_looks, par_mli.azimuth_looks
def main(zipfile, tempdir, outdir, srtmdir, transform, logfiles, intermediates): # Definition geocode_back interpolation function # method 1: negative values possible (e.g. in urban areas) - use method 2 to avoid this # 0 - Nearest Neighbor # 1 - Bicubic Spline # 2 - Bicubic Spline-Log func_geoback = 2 # function for interpolation of layover/shadow/foreshortening/DEM gaps # 0: set to 0; 1: linear interpolation; 2: actual value; 3: nn-thinned func_interp = 0 # define target resolution; multilooking factors will be computed automatically res_target = 20 # set DEM resolution and compute oversampling factor res_dem = 100 dem_ovs = res_dem // res_target print "##########################################\n%s\n-------------\nprocessing started: %s\n" % ( zipfile[:-4], asctime()) ###################################################################### pattern = r"^(?P<sat>S1[AB])_(?P<beam>S1|S2|S3|S4|S5|S6|IW|EW|WV|EN|N1|N2|N3|N4|N5|N6|IM)_(?P<prod>SLC|GRD|OCN)(?:F|H|M|_)_(?:1|2)(?P<class>S|A)(?P<pols>SH|SV|DH|DV|HH|HV|VV|VH)_(?P<start>[0-9]{8}T[0-9]{6})_(?P<stop>[0-9]{8}T[0-9]{6})_(?:[0-9]{6})_(?:[0-9A-F]{6})_(?:[0-9A-F]{4})\.SAFE$" # unzip the dataset try: with zf.ZipFile(zipfile, "r") as z: scene = sorted(z.namelist())[0].strip("/") match = re.match(pattern, scene) orbit = "D" if float( re.findall("[0-9]{6}", match.group("start"))[1]) < 120000 else "A" outname_base = "_".join([ os.path.join(outdir, match.group("sat")), match.group("beam"), match.group("start").replace("T", "_"), orbit ]) if not os.path.exists(os.path.join(tempdir, scene)) and len( finder(outdir, [os.path.basename(outname_base)], regex=True)) == 0: if not z.testzip(): print "unzipping data..." # print z.testzip() z.extractall(tempdir) else: print "corrupt zip" return else: print "file already imported/processed" return tempdir = os.path.join(tempdir, scene) except ImportError: print "...skipped" return # create logfile folder if this option was selected if logfiles: path_log = outname_base + "_log" if os.path.exists(path_log): shutil.rmtree(path_log) os.makedirs(path_log) else: path_log = None ###################################################################### print "converting to GAMMA format..." try: run([sys.executable, os.path.join(os.getcwd(), "reader.py"), tempdir], outdir=tempdir, logpath=path_log) except ImportError: print "...failed" return # gather all imported files files_mli = finder(tempdir, ["*_mli"]) # compute multilooking factors par = ReadPar(files_mli[0] + ".par") rlks = int(round(res_target / float(par.range_pixel_spacing))) azlks = int(round(res_target / float(par.azimuth_pixel_spacing))) # perform multilooking for item in files_mli: run([ "multi_look_MLI", item, item + ".par", item[:-3] + "mli2", item[:-3] + "mli2.par", rlks, azlks ], logpath=path_log) # gather all newly created MLIs files_mli = finder(tempdir, ["*_mli2"]) # select master image master = files_mli[0] base = "_".join(master.split("_")[:-1]) + "_" dem_seg = base + "dem" lut = base + "lut" lut_fine = base + "lut_fine" sim_sar = base + "sim_sar" u = base + "u" v = base + "v" inc = base + "inc" psi = base + "psi" pix = base + "pix" ls_map = base + "ls_map" pixel_area = base + "pixel_area" pixel_area2 = base + "pixel_area2" offs = base + "offs" coffs = base + "coffs" coffsets = base + "coffsets" snr = base + "snr" ellipse_pixel_area = base + "ellipse_pixel_area" ratio_sigma0 = base + "ratio_sigma0" # read image parameter file for meta information par = ReadPar(master + ".par") incidence = str(int(float(par.incidence_angle))) outname_base = outname_base + "_" + incidence ###################################################################### # colelct srtm file sand mosaic them # define a name for the output mosaic name_srtm = os.path.join(tempdir, "srtm") # collect srtm tiles (if tiles are not found in the defined srtm directory, they are automatically downloaded to the temporary directory) targets = srtm.hgt_collect([x + ".par" for x in files_mli], tempdir, demdir=srtmdir) print "preparing SRTM data..." srtm.mosaic(targets, name_srtm) # interpolate data gaps srtm.fill(name_srtm, name_srtm + "_fill", path_log, replace=True) name_srtm += "_fill" # project DEM to UTM if transform: srtm.transform(name_srtm, name_srtm + "_utm") name_srtm += "_utm" ###################################################################### # create DEM products print "sar image simulation..." try: run([ "gc_map", master + ".par", "-", name_srtm + ".par", name_srtm, dem_seg + ".par", dem_seg, lut, dem_ovs, dem_ovs, sim_sar, u, v, inc, psi, pix, ls_map, 8, func_interp ], logpath=path_log) except IOError: print "...failed" return ###################################################################### print "initial pixel area estimation..." run([ "pixel_area", master + ".par", dem_seg + ".par", dem_seg, lut, ls_map, inc, pixel_area ], logpath=path_log) ###################################################################### print "exact offset estimation..." try: inlist = ["", "0 0", "100 100", "128 128", 7.0] run(["create_diff_par", master + ".par", "-", master + "_diff.par", 1], inlist=inlist, logpath=path_log) run([ "offset_pwrm", master, pixel_area, master + "_diff.par", offs, snr, 128, 128, offs + ".txt", "-", 200, 200, 7.0 ], logpath=path_log) except: print "...failed" return ###################################################################### print "computation of offset polynomials..." try: run([ "offset_fitm", offs, snr, master + "_diff.par", coffs, coffsets, "-", 4, 0 ], logpath=path_log) except: print "...failed" return ###################################################################### print "supplementing lookuptable with offset polynomials..." try: sim_width = ReadPar(dem_seg + ".par").width run(["gc_map_fine", lut, sim_width, master + "_diff.par", lut_fine, 0], logpath=path_log) except: print "...failed" return ###################################################################### print "refined pixel area estimation..." try: run([ "pixel_area", master + ".par", dem_seg + ".par", dem_seg, lut_fine, ls_map, inc, pixel_area2 ], logpath=path_log) except: print "...failed" return ###################################################################### print "radiometric calibration and normalization..." try: slc_width = ReadPar(master + ".par").range_samples run([ "radcal_MLI", master, master + ".par", "-", master + "_cal", "-", 0, 0, 1, 0.0, "-", ellipse_pixel_area ], logpath=path_log) run([ "ratio", ellipse_pixel_area, pixel_area2, ratio_sigma0, slc_width, 1, 1 ], logpath=path_log) for item in files_mli: run([ "product", item, ratio_sigma0, item + "_pixcal", slc_width, 1, 1 ], logpath=path_log) except: print "...failed" return ###################################################################### print "backward geocoding, normalization and conversion to dB..." for item in files_mli: run([ "geocode_back", item + "_pixcal", slc_width, lut_fine, item + "_geo", sim_width, 0, func_geoback ], logpath=path_log) run([ "lin_comb", "1", item + "_geo", 0, math.cos(math.radians(float(par.incidence_angle))), item + "_geo_flat", sim_width ], logpath=path_log) run([ "sigma2gamma", item + "_geo_flat", inc, item + "_geo_norm", sim_width ], logpath=path_log) ###################################################################### print "creating final tiff files..." for item in finder(tempdir, ["*_geo_norm"]): polarization = re.findall("[HV]{2}", os.path.basename(item))[0].lower() outname = outname_base + "_" + polarization run([ "data2geotiff", dem_seg + ".par", item, 2, outname + "_geocoded_norm.tif" ], logpath=path_log) annotation_dir = os.path.join(tempdir, "annotation") annotation = os.path.join(annotation_dir, [ x for x in os.listdir(annotation_dir) if polarization in os.path.basename(x) ][0]) os.rename(annotation, outname + "_annotation.xml") ###################################################################### print "cleaning up..." # copy, rename and edit quicklook kml and png shutil.copyfile(os.path.join(tempdir, "preview", "map-overlay.kml"), outname_base + "_quicklook.kml") shutil.copyfile(os.path.join(tempdir, "preview", "quick-look.png"), outname_base + "_quicklook.png") with open(outname_base + "_quicklook.kml", "r") as infile: kml = infile.read().replace( "quick-look.png", os.path.basename(outname_base + "_quicklook.png")) with open(outname_base + "_quicklook.kml", "w") as outfile: outfile.write(kml) if not intermediates: shutil.rmtree(tempdir) if logfiles: os.rename(path_log, outname_base + "_log") print "...done:", asctime() print "##########################################"
def main(zipfile, tempdir, outdir, srtmdir, transform, logfiles, intermediates, verbose): with tempfile.NamedTemporaryFile(delete=False, dir=outdir) as mainlog: # Definition geocode_back interpolation function # method 1: negative values possible (e.g. in urban areas) - use method 2 to avoid this # 0 - Nearest Neighbor # 1 - Bicubic Spline # 2 - Bicubic Spline-Log func_geoback = 2 # function for interpolation of layover/shadow/foreshortening/DEM gaps # 0: set to 0; 1: linear interpolation; 2: actual value; 3: nn-thinned func_interp = 0 # Definition of the multi-look factor # Enter the number of looks you want to use in range and azimuth" # Try to achieve Level 1.5 azimuth pixel dimension and squarish pixels in GR image" # number of looks in range ml_rg = 4 # number of looks in azimuth ml_az = 2 # DEM oversampling factor" # for S1 GRDH: final resolution: 20m # 30m SRTM: # dem_ovs = 1.5 # 90m SRTM: dem_ovs = 5 message = "##########################################\n%s\n-------------\nprocessing started: %s\n" % ( zipfile[:-4], asctime()) print message if verbose else mainlog.writelines(message) if not verbose: os.rename(mainlog.name, os.path.join(outdir, "main.log")) ###################################################################### pattern = r"^(?P<sat>S1[AB])_(?P<beam>S1|S2|S3|S4|S5|S6|IW|EW|WV|EN|N1|N2|N3|N4|N5|N6|IM)_(?P<prod>SLC|GRD|OCN)(?:F|H|M|_)_(?:1|2)(?P<class>S|A)(?P<pols>SH|SV|DH|DV|HH|HV|VV|VH)_(?P<start>[0-9]{8}T[0-9]{6})_(?P<stop>[0-9]{8}T[0-9]{6})_(?:[0-9]{6})_(?:[0-9A-F]{6})_(?:[0-9A-F]{4})\.SAFE$" # unzip the dataset try: with zf.ZipFile(zipfile, "r") as z: scene = sorted(z.namelist())[0].strip("/") match = re.match(pattern, scene) orbit = "D" if float( re.findall("[0-9]{6}", match.group("start"))[1]) < 120000 else "A" outname_base = "_".join([ os.path.join(outdir, match.group("sat")), match.group("beam"), match.group("start").replace("T", "_"), orbit ]) if not os.path.exists(os.path.join(tempdir, scene)) and len( finder(outdir, [os.path.basename(outname_base)], regex=True)) == 0: if not z.testzip(): if verbose: print "unzipping data..." # print z.testzip() z.extractall(tempdir) tempdir = os.path.join(tempdir, scene) else: print "Corrupt zip" return else: print "file already imported/processed" return except ImportError: print "...skipped" return # create logfile folder if this option was selected if logfiles: path_log = outname_base + "_log" if os.path.exists(path_log): shutil.rmtree(path_log) os.makedirs(path_log) else: path_log = None ###################################################################### print "converting to GAMMA format..." try: run([ "/usr/local/bin/python2.7", os.path.join(os.getcwd(), "reader.py"), tempdir ], outdir=tempdir, logpath=path_log) except ImportError: print "...failed" return files_slc = finder(tempdir, ["*_slc"]) if len(files_slc) > 0: if verbose: print "multilooking..." for item in files_slc: run([ "multi_look", item, item + ".par", item[:-3] + "mli", item[:-3] + "mli.par", ml_rg, ml_az ], logpath=path_log) files_mli = finder(tempdir, ["*_mli"]) master = files_mli[0] base = master[:-3] dem_seg = base + "dem" lut = base + "lut" lut_fine = base + "lut_fine" sim_sar = base + "sim_sar" u = base + "u" v = base + "v" inc = base + "inc" psi = base + "psi" pix = base + "pix" ls_map = base + "ls_map" pixel_area = base + "pixel_area" pixel_area2 = base + "pixel_area2" offs = base + "offs" coffs = base + "coffs" coffsets = base + "coffsets" snr = base + "snr" ellipse_pixel_area = base + "ellipse_pixel_area" ratio_sigma0 = base + "ratio_sigma0" # read image parameter file for meta information par = ReadPar(master + ".par") incidence = str(int(float(par.incidence_angle))) outname_base = outname_base + "_" + incidence ###################################################################### if verbose: print "mosaicing SRTM data..." name_srtm = os.path.join(tempdir, "srtm") # extract corner coordinates from gamma parameter files and concatenate names of required hgt files lat, lon = srtm.latlon([x + ".par" for x in files_mli]) target_ids = srtm.hgt(lat, lon) # search for required tiles in the defined srtm directory targets = finder(srtmdir, target_ids) # copy hgt files to temporary directory if len(targets) > 0: for item in targets: shutil.copy(item, tempdir) targets = finder(tempdir, target_ids) else: print "...failed" return # create gamma parameter files for all DEMs srtm.dempar(targets) # mosaic hgt files srtm.mosaic(targets, name_srtm) # interpolate data gaps srtm.replace(name_srtm, name_srtm + "_fill", path_log) os.remove(name_srtm) os.remove(name_srtm + ".par") name_srtm += "_fill" # project DEM to UTM if transform: if verbose: print "reprojecting DEM..." srtm.transform(name_srtm, name_srtm + "_utm") name_srtm += "_utm" # remove hgt files from temporary directory for item in targets: os.remove(item) os.remove(item + ".par") ###################################################################### # create DEM products; command is automatically chosen based on SAR imagery parameter file entries (flawless functioning yet to be tested) if verbose: print "sar image simulation..." try: if ReadPar(master + ".par").image_geometry == "GROUND_RANGE": run([ "gc_map_grd", master + ".par", name_srtm + ".par", name_srtm, dem_seg + ".par", dem_seg, lut, dem_ovs, dem_ovs, sim_sar, u, v, inc, psi, pix, ls_map, 8, func_interp ], logpath=path_log) else: run([ "gc_map", master + ".par", "-", name_srtm + ".par", name_srtm, dem_seg + ".par", dem_seg, lut, dem_ovs, dem_ovs, sim_sar, u, v, inc, psi, pix, ls_map, 8, func_interp ], logpath=path_log) except IOError: print "...failed" return ###################################################################### if verbose: print "initial pixel area estimation..." run([ "pixel_area", master + ".par", dem_seg + ".par", dem_seg, lut, ls_map, inc, pixel_area ], logpath=path_log) ###################################################################### if verbose: print "exact offset estimation..." try: inlist = ["", "0 0", "100 100", "128 128", "7.0"] run([ "create_diff_par", master + ".par", "-", master + "_diff.par", 1 ], inlist=inlist, logpath=path_log) run([ "offset_pwrm", master, pixel_area, master + "_diff.par", offs, snr, 128, 128, offs + ".txt", "-", 200, 200, 7.0 ], logpath=path_log) except: print "...failed" return ###################################################################### if verbose: print "computation of offset polynomials..." try: run([ "offset_fitm", offs, snr, master + "_diff.par", coffs, coffsets, "-", 4, 0 ], logpath=path_log) except: print "...failed" return ###################################################################### if verbose: print "supplementing lookuptable with offset polynomials..." try: sim_width = ReadPar(dem_seg + ".par").width run([ "gc_map_fine", lut, sim_width, master + "_diff.par", lut_fine, 0 ], logpath=path_log) except: print "...failed" return ###################################################################### if verbose: print "refined pixel area estimation..." try: run([ "pixel_area", master + ".par", dem_seg + ".par", dem_seg, lut_fine, ls_map, inc, pixel_area2 ], logpath=path_log) except: print "...failed" return ###################################################################### if verbose: print "radiometric calibration and normalization..." try: slc_width = ReadPar(master + ".par").range_samples run([ "radcal_MLI", master, master + ".par", "-", master + "_cal", "-", 0, 0, 1, 0.0, "-", ellipse_pixel_area ], logpath=path_log) run([ "ratio", ellipse_pixel_area, pixel_area2, ratio_sigma0, slc_width, 1, 1 ], logpath=path_log) for item in files_mli: run([ "product", item, ratio_sigma0, item + "_pixcal", slc_width, 1, 1 ], logpath=path_log) except: print "...failed" return ###################################################################### if verbose: print "backward geocoding, normalization and conversion to dB..." for item in files_mli: run([ "geocode_back", item + "_pixcal", slc_width, lut_fine, item + "_geo", sim_width, 0, func_geoback ], logpath=path_log) run([ "lin_comb", "1", item + "_geo", 0, math.cos(math.radians(float(par.incidence_angle))), item + "_geo_flat", sim_width ], logpath=path_log) run([ "sigma2gamma", item + "_geo_flat", inc, item + "_geo_norm", sim_width ], logpath=path_log) ###################################################################### print "creating final tiff files..." for item in finder(tempdir, ["*_geo_norm"]): polarization = re.findall("[HV]{2}", os.path.basename(item))[0].lower() outname = outname_base + "_" + polarization run([ "data2geotiff", dem_seg + ".par", item, 2, outname + "_geocoded_norm.tif" ], logpath=path_log) annotation_dir = os.path.join(tempdir, "annotation") annotation = os.path.join(annotation_dir, [ x for x in os.listdir(annotation_dir) if polarization in os.path.basename(x) ][0]) os.rename(annotation, outname + "_annotation.xml") ###################################################################### if verbose: print "cleaning up..." # copy, rename and edit quicklook kml and png shutil.copyfile(os.path.join(tempdir, "preview", "map-overlay.kml"), outname_base + "_quicklook.kml") shutil.copyfile(os.path.join(tempdir, "preview", "quick-look.png"), outname_base + "_quicklook.png") with open(outname_base + "_quicklook.kml", "r") as infile: kml = infile.read().replace( "quick-look.png", os.path.basename(outname_base + "_quicklook.png")) with open(outname_base + "_quicklook.kml", "w") as outfile: outfile.write(kml) if not intermediates: shutil.rmtree(tempdir) if logfiles: os.rename(path_log, outname_base + "_log") if verbose: print "...done:", asctime() print "##########################################"
# find flattened interferograms list_flt = finder(path_out, ["*_int_diff"]) if differential else finder(path_out, ["*_flt"]) if len(list_flt) > 0: print "#############################################" print "estimation started..." for name_flt in list_flt: # extract timestamps from flt name id_pwr = re.findall("[A-Z0-9_]{10}[0-9T]{15}_[HV]{2}_slc(?:_cal)", name_flt) # find mli/rmli images matching the extracted timestamps try: name_pwr1 = finder(os.getcwd(), ["*"+id_pwr[0]+"_mli"])[0] name_pwr2 = finder(os.getcwd(), ["*"+id_pwr[1]+"_reg_mli"])[0] except: raise IOError("multilooked images missing") # concatenate coherence image name name_cc = name_flt+"_cc_wave" print os.path.basename(name_cc) # read image samples samples = str(ISPPar(name_pwr1 + '.par').range_samples) # run gamma command run(["cc_wave", name_flt, name_pwr1, name_pwr2, name_cc, samples, par.bx, par.by, par.wgt_wave], path_out, path_log) print "...estimation finished" print "#############################################" else: print "#############################################" print "no {0} interferograms found".format("differential" if differential else "flattened") print "#############################################"
os.remove(x + ".hdr") os.remove(x + ".aux.xml") # update processing list with new names processlist = [x[:-1] for x in processlist] # create table textfile for temporal filter name_ftab = os.path.join(os.getcwd(), "PAR/tab_tempfilt_" + tag) with open(name_ftab, "w") as out: for image in processlist: out.write(image + "\t" + image[:-3] + "tfilt\n") # read header file meta = HDRobject(processlist[0][:-3] + "tfilt.hdr") # perform temporal filtering run([ "temp_filt", name_ftab, meta.samples, par.waz, par.wr, par.wgt_tfilt ], os.getcwd(), path_log) for x in processlist: os.remove(x) if counter == 0: print "#############################################" print "no candidates for filtering found" print "#############################################" else: print "...done" print "#############################################"
path_log = os.path.join(os.getcwd(), "LOG/LAT/") if not os.path.exists(path_log): os.makedirs(path_log) # create list of scene tuple objects # all images following the defined patterns within the same folder (i.e. the same acquisition) will be grouped together tuples = grouping() print "#############################################" print "creating pauli decomposition..." for scene in tuples: if len(set(["HH_slc", "VV_slc", "HV_slc"]) & set(scene.__dict__.keys())) == 3: print scene.basename path_out = os.path.join(os.path.dirname(scene.HH_slc), "POL/") if not os.path.exists(path_out): os.makedirs(path_out) name_out = os.path.join(path_out, os.path.basename(scene.HH_slc)[:-6] + "pauli") run([ "pauli", scene.HH_slc, scene.VV_slc, scene.HV_slc, scene.HH_slc + ".par", scene.VV_slc + ".par", scene.HV_slc + ".par", name_out ], os.getcwd(), path_log) # rename files to consistent pattern for filename in finder(os.getcwd(), ["*.slc*"]): os.rename(filename, filename.replace(".slc", "_slc")) print "...done" print "#############################################"
os.mkdir(path) interferograms = finder(path_out, ["*int"]) if len(interferograms) > 0: print "#############################################" print "baseline estimation started..." for name_int in interferograms: name_off = name_int[:-3] + "off" name_base = name_int[:-3] + "base_init" print os.path.basename(name_base) slc = finder(os.getcwd(), [ re.findall("[A-Z0-9_]{10}[0-9T]{15}_[HV]{2}_slc(?:_cal)?", name_int)[0] ])[0] # rslc = finder(os.getcwd(), [re.findall("[A-Z0-9_]{10}[0-9T]{15}_[HV]{2}_slc(?:_cal)", name_int)[1]+"_reg"])[0] rslc = name_int[:-3] + "reg" run([ "base_init", slc + ".par", rslc + ".par", name_off, name_int, name_base, par.method_flag, par.nrfft, par.nazfft, par.r_samp, par.az_line ], path_out, path_log) print "...done" print "#############################################" else: print "#############################################" print "no interferograms found" print "#############################################"
print "converting data type" sp.check_call([{ "1": "uchar2float", "2": "short2float" }[header.data_type], dem, dem + "_f"], stdout=sp.PIPE) os.remove(dem) os.rename(dem + "_f", dem) header.data_type = "4" process += 1 if process > 0: hdr(header) # create gamma parameter file if not os.path.isfile(dem + ".par"): print "creating parameter file" false_northing = "0" if "North" in header.map_info else "10000000" posting = "-" + header.map_info[6] + " " + header.map_info[5] topleft = header.map_info[4] + " " + header.map_info[3] dempar = [ "UTM", "WGS84", "1", header.map_info[7], false_northing, os.path.basename(dem), "", "", "", header.samples, header.lines, posting, topleft ] run(["create_dem_par", dem + ".par"], path_dem, path_log, inlist=dempar) process += 1 if process == 0: print "nothing to be done"
if not os.path.exists(path): os.makedirs(path) list_K_dB = {"PSR1": "-115.0"} list_slc = finder(os.getcwd(), ["*_slc"]) if len(list_slc) > 0: print "#############################################" print "calibration started..." for name_slc in list_slc: sensor = name_slc.split("_")[0] if sensor in list_K_dB: K_dB = list_K_dB[sensor] else: print "calibration for sensor " + sensor + "not implemented" name_cslc = name_slc[:-3] + "cslc" run([ "radcal_SLC", name_slc, name_slc + ".par", name_cslc, name_cslc + ".par", "1", "-", "0", "0", "0", "0", "-", K_dB ], path_out, path_log) print "...done" print "#############################################" else: print "#############################################" print "no SLCs found" print "#############################################"
par = ReadPar(meta) mlk = Spacing(par, sys.argv[1]) # define (and create) directories for logfile path_log = os.path.join(os.getcwd(), "LOG/ISP/") if not os.path.exists(path_log): os.makedirs(path_log) print "slc range pixel spacing (slant, ground):", par.range_pixel_spacing, mlk.groundRangePS print "slc azimuth pixel spacing:", par.azimuth_pixel_spacing print "number of looks looks (range, azimuth):", mlk.rlks, mlk.azlks print "mli range pixel spacing (slant, ground):", int(mlk.rlks) * float( par.range_pixel_spacing), int(mlk.rlks) * mlk.groundRangePS print "mli azimuth pixel spacing:", int(mlk.azlks) * float( par.azimuth_pixel_spacing) print "-----------" # concatenate output names out_data = data + "_mli" out_meta = out_data + ".par" # set scaling factor scale = 0.000001 if "ERS" in par.sensor else 1.0 # perform gamma command run([ "multi_look", data, meta, out_data, out_meta, mlk.rlks, mlk.azlks, "-", "-", scale ], os.getcwd(), path_log) hdr(out_meta)