cars 1.0.0a2__cp310-cp310-win_amd64.whl → 1.0.0a4__cp310-cp310-win_amd64.whl

cars/pipelines/unit/unit_pipeline.py

@@ -32,10 +32,10 @@ from __future__ import print_function
 
 import copy
 import logging
-import math
 import os
 
 import numpy as np
+from pyproj import CRS
 
 import cars.applications.sparse_matching.sparse_matching_constants as sm_cst
 from cars import __version__
@@ -48,14 +48,11 @@ from cars.applications.dem_generation import (
 )
 from cars.applications.grid_generation import grid_correction_app
 from cars.applications.grid_generation.transform_grid import transform_grid_func
-from cars.applications.point_cloud_fusion import (
-    pc_fusion_algo,
-    pc_fusion_wrappers,
-)
 from cars.core import preprocessing, projection, roi_tools
 from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.inputs import (
     get_descriptions_bands,
+    rasterio_get_crs,
     rasterio_get_epsg,
     rasterio_get_size,
     read_vector,
@@ -66,13 +63,14 @@ from cars.orchestrator import orchestrator
 from cars.orchestrator.cluster.log_wrapper import cars_profile
 from cars.pipelines.parameters import advanced_parameters
 from cars.pipelines.parameters import advanced_parameters_constants as adv_cst
-from cars.pipelines.parameters import depth_map_inputs
-from cars.pipelines.parameters import depth_map_inputs_constants as depth_cst
-from cars.pipelines.parameters import dsm_inputs
+from cars.pipelines.parameters import application_parameters, dsm_inputs
 from cars.pipelines.parameters import dsm_inputs_constants as dsm_cst
 from cars.pipelines.parameters import output_constants as out_cst
 from cars.pipelines.parameters import output_parameters, sensor_inputs
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
+from cars.pipelines.parameters.advanced_parameters_constants import (
+    USE_ENDOGENOUS_DEM,
+)
 from cars.pipelines.pipeline import Pipeline
 from cars.pipelines.pipeline_constants import (
     ADVANCED,
@@ -107,7 +105,6 @@ class UnitPipeline(PipelineTemplate):
             save_output_point_clouds
             geom_plugin_without_dem_and_geoid
             geom_plugin_with_dem_and_geoid
-            dem_generation_roi
 
         :param pipeline_name: name of the pipeline.
         :type pipeline_name: str
@@ -119,6 +116,8 @@ class UnitPipeline(PipelineTemplate):
 
         # Used conf
         self.used_conf = {}
+        # refined conf
+        self.refined_conf = {}
 
         # Transform relative path to absolute path
         if config_dir is not None:
@@ -135,21 +134,35 @@ class UnitPipeline(PipelineTemplate):
         # Check conf inputs
         inputs = self.check_inputs(conf[INPUTS], config_dir=config_dir)
         self.used_conf[INPUTS] = inputs
+        self.refined_conf[INPUTS] = copy.deepcopy(inputs)
 
         # Check advanced parameters
         # TODO static method in the base class
+        output_dem_dir = os.path.join(
+            conf[OUTPUT][out_cst.OUT_DIRECTORY], "dump_dir", "initial_elevation"
+        )
+        safe_makedirs(output_dem_dir)
         (
             inputs,
             advanced,
             self.geometry_plugin,
             self.geom_plugin_without_dem_and_geoid,
             self.geom_plugin_with_dem_and_geoid,
-            self.dem_generation_roi,
+            self.scaling_coeff,
+            self.land_cover_map,
+            self.classification_to_config_mapping,
         ) = advanced_parameters.check_advanced_parameters(
-            inputs, conf.get(ADVANCED, {}), check_epipolar_a_priori=True
+            inputs,
+            conf.get(ADVANCED, {}),
+            check_epipolar_a_priori=True,
+            output_dem_dir=output_dem_dir,
         )
         self.used_conf[ADVANCED] = advanced
 
+        self.refined_conf[ADVANCED] = copy.deepcopy(advanced)
+        # Refined conf: resolutions 1
+        self.refined_conf[ADVANCED][adv_cst.EPIPOLAR_RESOLUTIONS] = [1]
+
         # Get ROI
         (
             self.input_roi_poly,
@@ -161,8 +174,16 @@ class UnitPipeline(PipelineTemplate):
         self.debug_with_roi = self.used_conf[ADVANCED][adv_cst.DEBUG_WITH_ROI]
 
         # Check conf output
-        output = self.check_output(conf[OUTPUT])
+        (
+            output,
+            self.scaling_coeff,
+        ) = self.check_output(conf[OUTPUT], self.scaling_coeff)
+
         self.used_conf[OUTPUT] = output
+        self.out_dir = self.used_conf[OUTPUT][out_cst.OUT_DIRECTORY]
+        self.dump_dir = os.path.join(self.out_dir, "dump_dir")
+
+        self.refined_conf[OUTPUT] = copy.deepcopy(output)
 
         prod_level = output[out_cst.PRODUCT_LEVEL]
 
@@ -177,11 +198,7 @@ class UnitPipeline(PipelineTemplate):
             or self.save_output_point_cloud
         )
         self.sensors_in_inputs = sens_cst.SENSORS in self.used_conf[INPUTS]
-        self.depth_maps_in_inputs = (
-            depth_cst.DEPTH_MAPS in self.used_conf[INPUTS]
-        )
         self.dsms_in_inputs = dsm_cst.DSMS in self.used_conf[INPUTS]
-        self.merging = self.used_conf[ADVANCED][adv_cst.MERGING]
 
         self.phasing = self.used_conf[ADVANCED][adv_cst.PHASING]
 
@@ -189,7 +206,6 @@ class UnitPipeline(PipelineTemplate):
             self.sensors_in_inputs
             and (not self.output_level_none)
             and not self.dsms_in_inputs
-            and not self.depth_maps_in_inputs
         )
 
         if self.output_level_none:
@@ -224,23 +240,15 @@ class UnitPipeline(PipelineTemplate):
         # Check conf application
         application_conf = self.check_applications(conf.get(APPLICATIONS, {}))
 
-        if (
-            self.sensors_in_inputs
-            and not self.depth_maps_in_inputs
-            and not self.dsms_in_inputs
-        ):
+        if self.sensors_in_inputs and not self.dsms_in_inputs:
             # Check conf application vs inputs application
             application_conf = self.check_applications_with_inputs(
-                self.used_conf[INPUTS], application_conf
+                self.used_conf[INPUTS], application_conf, self.res_resamp
             )
 
         self.used_conf[APPLICATIONS] = application_conf
 
-        self.config_full_res = copy.deepcopy(self.used_conf)
-        self.config_full_res.__delitem__("applications")
-        self.config_full_res[ADVANCED][adv_cst.EPIPOLAR_A_PRIORI] = {}
-        self.config_full_res[ADVANCED][adv_cst.TERRAIN_A_PRIORI] = {}
-        self.config_full_res[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] = True
+        self.out_dir = self.used_conf[OUTPUT][out_cst.OUT_DIRECTORY]
 
     def quit_on_app(self, app_name):
         """
@@ -269,34 +277,26 @@ class UnitPipeline(PipelineTemplate):
         sensor_to_depth_apps = {
             "grid_generation": 1,  # and 5
             "resampling": 2,  # and 8
-            "hole_detection": 3,
-            "sparse_matching.sift": 4,
+            "sparse_matching": 4,
             "ground_truth_reprojection": 6,
             "dense_matching": 8,
-            "dense_match_filling.1": 9,
-            "dense_match_filling.2": 10,
+            "dense_match_filling": 9,
             "triangulation": 11,
             "point_cloud_outlier_removal.1": 12,
             "point_cloud_outlier_removal.2": 13,
         }
 
-        depth_merge_apps = {
-            "point_cloud_fusion": 14,
-        }
-
         depth_to_dsm_apps = {
-            "pc_denoising": 15,
-            "point_cloud_rasterization": 16,
-            "dem_generation": 17,
-            "dsm_filling.1": 18,
-            "dsm_filling.2": 19,
-            "dsm_filling.3": 20,
-            "auxiliary_filling": 21,
+            "point_cloud_rasterization": 15,
+            "dem_generation": 16,
+            "dsm_filling.1": 17,
+            "dsm_filling.2": 18,
+            "dsm_filling.3": 19,
+            "auxiliary_filling": 20,
         }
 
         self.app_values = {}
         self.app_values.update(sensor_to_depth_apps)
-        self.app_values.update(depth_merge_apps)
         self.app_values.update(depth_to_dsm_apps)
 
         app_conf = conf.get(APPLICATIONS, {})
@@ -318,11 +318,7 @@ class UnitPipeline(PipelineTemplate):
                     ).format(key)
                     logging.warning(warn_msg)
 
-                elif (
-                    self.sensors_in_inputs
-                    and not self.depth_maps_in_inputs
-                    and not self.dsms_in_inputs
-                ):
+                elif self.sensors_in_inputs and not self.dsms_in_inputs:
                     self.compute_depth_map = True
                     self.last_application_to_run = max(
                         self.last_application_to_run, self.app_values[key]
@@ -330,11 +326,7 @@ class UnitPipeline(PipelineTemplate):
 
             elif key in depth_to_dsm_apps:
 
-                if not (
-                    self.sensors_in_inputs
-                    or self.depth_maps_in_inputs
-                    or self.dsms_in_inputs
-                ):
+                if not (self.sensors_in_inputs or self.dsms_in_inputs):
                     warn_msg = (
                         "The application {} can only be used when sensor "
                         "images or depth maps are given as an input. "
@@ -343,11 +335,7 @@ class UnitPipeline(PipelineTemplate):
                     logging.warning(warn_msg)
 
                 else:
-                    if (
-                        self.sensors_in_inputs
-                        and not self.depth_maps_in_inputs
-                        and not self.dsms_in_inputs
-                    ):
+                    if self.sensors_in_inputs and not self.dsms_in_inputs:
                         self.compute_depth_map = True
 
                     # enabled to start the depth map to dsm process
@@ -357,43 +345,6 @@ class UnitPipeline(PipelineTemplate):
                         self.last_application_to_run, self.app_values[key]
                     )
 
-            elif key in depth_merge_apps:
-
-                if not self.merging:
-                    warn_msg = (
-                        "The application {} can only be used when merging "
-                        "is activated (this parameter is located in the "
-                        "'advanced' config key). "
-                        "The application's configuration will be ignored."
-                    ).format(key)
-                    logging.warning(warn_msg)
-
-                elif not (
-                    self.sensors_in_inputs
-                    or self.depth_maps_in_inputs
-                    or self.dsms_in_inputs
-                ):
-                    warn_msg = (
-                        "The application {} can only be used when sensor "
-                        "images or depth maps are given as an input. "
-                        "Its configuration will be ignored."
-                    ).format(key)
-                    logging.warning(warn_msg)
-
-                else:
-                    if (
-                        self.sensors_in_inputs
-                        and not self.depth_maps_in_inputs
-                        and not self.dsms_in_inputs
-                    ):
-                        self.compute_depth_map = True
-
-                    # enabled to start the depth map to dsm process
-                    self.save_output_point_cloud = True
-
-                    self.last_application_to_run = max(
-                        self.last_application_to_run, self.app_values[key]
-                    )
             else:
                 warn_msg = (
                     "The application {} was not recognized. Its configuration"
@@ -436,45 +387,51 @@ class UnitPipeline(PipelineTemplate):
         """
 
         output_config = {}
-        if (
-            sens_cst.SENSORS in conf
-            and depth_cst.DEPTH_MAPS not in conf
-            and dsm_cst.DSMS not in conf
-        ):
+        if sens_cst.SENSORS in conf and dsm_cst.DSMS not in conf:
             output_config = sensor_inputs.sensors_check_inputs(
                 conf, config_dir=config_dir
             )
-        elif depth_cst.DEPTH_MAPS in conf:
-            output_config = {
-                **output_config,
-                **depth_map_inputs.check_depth_maps_inputs(
-                    conf, config_dir=config_dir
-                ),
-            }
-        else:
+        elif dsm_cst.DSMS in conf:
             output_config = {
                 **output_config,
                 **dsm_inputs.check_dsm_inputs(conf, config_dir=config_dir),
             }
+        else:
+            raise RuntimeError("No sensors or dsms in inputs")
         return output_config
 
-    @staticmethod
-    def check_output(conf):
+    def save_configurations(self):
+        """
+        Save used_conf and refined_conf configurations
+        """
+
+        cars_dataset.save_dict(
+            self.used_conf,
+            os.path.join(self.out_dir, "current_res_used_conf.json"),
+            safe_save=True,
+        )
+        cars_dataset.save_dict(
+            self.refined_conf,
+            os.path.join(self.out_dir, "refined_conf.json"),
+            safe_save=True,
+        )
+
+    def check_output(self, conf, scaling_coeff):
         """
         Check the output given
 
         :param conf: configuration of output
         :type conf: dict
-
-        :return overloader output
-        :rtype : dict
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+        :return: overloader output
+        :rtype: dict
         """
-        return output_parameters.check_output_parameters(conf)
+        return output_parameters.check_output_parameters(conf, scaling_coeff)
 
     def check_applications(  # noqa: C901 : too complex
         self,
         conf,
-        key=None,
     ):
         """
         Check the given configuration for applications,
@@ -483,43 +440,18 @@ class UnitPipeline(PipelineTemplate):
         :param conf: configuration of applications
         :type conf: dict
         """
+        scaling_coeff = self.scaling_coeff
+
+        needed_applications = application_parameters.get_needed_apps(
+            self.sensors_in_inputs,
+            self.save_output_dsm,
+            self.save_output_point_cloud,
+            conf,
+        )
 
         # Check if all specified applications are used
         # Application in terrain_application are note used in
         # the sensors_to_dense_depth_maps pipeline
-        needed_applications = []
-
-        if self.sensors_in_inputs:
-            needed_applications += [
-                "grid_generation",
-                "resampling",
-                "ground_truth_reprojection",
-                "hole_detection",
-                "dense_match_filling.1",
-                "dense_match_filling.2",
-                "sparse_matching.sift",
-                "dense_matching",
-                "triangulation",
-                "dem_generation",
-                "point_cloud_outlier_removal.1",
-                "point_cloud_outlier_removal.2",
-            ]
-
-        if self.save_output_dsm or self.save_output_point_cloud:
-            needed_applications += ["pc_denoising"]
-
-            if self.save_output_dsm:
-                needed_applications += [
-                    "point_cloud_rasterization",
-                    "dsm_filling.1",
-                    "dsm_filling.2",
-                    "dsm_filling.3",
-                    "auxiliary_filling",
-                ]
-
-            if self.merging:  # we have to merge point clouds, add merging apps
-                needed_applications += ["point_cloud_fusion"]
-
         for app_key in conf.keys():
             if app_key not in needed_applications:
                 msg = (
@@ -532,28 +464,24 @@ class UnitPipeline(PipelineTemplate):
         # Initialize used config
         used_conf = {}
 
-        for app_key in [
-            "point_cloud_outlier_removal.1",
-            "point_cloud_outlier_removal.2",
-            "auxiliary_filling",
-        ]:
-            if conf.get(app_key) is not None:
-                config_app = conf.get(app_key)
-                if "activated" not in config_app:
-                    conf[app_key]["activated"] = True
-
         for app_key in needed_applications:
             used_conf[app_key] = conf.get(app_key, {})
+            if used_conf[app_key] is None:
+                continue
             used_conf[app_key]["save_intermediate_data"] = (
                 self.save_all_intermediate_data
                 or used_conf[app_key].get("save_intermediate_data", False)
             )
 
-        for app_key in [
-            "point_cloud_fusion",
-            "pc_denoising",
-        ]:
-            if app_key in needed_applications:
+            if app_key == "auxiliary_filling":
+                if used_conf[app_key] is not None:
+                    used_conf[app_key]["activated"] = used_conf[app_key].get(
+                        "activated", True
+                    )
+
+            if app_key in [
+                "point_cloud_fusion",
+            ]:
                 used_conf[app_key]["save_by_pair"] = used_conf[app_key].get(
                     "save_by_pair", self.save_all_point_clouds_by_pair
                 )
@@ -561,26 +489,25 @@ class UnitPipeline(PipelineTemplate):
         self.epipolar_grid_generation_application = None
         self.resampling_application = None
         self.ground_truth_reprojection = None
-        self.hole_detection_app = None
-        self.dense_match_filling_1 = None
-        self.dense_match_filling_2 = None
-        self.sparse_mtch_sift_app = None
+        self.dense_match_filling = None
+        self.sparse_mtch_app = None
         self.dense_matching_app = None
         self.triangulation_application = None
         self.dem_generation_application = None
-        self.pc_denoising_application = None
-        self.pc_outlier_removal_1_app = None
-        self.pc_outlier_removal_2_app = None
+        self.pc_outlier_removal_apps = {}
         self.rasterization_application = None
         self.pc_fusion_application = None
         self.dsm_filling_1_application = None
         self.dsm_filling_2_application = None
         self.dsm_filling_3_application = None
+        self.dsm_filling_apps = {}
 
         if self.sensors_in_inputs:
             # Epipolar grid generation
             self.epipolar_grid_generation_application = Application(
-                "grid_generation", cfg=used_conf.get("grid_generation", {})
+                "grid_generation",
+                cfg=used_conf.get("grid_generation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["grid_generation"] = (
                 self.epipolar_grid_generation_application.get_conf()
@@ -588,7 +515,9 @@ class UnitPipeline(PipelineTemplate):
 
             # image resampling
             self.resampling_application = Application(
-                "resampling", cfg=used_conf.get("resampling", {})
+                "resampling",
+                cfg=used_conf.get("resampling", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["resampling"] = self.resampling_application.get_conf()
 
@@ -610,45 +539,29 @@ class UnitPipeline(PipelineTemplate):
                 self.ground_truth_reprojection = Application(
                     "ground_truth_reprojection",
                     cfg=used_conf.get("ground_truth_reprojection", {}),
+                    scaling_coeff=scaling_coeff,
                 )
-            # holes detection
-            self.hole_detection_app = Application(
-                "hole_detection", cfg=used_conf.get("hole_detection", {})
-            )
-            used_conf["hole_detection"] = self.hole_detection_app.get_conf()
-
-            # disparity filling 1 plane
-            self.dense_match_filling_1 = Application(
-                "dense_match_filling",
-                cfg=used_conf.get(
-                    "dense_match_filling.1",
-                    {"method": "plane"},
-                ),
-            )
-            used_conf["dense_match_filling.1"] = (
-                self.dense_match_filling_1.get_conf()
-            )
 
-            # disparity filling 2
-            self.dense_match_filling_2 = Application(
+            # disparity filling
+            self.dense_match_filling = Application(
                 "dense_match_filling",
                 cfg=used_conf.get(
-                    "dense_match_filling.2",
+                    "dense_match_filling",
                     {"method": "zero_padding"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
-            used_conf["dense_match_filling.2"] = (
-                self.dense_match_filling_2.get_conf()
+            used_conf["dense_match_filling"] = (
+                self.dense_match_filling.get_conf()
             )
 
             # Sparse Matching
-            self.sparse_mtch_sift_app = Application(
+            self.sparse_mtch_app = Application(
                 "sparse_matching",
-                cfg=used_conf.get("sparse_matching.sift", {"method": "sift"}),
-            )
-            used_conf["sparse_matching.sift"] = (
-                self.sparse_mtch_sift_app.get_conf()
+                cfg=used_conf.get("sparse_matching", {"method": "sift"}),
+                scaling_coeff=scaling_coeff,
             )
+            used_conf["sparse_matching"] = self.sparse_mtch_app.get_conf()
 
             # Matching
             generate_performance_map = (
@@ -671,14 +584,26 @@ class UnitPipeline(PipelineTemplate):
                 is None
             ):
                 dense_matching_config["performance_map_method"] = "risk"
+
+            # particular case for some epipolar resolutions
+            if not dense_matching_config:
+                used_conf["dense_matching"]["performance_map_method"] = [
+                    "risk",
+                    "intervals",
+                ]
+
             self.dense_matching_app = Application(
-                "dense_matching", cfg=dense_matching_config
+                "dense_matching",
+                cfg=dense_matching_config,
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_matching"] = self.dense_matching_app.get_conf()
 
             # Triangulation
             self.triangulation_application = Application(
-                "triangulation", cfg=used_conf.get("triangulation", {})
+                "triangulation",
+                cfg=used_conf.get("triangulation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["triangulation"] = (
                 self.triangulation_application.get_conf()
@@ -686,123 +611,134 @@ class UnitPipeline(PipelineTemplate):
 
             # MNT generation
             self.dem_generation_application = Application(
-                "dem_generation", cfg=used_conf.get("dem_generation", {})
+                "dem_generation",
+                cfg=used_conf.get("dem_generation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dem_generation"] = (
                 self.dem_generation_application.get_conf()
             )
 
-            # Points cloud small component outlier removal
-            if "point_cloud_outlier_removal.1" in used_conf:
-                if "method" not in used_conf["point_cloud_outlier_removal.1"]:
-                    used_conf["point_cloud_outlier_removal.1"][
-                        "method"
-                    ] = "small_components"
-            self.pc_outlier_removal_1_app = Application(
-                "point_cloud_outlier_removal",
-                cfg=used_conf.get(
-                    "point_cloud_outlier_removal.1",
-                    {"method": "small_components"},
-                ),
-            )
-            used_conf["point_cloud_outlier_removal.1"] = (
-                self.pc_outlier_removal_1_app.get_conf()
-            )
+            for app_key, app_conf in used_conf.items():
+                if not app_key.startswith("point_cloud_outlier_removal"):
+                    continue
 
-            # Points cloud statistical outlier removal
-            self.pc_outlier_removal_2_app = Application(
-                "point_cloud_outlier_removal",
-                cfg=used_conf.get(
-                    "point_cloud_outlier_removal.2",
-                    {"method": "statistical"},
-                ),
+                if app_conf is None:
+                    self.pc_outlier_removal_apps = {}
+                    # keep over multiple runs
+                    used_conf["point_cloud_outlier_removal"] = None
+                    break
+
+                if app_key in self.pc_outlier_removal_apps:
+                    msg = (
+                        f"The key {app_key} is defined twice in the input "
+                        "configuration."
+                    )
+                    logging.error(msg)
+                    raise NameError(msg)
+
+                if app_key[27:] == ".1":
+                    app_conf.setdefault("method", "small_components")
+                if app_key[27:] == ".2":
+                    app_conf.setdefault("method", "statistical")
+
+                self.pc_outlier_removal_apps[app_key] = Application(
+                    "point_cloud_outlier_removal",
+                    cfg=app_conf,
+                    scaling_coeff=scaling_coeff,
+                )
+                used_conf[app_key] = self.pc_outlier_removal_apps[
+                    app_key
+                ].get_conf()
+
+            methods_str = "\n".join(
+                f" - {k}={a.used_method}"
+                for k, a in self.pc_outlier_removal_apps.items()
             )
-            used_conf["point_cloud_outlier_removal.2"] = (
-                self.pc_outlier_removal_2_app.get_conf()
+            logging.info(
+                "{} point cloud outlier removal apps registered:\n{}".format(
+                    len(self.pc_outlier_removal_apps), methods_str
+                )
             )
 
         if self.save_output_dsm or self.save_output_point_cloud:
 
-            # Point cloud denoising
-            self.pc_denoising_application = Application(
-                "pc_denoising",
-                cfg=used_conf.get("pc_denoising", {"method": "none"}),
-            )
-            used_conf["pc_denoising"] = self.pc_denoising_application.get_conf()
-
             if self.save_output_dsm:
 
                 # Rasterization
                 self.rasterization_application = Application(
                     "point_cloud_rasterization",
                     cfg=used_conf.get("point_cloud_rasterization", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["point_cloud_rasterization"] = (
                     self.rasterization_application.get_conf()
                 )
-                # DSM filling 1 : Exogenous filling
-                self.dsm_filling_1_application = Application(
-                    "dsm_filling",
-                    cfg=conf.get(
-                        "dsm_filling.1",
-                        {"method": "exogenous_filling"},
-                    ),
-                )
-                used_conf["dsm_filling.1"] = (
-                    self.dsm_filling_1_application.get_conf()
-                )
-                # DSM filling 2 : Bulldozer
-                self.dsm_filling_2_application = Application(
-                    "dsm_filling",
-                    cfg=conf.get(
-                        "dsm_filling.2",
-                        {"method": "bulldozer"},
-                    ),
-                )
-                used_conf["dsm_filling.2"] = (
-                    self.dsm_filling_2_application.get_conf()
-                )
-                # DSM filling 3 : Border interpolation
-                self.dsm_filling_3_application = Application(
-                    "dsm_filling",
-                    cfg=conf.get(
-                        "dsm_filling.3",
-                        {"method": "border_interpolation"},
-                    ),
+
+                for app_key, app_conf in used_conf.items():
+                    if not app_key.startswith("dsm_filling"):
+                        continue
+
+                    if app_conf is None:
+                        self.dsm_filling_apps = {}
+                        # keep over multiple runs
+                        used_conf["dsm_filling"] = None
+                        break
+
+                    if app_key in self.dsm_filling_apps:
+                        msg = (
+                            f"The key {app_key} is defined twice in the input "
+                            "configuration."
+                        )
+                        logging.error(msg)
+                        raise NameError(msg)
+
+                    if app_key[11:] == ".1":
+                        app_conf.setdefault("method", "exogenous_filling")
+                    if app_key[11:] == ".2":
+                        app_conf.setdefault("method", "bulldozer")
+                    if app_key[11:] == ".3":
+                        app_conf.setdefault("method", "border_interpolation")
+
+                    self.dsm_filling_apps[app_key] = Application(
+                        "dsm_filling",
+                        cfg=app_conf,
+                        scaling_coeff=scaling_coeff,
+                    )
+                    used_conf[app_key] = self.dsm_filling_apps[
+                        app_key
+                    ].get_conf()
+
+                methods_str = "\n".join(
+                    f" - {k}={a.used_method}"
+                    for k, a in self.dsm_filling_apps.items()
                 )
-                used_conf["dsm_filling.3"] = (
-                    self.dsm_filling_3_application.get_conf()
+                logging.info(
+                    "{} dsm filling apps registered:\n{}".format(
+                        len(self.dsm_filling_apps), methods_str
+                    )
                 )
+
                 # Auxiliary filling
                 self.auxiliary_filling_application = Application(
-                    "auxiliary_filling", cfg=conf.get("auxiliary_filling", {})
+                    "auxiliary_filling",
+                    cfg=conf.get("auxiliary_filling", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["auxiliary_filling"] = (
                     self.auxiliary_filling_application.get_conf()
                 )
 
-            if (
-                self.dsm_filling_1_application.classification
-                or self.dsm_filling_2_application.classification
-                or self.dsm_filling_3_application.classification
+            if any(
+                app_obj.classification != ["nodata"]
+                for app_key, app_obj in self.dsm_filling_apps.items()
             ):
                 self.save_output_classif_for_filling = True
 
-            if self.merging:
-
-                # Point cloud fusion
-                self.pc_fusion_application = Application(
-                    "point_cloud_fusion",
-                    cfg=used_conf.get("point_cloud_fusion", {}),
-                )
-                used_conf["point_cloud_fusion"] = (
-                    self.pc_fusion_application.get_conf()
-                )
-
         return used_conf
 
     def check_applications_with_inputs(  # noqa: C901 : too complex
-        self, inputs_conf, application_conf
+        self, inputs_conf, application_conf, epipolar_resolution
     ):
         """
         Check for each application the input and output configuration
@@ -812,55 +748,34 @@ class UnitPipeline(PipelineTemplate):
         :type inputs_conf: dict
         :param application_conf: application checked configuration
         :type application_conf: dict
+        :param epipolar_resolution: epipolar resolution
+        :type epipolar_resolution: int
         """
 
         initial_elevation = (
             inputs_conf[sens_cst.INITIAL_ELEVATION]["dem"] is not None
         )
-        if self.sparse_mtch_sift_app.elevation_delta_lower_bound is None:
-            self.sparse_mtch_sift_app.used_config[
-                "elevation_delta_lower_bound"
-            ] = (-500 if initial_elevation else -1000)
-            self.sparse_mtch_sift_app.elevation_delta_lower_bound = (
-                self.sparse_mtch_sift_app.used_config[
-                    "elevation_delta_lower_bound"
-                ]
+        if self.sparse_mtch_app.elevation_delta_lower_bound is None:
+            self.sparse_mtch_app.used_config["elevation_delta_lower_bound"] = (
+                -500 if initial_elevation else -1000
             )
-        if self.sparse_mtch_sift_app.elevation_delta_upper_bound is None:
-            self.sparse_mtch_sift_app.used_config[
-                "elevation_delta_upper_bound"
-            ] = (1000 if initial_elevation else 9000)
-            self.sparse_mtch_sift_app.elevation_delta_upper_bound = (
-                self.sparse_mtch_sift_app.used_config[
-                    "elevation_delta_upper_bound"
-                ]
+            self.sparse_mtch_app.elevation_delta_lower_bound = (
+                self.sparse_mtch_app.used_config["elevation_delta_lower_bound"]
             )
-        application_conf["sparse_matching.sift"] = (
-            self.sparse_mtch_sift_app.get_conf()
-        )
-
-        if (
-            application_conf["dem_generation"]["method"]
-            == "bulldozer_on_raster"
-        ):
-            first_image_path = next(iter(inputs_conf["sensors"].values()))[
-                "image"
-            ]["main_file"]
-            first_image_size = rasterio_get_size(first_image_path)
-            first_image_nb_pixels = math.prod(first_image_size)
-            dem_gen_used_mem = first_image_nb_pixels / 1e8
-            if dem_gen_used_mem > 8:
-                logging.warning(
-                    "DEM generation method is 'bulldozer_on_raster'. "
-                    f"This method can use up to {dem_gen_used_mem} Gb "
-                    "of memory. If you think that it is too much for "
-                    "your computer, you can re-lauch the run using "
-                    "'dichotomic' method for DEM generation"
-                )
+        if self.sparse_mtch_app.elevation_delta_upper_bound is None:
+            self.sparse_mtch_app.used_config["elevation_delta_upper_bound"] = (
+                1000 if initial_elevation else 9000
+            )
+            self.sparse_mtch_app.elevation_delta_upper_bound = (
+                self.sparse_mtch_app.used_config["elevation_delta_upper_bound"]
+            )
+        application_conf["sparse_matching"] = self.sparse_mtch_app.get_conf()
 
         # check classification application parameter compare
         # to each sensors inputs classification list
         for application_key in application_conf:
+            if application_conf[application_key] is None:
+                continue
             if "classification" in application_conf[application_key]:
                 for item in inputs_conf["sensors"]:
                     if "classification" in inputs_conf["sensors"][item].keys():
@@ -895,44 +810,123 @@ class UnitPipeline(PipelineTemplate):
                                 )
         for key1, key2 in inputs_conf["pairing"]:
             corr_cfg = self.dense_matching_app.loader.get_conf()
-            img_left = inputs_conf["sensors"][key1]["image"]["main_file"]
-            img_right = inputs_conf["sensors"][key2]["image"]["main_file"]
+            nodata_left = inputs_conf["sensors"][key2]["image"]["no_data"]
+            nodata_right = inputs_conf["sensors"][key2]["image"]["no_data"]
             bands_left = list(
                 inputs_conf["sensors"][key1]["image"]["bands"].keys()
             )
             bands_right = list(
                 inputs_conf["sensors"][key2]["image"]["bands"].keys()
             )
-            classif_left = None
-            classif_right = None
+            bands_classif_left = None
+            bands_classif_right = None
             if (
                 "classification" in inputs_conf["sensors"][key1]
                 and inputs_conf["sensors"][key1]["classification"] is not None
             ):
-                classif_left = inputs_conf["sensors"][key1]["classification"][
-                    "main_file"
-                ]
+                bands_classif_left = inputs_conf["sensors"][key1][
+                    "classification"
+                ]["bands"].keys()
             if (
                 "classification" in inputs_conf["sensors"][key2]
-                and inputs_conf["sensors"][key1]["classification"] is not None
+                and inputs_conf["sensors"][key2]["classification"] is not None
             ):
-                classif_right = inputs_conf["sensors"][key2]["classification"][
-                    "main_file"
-                ]
+                bands_classif_right = inputs_conf["sensors"][key2][
+                    "classification"
+                ]["bands"].keys()
             self.dense_matching_app.corr_config = (
                 self.dense_matching_app.loader.check_conf(
                     corr_cfg,
-                    img_left,
-                    img_right,
+                    nodata_left,
+                    nodata_right,
                     bands_left,
                     bands_right,
-                    classif_left,
-                    classif_right,
+                    bands_classif_left,
+                    bands_classif_right,
                 )
             )
 
+        # Change the step regarding the resolution
+        # For the small resolution, the resampling perform better
+        # with a small step
+        # For the higher ones, a step at 30 should be better
+        first_image_path = next(iter(inputs_conf["sensors"].values()))["image"][
+            "main_file"
+        ]
+        first_image_size = rasterio_get_size(first_image_path)
+        size_low_res_img_row = first_image_size[0] // epipolar_resolution
+        size_low_res_img_col = first_image_size[1] // epipolar_resolution
+        if epipolar_resolution > 1:
+            if size_low_res_img_row <= 900 and size_low_res_img_col <= 900:
+                application_conf["grid_generation"]["epi_step"] = (
+                    epipolar_resolution * 5
+                )
+            else:
+                application_conf["grid_generation"]["epi_step"] = (
+                    epipolar_resolution * 30
+                )
+
         return application_conf
 
+    def generate_grid_correction_on_dem(self, pair_key, geo_plugin_on_dem):
+        """
+        Generate the epipolar grid correction for a given pair, using given dem
+        """
+
+        # Generate new grids with dem
+        # Generate rectification grids
+        (
+            grid_left_new_dem,
+            grid_right_new_dem,
+        ) = self.epipolar_grid_generation_application.run(
+            self.pairs[pair_key]["sensor_image_left"],
+            self.pairs[pair_key]["sensor_image_right"],
+            geo_plugin_on_dem,
+            orchestrator=self.cars_orchestrator,
+            pair_folder=os.path.join(
+                self.dump_dir,
+                "epipolar_grid_generation",
+                "new_dem",
+                pair_key,
+            ),
+            pair_key=pair_key,
+        )
+
+        if self.pairs[pair_key].get("sensor_matches_left", None) is None:
+            logging.error(
+                "No sensor matches available to compute grid correction"
+            )
+            return None
+
+        # Generate new matches with new grids
+        new_grid_matches_array = geo_plugin_on_dem.transform_matches_from_grids(
+            self.pairs[pair_key]["sensor_matches_left"],
+            self.pairs[pair_key]["sensor_matches_right"],
+            grid_left_new_dem,
+            grid_right_new_dem,
+        )
+
+        # Generate grid_correction
+        # Compute grid correction
+        (
+            new_grid_correction_coef,
+            _,
+            _,
+            _,
+        ) = grid_correction_app.estimate_right_grid_correction(
+            new_grid_matches_array,
+            grid_right_new_dem,
+            save_matches=False,
+            minimum_nb_matches=0,
+            pair_folder=os.path.join(
+                self.dump_dir, "grid_correction", " new_dem", pair_key
+            ),
+            pair_key=pair_key,
+            orchestrator=self.cars_orchestrator,
+        )
+
+        return new_grid_correction_coef
+
     def sensor_to_depth_maps(self):  # noqa: C901
         """
         Creates the depth map from the sensor images given in the input,
@@ -956,7 +950,7 @@ class UnitPipeline(PipelineTemplate):
                 self.input_roi_poly, self.input_roi_epsg, self.epsg
             )
 
-        self.resolution = output[out_cst.RESOLUTION] * self.res_resamp
+        self.resolution = output[out_cst.RESOLUTION]
 
         # List of terrain roi corresponding to each epipolar pair
         # Used to generate final terrain roi
@@ -991,7 +985,7 @@ class UnitPipeline(PipelineTemplate):
         # used in dem generation
         self.triangulated_matches_list = []
 
-        save_matches = self.sparse_mtch_sift_app.get_save_matches()
+        save_matches = self.sparse_mtch_app.get_save_matches()
 
         save_corrected_grid = (
             self.epipolar_grid_generation_application.get_save_grids()
@@ -1014,21 +1008,10 @@ class UnitPipeline(PipelineTemplate):
             # We generate grids with dem if it is provided.
             # If not provided, grid are generated without dem and a dem
             # will be generated, to use later for a new grid generation**
-            altitude_delta_min = inputs.get(sens_cst.INITIAL_ELEVATION, {}).get(
-                sens_cst.ALTITUDE_DELTA_MIN, None
-            )
-            altitude_delta_max = inputs.get(sens_cst.INITIAL_ELEVATION, {}).get(
-                sens_cst.ALTITUDE_DELTA_MAX, None
-            )
 
             if inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH] is None:
                 geom_plugin = self.geom_plugin_without_dem_and_geoid
 
-                if None not in (altitude_delta_min, altitude_delta_max):
-                    raise RuntimeError(
-                        "Dem path is mandatory for "
-                        "the use of altitude deltas"
-                    )
             else:
                 geom_plugin = self.geom_plugin_with_dem_and_geoid
 
@@ -1053,43 +1036,15 @@ class UnitPipeline(PipelineTemplate):
             if self.quit_on_app("grid_generation"):
                 continue  # keep iterating over pairs, but don't go further
 
-            # Run holes detection
-            # Get classif depending on which filling is used
-            # For now, 2 filling application can be used, and be configured
-            # with any order. the .1 will be performed before the .2
-            self.pairs[pair_key]["holes_classif"] = []
-            self.pairs[pair_key]["holes_poly_margin"] = 0
-            add_classif = False
-            if self.dense_match_filling_1.used_method == "plane":
-                self.pairs[pair_key][
-                    "holes_classif"
-                ] += self.dense_match_filling_1.get_classif()
-                self.pairs[pair_key]["holes_poly_margin"] = max(
-                    self.pairs[pair_key]["holes_poly_margin"],
-                    self.dense_match_filling_1.get_poly_margin(),
-                )
-                add_classif = True
-            if self.dense_match_filling_2.used_method == "plane":
-                self.pairs[pair_key][
-                    "holes_classif"
-                ] += self.dense_match_filling_2.get_classif()
-                self.pairs[pair_key]["holes_poly_margin"] = max(
-                    self.pairs[pair_key]["holes_poly_margin"],
-                    self.dense_match_filling_2.get_poly_margin(),
-                )
-                add_classif = True
-
-            self.pairs[pair_key]["holes_bbox_left"] = []
-            self.pairs[pair_key]["holes_bbox_right"] = []
-
-            if self.used_conf[ADVANCED][
-                adv_cst.USE_EPIPOLAR_A_PRIORI
-            ] is False or (len(self.pairs[pair_key]["holes_classif"]) > 0):
+            if self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI] in (
+                None,
+                {},
+            ):
                 # Run resampling only if needed:
-                # no a priori or needs to detect holes
+                # no a priori
 
                 # Get required bands of first resampling
-                required_bands = self.sparse_mtch_sift_app.get_required_bands()
+                required_bands = self.sparse_mtch_app.get_required_bands()
 
                 # Run first epipolar resampling
                 (
@@ -1106,49 +1061,30 @@ class UnitPipeline(PipelineTemplate):
                         self.dump_dir, "resampling", "initial", pair_key
                     ),
                     pair_key=pair_key,
-                    margins_fun=self.sparse_mtch_sift_app.get_margins_fun(),
+                    margins_fun=self.sparse_mtch_app.get_margins_fun(),
                     tile_width=None,
                     tile_height=None,
-                    add_classif=add_classif,
                     required_bands=required_bands,
                 )
 
                 if self.quit_on_app("resampling"):
                     continue  # keep iterating over pairs, but don't go further
 
-                # Generate the holes polygons in epipolar images
-                # They are only generated if dense_match_filling
-                # applications are used later
-                (
-                    self.pairs[pair_key]["holes_bbox_left"],
-                    self.pairs[pair_key]["holes_bbox_right"],
-                ) = self.hole_detection_app.run(
-                    self.pairs[pair_key]["epipolar_image_left"],
-                    self.pairs[pair_key]["epipolar_image_right"],
-                    classification=self.pairs[pair_key]["holes_classif"],
-                    margin=self.pairs[pair_key]["holes_poly_margin"],
-                    orchestrator=self.cars_orchestrator,
-                    pair_folder=os.path.join(
-                        self.dump_dir, "hole_detection", pair_key
-                    ),
-                    pair_key=pair_key,
-                )
-
-                if self.quit_on_app("hole_detection"):
-                    continue  # keep iterating over pairs, but don't go further
-
-            if self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is False:
+            if self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI] in (
+                None,
+                {},
+            ):
                 # Run epipolar sparse_matching application
                 (
                     self.pairs[pair_key]["epipolar_matches_left"],
                     _,
-                ) = self.sparse_mtch_sift_app.run(
+                ) = self.sparse_mtch_app.run(
                     self.pairs[pair_key]["epipolar_image_left"],
                     self.pairs[pair_key]["epipolar_image_right"],
                     self.pairs[pair_key]["grid_left"]["disp_to_alt_ratio"],
                     orchestrator=self.cars_orchestrator,
                     pair_folder=os.path.join(
-                        self.dump_dir, "sparse_matching.sift", pair_key
+                        self.dump_dir, "sparse_matching", pair_key
                     ),
                     pair_key=pair_key,
                 )
@@ -1156,12 +1092,14 @@ class UnitPipeline(PipelineTemplate):
             # Run cluster breakpoint to compute sifts: force computation
             self.cars_orchestrator.breakpoint()
 
+            minimum_nb_matches = self.sparse_mtch_app.get_minimum_nb_matches()
+
             # Run grid correction application
-            if self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is False:
+            if self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI] in (None, {}):
                 # Estimate grid correction if no epipolar a priori
                 # Filter and save matches
                 self.pairs[pair_key]["matches_array"] = (
-                    self.sparse_mtch_sift_app.filter_matches(
+                    self.sparse_mtch_app.filter_matches(
                         self.pairs[pair_key]["epipolar_matches_left"],
                         self.pairs[pair_key]["grid_left"],
                         self.pairs[pair_key]["grid_right"],
@@ -1169,18 +1107,12 @@ class UnitPipeline(PipelineTemplate):
                         orchestrator=self.cars_orchestrator,
                         pair_key=pair_key,
                         pair_folder=os.path.join(
-                            self.dump_dir, "sparse_matching.sift", pair_key
-                        ),
-                        save_matches=(
-                            self.sparse_mtch_sift_app.get_save_matches()
+                            self.dump_dir, "sparse_matching", pair_key
                         ),
+                        save_matches=(self.sparse_mtch_app.get_save_matches()),
                     )
                 )
 
-                minimum_nb_matches = (
-                    self.sparse_mtch_sift_app.get_minimum_nb_matches()
-                )
-
                 # Compute grid correction
                 (
                     self.pairs[pair_key]["grid_correction_coef"],
@@ -1217,7 +1149,7 @@ class UnitPipeline(PipelineTemplate):
                     pair_key
                 ]["grid_left"]
 
-                if self.quit_on_app("sparse_matching.sift"):
+                if self.quit_on_app("sparse_matching"):
                     continue
 
                 # Shrink disparity intervals according to SIFT disparities
@@ -1225,7 +1157,7 @@ class UnitPipeline(PipelineTemplate):
                     "disp_to_alt_ratio"
                 ]
                 disp_bounds_params = (
-                    self.sparse_mtch_sift_app.disparity_bounds_estimation
+                    self.sparse_mtch_app.disparity_bounds_estimation
                 )
 
                 if disp_bounds_params["activated"]:
@@ -1253,11 +1185,11 @@ class UnitPipeline(PipelineTemplate):
                     )
                 else:
                     disp_min = (
-                        -self.sparse_mtch_sift_app.elevation_delta_upper_bound
+                        -self.sparse_mtch_app.elevation_delta_upper_bound
                         / disp_to_alt_ratio
                     )
                     disp_max = (
-                        -self.sparse_mtch_sift_app.elevation_delta_lower_bound
+                        -self.sparse_mtch_app.elevation_delta_lower_bound
                         / disp_to_alt_ratio
                     )
                     logging.info(
@@ -1300,12 +1232,11 @@ class UnitPipeline(PipelineTemplate):
         if (
             self.quit_on_app("grid_generation")
             or self.quit_on_app("resampling")
-            or self.quit_on_app("hole_detection")
-            or self.quit_on_app("sparse_matching.sift")
+            or self.quit_on_app("sparse_matching")
         ):
             return True
 
-        if self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI]:
+        if not self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI] in (None, {}):
             # Use a priori
             dem_median = self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI][
                 adv_cst.DEM_MEDIAN
@@ -1316,50 +1247,10 @@ class UnitPipeline(PipelineTemplate):
             dem_max = self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI][
                 adv_cst.DEM_MAX
             ]
-            altitude_delta_min = self.used_conf[ADVANCED][
-                adv_cst.TERRAIN_A_PRIORI
-            ][adv_cst.ALTITUDE_DELTA_MIN]
-            altitude_delta_max = self.used_conf[ADVANCED][
-                adv_cst.TERRAIN_A_PRIORI
-            ][adv_cst.ALTITUDE_DELTA_MAX]
-
-            # update used configuration with terrain a priori
-            if None not in (altitude_delta_min, altitude_delta_max):
-                advanced_parameters.update_conf(
-                    self.used_conf,
-                    dem_median=dem_median,
-                    altitude_delta_min=altitude_delta_min,
-                    altitude_delta_max=altitude_delta_max,
-                )
-            else:
-                advanced_parameters.update_conf(
-                    self.used_conf,
-                    dem_median=dem_median,
-                    dem_min=dem_min,
-                    dem_max=dem_max,
-                )
-
-            advanced_parameters.update_conf(
-                self.config_full_res,
-                dem_median=dem_median,
-                dem_min=dem_min,
-                dem_max=dem_max,
-            )
-
-        # quit only after the configuration was updated
-        if self.quit_on_app("dem_generation"):
-            return True
 
         # Define param
         use_global_disp_range = self.dense_matching_app.use_global_disp_range
 
-        if self.pc_denoising_application is not None:
-            denoising_overload_fun = (
-                self.pc_denoising_application.get_triangulation_overload()
-            )
-        else:
-            denoising_overload_fun = None
-
         self.pairs_names = [
             pair_name for pair_name, _, _ in self.list_sensor_pairs
         ]
@@ -1368,7 +1259,7 @@ class UnitPipeline(PipelineTemplate):
             # Geometry plugin with dem will be used for the grid generation
             geom_plugin = self.geom_plugin_with_dem_and_geoid
 
-            if self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is False:
+            if self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI] in (None, {}):
                 save_matches = True
 
                 (
@@ -1384,7 +1275,8 @@ class UnitPipeline(PipelineTemplate):
                     save_matches=save_matches,
                 )
             elif (
-                self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is True
+                not self.used_conf[ADVANCED][adv_cst.TERRAIN_A_PRIORI]
+                in (None, {})
                 and not self.use_sift_a_priori
             ):
                 # Use epipolar a priori
@@ -1395,7 +1287,7 @@ class UnitPipeline(PipelineTemplate):
                     ][pair_key][adv_cst.DISPARITY_RANGE]
 
                     advanced_parameters.update_conf(
-                        self.config_full_res,
+                        self.refined_conf,
                         dmin=dmin,
                         dmax=dmax,
                         pair_key=pair_key,
@@ -1434,7 +1326,7 @@ class UnitPipeline(PipelineTemplate):
                 # Correct grids with former matches
                 # Transform matches to new grids
 
-                save_matches = self.sparse_mtch_sift_app.get_save_matches()
+                save_matches = self.sparse_mtch_app.get_save_matches()
 
                 self.sensor_matches_left = os.path.join(
                     self.first_res_out_dir,
@@ -1475,6 +1367,7 @@ class UnitPipeline(PipelineTemplate):
                     new_grid_matches_array,
                     self.pairs[pair_key]["grid_right"],
                     save_matches=save_matches,
+                    minimum_nb_matches=minimum_nb_matches,
                     pair_folder=os.path.join(
                         self.dump_dir, "grid_correction", "new", pair_key
                     ),
@@ -1515,28 +1408,19 @@ class UnitPipeline(PipelineTemplate):
                 right=True,
             )
 
-            # Update used_conf configuration with epipolar a priori
-            # Add global min and max computed with grids
-            advanced_parameters.update_conf(
-                self.used_conf,
-                grid_correction_coef=self.pairs[pair_key][
-                    "grid_correction_coef"
-                ],
-                pair_key=pair_key,
-            )
+            # Update refined_conf configuration with epipolar a priori
             advanced_parameters.update_conf(
-                self.config_full_res,
+                self.refined_conf,
                 grid_correction_coef=self.pairs[pair_key][
                     "grid_correction_coef"
                 ],
                 pair_key=pair_key,
+                reference_dem=self.used_conf[INPUTS][
+                    sens_cst.INITIAL_ELEVATION
+                ][sens_cst.DEM_PATH],
             )
             # saved used configuration
-            cars_dataset.save_dict(
-                self.used_conf,
-                os.path.join(self.out_dir, "used_conf.json"),
-                safe_save=True,
-            )
+            self.save_configurations()
 
             # Generate min and max disp grids
             # Global disparity min and max will be computed from
@@ -1545,11 +1429,9 @@ class UnitPipeline(PipelineTemplate):
                 self.dump_dir, "dense_matching", pair_key
             )
 
-            if (
-                self.which_resolution in ("first", "single")
-                and self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI]
-                is False
-            ):
+            if self.which_resolution in ("first", "single") and self.used_conf[
+                ADVANCED
+            ][adv_cst.TERRAIN_A_PRIORI] in (None, {}):
                 dmin = disp_min / self.res_resamp
                 dmax = disp_max / self.res_resamp
                 # generate_disparity_grids runs orchestrator.breakpoint()
@@ -1565,7 +1447,7 @@ class UnitPipeline(PipelineTemplate):
                     )
                 )
 
-                dsp_marg = self.sparse_mtch_sift_app.get_disparity_margin()
+                dsp_marg = self.sparse_mtch_app.get_disparity_margin()
                 updating_infos = {
                     application_constants.APPLICATION_TAG: {
                         sm_cst.DISPARITY_RANGE_COMPUTATION_TAG: {
@@ -1580,42 +1462,26 @@ class UnitPipeline(PipelineTemplate):
                 self.cars_orchestrator.update_out_info(updating_infos)
 
                 advanced_parameters.update_conf(
-                    self.config_full_res,
+                    self.refined_conf,
                     dmin=dmin,
                     dmax=dmax,
                     pair_key=pair_key,
                 )
             else:
-                if None in (altitude_delta_min, altitude_delta_max):
-                    # Generate min and max disp grids from dems
-                    # generate_disparity_grids runs orchestrator.breakpoint()
-                    self.pairs[pair_key]["disp_range_grid"] = (
-                        self.dense_matching_app.generate_disparity_grids(
-                            self.pairs[pair_key]["sensor_image_right"],
-                            self.pairs[pair_key]["corrected_grid_right"],
-                            self.geom_plugin_with_dem_and_geoid,
-                            dem_min=dem_min,
-                            dem_max=dem_max,
-                            dem_median=dem_median,
-                            pair_folder=dense_matching_pair_folder,
-                            orchestrator=self.cars_orchestrator,
-                        )
-                    )
-                else:
-                    # Generate min and max disp grids from deltas
-                    # generate_disparity_grids runs orchestrator.breakpoint()
-                    self.pairs[pair_key]["disp_range_grid"] = (
-                        self.dense_matching_app.generate_disparity_grids(
-                            self.pairs[pair_key]["sensor_image_right"],
-                            self.pairs[pair_key]["corrected_grid_right"],
-                            self.geom_plugin_with_dem_and_geoid,
-                            altitude_delta_min=altitude_delta_min,
-                            altitude_delta_max=altitude_delta_max,
-                            dem_median=dem_median,
-                            pair_folder=dense_matching_pair_folder,
-                            orchestrator=self.cars_orchestrator,
-                        )
+                # Generate min and max disp grids from dems
+                # generate_disparity_grids runs orchestrator.breakpoint()
+                self.pairs[pair_key]["disp_range_grid"] = (
+                    self.dense_matching_app.generate_disparity_grids(
+                        self.pairs[pair_key]["sensor_image_right"],
+                        self.pairs[pair_key]["corrected_grid_right"],
+                        self.geom_plugin_with_dem_and_geoid,
+                        dem_min=dem_min,
+                        dem_max=dem_max,
+                        dem_median=dem_median,
+                        pair_folder=dense_matching_pair_folder,
+                        orchestrator=self.cars_orchestrator,
                     )
+                )
 
                 if use_global_disp_range:
                     # Generate min and max disp grids from constants
@@ -1631,7 +1497,7 @@ class UnitPipeline(PipelineTemplate):
                         ]
 
                         # update orchestrator_out_json
-                        marg = self.sparse_mtch_sift_app.get_disparity_margin()
+                        marg = self.sparse_mtch_app.get_disparity_margin()
                         updating_infos = {
                             application_constants.APPLICATION_TAG: {
                                 sm_cst.DISPARITY_RANGE_COMPUTATION_TAG: {
@@ -1646,7 +1512,7 @@ class UnitPipeline(PipelineTemplate):
                         self.cars_orchestrator.update_out_info(updating_infos)
 
                         advanced_parameters.update_conf(
-                            self.config_full_res,
+                            self.refined_conf,
                             dmin=dmin,
                             dmax=dmax,
                             pair_key=pair_key,
@@ -1669,24 +1535,20 @@ class UnitPipeline(PipelineTemplate):
             # Update used_conf configuration with epipolar a priori
             # Add global min and max computed with grids
             advanced_parameters.update_conf(
-                self.used_conf,
+                self.refined_conf,
                 dmin=self.pairs[pair_key]["disp_range_grid"]["global_min"],
                 dmax=self.pairs[pair_key]["disp_range_grid"]["global_max"],
                 pair_key=pair_key,
             )
             advanced_parameters.update_conf(
-                self.config_full_res,
+                self.refined_conf,
                 dmin=self.pairs[pair_key]["disp_range_grid"]["global_min"],
                 dmax=self.pairs[pair_key]["disp_range_grid"]["global_max"],
                 pair_key=pair_key,
             )
 
             # saved used configuration
-            cars_dataset.save_dict(
-                self.used_conf,
-                os.path.join(self.out_dir, "used_conf.json"),
-                safe_save=True,
-            )
+            self.save_configurations()
 
             # end of for loop, to finish computing disparity range grids
 
@@ -1743,6 +1605,10 @@ class UnitPipeline(PipelineTemplate):
                 )
             )
 
+            # Quick fix to reduce memory usage
+            if self.res_resamp >= 16:
+                optimum_tile_size = 200
+
             # Run third epipolar resampling
             (
                 new_epipolar_image_left,
@@ -1781,6 +1647,7 @@ class UnitPipeline(PipelineTemplate):
                     geoid=self.used_conf[ADVANCED][adv_cst.GROUND_TRUTH_DSM][
                         adv_cst.INPUT_GEOID
                     ],
+                    scaling_coeff=self.scaling_coeff,
                 )
                 self.ground_truth_reprojection.run(
                     self.pairs[pair_key]["sensor_image_left"],
@@ -1804,105 +1671,6 @@ class UnitPipeline(PipelineTemplate):
                     ),
                 )
 
-            # Run epipolar matching application
-            epipolar_disparity_map = self.dense_matching_app.run(
-                new_epipolar_image_left,
-                new_epipolar_image_right,
-                local_tile_optimal_size_fun,
-                orchestrator=self.cars_orchestrator,
-                pair_folder=os.path.join(
-                    self.dump_dir, "dense_matching", pair_key
-                ),
-                pair_key=pair_key,
-                disp_range_grid=self.pairs[pair_key]["disp_range_grid"],
-                compute_disparity_masks=False,
-                margins_to_keep=(
-                    self.pc_outlier_removal_1_app.get_epipolar_margin()
-                    + self.pc_outlier_removal_2_app.get_epipolar_margin()
-                ),
-                texture_bands=texture_bands_indices,
-            )
-
-            if self.quit_on_app("dense_matching"):
-                continue  # keep iterating over pairs, but don't go further
-
-            # Dense matches filling
-            if self.dense_match_filling_1.used_method == "plane":
-                # Fill holes in disparity map
-                (filled_with_1_epipolar_disparity_map) = (
-                    self.dense_match_filling_1.run(
-                        epipolar_disparity_map,
-                        self.pairs[pair_key]["holes_bbox_left"],
-                        self.pairs[pair_key]["holes_bbox_right"],
-                        disp_min=self.pairs[pair_key]["disp_range_grid"][
-                            "global_min"
-                        ],
-                        disp_max=np.max(
-                            self.pairs[pair_key]["disp_range_grid"][
-                                "global_max"
-                            ]
-                        ),
-                        orchestrator=self.cars_orchestrator,
-                        pair_folder=os.path.join(
-                            self.dump_dir, "dense_match_filling_1", pair_key
-                        ),
-                        pair_key=pair_key,
-                    )
-                )
-            else:
-                # Fill with zeros
-                (filled_with_1_epipolar_disparity_map) = (
-                    self.dense_match_filling_1.run(
-                        epipolar_disparity_map,
-                        orchestrator=self.cars_orchestrator,
-                        pair_folder=os.path.join(
-                            self.dump_dir, "dense_match_filling_1", pair_key
-                        ),
-                        pair_key=pair_key,
-                    )
-                )
-
-            if self.quit_on_app("dense_match_filling.1"):
-                continue  # keep iterating over pairs, but don't go further
-
-            if self.dense_match_filling_2.used_method == "plane":
-                # Fill holes in disparity map
-                (filled_with_2_epipolar_disparity_map) = (
-                    self.dense_match_filling_2.run(
-                        filled_with_1_epipolar_disparity_map,
-                        self.pairs[pair_key]["holes_bbox_left"],
-                        self.pairs[pair_key]["holes_bbox_right"],
-                        disp_min=self.pairs[pair_key]["disp_range_grid"][
-                            "global_min"
-                        ],
-                        disp_max=np.max(
-                            self.pairs[pair_key]["disp_range_grid"][
-                                "global_max"
-                            ]
-                        ),
-                        orchestrator=self.cars_orchestrator,
-                        pair_folder=os.path.join(
-                            self.dump_dir, "dense_match_filling_2", pair_key
-                        ),
-                        pair_key=pair_key,
-                    )
-                )
-            else:
-                # Fill with zeros
-                (filled_with_2_epipolar_disparity_map) = (
-                    self.dense_match_filling_2.run(
-                        filled_with_1_epipolar_disparity_map,
-                        orchestrator=self.cars_orchestrator,
-                        pair_folder=os.path.join(
-                            self.dump_dir, "dense_match_filling_2", pair_key
-                        ),
-                        pair_key=pair_key,
-                    )
-                )
-
-            if self.quit_on_app("dense_match_filling.2"):
-                continue  # keep iterating over pairs, but don't go further
-
             if self.epsg is None:
                 # compute epsg
                 # Epsg uses global disparity min and max
@@ -1924,6 +1692,131 @@ class UnitPipeline(PipelineTemplate):
                     self.input_roi_poly, self.input_roi_epsg, self.epsg
                 )
 
+            self.vertical_crs = projection.get_output_crs(self.epsg, output)
+
+            if (
+                self.save_output_dsm
+                or self.save_output_point_cloud
+                or self.dense_matching_app.get_method() == "auto"
+            ):
+                # Compute terrain bounding box /roi related to
+                # current images
+                (current_terrain_roi_bbox, intersection_poly) = (
+                    preprocessing.compute_terrain_bbox(
+                        self.pairs[pair_key]["sensor_image_left"],
+                        self.pairs[pair_key]["sensor_image_right"],
+                        new_epipolar_image_left,
+                        self.pairs[pair_key]["corrected_grid_left"],
+                        self.pairs[pair_key]["corrected_grid_right"],
+                        self.epsg,
+                        self.geom_plugin_with_dem_and_geoid,
+                        resolution=self.resolution,
+                        disp_min=self.pairs[pair_key]["disp_range_grid"][
+                            "global_min"
+                        ],
+                        disp_max=self.pairs[pair_key]["disp_range_grid"][
+                            "global_max"
+                        ],
+                        roi_poly=(
+                            None if self.debug_with_roi else self.roi_poly
+                        ),
+                        orchestrator=self.cars_orchestrator,
+                        pair_key=pair_key,
+                        pair_folder=os.path.join(
+                            self.dump_dir, "terrain_bbox", pair_key
+                        ),
+                        check_inputs=False,
+                    )
+                )
+                self.list_terrain_roi.append(current_terrain_roi_bbox)
+                self.list_intersection_poly.append(intersection_poly)
+
+                # compute terrain bounds for later use
+                (
+                    self.terrain_bounds,
+                    self.optimal_terrain_tile_width,
+                ) = preprocessing.compute_terrain_bounds(
+                    self.list_terrain_roi,
+                    roi_poly=(None if self.debug_with_roi else self.roi_poly),
+                    resolution=self.resolution,
+                )
+
+                if self.which_resolution not in ("final", "single"):
+                    self.terrain_bounds = dem_wrappers.modify_terrain_bounds(
+                        self.terrain_bounds,
+                        self.dem_generation_application.margin[0],
+                        self.dem_generation_application.margin[1],
+                    )
+
+            if self.dense_matching_app.get_method() == "auto":
+                # Copy the initial corr_config in order to keep
+                # the inputs that have already been checked
+                corr_cfg = self.dense_matching_app.corr_config.copy()
+
+                # Find the conf that correspond to the land cover map
+                conf = self.dense_matching_app.loader.find_auto_conf(
+                    intersection_poly,
+                    self.land_cover_map,
+                    self.classification_to_config_mapping,
+                    self.epsg,
+                )
+
+                # Update the used_conf if order to reinitialize
+                # the dense matching app
+                # Because we kept the information regarding the ambiguity,
+                # performance_map calculus..
+                self.used_conf["applications"]["dense_matching"][
+                    "loader_conf"
+                ] = conf
+                self.used_conf["applications"]["dense_matching"][
+                    "method"
+                ] = "custom"
+
+                # Re initialization of the dense matching application
+                self.dense_matching_app = Application(
+                    "dense_matching",
+                    cfg=self.used_conf["applications"]["dense_matching"],
+                )
+
+                # Update the corr_config with the inputs that have
+                # already been checked
+                self.dense_matching_app.corr_config["input"] = corr_cfg["input"]
+
+            # Run epipolar matching application
+            epipolar_disparity_map = self.dense_matching_app.run(
+                new_epipolar_image_left,
+                new_epipolar_image_right,
+                local_tile_optimal_size_fun,
+                orchestrator=self.cars_orchestrator,
+                pair_folder=os.path.join(
+                    self.dump_dir, "dense_matching", pair_key
+                ),
+                pair_key=pair_key,
+                disp_range_grid=self.pairs[pair_key]["disp_range_grid"],
+                compute_disparity_masks=False,
+                margins_to_keep=sum(
+                    app.get_epipolar_margin()
+                    for _, app in self.pc_outlier_removal_apps.items()
+                ),
+                texture_bands=texture_bands_indices,
+            )
+
+            if self.quit_on_app("dense_matching"):
+                continue  # keep iterating over pairs, but don't go further
+
+            # Fill with zeros
+            (filled_epipolar_disparity_map) = self.dense_match_filling.run(
+                epipolar_disparity_map,
+                orchestrator=self.cars_orchestrator,
+                pair_folder=os.path.join(
+                    self.dump_dir, "dense_match_filling", pair_key
+                ),
+                pair_key=pair_key,
+            )
+
+            if self.quit_on_app("dense_match_filling"):
+                continue  # keep iterating over pairs, but don't go further
+
             if isinstance(output[sens_cst.GEOID], str):
                 output_geoid_path = output[sens_cst.GEOID]
             elif (
@@ -1943,7 +1836,6 @@ class UnitPipeline(PipelineTemplate):
                 output_geoid_path = None
 
             depth_map_dir = None
-            last_depth_map_application = None
             if self.save_output_depth_map:
                 depth_map_dir = os.path.join(
                     self.out_dir, "depth_map", pair_key
@@ -1957,33 +1849,9 @@ class UnitPipeline(PipelineTemplate):
                 )
                 safe_makedirs(point_cloud_dir)
 
-            if self.save_output_depth_map or self.save_output_point_cloud:
-                if (
-                    self.pc_outlier_removal_2_app.used_config.get(
-                        "activated", False
-                    )
-                    is True
-                    and self.merging is False
-                ):
-                    last_depth_map_application = "pc_outlier_removal_2"
-                elif (
-                    self.pc_outlier_removal_1_app.used_config.get(
-                        "activated", False
-                    )
-                    is True
-                    and self.merging is False
-                ):
-                    last_depth_map_application = "pc_outlier_removal_1"
-                else:
-                    last_depth_map_application = "triangulation"
-
             triangulation_point_cloud_dir = (
                 point_cloud_dir
-                if (
-                    point_cloud_dir
-                    and last_depth_map_application == "triangulation"
-                    and self.merging is False
-                )
+                if (point_cloud_dir and len(self.pc_outlier_removal_apps) == 0)
                 else None
             )
 
@@ -1993,11 +1861,11 @@ class UnitPipeline(PipelineTemplate):
                 self.pairs[pair_key]["sensor_image_right"],
                 self.pairs[pair_key]["corrected_grid_left"],
                 self.pairs[pair_key]["corrected_grid_right"],
-                filled_with_2_epipolar_disparity_map,
+                filled_epipolar_disparity_map,
                 self.geom_plugin_without_dem_and_geoid,
                 new_epipolar_image_left,
                 epsg=self.epsg,
-                denoising_overload_fun=denoising_overload_fun,
+                denoising_overload_fun=None,
                 source_pc_names=self.pairs_names,
                 orchestrator=self.cars_orchestrator,
                 pair_dump_dir=os.path.join(
@@ -2012,8 +1880,10 @@ class UnitPipeline(PipelineTemplate):
                 ),
                 depth_map_dir=depth_map_dir,
                 point_cloud_dir=triangulation_point_cloud_dir,
-                save_output_coordinates=last_depth_map_application
-                == "triangulation",
+                save_output_coordinates=(len(self.pc_outlier_removal_apps) == 0)
+                and (
+                    self.save_output_depth_map or self.save_output_point_cloud
+                ),
                 save_output_color=bool(depth_map_dir)
                 and self.auxiliary[out_cst.AUX_TEXTURE],
                 save_output_classification=bool(depth_map_dir)
@@ -2031,158 +1901,49 @@ class UnitPipeline(PipelineTemplate):
             if self.quit_on_app("triangulation"):
                 continue  # keep iterating over pairs, but don't go further
 
-            if self.merging:
-                self.list_epipolar_point_clouds.append(epipolar_point_cloud)
-            else:
-                filtering_depth_map_dir = (
-                    depth_map_dir
-                    if (
-                        depth_map_dir
-                        and last_depth_map_application == "pc_outlier_removal_1"
-                    )
-                    else None
-                )
-                filtering_point_cloud_dir = (
-                    point_cloud_dir
-                    if (
-                        point_cloud_dir
-                        and last_depth_map_application == "pc_outlier_removal_1"
-                        and self.merging is False
-                    )
-                    else None
-                )
+            filtered_epipolar_point_cloud = epipolar_point_cloud
+            for app_key, app in self.pc_outlier_removal_apps.items():
 
-                filtered_epipolar_point_cloud_1 = (
-                    self.pc_outlier_removal_1_app.run(
-                        epipolar_point_cloud,
-                        depth_map_dir=filtering_depth_map_dir,
-                        point_cloud_dir=filtering_point_cloud_dir,
-                        dump_dir=os.path.join(
-                            self.dump_dir, "pc_outlier_removal_1", pair_key
-                        ),
-                        epsg=self.epsg,
-                        orchestrator=self.cars_orchestrator,
-                    )
+                app_key_is_last = (
+                    app_key == list(self.pc_outlier_removal_apps)[-1]
                 )
-                if self.quit_on_app("point_cloud_outlier_removal.1"):
-                    continue  # keep iterating over pairs, but don't go further
                 filtering_depth_map_dir = (
-                    depth_map_dir
-                    if (
-                        depth_map_dir
-                        and last_depth_map_application == "pc_outlier_removal_2"
-                    )
-                    else None
+                    depth_map_dir if app_key_is_last else None
                 )
                 filtering_point_cloud_dir = (
-                    point_cloud_dir
-                    if (
-                        point_cloud_dir
-                        and last_depth_map_application == "pc_outlier_removal_2"
-                        and self.merging is False
-                    )
-                    else None
-                )
-                filtered_epipolar_point_cloud_2 = (
-                    self.pc_outlier_removal_2_app.run(
-                        filtered_epipolar_point_cloud_1,
-                        depth_map_dir=filtering_depth_map_dir,
-                        point_cloud_dir=filtering_point_cloud_dir,
-                        dump_dir=os.path.join(
-                            self.dump_dir, "pc_outlier_removal_2", pair_key
+                    point_cloud_dir if app_key_is_last else None
+                )
+
+                filtered_epipolar_point_cloud = app.run(
+                    filtered_epipolar_point_cloud,
+                    depth_map_dir=filtering_depth_map_dir,
+                    point_cloud_dir=filtering_point_cloud_dir,
+                    dump_dir=os.path.join(
+                        self.dump_dir,
+                        (  # pylint: disable=inconsistent-quotes
+                            f"pc_outlier_removal"
+                            f"{str(app_key[27:]).replace('.', '_')}"
                         ),
-                        epsg=self.epsg,
-                        orchestrator=self.cars_orchestrator,
-                    )
-                )
-                if self.quit_on_app("point_cloud_outlier_removal.2"):
-                    continue  # keep iterating over pairs, but don't go further
-
-                # denoising available only if we'll go further in the pipeline
-                if self.save_output_dsm or self.save_output_point_cloud:
-                    denoised_epipolar_point_clouds = (
-                        self.pc_denoising_application.run(
-                            filtered_epipolar_point_cloud_2,
-                            orchestrator=self.cars_orchestrator,
-                            pair_folder=os.path.join(
-                                self.dump_dir, "denoising", pair_key
-                            ),
-                            pair_key=pair_key,
-                        )
-                    )
-
-                    self.list_epipolar_point_clouds.append(
-                        denoised_epipolar_point_clouds
-                    )
-
-                    if self.quit_on_app("pc_denoising"):
-                        # keep iterating over pairs, but don't go further
-                        continue
-
-            if self.save_output_dsm or self.save_output_point_cloud:
-                # Compute terrain bounding box /roi related to
-                # current images
-                (current_terrain_roi_bbox, intersection_poly) = (
-                    preprocessing.compute_terrain_bbox(
-                        self.pairs[pair_key]["sensor_image_left"],
-                        self.pairs[pair_key]["sensor_image_right"],
-                        new_epipolar_image_left,
-                        self.pairs[pair_key]["corrected_grid_left"],
-                        self.pairs[pair_key]["corrected_grid_right"],
-                        self.epsg,
-                        self.geom_plugin_with_dem_and_geoid,
-                        resolution=self.resolution,
-                        disp_min=self.pairs[pair_key]["disp_range_grid"][
-                            "global_min"
-                        ],
-                        disp_max=self.pairs[pair_key]["disp_range_grid"][
-                            "global_max"
-                        ],
-                        roi_poly=(
-                            None if self.debug_with_roi else self.roi_poly
-                        ),
-                        orchestrator=self.cars_orchestrator,
-                        pair_key=pair_key,
-                        pair_folder=os.path.join(
-                            self.dump_dir, "terrain_bbox", pair_key
-                        ),
-                        check_inputs=False,
-                    )
-                )
-                self.list_terrain_roi.append(current_terrain_roi_bbox)
-                self.list_intersection_poly.append(intersection_poly)
-
-                # compute terrain bounds for later use
-                (
-                    self.terrain_bounds,
-                    self.optimal_terrain_tile_width,
-                ) = preprocessing.compute_terrain_bounds(
-                    self.list_terrain_roi,
-                    roi_poly=(None if self.debug_with_roi else self.roi_poly),
-                    resolution=self.resolution,
+                        pair_key,
+                    ),
+                    epsg=self.epsg,
+                    orchestrator=self.cars_orchestrator,
                 )
+            if self.quit_on_app("point_cloud_outlier_removal"):
+                continue  # keep iterating over pairs, but don't go further
 
-                if self.which_resolution not in ("final", "single"):
-                    if self.dem_generation_roi is not None:
-                        # To get the correct size for the dem generation
-                        self.terrain_bounds = (
-                            dem_wrappers.modify_terrain_bounds(
-                                self.dem_generation_roi,
-                                self.epsg,
-                                self.dem_generation_application.margin,
-                            )
-                        )
+            self.list_epipolar_point_clouds.append(
+                filtered_epipolar_point_cloud
+            )
 
         # quit if any app in the loop over the pairs was the last one
         # pylint:disable=too-many-boolean-expressions
         if (
             self.quit_on_app("dense_matching")
-            or self.quit_on_app("dense_match_filling.1")
-            or self.quit_on_app("dense_match_filling.2")
+            or self.quit_on_app("dense_match_filling")
             or self.quit_on_app("triangulation")
             or self.quit_on_app("point_cloud_outlier_removal.1")
             or self.quit_on_app("point_cloud_outlier_removal.2")
-            or self.quit_on_app("pc_denoising")
         ):
             return True
 
@@ -2312,6 +2073,7 @@ class UnitPipeline(PipelineTemplate):
         _ = self.rasterization_application.run(
             self.point_cloud_to_rasterize,
             self.epsg,
+            self.vertical_crs,
             resolution=self.resolution,
             orchestrator=self.cars_orchestrator,
             dsm_file_name=dsm_file_name,
@@ -2419,20 +2181,60 @@ class UnitPipeline(PipelineTemplate):
                         sens_cst.DEM_PATH
                     ]
                 ),
+                default_alt=self.geom_plugin_with_dem_and_geoid.default_alt,
                 cars_orchestrator=self.cars_orchestrator,
             )
 
+            # Update refined conf configuration with dem paths
             dem_median = paths["dem_median"]
             dem_min = paths["dem_min"]
             dem_max = paths["dem_max"]
 
             advanced_parameters.update_conf(
-                self.used_conf,
+                self.refined_conf,
                 dem_median=dem_median,
                 dem_min=dem_min,
                 dem_max=dem_max,
             )
 
+            if self.used_conf[ADVANCED][USE_ENDOGENOUS_DEM]:
+                # Generate new geom plugin with dem
+                output_dem_dir = os.path.join(
+                    self.dump_dir, "initial_elevation"
+                )
+                new_geom_plugin = (
+                    sensor_inputs.generate_geometry_plugin_with_dem(
+                        self.geometry_plugin,
+                        self.used_conf[INPUTS],
+                        dem=dem_median,
+                        output_dem_dir=output_dem_dir,
+                    )
+                )
+
+                for (
+                    pair_key,
+                    _,
+                    _,
+                ) in self.list_sensor_pairs:
+                    new_grid_correction_coef = (
+                        self.generate_grid_correction_on_dem(
+                            pair_key,
+                            new_geom_plugin,
+                        )
+                    )
+                    if new_grid_correction_coef is not None:
+                        # Update refined_conf configuration with epipolar
+                        # a priori
+                        advanced_parameters.update_conf(
+                            self.refined_conf,
+                            grid_correction_coef=new_grid_correction_coef,
+                            pair_key=pair_key,
+                            reference_dem=dem_median,
+                        )
+
+        # saved used configuration
+        self.save_configurations()
+
         return False
 
     def filling(self):  # noqa: C901 : too complex
@@ -2440,10 +2242,6 @@ class UnitPipeline(PipelineTemplate):
         Fill the dsm
         """
 
-        dsm_filling_1_dump_dir = os.path.join(self.dump_dir, "dsm_filling_1")
-        dsm_filling_2_dump_dir = os.path.join(self.dump_dir, "dsm_filling_2")
-        dsm_filling_3_dump_dir = os.path.join(self.dump_dir, "dsm_filling_3")
-
         dsm_file_name = (
             os.path.join(
                 self.out_dir,
@@ -2549,6 +2347,7 @@ class UnitPipeline(PipelineTemplate):
             )
 
             self.epsg = rasterio_get_epsg(dict_path["dsm"][0])
+            self.vertical_crs = rasterio_get_crs(dict_path["dsm"][0])
 
             # Compute roi polygon, in input EPSG
             self.roi_poly = preprocessing.compute_roi_poly(
@@ -2678,47 +2477,56 @@ class UnitPipeline(PipelineTemplate):
                     )
 
                     # Project polygon if epsg is different
-                    if self.epsg != inter_epsg:
-                        inter_poly = projection.polygon_projection(
-                            inter_poly, inter_epsg, self.epsg
+                    if self.vertical_crs != CRS(inter_epsg):
+                        inter_poly = projection.polygon_projection_crs(
+                            inter_poly, CRS(inter_epsg), self.vertical_crs
                         )
 
                 self.list_intersection_poly.append(inter_poly)
             else:
                 self.list_intersection_poly = None
 
-        _ = self.dsm_filling_1_application.run(
-            dsm_file=dsm_file_name,
-            classif_file=classif_file_name,
-            filling_file=filling_file_name,
-            dump_dir=dsm_filling_1_dump_dir,
-            roi_polys=self.list_intersection_poly,
-            roi_epsg=self.epsg,
-            output_geoid=self.used_conf[OUTPUT][sens_cst.GEOID],
-            geom_plugin=self.geom_plugin_with_dem_and_geoid,
-        )
-
-        if not self.dsm_filling_1_application.save_intermediate_data:
-            self.cars_orchestrator.add_to_clean(dsm_filling_1_dump_dir)
-
-        if self.quit_on_app("dsm_filling.1"):
-            return True
-
-        dtm_file_name = self.dsm_filling_2_application.run(
-            dsm_file=dsm_file_name,
-            classif_file=classif_file_name,
-            filling_file=filling_file_name,
-            dump_dir=dsm_filling_2_dump_dir,
-            roi_polys=self.list_intersection_poly,
-            roi_epsg=self.epsg,
-            orchestrator=self.cars_orchestrator,
-        )
-
-        if not self.dsm_filling_2_application.save_intermediate_data:
-            self.cars_orchestrator.add_to_clean(dsm_filling_2_dump_dir)
+        dtm_file_name = None
+        for app_key, app in self.dsm_filling_apps.items():
+
+            app_dump_dir = os.path.join(
+                self.dump_dir, app_key.replace(".", "_")
+            )
+
+            if app.get_conf()["method"] == "exogenous_filling":
+                _ = app.run(
+                    dsm_file=dsm_file_name,
+                    classif_file=classif_file_name,
+                    filling_file=filling_file_name,
+                    dump_dir=app_dump_dir,
+                    roi_polys=self.list_intersection_poly,
+                    roi_epsg=self.epsg,
+                    output_geoid=self.used_conf[OUTPUT][sens_cst.GEOID],
+                    geom_plugin=self.geom_plugin_with_dem_and_geoid,
+                )
+            elif app.get_conf()["method"] == "bulldozer":
+                dtm_file_name = app.run(
+                    dsm_file=dsm_file_name,
+                    classif_file=classif_file_name,
+                    filling_file=filling_file_name,
+                    dump_dir=app_dump_dir,
+                    roi_polys=self.list_intersection_poly,
+                    roi_epsg=self.epsg,
+                    orchestrator=self.cars_orchestrator,
+                )
+            elif app.get_conf()["method"] == "border_interpolation":
+                _ = app.run(
+                    dsm_file=dsm_file_name,
+                    classif_file=classif_file_name,
+                    filling_file=filling_file_name,
+                    dtm_file=dtm_file_name,
+                    dump_dir=app_dump_dir,
+                    roi_polys=self.list_intersection_poly,
+                    roi_epsg=self.epsg,
+                )
 
-        if self.quit_on_app("dsm_filling.2"):
-            return True
+            if not app.save_intermediate_data:
+                self.cars_orchestrator.add_to_clean(app_dump_dir)
 
         _ = self.auxiliary_filling_application.run(
             dsm_file=dsm_file_name,
@@ -2729,199 +2537,31 @@ class UnitPipeline(PipelineTemplate):
             pairing=self.used_conf[INPUTS].get("pairing"),
             geom_plugin=self.geom_plugin_with_dem_and_geoid,
             texture_bands=self.texture_bands,
+            output_geoid=self.used_conf[OUTPUT][sens_cst.GEOID],
             orchestrator=self.cars_orchestrator,
         )
-
-        if self.quit_on_app("auxiliary_filling"):
-            return True
-
         self.cars_orchestrator.breakpoint()
 
-        _ = self.dsm_filling_3_application.run(
-            dsm_file=dsm_file_name,
-            classif_file=classif_file_name,
-            filling_file=filling_file_name,
-            dtm_file=dtm_file_name,
-            dump_dir=dsm_filling_3_dump_dir,
-            roi_polys=self.list_intersection_poly,
-            roi_epsg=self.epsg,
-        )
-
-        if not self.dsm_filling_3_application.save_intermediate_data:
-            self.cars_orchestrator.add_to_clean(dsm_filling_3_dump_dir)
-
-        return self.quit_on_app("dsm_filling.3")
+        return self.quit_on_app("auxiliary_filling")
 
+    @cars_profile(name="Preprocess depth maps", interval=0.5)
     def preprocess_depth_maps(self):
         """
         Adds multiple processing steps to the depth maps :
-        Merging, denoising.
+        Merging.
         Creates the point cloud that will be rasterized in
         the last step of the pipeline.
         """
 
-        if not self.merging:
-            self.point_cloud_to_rasterize = (
-                self.list_epipolar_point_clouds,
-                self.terrain_bounds,
-            )
-            self.color_type = self.point_cloud_to_rasterize[0][
-                0
-            ].attributes.get("color_type", None)
-        else:
-            # find which application produce the final version of the
-            # point cloud. The last generated point cloud will be saved
-            # as official point cloud product if save_output_point_cloud
-            # is True.
-
-            last_pc_application = None
-            # denoising application will produce a point cloud, unless
-            # it uses the 'none' method.
-            if self.pc_denoising_application.used_method != "none":
-                last_pc_application = "denoising"
-            else:
-                last_pc_application = "fusion"
-
-            raster_app_margin = 0
-            if self.rasterization_application is not None:
-                raster_app_margin = self.rasterization_application.get_margins(
-                    self.resolution
-                )
-
-            merged_point_clouds = self.pc_fusion_application.run(
-                self.list_epipolar_point_clouds,
-                self.terrain_bounds,
-                self.epsg,
-                source_pc_names=(
-                    self.pairs_names if self.compute_depth_map else None
-                ),
-                orchestrator=self.cars_orchestrator,
-                margins=raster_app_margin,
-                optimal_terrain_tile_width=self.optimal_terrain_tile_width,
-                roi=(self.roi_poly if self.debug_with_roi else None),
-                save_laz_output=self.save_output_point_cloud
-                and last_pc_application == "fusion",
-            )
-
-            if self.quit_on_app("point_cloud_fusion"):
-                return True
-
-            # denoise point cloud
-            denoised_merged_point_clouds = self.pc_denoising_application.run(
-                merged_point_clouds,
-                orchestrator=self.cars_orchestrator,
-                save_laz_output=self.save_output_point_cloud
-                and last_pc_application == "denoising",
-            )
-
-            if self.quit_on_app("pc_denoising"):
-                return True
-
-            # Rasterize merged and filtered point cloud
-            self.point_cloud_to_rasterize = denoised_merged_point_clouds
-
-            # try getting the color type from multiple sources
-            self.color_type = self.list_epipolar_point_clouds[0].attributes.get(
-                "color_type",
-                self.point_cloud_to_rasterize.attributes.get(
-                    "color_type", None
-                ),
-            )
-
-        return False
-
-    def load_input_depth_maps(self):
-        """
-        Loads all the data and creates all the variables used
-        later when processing a depth map, as if it was just computed.
-        """
-        # get epsg
-        self.epsg = self.used_conf[OUTPUT][out_cst.EPSG]
-
-        output_parameters.intialize_product_index(
-            self.cars_orchestrator,
-            self.used_conf[OUTPUT]["product_level"],
-            self.used_conf[INPUTS][depth_cst.DEPTH_MAPS].keys(),
-        )
-
-        # compute epsg
-        epsg_cloud = pc_fusion_wrappers.compute_epsg_from_point_cloud(
-            self.used_conf[INPUTS][depth_cst.DEPTH_MAPS]
-        )
-        if self.epsg is None:
-            self.epsg = epsg_cloud
-
-        self.resolution = (
-            self.used_conf[OUTPUT][out_cst.RESOLUTION] * self.res_resamp
+        self.point_cloud_to_rasterize = (
+            self.list_epipolar_point_clouds,
+            self.terrain_bounds,
         )
-
-        # Compute roi polygon, in input EPSG
-        self.roi_poly = preprocessing.compute_roi_poly(
-            self.input_roi_poly, self.input_roi_epsg, self.epsg
+        self.color_type = self.point_cloud_to_rasterize[0][0].attributes.get(
+            "color_type", None
         )
 
-        if not self.merging:
-            # compute bounds
-            self.terrain_bounds = pc_fusion_wrappers.get_bounds(
-                self.used_conf[INPUTS][depth_cst.DEPTH_MAPS],
-                self.epsg,
-                roi_poly=self.roi_poly,
-            )
-
-            self.list_epipolar_point_clouds = (
-                pc_fusion_algo.generate_point_clouds(
-                    self.used_conf[INPUTS][depth_cst.DEPTH_MAPS],
-                    self.cars_orchestrator,
-                    tile_size=1000,
-                )
-            )
-        else:
-            # Compute terrain bounds and transform point clouds
-            (
-                self.terrain_bounds,
-                self.list_epipolar_point_clouds,
-            ) = pc_fusion_algo.transform_input_pc(
-                self.used_conf[INPUTS][depth_cst.DEPTH_MAPS],
-                self.epsg,
-                roi_poly=self.roi_poly,
-                epipolar_tile_size=1000,  # TODO change it
-                orchestrator=self.cars_orchestrator,
-            )
-
-            # Compute number of superposing point cloud for density
-            max_number_superposing_point_clouds = (
-                pc_fusion_wrappers.compute_max_nb_point_clouds(
-                    self.list_epipolar_point_clouds
-                )
-            )
-
-            # Compute average distance between two points
-            average_distance_point_cloud = (
-                pc_fusion_wrappers.compute_average_distance(
-                    self.list_epipolar_point_clouds
-                )
-            )
-            self.optimal_terrain_tile_width = (
-                self.rasterization_application.get_optimal_tile_size(
-                    self.cars_orchestrator.cluster.checked_conf_cluster[
-                        "max_ram_per_worker"
-                    ],
-                    superposing_point_clouds=(
-                        max_number_superposing_point_clouds
-                    ),
-                    point_cloud_resolution=average_distance_point_cloud,
-                )
-            )
-            # epsg_cloud and optimal_terrain_tile_width have the same epsg
-            self.optimal_terrain_tile_width = (
-                preprocessing.convert_optimal_tile_size_with_epsg(
-                    self.terrain_bounds,
-                    self.optimal_terrain_tile_width,
-                    self.epsg,
-                    epsg_cloud,
-                )
-            )
-
+    @cars_profile(name="Final cleanup", interval=0.5)
     def final_cleanup(self):
         """
         Clean temporary files and directory at the end of cars processing
@@ -2939,28 +2579,30 @@ class UnitPipeline(PipelineTemplate):
                 not any(
                     app.get("save_intermediate_data", False) is True
                     for app in self.used_conf[APPLICATIONS].values()
+                    if app is not None
                 )
                 and not self.dsms_in_inputs
             ):
                 self.cars_orchestrator.add_to_clean(self.dump_dir)
 
-    @cars_profile(name="run_dense_pipeline", interval=0.5)
-    def run(
+    @cars_profile(name="run_unit_pipeline", interval=0.5)
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
-        orchestrator_conf=None,
         generate_dems=False,
         which_resolution="single",
         use_sift_a_priori=False,
         first_res_out_dir=None,
-        final_out_dir=None,
+        log_dir=None,
     ):  # noqa C901
         """
         Run pipeline
 
         """
+        if log_dir is not None:
+            self.log_dir = log_dir
+        else:
+            self.log_dir = os.path.join(self.out_dir, "logs")
 
-        self.out_dir = self.used_conf[OUTPUT][out_cst.OUT_DIRECTORY]
-        self.dump_dir = os.path.join(self.out_dir, "dump_dir")
         self.first_res_out_dir = first_res_out_dir
         self.texture_bands = self.used_conf[ADVANCED][adv_cst.TEXTURE_BANDS]
 
@@ -2972,65 +2614,29 @@ class UnitPipeline(PipelineTemplate):
 
         self.which_resolution = which_resolution
 
-        # Save used conf
-        cars_dataset.save_dict(
-            self.used_conf,
-            os.path.join(self.out_dir, "used_conf.json"),
-            safe_save=True,
-        )
-
-        if self.which_resolution not in ("single", "final"):
-            path_used_conf_res = (
-                "used_conf_res" + str(self.res_resamp) + ".json"
-            )
-            cars_dataset.save_dict(
-                self.used_conf,
-                os.path.join(final_out_dir, path_used_conf_res),
-                safe_save=True,
-            )
-
-        if orchestrator_conf is None:
-            # start cars orchestrator
-            with orchestrator.Orchestrator(
-                orchestrator_conf=self.used_conf[ORCHESTRATOR],
-                out_dir=self.out_dir,
-                out_json_path=os.path.join(
-                    self.out_dir,
-                    out_cst.INFO_FILENAME,
-                ),
-            ) as self.cars_orchestrator:
-                # initialize out_json
-                self.cars_orchestrator.update_out_info({"version": __version__})
-
-                if not self.dsms_in_inputs:
-                    if self.compute_depth_map:
-                        self.sensor_to_depth_maps()
-                    else:
-                        self.load_input_depth_maps()
-
-                    if self.save_output_dsm or self.save_output_point_cloud:
-                        end_pipeline = self.preprocess_depth_maps()
-
-                        if self.save_output_dsm and not end_pipeline:
-                            self.rasterize_point_cloud()
-                            self.filling()
-                else:
-                    self.filling()
-
-                self.final_cleanup()
-        else:
-            self.cars_orchestrator = orchestrator_conf
+        # saved used configuration
+        self.save_configurations()
+        # start cars orchestrator
+        with orchestrator.Orchestrator(
+            orchestrator_conf=self.used_conf[ORCHESTRATOR],
+            out_dir=self.out_dir,
+            log_dir=self.log_dir,
+            out_json_path=os.path.join(
+                self.out_dir,
+                out_cst.INFO_FILENAME,
+            ),
+        ) as self.cars_orchestrator:
+            # initialize out_json
+            self.cars_orchestrator.update_out_info({"version": __version__})
 
             if not self.dsms_in_inputs:
                 if self.compute_depth_map:
                     self.sensor_to_depth_maps()
-                else:
-                    self.load_input_depth_maps()
 
                 if self.save_output_dsm or self.save_output_point_cloud:
-                    end_pipeline = self.preprocess_depth_maps()
+                    self.preprocess_depth_maps()
 
-                    if self.save_output_dsm and not end_pipeline:
+                    if self.save_output_dsm:
                         self.rasterize_point_cloud()
                         self.filling()
             else: