def _slice_assembly(filelist, outfile, logfile, polar='VV,VH,HH,HV'):
'''A wrapper of SNAP's slice assembly routine
This function assembles consecutive frames acquired at the same date.
Can be either GRD or SLC products
Args:
filelist (str): a string of a space separated list of OST imported
Sentinel-1 product slices to be assembled
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
'''
print(' INFO: Assembling consecutive frames:')
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
# construct command
command = '{} SliceAssembly -x -q {} -PselectedPolarisations={} \
-t \'{}\' {}'.format(gpt_file, 2 * os.cpu_count(), polar,
outfile, filelist)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully assembled products')
else:
print(' ERROR: Slice Assembly exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(101)
def _grd_speckle_filter(infile, outfile, logfile):
'''A wrapper around SNAP's Lee-Sigma Speckle Filter
This function takes OST imported Sentinel-1 product and applies
a standardised version of the Lee-Sigma Speckle Filter with
SNAP's defaut values.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
'''
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
print(' INFO: Applying the Lee-Sigma Speckle Filter')
# contrcut command string
command = '{} Speckle-Filter -x -q {} -PestimateENL=true \
-t \'{}\' \'{}\''.format(gpt_file, 2 * os.cpu_count(), outfile,
infile)
# run command and get return code
return_code = h.run_command(command, logfile)
# hadle errors and logs
if return_code == 0:
print(' INFO: Succesfully imported product')
else:
print(' ERROR: Speckle Filtering exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(111)
def _grd_subset_georegion(infile, outfile, logfile, georegion):
'''A wrapper around SNAP's subset routine
This function takes an OST imported frame and subsets it according to
the coordinates given in the region
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
georegion (str): a WKT style formatted POLYGON that bounds the
subset region
'''
# get Snap's gpt file
gpt_file = h.gpt_path()
# extract window from scene
command = '{} Subset -x -q {} -Ssource=\'{}\' -t \'{}\' \
-PcopyMetadata=true -Pgeoregion=\'{}\''.format(
gpt_file, 2 * os.cpu_count(), infile, outfile, georegion)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully subsetted product')
else:
print(' ERROR: Subsetting exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(107)
def _grd_speckle_filter(infile, outfile, logfile, speckle_dict):
'''A wrapper around SNAP's Lee-Sigma Speckle Filter
This function takes OST imported Sentinel-1 product and applies
a standardised version of the Lee-Sigma Speckle Filter with
SNAP's defaut values.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
'''
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
print(' INFO: Applying speckle filtering.')
# contrcut command string
command = ('{} Speckle-Filter -x -q {}'
' -PestimateENL={}'
' -PanSize={}'
' -PdampingFactor={}'
' -Penl={}'
' -Pfilter={}'
' -PfilterSizeX={}'
' -PfilterSizeY={}'
' -PnumLooksStr={}'
' -PsigmaStr={}'
' -PtargetWindowSizeStr={}'
' -PwindowSize={}'
'-t \'{}\' \'{}\''.format(
gpt_file, 2 * os.cpu_count(),
speckle_dict['estimate ENL'],
speckle_dict['pan size'],
speckle_dict['damping'],
speckle_dict['ENL'],
speckle_dict['filter'],
speckle_dict['filter x size'],
speckle_dict['filter y size'],
speckle_dict['num of looks'],
speckle_dict['sigma'],
speckle_dict['target window size'],
speckle_dict['window size'],
outfile, infile)
)
# run command and get return code
return_code = h.run_command(command, logfile)
# hadle errors and logs
if return_code == 0:
print(' INFO: Succesfully applied speckle filtering.')
else:
print(' ERROR: Speckle Filtering exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _grd_to_db(infile, outfile, logfile):
'''A wrapper around SNAP's linear to db routine
This function takes an OST calibrated Sentinel-1 product
and converts it to dB.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
'''
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
print(' INFO: Converting the image to dB-scale.')
# construct command string
command = '{} LinearToFromdB -x -q {} -t \'{}\' {}'.format(
gpt_file, 2 * os.cpu_count(), outfile, infile)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully converted product to dB-scale.')
else:
print(' ERROR: Linear to dB conversion exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(113)
def _coreg2(master, slave, outfile, logfile, dem_dict, ncores=os.cpu_count()):
'''A wrapper around SNAP's back-geocoding co-registration routine
This function takes a list of 2 OST imported Sentinel-1 SLC products
and co-registers them properly. This routine is sufficient for coherence
estimation, but not for InSAR, since the ESD refinement is not applied.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
ncores(int): the number of cpu cores to allocate to the gpt job - defaults to cpu count
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_Coreg.xml')
# make dem file snap readable in case of no external dem
if not dem_dict['dem file']:
dem_dict['dem file'] = " "
print(' INFO: Co-registering {} and {}'.format(master, slave))
command = ('{} {} -x -q {} '
' -Pmaster={}'
' -Pslave={}'
' -Pdem=\'{}\''
' -Pdem_file=\'{}\''
' -Pdem_nodata=\'{}\''
' -Pdem_resampling=\'{}\''
' -Poutput={} '.format(gpt_file, graph, ncores, master, slave,
dem_dict['dem name'],
dem_dict['dem file'],
dem_dict['dem nodata'],
dem_dict['dem resampling'], outfile))
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully coregistered product.')
else:
print(' ERROR: Co-registration exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _grd_ls_mask(infile, outfile, logfile, resolution, dem_dict):
'''A wrapper around SNAP's Layover/Shadow mask routine
This function takes OST imported Sentinel-1 product and calculates
the Layover/Shadow mask.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in meters
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
# get path to ost package
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
print(' INFO: Creating the Layover/Shadow mask')
# get path to workflow xml
graph = opj(rootpath, 'graphs', 'S1_GRD2ARD', '3_LSmap.xml')
# construct command string
# command = '{} {} -x -q {} -Pinput=\'{}\' -Presol={} -Pdem=\'{}\' \
# -Poutput=\'{}\''.format(gpt_file, graph, 2 * os.cpu_count(),
# infile, resolution, dem, outfile)
command = ('{} {} -x -q {} -Pinput=\'{}\' -Presol={} '
' -Pdem=\'{}\''
' -Pdem_file=\'{}\''
' -Pdem_nodata=\'{}\''
' -Pdem_resampling=\'{}\''
' -Pimage_resampling=\'{}\''
' -Poutput=\'{}\''.format(
gpt_file, graph, 2 * os.cpu_count(), infile, resolution,
dem_dict['dem name'], dem_dict['dem file'],
dem_dict['dem nodata'], dem_dict['dem resampling'],
dem_dict['image resampling'], outfile))
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully create a Layover/Shadow mask')
else:
print(' ERROR: Layover/Shadow mask creation exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _grd_terrain_correction_deg(infile,
outfile,
logfile,
resolution,
dem='SRTM 1Sec HGT'):
'''A wrapper around SNAP's Terrain Correction routine
This function takes an OST calibrated Sentinel-1 product and
does the geocodification.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in meters
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
# get path to ost package
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
print(' INFO: Geocoding the calibrated product')
# calculate the multi-look factor
# multilook_factor = int(int(resolution) / 10)
multilook_factor = 1
graph = opj(rootpath, 'graphs', 'S1_GRD2ARD', '3_ML_TC_deg.xml')
# construct command string
command = '{} {} -x -q {} -Pinput=\'{}\' -Presol={} -Pml={} -Pdem=\'{}\' \
-Poutput=\'{}\''.format(gpt_file, graph, 2 * os.cpu_count(),
infile, resolution, multilook_factor,
dem, outfile)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully imported product')
else:
print(' ERROR: Terain Correction exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _grd_frame_import_subset(infile,
outfile,
georegion,
logfile,
polarisation='VV,VH,HH,HV'):
'''A wrapper of SNAP import of a subset of single Sentinel-1 GRD product
This function takes an original Sentinel-1 scene (either zip or
SAFE format), updates the orbit information (does not fail if not
available), removes the thermal noise, subsets it to the given georegion
and stores it as a SNAP
compatible EAM-Dimap format.
Args:
infile: string or os.path object for
an original Sentinel-1 GRD product in zip or SAFE format
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
polarisation (str): a string consisiting of the polarisation (comma separated)
e.g. 'VV,VH',
default value: 'VV,VH,HH,HV'
georegion (str): a WKT style formatted POLYGON that bounds the
subset region
'''
print(' INFO: Importing {} by applying precise orbit file and'
' removing thermal noise, as well as subsetting.'.format(
os.path.basename(infile)))
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
# get path to ost package
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
graph = opj(rootpath, 'graphs', 'S1_GRD2ARD', '1_AO_TNR_SUB.xml')
# construct command
command = '{} {} -x -q {} -Pinput=\'{}\' -Pregion=\'{}\' -Ppolarisation={} \
-Poutput=\'{}\''.format(gpt_file, graph,
2 * os.cpu_count(), infile,
georegion, polarisation, outfile)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully imported product')
else:
print(' ERROR: Frame import exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _import(infile,
out_prefix,
logfile,
swath,
burst,
polar='VV,VH,HH,HV',
ncores=os.cpu_count()):
'''A wrapper of SNAP import of a single Sentinel-1 SLC burst
This function takes an original Sentinel-1 scene (either zip or
SAFE format), updates the orbit information (does not fail if not
available), and extracts a single burst based on the
given input parameters.
Args:
infile: string or os.path object for
an original Sentinel-1 GRD product in zip or SAFE format
out_prefix: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
swath (str): the corresponding IW subswath of the burst
burst (str): the burst number as in the Sentinel-1 annotation file
polar (str): a string consisiting of the polarisation (comma separated)
e.g. 'VV,VH',
default value: 'VV,VH,HH,HV'
ncores(int): the number of cpu cores to allocate to the gpt job - defaults to cpu count
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_BurstSplit_AO.xml')
print(' INFO: Importing Burst {} from Swath {}'
' from scene {}'.format(burst, swath, os.path.basename(infile)))
command = '{} {} -x -q {} -Pinput={} -Ppolar={} -Pswath={}\
-Pburst={} -Poutput={}' \
.format(gpt_file, graph, ncores, infile, polar, swath,
burst, out_prefix)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully imported product')
else:
print(' ERROR: Frame import exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(119)
return return_code
def _terrain_correction(infile, outfile, logfile, resolution, dem_dict):
'''A wrapper around SNAP's Terrain Correction routine
This function takes an OST calibrated Sentinel-1 product and
does the geocodification.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in meters
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get gpt file
gpt_file = h.gpt_path()
print(" INFO: Geocoding input scene")
command = ('{} Terrain-Correction -x -q {}'
' -PdemName=\'{}\''
' -PexternalDEMFile=\'{}\''
' -PexternalDEMNoDataValue=\'{}\''
' -PdemResamplingMethod=\'{}\''
' -PimgResamplingMethod=\'{}\''
' -PnodataValueAtSea=\'false\''
' -PpixelSpacingInMeter=\'{}\''
' -t {} {}'.format(gpt_file, 2 * os.cpu_count(),
dem_dict['dem name'], dem_dict['dem file'],
dem_dict['dem nodata'],
dem_dict['dem resampling'],
dem_dict['image resampling'], resolution,
outfile, infile))
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully orthorectified product.')
else:
print(' ERROR: Geocoding exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _terrain_correction_deg(infile,
outfile,
logfile,
resolution=0.001,
dem='SRTM 1sec HGT'):
'''A wrapper around SNAP's Terrain Correction routine
This function takes an OST calibrated Sentinel-1 product and
does the geocodification.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in degree
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get gpt file
gpt_file = h.gpt_path()
print(" INFO: Geocoding input scene")
command = '{} Terrain-Correction -x -q {} \
-PdemResamplingMethod=\'BILINEAR_INTERPOLATION\' \
-PimgResamplingMethod=\'BILINEAR_INTERPOLATION\' \
-PnodataValueAtSea=\'false\' \
-PpixelSpacingInDegree=\'{}\' \
-PdemName=\'{}\' \
-t {} {}' \
.format(gpt_file, 2 * os.cpu_count(), resolution, dem,
outfile, infile)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully imported product')
else:
print(' ERROR: Geocoding exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(122)
return return_code
def mt_speckle_filter(in_stack,
out_stack,
logfile,
speckle_dict,
ncores=os.cpu_count()):
'''
'''
# get gpt file
gpt_file = h.gpt_path()
# # get path to graph
# rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
# graph = opj(rootpath, 'graphs', 'S1_TS', '2_MT_Speckle.xml')
#
# command = '{} {} -x -q {} -Pinput={} \
# -Poutput={}'.format(gpt_file, graph, 2 * os.cpu_count(),
# in_stack, out_stack)
print(' INFO: Applying multi-temporal speckle filtering.')
# contrcut command string
command = ('{} Multi-Temporal-Speckle-Filter -x -q {}'
' -PestimateENL={}'
' -PanSize={}'
' -PdampingFactor={}'
' -Penl={}'
' -Pfilter=\'{}\''
' -PfilterSizeX={}'
' -PfilterSizeY={}'
' -PnumLooksStr={}'
' -PsigmaStr={}'
' -PtargetWindowSizeStr={}'
' -PwindowSize={}'
' -t \'{}\' \'{}\''.format(
gpt_file, ncores, speckle_dict['estimate ENL'],
speckle_dict['pan size'], speckle_dict['damping'],
speckle_dict['ENL'], speckle_dict['filter'],
speckle_dict['filter x size'],
speckle_dict['filter y size'], speckle_dict['num of looks'],
speckle_dict['sigma'], speckle_dict['target window size'],
speckle_dict['window size'], out_stack, in_stack))
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Successfully applied multi-temporal speckle filtering')
else:
print(' ERROR: Multi-temporal speckle filtering exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _ha_alpha(infile, outfile, logfile, pol_speckle_filter=False):
'''A wrapper of SNAP H-A-alpha polarimetric decomposition
This function takes an OST imported Sentinel-1 scene/burst
and calulates the polarimetric decomposition parameters for
the H-A-alpha decomposition.
Args:
infile: string or os.path object for
an original Sentinel-1 GRD product in zip or SAFE format
out_prefix: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
pol_speckle_filter (bool): wether or not to apply the
polarimetric speckle filter
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
if pol_speckle_filter:
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD',
'S1_SLC_Deb_Spk_Halpha.xml')
else:
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_Deb_Halpha.xml')
print(" INFO: Calculating the H-alpha dual polarisation")
command = '{} {} -x -q {} -Pinput={} -Poutput={}' \
.format(gpt_file, graph, 2 * os.cpu_count(), infile, outfile)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully created H/Alpha product')
else:
print(' ERROR: H/Alpha exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(121)
return return_code
def _grd_frame_import(infile, outfile, logfile, polar='VV,VH,HH,HV'):
'''A wrapper of SNAP import of a single Sentinel-1 GRD product
This function takes an original Sentinel-1 scene (either zip or
SAFE format), updates the orbit information (does not fail if not
available), removes the thermal noise and stores it as a SNAP
compatible BEAM-Dimap format.
Args:
infile: string or os.path object for
an original Sentinel-1 GRD product in zip or SAFE format
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
polar (str): a string consisiting of the polarisation (comma separated)
e.g. 'VV,VH',
default value: 'VV,VH,HH,HV'
'''
print(' INFO: Importing {} by applying precise orbit file and'
' removing thermal noise'.format(os.path.basename(infile)))
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
# get path to ost package
root_path = imp.find_module('ost')[1]
graph = opj(root_path, 'graphs', 'S1_GRD2ARD', '1_AO_TNR.xml')
# construct command
command = '{} {} -x -q {} -Pinput=\'{}\' -Ppolar={} \
-Poutput=\'{}\''.format(gpt_file, graph, os.cpu_count(), infile,
polar, outfile)
# run command
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully imported product')
else:
print(' ERROR: Frame import exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(102)
def _coreg2(master, slave, outfile, logfile, dem='SRTM 1sec HGT'):
'''A wrapper around SNAP's back-geocoding co-registration routine
This function takes a list of 2 OST imported Sentinel-1 SLC products
and co-registers them properly. This routine is sufficient for coherence
estimation, but not for InSAR, since the ESD refinement is not applied.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = imp.find_module('ost')[1]
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_Coreg.xml')
print(' INFO: Co-registering {} and {}'.format(master, slave))
command = '{} {} -x -q {} -Pmaster={} -Pslave={} -Poutput={} -Pdem=\'{}\''\
.format(gpt_file, graph, 2 * os.cpu_count(), master, slave,
outfile, dem)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully coregistered product')
else:
print(' ERROR: Co-registration exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(112)
return return_code
def _ls_mask(infile, outfile, logfile, resolution, dem='SRTM 1sec HGT'):
'''A wrapper around SNAP's Layover/Shadow mask routine
This function takes OST imported Sentinel-1 product and calculates
the Layover/Shadow mask.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in meters
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = imp.find_module('ost')[1]
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_LS_TC.xml')
print(" INFO: Compute Layover/Shadow mask")
command = '{} {} -x -q {} -Pinput={} -Presol={} -Poutput={} -Pdem=\'{}\'' \
.format(gpt_file, graph, 2 * os.cpu_count(), infile, resolution,
outfile, dem)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully created Layover/Shadow mask')
else:
print(' ERROR: Layover/Shadow mask creation exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(121)
return return_code
def _terrain_flattening(infile, outfile, logfile, dem_dict):
'''A wrapper around SNAP's terrain flattening
This function takes OST calibrated Sentinel-1 SLC product and applies
the terrain flattening to correct for radiometric distortions along slopes
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
'''
# get gpt file
gpt_file = h.gpt_path()
print(' INFO: Correcting for the illumination along slopes'
' (Terrain Flattening).')
command = ('{} Terrain-Flattening -x -q {} '
' -PadditionalOverlap=0.15'
' -PoversamplingMultiple=1.5'
' -PdemName=\'{}\''
' -PexternalDEMFile=\'{}\''
' -PexternalDEMNoDataValue=\'{}\''
' -PdemResamplingMethod=\'{}\''
' -t {} {}'.format(gpt_file, 2 * os.cpu_count(),
dem_dict['dem name'], dem_dict['dem file'],
dem_dict['dem nodata'],
dem_dict['dem resampling'], outfile, infile))
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully applied the terrain flattening.')
else:
print(' ERROR: Terrain Flattening exited with an error.'
' See {} for Snap Error output'.format(logfile))
return return_code
def _coherence(infile,
outfile,
logfile,
polar='VV,VH,HH,HV',
ncores=os.cpu_count()):
'''A wrapper around SNAP's coherence routine
This function takes a co-registered stack of 2 Sentinel-1 SLC products
and calculates the coherence.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
ncores(int): the number of cpu cores to allocate to the gpt job - defaults to cpu count
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_Coh_Deb.xml')
print(' INFO: Coherence estimation')
command = '{} {} -x -q {} -Pinput={} -Ppolar=\'{}\' -Poutput={}' \
.format(gpt_file, graph, ncores, infile, polar, outfile)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully created coherence product.')
else:
print(' ERROR: Coherence exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def create_stack(filelist,
out_stack,
logfile,
polarisation=None,
pattern=None,
ncores=os.cpu_count()):
'''
:param filelist: list of single Files (space separated)
:param outfile: the stack that is generated
:return:
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
if pattern:
graph = opj(rootpath, 'graphs', 'S1_TS', '1_BS_Stacking_HAalpha.xml')
command = '{} {} -x -q {} -Pfilelist={} -PbandPattern=\'{}.*\' \
-Poutput={}'.format(gpt_file, graph, ncores, filelist, pattern,
out_stack)
else:
graph = opj(rootpath, 'graphs', 'S1_TS', '1_BS_Stacking.xml')
command = '{} {} -x -q {} -Pfilelist={} -Ppol={} \
-Poutput={}'.format(gpt_file, graph, ncores, filelist,
polarisation, out_stack)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Successfully created multi-temporal stack')
else:
print(' ERROR: Stack creation exited with an error.'
' See {} for Snap Error output'.format(logfile))
return return_code
def create_stack(filelist,
out_stack,
logfile,
polarisation=None,
pattern=None):
'''
:param filelist: list of single Files (space separated)
:param outfile: the stack that is generated
:return:
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = imp.find_module('ost')[1]
print(" INFO: Creating multi-temporal stack of images")
if pattern:
graph = opj(rootpath, 'graphs', 'S1_TS', '1_BS_Stacking_HAalpha.xml')
command = '{} {} -x -q {} -Pfilelist={} -PbandPattern=\'{}.*\' \
-Poutput={}'.format(gpt_file, graph, 2 * os.cpu_count(),
filelist, pattern, out_stack)
else:
graph = opj(rootpath, 'graphs', 'S1_TS', '1_BS_Stacking.xml')
command = '{} {} -x -q {} -Pfilelist={} -Ppol={} \
-Poutput={}'.format(gpt_file, graph, 2 * os.cpu_count(),
filelist, polarisation, out_stack)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully created multi-temporal stack')
else:
print(' ERROR: Stack creation exited with an error.'
' See {} for Snap Error output'.format(logfile))
sys.exit(201)
def _grd_subset(infile, outfile, logfile, region):
'''A wrapper around SNAP's subset routine
This function takes an OST imported frame and subsets it according to
the coordinates given in the region
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
region (str): a list of image coordinates that bound the subset region
'''
# get Snap's gpt file
gpt_file = h.gpt_path()
# format region string
region = ','.join([str(int(x)) for x in region])
# construct command
command = '{} Subset -x -q {} -Pregion={} -t \'{}\' \'{}\''.format(
gpt_file, os.cpu_count(), region, outfile, infile)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully subsetted product')
else:
print(' ERROR: Subsetting exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _coherence(infile, outfile, logfile):
'''A wrapper around SNAP's coherence routine
This function takes a co-registered stack of 2 Sentinel-1 SLC products
and calculates the coherence.
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = imp.find_module('ost')[1]
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_Coh_Deb.xml')
print(' INFO: Coherence estimation')
command = '{} {} -x -q {} -Pinput={} -Poutput={}' \
.format(gpt_file, graph, 2 * os.cpu_count(), infile, outfile)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully created Coherence product')
else:
print(' ERROR: Coherence exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(121)
return return_code
def mt_speckle_filter(in_stack, out_stack, logfile):
'''
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = imp.find_module('ost')[1]
graph = opj(rootpath, 'graphs', 'S1_TS', '2_MT_Speckle.xml')
print(" INFO: Applying the multi-temporal speckle-filtering")
command = '{} {} -x -q {} -Pinput={} \
-Poutput={}'.format(gpt_file, graph, 2 * os.cpu_count(),
in_stack, out_stack)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully applied multi-temporal speckle filtering')
else:
print(' ERROR: Multi-temporal speckle filtering exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(202)
def mt_speckle_filter(in_stack, out_stack, logfile):
'''
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
graph = opj(rootpath, 'graphs', 'S1_TS', '2_MT_Speckle.xml')
command = '{} {} -x -q {} -Pinput={} \
-Poutput={}'.format(gpt_file, graph, 2 * os.cpu_count(),
in_stack, out_stack)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully applied multi-temporal speckle filtering')
else:
print(' ERROR: Multi-temporal speckle filtering exited with an error. \
See {} for Snap Error output'.format(logfile))
return return_code
def _calibration(infile, outfile, logfile, product_type='GTCgamma'):
'''A wrapper around SNAP's radiometric calibration
This function takes OST imported Sentinel-1 product and generates
it to calibrated backscatter.
3 different calibration modes are supported.
- Radiometrically terrain corrected Gamma nought (RTC)
NOTE: that the routine actually calibrates to bet0 and needs to
be used together with _terrain_flattening routine
- ellipsoid based Gamma nought (GTCgamma)
- Sigma nought (GTCsigma).
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in meters
product_type (str): the product type of the output product
i.e. RTC, GTCgamma or GTCsigma
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
if product_type == 'RTC':
print(' INFO: Calibrating the product to a RTC product.')
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD',
'S1_SLC_TNR_Calbeta_Deb.xml')
elif product_type == 'GTCgamma':
print(' INFO: Calibrating the product to a GTC product (Gamma0).')
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD',
'S1_SLC_TNR_CalGamma_Deb.xml')
elif product_type == 'GTCsigma':
print(' INFO: Calibrating the product to a GTC product (Sigma0).')
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD',
'S1_SLC_TNR_CalSigma_Deb.xml')
else:
print(' ERROR: Wrong product type selected.')
sys.exit(121)
print(" INFO: Removing thermal noise, calibrating and debursting")
command = '{} {} -x -q {} -Pinput={} -Poutput={}' \
.format(gpt_file, graph, 2 * os.cpu_count(), infile, outfile)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully calibrated product')
else:
print(' ERROR: Frame import exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(121)
return return_code
def _ha_alpha(infile,
outfile,
logfile,
pol_speckle_filter=False,
pol_speckle_dict=None,
ncores=os.cpu_count()):
'''A wrapper of SNAP H-A-alpha polarimetric decomposition
This function takes an OST imported Sentinel-1 scene/burst
and calulates the polarimetric decomposition parameters for
the H-A-alpha decomposition.
Args:
infile: string or os.path object for
an original Sentinel-1 GRD product in zip or SAFE format
out_prefix: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
pol_speckle_filter (bool): wether or not to apply the
polarimetric speckle filter
ncores(int): the number of cpu cores to allocate to the gpt job - defaults to cpu count
'''
# get gpt file
gpt_file = h.gpt_path()
# get path to graph
rootpath = importlib.util.find_spec('ost').submodule_search_locations[0]
if pol_speckle_filter:
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD',
'S1_SLC_Deb_Spk_Halpha.xml')
print(' INFO: Applying the polarimetric speckle filter and'
' calculating the H-alpha dual-pol decomposition')
command = ('{} {} -x -q {} -Pinput={} -Poutput={}'
' -Pfilter=\'{}\''
' -Pfilter_size=\'{}\''
' -Pnr_looks={}'
' -Pwindow_size={}'
' -Ptarget_window_size={}'
' -Ppan_size={}'
' -Psigma={}'.format(gpt_file, graph, ncores, infile,
outfile, pol_speckle_dict['filter'],
pol_speckle_dict['filter size'],
pol_speckle_dict['num of looks'],
pol_speckle_dict['window size'],
pol_speckle_dict['target window size'],
pol_speckle_dict['pan size'],
pol_speckle_dict['sigma']))
else:
graph = opj(rootpath, 'graphs', 'S1_SLC2ARD', 'S1_SLC_Deb_Halpha.xml')
print(" INFO: Calculating the H-alpha dual polarisation")
command = '{} {} -x -q {} -Pinput={} -Poutput={}' \
.format(gpt_file, graph, ncores, infile, outfile)
return_code = h.run_command(command, logfile)
if return_code == 0:
print(' INFO: Succesfully created H/A/Alpha product')
else:
print(' ERROR: H/Alpha exited with an error. \
See {} for Snap Error output'.format(logfile))
# sys.exit(121)
return return_code
def _grd_backscatter(infile,
outfile,
logfile,
product_type='GTCgamma',
dem='SRTM 1Sec HGT'):
'''A wrapper around SNAP's radiometric calibration
This function takes OST imported Sentinel-1 product and generates
it to calibrated backscatter.
3 different calibration modes are supported.
- Radiometrically terrain corrected Gamma nought (RTC)
- ellipsoid based Gamma nought (GTCgamma)
- Sigma nought (GTCsigma).
Args:
infile: string or os.path object for
an OST imported frame in BEAM-Dimap format (i.e. *.dim)
outfile: string or os.path object for the output
file written in BEAM-Dimap format
logfile: string or os.path object for the file
where SNAP'S STDOUT/STDERR is written to
resolution (int): the resolution of the output product in meters
product_type (str): the product type of the output product
i.e. RTC, GTCgamma or GTCsigma
dem (str): A Snap compliant string for the dem to use.
Possible choices are:
'SRTM 1sec HGT' (default)
'SRTM 3sec'
'ASTER 1sec GDEM'
'ACE30'
'''
# get path to SNAP's command line executable gpt
gpt_file = h.gpt_path()
# get path to ost package
root_path = imp.find_module('ost')[1]
# select xml according to product type
if product_type == 'RTC':
print(' INFO: Calibrating the product to a RTC product.')
graph = opj(root_path, 'graphs', 'S1_GRD2ARD', '2_CalBeta_TF.xml')
elif product_type == 'GTCgamma':
print(' INFO: Calibrating the product to a GTC product (Gamma0).')
graph = opj(root_path, 'graphs', 'S1_GRD2ARD', '2_CalGamma.xml')
elif product_type == 'GTCsigma':
print(' INFO: Calibrating the product to a GTC product (Sigma0).')
graph = opj(root_path, 'graphs', 'S1_GRD2ARD', '2_CalSigma.xml')
else:
print(' ERROR: Wrong product type selected.')
sys.exit(103)
# construct command sring
if product_type == 'RTC':
command = '{} {} -x -q {} -Pinput=\'{}\' -Pdem=\'{}\' \
-Poutput=\'{}\''.format(gpt_file, graph, 2 * os.cpu_count(),
infile, dem, outfile)
else:
command = '{} {} -x -q {} -Pinput=\'{}\' -Poutput=\'{}\''.format(
gpt_file, graph, 2 * os.cpu_count(), infile, outfile)
# run command and get return code
return_code = h.run_command(command, logfile)
# handle errors and logs
if return_code == 0:
print(' INFO: Succesfully calibrated product')
else:
print(' ERROR: Backscatter calibration exited with an error. \
See {} for Snap Error output'.format(logfile))
sys.exit(103)
