cars 1.0.0a1__cp311-cp311-win_amd64.whl → 1.0.0a3__cp311-cp311-win_amd64.whl

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"]
@@ -86,7 +88,12 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         self.morphological_filters_size = self.used_config[
             "morphological_filters_size"
         ]
-        self.median_filter_size = self.used_config["median_filter_size"]
+        self.preprocessing_median_filter_size = self.used_config[
+            "preprocessing_median_filter_size"
+        ]
+        self.postprocessing_median_filter_size = self.used_config[
+            "postprocessing_median_filter_size"
+        ]
         self.dem_median_output_resolution = self.used_config[
             "dem_median_output_resolution"
         ]
@@ -129,13 +136,20 @@ 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
         )
-        overloaded_conf["median_filter_size"] = conf.get(
-            "median_filter_size", 5
+        overloaded_conf["preprocessing_median_filter_size"] = conf.get(
+            "preprocessing_median_filter_size", 5
+        )
+        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
@@ -145,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
         )
@@ -164,12 +180,13 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             application_constants.SAVE_INTERMEDIATE_DATA: bool,
             "margin": And(Or(float, int), lambda x: x > 0),
             "morphological_filters_size": And(int, lambda x: x > 0),
-            "median_filter_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),
             "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": And(Or(float, int), lambda x: x > 0),
+            "height_margin": Or(list, float, int),
             "bulldozer_max_object_size": And(int, lambda x: x > 0),
             "compute_stats": bool,
             "coregistration": bool,
@@ -191,8 +208,10 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         dem_min_file_name,
         dem_max_file_name,
         dem_median_file_name,
-        geoid_path,
+        input_geoid,
+        output_geoid,
         initial_elevation=None,
+        default_alt=0,
         cars_orchestrator=None,
     ):
         """
@@ -208,7 +227,8 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         :type dem_max_file_name: str
         :param dem_median_file_name: path of dem_median
         :type dem_median_file_name: str
-        :param geoid_path: geoid path
+        :param input_geoid: input geoid path
+        :param output_geoid: output geoid path
         :param dem_roi_to_use: dem roi polygon to use as roi
 
         :return: dem data computed with mean, min and max.
@@ -220,6 +240,11 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         # 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
+
         resolution_in_meters = self.resolution
 
         # rasterize point cloud
@@ -275,24 +300,45 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         not_filled_pixels = dem_data == nodata
 
         # Add geoid
-        with rio.open(geoid_path) as in_geoid:
-            # Reproject the geoid data to match the DSM
-            input_geoid_data = np.empty(
-                dem_data.shape, dtype=in_geoid.dtypes[0]
-            )
+        if input_geoid:
+            with rio.open(input_geoid) as in_geoid:
+                # Reproject the geoid data to match the DSM
+                input_geoid_data = np.empty(
+                    dem_data.shape, dtype=in_geoid.dtypes[0]
+                )
 
-            logging.info("Reprojection of geoid data")
+                logging.info("Reprojection of geoid data")
 
-            reproject(
-                source=rio.band(in_geoid, 1),
-                destination=input_geoid_data,
-                src_transform=in_geoid.transform,
-                src_crs=in_geoid.crs,
-                dst_transform=profile["transform"],
-                dst_crs=profile["crs"],
-                resampling=Resampling.bilinear,
-            )
-        dem_data -= input_geoid_data
+                reproject(
+                    source=rio.band(in_geoid, 1),
+                    destination=input_geoid_data,
+                    src_transform=in_geoid.transform,
+                    src_crs=in_geoid.crs,
+                    dst_transform=profile["transform"],
+                    dst_crs=profile["crs"],
+                    resampling=Resampling.bilinear,
+                )
+            dem_data -= input_geoid_data
+
+        if output_geoid:
+            with rio.open(input_geoid) as in_geoid:
+                # Reproject the geoid data to match the DSM
+                input_geoid_data = np.empty(
+                    dem_data.shape, dtype=in_geoid.dtypes[0]
+                )
+
+                logging.info("Reprojection of geoid data")
+
+                reproject(
+                    source=rio.band(in_geoid, 1),
+                    destination=input_geoid_data,
+                    src_transform=in_geoid.transform,
+                    src_crs=in_geoid.crs,
+                    dst_transform=profile["transform"],
+                    dst_crs=profile["crs"],
+                    resampling=Resampling.bilinear,
+                )
+            dem_data += input_geoid_data
 
         # apply morphological filters and height margin
         footprint = skimage.morphology.disk(
@@ -314,7 +360,10 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         dem_median = skimage.filters.median(
             dem_data,
             footprint=np.ones(
-                (self.median_filter_size, self.median_filter_size)
+                (
+                    self.preprocessing_median_filter_size,
+                    self.preprocessing_median_filter_size,
+                )
             ),
         )
 
@@ -329,13 +378,13 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         dem_median[eroded_mask] = nodata
         dem_max[eroded_mask] = nodata
 
-        # Rectify pixels where DEM min < DEM - min_depth
+        # Rectify pixels where DEM min < DEM median + min_depth
         dem_min = np.where(
-            dem_median - dem_min < self.min_dem,
+            dem_min - dem_median < self.min_dem,
             dem_median + self.min_dem,
             dem_min,
         )
-        # Rectify pixels where DEM max > DEM + max_height
+        # Rectify pixels where DEM max > DEM median + max_height
         dem_max = np.where(
             dem_max - dem_median > self.max_dem,
             dem_median + self.max_dem,
@@ -369,12 +418,15 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
         downsample_dem(
             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
         saved_transform = edit_transform(
             dem_min_path, resolution=resolution_in_meters
         )
+        logging.info("Launch Bulldozer on DEM min")
         temp_output_path = launch_bulldozer(
             dem_min_path,
             os.path.join(output_dir, "dem_min_bulldozer"),
@@ -390,6 +442,7 @@ class Rasterization(DemGeneration, short_name="bulldozer_on_raster"):
             dem_max_path, resolution=resolution_in_meters
         )
         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/applications/dense_match_filling/abstract_dense_match_filling_app.py

@@ -163,6 +163,7 @@ class DenseMatchFilling(ApplicationTemplate, metaclass=ABCMeta):
         pair_folder,
         pair_key,
         app_name=None,
+        nodata_epi_disp=0,
     ):
         """
         Create dataset and registered the output in the orchestrator
@@ -177,6 +178,8 @@ class DenseMatchFilling(ApplicationTemplate, metaclass=ABCMeta):
         :type pair_key: str
         :param app_name: application name for file names
         :type app_name: str
+        :param nodata_epi_disp: the nodata for the epi disp
+        :type nodata_epi_disp: int
 
         """
         if app_name is None:
@@ -204,6 +207,7 @@ class DenseMatchFilling(ApplicationTemplate, metaclass=ABCMeta):
                 cst_disp.MAP,
                 new_epipolar_disparity_map,
                 cars_ds_name="epi_disp_" + app_name + "_filled",
+                nodata=nodata_epi_disp,
             )
 
             self.orchestrator.add_to_save_lists(

cars/applications/dense_match_filling/fill_disp_algo.py

@@ -59,6 +59,7 @@ def fill_central_area_using_plane(  # noqa: C901
     nb_pix: int,
     percent_to_erode: float,
     class_index: list,
+    fill_valid_pixels: bool,
 ):
     """
     Finds central area of invalid region and estimates disparity values
@@ -91,6 +92,8 @@ def fill_central_area_using_plane(  # noqa: C901
     :type percent_to_erode: float
     :param class_index: list of tag to use
     :type class_index: list(str)
+    :param fill_valid_pixels: option to fill valid pixels
+    :type fill_valid_pixels: bool
 
     :return: mask of invalid region that hasn't been filled yet
         (original invalid region - central area)
@@ -233,11 +236,16 @@ def fill_central_area_using_plane(  # noqa: C901
                 )
 
                 # Exclude pixels outside of epipolar footprint
-                central_area = np.logical_and(
-                    central_area,
+                mask = (
                     disp_map[cst.EPI_MSK].values
-                    != mask_cst.NO_DATA_IN_EPIPOLAR_RECTIFICATION,
+                    != mask_cst.NO_DATA_IN_EPIPOLAR_RECTIFICATION
                 )
+                if not fill_valid_pixels:
+                    # Exclude valid pixels
+                    mask = np.logical_and(
+                        mask, disp_map["disp_msk"].values == 0
+                    )
+                central_area = np.logical_and(central_area, mask)
 
                 variable_disp = calculate_disp_plane(
                     band_disp_values,
@@ -302,7 +310,12 @@ def calculate_disp_plane(
     return val
 
 
-def fill_area_borders_using_interpolation(disp_map, masks_to_fill, options):
+def fill_area_borders_using_interpolation(
+    disp_map,
+    masks_to_fill,
+    options,
+    fill_valid_pixels,
+):
     """
     Raster interpolation command
     :param disp_map: disparity values
@@ -311,6 +324,8 @@ def fill_area_borders_using_interpolation(disp_map, masks_to_fill, options):
     :type masks_to_fill: list(2D np.array (row, col))
     :param options: parameters for interpolation methods
     :type options: dict
+    :param fill_valid_pixels: option to fill valid pixels
+    :type fill_valid_pixels: bool
     """
     # Copy input data - disparity values + mask with values to fill
     raster = np.copy(disp_map["disp"].values)
@@ -318,11 +333,14 @@ def fill_area_borders_using_interpolation(disp_map, masks_to_fill, options):
     # Interpolation step
     for mask_to_fill in masks_to_fill:
         # Exclude pixels outside of epipolar footprint
-        mask_to_fill = np.logical_and(
-            mask_to_fill,
+        mask = (
             disp_map[cst.EPI_MSK].values
-            != mask_cst.NO_DATA_IN_EPIPOLAR_RECTIFICATION,
+            != mask_cst.NO_DATA_IN_EPIPOLAR_RECTIFICATION
         )
+        if not fill_valid_pixels:
+            # Exclude valid pixels
+            mask = np.logical_and(mask, disp_map["disp_msk"].values == 0)
+        mask_to_fill = np.logical_and(mask_to_fill, mask)
 
         interpol_raster = fill_wrap.make_raster_interpolation(
             raster, mask_to_fill, options
@@ -346,6 +364,7 @@ def fill_disp_using_plane(
     percent_to_erode: float,
     interp_options: dict,
     classification,
+    fill_valid_pixels,
 ) -> xr.Dataset:
     """
     Fill disparity map holes
@@ -372,6 +391,8 @@ def fill_disp_using_plane(
     :type interp_options: dict
     :param classification: list of tag to use
     :type classification: list(str)
+    :param fill_valid_pixels: option to fill valid pixels
+    :type fill_valid_pixels: bool
     """
 
     border_region = fill_central_area_using_plane(
@@ -385,18 +406,21 @@ def fill_disp_using_plane(
         nb_pix,
         percent_to_erode,
         classification,
+        fill_valid_pixels,
     )
 
     fill_area_borders_using_interpolation(
         disp_map,
         border_region,
         interp_options,
+        fill_valid_pixels,
     )
 
 
 def fill_disp_using_zero_padding(
     disp_map: xr.Dataset,
     class_index,
+    fill_valid_pixels,
 ) -> xr.Dataset:
     """
     Fill disparity map holes
@@ -405,6 +429,8 @@ def fill_disp_using_zero_padding(
     :type disp_map: xr.Dataset
     :param class_index: class index according to the classification tag
     :type class_index: int
+    :param fill_valid_pixels: option to fill valid pixels
+    :type fill_valid_pixels: bool
     """
     # get index of the application class config
     # according the coords classif band
@@ -414,14 +440,17 @@ def fill_disp_using_zero_padding(
             disp_map, class_index
         )
         # Exclude pixels outside of epipolar footprint
-        stack_index = np.logical_and(
-            stack_index,
+        mask = (
             disp_map[cst.EPI_MSK].values
-            != mask_cst.NO_DATA_IN_EPIPOLAR_RECTIFICATION,
+            != mask_cst.NO_DATA_IN_EPIPOLAR_RECTIFICATION
         )
-        # set disparity value to np.nan where the class is
+        if not fill_valid_pixels:
+            # Exclude valid pixels
+            mask = np.logical_and(mask, disp_map["disp_msk"].values == 0)
+        stack_index = np.logical_and(stack_index, mask)
+        # set disparity value to zero where the class is
         # non zero value and masked region
-        disp_map["disp"].values[stack_index] = np.nan
+        disp_map["disp"].values[stack_index] = 0
         disp_map["disp_msk"].values[stack_index] = 255
         disp_map[cst.EPI_MSK].values[stack_index] = 0
         # Add a band to disparity dataset to memorize which pixels are filled

cars/applications/dense_match_filling/plane_app.py

@@ -84,6 +84,7 @@ class PlaneFill(
         self.nb_pix = self.used_config["nb_pix"]
         self.percent_to_erode = self.used_config["percent_to_erode"]
         self.classification = self.used_config["classification"]
+        self.fill_valid_pixels = self.used_config["fill_valid_pixels"]
         # Saving files
         self.save_intermediate_data = self.used_config["save_intermediate_data"]
 
@@ -126,6 +127,9 @@ class PlaneFill(
         overloaded_conf["nb_pix"] = conf.get("nb_pix", 20)
         overloaded_conf["percent_to_erode"] = conf.get("percent_to_erode", 0.2)
         overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["fill_valid_pixels"] = conf.get(
+            "fill_valid_pixels", True
+        )
         # Saving files
         overloaded_conf["save_intermediate_data"] = conf.get(
             "save_intermediate_data", False
@@ -144,6 +148,7 @@ class PlaneFill(
             "nb_pix": Or(None, int),
             "percent_to_erode": Or(None, float),
             "classification": Or(None, [str]),
+            "fill_valid_pixels": bool,
         }
 
         # Check conf
@@ -242,6 +247,7 @@ class PlaneFill(
                     pair_folder,
                     pair_key,
                     app_name="plane",
+                    nodata_epi_disp=-9999,
                 )
 
                 # Get saving infos in order to save tiles when they are computed
@@ -380,6 +386,7 @@ class PlaneFill(
                                     nb_pix=self.nb_pix,
                                     percent_to_erode=self.percent_to_erode,
                                     interp_options=interp_options,
+                                    fill_valid_pixels=self.fill_valid_pixels,
                                     saving_info=full_saving_info,
                                 )
 
@@ -405,6 +412,7 @@ def fill_disparity_plane_wrapper(
     nb_pix=20,
     percent_to_erode=0.3,
     interp_options=None,
+    fill_valid_pixels=True,
     saving_info=None,
 ):
     """
@@ -434,6 +442,8 @@ def fill_disparity_plane_wrapper(
     :type percent_to_erode: float
     :param interp_options: interp_options
     :type interp_options: dict
+    :param fill_valid_pixels: option to fill valid pixels
+    :type fill_valid_pixels: bool
     :param saving_info: saving infos
     :type saving_info: dict
 
@@ -469,6 +479,7 @@ def fill_disparity_plane_wrapper(
         percent_to_erode,
         interp_options,
         classification,
+        fill_valid_pixels,
     )
 
     # Find xarray Dataset corresponding to current tile

cars/applications/dense_match_filling/zero_padding_app.py

@@ -67,6 +67,7 @@ class ZerosPadding(
         # get conf
         self.used_method = self.used_config["method"]
         self.classification = self.used_config["classification"]
+        self.fill_valid_pixels = self.used_config["fill_valid_pixels"]
 
         # Saving files
         self.save_intermediate_data = self.used_config["save_intermediate_data"]
@@ -93,6 +94,9 @@ class ZerosPadding(
         overloaded_conf["method"] = conf.get("method", "zero_padding")
 
         overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["fill_valid_pixels"] = conf.get(
+            "fill_valid_pixels", True
+        )
         # Saving files
         overloaded_conf["save_intermediate_data"] = conf.get(
             "save_intermediate_data", False
@@ -102,6 +106,7 @@ class ZerosPadding(
             "method": str,
             "save_intermediate_data": bool,
             "classification": Or(None, [str]),
+            "fill_valid_pixels": bool,
         }
 
         # Check conf
@@ -179,6 +184,7 @@ class ZerosPadding(
                     pair_folder,
                     pair_key,
                     app_name="zero_padding",
+                    nodata_epi_disp=-9999,
                 )
 
                 # Get saving infos in order to save tiles when they are computed
@@ -229,6 +235,7 @@ class ZerosPadding(
                                 window,
                                 overlap,
                                 classif_index=self.classification,
+                                fill_valid_pixels=self.fill_valid_pixels,
                                 saving_info=full_saving_info,
                             )
 
@@ -247,6 +254,7 @@ def fill_disparity_zeros_wrapper(
     window,
     overlap,
     classif_index,
+    fill_valid_pixels,
     saving_info=None,
 ):
     """
@@ -260,6 +268,8 @@ def fill_disparity_zeros_wrapper(
     :type overlap: list
     :param class_index: class index according to the classification tag
     :type class_index: list
+    :param fill_valid_pixels: option to fill valid pixels
+    :type fill_valid_pixels: bool
     :param saving_info: saving infos
     :type saving_info: dict
 
@@ -268,7 +278,7 @@ def fill_disparity_zeros_wrapper(
     """
     # Add a band to disparity dataset to memorize which pixels are filled
     disp = fd_wrappers.add_empty_filling_band(disp, ["zeros_padding"])
-    fd_algo.fill_disp_using_zero_padding(disp, classif_index)
+    fd_algo.fill_disp_using_zero_padding(disp, classif_index, fill_valid_pixels)
     result = copy.copy(disp)
 
     # Fill with attributes