cars 1.0.0a1__cp311-cp311-win_amd64.whl → 1.0.0a3__cp311-cp311-win_amd64.whl

cars/pipelines/unit/unit_pipeline.py

@@ -36,6 +36,7 @@ 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__
@@ -56,6 +57,7 @@ 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,
@@ -94,7 +96,7 @@ class UnitPipeline(PipelineTemplate):
 
     # pylint: disable=too-many-instance-attributes
 
-    def __init__(self, conf, config_json_dir=None):
+    def __init__(self, conf, config_dir=None):  # noqa: C901
         """
         Creates pipeline
 
@@ -113,13 +115,17 @@ class UnitPipeline(PipelineTemplate):
         :type pipeline_name: str
         :param cfg: configuration {'matching_cost_method': value}
         :type cfg: dictionary
-        :param config_json_dir: path to dir containing json
-        :type config_json_dir: str
+        :param config_dir: path to dir containing json/yaml
+        :type config_dir: str
         """
 
         # Used conf
         self.used_conf = {}
 
+        # Transform relative path to absolute path
+        if config_dir is not None:
+            config_dir = os.path.abspath(config_dir)
+
         # Check global conf
         self.check_global_schema(conf)
 
@@ -129,9 +135,7 @@ class UnitPipeline(PipelineTemplate):
         )
 
         # Check conf inputs
-        inputs = self.check_inputs(
-            conf[INPUTS], config_json_dir=config_json_dir
-        )
+        inputs = self.check_inputs(conf[INPUTS], config_dir=config_dir)
         self.used_conf[INPUTS] = inputs
 
         # Check advanced parameters
@@ -143,6 +147,9 @@ class UnitPipeline(PipelineTemplate):
             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
         )
@@ -159,7 +166,11 @@ 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
 
         prod_level = output[out_cst.PRODUCT_LEVEL]
@@ -419,15 +430,15 @@ class UnitPipeline(PipelineTemplate):
             logging.warning(log_msg)
 
     @staticmethod
-    def check_inputs(conf, config_json_dir=None):
+    def check_inputs(conf, config_dir=None):
         """
         Check the inputs given
 
         :param conf: configuration of inputs
         :type conf: dict
-        :param config_json_dir: directory of used json, if
+        :param config_dir: directory of used json/yaml, if
             user filled paths with relative paths
-        :type config_json_dir: str
+        :type config_dir: str
 
         :return: overloaded inputs
         :rtype: dict
@@ -440,36 +451,35 @@ class UnitPipeline(PipelineTemplate):
             and dsm_cst.DSMS not in conf
         ):
             output_config = sensor_inputs.sensors_check_inputs(
-                conf, config_json_dir=config_json_dir
+                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_json_dir=config_json_dir
+                    conf, config_dir=config_dir
                 ),
             }
         else:
             output_config = {
                 **output_config,
-                **dsm_inputs.check_dsm_inputs(
-                    conf, config_json_dir=config_json_dir
-                ),
+                **dsm_inputs.check_dsm_inputs(conf, config_dir=config_dir),
             }
         return output_config
 
     @staticmethod
-    def check_output(conf):
+    def check_output(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,
@@ -483,6 +493,7 @@ class UnitPipeline(PipelineTemplate):
         :param conf: configuration of applications
         :type conf: dict
         """
+        scaling_coeff = self.scaling_coeff
 
         # Check if all specified applications are used
         # Application in terrain_application are note used in
@@ -580,7 +591,9 @@ class UnitPipeline(PipelineTemplate):
         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 +601,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,10 +625,13 @@ 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", {})
+                "hole_detection",
+                cfg=used_conf.get("hole_detection", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["hole_detection"] = self.hole_detection_app.get_conf()
 
@@ -624,6 +642,7 @@ class UnitPipeline(PipelineTemplate):
                     "dense_match_filling.1",
                     {"method": "plane"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.1"] = (
                 self.dense_match_filling_1.get_conf()
@@ -636,6 +655,7 @@ class UnitPipeline(PipelineTemplate):
                     "dense_match_filling.2",
                     {"method": "zero_padding"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.2"] = (
                 self.dense_match_filling_2.get_conf()
@@ -645,6 +665,7 @@ class UnitPipeline(PipelineTemplate):
             self.sparse_mtch_sift_app = Application(
                 "sparse_matching",
                 cfg=used_conf.get("sparse_matching.sift", {"method": "sift"}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["sparse_matching.sift"] = (
                 self.sparse_mtch_sift_app.get_conf()
@@ -672,13 +693,17 @@ class UnitPipeline(PipelineTemplate):
             ):
                 dense_matching_config["performance_map_method"] = "risk"
             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,7 +711,9 @@ 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()
@@ -704,6 +731,7 @@ class UnitPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.1",
                     {"method": "small_components"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["point_cloud_outlier_removal.1"] = (
                 self.pc_outlier_removal_1_app.get_conf()
@@ -716,6 +744,7 @@ class UnitPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.2",
                     {"method": "statistical"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["point_cloud_outlier_removal.2"] = (
                 self.pc_outlier_removal_2_app.get_conf()
@@ -727,6 +756,7 @@ class UnitPipeline(PipelineTemplate):
             self.pc_denoising_application = Application(
                 "pc_denoising",
                 cfg=used_conf.get("pc_denoising", {"method": "none"}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["pc_denoising"] = self.pc_denoising_application.get_conf()
 
@@ -736,6 +766,7 @@ class UnitPipeline(PipelineTemplate):
                 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()
@@ -747,6 +778,7 @@ class UnitPipeline(PipelineTemplate):
                         "dsm_filling.1",
                         {"method": "exogenous_filling"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.1"] = (
                     self.dsm_filling_1_application.get_conf()
@@ -769,22 +801,25 @@ class UnitPipeline(PipelineTemplate):
                         "dsm_filling.3",
                         {"method": "border_interpolation"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.3"] = (
                     self.dsm_filling_3_application.get_conf()
                 )
                 # 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
+                self.dsm_filling_1_application.classification != ["nodata"]
+                or self.dsm_filling_2_application.classification != ["nodata"]
+                or self.dsm_filling_3_application.classification != ["nodata"]
             ):
                 self.save_output_classif_for_filling = True
 
@@ -794,6 +829,7 @@ class UnitPipeline(PipelineTemplate):
                 self.pc_fusion_application = Application(
                     "point_cloud_fusion",
                     cfg=used_conf.get("point_cloud_fusion", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["point_cloud_fusion"] = (
                     self.pc_fusion_application.get_conf()
@@ -914,7 +950,7 @@ class UnitPipeline(PipelineTemplate):
                 ]
             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"
@@ -1156,6 +1192,10 @@ class UnitPipeline(PipelineTemplate):
             # Run cluster breakpoint to compute sifts: force computation
             self.cars_orchestrator.breakpoint()
 
+            minimum_nb_matches = (
+                self.sparse_mtch_sift_app.get_minimum_nb_matches()
+            )
+
             # Run grid correction application
             if self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is False:
                 # Estimate grid correction if no epipolar a priori
@@ -1177,23 +1217,15 @@ class UnitPipeline(PipelineTemplate):
                     )
                 )
 
-                minimum_nb_matches = (
-                    self.sparse_mtch_sift_app.get_minimum_nb_matches()
-                )
-
                 # Compute grid correction
                 (
                     self.pairs[pair_key]["grid_correction_coef"],
                     self.pairs[pair_key]["corrected_matches_array"],
-                    self.pairs[pair_key]["corrected_matches_cars_ds"],
                     _,
                     _,
                 ) = grid_correction_app.estimate_right_grid_correction(
                     self.pairs[pair_key]["matches_array"],
                     self.pairs[pair_key]["grid_right"],
-                    initial_cars_ds=self.pairs[pair_key][
-                        "epipolar_matches_left"
-                    ],
                     save_matches=save_matches,
                     minimum_nb_matches=minimum_nb_matches,
                     pair_folder=os.path.join(
@@ -1255,6 +1287,19 @@ class UnitPipeline(PipelineTemplate):
                         "Global disparity interval with margin : "
                         f"[{disp_min:.2f} pix, {disp_max:.2f} pix]"
                     )
+                else:
+                    disp_min = (
+                        -self.sparse_mtch_sift_app.elevation_delta_upper_bound
+                        / disp_to_alt_ratio
+                    )
+                    disp_max = (
+                        -self.sparse_mtch_sift_app.elevation_delta_lower_bound
+                        / disp_to_alt_ratio
+                    )
+                    logging.info(
+                        "Global disparity interval : "
+                        f"[{disp_min:.2f} pix, {disp_max:.2f} pix]"
+                    )
 
                 if self.epsg is None:
                     # compute epsg
@@ -1293,7 +1338,6 @@ class UnitPipeline(PipelineTemplate):
             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.pandora")
         ):
             return True
 
@@ -1356,13 +1400,12 @@ class UnitPipeline(PipelineTemplate):
             pair_name for pair_name, _, _ in self.list_sensor_pairs
         ]
 
-        for cloud_id, (pair_key, _, _) in enumerate(self.list_sensor_pairs):
+        for _, (pair_key, _, _) in enumerate(self.list_sensor_pairs):
             # 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.which_resolution in ("first", "single"):
-                    save_matches = True
+                save_matches = True
 
                 (
                     self.pairs[pair_key]["sensor_matches_left"],
@@ -1376,97 +1419,6 @@ class UnitPipeline(PipelineTemplate):
                     ),
                     save_matches=save_matches,
                 )
-
-                # saved used
-
-                if (
-                    inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-                    is None
-                    # cover the case where the geom plugin doesn't use init elev
-                    or (
-                        inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-                        != geom_plugin.dem
-                    )
-                ):
-                    # Generate grids with new MNT
-                    (
-                        self.pairs[pair_key]["new_grid_left"],
-                        self.pairs[pair_key]["new_grid_right"],
-                    ) = self.epipolar_grid_generation_application.run(
-                        self.pairs[pair_key]["sensor_image_left"],
-                        self.pairs[pair_key]["sensor_image_right"],
-                        geom_plugin,
-                        orchestrator=self.cars_orchestrator,
-                        pair_folder=os.path.join(
-                            self.dump_dir,
-                            "epipolar_grid_generation",
-                            "new_mnt",
-                            pair_key,
-                        ),
-                        pair_key=pair_key,
-                    )
-
-                    # Correct grids with former matches
-                    # Transform matches to new grids
-
-                    save_matches = self.sparse_mtch_sift_app.get_save_matches()
-
-                    new_grid_matches_array = (
-                        geom_plugin.transform_matches_from_grids(
-                            self.pairs[pair_key]["sensor_matches_left"],
-                            self.pairs[pair_key]["sensor_matches_right"],
-                            self.pairs[pair_key]["new_grid_left"],
-                            self.pairs[pair_key]["new_grid_right"],
-                        )
-                    )
-
-                    # Estimate grid_correction
-                    (
-                        self.pairs[pair_key]["grid_correction_coef"],
-                        self.pairs[pair_key]["corrected_matches_array"],
-                        self.pairs[pair_key]["corrected_matches_cars_ds"],
-                        _,
-                        _,
-                    ) = grid_correction_app.estimate_right_grid_correction(
-                        new_grid_matches_array,
-                        self.pairs[pair_key]["new_grid_right"],
-                        save_matches=save_matches,
-                        minimum_nb_matches=minimum_nb_matches,
-                        initial_cars_ds=self.pairs[pair_key][
-                            "epipolar_matches_left"
-                        ],
-                        pair_folder=os.path.join(
-                            self.dump_dir, "grid_correction", "new", pair_key
-                        ),
-                        pair_key=pair_key,
-                        orchestrator=self.cars_orchestrator,
-                    )
-
-                    # Correct grid right
-
-                    self.pairs[pair_key]["corrected_grid_right"] = (
-                        grid_correction_app.correct_grid(
-                            self.pairs[pair_key]["new_grid_right"],
-                            self.pairs[pair_key]["grid_correction_coef"],
-                            os.path.join(
-                                self.dump_dir,
-                                "grid_correction",
-                                "new",
-                                pair_key,
-                            ),
-                            save_corrected_grid,
-                        )
-                    )
-
-                    # Use the new grid as uncorrected grid
-                    self.pairs[pair_key]["grid_right"] = self.pairs[pair_key][
-                        "new_grid_right"
-                    ]
-
-                    self.pairs[pair_key]["corrected_grid_left"] = self.pairs[
-                        pair_key
-                    ]["new_grid_left"]
-
             elif (
                 self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is True
                 and not self.use_sift_a_priori
@@ -1553,14 +1505,13 @@ class UnitPipeline(PipelineTemplate):
                 (
                     self.pairs[pair_key]["grid_correction_coef"],
                     self.pairs[pair_key]["corrected_matches_array"],
-                    self.pairs[pair_key]["corrected_matches_cars_ds"],
                     _,
                     _,
                 ) = grid_correction_app.estimate_right_grid_correction(
                     new_grid_matches_array,
                     self.pairs[pair_key]["grid_right"],
                     save_matches=save_matches,
-                    initial_cars_ds=None,
+                    minimum_nb_matches=minimum_nb_matches,
                     pair_folder=os.path.join(
                         self.dump_dir, "grid_correction", "new", pair_key
                     ),
@@ -1638,8 +1589,8 @@ class UnitPipeline(PipelineTemplate):
             ):
                 dmin = disp_min / self.res_resamp
                 dmax = disp_max / self.res_resamp
-
-                disp_range_grid = (
+                # 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"],
@@ -1647,7 +1598,7 @@ class UnitPipeline(PipelineTemplate):
                         dmin=dmin,
                         dmax=dmax,
                         pair_folder=dense_matching_pair_folder,
-                        loc_inverse_orchestrator=self.cars_orchestrator,
+                        orchestrator=self.cars_orchestrator,
                     )
                 )
 
@@ -1674,8 +1625,8 @@ class UnitPipeline(PipelineTemplate):
             else:
                 if None in (altitude_delta_min, altitude_delta_max):
                     # Generate min and max disp grids from dems
-
-                    disp_range_grid = (
+                    # 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"],
@@ -1684,12 +1635,13 @@ class UnitPipeline(PipelineTemplate):
                             dem_max=dem_max,
                             dem_median=dem_median,
                             pair_folder=dense_matching_pair_folder,
-                            loc_inverse_orchestrator=self.cars_orchestrator,
+                            orchestrator=self.cars_orchestrator,
                         )
                     )
                 else:
                     # Generate min and max disp grids from deltas
-                    disp_range_grid = (
+                    # 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"],
@@ -1698,7 +1650,7 @@ class UnitPipeline(PipelineTemplate):
                             altitude_delta_max=altitude_delta_max,
                             dem_median=dem_median,
                             pair_folder=dense_matching_pair_folder,
-                            loc_inverse_orchestrator=self.cars_orchestrator,
+                            orchestrator=self.cars_orchestrator,
                         )
                     )
 
@@ -1708,12 +1660,12 @@ class UnitPipeline(PipelineTemplate):
                     # TODO remove when only local diparity range will be used
 
                     if self.use_sift_a_priori:
-                        dmin = np.nanmin(
-                            disp_range_grid[0, 0]["disp_min_grid"].values
-                        )
-                        dmax = np.nanmax(
-                            disp_range_grid[0, 0]["disp_max_grid"].values
-                        )
+                        dmin = self.pairs[pair_key]["disp_range_grid"][
+                            "global_min"
+                        ]
+                        dmax = self.pairs[pair_key]["disp_range_grid"][
+                            "global_max"
+                        ]
 
                         # update orchestrator_out_json
                         marg = self.sparse_mtch_sift_app.get_disparity_margin()
@@ -1737,7 +1689,8 @@ class UnitPipeline(PipelineTemplate):
                             pair_key=pair_key,
                         )
 
-                    disp_range_grid = (
+                    # 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"],
@@ -1745,34 +1698,23 @@ class UnitPipeline(PipelineTemplate):
                             dmin=dmin,
                             dmax=dmax,
                             pair_folder=dense_matching_pair_folder,
-                            loc_inverse_orchestrator=self.cars_orchestrator,
+                            orchestrator=self.cars_orchestrator,
                         )
                     )
-            # Get margins used in dense matching,
-            dense_matching_margins_fun = (
-                self.dense_matching_app.get_margins_fun(
-                    self.pairs[pair_key]["corrected_grid_left"],
-                    disp_range_grid,
-                )
-            )
 
             # TODO add in metadata.json max diff max - min
             # Update used_conf configuration with epipolar a priori
             # Add global min and max computed with grids
             advanced_parameters.update_conf(
                 self.used_conf,
-                dmin=np.min(
-                    disp_range_grid[0, 0]["disp_min_grid"].values
-                ),  # TODO compute dmin dans dmax
-                dmax=np.max(disp_range_grid[0, 0]["disp_max_grid"].values),
+                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,
-                dmin=np.min(
-                    disp_range_grid[0, 0]["disp_min_grid"].values
-                ),  # TODO compute dmin dans dmax
-                dmax=np.max(disp_range_grid[0, 0]["disp_max_grid"].values),
+                dmin=self.pairs[pair_key]["disp_range_grid"]["global_min"],
+                dmax=self.pairs[pair_key]["disp_range_grid"]["global_max"],
                 pair_key=pair_key,
             )
 
@@ -1783,6 +1725,10 @@ class UnitPipeline(PipelineTemplate):
                 safe_save=True,
             )
 
+            # end of for loop, to finish computing disparity range grids
+
+        for cloud_id, (pair_key, _, _) in enumerate(self.list_sensor_pairs):
+
             # Generate roi
             epipolar_roi = preprocessing.compute_epipolar_roi(
                 self.input_roi_poly,
@@ -1793,10 +1739,8 @@ class UnitPipeline(PipelineTemplate):
                 self.pairs[pair_key]["corrected_grid_left"],
                 self.pairs[pair_key]["corrected_grid_right"],
                 os.path.join(self.dump_dir, "compute_epipolar_roi", pair_key),
-                disp_min=np.min(
-                    disp_range_grid[0, 0]["disp_min_grid"].values
-                ),  # TODO compute dmin dans dmax
-                disp_max=np.max(disp_range_grid[0, 0]["disp_max_grid"].values),
+                disp_min=self.pairs[pair_key]["disp_range_grid"]["global_min"],
+                disp_max=self.pairs[pair_key]["disp_range_grid"]["global_max"],
             )
 
             # Generate new epipolar images
@@ -1808,7 +1752,7 @@ class UnitPipeline(PipelineTemplate):
                 optimum_tile_size,
                 local_tile_optimal_size_fun,
             ) = self.dense_matching_app.get_optimal_tile_size(
-                disp_range_grid,
+                self.pairs[pair_key]["disp_range_grid"],
                 self.cars_orchestrator.cluster.checked_conf_cluster[
                     "max_ram_per_worker"
                 ],
@@ -1828,6 +1772,14 @@ class UnitPipeline(PipelineTemplate):
                 for band in self.texture_bands
             ]
 
+            # Get margins used in dense matching,
+            dense_matching_margins_fun = (
+                self.dense_matching_app.get_margins_fun(
+                    self.pairs[pair_key]["corrected_grid_left"],
+                    self.pairs[pair_key]["disp_range_grid"],
+                )
+            )
+
             # Run third epipolar resampling
             (
                 new_epipolar_image_left,
@@ -1866,6 +1818,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"],
@@ -1889,6 +1842,131 @@ class UnitPipeline(PipelineTemplate):
                     ),
                 )
 
+            if self.epsg is None:
+                # compute epsg
+                # Epsg uses global disparity min and max
+                self.epsg = preprocessing.compute_epsg(
+                    self.pairs[pair_key]["sensor_image_left"],
+                    self.pairs[pair_key]["sensor_image_right"],
+                    self.pairs[pair_key]["corrected_grid_left"],
+                    self.pairs[pair_key]["corrected_grid_right"],
+                    self.geom_plugin_with_dem_and_geoid,
+                    disp_min=self.pairs[pair_key]["disp_range_grid"][
+                        "global_min"
+                    ],
+                    disp_max=self.pairs[pair_key]["disp_range_grid"][
+                        "global_max"
+                    ],
+                )
+                # Compute roi polygon, in input EPSG
+                self.roi_poly = preprocessing.compute_roi_poly(
+                    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"):
+                    # To get the correct size for the dem generation
+                    if self.dem_generation_roi is not None:
+                        # ROI has been computed by Shareloc
+                        self.terrain_bounds = (
+                            dem_wrappers.modify_terrain_bounds(
+                                self.dem_generation_roi.bounds,
+                                4326,
+                                self.epsg,
+                                self.dem_generation_application.margin,
+                            )
+                        )
+                    else:
+                        # ROI has not been computed
+                        self.terrain_bounds = (
+                            dem_wrappers.modify_terrain_bounds(
+                                self.terrain_bounds,
+                                self.epsg,
+                                self.epsg,
+                                self.dem_generation_application.margin,
+                                0.7,
+                            )
+                        )
+
+            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"][
+                    "pipeline"
+                ] = conf["pipeline"]
+
+                # 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,
@@ -1899,7 +1977,7 @@ class UnitPipeline(PipelineTemplate):
                     self.dump_dir, "dense_matching", pair_key
                 ),
                 pair_key=pair_key,
-                disp_range_grid=disp_range_grid,
+                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()
@@ -1919,11 +1997,13 @@ class UnitPipeline(PipelineTemplate):
                         epipolar_disparity_map,
                         self.pairs[pair_key]["holes_bbox_left"],
                         self.pairs[pair_key]["holes_bbox_right"],
-                        disp_min=np.min(
-                            disp_range_grid[0, 0]["disp_min_grid"].values
-                        ),
+                        disp_min=self.pairs[pair_key]["disp_range_grid"][
+                            "global_min"
+                        ],
                         disp_max=np.max(
-                            disp_range_grid[0, 0]["disp_max_grid"].values
+                            self.pairs[pair_key]["disp_range_grid"][
+                                "global_max"
+                            ]
                         ),
                         orchestrator=self.cars_orchestrator,
                         pair_folder=os.path.join(
@@ -1955,11 +2035,13 @@ class UnitPipeline(PipelineTemplate):
                         filled_with_1_epipolar_disparity_map,
                         self.pairs[pair_key]["holes_bbox_left"],
                         self.pairs[pair_key]["holes_bbox_right"],
-                        disp_min=np.min(
-                            disp_range_grid[0, 0]["disp_min_grid"].values
-                        ),
+                        disp_min=self.pairs[pair_key]["disp_range_grid"][
+                            "global_min"
+                        ],
                         disp_max=np.max(
-                            disp_range_grid[0, 0]["disp_max_grid"].values
+                            self.pairs[pair_key]["disp_range_grid"][
+                                "global_max"
+                            ]
                         ),
                         orchestrator=self.cars_orchestrator,
                         pair_folder=os.path.join(
@@ -1984,27 +2066,6 @@ class UnitPipeline(PipelineTemplate):
             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
-                self.epsg = preprocessing.compute_epsg(
-                    self.pairs[pair_key]["sensor_image_left"],
-                    self.pairs[pair_key]["sensor_image_right"],
-                    self.pairs[pair_key]["corrected_grid_left"],
-                    self.pairs[pair_key]["corrected_grid_right"],
-                    self.geom_plugin_with_dem_and_geoid,
-                    disp_min=np.min(
-                        disp_range_grid[0, 0]["disp_min_grid"].values
-                    ),
-                    disp_max=np.max(
-                        disp_range_grid[0, 0]["disp_max_grid"].values
-                    ),
-                )
-                # Compute roi polygon, in input EPSG
-                self.roi_poly = preprocessing.compute_roi_poly(
-                    self.input_roi_poly, self.input_roi_epsg, self.epsg
-                )
-
             if isinstance(output[sens_cst.GEOID], str):
                 output_geoid_path = output[sens_cst.GEOID]
             elif (
@@ -2200,57 +2261,6 @@ class UnitPipeline(PipelineTemplate):
                         # 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=np.min(
-                            disp_range_grid[0, 0]["disp_min_grid"].values
-                        ),
-                        disp_max=np.max(
-                            disp_range_grid[0, 0]["disp_max_grid"].values
-                        ),
-                        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"):
-                    # 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,
-                    )
-
         # quit if any app in the loop over the pairs was the last one
         # pylint:disable=too-many-boolean-expressions
         if (
@@ -2390,6 +2400,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,
@@ -2488,14 +2499,16 @@ class UnitPipeline(PipelineTemplate):
                 dem_min_file_name,
                 dem_max_file_name,
                 dem_median_file_name,
-                self.used_conf[INPUTS][sens_cst.INITIAL_ELEVATION][
+                input_geoid=self.used_conf[INPUTS][sens_cst.INITIAL_ELEVATION][
                     sens_cst.GEOID
                 ],
+                output_geoid=self.used_conf[OUTPUT][out_cst.OUT_GEOID],
                 initial_elevation=(
                     self.used_conf[INPUTS][sens_cst.INITIAL_ELEVATION][
                         sens_cst.DEM_PATH
                     ]
                 ),
+                default_alt=self.geom_plugin_with_dem_and_geoid.default_alt,
                 cars_orchestrator=self.cars_orchestrator,
             )
 
@@ -2539,7 +2552,7 @@ class UnitPipeline(PipelineTemplate):
             for key in dsm_dict.keys():
                 for path_name in dsm_dict[key].keys():
                     if dsm_dict[key][path_name] is not None:
-                        if not isinstance(dsm_dict[key][path_name], dict):
+                        if isinstance(dsm_dict[key][path_name], str):
                             if path_name not in dict_path:
                                 dict_path[path_name] = [
                                     dsm_dict[key][path_name]
@@ -2548,22 +2561,6 @@ class UnitPipeline(PipelineTemplate):
                                 dict_path[path_name].append(
                                     dsm_dict[key][path_name]
                                 )
-                        else:
-                            for confidence_path_name in dsm_dict[key][
-                                path_name
-                            ].keys():
-                                if confidence_path_name not in dict_path:
-                                    dict_path[confidence_path_name] = [
-                                        dsm_dict[key][path_name][
-                                            confidence_path_name
-                                        ]
-                                    ]
-                                else:
-                                    dict_path[confidence_path_name].append(
-                                        dsm_dict[key][path_name][
-                                            confidence_path_name
-                                        ]
-                                    )
 
             color_file_name = (
                 os.path.join(
@@ -2642,6 +2639,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(
@@ -2771,9 +2769,9 @@ 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)
@@ -2944,6 +2942,10 @@ class UnitPipeline(PipelineTemplate):
         if self.epsg is None:
             self.epsg = epsg_cloud
 
+        self.vertical_crs = projection.get_output_crs(
+            self.epsg, self.used_conf[OUTPUT]
+        )
+
         self.resolution = (
             self.used_conf[OUTPUT][out_cst.RESOLUTION] * self.res_resamp
         )