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

cars/core/geometry/shareloc_geometry.py

@@ -91,7 +91,11 @@ class SharelocGeometry(AbstractGeometry):
                 self.dem_roi_epsg = inputs.rasterio_get_epsg(dem)
 
             self.roi_shareloc = self.get_roi(
-                pairs_for_roi, self.dem_roi_epsg, margin=0.012
+                pairs_for_roi,
+                self.dem_roi_epsg,
+                z_min=0,
+                z_max=0,
+                margin=self.dem_roi_margin,
             )
             # change convention
             self.dem_roi = [
@@ -105,14 +109,26 @@ class SharelocGeometry(AbstractGeometry):
 
             # fill_nodata option should be set when dealing with void in DTM
             # see shareloc DTM limitations in sphinx doc for further details
-            dtm_image = dtm_reader(
-                dem,
-                geoid,
-                roi=self.roi_shareloc,
-                roi_is_in_physical_space=True,
-                fill_nodata="mean",
-                fill_value=0.0,
-            )
+
+            try:
+                dtm_image = dtm_reader(
+                    dem,
+                    geoid,
+                    roi=self.roi_shareloc,
+                    roi_is_in_physical_space=True,
+                    fill_nodata="mean",
+                    fill_value=0.0,
+                )
+            except RuntimeError as err:
+                mss = "the roi bounds are"
+                if mss in str(err):
+                    new_except_mss = (
+                        f"The extent of the roi lies outside "
+                        f"the extent of the initial elevation : {err}"
+                    )
+                    raise RuntimeError(new_except_mss) from err
+                raise
+
             self.elevation = (
                 bindings_cpp.DTMIntersection(  # pylint: disable=I1101
                     dtm_image.epsg,
@@ -125,7 +141,7 @@ class SharelocGeometry(AbstractGeometry):
         else:
             self.elevation = default_alt
 
-    def get_roi(self, pairs_for_roi, epsg, margin=0.006):
+    def get_roi(self, pairs_for_roi, epsg, z_min=0, z_max=0, margin=0.012):
         """
         Compute region of interest for intersection of DEM
 
@@ -138,27 +154,56 @@ class SharelocGeometry(AbstractGeometry):
         """
         coords_list = []
         for image1, geomodel1, image2, geomodel2 in pairs_for_roi:
-            # Footprint of left image
+            # Footprint of left image with altitude z_min
             coords_list.extend(
-                self.image_envelope(image1["main_file"], geomodel1)
+                self.image_envelope(
+                    image1["main_file"], geomodel1, elevation=z_min
+                )
             )
-            # Footprint of right image
+            # Footprint of left image with altitude z_max
             coords_list.extend(
-                self.image_envelope(image2["main_file"], geomodel2)
+                self.image_envelope(
+                    image1["main_file"], geomodel1, elevation=z_max
+                )
+            )
+            # Footprint of right image with altitude z_min
+            coords_list.extend(
+                self.image_envelope(
+                    image2["main_file"], geomodel2, elevation=z_min
+                )
+            )
+            # Footprint of right image with altitude z_max
+            coords_list.extend(
+                self.image_envelope(
+                    image2["main_file"], geomodel2, elevation=z_max
+                )
             )
             # Footprint of rectification grid (with margins)
             image1 = SharelocGeometry.load_image(image1["main_file"])
             geomodel1 = self.load_geom_model(geomodel1)
             geomodel2 = self.load_geom_model(geomodel2)
+
+            # With altitude z_min
             epipolar_extent = rectif.get_epipolar_extent(
                 image1,
                 geomodel1,
                 geomodel2,
+                elevation=z_min,
                 grid_margin=self.rectification_grid_margin,
             )
             lat_min, lon_min, lat_max, lon_max = list(epipolar_extent)
             coords_list.extend([(lon_min, lat_min), (lon_max, lat_max)])
 
+            # With altitude z_max
+            epipolar_extent = rectif.get_epipolar_extent(
+                image1,
+                geomodel1,
+                geomodel2,
+                elevation=z_max,
+                grid_margin=self.rectification_grid_margin,
+            )
+            lat_min, lon_min, lat_max, lon_max = list(epipolar_extent)
+            coords_list.extend([(lon_min, lat_min), (lon_max, lat_max)])
         lon_list, lat_list = list(zip(*coords_list))  # noqa: B905
         roi = [
             min(lat_list) - margin,

cars/orchestrator/registry/saver_registry.py

@@ -28,8 +28,6 @@ import logging
 import os
 import traceback
 
-from cars.core import constants as cst
-
 # CARS imports
 from cars.orchestrator.registry.abstract_registry import (
     AbstractCarsDatasetRegistry,
@@ -291,21 +289,6 @@ class SingleCarsDatasetSaver:
         try:
             if self.cars_ds.dataset_type == "arrays":
                 if not self.already_seen:
-                    self.add_confidences(future_result, cst.RASTER_CONFIDENCE)
-                    self.add_confidences(future_result, cst.RASTER_AMBIGUITY)
-
-                    # delete doublon because of the confidences adding
-                    for index, value in enumerate(self.file_names):
-                        if (
-                            cst.RASTER_AMBIGUITY in value
-                            and cst.DSM_ALT not in value
-                            and "depth_map" not in value
-                        ):
-                            self.tags.pop(index)
-                            self.dtypes.pop(index)
-                            self.nodatas.pop(index)
-                            self.file_names.pop(index)
-
                     # generate descriptors
                     for count, file_name in enumerate(self.file_names):
                         if self.tags[count] in future_result.keys():
@@ -340,22 +323,6 @@ class SingleCarsDatasetSaver:
             elif self.cars_ds.dataset_type == "points":
                 # type points
                 if not self.already_seen:
-                    # get the confidence tags available in future result
-                    self.add_confidences(future_result, cst.RASTER_CONFIDENCE)
-                    self.add_confidences(future_result, cst.RASTER_AMBIGUITY)
-
-                    # delete doublon because of the confidences adding
-                    for index, value in enumerate(self.file_names):
-                        if (
-                            cst.RASTER_AMBIGUITY in value
-                            and cst.DSM_ALT not in value
-                            and "depth_map" not in value
-                        ):
-                            self.tags.pop(index)
-                            self.dtypes.pop(index)
-                            self.nodatas.pop(index)
-                            self.file_names.pop(index)
-
                     # create tmp_folder
                     self.folder_name = self.file_names[0]
                     if not os.path.exists(self.folder_name):
@@ -380,51 +347,6 @@ class SingleCarsDatasetSaver:
             logging.error(traceback.format_exc())
             logging.error("Tile not saved")
 
-    def add_confidences(self, future_result, confidence_type):
-        """
-        Add all confidence data in the register
-        Read confidence from future result outputs and rewrite
-        the confidence registered values
-        """
-
-        def test_conf(val):
-            """
-            Check if val key string contains confidence subtring
-            """
-            if isinstance(val, str):
-                return confidence_type in val
-            return False
-
-        confidence_tags = list(filter(test_conf, future_result.keys()))
-
-        index = None
-        if confidence_type in self.tags:
-            # get the confidence indexes in the registered tag
-            index_table = [
-                idx
-                for idx, value in enumerate(self.tags)
-                if value == confidence_type
-            ]  # self.tags.index("confidence")
-            for index in reversed(index_table):
-                ref_confidence_path = self.file_names[index]
-                confidence_dtype = self.dtypes[index]
-                confidence_nodatas = self.nodatas[index]
-                # delete the generic confidence registered values
-                self.tags.pop(index)
-                self.dtypes.pop(index)
-                self.nodatas.pop(index)
-                self.file_names.pop(index)
-                self.optional_data_list.pop(index)
-                for item in confidence_tags:
-                    self.tags.append(item)
-                    self.file_names.append(
-                        ref_confidence_path.replace(
-                            confidence_type, item.replace(".", "_")
-                        )
-                    )
-                    self.dtypes.append(confidence_dtype)
-                    self.nodatas.append(confidence_nodatas)
-
     def cleanup(self):
         """
         Cleanup function

cars/pipelines/default/default_pipeline.py

@@ -80,7 +80,7 @@ class DefaultPipeline(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
 
@@ -99,13 +99,17 @@ class DefaultPipeline(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 or yaml file
+        :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)
 
@@ -114,9 +118,7 @@ class DefaultPipeline(PipelineTemplate):
         # So we do the check once
 
         # 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)
 
         # Check conf output
         output = self.check_output(conf[OUTPUT])
@@ -523,15 +525,15 @@ class DefaultPipeline(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, if
             user filled paths with relative paths
-        :type config_json_dir: str
+        :type config_dir: str
 
         :return: overloaded inputs
         :rtype: dict
@@ -544,21 +546,19 @@ class DefaultPipeline(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
 
@@ -830,17 +830,6 @@ class DefaultPipeline(PipelineTemplate):
                     "intervals",
                 ]
 
-            if res <= 16:
-                if (
-                    "dense matching" not in conf
-                    or "confidence filtering" not in conf["dense matching"]
-                    or "lower bound"
-                    not in conf["dense matching"]["confidence filtering"]
-                ):
-                    used_conf["dense_matching"]["confidence_filtering"][
-                        "lower_bound"
-                    ] = -90
-
             # Triangulation
             self.triangulation_application = Application(
                 "triangulation", cfg=used_conf.get("triangulation", {})
@@ -853,10 +842,18 @@ class DefaultPipeline(PipelineTemplate):
             self.dem_generation_application = Application(
                 "dem_generation", cfg=used_conf.get("dem_generation", {})
             )
+
+            height_margin = None
+            if res >= 8 and "height_margin" not in used_conf["dem_generation"]:
+                height_margin = [50, 250]
+
             used_conf["dem_generation"] = (
                 self.dem_generation_application.get_conf()
             )
 
+            if height_margin is not None:
+                used_conf["dem_generation"]["height_margin"] = height_margin
+
             # 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"]:
@@ -1118,7 +1115,7 @@ class DefaultPipeline(PipelineTemplate):
         size_low_res_img_col = first_image_size[1] // res
         if (
             "grid_generation" not in initial_conf_app
-            or "epi_step" not in application_conf["grid_generation"]
+            or "epi_step" not in initial_conf_app["grid_generation"]
         ):
             if size_low_res_img_row <= 900 and size_low_res_img_col <= 900:
                 application_conf["grid_generation"]["epi_step"] = res * 5

cars/pipelines/parameters/depth_map_inputs.py

@@ -37,15 +37,15 @@ from cars.pipelines.parameters import sensor_inputs as sens_inp
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
 
 
-def check_depth_maps_inputs(conf, config_json_dir=None):
+def check_depth_maps_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, if
         user filled paths with relative paths
-    :type config_json_dir: str
+    :type config_dir: str
 
     :return: overloader inputs
     :rtype: dict
@@ -88,7 +88,7 @@ def check_depth_maps_inputs(conf, config_json_dir=None):
         cst.EPI_Z_INF: Or(str, None),
         cst.EPI_Z_SUP: Or(str, None),
         cst.POINT_CLOUD_CLASSIF_KEY_ROOT: Or(str, None),
-        cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT: Or(dict, None),
+        cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT: Or(str, None),
         cst.POINT_CLOUD_CLR_KEY_ROOT: str,
         cst.POINT_CLOUD_FILLING_KEY_ROOT: Or(str, None),
         cst.POINT_CLOUD_MSK: Or(str, None),
@@ -96,7 +96,6 @@ def check_depth_maps_inputs(conf, config_json_dir=None):
         cst.PC_EPSG: Or(str, int, None),
     }
     checker_pc = Checker(pc_schema)
-    confidence_conf_ref = None
     for depth_map_key in conf[depth_map_cst.DEPTH_MAPS]:
         # Get depth maps with default
         overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key] = {}
@@ -144,43 +143,10 @@ def check_depth_maps_inputs(conf, config_json_dir=None):
             cst.POINT_CLOUD_FILLING_KEY_ROOT
         ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("filling", None)
 
-        confidence_conf = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            "confidence", None
-        )
-        if confidence_conf:
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
-            ] = {}
-            if (
-                confidence_conf_ref
-                and confidence_conf.keys() != confidence_conf_ref
-            ):
-                raise KeyError(
-                    "The confidence keys are not the same: \n",
-                    confidence_conf.keys(),
-                    "\n",
-                    confidence_conf_ref,
-                )
+        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
+            cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
+        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("ambiguity", None)
 
-            confidence_conf_ref = confidence_conf.keys()
-            for confidence_name in confidence_conf:
-                output_confidence_name = confidence_name
-                if (
-                    cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
-                    not in output_confidence_name
-                ):
-                    output_confidence_name = (
-                        cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
-                        + "_"
-                        + output_confidence_name
-                    )
-                overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                    cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
-                ][output_confidence_name] = confidence_conf[confidence_name]
-        else:
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
-            ] = None
         overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
             cst.PC_EPSG
         ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("epsg", 4326)
@@ -190,8 +156,8 @@ def check_depth_maps_inputs(conf, config_json_dir=None):
         )
 
     # Modify to absolute path
-    if config_json_dir is not None:
-        modify_to_absolute_path(config_json_dir, overloaded_conf)
+    if config_dir is not None:
+        modify_to_absolute_path(config_dir, overloaded_conf)
     else:
         logging.debug(
             "path of config file was not given,"
@@ -217,7 +183,7 @@ def check_depth_maps_inputs(conf, config_json_dir=None):
                 cst.POINT_CLOUD_FILLING_KEY_ROOT
             ],
             overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
+                cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
             ],
         )
 
@@ -227,7 +193,7 @@ def check_depth_maps_inputs(conf, config_json_dir=None):
     )
 
     if sens_cst.SENSORS in conf and conf[sens_cst.SENSORS] is not None:
-        sens_inp.check_sensors(conf, overloaded_conf, config_json_dir)
+        sens_inp.check_sensors(conf, overloaded_conf, config_dir)
 
     return overloaded_conf
 
@@ -264,10 +230,10 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
 
 
 def check_input_size(
-    x_path, y_path, z_path, mask, color, classif, filling, confidence
+    x_path, y_path, z_path, mask, color, classif, filling, ambiguity
 ):
     """
-    Check x, y, z, mask, color, classif and confidence given
+    Check x, y, z, mask, color, classif and ambiguity given
 
     Images must have same size
 
@@ -285,15 +251,15 @@ def check_input_size(
     :type classif: str
     :param filling: filling path
     :type filling: str
-    :param confidence: confidence dict path
-    :type confidence: dict[str]
+    :param ambiguity: ambiguity path
+    :type ambiguity: str
     """
 
     for path in [x_path, y_path, z_path]:
         if inputs.rasterio_get_nb_bands(path) != 1:
             raise RuntimeError("{} is not mono-band image".format(path))
 
-    for path in [mask, color, classif, filling]:
+    for path in [mask, color, classif, filling, ambiguity]:
         if path is not None:
             if inputs.rasterio_get_size(x_path) != inputs.rasterio_get_size(
                 path
@@ -302,25 +268,14 @@ def check_input_size(
                     "The image {} and {} "
                     "do not have the same size".format(x_path, path)
                 )
-    if confidence:
-        for key in confidence:
-            path = confidence[key]
-            if path is not None:
-                if inputs.rasterio_get_size(x_path) != inputs.rasterio_get_size(
-                    path
-                ):
-                    raise RuntimeError(
-                        "The image {} and {} "
-                        "do not have the same size".format(x_path, path)
-                    )
 
 
-def modify_to_absolute_path(config_json_dir, overloaded_conf):
+def modify_to_absolute_path(config_dir, overloaded_conf):
     """
     Modify input file path to absolute path
 
-    :param config_json_dir: directory of the json configuration
-    :type config_json_dir: str
+    :param config_dir: directory of the json/yaml configuration
+    :type config_dir: str
     :param overloaded_conf: overloaded configuration json
     :dict overloaded_conf: dict
     """
@@ -339,7 +294,7 @@ def modify_to_absolute_path(config_json_dir, overloaded_conf):
             if tag != cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT:
                 if depth_map[tag] is not None:
                     depth_map[tag] = make_relative_path_absolute(
-                        depth_map[tag], config_json_dir
+                        depth_map[tag], config_dir
                     )
             else:
                 if depth_map[tag] is not None:
@@ -348,12 +303,12 @@ def modify_to_absolute_path(config_json_dir, overloaded_conf):
                             depth_map[tag][confidence_name] = (
                                 make_relative_path_absolute(
                                     depth_map[tag][confidence_name],
-                                    config_json_dir,
+                                    config_dir,
                                 )
                             )
 
     if overloaded_conf[sens_cst.ROI] is not None:
         if isinstance(overloaded_conf[sens_cst.ROI], str):
             overloaded_conf[sens_cst.ROI] = make_relative_path_absolute(
-                overloaded_conf[sens_cst.ROI], config_json_dir
+                overloaded_conf[sens_cst.ROI], config_dir
             )

cars/pipelines/parameters/dsm_inputs.py

@@ -48,15 +48,15 @@ from cars.pipelines.parameters import sensor_inputs as sens_inp
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
 
 
-def check_dsm_inputs(conf, config_json_dir=None):
+def check_dsm_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: overloader inputs
     :rtype: dict
@@ -108,7 +108,7 @@ def check_dsm_inputs(conf, config_json_dir=None):
         cst.DSM_INF_STD: Or(str, None),
         cst.DSM_SUP_MEAN: Or(str, None),
         cst.DSM_SUP_STD: Or(str, None),
-        cst.DSM_CONFIDENCE: Or(dict, None),
+        cst.DSM_AMBIGUITY: Or(str, None),
         cst.DSM_PERFORMANCE_MAP: Or(str, None),
         cst.DSM_SOURCE_PC: Or(str, None),
         cst.DSM_FILLING: Or(str, None),
@@ -164,9 +164,9 @@ def check_dsm_inputs(conf, config_json_dir=None):
         overloaded_conf[dsm_cst.DSMS][dsm_key][cst.DSM_SUP_STD] = conf[
             dsm_cst.DSMS
         ][dsm_key].get("dsm_sup_std", None)
-        overloaded_conf[dsm_cst.DSMS][dsm_key][cst.DSM_CONFIDENCE] = conf[
+        overloaded_conf[dsm_cst.DSMS][dsm_key][cst.DSM_AMBIGUITY] = conf[
             dsm_cst.DSMS
-        ][dsm_key].get("confidence", None)
+        ][dsm_key].get("ambiguity", None)
         overloaded_conf[dsm_cst.DSMS][dsm_key][cst.DSM_PERFORMANCE_MAP] = conf[
             dsm_cst.DSMS
         ][dsm_key].get("performance_map", None)
@@ -181,8 +181,8 @@ def check_dsm_inputs(conf, config_json_dir=None):
         checker_pc.validate(overloaded_conf[dsm_cst.DSMS][dsm_key])
 
     # Modify to absolute path
-    if config_json_dir is not None:
-        modify_to_absolute_path(config_json_dir, overloaded_conf)
+    if config_dir is not None:
+        modify_to_absolute_path(config_dir, overloaded_conf)
     else:
         logging.debug(
             "path of config file was not given,"
@@ -200,14 +200,6 @@ def check_dsm_inputs(conf, config_json_dir=None):
             overloaded_conf[dsm_cst.DSMS][dsm_key][cst.INDEX_DSM_MASK],
         )
 
-        if cst.DSM_CONFIDENCE in conf[dsm_cst.DSMS][dsm_key]:
-            if conf[dsm_cst.DSMS][dsm_key][cst.DSM_CONFIDENCE] is not None:
-                for _, conf_value in conf[dsm_cst.DSMS][dsm_key][
-                    cst.DSM_CONFIDENCE
-                ].items():
-                    if not os.path.exists(conf_value):
-                        raise RuntimeError("The path doesn't exist")
-
     # Check srtm dir
     sens_inp.check_srtm(
         overloaded_conf[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
@@ -216,7 +208,7 @@ def check_dsm_inputs(conf, config_json_dir=None):
     check_phasing(conf[dsm_cst.DSMS])
 
     if sens_cst.SENSORS in conf and conf[sens_cst.SENSORS] is not None:
-        sens_inp.check_sensors(conf, overloaded_conf, config_json_dir)
+        sens_inp.check_sensors(conf, overloaded_conf, config_dir)
 
     return overloaded_conf
 
@@ -249,12 +241,12 @@ def check_input_size(dsm, classif, color, mask):
                 )
 
 
-def modify_to_absolute_path(config_json_dir, overloaded_conf):
+def modify_to_absolute_path(config_dir, overloaded_conf):
     """
     Modify input file path to absolute path
 
-    :param config_json_dir: directory of the json configuration
-    :type config_json_dir: str
+    :param config_dir: directory of the json configuration
+    :type config_dir: str
     :param overloaded_conf: overloaded configuration json
     :dict overloaded_conf: dict
     """
@@ -267,14 +259,12 @@ def modify_to_absolute_path(config_json_dir, overloaded_conf):
             cst.INDEX_DSM_MASK,
         ]:
             if dsms[tag] is not None:
-                dsms[tag] = make_relative_path_absolute(
-                    dsms[tag], config_json_dir
-                )
+                dsms[tag] = make_relative_path_absolute(dsms[tag], config_dir)
 
     if overloaded_conf[sens_cst.ROI] is not None:
         if isinstance(overloaded_conf[sens_cst.ROI], str):
             overloaded_conf[sens_cst.ROI] = make_relative_path_absolute(
-                overloaded_conf[sens_cst.ROI], config_json_dir
+                overloaded_conf[sens_cst.ROI], config_dir
             )
 
 
@@ -505,11 +495,8 @@ def merge_dsm_infos(  # noqa: C901 function is too complex
             and performance_map_file_name is not None
         ):
             out_file_name = performance_map_file_name
-        elif (
-            cst.DSM_CONFIDENCE_AMBIGUITY in key
-            and ambiguity_file_name is not None
-        ):
-            out_file_name = os.path.join(ambiguity_file_name, key + ".tif")
+        elif key == cst.DSM_AMBIGUITY and ambiguity_file_name is not None:
+            out_file_name = ambiguity_file_name
         elif (
             key == cst.DSM_SOURCE_PC and contributing_pair_file_name is not None
         ):