cars 1.0.0a2__cp311-cp311-musllinux_1_2_i686.whl → 1.0.0a4__cp311-cp311-musllinux_1_2_i686.whl

cars/applications/__init__.py

@@ -30,9 +30,6 @@ from . import dense_matching  # noqa: F401
 from . import dsm_filling  # noqa: F401
 from . import grid_generation  # noqa: F401
 from . import ground_truth_reprojection  # noqa: F401
-from . import hole_detection  # noqa: F401
-from . import point_cloud_denoising  # noqa: F401
-from . import point_cloud_fusion  # noqa: F401
 from . import point_cloud_outlier_removal  # noqa: F401
 from . import rasterization  # noqa: F401
 from . import resampling  # noqa: F401

cars/applications/application.py

@@ -26,6 +26,8 @@ This module contains class application factory.
 # Standard imports
 import logging
 
+from cars.applications.application_template import ScalingApplicationTemplate
+
 # CARS imports
 from cars.conf.input_parameters import ConfigType
 
@@ -46,6 +48,7 @@ class Application:
         cls,
         app_name: str,
         cfg: ConfigType = None,
+        scaling_coeff: float = 1,
     ):
         """
         Return the instance of application associated with the application
@@ -55,12 +58,14 @@ class Application:
         :type app_name: str
         :param cfg: configuration {'matching_cost_method': value}
         :type cfg: dictionary
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         """
 
-        return cls.create_app(app_name, cfg)
+        return cls.create_app(app_name, cfg, scaling_coeff)
 
     @classmethod
-    def create_app(cls, name: str, cfg: ConfigType):
+    def create_app(cls, name: str, cfg: ConfigType, scaling_coeff: float = 1):
         """Factory command to create the application
         Return the instance of application associated with the application
         name given as parameter
@@ -69,16 +74,19 @@ class Application:
         :type app_name: str
         :param cfg: configuration {'matching_cost_method': value}
         :type cfg: dictionary
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         """
-        app = None
-
         try:
             app_class = cls.available_applications[name]
         except KeyError:
             logging.error("No application named {0} supported".format(name))
             return None
-        app = app_class(conf=cfg)
-        return app
+
+        if issubclass(app_class, ScalingApplicationTemplate):
+            return app_class(scaling_coeff=scaling_coeff, conf=cfg)
+
+        return app_class(conf=cfg)
 
     @classmethod
     def print_applications(cls):

cars/applications/application_template.py

@@ -29,6 +29,7 @@ in sub application classes
 
 # Standard imports
 import logging
+import os
 import pprint
 from abc import ABCMeta, abstractmethod
 
@@ -102,3 +103,44 @@ class ApplicationTemplate(metaclass=ABCMeta):
         """
 
         return self.used_config
+
+    def generate_unknown_dump_dir(self, orchestrator):
+        """
+        Generate dump dir from orchestrator
+
+        :param orchestrator: orchestrator
+
+        :return: dump dir
+        """
+
+        dump_dir = None
+        if orchestrator is not None:
+            orch_out_dir = orchestrator.out_dir
+            dump_dir = os.path.join(
+                orch_out_dir,
+                "unknown_dump",
+                self.__class__.__bases__[0].__name__,
+            )
+        return dump_dir
+
+
+class ScalingApplicationTemplate(ApplicationTemplate, metaclass=ABCMeta):
+    """
+    Template for applications requiring resolution scaling.
+
+    Inherits from ApplicationTemplate and adds the scaling coefficient
+    as a required argument.
+    """
+
+    def __init__(self, scaling_coeff, conf=None):
+        """
+        Init function of ScalingApplicationTemplate
+
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+
+        :param conf: configuration for application
+        :type conf: dict
+        """
+        self.scaling_coeff = scaling_coeff
+        super().__init__(conf=conf)

cars/applications/auxiliary_filling/abstract_auxiliary_filling_app.py

@@ -86,8 +86,18 @@ class AuxiliaryFilling(ApplicationTemplate, metaclass=ABCMeta):
         cls.available_applications[short_name] = cls
 
     @abstractmethod
-    def run(
-        self, dsm_file, color_file, classif_file, dump_dir, orchestrator=None
+    def run(  # pylint: disable=too-many-positional-arguments
+        self,
+        dsm_file,
+        color_file,
+        classif_file,
+        dump_dir,
+        sensor_inputs,
+        pairing,
+        geom_plugin,
+        texture_bands,
+        output_geoid,
+        orchestrator=None,
     ):
         """
         Run Auxiliary filling

cars/applications/auxiliary_filling/auxiliary_filling_algo.py

@@ -28,7 +28,7 @@ import rasterio as rio
 from scipy import interpolate
 
 
-def fill_auxiliary(
+def fill_auxiliary(  # pylint: disable=too-many-positional-arguments
     sensor_inputs,
     pairing,
     longitudes,
@@ -156,7 +156,7 @@ def fill_auxiliary(
     return filled_color, filled_classif
 
 
-def fill_from_one_sensor(  # noqa C901
+def fill_from_one_sensor(  # pylint: disable=too-many-positional-arguments  # noqa C901
     sensor,
     filled_color,
     filled_classif,

cars/applications/auxiliary_filling/auxiliary_filling_from_sensors_app.py

@@ -30,6 +30,9 @@ import numpy as np
 import rasterio as rio
 import xarray as xr
 from json_checker import Checker
+from pyproj import CRS
+from rasterio.enums import Resampling
+from rasterio.warp import reproject
 from shapely.geometry import Polygon
 
 import cars.orchestrator.orchestrator as ocht
@@ -93,10 +96,11 @@ class AuxiliaryFillingFromSensors(
         overloaded_conf["mode"] = conf.get("mode", "fill_nan")
 
         if overloaded_conf["mode"] not in ["fill_nan", "full"]:
+            # pylint: disable=inconsistent-quotes
             raise RuntimeError(
                 f"Invalid mode {overloaded_conf['mode']} for "
-                "AuxiliaryFilling, supported modes are fill_nan "
-                "and full"
+                f"AuxiliaryFilling, supported modes are fill_nan "
+                f"and full"
             )
 
         overloaded_conf["texture_interpolator"] = conf.get(
@@ -125,7 +129,8 @@ class AuxiliaryFillingFromSensors(
 
         return overloaded_conf
 
-    def run(
+    # pylint: disable=too-many-positional-arguments
+    def run(  # noqa: C901
         self,
         dsm_file,
         color_file,
@@ -135,6 +140,7 @@ class AuxiliaryFillingFromSensors(
         pairing,
         geom_plugin,
         texture_bands,
+        output_geoid,
         orchestrator=None,
     ):
         """
@@ -157,6 +163,10 @@ class AuxiliaryFillingFromSensors(
         :type geom_plugin: AbstractGeometry
         :param texture_bands: list of band names used for output texture
         :type texture_bands: list
+        :param output_geoid: output geoid filename as vertical reference for the
+            input DSM. If a boolean is provided instead of a filename True means
+            defined relative to cars internal geoid, and false on ellipsoid
+        :type output_geoid: OR(bool, str)
         :param orchestrator: orchestrator used
         :type orchestrator: Orchestrator
         """
@@ -187,16 +197,19 @@ class AuxiliaryFillingFromSensors(
             os.makedirs(dump_dir)
 
         color_not_filled_file = os.path.join(dump_dir, "texture_not_filled.tif")
-        if os.path.exists(color_file):
+        if color_file is not None and os.path.exists(color_file):
             shutil.move(color_file, color_not_filled_file)
 
         classification_not_filled_file = None
+        # classif_file could be defined without data attached
+        if classif_file is not None and not os.path.exists(classif_file):
+            classif_file = None
+
         if classif_file is not None:
             classification_not_filled_file = os.path.join(
                 dump_dir, "classification_not_filled.tif"
             )
-            if os.path.exists(classif_file):
-                shutil.move(classif_file, classification_not_filled_file)
+            shutil.move(classif_file, classification_not_filled_file)
 
         # Clean dump_dir at the end of processing if required
         if not self.used_config["save_intermediate_data"]:
@@ -229,19 +242,20 @@ class AuxiliaryFillingFromSensors(
         color_dtype = np.float32
         classif_dtype = np.uint8
 
-        if os.path.exists(color_not_filled_file):
-            with rio.open(color_not_filled_file, "r") as descriptor:
-                texture_no_data_value = descriptor.nodata
-                color_dtype = descriptor.profile.get("dtype", np.float32)
-
-        self.orchestrator.add_to_save_lists(
-            os.path.join(dump_dir, color_file),
-            cst.RASTER_COLOR_IMG,
-            aux_filled_image,
-            nodata=texture_no_data_value,
-            dtype=color_dtype,
-            cars_ds_name="filled_texture",
-        )
+        if color_file is not None:
+            if os.path.exists(color_not_filled_file):
+                with rio.open(color_not_filled_file, "r") as descriptor:
+                    texture_no_data_value = descriptor.nodata
+                    color_dtype = descriptor.profile.get("dtype", np.float32)
+
+            self.orchestrator.add_to_save_lists(
+                os.path.join(dump_dir, color_file),
+                cst.RASTER_COLOR_IMG,
+                aux_filled_image,
+                nodata=texture_no_data_value,
+                dtype=color_dtype,
+                cars_ds_name="filled_texture",
+            )
 
         if classif_file is not None:
             if os.path.exists(classification_not_filled_file):
@@ -264,12 +278,12 @@ class AuxiliaryFillingFromSensors(
         [saving_info] = self.orchestrator.get_saving_infos([aux_filled_image])
 
         reference_transform = inputs.rasterio_get_transform(dsm_file)
-        reference_epsg = inputs.rasterio_get_epsg(dsm_file)
+        reference_crs = inputs.rasterio_get_crs(dsm_file)
 
         # Pre-compute sensor bounds of all sensors to filter sensors that do
         # not intersect with tile in tasks
         sensor_bounds = auxiliary_filling_wrappers.compute_sensor_bounds(
-            sensor_inputs, geom_plugin, reference_epsg
+            sensor_inputs, geom_plugin, reference_crs
         )
 
         for row in range(aux_filled_image.shape[0]):
@@ -296,10 +310,11 @@ class AuxiliaryFillingFromSensors(
                     pairing,
                     window,
                     reference_transform,
-                    reference_epsg,
+                    reference_crs,
                     full_saving_info,
                     geom_plugin,
                     texture_bands,
+                    output_geoid,
                     mode=self.used_config["mode"],
                     texture_interpolator=self.used_config[
                         "texture_interpolator"
@@ -315,6 +330,7 @@ class AuxiliaryFillingFromSensors(
         return aux_filled_image
 
 
+# pylint: disable=too-many-positional-arguments
 def filling_from_sensor_wrapper(
     dsm_file,
     color_file,
@@ -324,10 +340,11 @@ def filling_from_sensor_wrapper(
     pairing,
     window,
     transform,
-    epsg,
+    crs,
     saving_info,
     geom_plugin,
     texture_bands,
+    output_geoid,
     mode,
     texture_interpolator,
     use_mask,
@@ -351,14 +368,18 @@ def filling_from_sensor_wrapper(
     :type window: dict
     :param transform: input geo transform
     :type transform: tuple
-    :param epsg: input epsg
-    :type epsg: int
+    :param crs: input crs
+    :type crs: CRS
     :param saving_info: saving info for cars orchestrator
     :type saving_info: dict
     :param geom_plugin: geometry plugin used for inverse locations
     :type geom_plugin: AbstractGeometry
     :param texture_bands: list of band names used for output texture
     :type texture_bands: list
+    :param output_geoid: output geoid filename as vertical reference for the
+        input DSM. If a boolean is provided instead of a filename True means
+        defined relative to cars internal geoid, and false on ellipsoid
+    :type output_geoid: OR(bool, str)
     :param mode: geometry plugin used for inverse locations
     :type mode: str
     :param texture_interpolator: scipy interpolator use to interpolate color
@@ -366,13 +387,17 @@ def filling_from_sensor_wrapper(
     :type texture_interpolator: str
     :param use_mask: use mask information from sensors in color computation
     :type use_mask: bool
-
     """
 
-    col_min_ground = window["col_min"] * transform[0] + transform[2]
-    col_max_ground = window["col_max"] * transform[0] + transform[2]
-    row_min_ground = window["row_min"] * transform[4] + transform[5]
-    row_max_ground = window["row_max"] * transform[4] + transform[5]
+    col_min = window["col_min"]
+    col_max = window["col_max"]
+    row_min = window["row_min"]
+    row_max = window["row_max"]
+
+    col_min_ground = col_min * transform[0] + transform[2]
+    col_max_ground = col_max * transform[0] + transform[2]
+    row_min_ground = row_min * transform[4] + transform[5]
+    row_max_ground = row_max * transform[4] + transform[5]
 
     ground_polygon = Polygon(
         [
@@ -384,33 +409,31 @@ def filling_from_sensor_wrapper(
         ]
     )
 
-    cols = np.arange(
-        col_min_ground,
-        col_max_ground,
-        transform[0],
+    cols = (
+        np.linspace(col_min, col_max, col_max - col_min) * transform[0]
+        + transform[2]
     )
-    rows = np.arange(
-        row_min_ground,
-        row_max_ground,
-        transform[4],
+    rows = (
+        np.linspace(row_min, row_max, row_max - row_min) * transform[4]
+        + transform[5]
     )
 
     cols_values_2d, rows_values_2d = np.meshgrid(cols, rows)
 
     stacked_values = np.vstack([cols_values_2d.ravel(), rows_values_2d.ravel()])
 
-    lon_lat = projection.point_cloud_conversion(
-        stacked_values.transpose(), epsg, 4326
+    lon_lat = projection.point_cloud_conversion_crs(
+        stacked_values.transpose(), crs, CRS(4326)
     )
 
     rio_window = rio.windows.Window.from_slices(
         (
-            window["row_min"],
-            window["row_max"],
+            row_min,
+            row_max,
         ),
         (
-            window["col_min"],
-            window["col_max"],
+            col_min,
+            col_max,
         ),
     )
 
@@ -424,6 +447,28 @@ def filling_from_sensor_wrapper(
         target_mask = dsm_image.read_masks(1, window=rio_window)
         dsm_profile = dsm_image.profile
 
+    if output_geoid:
+        if output_geoid is True:
+            geoid_file = geom_plugin.geoid
+        else:
+            geoid_file = output_geoid
+        with rio.open(geoid_file) as in_geoid:
+            # Reproject the geoid data to match the DSM
+            output_geoid_data = np.empty(
+                alt_values.shape, dtype=in_geoid.dtypes[0]
+            )
+
+            reproject(
+                source=rio.band(in_geoid, 1),
+                destination=output_geoid_data,
+                src_transform=in_geoid.transform,
+                src_crs=in_geoid.crs,
+                dst_transform=transform,
+                dst_crs=crs,
+                resampling=Resampling.bilinear,
+            )
+            alt_values += output_geoid_data
+
     nodata_color = None
     nodata_classif = None
 
@@ -458,6 +503,7 @@ def filling_from_sensor_wrapper(
     number_of_classification_bands = 0
     classification_values = None
     classification_band_names = None
+
     if classification_file is not None:
         if os.path.exists(classification_file):
             with rio.open(classification_file) as classification_image:
@@ -538,8 +584,8 @@ def filling_from_sensor_wrapper(
                 classification_values_filled[band_index, :],
             )
 
-    row_arr = np.array(range(window["row_min"], window["row_max"]))
-    col_arr = np.array(range(window["col_min"], window["col_max"]))
+    row_arr = np.array(range(row_min, row_max))
+    col_arr = np.array(range(col_min, col_max))
 
     values = {}
     coords = {cst.ROW: row_arr, cst.COL: col_arr}
@@ -568,6 +614,9 @@ def filling_from_sensor_wrapper(
         values,
         coords=coords,
     )
+
+    profile.update(crs=crs.to_wkt())
+
     cars_dataset.fill_dataset(
         dataset,
         saving_info=saving_info,

cars/applications/auxiliary_filling/auxiliary_filling_wrappers.py

@@ -22,12 +22,13 @@
 this module contains the AuxiliaryFillingFromSensors application class.
 """
 
+from pyproj import CRS
 from shapely.geometry import Polygon
 
-from cars.core.projection import polygon_projection
+from cars.core.projection import polygon_projection_crs
 
 
-def compute_sensor_bounds(sensor_inputs, geom_plugin, output_epsg):
+def compute_sensor_bounds(sensor_inputs, geom_plugin, output_crs):
     """
     Compute bounds of each input sensor that have an associated color or
     classification image
@@ -38,8 +39,8 @@ def compute_sensor_bounds(sensor_inputs, geom_plugin, output_epsg):
     :type geom_plugin: AbstractGeometry
     :param geom_plugin: geometry plugin used for inverse locations
     :type geom_plugin: AbstractGeometry
-    :param output_epsg: epsg of the output polygons
-    :type output_epsg: int
+    :param output_crs: crs of the output polygons
+    :type output_crs: CRS
 
     :return: a dictionary containing a Polygon in output geometry for each
         valid input sensor
@@ -59,8 +60,8 @@ def compute_sensor_bounds(sensor_inputs, geom_plugin, output_epsg):
 
         poly_geo = Polygon([u_l, u_r, l_r, l_l, u_l])
 
-        sensor_bounds[sensor_name] = polygon_projection(
-            poly_geo, 4326, output_epsg
+        sensor_bounds[sensor_name] = polygon_projection_crs(
+            poly_geo, CRS(4326), output_crs
         )
 
     return sensor_bounds

cars/applications/dem_generation/abstract_dem_generation_app.py

@@ -26,11 +26,11 @@ from abc import ABCMeta, abstractmethod
 from typing import Dict
 
 from cars.applications.application import Application
-from cars.applications.application_template import ApplicationTemplate
+from cars.applications.application_template import ScalingApplicationTemplate
 
 
 @Application.register("dem_generation")
-class DemGeneration(ApplicationTemplate, metaclass=ABCMeta):
+class DemGeneration(ScalingApplicationTemplate, metaclass=ABCMeta):
     """
     DemGeneration
     """
@@ -38,13 +38,15 @@ class DemGeneration(ApplicationTemplate, metaclass=ABCMeta):
     available_applications: Dict = {}
     default_application = "bulldozer_on_raster"
 
-    def __new__(cls, conf=None):  # pylint: disable=W0613
+    def __new__(cls, scaling_coeff, conf=None):  # pylint: disable=W0613
         """
         Return the required application
         :raises:
          - KeyError when the required application is not registered
 
         :param orchestrator: orchestrator used
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration for resampling
         :return: an application_to_use object
         """
@@ -84,15 +86,17 @@ class DemGeneration(ApplicationTemplate, metaclass=ABCMeta):
         super().__init_subclass__(**kwargs)
         cls.available_applications[short_name] = cls
 
-    def __init__(self, conf=None):
+    def __init__(self, scaling_coeff, conf=None):
         """
         Init function of MntGeneration
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration
         :return: an application_to_use object
         """
 
-        super().__init__(conf=conf)
+        super().__init__(scaling_coeff, conf=conf)
 
     @abstractmethod
     def run(self, triangulated_matches_list, output_dir):

cars/applications/dem_generation/dem_generation_algo.py

@@ -108,7 +108,7 @@ def launch_bulldozer(
     return output_dem
 
 
-def multi_res_rec(
+def multi_res_rec(  # pylint: disable=too-many-positional-arguments
     pd_pc,
     list_fun,
     x_grid,