cars 1.0.0a2__cp310-cp310-win_amd64.whl → 1.0.0a4__cp310-cp310-win_amd64.whl

cars/applications/dem_generation/dem_generation_wrappers.py

@@ -26,7 +26,6 @@ import logging
 import os
 
 import numpy as np
-import pyproj
 import rasterio as rio
 import xdem
 
@@ -37,8 +36,6 @@ from rasterio.enums import Resampling
 from rasterio.warp import calculate_default_transform, reproject
 from scipy.ndimage import median_filter
 
-from cars.core import preprocessing
-
 
 def fit_initial_elevation_on_dem_median(
     dem_to_fit_path: str, dem_ref_path: str, dem_out_path: str
@@ -136,7 +133,7 @@ def add_margin(bbox, ratio=1):
     return new_bbox
 
 
-def generate_grid(
+def generate_grid(  # pylint: disable=too-many-positional-arguments
     pd_pc, resolution, xmin=None, xmax=None, ymin=None, ymax=None
 ):
     """
@@ -244,7 +241,13 @@ 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,
+    interpolator,
+    median_filter_size=None,
+    default_alt=0,
+):
     """
     Downsample median DEM with median resampling
 
@@ -266,85 +269,67 @@ 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))
+    interpolator_dict = {
+        "min": Resampling.min,
+        "median": Resampling.med,
+        "max": Resampling.max,
+        "nearest": Resampling.nearest,
+    }
+    interpolator = interpolator_dict[interpolator]
     reproject(
         data,
-        output,
+        dem_data,
         src_transform=src_transform,
         src_crs=crs,
         dst_transform=dst_transform,
         dst_crs=crs,
         dst_nodata=nodata,
-        resampling=Resampling.med,
+        resampling=interpolator,
+    )
+
+    # Post-processing
+
+    # Median filter
+    if median_filter_size is not None:
+        dem_data = median_filter(dem_data, size=median_filter_size)
+
+    # Fill nodata
+    dem_data = rio.fill.fillnodata(
+        dem_data,
+        mask=~(dem_data == nodata),
     )
 
-    # Median filter as post-processing
-    output = median_filter(output, size=median_filter_size)
+    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(terrain_bounds, linear_margin, constant_margin):
     """
     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 terrain_bounds: Input region of interest for DEM
+    :type terrain_bounds: list
+    :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])
-    ymax = max(bounds_poly[1], bounds_poly[3])
-
-    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
-
-    # Get borders, adding margin
-    xmin = xmin - margin_in_degrees
-    ymin = ymin - margin_in_degrees
-    xmax = xmax + margin_in_degrees
-    ymax = ymax + margin_in_degrees
+    xsize = terrain_bounds[2] - terrain_bounds[0]
+    ysize = terrain_bounds[3] - terrain_bounds[1]
+    xmin = terrain_bounds[0] - linear_margin * xsize - constant_margin
+    ymin = terrain_bounds[1] - linear_margin * ysize - constant_margin
+    xmax = terrain_bounds[2] + linear_margin * xsize + constant_margin
+    ymax = terrain_bounds[3] + linear_margin * ysize + constant_margin
 
     terrain_bounds = [xmin, ymin, xmax, ymax]
 
-    if epsg != 4326:
-        crs_in = pyproj.CRS.from_epsg(4326)
-        crs_out = pyproj.CRS.from_epsg(epsg)
-
-        transformer = pyproj.Transformer.from_crs(
-            crs_in, crs_out, always_xy=True
-        )
-
-        xymin = transformer.transform(terrain_bounds[0], terrain_bounds[1])
-        xymax = transformer.transform(terrain_bounds[2], terrain_bounds[3])
-
-        xmin, ymin = xymin if isinstance(xymin, tuple) else (None, None)
-        xmax, ymax = xymax if isinstance(xymax, tuple) else (None, None)
-
-        if None in (xmin, ymin, xmax, ymax):
-            raise RuntimeError("An error occured during the projection")
-
-    new_terrain_bounds = [xmin, ymin, xmax, ymax]
-
-    return new_terrain_bounds
+    return terrain_bounds
 
 
 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"]
@@ -127,7 +129,7 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         overloaded_conf["resolution"] = conf.get("resolution", 90)
         # default margin: (z max - zmin) * tan(teta)
         # with z max = 9000, z min = 0, teta = 30 degrees
-        overloaded_conf["margin"] = conf.get("margin", 6000)
+        overloaded_conf["margin"] = conf.get("margin", [0, 6000])
         overloaded_conf["height_margin"] = conf.get("height_margin", 20)
         overloaded_conf["percentile"] = conf.get("percentile", 1)
         overloaded_conf["min_number_matches"] = conf.get(
@@ -152,7 +154,7 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         rectification_schema = {
             "method": str,
             "resolution": And(Or(float, int), lambda x: x > 0),
-            "margin": And(Or(float, int), lambda x: x > 0),
+            "margin": [Or(float, int)],
             "height_margin": Or(list, int),
             "percentile": And(Or(int, float), lambda x: x >= 0),
             "min_number_matches": And(int, lambda x: x > 0),
@@ -171,7 +173,7 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         return overloaded_conf
 
     @cars_profile(name="DEM Generation")
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         triangulated_matches_list,
         output_dir,
@@ -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

@@ -23,6 +23,7 @@ this module contains the dichotomic dem generation application class.
 """
 # Standard library
 import logging
+import math
 import os
 import shutil
 
@@ -63,14 +64,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"]
@@ -92,9 +95,8 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         self.postprocessing_median_filter_size = self.used_config[
             "postprocessing_median_filter_size"
         ]
-        self.dem_median_output_resolution = self.used_config[
-            "dem_median_output_resolution"
-        ]
+        self.dem_median_downscale = self.used_config["dem_median_downscale"]
+        self.dem_min_max_downscale = self.used_config["dem_min_max_downscale"]
         self.fillnodata_max_search_distance = self.used_config[
             "fillnodata_max_search_distance"
         ]
@@ -103,6 +105,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         self.bulldozer_max_object_size = self.used_config[
             "bulldozer_max_object_size"
         ]
+        self.disable_bulldozer = self.used_config["disable_bulldozer"]
         self.compute_stats = self.used_config["compute_stats"]
         self.coregistration = self.used_config["coregistration"]
         self.coregistration_max_shift = self.used_config[
@@ -134,8 +137,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 * 0.5)
+        )
+        overloaded_conf["margin"] = conf.get(
+            "margin", [0.1, float(math.sqrt(self.scaling_coeff) * 500)]
+        )
         overloaded_conf["morphological_filters_size"] = conf.get(
             "morphological_filters_size", 30
         )
@@ -145,18 +152,26 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         overloaded_conf["postprocessing_median_filter_size"] = conf.get(
             "postprocessing_median_filter_size", 7
         )
-        overloaded_conf["dem_median_output_resolution"] = conf.get(
-            "dem_median_output_resolution", 30
+        overloaded_conf["dem_median_downscale"] = conf.get(
+            "dem_median_downscale", 10
+        )
+        overloaded_conf["dem_min_max_downscale"] = conf.get(
+            "dem_min_max_downscale", 2
         )
         overloaded_conf["fillnodata_max_search_distance"] = conf.get(
             "fillnodata_max_search_distance", 50
         )
         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(math.sqrt(self.scaling_coeff) * 20)
+        )
         overloaded_conf["bulldozer_max_object_size"] = conf.get(
             "bulldozer_max_object_size", 8
         )
+        overloaded_conf["disable_bulldozer"] = conf.get(
+            "disable_bulldozer", False
+        )
         overloaded_conf["compute_stats"] = conf.get("compute_stats", True)
         overloaded_conf["coregistration"] = conf.get("coregistration", True)
         overloaded_conf["coregistration_max_shift"] = conf.get(
@@ -170,16 +185,18 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             "method": str,
             "resolution": And(Or(float, int), lambda x: x > 0),
             application_constants.SAVE_INTERMEDIATE_DATA: bool,
-            "margin": And(Or(float, int), lambda x: x > 0),
+            "margin": [Or(float, int)],
             "morphological_filters_size": And(int, lambda x: x > 0),
             "preprocessing_median_filter_size": And(int, lambda x: x > 0),
             "postprocessing_median_filter_size": And(int, lambda x: x > 0),
-            "dem_median_output_resolution": And(int, lambda x: x > 0),
+            "dem_median_downscale": And(int, lambda x: x > 0),
+            "dem_min_max_downscale": And(int, lambda x: x > 0),
             "fillnodata_max_search_distance": And(int, lambda x: x > 0),
             "min_dem": And(Or(int, float), lambda x: x < 0),
             "max_dem": And(Or(int, float), lambda x: x > 0),
             "height_margin": Or(list, float, int),
             "bulldozer_max_object_size": And(int, lambda x: x > 0),
+            "disable_bulldozer": bool,
             "compute_stats": bool,
             "coregistration": bool,
             "coregistration_max_shift": And(Or(int, float), lambda x: x > 0),
@@ -193,7 +210,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         return overloaded_conf
 
     @cars_profile(name="DEM Generation")
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments # noqa: C901
         self,
         dsm_file_name,
         output_dir,
@@ -203,6 +220,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         input_geoid,
         output_geoid,
         initial_elevation=None,
+        default_alt=0,
         cars_orchestrator=None,
     ):
         """
@@ -389,14 +407,17 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             out_dem.write(dem_median, 1)
         with rio.open(dem_max_path, "w", **profile) as out_dem:
             out_dem.write(dem_max, 1)
+        dem_filled_path = os.path.join(output_dir, "dem_filled.tif")
+        with rio.open(dem_filled_path, "w", **profile) as out_dem:
+            out_dem.write(dem_data, 1)
 
         if self.save_intermediate_data:
             intermediate_dem_min_path = os.path.join(
-                output_dir, "dem_min_before_bulldozer.tif"
+                output_dir, "dem_min_before_downsampling.tif"
             )
             shutil.copy2(dem_min_path, intermediate_dem_min_path)
             intermediate_dem_max_path = os.path.join(
-                output_dir, "dem_max_before_bulldozer.tif"
+                output_dir, "dem_max_before_downsampling.tif"
             )
             shutil.copy2(dem_max_path, intermediate_dem_max_path)
 
@@ -405,44 +426,79 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             )
             shutil.copy2(dem_median_path_out, intermediate_dem_median_path)
 
-        # Downsample median dem
+        # Downsample dems
         downsample_dem(
             dem_median_path_out,
-            scale=self.dem_median_output_resolution / resolution_in_meters,
+            scale=self.dem_median_downscale,
+            interpolator="median",
             median_filter_size=self.postprocessing_median_filter_size,
+            default_alt=default_alt,
         )
 
-        # Launch Bulldozer on dem min
-        saved_transform = edit_transform(
-            dem_min_path, resolution=resolution_in_meters
-        )
-        logging.info("Launch Bulldozer on DEM min")
-        temp_output_path = launch_bulldozer(
+        downsample_dem(
             dem_min_path,
-            os.path.join(output_dir, "dem_min_bulldozer"),
-            cars_orchestrator,
-            self.bulldozer_max_object_size,
+            scale=self.dem_min_max_downscale,
+            interpolator="min",
+            default_alt=default_alt,
         )
-        if temp_output_path is not None:
-            shutil.copy2(temp_output_path, dem_min_path)
-        edit_transform(dem_min_path, transform=saved_transform)
 
-        # Inverse dem max and launch bulldozer
-        saved_transform = edit_transform(
-            dem_max_path, resolution=resolution_in_meters
-        )
-        reverse_dem(dem_max_path)
-        logging.info("Launch Bulldozer on DEM max")
-        temp_output_path = launch_bulldozer(
+        downsample_dem(
             dem_max_path,
-            os.path.join(output_dir, "dem_max_bulldozer"),
-            cars_orchestrator,
-            self.bulldozer_max_object_size,
+            scale=self.dem_min_max_downscale,
+            interpolator="max",
+            default_alt=default_alt,
         )
-        if temp_output_path is not None:
-            shutil.copy2(temp_output_path, dem_max_path)
-        reverse_dem(dem_max_path)
-        edit_transform(dem_max_path, transform=saved_transform)
+
+        downsample_dem(
+            dem_filled_path,
+            scale=self.dem_min_max_downscale,
+            interpolator="nearest",
+            default_alt=default_alt,
+        )
+
+        if self.save_intermediate_data:
+            intermediate_dem_min_path = os.path.join(
+                output_dir, "dem_min_before_bulldozer.tif"
+            )
+            shutil.copy2(dem_min_path, intermediate_dem_min_path)
+            intermediate_dem_max_path = os.path.join(
+                output_dir, "dem_max_before_bulldozer.tif"
+            )
+            shutil.copy2(dem_max_path, intermediate_dem_max_path)
+
+        if not self.disable_bulldozer:
+            dem_min_max_res = resolution_in_meters * self.dem_min_max_downscale
+            # Launch Bulldozer on dem min
+            saved_transform = edit_transform(
+                dem_min_path, resolution=dem_min_max_res
+            )
+            logging.info("Launch Bulldozer on DEM min")
+            temp_output_path = launch_bulldozer(
+                dem_min_path,
+                os.path.join(output_dir, "dem_min_bulldozer"),
+                cars_orchestrator,
+                self.bulldozer_max_object_size,
+            )
+            if temp_output_path is not None:
+                shutil.copy2(temp_output_path, dem_min_path)
+            edit_transform(dem_min_path, transform=saved_transform)
+
+            # Inverse dem max and launch bulldozer
+            saved_transform = edit_transform(
+                dem_max_path, resolution=dem_min_max_res
+            )
+            reverse_dem(dem_max_path)
+            logging.info("Launch Bulldozer on DEM max")
+            temp_output_path = launch_bulldozer(
+                dem_max_path,
+                os.path.join(output_dir, "dem_max_bulldozer"),
+                cars_orchestrator,
+                self.bulldozer_max_object_size,
+            )
+            if temp_output_path is not None:
+                shutil.copy2(temp_output_path, dem_max_path)
+            reverse_dem(dem_max_path)
+            edit_transform(dem_max_path, transform=saved_transform)
 
         # Check DEM min and max
         with rio.open(dem_min_path, "r") as in_dem:
@@ -452,11 +508,14 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         with rio.open(dem_max_path, "r") as in_dem:
             dem_max = in_dem.read()
             dem_max_metadata = in_dem.meta
+        with rio.open(dem_filled_path, "r") as in_dem:
+            dem_data = in_dem.read()
         dem_data[dem_data == nodata] = np.nan
         dem_min[dem_min == nodata] = np.nan
         dem_max[dem_max == nodata] = np.nan
         if self.compute_stats:
             diff = dem_data - dem_min
+            diff = diff[dem_data != 0]
             logging.info(
                 "Statistics of difference between subsampled "
                 "DSM and DEM min (in meters)"
@@ -464,6 +523,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             compute_stats(diff)
 
             diff = dem_max - dem_data
+            diff = diff[dem_data != 0]
             logging.info(
                 "Statistics of difference between DEM max "
                 "and subsampled DSM (in meters)"
@@ -471,6 +531,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             compute_stats(diff)
 
             diff = dem_max - dem_min
+            diff = diff[dem_data != 0]
             logging.info(
                 "Statistics of difference between DEM max "
                 "and DEM min (in meters)"
@@ -490,6 +551,14 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             dem_max,
         )
 
+        # Rectify pixels where DEM min > DEM max - margin, to ensure that
+        # DEM min < DEM max even on filled pixels
+        dem_min = np.where(
+            dem_min > dem_max - self.min_height_margin,
+            dem_max - self.min_height_margin,
+            dem_min,
+        )
+
         with rio.open(dem_min_path, "w", **dem_min_metadata) as out_dem:
             out_dem.write(dem_min)
         with rio.open(dem_max_path, "w", **dem_max_metadata) as out_dem:

cars/applications/dense_match_filling/__init__.py

@@ -27,4 +27,4 @@ from cars.applications.dense_match_filling.abstract_dense_match_filling_app impo
     DenseMatchFilling,
 )
 
-from . import plane_app, zero_padding_app
+from . import zero_padding_app

cars/applications/dense_match_filling/abstract_dense_match_filling_app.py

@@ -123,23 +123,10 @@ class DenseMatchFilling(ApplicationTemplate, metaclass=ABCMeta):
         **kwargs,
     ):
         """
-        Run Refill application using plane method.
+        Run filling application.
 
         :param epipolar_disparity_map:  left disparity
         :type epipolar_disparity_map: CarsDataset
-        :param holes_bbox_left:  left holes
-        :type holes_bbox_left: CarsDataset
-        :param holes_bbox_right:  right holes
-        :type holes_bbox_right: CarsDataset
-        :param disp_min: minimum disparity
-        :type disp_min: int
-        :param disp_max: maximum disparity
-        :type disp_max: int
-        :param orchestrator: orchestrator used
-        :param pair_folder: folder used for current pair
-        :type pair_folder: str
-        :param pair_key: pair id
-        :type pair_key: str
 
         :return: filled disparity map: \
             The CarsDataset contains:
@@ -156,7 +143,7 @@ class DenseMatchFilling(ApplicationTemplate, metaclass=ABCMeta):
 
         """
 
-    def __register_dataset__(
+    def __register_dataset__(  # pylint: disable=too-many-positional-arguments
         self,
         epipolar_disparity_map,
         save_intermediate_data,