cars 1.0.0a2__cp312-cp312-musllinux_1_2_i686.whl → 1.0.0a3__cp312-cp312-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

@@ -244,7 +244,12 @@ def reverse_dem(input_dem):
         out_dem.nodata = -nodata
 
 
-def downsample_dem(input_dem, scale, median_filter_size=7):
+def downsample_dem(
+    input_dem,
+    scale,
+    median_filter_size=7,
+    default_alt=0,
+):
     """
     Downsample median DEM with median resampling
 
@@ -266,10 +271,10 @@ def downsample_dem(input_dem, scale, median_filter_size=7):
     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,
@@ -278,26 +283,39 @@ def downsample_dem(input_dem, scale, median_filter_size=7):
         resampling=Resampling.med,
     )
 
-    # Median filter as post-processing
-    output = median_filter(output, size=median_filter_size)
+    # 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])
@@ -305,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
@@ -344,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"]
@@ -179,8 +181,9 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         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
 

cars/applications/dem_generation/rasterization_app.py

@@ -63,14 +63,16 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
 
     # pylint: disable=too-many-instance-attributes
 
-    def __init__(self, conf=None):
+    def __init__(self, scaling_coeff, conf=None):
         """
         Init function of Rasterization
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration for Rasterization
         :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"]
@@ -134,8 +136,12 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
 
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer_on_raster")
-        overloaded_conf["resolution"] = conf.get("resolution", 2)
-        overloaded_conf["margin"] = conf.get("margin", 500)
+        overloaded_conf["resolution"] = conf.get(
+            "resolution", float(self.scaling_coeff * 2)
+        )
+        overloaded_conf["margin"] = conf.get(
+            "margin", float(self.scaling_coeff * 500)
+        )
         overloaded_conf["morphological_filters_size"] = conf.get(
             "morphological_filters_size", 30
         )
@@ -153,7 +159,9 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         )
         overloaded_conf["min_dem"] = conf.get("min_dem", -500)
         overloaded_conf["max_dem"] = conf.get("max_dem", 1000)
-        overloaded_conf["height_margin"] = conf.get("height_margin", 20)
+        overloaded_conf["height_margin"] = conf.get(
+            "height_margin", float(self.scaling_coeff * 20)
+        )
         overloaded_conf["bulldozer_max_object_size"] = conf.get(
             "bulldozer_max_object_size", 8
         )
@@ -203,6 +211,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         input_geoid,
         output_geoid,
         initial_elevation=None,
+        default_alt=0,
         cars_orchestrator=None,
     ):
         """
@@ -410,6 +419,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             dem_median_path_out,
             scale=self.dem_median_output_resolution / resolution_in_meters,
             median_filter_size=self.postprocessing_median_filter_size,
+            default_alt=default_alt,
         )
 
         # Launch Bulldozer on dem min

cars/applications/dense_matching/census_mccnn_sgm_app.py

@@ -35,11 +35,11 @@ from typing import Dict, Tuple
 import numpy as np
 import pandora
 import xarray as xr
-from affine import Affine
 from json_checker import And, Checker, Or
 from pandora.check_configuration import check_pipeline_section
 from pandora.img_tools import add_global_disparity
 from pandora.state_machine import PandoraMachine
+from rasterio.profiles import DefaultGTiffProfile
 from scipy.ndimage import maximum_filter, minimum_filter
 
 import cars.applications.dense_matching.dense_matching_constants as dm_cst
@@ -78,6 +78,7 @@ class CensusMccnnSgm(
         "census_sgm_mountain_and_vegetation",
         "census_sgm_homogeneous",
         "mccnn_sgm",
+        "auto",
     ],
 ):  # pylint: disable=R0903,disable=R0902
     """
@@ -178,7 +179,7 @@ class CensusMccnnSgm(
 
         # Overload conf
         overloaded_conf["method"] = conf.get(
-            "method", "census_sgm_default"
+            "method", "auto"
         )  # change it if census_sgm is not default
         # method called in abstract_dense_matching_app.py
         overloaded_conf["min_epi_tile_size"] = conf.get(
@@ -597,6 +598,13 @@ class CensusMccnnSgm(
 
         return margins_wrapper
 
+    def get_method(self):
+        """
+        return the method that will be used in dense_matching
+        """
+
+        return self.used_method
+
     @cars_profile(name="Optimal size estimation")
     def get_optimal_tile_size(self, disp_range_grid, max_ram_per_worker):
         """
@@ -792,26 +800,7 @@ class CensusMccnnSgm(
         global_infos_cars_ds = cars_dataset.CarsDataset("dict")
 
         # Generate profile
-        geotransform = (
-            epi_size_row,
-            step_row,
-            0.0,
-            epi_size_col,
-            0.0,
-            step_col,
-        )
-
-        transform = Affine.from_gdal(*geotransform)
-        raster_profile = collections.OrderedDict(
-            {
-                "height": nb_rows,
-                "width": nb_cols,
-                "driver": "GTiff",
-                "dtype": "float32",
-                "transform": transform,
-                "tiled": True,
-            }
-        )
+        raster_profile = DefaultGTiffProfile(count=1)
 
         # saving infos
         # disp grids

cars/applications/dense_matching/disparity_grid_algo.py

@@ -216,6 +216,25 @@ def generate_disp_range_from_dem_wrapper(
     :rtype: dict
     """
 
+    # compute reverse matrix
+    transform_sensor = rasterio.Affine(
+        *np.abs(
+            inputs.rasterio_get_transform(
+                sensor_image_right["image"]["main_file"]
+            )
+        )
+    )
+
+    trans_inv_sensor = ~transform_sensor
+    # Transform to positive values
+    trans_inv_sensor = np.array(trans_inv_sensor)
+    trans_inv_sensor = np.reshape(trans_inv_sensor, (3, 3))
+    if trans_inv_sensor[0, 0] < 0:
+        trans_inv_sensor[0, :] *= -1
+    if trans_inv_sensor[1, 1] < 0:
+        trans_inv_sensor[1, :] *= -1
+    trans_inv_sensor = affine.Affine(*list(trans_inv_sensor.flatten()))
+
     # Geometry plugin
     geo_plugin = geom_plugin_with_dem_and_geoid
 
@@ -276,14 +295,11 @@ def generate_disp_range_from_dem_wrapper(
         (np.max(col_range_with_margin), np.max(row_range_with_margin)),
     ]
     sensor_bbox = geo_plugin.sensor_position_from_grid(grid_right, epi_bbox)
-    transform_sensor = inputs.rasterio_get_transform(
-        sensor_image_right["image"]["main_file"]
-    )
     row_sensor_bbox, col_sensor_bbox = transform_physical_point_to_index(
-        ~transform_sensor, sensor_bbox[:, 1], sensor_bbox[:, 0]
+        trans_inv_sensor, sensor_bbox[:, 1], sensor_bbox[:, 0]
     )
 
-    terrain_bbox = geo_plugin.direct_loc(
+    terrain_bbox = geo_plugin.safe_direct_loc(
         sensor_image_right["image"]["main_file"],
         sensor_image_right["geomodel"],
         col_sensor_bbox,
@@ -365,7 +381,7 @@ def generate_disp_range_from_dem_wrapper(
         ind_cols_sensor,
         ind_rows_sensor,
         _,
-    ) = geom_plugin_with_dem_and_geoid.inverse_loc(
+    ) = geom_plugin_with_dem_and_geoid.safe_inverse_loc(
         sensor_image_right["image"]["main_file"],
         sensor_image_right["geomodel"],
         lat_mean,
@@ -397,35 +413,13 @@ def generate_disp_range_from_dem_wrapper(
         )
     )
 
-    # compute reverse matrix
-    transform_sensor = rasterio.Affine(
-        *np.abs(
-            inputs.rasterio_get_transform(
-                sensor_image_right["image"]["main_file"]
-            )
+    # Transform physical position to index
+    ind_rows_sensor_grid, ind_cols_sensor_grid = (
+        transform_physical_point_to_index(
+            trans_inv_sensor, sensors_positions[:, 1], sensors_positions[:, 0]
         )
     )
 
-    trans_inv = ~transform_sensor
-    # Transform to positive values
-    trans_inv = np.array(trans_inv)
-    trans_inv = np.reshape(trans_inv, (3, 3))
-    if trans_inv[0, 0] < 0:
-        trans_inv[0, :] *= -1
-    if trans_inv[1, 1] < 0:
-        trans_inv[1, :] *= -1
-    trans_inv = affine.Affine(*list(trans_inv.flatten()))
-
-    # Transform physical position to index
-    index_positions = np.empty(sensors_positions.shape)
-    for row_point in range(index_positions.shape[0]):
-        row_geo, col_geo = sensors_positions[row_point, :]
-        col, row = trans_inv * (row_geo, col_geo)
-        index_positions[row_point, :] = (row, col)
-
-    ind_rows_sensor_grid = index_positions[:, 0] - 0.5
-    ind_cols_sensor_grid = index_positions[:, 1] - 0.5
-
     if len(ind_rows_sensor) < 5:
         # QH6214 needs at least 4 points for interpolation
 

cars/applications/dense_matching/loaders/config_mapping.json

@@ -0,0 +1,13 @@
+{
+    "10": "census_sgm_mountain_and_vegetation",
+    "20": "census_sgm_mountain_and_vegetation",
+    "30": "census_sgm_mountain_and_vegetation",
+    "40": "census_sgm_mountain_and_vegetation",
+    "50": "census_sgm_urban",
+    "60": "census_sgm_homogeneous",
+    "70": "census_sgm_mountain_and_vegetation",
+    "80": "census_sgm_mountain_and_vegetation",
+    "90": "census_sgm_mountain_and_vegetation",
+    "95": "census_sgm_mountain_and_vegetation",
+    "100": "census_sgm_mountain_and_vegetation"
+}