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

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,12 +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
-        )
-
-        # Check conf output
-        output = self.check_output(conf[OUTPUT])
+        inputs = self.check_inputs(conf[INPUTS], config_dir=config_dir)
 
         # Check advanced parameters
         # TODO static method in the base class
@@ -130,10 +129,19 @@ class DefaultPipeline(PipelineTemplate):
             self.geom_plugin_without_dem_and_geoid,
             self.geom_plugin_with_dem_and_geoid,
             _,
+            self.scaling_coeff,
+            _,
+            _,
         ) = advanced_parameters.check_advanced_parameters(
             inputs, conf.get(ADVANCED, {}), check_epipolar_a_priori=True
         )
 
+        # Check conf output
+        (
+            output,
+            self.scaling_coeff,
+        ) = self.check_output(conf[OUTPUT], self.scaling_coeff)
+
         resolutions = advanced["epipolar_resolutions"]
         if isinstance(resolutions, int):
             resolutions = [resolutions]
@@ -252,20 +260,6 @@ class DefaultPipeline(PipelineTemplate):
                     # (except the last one)
                     self.used_conf[key][OUTPUT][out_cst.PRODUCT_LEVEL] = "dsm"
 
-                    # The idea is to calculate the less possible things
-                    # So we override those parameters
-                    self.used_conf[key][ADVANCED][adv_cst.MERGING] = False
-                    self.used_conf[key][ADVANCED][adv_cst.PHASING] = None
-                    self.used_conf[key][OUTPUT][out_cst.SAVE_BY_PAIR] = False
-
-                    aux_items = self.used_conf[key][OUTPUT][
-                        out_cst.AUXILIARY
-                    ].items()
-                    for aux_key, _ in aux_items:
-                        if aux_key not in ("dem_min", "dem_max", "dem_median"):
-                            self.used_conf[key][OUTPUT][out_cst.AUXILIARY][
-                                aux_key
-                            ] = False
                 else:
                     # If save_intermediate_data is true,
                     # we save the depth_maps also to debug
@@ -523,15 +517,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,36 +538,36 @@ 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
 
     @staticmethod
-    def check_output(conf):
+    def check_output(conf, scaling_coeff):
         """
         Check the output given
 
         :param conf: configuration of output
         :type conf: 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 merge_resolution_conf(self, config1, config2):
         """
@@ -629,6 +623,7 @@ class DefaultPipeline(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
@@ -727,7 +722,9 @@ class DefaultPipeline(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()
@@ -736,7 +733,9 @@ class DefaultPipeline(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()
 
@@ -758,10 +757,13 @@ class DefaultPipeline(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()
 
@@ -772,6 +774,7 @@ class DefaultPipeline(PipelineTemplate):
                     "dense_match_filling.1",
                     {"method": "plane"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.1"] = (
                 self.dense_match_filling_1.get_conf()
@@ -784,6 +787,7 @@ class DefaultPipeline(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()
@@ -793,6 +797,7 @@ class DefaultPipeline(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()
@@ -820,7 +825,9 @@ class DefaultPipeline(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()
 
@@ -830,20 +837,11 @@ 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", {})
+                "triangulation",
+                cfg=used_conf.get("triangulation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["triangulation"] = (
                 self.triangulation_application.get_conf()
@@ -851,12 +849,22 @@ class DefaultPipeline(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,
             )
+
+            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"]:
@@ -870,6 +878,7 @@ class DefaultPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.1",
                     {"method": "small_components"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
 
             connection_val = None
@@ -897,6 +906,7 @@ class DefaultPipeline(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()
@@ -908,6 +918,7 @@ class DefaultPipeline(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()
 
@@ -917,6 +928,7 @@ class DefaultPipeline(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()
@@ -928,6 +940,7 @@ class DefaultPipeline(PipelineTemplate):
                         "dsm_filling.1",
                         {"method": "exogenous_filling"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.1"] = (
                     self.dsm_filling_1_application.get_conf()
@@ -950,13 +963,16 @@ class DefaultPipeline(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()
@@ -968,6 +984,7 @@ class DefaultPipeline(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()
@@ -1118,7 +1135,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/advanced_parameters.py

@@ -60,6 +60,10 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         adv_cst.SAVE_INTERMEDIATE_DATA, False
     )
 
+    overloaded_conf[adv_cst.LAND_COVER_MAP] = conf.get(
+        adv_cst.LAND_COVER_MAP, "global_land_cover_map.tif"
+    )
+
     overloaded_conf[adv_cst.KEEP_LOW_RES_DIR] = conf.get(
         adv_cst.KEEP_LOW_RES_DIR, True
     )
@@ -68,6 +72,10 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         adv_cst.DEBUG_WITH_ROI, False
     )
 
+    overloaded_conf[adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING] = conf.get(
+        adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING, "config_mapping.json"
+    )
+
     overloaded_conf[adv_cst.PHASING] = conf.get(adv_cst.PHASING, None)
 
     overloaded_conf[adv_cst.EPIPOLAR_RESOLUTIONS] = conf.get(
@@ -144,6 +152,7 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
                     ]
                 )
 
+    scaling_coeff = None
     if inputs[sens_cst.SENSORS] is not None:
         # Check geometry plugin and overwrite geomodel in conf inputs
         (
@@ -152,10 +161,13 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
             geom_plugin_without_dem_and_geoid,
             geom_plugin_with_dem_and_geoid,
             dem_generation_roi,
+            scaling_coeff,
         ) = sensor_inputs.check_geometry_plugin(
             inputs, conf.get(adv_cst.GEOMETRY_PLUGIN, None)
         )
     elif depth_cst.DEPTH_MAPS in inputs or dsm_cst.DSMS in inputs:
+        # assume the input comes from 0.5m sensor images
+        scaling_coeff = 1
         # If there's an initial elevation with
         # point clouds as inputs, generate a plugin (used in dsm_filling)
         (
@@ -182,6 +194,8 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         adv_cst.DSM_MERGING_TILE_SIZE: And(int, lambda x: x > 0),
         adv_cst.TEXTURE_BANDS: list,
         adv_cst.EPIPOLAR_RESOLUTIONS: Or(int, list),
+        adv_cst.LAND_COVER_MAP: str,
+        adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING: str,
     }
     if check_epipolar_a_priori:
         schema[adv_cst.USE_EPIPOLAR_A_PRIORI] = bool
@@ -245,6 +259,9 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         geom_plugin_without_dem_and_geoid,
         geom_plugin_with_dem_and_geoid,
         dem_generation_roi,
+        scaling_coeff,
+        overloaded_conf[adv_cst.LAND_COVER_MAP],
+        overloaded_conf[adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING],
     )
 
 

cars/pipelines/parameters/advanced_parameters_constants.py

@@ -27,6 +27,10 @@ SAVE_INTERMEDIATE_DATA = "save_intermediate_data"
 KEEP_LOW_RES_DIR = "keep_low_res_dir"
 PHASING = "phasing"
 DEBUG_WITH_ROI = "debug_with_roi"
+LAND_COVER_MAP = "land_cover_map"
+CLASSIFICATION_TO_CONFIGURATION_MAPPING = (
+    "classification_to_configuration_mapping"
+)
 
 USE_EPIPOLAR_A_PRIORI = "use_epipolar_a_priori"
 EPIPOLAR_A_PRIORI = "epipolar_a_priori"