Esempio n. 1
0
    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
Esempio n. 2
0
    def band_maths(self, expression):
        """
        Perform a SNAP GPF BandMath operation on the product, excluding non-vegetation and non-soil pixels.

        Args:

            expression: The band maths expression to execute
        """
        print("\tBandMaths, product={}".format(self.product.getName()))

        BandDescriptor = jpy.get_type(
            'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')

        band = BandDescriptor()
        band.name = 'band_maths'
        band.type = 'float32'
        band.expression = expression
        band.noDataValue = np.nan

        bands = jpy.array(
            'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
        bands[0] = band

        HashMap = jpy.get_type('java.util.HashMap')
        parameters = HashMap()
        parameters.put('targetBands', bands)

        self.product = GPF.createProduct('BandMaths', parameters, self.product)
        return self.product
Esempio n. 3
0
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
Esempio n. 4
0
    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")
Esempio n. 5
0
def get_band_math_config(band_name, expression):
    parameters = HashMap()
    band_descriptor = jpy.get_type('org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
    target_band = band_descriptor()
    target_band.name = band_name
    target_band.type = 'float32'
    target_band.expression = expression
    target_bands = jpy.array('org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
    target_bands[0] = target_band
    parameters.put('targetBands', target_bands)
    return parameters
Esempio n. 6
0
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 band_math(src, band_name, expression):
    parameters = HashMap()
    band_descriptor = jpy.get_type(
        'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
    target_band = band_descriptor()
    target_band.name = band_name
    target_band.type = 'float32'
    target_band.expression = expression

    target_bands = jpy.array(
        'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
    target_bands[0] = target_band
    parameters.put('targetBands', target_bands)

    return GPF.createProduct("BandMaths", parameters, src)
Esempio n. 8
0
def sigma_naught(product):
    targetBands = jpy.array(
        'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
    targetBand1 = BandDescriptor()
    targetBand1.name = 'sigma_int'
    targetBand1.type = 'Int32'
    targetBand1.expression = 'round(log10(Sigma0_VV)*1000)'

    targetBands[0] = targetBand1

    parameters = HashMap()
    parameters.put('targetBands', targetBands)

    result = GPF.createProduct('BandMaths', parameters, product)
    return (result)
Esempio n. 9
0
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
Esempio n. 10
0
def compute_vegeation_index(product, index):
    index = ''.join(index)
    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 = index
    targetBand.type = 'float32'
    targetBand.expression = indices_expr[index]
    targetBands = jpy.array(
        'org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
    targetBands[0] = targetBand
    parameters = HashMap()
    parameters.put('targetBands', targetBands)
    print("Start to compute:" + indices_expr[index])
    result = GPF.createProduct('BandMaths', parameters, product)
    print('Expression computed: ' + indices_expr[index])
    print result.getBand(index)
    return result.getBand(index)
Esempio n. 11
0
    def apply_threshold_to_product(self):
        self.temporary_data_binary = []
        snappy.GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
        BandDescriptor = jpy.get_type('org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor')
        targetBand = BandDescriptor()
        targetBand.name = 'band1'
        targetBand.type = 'float32'
        targetBand.expression = 'Sigma0_VV_db < -16.5 '
        targetBands = jpy.array('org.esa.snap.core.gpf.common.BandMathsOp$BandDescriptor', 1)
        targetBands[0] = targetBand

        for product in self.temporary_data_list:
            parameters = snappy.HashMap()
            parameters.put('name', 'Sigma0_VV_db_Threshold')
            parameters.put('targetBands', targetBands)
            binary = snappy.GPF.createProduct('BandMaths', parameters, product)
            self.temporary_data_binary.append(binary)

        self.temporary_data_list = self.temporary_data_binary
        return self.temporary_data_binary
Esempio n. 12
0
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))
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)
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.")

Esempio n. 14
0
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()

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)
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
Esempio n. 15
0
    def mosaic(self,
               src_data,
               trg_file_path,
               band_dict,
               para_dict,
               trg_file_format='GeoTIFF'):
        '''
        --------------------------------------------------------------------------------------------------------------------------------
        Function: Creates a mosaic out of a set of source products.
        --------------------------------------------------------------------------------------------------------------------------------
        Parameter: - src_data:      An object ('Product') of the S2-dataset
                   - trg_file_path: A string containing the path to the output S-2 dataset and it's name.
                   - para_dict:                                                                          
                                    - combine=<string>               Specifies the way how conditions are combined.
                                                                     Value must be one of 'OR', 'AND'.
                                                                     DEFAULT value is 'OR'.
                                                                     
                                    - crs=<string>                   The CRS of the target product, represented as WKT or authority code.
                                                                     DEFAULT value is 'EPSG:4326'.
                                                                     
                                    - northBound=<double>            The northern latitude.
                                                                     Valid interval is [-90,90].
                                                                     DEFAULT value is '75.0'. 
                                                                     
                                    - eastBound=<double>             The eastern longitude.
                                                                     Valid interval is [-180,180].
                                                                     DEFAULT value is '30.0'.
                                                                     
                                    - southBound=<double>            The southern latitude.
                                                                     Valid interval is [-90,90].
                                                                     DEFAULT value is '35.0'.
                                                                     
                                    - westBound=<double>             The western longitude.
                                                                     Valid interval is [-180,180].
                                                                     DEFAULT value is '-15.0'.                                 
                                                                     
                                    - elevationModelName=<string>    The name of the elevation model for the orthorectification.
 
                                    - orthorectify=<boolean>         Whether the source product should be orthorectified.
                                                                     DEFAULT value is 'false'.
                                                                     
                                    - pixelSizeX=<double>            Size of a pixel in X-direction in map units.
                                                                     DEFAULT value is '0.05'.
                                                                     
                                    - pixelSizeY=<double>            Size of a pixel in Y-direction in map units.
                                                                     DEFAULT value is '0.05'.
                                                                     
                                    - resampling=<string>            The method used for resampling.
                                                                     Value must be one of 'Nearest', 'Bilinear', 'Bicubic'.
                                                                     DEFAULT value is 'Nearest'.
                                                
                   - trg_file_format: A string containing the Export Format Name. e.g. 'BEAM-DIMAP', 'GeoTIFF', 'NetCDF'
                                                                     DEFAULT value is 'BEAM-DIMAP'
        --------------------------------------------------------------------------------------------------------------------------------
        How to run this code:
        
        from snappy import ProductIO
        from snappy_mosaic import mosaicOp
        
        src_path_1 = 'C:/S2/S2A_USER_MTD_SAFL2A_..._20151129T112140/S2A_USER_MTD_SAFL2A_..._20151129T112140.xml'
        src_path_2 = 'C:/S2/S2A_USER_MTD_SAFL2A_..._20151129T112141/S2A_USER_MTD_SAFL2A_..._20151129T112141.xml'
        trg_path   = 'C:/S2/S2A_USER_MTD_SAFL2A_..._20151129T112140_mos/'
        
        bands      = {'B2': 'B2'}
        para       = {'northBound': 37.4, 'eastBound': 76.8, 'southBound': 36.3, 'westBound': 75.6, \
                      'pixelSizeX': 0.001, 'pixelSizeY': 0.001}
        
        products   = []
        products.append(ProductIO.readProduct(src_path_1))
        products.append(ProductIO.readProduct(src_path_2))
        
        mosaicOp().mosaic(products, trg_path, bands, para)
        
        --------------------------------------------------------------------------------------------------------------------------------
        '''
        func_name = 'MOSAIC'
        func_code = 'Mosaic'

        parameters = self.HashMap()

        # Set variables.
        print('{}: Set variables'.format(func_name))
        variables = jpy.array('org.esa.snap.core.gpf.common.MosaicOp$Variable',
                              len(band_dict))
        for (i, band_name) in enumerate(band_dict):
            variable_i = self.Variables()
            variable_i.setName(band_name)
            variable_i.setExpression(band_dict[band_name])
            variables[i] = variable_i

        parameters.put('variables', variables)

        # Set parameters.
        print('{}: Set parameters'.format(func_name))
        BB = 0
        PS = 0
        for para_name in para_dict:
            if para_name in ('pixelSizeX', 'pixelSizeY'):
                PS = PS + 1
            if para_name in ('northBound', 'eastBound', 'southBound',
                             'westBound'):
                BB = BB + 1
            parameters.put(para_name, para_dict[para_name])

        # Set Bounding Box and Pixelsize if none was defined.
        if BB == 4 and PS == 2:
            print(
                '{}: INFO, Bounding Box Coordinates and Pixelsizes defined through User-Input'
                .format(func_name))
        elif BB == 0:
            print(
                '{}: INFO, No Bounding Box Coordinates defined through User-Input'
                .format(func_name))
            print('{}: Set Parameter Bounding Box'.format(func_name))
            bboxE, bboxW, bboxS, bboxN, pxSzNS, pxSzEW = ([] for i in range(6))

            for data in src_data:
                (b, y_EW, x_NS) = basicOp().BoundingBox(data)
                bboxE.append(b[0])
                bboxW.append(b[1])
                bboxS.append(b[2])
                bboxN.append(b[3])
                pxSzNS.append(x_NS)
                pxSzEW.append(y_EW)

            bbox = [min(bboxE), max(bboxW), min(bboxS), max(bboxN)]
            parameters.put('eastBound', bbox[1])
            parameters.put('westBound', bbox[0])
            parameters.put('southBound', bbox[2])
            parameters.put('northBound', bbox[3])

            if PS != 2:
                print('{}: Set Parameter Pixelsize'.format(func_name))
                pxSzEW_avg_m, pxSzNS_avg_m = basicOp().deg2m(
                    bbox, pxSzEW, pxSzNS)

                pxSzEW_avg_int_m = int(round(pxSzEW_avg_m / 5.0, 0) * 5.0)
                pxSzNS_avg_int_m = int(round(pxSzNS_avg_m / 5.0, 0) * 5.0)

                pxSzEW_avg_deg, pxSzNS_avg_deg = basicOp().m2deg(
                    bbox, pxSzEW_avg_int_m, pxSzNS_avg_int_m)
                print('{}: pixelSizeY: {}m'.format(func_name,
                                                   pxSzEW_avg_int_m))
                print('{}: pixelSizeX: {}m'.format(func_name,
                                                   pxSzNS_avg_int_m))

                parameters.put('pixelSizeY', pxSzEW_avg_deg)
                parameters.put('pixelSizeX', pxSzNS_avg_deg)

        elif 1 <= BB < 4:
            BB_num = ('One' if BB == 1 else 'Two'
                      if BB == 2 else 'Tree' if BB == 3 else BB.__str__())
            BB_nam = ('Coordinate' if BB == 1 else 'Coordinates')
            print('{}: {} Bounding Box {} defined by Input'.format(
                func_name, BB_num, BB_nam))
        else:
            print(
                '{}: ERROR, too many Bounding Box input coordinates ({} instead of 4) or missing Pixelsize.'
                .format(func_name, BB))
            sys.exit(1)

        # Create product.
        print('{}: Create product...'.format(func_name))
        trg_data = GPF.createProduct(func_code, parameters, src_data)

        # Save product
        # <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
        #
        print('{}: Save as {} ...'.format(func_name, trg_file_path))
        ProductIO.writeProduct(trg_data, trg_file_path, trg_file_format)

        print('{}: Done.'.format(func_name))
Esempio n. 16
0
HashMap = jpy.get_type('java.util.HashMap')
BandDescriptor = jpy.get_type(
    'org.esa.snap.gpf.operators.standard.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.gpf.operators.standard.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
Esempio n. 17
0
width = Product.getSceneRasterWidth()
os.chdir(TempFolder)
os.system(snaphu_dir + ' -f snaphu.conf ' + phasen + ' ' + str(width))
print("Phase unwrapping performed successfully ..............................")
#%%
# Snaphu import
bandList = os.listdir(TempFolder)
for item in bandList:
    if item.endswith('.hdr') and item[0:8] == 'UnwPhase':
        upha = item
print(upha)

#working_dir='D:\\PhD Info\\InSAR\\Examples\\SNAPPY_Ecuador_Galapagos'
#os.chdir (working_dir + '\\' + Fname)
#
Files = jpy.array('org.esa.snap.core.datamodel.Product', 2)
#Files[0]    = ProductIO.readProduct(os.path.join(r'D:\PhD Info\InSAR\Examples\SNAPPY_Ecuador_Galapagos','subset_0_of_InSAR_pipeline_II.dim'))
Files[0] = read(os.path.join(Fpath, Fname + '.dim'))  # reads .dim
Files[1] = ProductIO.readProduct(glob.glob(TempFolder + '\\' + upha)[0])
HashMap = jpy.get_type("java.util.HashMap")
params = HashMap()
Product = GPF.createProduct("SnaphuImport", params, Files)
os.chdir(Fpath)
ProductIO.writeProduct(Product, Fname + "_ifg_ml_fit_unwph.dim", "BEAM-DIMAP")
print("Snaphu import performed successfully .................................")
# Phase To Displacement
#Product = read(os.path.join(r'D:\PhD Info\InSAR\Examples\SNAPPY_Ecuador_Galapagos\exp_subset','subset_0_of_InSAR_pipeline_II_ifg_ml_fit_unwph.dim')) # reads .dim
params = HashMap()
Product = GPF.createProduct("PhaseToDisplacement", params, Product)
os.chdir(Fpath)
ProductIO.writeProduct(Product, Fname + '_ifg_ml_fit_unwph_disp.dim',
Esempio n. 18
0
snappy.GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
HashMap = jpy.get_type('java.util.HashMap')
Coord = jpy.get_type('org.esa.snap.pixex.Coordinate')

snow_dataset=pd.read_csv("/home/simsek/workspace/EDUCATION/Thesis/Scripts/turku_SnowCover_insitu.csv", names=["year","month","day","lat","lon","sd"])
nosnow_dataset=pd.read_csv("/home/simsek/workspace/EDUCATION/Thesis/Scripts/turku_NoSnow_insitu.csv", names=["year","month","day","lat","lon","sd"])
snow_coords=np.asarray(nosnow_dataset[["lat","lon"]].drop_duplicates())
n=np.asarray(nosnow_dataset[["lat","lon"]].drop_duplicates()).shape[0]


## Parameters for resampling
resampling_parameters = HashMap()
resampling_parameters.put('targetResolution', 60)
## Parameters for Pixel extraction
insitu_coordinates = jpy.array('org.esa.snap.pixex.Coordinate',n)
for i in range(n):
    insitu_coordinates[i] = Coord('station'+str(i), snow_coords[i,0], snow_coords[i,1], None)
#insitu_coordinates[0] = Coord('station0', 61.00, 24.5, None)
# insitu_coordinates[1] = Coord('station1', 60.82, 23.5, None)
# insitu_coordinates[2] = Coord('station2', 60.45, 23.65, None)
# insitu_coordinates[3] = Coord('station3', 60.65, 23.81, None)
# insitu_coordinates[4] = Coord('station4', 60.52, 24.65, None)
# insitu_coordinates[5] = Coord('station5', 61.12, 24.33, None)
# insitu_coordinates[6] = Coord('station6', 60.37, 23.12, None)

print(insitu_coordinates[8])
pixex_parameters = HashMap()
pixex_parameters.put('PexportBands', 1)
pixex_parameters.put('PexportExpressionResult', 0)
pixex_parameters.put('PexportMasks', 0)
Esempio n. 19
0
GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()

HashMap = jpy.get_type('java.util.HashMap')
BandDescriptor = jpy.get_type('org.esa.snap.gpf.operators.standard.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.gpf.operators.standard.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.")