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

cars/pipelines/parameters/depth_map_inputs.py

@@ -1,314 +0,0 @@
-#!/usr/bin/env python
-# coding: utf8
-#
-# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
-#
-# This file is part of CARS
-# (see https://github.com/CNES/cars).
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-"""
-CARS depth map inputs
-"""
-
-import logging
-
-from json_checker import Checker, Or
-
-import cars.pipelines.parameters.depth_map_inputs_constants as depth_map_cst
-
-# CARS imports
-from cars.core import constants as cst
-from cars.core import inputs
-from cars.core.geometry.abstract_geometry import AbstractGeometry
-from cars.core.utils import make_relative_path_absolute
-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_dir=None):
-    """
-    Check the inputs given
-
-    :param conf: configuration of inputs
-    :type conf: dict
-    :param config_dir: directory of used json, if
-        user filled paths with relative paths
-    :type config_dir: str
-
-    :return: overloader inputs
-    :rtype: dict
-    """
-
-    overloaded_conf = {}
-
-    # Overload some optional parameters
-    overloaded_conf[sens_cst.ROI] = conf.get(sens_cst.ROI, None)
-    overloaded_conf[depth_map_cst.DEPTH_MAPS] = {}
-
-    overloaded_conf[sens_cst.INITIAL_ELEVATION] = (
-        sens_inp.get_initial_elevation(
-            conf.get(sens_cst.INITIAL_ELEVATION, None)
-        )
-    )
-
-    overloaded_conf[sens_cst.SENSORS] = conf.get(sens_cst.SENSORS, None)
-
-    overloaded_conf[sens_cst.PAIRING] = conf.get(sens_cst.PAIRING, None)
-
-    # Validate inputs
-    inputs_schema = {
-        depth_map_cst.DEPTH_MAPS: dict,
-        sens_cst.ROI: Or(str, dict, None),
-        sens_cst.INITIAL_ELEVATION: Or(dict, None),
-        sens_cst.SENSORS: Or(dict, None),
-        sens_cst.PAIRING: Or([[str]], None),
-    }
-
-    checker_inputs = Checker(inputs_schema)
-    checker_inputs.validate(overloaded_conf)
-
-    # Validate depth maps
-
-    pc_schema = {
-        cst.X: str,
-        cst.Y: str,
-        cst.Z: str,
-        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_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),
-        cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT: Or(str, None),
-        cst.PC_EPSG: Or(str, int, None),
-    }
-    checker_pc = Checker(pc_schema)
-    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] = {}
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.X] = conf[
-            depth_map_cst.DEPTH_MAPS
-        ][depth_map_key].get("x", None)
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Y] = conf[
-            depth_map_cst.DEPTH_MAPS
-        ][depth_map_key].get("y", None)
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Z] = conf[
-            depth_map_cst.DEPTH_MAPS
-        ][depth_map_key].get("z", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.EPI_Z_INF
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            cst.EPI_Z_INF, None
-        )
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.EPI_Z_SUP
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            cst.EPI_Z_SUP, None
-        )
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_CLR_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("texture", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_MSK
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("mask", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_CLASSIF_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            "classification", None
-        )
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            "performance_map", None
-        )
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_FILLING_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("filling", None)
-
-        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)
-
-        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)
-        # validate
-        checker_pc.validate(
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key]
-        )
-
-    # Modify to absolute path
-    if config_dir is not None:
-        modify_to_absolute_path(config_dir, overloaded_conf)
-    else:
-        logging.debug(
-            "path of config file was not given,"
-            "relative path are not transformed to absolute paths"
-        )
-
-    for depth_map_key in conf[depth_map_cst.DEPTH_MAPS]:
-        # check sizes
-        check_input_size(
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.X],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Y],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Z],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_MSK
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CLR_KEY_ROOT
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CLASSIF_KEY_ROOT
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_FILLING_KEY_ROOT
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
-            ],
-        )
-
-    # Check srtm dir
-    sens_inp.check_srtm(
-        overloaded_conf[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-    )
-
-    if sens_cst.SENSORS in conf and conf[sens_cst.SENSORS] is not None:
-        sens_inp.check_sensors(conf, overloaded_conf, config_dir)
-
-    return overloaded_conf
-
-
-def check_geometry_plugin(conf_inputs, conf_geom_plugin):
-    """
-    Check the geometry plugin with inputs
-    :param conf_geom_plugin: name of geometry plugin
-    :type conf_geom_plugin: str
-    :param conf_inputs: checked configuration of inputs
-    :type conf_inputs: type
-
-    :return: geometry plugin with dem
-    """
-    if conf_geom_plugin is None:
-        conf_geom_plugin = "SharelocGeometry"
-
-    dem_path = conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-
-    if dem_path is None:
-        return conf_geom_plugin, None
-
-    # Initialize a geometry plugin with elevation information
-    geom_plugin_with_dem_and_geoid = (
-        AbstractGeometry(  # pylint: disable=abstract-class-instantiated
-            conf_geom_plugin,
-            dem=dem_path,
-            geoid=conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.GEOID],
-            default_alt=sens_cst.CARS_DEFAULT_ALT,
-        )
-    )
-
-    return conf_geom_plugin, geom_plugin_with_dem_and_geoid
-
-
-def check_input_size(
-    x_path, y_path, z_path, mask, color, classif, filling, ambiguity
-):
-    """
-    Check x, y, z, mask, color, classif and ambiguity given
-
-    Images must have same size
-
-    :param x_path: x path
-    :type x_path: str
-    :param y_path: y path
-    :type y_path: str
-    :param z_path: z path
-    :type z_path: str
-    :param mask: mask path
-    :type mask: str
-    :param color: color path
-    :type color: str
-    :param classif: classif path
-    :type classif: str
-    :param filling: filling path
-    :type filling: 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, ambiguity]:
-        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_dir, overloaded_conf):
-    """
-    Modify input file path to absolute path
-
-    :param config_dir: directory of the json/yaml configuration
-    :type config_dir: str
-    :param overloaded_conf: overloaded configuration json
-    :dict overloaded_conf: dict
-    """
-    for depth_map_key in overloaded_conf[depth_map_cst.DEPTH_MAPS]:
-        depth_map = overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key]
-        for tag in [
-            cst.X,
-            cst.Y,
-            cst.Z,
-            cst.POINT_CLOUD_CLR_KEY_ROOT,
-            cst.POINT_CLOUD_MSK,
-            cst.POINT_CLOUD_CLASSIF_KEY_ROOT,
-            cst.POINT_CLOUD_FILLING_KEY_ROOT,
-            cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT,
-        ]:
-            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_dir
-                    )
-            else:
-                if depth_map[tag] is not None:
-                    for confidence_name in depth_map[tag]:
-                        if depth_map[tag][confidence_name] is not None:
-                            depth_map[tag][confidence_name] = (
-                                make_relative_path_absolute(
-                                    depth_map[tag][confidence_name],
-                                    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_dir
-            )

cars/pipelines/parameters/dsm_inputs.py

@@ -42,6 +42,7 @@ from cars.applications.rasterization.rasterization_wrappers import (
 )
 from cars.core import constants as cst
 from cars.core import inputs, preprocessing, tiling
+from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.utils import make_relative_path_absolute, safe_makedirs
 from cars.data_structures import cars_dataset
 from cars.pipelines.parameters import sensor_inputs as sens_inp
@@ -213,6 +214,37 @@ def check_dsm_inputs(conf, config_dir=None):
     return overloaded_conf
 
 
+def check_geometry_plugin(conf_inputs, conf_geom_plugin):
+    """
+    Check the geometry plugin with inputs
+    :param conf_geom_plugin: name of geometry plugin
+    :type conf_geom_plugin: str
+    :param conf_inputs: checked configuration of inputs
+    :type conf_inputs: type
+
+    :return: geometry plugin with dem
+    """
+    if conf_geom_plugin is None:
+        conf_geom_plugin = "SharelocGeometry"
+
+    dem_path = conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
+
+    if dem_path is None:
+        return conf_geom_plugin, None
+
+    # Initialize a geometry plugin with elevation information
+    geom_plugin_with_dem_and_geoid = (
+        AbstractGeometry(  # pylint: disable=abstract-class-instantiated
+            conf_geom_plugin,
+            dem=dem_path,
+            geoid=conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.GEOID],
+            default_alt=sens_cst.CARS_DEFAULT_ALT,
+        )
+    )
+
+    return conf_geom_plugin, geom_plugin_with_dem_and_geoid
+
+
 def check_input_size(dsm, classif, color, mask):
     """
     Check dsm, mask, color, classif given
@@ -318,6 +350,7 @@ def check_phasing(dsm_dict):
             raise RuntimeError(f"DSM {dsm_key} and {ref_key} are not phased")
 
 
+# pylint: disable=too-many-positional-arguments
 def merge_dsm_infos(  # noqa: C901 function is too complex
     dict_path,
     orchestrator,
@@ -378,6 +411,9 @@ def merge_dsm_infos(  # noqa: C901 function is too complex
     terrain_raster = cars_dataset.CarsDataset("arrays", name="rasterization")
 
     # find the global bounds of the dataset
+    dsm_nodata = None
+    epsg = None
+    resolution = None
     for index, path in enumerate(dict_path["dsm"]):
         with rasterio.open(path) as src:
             if index == 0:
@@ -544,7 +580,7 @@ def merge_dsm_infos(  # noqa: C901 function is too complex
     return terrain_raster
 
 
-def dsm_merging_wrapper(  # noqa C901
+def dsm_merging_wrapper(  # pylint: disable=too-many-positional-arguments # noqa C901
     dict_path,
     tile_bounds,
     resolution,
@@ -744,7 +780,7 @@ def dsm_merging_wrapper(  # noqa C901
     return dataset
 
 
-def assemblage(
+def assemblage(  # pylint: disable=too-many-positional-arguments
     out,
     current_weights,
     method,
@@ -828,11 +864,11 @@ def assemblage(
                 # doesn't equal to the entire tile
                 x_offset = int(
                     (intersect_bounds[idx][0] - tile_bounds[0])
-                    * np.abs(src.res[0])
+                    / np.abs(src.res[0])
                 )
                 y_offset = int(
                     (tile_bounds[3] - intersect_bounds[idx][3])
-                    * np.abs(src.res[1])
+                    / np.abs(src.res[1])
                 )
 
                 if cols > 0 and rows > 0:

cars/pipelines/parameters/output_parameters.py

@@ -89,7 +89,7 @@ def check_output_parameters(conf, scaling_coeff):
 
     resolution = None
     overloaded_scaling_coeff = scaling_coeff
-    if output_constants.RESOLUTION in overloaded_conf:
+    if overloaded_conf.get(output_constants.RESOLUTION, None) is not None:
         resolution = overloaded_conf[output_constants.RESOLUTION]
         # update scaling coeff so the parameters are right for the dsm
         # overloaded_scaling_coeff = 2*resolution
@@ -104,7 +104,7 @@ def check_output_parameters(conf, scaling_coeff):
 
     else:
         resolution = float(0.5 * scaling_coeff)
-        logging.warning(
+        logging.info(
             "The resolution of the output DSM will be " f"{resolution} meters. "
         )
 

cars/pipelines/parameters/sensor_inputs.py

@@ -29,15 +29,13 @@ import os
 
 import numpy as np
 import rasterio as rio
-from json_checker import Checker, OptionalKey, Or
+from json_checker import Checker, Or
 
 # CARS imports
-from cars.core import inputs, preprocessing, projection, roi_tools
+from cars.core import inputs, projection
 from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.utils import make_relative_path_absolute
-from cars.pipelines.parameters import (
-    depth_map_inputs_constants as depth_map_cst,
-)
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
 from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
 
@@ -70,7 +68,6 @@ def sensors_check_inputs(conf, config_dir=None):  # noqa: C901
         sens_cst.PAIRING: Or([[str]], None),
         sens_cst.INITIAL_ELEVATION: Or(str, dict, None),
         sens_cst.ROI: Or(str, dict, None),
-        OptionalKey(depth_map_cst.DEPTH_MAPS): dict,
     }
 
     checker_inputs = Checker(inputs_schema)
@@ -113,12 +110,12 @@ def check_sensors(conf, overloaded_conf, config_dir=None):  # noqa: C901
             sens_cst.INPUT_IMG, None
         )
         if isinstance(image, str):
-            loader_name = "basic"
+            loader_name = "basic_image"
         elif isinstance(image, dict):
-            loader_name = image.get("loader", "basic")
+            loader_name = image.get("loader", "basic_image")
         else:
             raise TypeError(f"Image {image} is not of type str or dict")
-        image_loader = SensorLoader(loader_name, image, "image", config_dir)
+        image_loader = SensorLoader(loader_name, image, config_dir)
         image_as_pivot_format = (
             image_loader.get_pivot_format()  # pylint: disable=E1101
         )
@@ -147,14 +144,12 @@ def check_sensors(conf, overloaded_conf, config_dir=None):  # noqa: C901
         )
         if classif is not None:
             if isinstance(classif, str):
-                loader_name = "basic"
+                loader_name = "basic_classif"
             elif isinstance(classif, dict):
-                loader_name = classif.get("loader", "basic")
+                loader_name = classif.get("loader", "basic_classif")
             else:
                 raise TypeError(f"Classif {classif} is not of type str or dict")
-            classif_loader = SensorLoader(
-                loader_name, classif, "classification", config_dir
-            )
+            classif_loader = SensorLoader(loader_name, classif, config_dir)
             classif_as_pivot_format = (
                 classif_loader.get_pivot_format()  # pylint: disable=E1101
             )
@@ -296,7 +291,9 @@ def get_sensor_resolution(
     return (res_x + res_y) / 2
 
 
-def check_geometry_plugin(conf_inputs, conf_geom_plugin):
+def check_geometry_plugin(
+    conf_inputs, conf_geom_plugin, epipolar_resolution, output_dem_dir
+):
     """
     Check the geometry plugin with inputs
 
@@ -306,6 +303,8 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
     :type conf_advanced: type
     :param conf_geom_plugin: name of geometry plugin
     :type conf_geom_plugin: str
+    :param epipolar_resolution: epipolar resolution
+    :type epipolar_resolution: int
     :return: overload inputs conf
              overloaded geometry plugin conf
              geometry plugin without dem
@@ -329,8 +328,9 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
             sensor,
             geomodel,
         ) = temp_geom_plugin.check_product_consistency(sensor, geomodel)
-        average_sensor_resolution += get_sensor_resolution(
-            temp_geom_plugin, sensor, geomodel
+        average_sensor_resolution += (
+            get_sensor_resolution(temp_geom_plugin, sensor, geomodel)
+            * epipolar_resolution
         )
     average_sensor_resolution /= len(conf_inputs[sens_cst.SENSORS])
     # approximate resolution to the highest digit:
@@ -370,76 +370,29 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
         ] = geomodel
 
     geom_plugin_with_dem_and_geoid = generate_geometry_plugin_with_dem(
-        conf_geom_plugin, conf_inputs, scaling_coeff=scaling_coeff
+        conf_geom_plugin,
+        conf_inputs,
+        scaling_coeff=scaling_coeff,
+        output_dem_dir=output_dem_dir,
     )
 
-    # Check dem is big enough
-    dem_generation_roi_poly = None
-    needed_dem_roi = geom_plugin_with_dem_and_geoid.dem_roi
-    needed_dem_roi_epsg = geom_plugin_with_dem_and_geoid.dem_roi_epsg
-    if needed_dem_roi is not None:
-        needed_dem_roi_poly = roi_tools.bounds_to_poly(needed_dem_roi)
-        # convert to 4326 roi
-        dem_generation_roi_poly = preprocessing.compute_roi_poly(
-            needed_dem_roi_poly, needed_dem_roi_epsg, 4326
-        )
-
-        if (
-            conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-            is not None
-        ):
-            # get dem total roi
-            total_input_roi_poly = roi_tools.bounds_to_poly(
-                inputs.rasterio_get_bounds(
-                    conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-                )
-            )
-            total_input_roi_epsg = inputs.rasterio_get_epsg_code(
-                conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-            )
-            if not isinstance(total_input_roi_epsg, int):
-                total_input_roi_epsg = total_input_roi_epsg.to_epsg()
-            total_input_roi_poly = preprocessing.compute_roi_poly(
-                total_input_roi_poly, total_input_roi_epsg, 4326
-            )
-
-            # if needed roi not inside dem, raise error
-            if not total_input_roi_poly.contains_properly(
-                dem_generation_roi_poly
-            ):
-                base_message = (
-                    "Given initial elevation ROI is not covering needed ROI: "
-                    " EPSG:4326, ROI: {}".format(dem_generation_roi_poly.bounds)
-                )
-
-                if total_input_roi_poly.intersects(dem_generation_roi_poly):
-                    logging.warning(
-                        "{}. Only a part of it intersects. "
-                        "Errors might occur".format(base_message)
-                    )
-                else:
-                    # Exit, Error is certain to occur
-                    raise RuntimeError(base_message)
-
-    else:
-        logging.warning(
-            "Current geometry plugin doesnt compute dem roi needed "
-            "for later computations. Errors related to unsufficient "
-            "dem roi might occur."
-        )
-
     return (
         overloaded_conf_inputs,
         conf_geom_plugin,
         geom_plugin_without_dem_and_geoid,
         geom_plugin_with_dem_and_geoid,
-        dem_generation_roi_poly,
         scaling_coeff,
     )
 
 
+# pylint: disable=too-many-positional-arguments
 def generate_geometry_plugin_with_dem(
-    conf_geom_plugin, conf_inputs, dem=None, crop_dem=True, scaling_coeff=1
+    conf_geom_plugin,
+    conf_inputs,
+    dem=None,
+    crop_dem=True,
+    output_dem_dir=None,
+    scaling_coeff=1,
 ):
     """
     Generate geometry plugin with dem and geoid
@@ -483,6 +436,7 @@ def generate_geometry_plugin_with_dem(
             default_alt=sens_cst.CARS_DEFAULT_ALT,
             pairs_for_roi=pairs_for_roi,
             scaling_coeff=scaling_coeff,
+            output_dem_dir=output_dem_dir,
         )
     )
 
@@ -738,6 +692,7 @@ def check_all_nbits_equal_one(nbits):
     return False
 
 
+@cars_profile(name="Generate inputs")
 def generate_inputs(conf, geometry_plugin):
     """
     Generate sensors inputs form inputs conf :

cars/pipelines/parameters/sensor_inputs_constants.py

@@ -34,8 +34,6 @@ CHECK_INPUTS = "check_inputs"
 ROI = "roi"
 GEOID = "geoid"
 DEM_PATH = "dem"
-ALTITUDE_DELTA_MIN = "altitude_delta_min"
-ALTITUDE_DELTA_MAX = "altitude_delta_max"
 
 INPUT_IMG = "image"
 INPUT_MSK = "mask"

cars/pipelines/parameters/sensor_loaders/__init__.py

@@ -22,6 +22,7 @@
 CARS application module init file
 """
 
-# Imports needed in order to register application for Application factory
-from .basic_sensor_loader import BasicSensorLoader  # noqa: F401
-from .pivot_sensor_loader import PivotSensorLoader  # noqa: F401
+from .basic_classif_loader import BasicClassifSensorLoader  # noqa: F401
+from .basic_image_loader import BasicImageSensorLoader  # noqa: F401
+from .pivot_classif_loader import PivotClassifSensorLoader  # noqa: F401
+from .pivot_image_loader import PivotImageSensorLoader  # noqa: F401