cars 1.0.0a3__cp39-cp39-win_amd64.whl → 1.0.0a4__cp39-cp39-win_amd64.whl

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
 
@@ -94,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"
         ]
@@ -105,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[
@@ -137,10 +138,10 @@ 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", float(self.scaling_coeff * 2)
+            "resolution", float(self.scaling_coeff * 0.5)
         )
         overloaded_conf["margin"] = conf.get(
-            "margin", float(self.scaling_coeff * 500)
+            "margin", [0.1, float(math.sqrt(self.scaling_coeff) * 500)]
         )
         overloaded_conf["morphological_filters_size"] = conf.get(
             "morphological_filters_size", 30
@@ -151,8 +152,11 @@ 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
@@ -160,11 +164,14 @@ 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", float(self.scaling_coeff * 20)
+            "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(
@@ -178,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),
@@ -201,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,
@@ -398,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)
 
@@ -414,45 +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:
@@ -462,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)"
@@ -474,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)"
@@ -481,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)"
@@ -500,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,