def copy_bands_to_file(src_file_path, dst_file_path, bands=None): # Get info from source product src_prod = ProductIO.readProduct(src_file_path) prod_name = src_prod.getName() prod_type = src_prod.getProductType() width = src_prod.getSceneRasterWidth() height = src_prod.getSceneRasterHeight() if bands is None: bands = src_prod.getBandNames() # Copy geocoding and selected bands from source to destination product dst_prod = Product(prod_name, prod_type, width, height) ProductUtils.copyGeoCoding(src_prod.getBandAt(0), dst_prod) for band in bands: r = ProductUtils.copyBand(band, src_prod, dst_prod, True) if r is None: src_prod.closeIO() raise RuntimeError(src_file_path + " does not contain band " + band) # Write destination product to disk ext = os.path.splitext(dst_file_path)[1] if ext == '.dim': file_type = 'BEAM_DIMAP' elif ext == '.nc': file_type = 'NetCDF-CF' elif ext == '.tif': file_type = 'GeoTIFF-BigTIFF' else: file_type = 'GeoTIFF-BigTIFF' ProductIO.writeProduct(dst_prod, dst_file_path, file_type) src_prod.closeIO() dst_prod.closeIO()
def read_terrain_corrected_product(path_to_dim): print(path_to_dim) dataproduct_r = ProductIO.readProduct(path_to_dim) # will the computed band show up? for band in dataproduct_r.getBandNames(): print(band) print('WRITING OUT TO GEOTIFF!!') sigma0_ortho_bands = ["Sigma0_VH_use_local_inci_angle_from_dem", "Sigma0_VV_use_local_inci_angle_from_dem"] convertComputedBandToBand(dataproduct_r.getBand(sigma0_ortho_bands[0])) convertComputedBandToBand(dataproduct_r.getBand(sigma0_ortho_bands[1])) HashMap = jpy.get_type('java.util.HashMap') sub_parameters = HashMap() sub_parameters.put('bandNames', ",".join(sigma0_ortho_bands)) # Should eventually look at using a local SRTM 1Sec DEM (instead of auto downloading) subset = GPF.createProduct("Subset", sub_parameters, dataproduct_r) final_output_name = Path(Path(path_to_dim).parent, "test") print('writing out final result') # Get a progressMonitor object # monitor = self.createProgressMonitor() # print('WRITING OUT PRODUCT') ProductIO.writeProduct(subset, str(final_output_name), 'BEAM-DIMAP')
def match_up(filename, file, stations): print('match_up...') # file = ProductIO.readProduct(filepath+filename) geo = file.getSceneGeoCoding() size = file.getSceneRasterSize() if geo.canGetGeoPos(): for station in stations: p1 = geo.getPixelPos(geopos(station['Lat'], station['Lon']), None) if p1.getX() == 'non': continue x = p1.getX() - Height / 2 y = p1.getY() - Width / 2 if file.containsPixel(p1): flist = filename.split('_') wdir, wspeed = wind_filed_from_ndbc(station['name'], flist[-5]) if wdir == 0 and wspeed == 0: continue else: print(flist[-1].split('.')[0]) print(station) print(x, y) print(size.getHeight(), size.getWidth()) if size.getHeight() > 400 and size.getWidth > 400: subfile = subset(file, int(x), int(y)) if subfile is False: print('cut exception') continue print('write...') print(filename, station['name']) try: ProductIO.writeProduct( subfile, '/users/yangchao/GitHub/wind/snap/match_data1/' + station['name'] + '_subset_' + wdir + '_' + wspeed + '_' + station['height'] + '_' + filename.split('.')[0], 'BEAM-DIMAP') except Exception: print('exception') subfile.dispose() continue subfile.dispose() del subfile else: print('copy...') try: ProductIO.writeProduct( file, '/users/yangchao/GitHub/wind/snap/match_data1/' + station['name'] + '_subset_' + wdir + '_' + wspeed + '_' + station['height'] + '_' + filename.split('.')[0], 'BEAM-DIMAP') except Exception: print('exception') continue else: print(filename + " can't get geo pos") del size del geo file.dispose()
def apply_orbit_file(self, write_intermediate=False): parameters = self.HashMap() dataproduct = GPF.createProduct("Apply-Orbit-File", parameters, self.dataproduct_r) self.operations_list.append('ApplyOrbit') SF_filepath = "" # Get a progressMonitor object monitor = self.createProgressMonitor() if write_intermediate: # Write data product with BEAM-DIM format to given file path # ProductIO.writeProduct(Product product, String filePath, String formatName) SF_filepath = Path(self.working_dir, self.name_with_safe + "_ORB") print('Writing out Orbit File corrected product') ProductIO.writeProduct(dataproduct, str(SF_filepath), 'BEAM-DIMAP', monitor) # Set start time and loop counter finish_time = datetime.datetime.now() # for calculation elapsed_time = finish_time - self.start_time print(elapsed_time.strftime("%H:%M:%S")) if os.path.exists(SF_filepath + ".dim"): print("Completed applying orbit file:", SF_filepath) else: print("Completed applying orbit file: data product saved to in-memory") self.intermediate_product = dataproduct
def main(): ## All Sentinel-2 data subfolders are located within a super folder (make sure data is already unzipped and each sub folder name ends with .SAFE) path = r'D:\Sentinel\test' outpath = r'D:\Sentinel\out' if not os.path.exists(outpath): os.makedirs(outpath) for folder in os.listdir(path): gc.enable() gc.collect() print ("Filname: ", path + "\\" + folder + "\\manifest.safe") ##sentinel2 = path + "\\" + folder + "\\MTD_MSIL1C.xml" sentinel2 = ProductIO.readProduct(path + "\\" + folder + "\\MTD_MSIL1C.xml") loopstarttime = str(datetime.datetime.now()) print ('Start time: ', loopstarttime) start_time = time.time() ## Extract mode, product type modestamp = folder.split("_")[1] productstamp = folder.split("_")[2] ## Start preprocessing resample = do_resampling(sentinel2) biOp = do_biophysical_parameter(resample) ##ndvi = do_vegetation_indices(sentinel2) print ("outFilename: ", outpath + "\\" + folder.split(".SAFE")[0] + '_biOp' + '.dim') ProductIO.writeProduct(biOp, outpath + "\\" + folder.split(".SAFE")[0] + '_biOp' + '.dim', "BEAM-DIMAP")
def guardarArchivo(): global flood_mask #Crear la imagen a partir de la mascara ProductIO.writeProduct(flood_mask, "C:/CTE_334/Actividad09/final_mask", 'GeoTIFF') os.path.exists("C:/CTE_334/Actividad09/final_mask.tif") print("IMAGEN CREADA EXITOSAMENTE A PARTIR DE MASCARA")
def guardarArchivo(): global flood_mask #Crear la imagen a partir de la mascara ProductIO.writeProduct( flood_mask, "C:/Users/Usuario/Desktop/Actvidades_CTE_334/Examen_unidad_2/final_mask", 'GeoTIFF') print("IMAGEN CREADA EXITOSAMENTE A PARTIR DE MASCARA")
def topo_removal(file): image = ProductIO.readProduct(file) p = HashMap() p.put('demName', 'SRTM 1Sec HGT') result = GPF.createProduct('TopoPhaseRemoval', p, image) # Write to temporary file outfile = file.split('.dim')[0] + '_noSRTM.dim' ProductIO.writeProduct(result, outfile, 'BEAM-DIMAP')
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 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 write(self, file_path): """ Write the processed product to a file with a file type and close the product. """ print("\tWrite, file_path={}".format(file_path)) ProductIO.writeProduct(self.product, file_path, 'GeoTIFF') self.product.closeIO() self.product = None return self.product
def speckle_filter(self, filter="Gamma Map", estimateENL=True, filterSize=11, numLooksStr="1", targetWindowStr="3x3", windowSize="11x11", write_intermediate=False): print("-------------") # Apply SPECKLE FILTER print("Applying speckle-filter:", self.name) # Define object parameterisation for filtering parameters = self.HashMap() parameters.put('filter', filter) parameters.put('estimateENL', estimateENL) parameters.put('filterSizeX', filterSize) parameters.put('filterSizeY', filterSize) parameters.put('numLooksStr', numLooksStr) parameters.put('sourceBands', ",".join(self.srcbands)) parameters.put('targetWindowStr', targetWindowStr) parameters.put('windowSize', windowSize) print("Speckle filtering parameters:", parameters) # Create speckle filter data product using 'Speckle-Filter' operator/parameters and raw data product as source product # Speckle noise reduction can be applied either by spatial filtering or multilook processing # Filtered product contains 4 real bands: 2 amplitude and intensity bands for each polarizations # createProduct(String operatorName, Map<String,Object> parameters, Map<String,Product> sourceProducts) dataproduct = GPF.createProduct("Speckle-Filter", parameters, self.dataproduct_r) self.operations_list.append('SpeckleFilter') SF_filepath = "" # Get a progressMonitor object monitor = self.createProgressMonitor() if write_intermediate: # Write data product with BEAM-DIM format to given file path # ProductIO.writeProduct(Product product, String filePath, String formatName) SF_filepath = Path(self.working_dir, self.name_with_safe + "_SF") print('Writing out SpeckleFilter Product') ProductIO.writeProduct(dataproduct, str(SF_filepath), 'BEAM-DIMAP', monitor) finish_time = datetime.datetime.now() # for calculation elapsed_time = finish_time - self.start_time print(elapsed_time.strftime("%H:%M:%S")) if os.path.exists(SF_filepath + ".dim"): print("Completed speckle-filtering:", SF_filepath) else: print("Completed speckle-filtering: data product saved to in-memory") self.intermediate_product = dataproduct
def getGeoTiffImage(sarDownloadFilePath, geopandasDataFilePath, geoDataIndex, dstPath=None): ''' Get GeoTiff image from a .SAFE folder extracted after download :type sarDownloadFilePath: string or list of string :type geopandasDataFilePath: string :type geoDataIndex: int :type dstPath: string :param sarDownloadFilePath: directory (or list of directory) of .SAFE folder(s) :param geopandasDataFilePath: directory of geopandas dataframe file :param geoDataIndex: geoDataIndex of data needed to retrieve in geopandas Dataframe :param dstPath: directory of destination file, must have '.tif' extension :return: None :example: sarHelpers.getGeoTiffImage(sarDownloadFilePath='S1A_IW_GRDH_1SDV_20170221T225238_20170221T225303_015388_019405_9C41.SAFE', geopandasDataFilePath='mekongReservoirs', geoDataIndex=0, dstPath='geotiff/1.tif') ''' from snappy import jpy from snappy import ProductIO from snappy import GPF from snappy import HashMap s1meta = "manifest.safe" s1product = "%s/%s" % (sarDownloadFilePath, s1meta) reader = ProductIO.getProductReader("SENTINEL-1") product = reader.readProductNodes(s1product, None) parameters = HashMap() borderRectInGeoCoor = Utils.getGeoDataBorder(geopandasDataFilePath, geoDataIndex) subset = Utils.subset(product, borderRectInGeoCoor) calibrate = Utils.calibrate(subset) terrain = Utils.terrainCorrection(calibrate) terrainDB = GPF.createProduct("LinearToFromdB", parameters, terrain) speckle = Utils.speckleFilter(terrainDB) if dstPath is None: dstPath = sarImgPath[:-4] + '.tif' ProductIO.writeProduct(speckle, dstPath, 'GeoTiff') product.dispose() subset.dispose() calibrate.dispose() terrain.dispose() speckle.dispose() del product, subset, calibrate, terrain, terrainDB, speckle return dstPath
def collocate_all(input_imgs, write_product): if len(input_imgs) < 2: raise ValueError('Error, len(input_imgs)={}'.format(len(input_imgs))) col = collocate(input_imgs[0],input_imgs[1]) for i in range(2,len(input_imgs)): col = collocate(col,input_imgs[i]) if write_product: collocation = "collocation_all.tif" ProductIO.writeProduct(col, collocation, 'GeoTiff') return col
def snaphu_unwrapping(product, target_Product_File, outFolder, filename): parameters = HashMap() parameters.put('targetProductFile', target_Product_File) # from SNAPHU_export parameters.put('outputFolder', outFolder) parameters.put('copyOutputAndDelete', 'Snaphu-unwrapping-after.vm') parameters.put('copyFilesTemplate', 'Snaphu-unwrapping-before.vm') product = GPF.createProduct('snaphu-unwrapping', parameters, product) ProductIO.writeProduct(product, filename + '.dim', 'BEAM-DIMAP') print('Phase unwrapping performed successfully …')
def do_ifg(path): """ Takes filepath of TDX xml file Uses snappy to create interferogram Add in parameters to p if required (see gpt Interferogram -h for details) """ target = ifg_file(path) image = ProductIO.readProduct(path) p = HashMap() image = GPF.createProduct('Interferogram',p,image) ProductIO.writeProduct(image,target,'BEAM-DIMAP')
def createP(function, inputProduct, writeout=False, **kwargs): # pythonic version of GPF.createProduct() # function is string of SNAP operator # inputProduct is SNAP product object # kwargs contains any parameters to pass to the operator p = HashMap() for arg in kwargs: p.put(arg, kwargs.get(arg)) result = GPF.createProduct(function, p, inputProduct) if writeout != False: ProductIO.writeProduct(result, writeout, 'BEAM-DIMAP') else: return result
def write_out_result(self, format='BEAM-DIMAP'): if format == 'BEAM-DIMAP': # Write data product with BEAM-DIM format to given file path # ProductIO.writeProduct(Product product, String filePath, String formatName) SF_filepath = Path(self.working_dir, self.name_with_safe + "_FINAL") print('WRITING OUT PRODUCT') ProductIO.writeProduct(self.intermediate_product, str(SF_filepath), 'BEAM-DIMAP') finish_time = datetime.datetime.now()# for calculation elapsed_time = finish_time - self.start_time print(elapsed_time.strftime("%H:%M:%S")) elif format == 'GEOTIFF': print('WRITING OUT TO GEOTIFF!!') sigma0_ortho_bands = ["Sigma0_VH_use_local_inci_angle_from_dem", "Sigma0_VV_use_local_inci_angle_from_dem"] print(self.intermediate_product) print(self.intermediate_product.getBandNames()) for band in self.intermediate_product.getBandNames(): print(band) self.convertComputedBandToBand(self.intermediate_product.getBand(sigma0_ortho_bands[0])) self.convertComputedBandToBand(self.intermediate_product.getBand(sigma0_ortho_bands[1])) sub_parameters = self.HashMap() sub_parameters.put('bandNames', ",".join(sigma0_ortho_bands)) # Should eventually look at using a local SRTM 1Sec DEM (instead of auto downloading) subset = GPF.createProduct("Subset", sub_parameters, self.intermediate_product) print(self.name_with_safe) final_output_name = Path(self.working_dir, self.name_with_safe + "_".join(self.operations_list)) print('writing out final result') # Get a progressMonitor object monitor = self.createProgressMonitor() print('WRITING OUT PRODUCT') ProductIO.writeProduct(self.intermediate_product, str(final_output_name), 'GeoTIFF') finish_time = datetime.datetime.now() # for calculation elapsed_time = finish_time - self.start_time print(elapsed_time.strftime("%H:%M:%S"))
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 range_doppler_to_sigma0(self, resolution=10.0, suffix="", window_size=11, write_intermediate=False): # APPLY Range Doppler terrain correction and ortho print('Applying applying R.Doppler terrain corr. and ortho...') rd_parameters = self.HashMap() rd_parameters.put('demName', "SRTM 1Sec HGT") # Should eventually look at using a local SRTM 1Sec DEM (instead of auto downloading) rd_parameters.put('imgResamplingMethod', "BILINEAR_INTERPOLATION") rd_parameters.put('pixelSpacingInMeter', resolution) rd_parameters.put('sourceBands', ",".join(self.srcbands)) # rd_parameters.put('mapProjection', projection) # Defined above, should be auto set to best UTM zone # APPLY RADIOMETRIC NORMALIZATION to SIGMA0 (not clear if necessary) only do if sigma0 NOT done above rd_parameters.put('applyRadiometricNormalization', True) rd_parameters.put('incidenceAngleForSigma0', "Use local incidence angle from DEM") rd_parameters.put('saveSigmaNought', True) rd_parameters.put('saveLocalIncidenceAngle', True) rd_corrected = GPF.createProduct("Terrain-Correction", rd_parameters, self.intermediate_product) self.operations_list.append("RangeDopplerOrthoConversionToSigma0") print(self.name_with_safe) final_output_name = self.name_with_safe + "_{}_{}x{}_{}m".format(suffix, window_size, window_size, resolution) print('writing out final result') # Get a progressMonitor object monitor = self.createProgressMonitor() SF_filepath = "" if write_intermediate: # Write data product with BEAM-DIM format to given file path # ProductIO.writeProduct(Product product, String filePath, String formatName) SF_filepath = Path(self.working_dir, self.name_with_safe + "_ORTHO") print('Writing out Terrain-Correction Product') ProductIO.writeProduct(rd_corrected, str(SF_filepath), 'BEAM-DIMAP', monitor) finish_time = datetime.datetime.now() # for calculation elapsed_time = finish_time - self.start_time print(elapsed_time.strftime("%H:%M:%S")) if os.path.exists(SF_filepath + ".dim"): print("Completed speckle-filtering:", SF_filepath) else: print("Completed speckle-filtering: data product saved to in-memory") self.intermediate_product = rd_corrected
def nbr(self): if hasattr(self, 'path_post'): name = 'NBR' exprss = '(B8 - B12) / (B8 + B12)' product_pre = self._band_math(self.product_pre, name, exprss) product_post = self._band_math(self.product_post, name, exprss) print(list(product_pre.getBandNames())) print(list(product_post.getBandNames())) name = 'difNBR' exprss = '$p1.NBR - $p2.NBR'.format(product_pre, product_post) products = [product_pre, product_post] product = self._band_math(products, name, exprss) out = "/".join([self.path, 'NBR.tif']) ProductIO.writeProduct(product, out, "GeoTIFF-BigTIFF")
def read_ref_raster(region, data_server): """ Checks if reference raster for region exists, if not, creates it using B1 of a Sentinel-2 L1C product. """ # Requires snappy, currently imported in sentinel1_pre/sentinel2_pre loc_raster = os.path.join(os.environ[data_server], 'spatial_ref', region + '.dim') if os.path.isfile(loc_raster): return loc_raster else: # Import required packages import snappy from snappy import ProductIO, HashMap, GPF, jpy GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis() HashMap = snappy.jpy.get_type('java.util.HashMap') WKTReader = snappy.jpy.get_type('com.vividsolutions.jts.io.WKTReader') #Construct ref_raster # Get any s2 product available ## CHANGED TO L2A for Europe, change back to L1C for others prdlist = filter( re.compile(r'^S2.*L2A.*SAFE$').search, os.listdir(set_data_dir(region, 'S2', data_server))) first_product = prdlist[0] # Read reference product ref_product = ProductIO.readProduct( os.path.join(set_data_dir(region, 'S2', data_server), first_product)) # Resample all bands to 10m resolution resample_subset = HashMap() resample_subset.put('targetResolution', 10) resampled = GPF.createProduct('Resample', resample_subset, ref_product) # Subset to area of interest param_subset = HashMap() param_subset.put('geoRegion', read_aoi(region, data_server)) param_subset.put('outputImageScaleInDb', False) param_subset.put('bandNames', 'B1') subset = GPF.createProduct("Subset", param_subset, resampled) # Write file ProductIO.writeProduct(subset, loc_raster, 'BEAM-DIMAP') return loc_raster
def convertDim2Tiff(input_dim, output_file, name_file, format_file='float32', type_file='GeoTIFF'): if debug >= 2: print(cyan + "convertDim2Tiff() : " + bold + green + "Import Dim to SNAP : " + endC + input_dim) # Info input file product = ProductIO.readProduct(input_dim) band = product.getBand(name_file) width = product.getSceneRasterWidth() height = product.getSceneRasterHeight() # 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', 1) # Get des expressions d'entréées targetBand = BandDescriptor() targetBand.name = 'band_0' targetBand.type = format_file targetBand.expression = name_file targetBands[0] = targetBand # Set des parametres parameters = HashMap() parameters.put('targetBands', targetBands) result = GPF.createProduct(operator, parameters, product) ProductIO.writeProduct(result, output_file, type_file) if debug >= 2: print(cyan + "convertDim2Tiff() : " + bold + green + "Writing Done : " + endC + str(output_file)) return
def resize(sarImgDir, imgDst=None, maxSize=400): ''' Get water body of reservoir from a tif image :type sarImgDir: string :type imgDst: string :type maxSize: int :param sarImgDir: directory to sentinel-1 .tif image :param imgDst: directory to resized image. If none, use default name :param maxSize: maximum value of width and height after resizing :return: string - directory to resized image ''' import math from snappy import jpy from snappy import ProductIO from snappy import GPF from snappy import HashMap GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis() HashMap = jpy.get_type('java.util.HashMap') p = ProductIO.readProduct(sarImgDir) firstBand = p.getBands()[0] width = firstBand.getRasterWidth() height = firstBand.getRasterHeight() ratio = width / height parameters = HashMap() if ratio <= 1: parameters.put('targetHeight', maxSize) parameters.put('targetWidth', math.ceil(maxSize * ratio)) else: parameters.put('targetWidth', maxSize) parameters.put('targetHeight', math.ceil(maxSize / ratio)) product = GPF.createProduct('Resample', parameters, p) if imgDst is None: sourceName = imgDir.split('/')[:-4] imgDst = sourceName + '_resized.tif' ProductIO.writeProduct(product, imgDst, 'GeoTiff') del p, product print('Done.') return imgDst
def thermal_noise_removal_gpt(product): logger = logging.getLogger('root') fname = product.getName() logger.info("writing product for thermal noise removal") ProductIO.writeProduct(product, sarIn + "/" + fname + '.dim', "BEAM-DIMAP") logger.info("finished writing. proceeding with gpt ThermalNoiseRemoval") product.dispose() subprocess.call([ '/users/stud09/martinsd/local/snap/bin/gpt', 'ThermalNoiseRemoval', '-SsourceProduct=' + sarIn + '/' + fname + '.dim', '-PselectedPolarisations=VV', '-PremoveThermalNoise=true', '-t', sarIn + '/' + fname + '.dim' ]) result = ProductIO.readProduct(sarIn + "/" + fname + '.dim') logger.info("finished thermal noise removal") return (result)
def subset_s1(path, file, aoi): # Read Data________________________________________________________________ print("SUBSET: Read Product...") sentinel = ProductIO.readProduct(path+file) print("SUBSET: Done reading!") name = sentinel.getName() print(name) # Get Polarisation and Name pols = ['VV'] # WISHLIST only VV works right now, should be changed to HH and VH for p in pols: print("SUBSET: calibration: %s" % p) polarization = p # Preprocessing________________________________________________________ # Calibration parameters = HashMap() parameters.put('outputSigmaBand', True) parameters.put('sourceBands', 'Intensity_' + polarization) parameters.put('selectedPolarisations', polarization) parameters.put('outputImageScaleInDb', False) calib = path + file + "_calibrate_" + polarization target_0 = GPF.createProduct("Calibration", parameters, sentinel) ProductIO.writeProduct(target_0, calib, 'BEAM-DIMAP') calibration = ProductIO.readProduct(calib + ".dim") # Geojson to wkt with open(aoi) as f: gjson = json.load(f) for feature in gjson['features']: polygon = (feature['geometry']) str_poly = json.dumps(polygon) gjson_poly = geojson.loads(str_poly) poly_shp = shape(gjson_poly) wkt = poly_shp.wkt # Subset geom = WKTReader().read(wkt) subsettings = HashMap() subsettings.put('geoRegion', geom) subsettings.put('outputImageScaleInDb', False) # Write Data_______________________________________________________ print("SUBSET: Writing subset.") subset = path + file + "_subset_" + polarization target_1 = GPF.createProduct("Subset", subsettings, calibration) ProductIO.writeProduct(target_1, subset, 'BEAM-DIMAP') print("SUBSET: Done and saved in %s" % path)
def pre_process(files, dest, nameFunc=defaultNaming): # List to keep track of processed image paths output = [] # Iterates through list of files print('Starting...') for i in files: print('Reading product...') # Try reading the file path by itself try: product = ProductIO.readProduct(i) except: # Try reading a product.xml within the file try: print('Checking product.xml...') product = ProductIO.readProduct(os.path.join(i, 'product.xml')) except: print('Snap could not read product: %s' % i) continue print('Applying corrections...') # Apply preprocessing calibratedProduct = do_calibration(product) spkFilterProduct = do_speckle_filter(calibratedProduct) terCorrectedProduct = do_terrain_correction(spkFilterProduct) print('Creating product...') # Saving new product name = os.path.join(dest, nameFunc(i) + '.tif') ProductIO.writeProduct(terCorrectedProduct, name, 'GeoTiff') # Properly dispose in memory and close product.dispose() product.closeIO() output.append(name) return output
def BandMath(stack): product = ProductIO.readProduct(stack) band_names = product.getBandNames() print(list(band_names)) band1 = input("Enter Band 1:") band2 = input("Enter Band 2 which will be subtracted:") GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis() ## Band Math targetBands = jpy.array( 'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 2) #print('{}_minus_{}'.format(bandlist[x], bandlist[y])) targetBand1 = BandDescriptor() targetBand1.name = '{}_minus_{}'.format(band1, band2) targetBand1.type = 'float32' #targetBand1.expression = '(({} - {})<(-2))? 255 : 0'.format(band1, band2) targetBand1.expression = '(({} - {})<(-2))? 255 : 0'.format(band1, band2) parameters = HashMap() parameters.put('targetBands', targetBands) result = GPF.createProduct('BandMaths', parameters, product) print("Writing...") ProductIO.writeProduct(result, '{}_minus_{}.dim'.format(band1, band2), 'BEAM-DIMAP') print('{}_minus_{}.dim Done.'.format(band1, band2))
def write_product(self, src_data, trg_file_path, trg_file_format='BEAM-DIMAP'): # Parameter: - src_data <SAR Object> : An object ('Product') of Sentinel SAR dataset # - trg_file_path <string> : A string containing the path to the output Sentinel SAR dataset and it's name file. # - trg_file_format <supported-format>: BEAM-DIMAP, GeoTIFF, NetCDF, ... # ------------------------------------------------------------------------------------------------------------------------------ # ATTENTION, in case of: # RuntimeError: java.lang.OutOfMemoryError: Java heap space # ------------------------------------------------------------------------------------------------------------------------------ # SOLUTION 1: # (http://forum.step.esa.int/t/snappy-error-productio-writeproduct/1102) # # 1. CHANGE <snappy>/jpyconfig.py: # jvm_maxmem = None ----> jvm_maxmem = '6G' # Increase RAM # # 2. CHANGE <snappy>/snappy.ini: # # java_max_mem: 4G ----> java_max_mem: 6G # Remove '#' and increase RAM # ------------------------------------------------------------------------------------------------------------------------------ # SOLUTION 2: # If you swapped Latitude/Longitude in POLYGON(...) there is also a out-of-memory-error # ProductIO.writeProduct(src_data, trg_file_path, trg_file_format)
def process(ziplist): product_set = [] for f in ziplist: f = os.path.splitext(f)[ 0] #pretty dirty works only with zip, because filenam is cut. f = _process(f) product_set.append(f) print("Creating Stack with", len(product_set), "bands") if len(product_set) <= 1: ##RuntimeError: org.esa.snap.core.gpf.OperatorException: Please select at least two source products parameters = HashMap() parameters.put('resamplingType', None) parameters.put('initialOffsetMethod', 'Orbit') parameters.put('extent', 'Master') create_stack = GPF.createProduct('CreateStack', parameters, product_set[0]) #write the stack ProductIO.writeProduct(create_stack, 'create_stack.dim', 'BEAM-DIMAP') print('Single Product created') else: parameters = HashMap() parameters.put('resamplingType', None) parameters.put('initialOffsetMethod', 'Product Geolocation') parameters.put('extent', 'Master') ## Linear to dB create_stack = GPF.createProduct('CreateStack', parameters, product_set) #write the stack ProductIO.writeProduct(create_stack, 'create_stack.dim', 'BEAM-DIMAP') #ProductIO.writeProduct(terrain_correction, s1_identifier + '.tif', "GeoTIFF-BigTIFF") #ProductIO.writeProduct(terrain_correction, s1_identifier + '.dim', 'BEAM-DIMAP') print('Stack created')
print 'Product file and band index required' sys.exit(1) # check if band index given is correct if not sys.argv[2] in ['2', '3', '4', '8']: print 'Incorrect band index' # get cli arguments product_file = sys.argv[1] band_index = sys.argv[2] band_name = 'B' + band_index product_name = { 'B2': 'blue', 'B3': 'green', 'B4': 'red', 'B8': 'nir', }[band_name] # input product: open and get dimensions & name input_product = ProductIO.readProduct(product_file) product_width = input_product.getSceneRasterWidth() product_height = input_product.getSceneRasterHeight() product_name = input_product.getName() # output product: copy selected band & save product output_product = Product(product_name, product_name, product_width, product_height) ProductUtils.copyGeoCoding(input_product, output_product) ProductUtils.copyBand(band_name, input_product, output_product, True) ProductIO.writeProduct(output_product, product_name + '.band.dim', 'BEAM-DIMAP') output_product.closeIO()
import snappy from snappy import ProductIO SubsetOp = snappy.jpy.get_type('org.esa.snap.gpf.operators.standard.SubsetOp') WKTReader = snappy.jpy.get_type('com.vividsolutions.jts.io.WKTReader') if len(sys.argv) != 3: print("usage: %s <file> <geometry-wkt>" % sys.argv[0]) print(" %s ./TEST.N1 \"POLYGON((15.786082 45.30223, 11.798364 46.118263, 10.878688 43.61961, 14.722727" "42.85818, 15.786082 45.30223))\"" % sys.argv[0]) sys.exit(1) file = sys.argv[1] wkt = sys.argv[2] geom = WKTReader().read(wkt) print("Reading...") product = ProductIO.readProduct(file) op = SubsetOp() op.setSourceProduct(product) op.setGeoRegion(geom) sub_product = op.getTargetProduct() print("Writing...") ProductIO.writeProduct(sub_product, "snappy_subset_output.dim", "BEAM-DIMAP") print("Done.")
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) targetBands[0] = targetBand1 targetBands[1] = targetBand2 parameters = HashMap() parameters.put('targetBands', targetBands) result = GPF.createProduct('BandMaths', parameters, product) print("Writing...") ProductIO.writeProduct(result, 'snappy_bmaths_output.dim', 'BEAM-DIMAP') print("Done.") """ Please note: the next major version of snappy/jpy will be more pythonic in the sense that implicit data type conversions are performed. The 'parameters' from above variable could then be given as a Python dict object: parameters = { 'targetBands': [ { 'name': 'band_1', 'type': 'float32', 'expression': '(radiance_10 - radiance_7) / (radiance_10 + radiance_7)' },