def list_operators():
"""This function provides a Python dictionary with all SNAP operators.
Args:
None.
Returns
Python dictionary with all SNAP operators.
Raises:
None.
"""
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
op_spi_it = GPF.getDefaultInstance().getOperatorSpiRegistry(
).getOperatorSpis().iterator()
snap_operators = []
while op_spi_it.hasNext():
op_spi = op_spi_it.next()
snap_operators.append(op_spi.getOperatorAlias())
return snap_operators
def topophaseRemoval(product):
if debug >= 2:
print(cyan + "topophaseRemoval() : " + bold + green +
"Run to SNAP... " + endC)
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'TopoPhaseRemoval'
# Set des parametres
parameters = HashMap()
parameters.put("Orbit Interpolation Degree", 3)
parameters.put("Digital Elevation Model", "SRTM 1Sec HGT (Auto Download)")
parameters.put("Tile Extension[%]", 100)
parameters.put("Output topographic phase band", True)
parameters.put("Output elevation band", False)
if debug >= 2:
print(parameters)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
if debug >= 2:
print(cyan + "topophaseRemoval() : " + bold + green + "Done... " +
endC)
return result
def backGeocoding(product):
if debug >= 2:
print(cyan + "backGeocoding() : " + bold + green + "Run to SNAP... " +
endC)
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'Back-Geocoding'
# Set des parametres
parameters = HashMap()
parameters.put("Digital Elevation Model", "SRTM 1Sec HGT (Auto Download)")
parameters.put("DEM Resampling Method", "BICUBIC_INTERPOLATION")
parameters.put("Resampling Type", "BISINC_5_POINT_INTERPOLATION")
parameters.put("Mask out areas with no elevation", True)
parameters.put("Output Deramp and Demod Phase", False)
if debug >= 2:
print(parameters)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
if debug >= 2:
print(cyan + "backGeocoding() : " + bold + green + "Done... " + endC)
return result
def resample(DIR, band, resolution):
"""
resamples a band of a SENTINEL product to a given target resolution
:param DIR: base directory of Sentinel2 directory tree
:param band: band name (e.g. B4)
:param resolution: target resolution in meter (e.g 10)
:return: resampled band
"""
from snappy import GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
HashMap = jpy.get_type('java.util.HashMap')
BandDescriptor = jpy.get_type(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
parameters = HashMap()
parameters.put('targetResolution', resolution)
parameters.put('upsampling', 'Bicubic')
parameters.put('downsampling', 'Mean')
parameters.put('flagDownsampling', 'FlagMedianAnd')
parameters.put('resampleOnPyramidLevels', True)
product = ProductIO.readProduct(DIR)
product = GPF.createProduct('Resample', parameters, product)
rsp_band = product.getBand(band)
return rsp_band
def describe_operators():
"""This function provides a Python dictionary with all SNAP operators.
Args:
None.
Returns
Python dictionary with all SNAP operators.
Raises:
None.
"""
desc_dict = {}
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
op_spi_it = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpis().iterator()
while op_spi_it.hasNext():
op_spi = op_spi_it.next()
alias = op_spi.getOperatorDescriptor().getAlias()
description = op_spi.getOperatorDescriptor().getDescription()
desc_dict[alias] = description
print(
"{} - {}".format(
alias, description
)
)
return desc_dict
def interferogram(product):
if debug >= 2:
print(cyan + "interferogram() : " + bold + green + "Run to SNAP... " +
endC)
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'Interferogram'
# Set des parametres
parameters = HashMap()
parameters.put("Subtract flat-earth phase", True)
parameters.put("Degree of \"Flat Earth\" polynomial", 5)
parameters.put("Number of \"Flat Earth\" estimation points", 501)
parameters.put("Orbit interpolation degree", 3)
parameters.put("Include coherence estimation", True)
parameters.put("Square Pixel", False)
parameters.put("Independent Window Sizes", False)
parameters.put("Coherence Azimuth Window Size", 10)
parameters.put("Coherence Range Window Size", 10)
if debug >= 2:
print(parameters)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
if debug >= 2:
print(cyan + "interferogram() : " + bold + green + "Done... " + endC)
return result
def topsarSplit(product):
if debug >= 2:
print(cyan + "applyingOrbitFile() : " + bold + green + "Run to SNAP... " + endC )
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'TOPSAR-Split'
# Set des parametres
parameters = HashMap()
op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)
op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()
for param in op_params:
if debug >= 2:
print(cyan + "topsarSplit() : " + bold + green + str(param.getName()) + " : " + str(param.getDefaultValue()) + endC)
parameters.put(param.getName(), param.getDefaultValue())
parameters.put('subswath', 'IW1')
parameters.put('selectedPolarisations', 'VV')
if debug >= 2:
print(parameters)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
if debug >= 2:
print(cyan + "topsarSplit() : " + bold + green + "Done... " + endC)
return result
def _band_math(self, product, name, expression):
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
HashMap = jpy.get_type('java.util.HashMap')
BandDescriptor = jpy.get_type(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
targetBand = BandDescriptor()
targetBand.name = name
targetBand.type = 'float32'
targetBand.expression = expression
bands = jpy.array(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
bands[0] = targetBand
parameters = HashMap()
parameters.put('targetBands', bands)
productMap = HashMap()
if isinstance(product, list):
for ind in range(len(product)):
print('p{}'.format(ind + 1))
productMap.put('p{}'.format(ind + 1), product[ind])
result = GPF.createProduct('BandMaths', parameters, productMap)
else:
result = GPF.createProduct('BandMaths', parameters, product)
return result
def subset(product, borderRectInGeoCoor):
from snappy import jpy
from snappy import ProductIO
from snappy import GPF
from snappy import HashMap
xmin = borderRectInGeoCoor[0]
ymin = borderRectInGeoCoor[1]
xmax = borderRectInGeoCoor[2]
ymax = borderRectInGeoCoor[3]
p1 = '%s %s' % (xmin, ymin)
p2 = '%s %s' % (xmin, ymax)
p3 = '%s %s' % (xmax, ymax)
p4 = '%s %s' % (xmax, ymin)
wkt = "POLYGON((%s, %s, %s, %s, %s))" % (p1, p2, p3, p4, p1)
WKTReader = jpy.get_type('com.vividsolutions.jts.io.WKTReader')
geom = WKTReader().read(wkt)
HashMap = jpy.get_type('java.util.HashMap')
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
parameters = HashMap()
parameters.put('copyMetadata', True)
parameters.put('geoRegion', geom)
parameters.put('outputImageScaleInDb', False)
subset = GPF.createProduct('Subset', parameters, product)
return subset
def topsarDeburst(product):
if debug >= 2:
print(cyan + "topsarDeburst() : " + bold + green + "Run to SNAP... " +
endC)
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'TOPSAR-Deburst'
# Set des parametres
parameters = HashMap()
parameters.put("Polarisations", "VV")
if debug >= 2:
print(parameters)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
if debug >= 2:
print(cyan + "topsarDeburst() : " + bold + green + "Done... " + endC)
return result
def goldsteinPhasefiltering(product):
if debug >= 2:
print(cyan + "goldsteinPhasefiltering() : " + bold + green +
"Run to SNAP... " + endC)
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'GoldsteinPhaseFiltering'
# Set des parametres
parameters = HashMap()
parameters.put("Adaptive Filter Exponent in(0,1]:", 1.0)
parameters.put("FFT Size", 64)
parameters.put("Window Size", 3)
parameters.put("Use coherence mask", False)
parameters.put("Coherence Threshold in[0,1]:", 0.2)
if debug >= 2:
print(parameters)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
if debug >= 2:
print(cyan + "goldsteinPhasefiltering() : " + bold + green +
"Done... " + endC)
return result
def __init__(self):
# HashMap
# Key-Value pairs.
# https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html
self.HashMap = jpy.get_type('java.util.HashMap')
# Get snappy Operators
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
def classify(prepros_folder):
for file in os.listdir(prepros_folder):
### Folder, date & timestamp
classification = rootpath + "\\classification"
scene_name = str(prepros_folder.split("\\")[X])[:32] # [X] element of filepath, change this to match scene name. [:32] first caracters of element
print("scene_name:", scene_name)
output_folder = os.path.join(classification, scene_name)
print("output_folder:", output_folder)
polarization = str(file)[46:48] # polarization from filename
if not os.path.exists(output_folder):
os.mkdir(output_folder)
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
HashMap = snappy.jpy.get_type('java.util.HashMap')
gc.enable()
sentinel_1 = ProductIO.readProduct(os.path.join(prepros_folder, file))
res = [20, 50] # parameters for CFAR
for r in res:
resolution = r
gd_window = resolution * 12.0
bg_window = resolution * 37.0
# AdaptiveThresholding (Constant False Alarm Rate CFAR)
parameters = HashMap()
parameters.put('targetWindowSizeInMeter', resolution)
parameters.put('guardWindowSizeInMeter', gd_window)
parameters.put('backgroundWindowSizeInMeter', bg_window)
parameters.put('pfa', 6.0)
target_1 = GPF.createProduct("AdaptiveThresholding", parameters, sentinel_1)
parameters = None
# Subset (extracting classification band)
parameters = HashMap()
parameters.put('bandNames', 'Sigma0_' + polarization + '_ship_bit_msk')
outfile = output_folder + "\\" + scene_name + "_" + polarization + "_cfar_" + str(resolution) + "m"
target_2 = GPF.createProduct("Subset", parameters, target_1)
ProductIO.writeProduct(target_2, outfile, 'GeoTIFF-BigTIFF', pm)
# Classification to vector
ds = gdal.Open(str(outfile + ".tif"))
rasterband = ds.GetRasterBand(1)
dst_layername = outfile + "_Iceberg_outline"
drv = ogr.GetDriverByName("GeoJSON")
dst_ds = drv.CreateDataSource(dst_layername + ".geojson")
dest_srs = ogr.osr.SpatialReference()
dest_srs.ImportFromEPSG(4326)
dst_layer = dst_ds.CreateLayer(dst_layername, dest_srs)
gdal.Polygonize(rasterband, rasterband, dst_layer, -1, [], callback=None) # (input, mask, dest_layer,,,)
def bandMathSnap(input_dim,
output_file,
expression_list,
format_file='float32'):
if debug >= 2:
print(cyan + "bandmathSnap() : " + bold + green +
"Import Dim to SNAP : " + endC + input_dim)
# Info input file
product = ProductIO.readProduct(input_dim)
width = product.getSceneRasterWidth()
height = product.getSceneRasterHeight()
name = product.getName()
description = product.getDescription()
band_names = product.getBandNames()
if debug >= 2:
print(cyan + "bandmathSnap() : " + bold + green +
"Product: %s, %d x %d pixels, %s" %
(name, width, height, description) + endC)
print(cyan + "bandmathSnap() : " + bold + green + "Bands: %s" %
(list(band_names)) + endC)
# Instance de GPF
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Def operateur SNAP
operator = 'BandMaths'
BandDescriptor = jpy.get_type(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
targetBands = jpy.array(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor',
len(expression_list))
# Get des expressions d'entréées
i = 0
for expression in expression_list:
targetBand = BandDescriptor()
targetBand.name = 'band_' + str(i + 1)
targetBand.type = format_file
targetBand.expression = expression
targetBands[i] = targetBand
i += 1
# Set des parametres
parameters = HashMap()
parameters.put('targetBands', targetBands)
# Get snappy Operators
result = GPF.createProduct(operator, parameters, product)
ProductIO.writeProduct(result, output_file, 'BEAM-DIMAP')
if debug >= 2:
print(cyan + "bandmathSnap() : " + bold + green + "Writing Done : " +
endC + str(output_file))
return result
def extract_values(self, file):
if not exists(self.plots):
mkdir(self.plots)
coords = []
with open(file, 'r') as f:
for line in f:
line = line.replace('\n', '')
coords.append([float(x) for x in line.split(' ')])
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
HashMap = jpy.get_type('java.util.HashMap')
Coords = jpy.array('org.esa.snap.pixex.Coordinate', len(coords))
Coord = jpy.get_type('org.esa.snap.pixex.Coordinate')
for ind, coord in enumerate(coords):
c = Coord('Coord{}'.format(ind), coord[0], coord[1], None)
Coords[ind] = c
parameters = HashMap()
parameters.put('exportBands', True)
parameters.put('exportTiePoints', False)
parameters.put('exportMasks', False)
parameters.put('coordinates', Coords)
parameters.put('outputDir', '.')
pre = self._extract_values(parameters, self.product_pre)
post = self._extract_values(parameters, self.product_post)
waves = pre.meta['comments'][-1].replace('\t', ' ')
waves = waves.replace('Wavelength:', '').split(' ')
waves = filter(lambda x: x != '', waves)
waves = [float(x) for x in waves]
waves = filter(lambda x: x != 0, waves)
bands = ['B{}'.format(ind) for ind in range(1, 9)]
bands += ['B8A', 'B9']
bands += ['B{}'.format(ind) for ind in range(11, 13)]
print(pre.colnames)
print(post.colnames)
for ind in range(len(pre)):
f, ax = plt.subplots()
ax.set_xlabel('Wavelength (nm)')
ax.set_ylabel('dl')
radiances = list(pre[bands][ind])
ax.plot(waves, radiances, color='g', label='pre')
ax.scatter(waves, radiances, color='g')
radiances = list(post[bands][ind])
ax.plot(waves, radiances, color='b', label='post')
ax.scatter(waves, radiances, color='b')
lat = pre['Latitude'][ind]
lon = pre['Longitude'][ind]
ax.set_title("{}, {}".format(lat, lon))
plt.legend()
save = "{}/{}.pdf".format(self.plots, pre['Name'][ind])
f.savefig(save, bbox_inches="tight")
def listParams(operator_name):
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(
operator_name)
print('Op name:', op_spi.getOperatorDescriptor().getName())
print('Op alias:', op_spi.getOperatorDescriptor().getAlias())
param_Desc = op_spi.getOperatorDescriptor().getParameterDescriptors()
for param in param_Desc:
print(param.getName())
def do_resampling (source):
print ('\tResampling ...')
HashMap = jpy.get_type('java.util.HashMap')
parameters = HashMap()
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
parameters.put('targetResolution', 10)
output = GPF.createProduct('Resample', parameters, source)
return output
def c2rcc_params():
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi('c2rcc.msi')
print(dir(op_spi))
print('Op name:', op_spi.getOperatorDescriptor().getName())
print('Op alias:', op_spi.getOperatorDescriptor().getAlias())
param_Desc = op_spi.getOperatorDescriptor().getParameterDescriptors()
for param in param_Desc:
print(param.getName(), "or", param.getAlias())
def subset(product, x, y, width, heigth, toPrint=True):
# subset of the Sentinel-1 GRD product by specify a rectangle whose top most left corner is defined by x and y coordinates
HashMap = jpy.get_type('java.util.HashMap')
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
parameters = HashMap()
parameters.put('copyMetadata', True)
parameters.put('region', "%s,%s,%s,%s" % (x, y, width, height))
subset = GPF.createProduct('Subset', parameters, product)
if toPrint:
print("Bands: %s" % (list(subset.getBandNames())))
return subset
def do_biophysical_parameter (source):
print ('\tBiophysical Parameters ...')
HashMap = jpy.get_type('java.util.HashMap')
parameters = HashMap()
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
parameters.put('targetResolution', 10)
parameters.put('computeLAI', True)
##parameters.put('computeFcover', True)
output = GPF.createProduct('BiophysicalOp', parameters, source)
return output
def Subset(data, x, y, w, h):
print('Subsetting the image...')
HashMap = jpy.get_type('java.util.HashMap')
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
parameters = HashMap()
parameters.put('copyMetadata', True)
parameters.put('region', "%s,%s,%s,%s" % (x, y, w, h))
return GPF.createProduct('Subset', parameters, data)
def ApplyOrbitFile(data):
print('Aplying Orbit File...')
parameters = HashMap()
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
parameters.put('orbitType', 'Sentinel Precise (Auto Download)')
parameters.put('polyDegree', '3')
parameters.put('continueOnFail', 'false')
return GPF.createProduct('Apply-Orbit-File', parameters, data)
def BandMathList(stack):
product = ProductIO.readProduct(stack)
band_names = product.getBandNames()
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
BandDescriptor = jpy.get_type(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
bandlist = list(band_names)
#targetBands = list()
x = 0
y = 1
bandlength = len(bandlist)
runs = (bandlength - 1)
targetBands = jpy.array(
'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', runs)
for i in bandlist:
while y <= runs:
#print('{}_minus_{}'.format(bandlist[x], bandlist[y]))
#targetBand1 = '{}_minus_{}'.format(bandlist[x], bandlist[y])
targetBand1 = BandDescriptor()
targetBand1.name = '{}_minus_{}'.format(bandlist[x], bandlist[y])
targetBand1.type = 'float32'
targetBand1.expression = '(({} - {})<(-2))? 255 : 0'.format(
bandlist[x], bandlist[y])
print("Writing Band {} : {}_minus_{}".format(
x, bandlist[x], bandlist[y]))
#targetBands.append(targetBand1)
targetBands[x] = targetBand1
x = x + 1
y = y + 1
"""targetBand1 = BandDescriptor()
targetBand1.name = 'first_{}_minus_last_{}'.format(bandlist[0], bandlist[bandlength])
targetBand1.type = 'float32'
targetBand1.expression = '(({} - {})<(-2))? 255 : 0'.format(bandlist[x], bandlist[y])
print("Writing Band first_{}_minus_last_{}".format(bandlist[0], bandlist[bandlength])
targetBands[bandlength] = targetBand1"""
parameters = HashMap()
parameters.put('targetBands', targetBands)
result = GPF.createProduct('BandMaths', parameters, product)
print("Writing...")
ProductIO.writeProduct(result, 'BandMaths.dim', 'BEAM-DIMAP')
print("BandMaths.dim Done.")
ProductIO.writeProduct(result, 'BandMaths.tif', "GeoTIFF-BigTIFF")
print("BandMaths.tif Done.")
def __init__(self, product, wkt_footprint, working_dir, external_dem_dir):
"""Prepare to use SNAPPY as a subprocess
This class prepares commands and runs SNAPPY as a python3.4 subprocess
"""
self.working_dir = working_dir
self.product_meta = product
self.wkt_footprint = wkt_footprint
self.dem_dir = external_dem_dir
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Set object parameterisation dictionary
self.HashMap = jpy.get_type('java.util.HashMap')
# Set start time and loop counter
self.start_time = datetime.datetime.now() # for calculation
self.start_time_string = self.start_time.strftime("%Y-%m-%d %H:%M:%S")
print("Processing start time:", self.start_time)
self.name = self.product_meta['name']
self.name_with_safe = self.name + '.SAFE'
self.product_path = os.path.join(self.working_dir, self.name + '.zip')
self.preprocess_path = working_dir
self.manifest_path = os.path.join(self.working_dir, self.name_with_safe, 'manifest.safe')
# for rs2
self.productxml_path = os.path.join(self.working_dir, self.name, 'product.xml')
# Read S1 raw data product and assigns source bands for given file
# readProduct(File file, String... formatNames)
if product['name'].startswith("S1"):
self.dataproduct_r = snappy.ProductIO.readProduct(self.manifest_path)
# self.srcbands = ["Intensity_VV", "Intensity_VH", "Amplitude_VV", "Amplitude_VH"]
self.srcbands = ["Intensity_VV", "Intensity_VH"]
print("Reading S1 data product with polarization bands:", self.srcbands)
# Read RS2 raw data product and assigns source bands for given file
else:
self.dataproduct_r = snappy.ProductIO.readProduct(self.productxml_path)
# self.srcbands = ["Intensity_VV", "Intensity_VH", "Amplitude_VV", "Amplitude_VH"]
print("Reading RS2 data product with polarization bands:", self.srcbands)
self.intermediate_product = None
self.operations_list = []
def __init__(self):
# HashMap
# Key-Value pairs.
# https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html
self.HashMap = jpy.get_type('java.util.HashMap')
# Get snappy Operators
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# Variables
# Describes a target band to be generated by this operator.
# http://step.esa.int/docs/v2.0/apidoc/engine/org/esa/snap/core/gpf/common/BandMathsOp.BandDescriptor.html
self.Variables = jpy.get_type(
'org.esa.snap.core.gpf.common.MosaicOp$Variable')
def process_date(prod_list, out_dir, orbit, area_of_int, ref_raster,
polarizations):
"""products is a list of products of the same orbit (ASCENDING/DESCENDING) and date (STATE_VECTOR_TIME[0:11]). Returns product subset for a given polarizaton"""
if len(prod_list) > 1:
# 0 Slice assembly
param_sliceass = hashp()
param_sliceass.put('selectedPolarisations', 'VH,VV')
product = GPF.createProduct("SliceAssembly", param_sliceass, prod_list)
else:
product = prod_list[0]
# 1 Apply orbit file
param = hashp()
product = GPF.createProduct("Apply-Orbit-File", param, product)
# 2 Radiometric calibration
param = hashp()
param.put('outputSigmaBand', True)
param.put('sourceBands', getBandNames(product, 'Intensity_'))
param.put('selectedPolarisations', 'VH,VV')
param.put('outputImageScaleInDb', False)
product = GPF.createProduct("Calibration", param, product)
# 3 Terrain correction
param = hashp()
param.put('demResamplingMethod', 'NEAREST_NEIGHBOUR')
param.put('imgResamplingMethod', 'NEAREST_NEIGHBOUR')
param.put('applyRadiometricNormalization', True)
param.put('demName', 'SRTM 3Sec')
param.put('pixelSpacingInMeter', 10.0)
param.put('sourceBands', getBandNames(product, 'Sigma0_'))
param.put('mapProjection', 'WGS84(DD)')
product = GPF.createProduct("Terrain-Correction", param, product)
# 4 Subset
if area_of_int is not None:
param = hashp()
param.put('geoRegion', area_of_int)
param.put('outputImageScaleInDb', False)
param.put('sourceBandNames', getBandNames(product, 'Sigma0_'))
product = GPF.createProduct("Subset", param, product)
out_name = out_dir + 'S1_' + orbit + '_' + product.getName()[24:32] + '_'
write_product(product, out_name, ConcisePM(System.out))
def get_operator_help(operator):
"""This function prints the human readable information about a SNAP operator
Args:
operator: SNAP operator
Returns
The human readable information about the provided SNAP operator.
Raises:
None.
"""
op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)
logging.info('Operator name: {}'.format(op_spi.getOperatorDescriptor().getName()))
logging.info('Operator alias: {}\n'.format(op_spi.getOperatorDescriptor().getAlias()))
logging.info('Parameters:\n')
param_Desc = op_spi.getOperatorDescriptor().getParameterDescriptors()
for param in param_Desc:
logging.info('{}: {}\nDefault Value: {}\n'.format(param.getName(),
param.getDescription(),
param.getDefaultValue()))
logging.info('Possible values: {}\n').format(list(param.getValueSet()))
def dem_extract(in_prod, xpix, ypix, bandname="altitude"):
"""Run the S3 SNOW DEM tool.
Args:
inprod (java.lang.Object): snappy java object: SNAP image product
xpix (float): x position in product to query
ypix (float): y position in product to query
bandname (str): DEM band name in product
Returns:
slope_vals (dictionnary): values from all bands at the given x,y"""
# Initialise a HashMap
parameters = HashMap()
parameters.put("elevationBandName", bandname)
parameters.put("copyElevationBand", "true")
# Run slope operator
s3snow_slope = GPF.createProduct("SlopeCalculation", parameters, in_prod)
# Initialise dictionnary to store data
slope_vals = {}
# Get all bands
for band in list(s3snow_slope.getBandNames()):
currentband = s3snow_slope.getBand(band)
currentband.loadRasterData()
slope_vals[band] = currentband.getPixelFloat(xpix, ypix)
return slope_vals
def TOPSAR_split_s(product):
parameters = HashMap()
parameters.put('subswath', 'IW1')
parameters.put('selectedPolarisations', 'VV')
parameters.put('firstBurstIndex', 3)
parameters.put('lastBurstIndex', 6)
return GPF.createProduct('TOPSAR-Split', parameters, product)
def terrain_correction(src, projection):
parameters = HashMap()
parameters.put("demName", "SRTM 1Sec HGT") # ~25 to 30m
parameters.put("externalDEMNoDataValue", 0.0)
parameters.put("externalDEMApplyEGM", True)
parameters.put("demResamplingMethod", "BICUBIC_INTERPOLATION")
parameters.put("imgResamplingMethod", "BICUBIC_INTERPOLATION")
parameters.put("pixelSpacingInMeter", 10.0)
parameters.put("pixelSpacingInDegree", 8.983152841195215E-5)
parameters.put("mapProjection", projection)
parameters.put("alignToStandardGrid", False)
parameters.put("standardGridOriginX", 0.0)
parameters.put("standardGridOriginY", 0.0)
parameters.put("nodataValueAtSea", True)
parameters.put("saveDEM", False)
parameters.put("saveLatLon", False)
parameters.put("saveIncidenceAngleFromEllipsoid", False)
parameters.put("saveLocalIncidenceAngle", False)
parameters.put("saveSelectedSourceBand", True)
parameters.put("outputComplex", False)
parameters.put("applyRadiometricNormalization", False)
parameters.put("saveSigmaNought", False)
parameters.put("saveGammaNought", False)
parameters.put("saveBetaNought", False)
parameters.put("incidenceAngleForSigma0",
"Use projected local incidence angle from DEM")
parameters.put("incidenceAngleForGamma0",
"Use projected local incidence angle from DEM")
parameters.put("auxFile", "Latest Auxiliary File")
return GPF.createProduct("Terrain-Correction", parameters, src)
sys.exit(1)
file = sys.argv[1]
print("Reading...")
product = ProductIO.readProduct(file)
width = product.getSceneRasterWidth()
height = product.getSceneRasterHeight()
name = product.getName()
description = product.getDescription()
band_names = product.getBandNames()
print("Product: %s, %d x %d pixels, %s" % (name, width, height, description))
print("Bands: %s" % (list(band_names)))
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
HashMap = jpy.get_type('java.util.HashMap')
BandDescriptor = jpy.get_type('org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
targetBand1 = BandDescriptor()
targetBand1.name = 'band_1'
targetBand1.type = 'float32'
targetBand1.expression = '(radiance_10 - radiance_7) / (radiance_10 + radiance_7)'
targetBand2 = BandDescriptor()
targetBand2.name = 'band_2'
targetBand2.type = 'float32'
targetBand2.expression = '(radiance_9 - radiance_6) / (radiance_9 + radiance_6)'
targetBands = jpy.array('org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 2)
