cars 1.0.0a1__cp310-cp310-musllinux_1_2_i686.whl → 1.0.0a3__cp310-cp310-musllinux_1_2_i686.whl

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

@@ -102,3 +102,25 @@ class ApplicationTemplate(metaclass=ABCMeta):
         """
 
         return self.used_config
+
+
+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/auxiliary_filling_from_sensors_app.py

@@ -30,6 +30,7 @@ import numpy as np
 import rasterio as rio
 import xarray as xr
 from json_checker import Checker
+from pyproj import CRS
 from shapely.geometry import Polygon
 
 import cars.orchestrator.orchestrator as ocht
@@ -191,12 +192,15 @@ class AuxiliaryFillingFromSensors(
             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"]:
@@ -264,12 +268,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,7 +300,7 @@ class AuxiliaryFillingFromSensors(
                     pairing,
                     window,
                     reference_transform,
-                    reference_epsg,
+                    reference_crs,
                     full_saving_info,
                     geom_plugin,
                     texture_bands,
@@ -324,7 +328,7 @@ def filling_from_sensor_wrapper(
     pairing,
     window,
     transform,
-    epsg,
+    crs,
     saving_info,
     geom_plugin,
     texture_bands,
@@ -351,8 +355,8 @@ 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
@@ -399,8 +403,8 @@ def filling_from_sensor_wrapper(
 
     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(
@@ -458,6 +462,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:

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_wrappers.py

@@ -35,6 +35,7 @@ from affine import Affine
 from rasterio.coords import BoundingBox
 from rasterio.enums import Resampling
 from rasterio.warp import calculate_default_transform, reproject
+from scipy.ndimage import median_filter
 
 from cars.core import preprocessing
 
@@ -243,7 +244,12 @@ def reverse_dem(input_dem):
         out_dem.nodata = -nodata
 
 
-def downsample_dem(input_dem, scale):
+def downsample_dem(
+    input_dem,
+    scale,
+    median_filter_size=7,
+    default_alt=0,
+):
     """
     Downsample median DEM with median resampling
 
@@ -265,10 +271,10 @@ def downsample_dem(input_dem, scale):
     metadata["transform"] = dst_transform
     metadata["height"] = dst_height
     metadata["width"] = dst_width
-    output = np.zeros((dst_height, dst_width))
+    dem_data = np.zeros((dst_height, dst_width))
     reproject(
         data,
-        output,
+        dem_data,
         src_transform=src_transform,
         src_crs=crs,
         dst_transform=dst_transform,
@@ -277,23 +283,39 @@ def downsample_dem(input_dem, scale):
         resampling=Resampling.med,
     )
 
+    # Post-processing
+
+    # Median filter
+    dem_data = median_filter(dem_data, size=median_filter_size)
+
+    # Fill nodata
+    dem_data = rio.fill.fillnodata(
+        dem_data,
+        mask=~(dem_data == nodata),
+    )
+
+    dem_data[dem_data == nodata] = default_alt
+
     with rio.open(input_dem, "w", **metadata) as dst:
-        dst.write(output, 1)
+        dst.write(dem_data, 1)
 
 
-def modify_terrain_bounds(dem_roi_to_use, epsg, margin):
+def modify_terrain_bounds(
+    bounds_poly, in_epsg, out_epsg, constant_margin, linear_margin=0
+):
     """
     Modify the terrain bounds
 
-    :param dem_roi_to_use: the dem roi
-    :type dem_roi_to_use: polygon
-    :param epsg: the epsg code
-    :type epsg: int
-    :param margin: the margin
+    :param bounds_poly: Input region of interest for DEM
+    :type bounds_poly: list
+    :param in_epsg: EPSG code of dem_roi_to_use
+    :type in_epsg: int
+    :param out_epsg: EPSG code of dem_roi_to_use
+    :type out_epsg: int
+    :param margin: Margin of the output ROI in meters
     :type margin: int
     """
     # Get bounds
-    bounds_poly = dem_roi_to_use.bounds
     xmin = min(bounds_poly[0], bounds_poly[2])
     xmax = max(bounds_poly[0], bounds_poly[2])
     ymin = min(bounds_poly[1], bounds_poly[3])
@@ -301,24 +323,25 @@ def modify_terrain_bounds(dem_roi_to_use, epsg, margin):
 
     bounds_cloud = [xmin, ymin, xmax, ymax]
 
-    # Convert resolution and margin to degrees
-    utm_epsg = preprocessing.get_utm_zone_as_epsg_code(xmin, ymin)
-    conversion_factor = preprocessing.get_conversion_factor(
-        bounds_cloud, 4326, utm_epsg
-    )
-    margin_in_degrees = margin * conversion_factor
+    if in_epsg == 4326:
+        # Convert resolution and margin to degrees
+        utm_epsg = preprocessing.get_utm_zone_as_epsg_code(xmin, ymin)
+        conversion_factor = preprocessing.get_conversion_factor(
+            bounds_cloud, 4326, utm_epsg
+        )
+        constant_margin *= conversion_factor
 
     # Get borders, adding margin
-    xmin = xmin - margin_in_degrees
-    ymin = ymin - margin_in_degrees
-    xmax = xmax + margin_in_degrees
-    ymax = ymax + margin_in_degrees
+    xmin = xmin - constant_margin - linear_margin * (xmax - xmin)
+    ymin = ymin - constant_margin - linear_margin * (ymax - ymin)
+    xmax = xmax + constant_margin + linear_margin * (xmax - xmin)
+    ymax = ymax + constant_margin + linear_margin * (ymax - ymin)
 
     terrain_bounds = [xmin, ymin, xmax, ymax]
 
-    if epsg != 4326:
-        crs_in = pyproj.CRS.from_epsg(4326)
-        crs_out = pyproj.CRS.from_epsg(epsg)
+    if out_epsg != in_epsg:
+        crs_in = pyproj.CRS.from_epsg(in_epsg)
+        crs_out = pyproj.CRS.from_epsg(out_epsg)
 
         transformer = pyproj.Transformer.from_crs(
             crs_in, crs_out, always_xy=True
@@ -340,7 +363,7 @@ def modify_terrain_bounds(dem_roi_to_use, epsg, margin):
 
 def reproject_dem(dsm_file_name, epsg_out, out_file_name):
     """
-    Reproject the dem
+    Reproject the DEM
 
     :param dsm_file_name: the path to dsm
     :type dsm_file_name: str

cars/applications/dem_generation/dichotomic_generation_app.py

@@ -64,14 +64,16 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
 
     # pylint: disable=too-many-instance-attributes
 
-    def __init__(self, conf=None):
+    def __init__(self, scaling_coeff, conf=None):
         """
         Init function of DichotomicGeneration
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration for DichotomicGeneration
         :return: an application_to_use object
         """
-        super().__init__(conf=conf)
+        super().__init__(scaling_coeff, conf=conf)
 
         # check conf
         self.used_method = self.used_config["method"]
@@ -175,11 +177,13 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         self,
         triangulated_matches_list,
         output_dir,
-        geoid_path,
+        input_geoid,
+        output_geoid,
         dem_roi_to_use=None,
         initial_elevation=None,
+        default_alt=0,
         cars_orchestrator=None,
-    ):
+    ):  # pylint: disable=W0613
         """
         Run dichotomic dem generation using matches
 
@@ -188,7 +192,8 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         :type triangulated_matches_list: list(pandas.Dataframe)
         :param output_dir: directory to save dem
         :type output_dir: str
-        :param geoid_path: geoid path
+        :param input_geoid: input geoid path
+        :param output_geoid: output geoid path
         :param cars_orchrestrator: the main cars orchestrator
         :param dem_roi_to_use: dem roi polygon to use as roi
         :param initial_elevation: the path to the initial elevation file
@@ -208,6 +213,11 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         # Generate point cloud
         epsg = 4326
 
+        # Optimize the case when input and output geoid are the same
+        if output_geoid is True:
+            input_geoid = False
+            output_geoid = False
+
         for pair_pc in triangulated_matches_list:
             # convert to degrees for geoid offset
             if pair_pc.attrs["epsg"] != epsg:
@@ -312,9 +322,14 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         # Transform to lon lat
         projection.point_cloud_conversion_dataset(alti_zeros_dataset, 4326)
 
-        geoid_offset = triangulation_wrappers.geoid_offset(
-            alti_zeros_dataset, geoid_path
-        )
+        if input_geoid:
+            input_geoid = triangulation_wrappers.geoid_offset(
+                alti_zeros_dataset, input_geoid
+            )
+        if output_geoid:
+            output_geoid = triangulation_wrappers.geoid_offset(
+                alti_zeros_dataset, output_geoid
+            )
 
         # fillnodata
         valid = np.isfinite(list_z_grid[0])
@@ -323,7 +338,10 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
             list_z_grid[idx] = rasterio.fill.fillnodata(
                 list_z_grid[idx], mask=valid, max_search_distance=msd
             )
-            list_z_grid[idx] += geoid_offset[cst.Z].values
+            if input_geoid:
+                list_z_grid[idx] += input_geoid[cst.Z].values
+            if output_geoid:
+                list_z_grid[idx] -= output_geoid[cst.Z].values
 
         dem_median = list_z_grid[0]
         dem_min = list_z_grid[1]