junk

import glob
import os
import snappy
import gc
import shutil
from snappy import ProductIO, GPF

# from rsgislib.segmentation import segutils

# Get snappy Operators
snappy.GPF.getDefaultInstance().getOperatorSpiRegistry().loadOperatorSpis()
# HashMap Key-Value pairs
HashMap = snappy.jpy.get_type('java.util.HashMap')
gc.enable()
# Working directory
input_dir = "/mnt/DD/Bonds_Project/Aurea_Project/Input/troncon/A/3/"
images_list = []
s1list = []


def polarisation (img):
    # return polarisation from input text
    # for  Naming purpose
    if 'VV' in img:
        return 'VV'
    elif 'VH' in img:
        return 'VH'


def correctpolarisation(img):
    # return correct polarisation from input text
    # parameters purpose
    if 'VV' or 'Vv' or 'vV' or 'vv' in img :
        return 'Sigma0_VV'
    elif 'Vh' or 'vH' or 'VH' or 'vh' in img:
        return 'Sigma0_VH'
    else :
        print('Invalid polarisation')


class Image:
    # Object Image for multi correction and optionnal correction purposes
    VVcalibFile = ''
    coregistrationlist = []

    def __init__(self, path):
        # Basic attributes
        self.path = path
        # self.imgpath = ProductIO.readProduct(path)
        self.timestamp = path.split('_')[6:7]
        # Orbit file
        self.orbFile = ''
        self.orb = False
        # Calibrated
        self.VVcalibFile = ''
        self.VHcalibFile = ''
        self.calib = False
        # Terrain correction
        self.VVterrainFlatFile = ''
        self.VHterrainFlatFile = ''
        self.terr = False
        self.VVorthoCorrFile = ''
        self.VHorthoCorrFile = ''
        self.orth = False
        self.VHorthFile = ''
        self.VVorthFile = ''
        # Speckle filter
        self.VVspeckFile = ''
        self.VHspeckFile = ''
        self.speck = False
        # Decibel
        self.VVdBFile = ''
        self.VHdBFile = ''
        self.dB = False
        # meanstack
        self.stack = False
        self.VVmeanFile = ''
        self.VHmeanFile = ''
        # Border Noise
        self.VVbordernoiseFile = ''
        self.VHbordernoiseFile=''
        self.bordernoise= False

    def getPath(self):
        return self.path

    def setPath(self, path):
        self.path = path

    def silentDelete(self, correction):
        try:
            toRemove = getattr(self, 'correction')
            os.remove(toRemove)
            os.rmdir(correction)
        except OSError:
            print('could not delete directory doesnt exists')
            pass
        except AttributeError:
            print('could not find attribute')
            pass

    def deleteOnceDone(self):
        try:
            print('deleting stuff')
            for things in os.listdir(input_dir):
                if ''.join(self.timestamp) in things and things.endswith('.data') and 'orth' not in things:
                    print(things + ' is going to the recycle bin')
                    shutil.rmtree(things)
        except OSError:
            print('error deleting data folder')
            pass

    def getTimestamp(self):
        return self.timestamp

    def setTimestamp(self, path):
        self.timestamp = path.split('_')[6:7]
        return self.timestamp

    def determineTimeStamp(self):
        self.timestamp = self.path.split('_')[6:7]

    def customTimeStamp(self, usertimestamp):
        # we want to set a timestamp with the given timestamp argument
        self.timestamp = usertimestamp

    def datafolder(self, cor):
        # on veut creer une fonction qui renvoie une chaine de caractere path  pour un object image
        # de type /inputdir/string_timestamp.data/
        data = ''
        try:
            dim = getattr(self, cor)
            if dim:
                data = dim.split('.')[:-1] + 'data/'
        except AttributeError:
            print('Invalid Attribute')
            pass
        return data

    def openImg(self):
        # Open image with Snap reader
        res = ProductIO.readProduct(self.path)
        return res

    def applyOrbit(self):
        # first step to apply orbitfile
        """
        Applying orbit on S1 GRD Object Image File

        """
        if self.orb:
            print('file already exists')
        elif "orb_" + ''.join(self.getTimestamp()) + '.dim' in os.listdir(input_dir):
            self.orbFile = input_dir + "orb_" + ''.join(self.getTimestamp())
            print('file has already been proccessed')
            pass
        else:

            # ---------initialisation des parametres
            parameters = HashMap()
            # ---------Input
            orbit_param = snappy.GPF.createProduct("Apply-Orbit-File", parameters, ProductIO.readProduct(self.path))
            #
            # --------Output
            self.orbFile = input_dir + "orb_" + ''.join(self.getTimestamp())
            ProductIO.writeProduct(orbit_param, self.orbFile,
                                   'BEAM-DIMAP')  # on cree un objet qu'on rempli avec le tableau image
            print(str(self.getTimestamp()) + " is done ")
            # ---------Return values
            self.orb = True
            return self.orbFile, self.orb

    def applyCalibration(self):
        """
        Input:  Amplitude_VH, Intesity_VH, Amplitude_VV, Intensity_VV : an orbite file corrected
        output: beta0_VH, beta0_VV : a calibrated image file
        """
        print("Now applying calibration")
        if self.calib:
            print('file already exists')
            pass
        elif 'VVcalib_' + ''.join(self.getTimestamp()) + '.dim' in os.listdir(input_dir):
            self.VVcalibFile = input_dir + 'VVcalib_' + ''.join(self.getTimestamp())
            self.VHcalibFile = input_dir + 'VHcalib_' + ''.join(self.getTimestamp())
            print(' file has already been calibrated')
            pass
        else:
            # initialisation des parametres
            parameters = HashMap()
            parameters.put('outputSigmaBand', True)
            parameters.put('outputBetaBand', False)
            parameters.put('outputGammaBand', False)
            parameters.put("outputImageScaleInDb", False)
            parametersVH = parameters
            parameters.put('Polarisations', 'VV')
            parametersVH.put('Polarisations', 'VH')
            self.VVcalibFile = input_dir + "VVcalib_" + ''.join(self.getTimestamp())
            self.VHcalibFile = input_dir + 'VHcalib_' + ''.join(self.getTimestamp())
            calib_param = snappy.GPF.createProduct("Calibration", parameters,
                                                   ProductIO.readProduct(self.orbFile + '.dim'))
            calib_paramVH = snappy.GPF.createProduct("Calibration", parametersVH,
                                                     ProductIO.readProduct(self.orbFile + '.dim'))

            # ----Writing
            # ---VV
            ProductIO.writeProduct(calib_param, self.VVcalibFile, 'BEAM-DIMAP')
            print(str(self.VVcalibFile) + " is done")
            # ----VH
            ProductIO.writeProduct(calib_paramVH, self.VHcalibFile, 'BEAM-DIMAP')
            print(str(self.VHcalibFile) + " is done")
            self.calib = True
            # Deleting old stuff
            # print('trying to free disk space')
            # if self.orb:
            #     try:
            #         for things in input_dir + 'orb_' + ''.join(self.getTimestamp()) + '.data/':
            #             os.remove(things)
            #         os.removedirs(input_dir + 'orb_' + ''.join(self.getTimestamp()) + '.data/')
            #         print('orbfile has been removed')
            #     except OSError:
            #         print('nothing to delete')
            #         pass
            return self.VVcalibFile, self.VHcalibFile, self.calib

    def borderNoiseremoval(self, img, pol = '', output=''):
        outputname = ''
        print('applying Border Noise removal op on ' + self.path)
        if self.bordernoise:
            print('file has already been corrected')
        else:
            parameters = HashMap()
            if polarisation:
                parameters.put('sourceBands',correctpolarisation(pol))
                if not output:
                    outputname = input_dir+'_' + polarisation(pol) + '_' + ''.join(self.getTimestamp())+'.dim'
                    if 'VV' in outputname:
                        self.VVbordernoiseFile = outputname
                    elif 'VH' in outputname:
                        self.VHbordernoiseFile = outputname
            else :
                if not output:
                    outputname = input_dir+''.join(self.getTimestamp()+'.dim')
            print(parameters)
            print('outputname' + outputname)
            # Reading
            ProductIO.readProduct(getattr((self, img)))
            # Writing
            brf
            ProductIO.writeProduct()



    def applySpeckleFilter(self, img, polarisation, output='',corVV=):
        corVV =
        corVH =
        # fonction qui permet de retirer le speckle d'une image radar, Gamma 0 en input
        print("Now applying speckle filtering")
        # check if file has already been speckle filtered
        if self.speck:
            print("file already exists")
        elif "VVspeck_" + ''.join(self.getTimestamp()) + '.dim' in os.listdir(input_dir):
            self.VVspeckFile = input_dir + "VVspeck_" + ''.join(self.getTimestamp())
            self.VHspeckFile = input_dir + "VHspeck_" + ''.join(self.getTimestamp())
            print('file has already been proccessed')
            pass
        else:
            # Validity Check
            try:
                VVInput = getattr(self, corVV)
                VHInput = getattr(self, corVH)
            except AttributeError:
                print (' correction does not exist')
                pass

            if VVInput or VHInput:
                # -----------------initialisation des parametres--------
                parameters = HashMap()
                # parameters.put('sourceBands', 'Sigma0_VV','Sigma0_VH')
                # parameters.put('numberofLooks', 4)
                parameters.put('filter', 'Lee Sigma')
                parameters.put('windowSize', "5x5")
                parameters.put('sigma', 0.9)
                parameters.put('targetWindowSize', "5")
                parametersVH = parameters
                parameters.put('sourceBands', 'Sigma0_VV')
                # ---------- Output----------
                self.VVspeckFile = input_dir + "VVspeck_" + ''.join(self.getTimestamp())
                self.VHspeckFile = input_dir + "VHspeck_" + ''.join(self.getTimestamp())
                # ----------Reading-------
                # VV
                VVspeck_param = snappy.GPF.createProduct("Speckle-Filter", parameters,
                                                         ProductIO.readProduct(VVInput + '.dim'))
                # VH
                parametersVH.put('sourceBands', 'Sigma0_VH')
                VHspeck_param = snappy.GPF.createProduct("Speckle-Filter", parametersVH,
                                                         ProductIO.readProduct(VHInput + '.dim'))
                # ------- Writing--------
                # VV
                print(" Using speckefiltering on " + str(self.VVspeckFile))
                ProductIO.writeProduct(VVspeck_param, self.VVspeckFile, 'BEAM-DIMAP')
                print(str(self.VVspeckFile) + "is done")
                # VH
                print(" Using speckefiltering on " + str(self.VVspeckFile))
                ProductIO.writeProduct(VHspeck_param, self.VHspeckFile, 'BEAM-DIMAP')
                print(str(self.VHspeckFile) + "is done")
                # -------- Return values and deleting---------
                self.speck = True
                return self.VVspeckFile, self.VHspeckFile, self.speck

    def applyTerrainCorrection(self):
        # Apply Terrain Flattening on a  Calibrated file
        VVcalibFile = ''
        print "Now applying terrain correction"
        # LEt us check if it exists
        if self.terr:
            print('file already exists')
        elif 'VVterr_' + ''.join(self.getTimestamp()) + '.dim' in os.listdir(input_dir):
            print('file has already been calibrated adding to desc')
            self.VVterrainFlatFile = input_dir + 'VVterr_' + ''.join(self.getTimestamp())
            self.VHterrainFlatFile = input_dir + 'VHterr_' + ''.join(self.getTimestamp())
        else:
            # Output
            print('applying terrain flattening operator')
            self.VVterrainFlatFile = input_dir + "VVterr_" + ''.join(self.getTimestamp())
            self.VHterrainFlatFile = input_dir + 'VHterr_' + ''.join(self.getTimestamp())

            # ---------Parameters-------
            parameters = HashMap()
            # parameters.put('demName', 'SRTM 3Sec')
            # dempath = '/mnt/DD/Bonds_Project/Hardi_Process/dem/srtm_26_13.zip'
            # parameters.put('mapProjection', proj)
            # parameters.put('externalDEMFile', 'dempath')
            # parameters.put('pixelSpacingInMeter', '10.0')
            parameters.put('demName', 'SRTM 1sec HGT')
            parameters.put('demResamplingMethod', 'BILINEAR_INTERPOLATION')
            parameters.put('additionalOverlap', 0.1)
            parameters.put('OversamplingMultiple', 1.5)
            parametersVH = parameters
            parameters.put('sourceBands', 'Sigma0_VV')
            parametersVH.put('sourceBands', 'Sigma0_VH')

            # ----------Reading --------
            # ----Creating the product
            # --  VV  --
            # we fetch the input , the input shall be a calibrated sar file so we are checking if it exists
            try:
                VVspeckle = getattr(self, "VVspeckFile")
                print('doing VV, VV calib File is : ' + VVspeckle)
            except AttributeError:
                print('No VVspecklefile')
                pass
            if VVspeckle:  # We assume VH exists if VV exists , thus reading
                # ------------Reading
                VVterr_param = snappy.GPF.createProduct("Terrain-Flattening", parameters,
                                                        ProductIO.readProduct(self.VVspeckFile + '.dim'))
                # --  VH  --
                VHterr_param = snappy.GPF.createProduct("Terrain-Flattening", parametersVH,
                                                        ProductIO.readProduct(self.VHspeckFile + '.dim'))
                # ----- Writing----
                ProductIO.writeProduct(VVterr_param, self.VVterrainFlatFile, 'BEAM-DIMAP')
                print str(self.VVterrainFlatFile) + " is done "

                ProductIO.writeProduct(VHterr_param, self.VHterrainFlatFile, 'BEAM-DIMAP')
                print str(self.VHterrainFlatFile) + " is done "

                # ------------Deleting useless stuff and returning values -------
                self.terr = True
                return self.VVterrainFlatFile, self.VHterrainFlatFile, self.terr

            else:  # Condition if VV doesnt exist( '' chain )
                print('Image not calibrated')
                pass

    def applyOrthorectification(self):
        # Validity check
        VVspeckFile = ''
        #  Correction of geometry of object images , Input = Gamma0 terrain flattened file only
        print("Now applying Orthorectification")
        if self.orth:
            print("file already exists")

        elif 'VVorth_' + ''.join(self.getTimestamp()) + '.dim' in os.listdir(input_dir):
            print('file has already been geo corrected adding to desc')
            self.VVorthoCorrFile = input_dir + "VVorth_" + ''.join(self.getTimestamp())
            self.VHorthoCorrFile = input_dir + 'VHorth_' + ''.join(self.getTimestamp())

        else:
            # Validity checked
            try:
                VVspeckFile = getattr(self, "VVspeckFile")
                print('doing VV, VV speckFile is : ' + VVspeckFile)
            except AttributeError:
                print('No VVspeckFile')
                pass

            if VVspeckFile:
                # -------initialisation des parametres
                parameters = HashMap()
                parameters.put('demResamplingMethod', 'BICUBIC_INTERPOLATION')
                parameters.put('demName', 'SRTM 1Sec HGT')
                parametersVH = HashMap()
                parametersVH.put('demResamplingMethod', 'BICUBIC_INTERPOLATION')
                parametersVH.put('demName', 'SRTM 1Sec HGT')
                # parametersVH.put('sourceBands', 'Sigma0_VH')
                # parameters.put('sourceBands', 'Sigma0_VV')
                print parameters
                print parametersVH
                print VVspeckFile
                # ------------Output----
                self.VVorthoCorrFile = input_dir + "VVorth_" + ''.join(self.getTimestamp())
                self.VHorthoCorrFile = input_dir + 'VHorth_' + ''.join(self.getTimestamp())
                # --------Reading---------
                # VH
                print('VH speckfile is ' + self.VHspeckFile)
                VHorth_param = snappy.GPF.createProduct("Terrain-Correction", parametersVH,
                                                        ProductIO.readProduct(self.VHspeckFile + '.dim'))
                # VV
                VVorth_param = snappy.GPF.createProduct("Terrain-Correction", parameters,
                                                        ProductIO.readProduct(self.VVspeckFile + '.dim'))
                # --------writing-------
                # VV
                ProductIO.writeProduct(VVorth_param, self.VVorthoCorrFile, 'BEAM-DIMAP')
                print(str(self.VVorthoCorrFile + ''.join(self.getTimestamp()) + " is done "))
                # VH
                ProductIO.writeProduct(VHorth_param, self.VHorthoCorrFile, 'BEAM-DIMAP')
                print(str(self.VHorthoCorrFile + ''.join(self.getTimestamp()) + 'is done '))

                # ------- Return values and deleting useless stuff
                self.orth = True
                return self.VVorthoCorrFile, self.VHorthoCorrFile, self.orth

            else:
                print('file has not been terrain corrected')
                pass

    def convertToDecibel(self):
        # imgFileVV = ''
        # imgFileVH = ''
        # Convert an img to decibel, cor is actually the type of correction one may set to dB
        if self.dB:
            # check if file has already been orthorectified
            print("file already exists")
        elif "VVdB_" + ''.join(self.getTimestamp()) + '.dim' in os.listdir(input_dir):
            self.VVdBFile = input_dir + "VVdB_" + ''.join(self.getTimestamp())
            self.VHdBFile = input_dir + "VHdB_" + ''.join(self.getTimestamp())
            print('file has already been proccessed')
            pass
        else:
            # There are 2 possible inputs, one is a terrain corrected image (orth)
            # The other is a mean raster which wont have a true stack attribute
            # both will have either VV or VH ,
            # corvv = {VVmeanFile, VVorthoCorrFile } , corvh = { VHmeanFile, VHorthoCorrFile}
            try:
                print("Now converting to dB")
                print ("converting Linear to decibel for " + ''.join(self.getTimestamp()))
                # -------Output
                # VV , we can insert a try statement here to safe proof the run in case of an unlikely error
                self.VVdBFile = input_dir + "VVdB_" + ''.join(self.getTimestamp())
                # VH
                self.VHdBFile = input_dir + "VHdB_" + ''.join(self.getTimestamp())
                # initialisation des parametres
                parameters = HashMap()
                parametersVH = parameters
                # parameters.put('sourceBands', 'Sigma0_VV')
                # parametersVH.put('sourceBands', 'Sigma0_VH')
                # Reading
                VVdb_param = snappy.GPF.createProduct("LinearToFromdB", parameters,
                                                      ProductIO.readProduct(self.VVorthoCorrFile + '.dim'))
                VHdb_param = snappy.GPF.createProduct("LinearToFromdB", parametersVH,
                                                      ProductIO.readProduct(self.VHorthoCorrFile + '.dim'))
                # Writing

                ProductIO.writeProduct(VVdb_param, self.VVdBFile, 'GeoTIFF-BigTIFF')
                print str(self.VVdBFile) + "is done"
                ProductIO.writeProduct(VHdb_param, self.VHdBFile, 'GeoTIFF-BigTIFF')
                print str(self.VHdBFile) + "is done"
                # Return  values
                self.dB = True
                return self.VVdBFile, self.VHdBFile, self.dB
            except AttributeError:
                print('correction doesnt exists')
                pass

    def converToDecibel(self):
        # We want a function wich take a object , read it into an image and the nperform convert to DB OP
        try:
            print('Converting to DB')
            # Output
            # polarisation = ''
            if 'VV' in self.path:
                polarisation = 'VV_'
            elif 'VH' in self.path:
                polarisation = 'VH_'
            else:
                polarisation = ''
            output = input_dir + '/dB_' + polarisation + ''.join(self.getTimestamp())
            # Reading
            im = ProductIO.readProduct(self.path)
            parameters = HashMap()
            dbparam = snappy.GPF.createProduct("LinearToFromdB", parameters, im)
            # Writing
            ProductIO.writeProduct(dbparam, output, 'GeoTIFF')
        except OSError:
            print('Invalid')

    def stackRegistration(self):
        stacklist = []
        ProductIO.readProduct(self).append(stacklist)
        self.stack = True
        return stacklist, self.stack

    def addtoCoRegistration(self, coregistrationlist=None):
        coregistrationlist.append(ProductIO.readProduct(self.path))
        return coregistrationlist


def imageSearch(folder, extension):
    for images in os.listdir(folder):
        if images.endswith(extension):
            images_list.append(folder + images)
    print("listes d'images: " + str(images_list))
    return images_list


def createstack(polarisation, stack):
    if os.path.isfile(input_dir + "/+" + polarisation + 'stack*'):
        print "file already exists"
    else:
        print "creating stack"
        # initialisation des parametres
        parameters = HashMap()  # initialise le dico pour les parametres
        parameters.put('extent', 'Master')
        parameters.put('initialOffsetMethod', 'Product Geolocation')
        parameters.put('ResamplingType', 'None')
        parameters.put('FindOptimalMaster', 'True')
        # recherche des images pour le stack
        create_stack = GPF.createProduct("CreateStack", parameters, stack)
        output = input_dir + '/stackVV'
        ProductIO.writeProduct(create_stack, output, 'BEAM-DIMAP')


def createS1Imglist(inputfolder='', extension='zip'):
    if inputfolder:
        folder = inputfolder
    else:
        folder = "/mnt/DD/Bonds_Project/Aurea_Project/Input/2017/"
    imageSearch(folder, extension)  # The goal here is to fetch a list of path and give it to our variable object
    for path in images_list:
        # a list  named s1list will be created and will get line of path for each image into the path attribute
        s1list.append(Image(path))
    return s1list, images_list


# def checkDone(self,targetdirectory):
#     # We want to create a function which search a folder in order to determine if some process has been done
#     # so first we want using the timestamp (which differentiate one image from another ) to search the folder
#     correctionlist = ['calibVH_','calibVV_','orb_','speckVH_','speckVV_','VHterr_','VVterr_']
#     for time in glob.glob(targetdirectory):
#         if ''.join(self.getTimestamp()) in time:
#             for correction in correctionlist:
#                 if time.startswith(correction):
#                     self.

def demCoregistration():
    print('doing dem coregistration')
    nom_image_list = []
    nom_image_list2 = []
    stack = []
    stack2 = []
    for img in glob.glob(input_dir + '/VVorth*'):
        print(str(img))
        if '.dim' in img:
            nom_image_list.append(img)
    for imgVH in glob.glob(input_dir + '/VHorth*'):
        print(str(imgVH))
        if '.dim' in imgVH:
            nom_image_list2.append(imgVH)
    print(str(nom_image_list))
    print(str(nom_image_list2))
    print str(stack)
    # on cree l'objet product permettant de faire la coregistration
    for f in nom_image_list:
        stack.append(ProductIO.readProduct(f))
    for g in nom_image_list2:
        stack2.append(ProductIO.readProduct(g))
    # initialisation des parametres
    parameters = HashMap()
    parameters.put('demName', 'SRTM 1Sec HGT')
    parameters.put('demResamplingMethod', 'BICUBIC_INTERPOLATION')
    parameters.put('ResamplingType', 'BICUBIC_INTERPOLATION')
    parametersVH = parameters
    parameters.put('sourceBands', 'Sigma0_VV')
    parametersVH.put('sourceBands', 'Sigma0_VH')
    # on cree la sortie
    outfile = input_dir + '/coregistrationVV'
    outfile2 = input_dir + '/coregistrationVH'
    print "destination folder is " + str(outfile)
    param = snappy.GPF.createProduct("DEM-Assisted-Coregistration", parameters, stack)
    ProductIO.writeProduct(param, outfile, 'BEAM-DIMAP')
    print('doing VH ')
    param2 = snappy.GPF.createProduct("DEM-Assisted-Coregistration", parametersVH, stack2)
    ProductIO.writeProduct(param2, outfile2, 'BEAM-DIMAP')


def doCoregistration(imglist, polarisation, outputname, dem=''):
    # function which take an string of img list convert it into objects images and coregistrate everything
    stack = []
    for img in imglist:
        stack.append(ProductIO.readProduct(img))
    parameters = HashMap()
    parameters.put('sourceBands', polarisation)
    if not dem:
        parameters.put('demName', 'SRTM 1Sec HGT')
    else:
        parameters.put('demName', dem)
    parameters.put('demResamplingMethod', 'BICUBIC_INTERPOLATION')
    coregisterfile = snappy.GPF.createProduct('DEM-Assisted-Coregistration', parameters, stack)
    ProductIO.writeProduct(coregisterfile, outputname, 'BEAM-DIMAP')


def stackaveraging(img, polarisation, outputname):
    # On cree une fonction permettant de calculer la moyenne de l'ensemble des bandes d'un stack par pixels
    print 'stack averaging'
    # initialisation des parametres
    parameters = HashMap()
    parameters.put('Statistic', 'Mean Average')
    parameters.put('sourceBands', polarisation)
    stack = ProductIO.readProduct(img)
    # creation of the output
    output = input_dir + '/meanraster/meanraster.dim'
    createmeanraster = snappy.GPF.createProduct("Stack-Averaging", parameters, stack)
    ProductIO.writeProduct(createmeanraster, output, 'BEAM-DIMAP')
    # Converting ASAP to DB
    print 'converting to dB'
    parameters2 = HashMap()
    # Just in case
    parameters2.put('sourceBands', polarisation)
    db_param = snappy.GPF.createProduct("LinearToFromdB", parameters2,
                                        ProductIO.readProduct(output))
    ProductIO.writeProduct(db_param, input_dir + outputname, 'GeoTIFF-BigTIFF')
    print('dbmeanraster is done')


def run(inputfolder=''):
    if inputfolder:
        os.chdir(inputfolder)
        currentDir = os.getcwd()
        print(currentDir)
        createS1Imglist(inputfolder)
        if not s1list:
            print('list is empty, filling list')
            for s1 in images_list:
                s1list.append(Image(s1))
    else:
        inputfolder = input_dir
        os.chdir(input_dir)
        createS1Imglist(inputfolder)

    print('Step 1 , Preprocessing Image0s ')

    for s1img in s1list:
        if isinstance(s1img, Image):
            # Check if it is an object image
            s1img.applyOrbit()
            s1img.applyCalibration()
            s1img.applySpeckleFilter('VVcalibFile', 'VHcalibFile')
            # s1img.applyTerrainCorrection()
            s1img.applyOrthorectification()
            s1img.convertToDecibel()
            # s1img.deleteOnceDone()
    print('preprocess is done ')
    print('starting Step 2 , CoRegistration')
    stackVV = []
    stackVH = []
    # We are looking for image to stack, and we need those which are not stacked
    # for s1img in s1list:
    #   if not s1img.stack:
    #       stackVV.append(ProductIO.readProduct(getattr(s1img, 'VVorthoCorrFile')))
    #      stackVH.append(ProductIO.readProduct(getattr(s1img, 'VHorthoCorrFile')))
    #      s1img.stack = True
    doCoregistration(imageSearch(input_dir, extension='tif'), 'Sigma0_VV',
                     outputname=imageSearch(input_dir, 'tif')[0].split('_')[-1:].join('')+'coregistration')
    #doCoregistration()
    # createstack('VV', stackVV)
    # createstack('VH', stackVH)

# def main():
#     # loop to fetch all zip in folder for preprocessing
#     for folder in glob.glob(input_dir + "/*.zip"):
#         if folder.endswith(".zip"):
#             timestamp = folder.split("_")[5]
#             sentinel_image = ProductIO.readProduct(folder)
#             print(str(timestamp) + " is being processed")
#             applyOrbit(timestamp, sentinel_image, HashMap)
#             applyCalibration(timestamp, sentinel_image, HashMap)
#             # applyMultilook(timestamp, HashMap)
#             applyTerrainCorrection(timestamp, HashMap)
#             applyOrthorectification(timestamp, HashMap)
#             applySpeckleFilter(timestamp, HashMap)
#             # shepherdSeg()


# main()