ENH : Spread interferogram filtering to diapOTB_S1IW chain

python_src/diapOTB_S1IW.py

@@ -44,6 +44,7 @@ import re
 from processings import Pre_Processing
 from processings import Ground
 from processings import DInSar
+from processings import Post_Processing
 
 from utils import func_utils
 
@@ -65,7 +66,8 @@ if __name__ == "__main__":
     dict_PreProcessing = dataConfig['Pre_Processing']
     dict_Ground = dataConfig['Ground']
     dict_DInSAR = dataConfig['DIn_SAR']
-   
+    dict_PostProcessing = dataConfig['Post_Processing']
+
          
     # Get elements from dictionaries
     # Global
@@ -102,7 +104,26 @@ if __name__ == "__main__":
     else :
         esd_AutoMode = True
         esd_NbIter = 10 # 10 iterations maximum for automatic mode
-   
+       
+ 
+    # Post_Processing
+    activateOrtho = dict_PostProcessing['parameter']['Activate_Ortho']
+    
+    spacingxy = 0.00001
+    if "spacingxy" in dict_PostProcessing['parameter'] :
+        spacingxy = dict_PostProcessing['parameter']['Spacingxy']
+
+    activateFiltering = "false"
+    if "Activate_Filtering" in dict_PostProcessing['parameter'] :
+        activateFiltering = dict_PostProcessing['parameter']['Activate_Filtering']
+
+    ml_interf_filt_range = 3
+    if "Filtered_Interferogram_mlran" in dict_PostProcessing['parameter'] :
+        ml_interf_filt_range = int(dict_PostProcessing['parameter']['Filtered_Interferogram_mlran'])
+
+    ml_interf_filt_azimut = 3
+    if "Filtered_Interferogram_mlazi" in dict_PostProcessing['parameter'] :
+        ml_interf_filt_azimut = int(dict_PostProcessing['parameter']['Filtered_Interferogram_mlazi'])
 
     # Check Threshold
     if (geoGrid_threshold < 0) or (geoGrid_threshold > 1) :
@@ -150,6 +171,16 @@ if __name__ == "__main__":
     func_utils.log(logging.INFO, "esd_AutoMode : {param}".format(param=esd_AutoMode))
     func_utils.log(logging.INFO, "esd_NbIter : {param}".format(param=esd_NbIter))
 
+     # Post_Processing
+    func_utils.log(logging.INFO, " Post_Processing : ")
+    func_utils.log(logging.INFO, "activateOrtho : {param}".format(param=activateOrtho))
+    if func_utils.str2bool(activateOrtho):
+        func_utils.log(logging.INFO, "spacingxy : {param}".format(param=spacingxy))
+    func_utils.log(logging.INFO, "activateFiltering : {param}".format(param=activateFiltering))
+    if func_utils.str2bool(activateFiltering):
+        func_utils.log(logging.INFO, "ml_interf_filt_range : {param}".format(param=ml_interf_filt_range))
+        func_utils.log(logging.INFO, "ml_interf_filt_azimut : {param}".format(param=ml_interf_filt_azimut))
+
     func_utils.log(logging.INFO, "########### Input Images for the current execution ############## ")
     func_utils.log(logging.INFO, "master_Image : {param}".format(param=master_Image))
     func_utils.log(logging.INFO, "slave_Image : {param}".format(param=slave_Image))
@@ -310,6 +341,24 @@ if __name__ == "__main__":
     param['esd_AutoMode']  = esd_AutoMode
 
     DInSar.gridToInterferogram(dem, master_Image, master_Image_base, slave_Image, slave_Image_base, output_dir, output_dir, param, 'S1_IW', output_dir)
+
+
+    ######################## Post_Processing Chain #############################
+    func_utils.printOnStd("\n Post_Processing chain \n")
+    func_utils.log(logging.INFO, "Post_Processing chain")
+
+    # Phase Filtering (if required)
+    if func_utils.str2bool(activateFiltering):
+        # Default paramater 
+        alpha = 0.7
+        step = 16
+        sizetiles = 64
+
+        paramPost = {}
+        paramPost['ml_filt_interf_range'] = ml_interf_filt_range
+        paramPost['ml_filt_interf_azimut'] = ml_interf_filt_azimut
+
+        Post_Processing.filtering(master_Image, master_Image_base, slave_Image, slave_Image_base, output_dir, output_dir, paramPost, "S1_IW", output_dir)
  
     func_utils.printOnStd("\n End of DiapOTB processing (S1 IW mode) \n")
     func_utils.log(logging.INFO, "############ End of DiapOTB processing  (S1 IW mode) ##############")

python_src/processings/Post_Processing.py

@@ -214,6 +214,44 @@ def filtering_S1IW(master_Image, master_Image_base, slave_Image, slave_Image_bas
         :rtype: list, list 
     """    
     # Get elements into param dictionnaries 
-    ml_azimut = param['ml_azimut']
-    ml_range = param['ml_range']
+    ml_azimut = 1
+    ml_range = 1
+    
+    ml_filt_interf_range = ml_range
+    if "ml_filt_interf_range" in param :
+        ml_filt_interf_range = param['ml_filt_interf_range']
+    
+    ml_filt_interf_azimut = ml_azimut
+    if "ml_filt_interf_azimut" in param :
+        ml_filt_interf_azimut = param['ml_filt_interf_azimut']
+    
+
+    # define partial function with previous parameters
+    phaseFilteringApp = partial(diapOTBApp.phaseFiltering, withComplex="false", 
+                                mlran=ml_filt_interf_range, mlazi=ml_filt_interf_azimut, step=16, 
+                                sizetiles=64, alpha=0.7)
+
+    addAmpApp = partial(diapOTBApp.addAmpInterferogram, withComplex="false", 
+                        mlran=ml_filt_interf_range, mlazi=ml_filt_interf_azimut, gain=1)
+
+    filt_dir = os.path.join(output_dir, "filt")
+
+    if not os.path.exists(filt_dir):
+        os.makedirs(filt_dir)
+
+    # Use directly the interferogram (ML 1x1)
+    interf_name = "interferogram_swath.tif"
+    
+
+    # SARPhaseFiltering
+    filt_phacoh = "filfPhaCoh.tif"
+    filt_phacoh_path = os.path.join(filt_dir, filt_phacoh)
+    phaseFilteringApp(inForFiltering=os.path.join(output_dir, interf_name),
+                      outPath=filt_phacoh_path)
+
     
+    # SARAddBandInterfergoram
+    filt_interferogram = "filtered_interferogram.tif"
+    addAmpApp(inForAmp=os.path.join(output_dir, interf_name), 
+              inForPhaCoh=filt_phacoh_path,
+              outPath=os.path.join(output_dir, filt_interferogram))