cars 1.0.0a1__cp313-cp313-win_amd64.whl → 1.0.0a3__cp313-cp313-win_amd64.whl

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
         ):

cars/pipelines/parameters/output_parameters.py

@@ -26,7 +26,7 @@ This module contains the output definition
 import logging
 import os
 
-from json_checker import Checker, Or
+from json_checker import And, Checker, Or
 from pyproj import CRS
 
 import cars.core.constants as cst
@@ -34,12 +34,29 @@ from cars.core.utils import safe_makedirs
 from cars.pipelines.parameters import output_constants
 
 
-def check_output_parameters(conf):
+def is_valid_epsg(epsg) -> bool:
+    """
+    Check if the given EPSG code is valid using pyproj.
+    """
+    if epsg is None:
+        return True
+
+    try:
+        # Try creating a CRS
+        CRS(f"EPSG:{epsg}")
+        return True
+    except Exception:
+        return False
+
+
+def check_output_parameters(conf, scaling_coeff):
     """
     Check the output json configuration and fill in default values
 
     :param conf: configuration of output
     :type conf: dict
+    :param scaling_coeff: scaling factor for resolution
+    :type scaling_coeff: float
     :param pipeline_name: name of corresponding pipeline
     :type pipeline_name: str
     """
@@ -64,15 +81,34 @@ def check_output_parameters(conf):
             raise RuntimeError("Unknown product level {}".format(level))
 
     overloaded_conf[output_constants.OUT_GEOID] = overloaded_conf.get(
-        output_constants.OUT_GEOID, False
+        output_constants.OUT_GEOID, True
     )
     overloaded_conf[output_constants.EPSG] = overloaded_conf.get(
         output_constants.EPSG, None
     )
 
-    overloaded_conf[output_constants.RESOLUTION] = overloaded_conf.get(
-        output_constants.RESOLUTION, 0.5
-    )
+    resolution = None
+    overloaded_scaling_coeff = scaling_coeff
+    if output_constants.RESOLUTION in overloaded_conf:
+        resolution = overloaded_conf[output_constants.RESOLUTION]
+        # update scaling coeff so the parameters are right for the dsm
+        # overloaded_scaling_coeff = 2*resolution
+
+        if resolution < 0.5 * scaling_coeff:
+            logging.warning(
+                "The requested DSM resolution of "
+                f"{overloaded_conf[output_constants.RESOLUTION]} seems "
+                "too low for the sensor images' resolution. "
+                "The pipeline will still continue with it."
+            )
+
+    else:
+        resolution = float(0.5 * scaling_coeff)
+        logging.warning(
+            "The resolution of the output DSM will be " f"{resolution} meters. "
+        )
+
+    overloaded_conf[output_constants.RESOLUTION] = resolution
 
     overloaded_conf[output_constants.SAVE_BY_PAIR] = overloaded_conf.get(
         output_constants.SAVE_BY_PAIR, False
@@ -145,7 +181,7 @@ def check_output_parameters(conf):
         output_constants.OUT_DIRECTORY: str,
         output_constants.PRODUCT_LEVEL: list,
         output_constants.OUT_GEOID: Or(bool, str),
-        output_constants.EPSG: Or(int, None),
+        output_constants.EPSG: And(Or(int, str, None), is_valid_epsg),
         output_constants.RESOLUTION: Or(int, float),
         output_constants.SAVE_BY_PAIR: bool,
         output_constants.AUXILIARY: dict,
@@ -181,7 +217,7 @@ def check_output_parameters(conf):
                     + "fixed according to the epsg"
                 )
 
-    return overloaded_conf
+    return overloaded_conf, overloaded_scaling_coeff
 
 
 def intialize_product_index(orchestrator, product_levels, input_pairs):