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

cars/applications/dense_match_filling/fill_disp_wrappers.py

@@ -24,134 +24,13 @@ thus it fills the disparity map with values estimated according to
 their neighbourhood.
 """
 
-import copy
-
-# Standard imports
-import logging
-import math
-from typing import Tuple
-
 # Third party imports
-import matplotlib.pyplot as plt
 import numpy as np
 import xarray as xr
-from rasterio.fill import fillnodata
-from scipy.ndimage import (
-    generate_binary_structure,
-    label,
-    measurements,
-    median_filter,
-)
-from scipy.spatial.distance import cdist
-from shapely import affinity
-from skimage.segmentation import find_boundaries
 
 # Cars import
 from cars.core import constants as cst
 
-from .cpp import dense_match_filling_cpp
-
-
-def add_surrounding_nodata_to_roi(
-    roi_mask,
-    disp,
-    disp_mask,
-):
-    """
-    Add surounding nodata to invalidity region
-
-    :param roi_mask: invalidity mask (values to fill)
-    :type roi_mask: 2D np.array (row, col)
-    :param disp: disparity values
-    :type disp: 2D np.array (row, col)
-    :param disp_mask: disparity values mask
-    :type disp_mask: 2D np.array (row, col)
-    """
-
-    struct = generate_binary_structure(2, 2)
-    modified_nan_disp_mask = np.nan_to_num(disp_mask, nan=0, posinf=0)
-
-    all_mask = np.logical_or(
-        roi_mask.astype(bool), ~modified_nan_disp_mask.astype(bool)
-    )
-
-    # Added because zero values not included in disp_mask are present
-    all_mask = np.logical_or(all_mask, disp == np.nan)
-    labeled_msk_array, __ = label(all_mask.astype(int), structure=struct)
-    label_of_interest = np.unique(labeled_msk_array[np.where(roi_mask == 1)])
-    if len(label_of_interest) != 1:
-        logging.error(
-            "More than one label found for ROI :\
-            {}".format(
-                label_of_interest
-            )
-        )
-
-        for label_o_i in label_of_interest:
-            roi_mask[labeled_msk_array == label_o_i] = 1
-
-    else:
-        roi_mask[labeled_msk_array == label_of_interest] = 1
-
-
-def define_interpolation_band_width(binary_image, percentage):
-    """
-    Define number of pixel for later erosion operation
-
-    :param binary_image: invalidity mask (values to fill)
-    :type binary_image: 2D np.array (row, col)
-    :param percentage: percentage of border compared to center region
-    :type percentage: dict
-
-    :return: pixel number to erode
-    :rtype: int
-    """
-
-    # Recherche des pixels de contour de la région masquée
-    contours = find_boundaries(binary_image, mode="inner")
-    # Localisation du centre de la zone masquée
-    # TODO: cas d'une zone bien concave --> résultat ok?
-    centroid = measurements.center_of_mass(binary_image)
-    # Recherche de la dist moy entre contours et centre de la zone
-    coords_contours = list(zip(*np.where(contours)))  # noqa: B905
-    centroid_list = (centroid,) * len(coords_contours)
-    all_dist = cdist(centroid_list, coords_contours, "euclidean")
-    mean_dist = np.mean(all_dist)
-    erosion_value = np.round((percentage * mean_dist))
-    return int(erosion_value)
-
-
-def plot_function(
-    data,
-    fit,
-):
-    """
-    Displays shape of plane/quadratic function used in region to fill.
-
-    :param data: coords and value of valid disparity values
-    :type data: 3D np.array (row, col)
-    :param fit: Least-squares solution.
-    :type fit: ndarray
-
-    :return: plot of function used in region to fill
-    :rtype: matplotlib plot
-    """
-
-    plt.figure()
-    plt_ax = plt.subplot(111, projection="3d")
-    plt_ax.scatter(data[:, 0], data[:, 1], data[:, 2], color="b", alpha=0.5)
-    plt_ax.set_xlabel("x")
-    plt_ax.set_ylabel("y")
-    plt_ax.set_zlabel("z")
-    xlim = plt_ax.get_xlim()
-    ylim = plt_ax.get_ylim()
-    v_x, v_y = np.meshgrid(
-        np.arange(xlim[0], xlim[1]), np.arange(ylim[0], ylim[1])
-    )
-    val_ref = fit[0] * v_x + fit[1] * v_y + fit[2]
-    plt_ax.plot_wireframe(v_x, v_y, val_ref, color="r", alpha=0.5)
-    plt.show()
-
 
 def add_empty_filling_band(
     output_dataset: xr.Dataset,
@@ -202,225 +81,3 @@ def update_filling(
     # Add True values from inputmask to output accurate band
     filling = filling.astype(bool)
     output_dataset[cst.EPI_FILLING].sel(**filling_type).values[filling] = True
-
-
-# --------------------------------------------------------------------
-#     Global functions for interpolation process
-# --------------------------------------------------------------------
-def make_raster_interpolation(
-    raster: np.ndarray, mask: np.ndarray, options: dict
-):
-    """
-    Raster interpolation (scipy, rasterio or pandora)
-    :param raster: disparity values
-    :type raster: 2D np.array (row, col)
-    :param mask: invalidity mask (values to fill)
-    :type mask: 2D np.array (row, col)
-    :param options: parameters for interpolation methods
-    :type options: dict
-    :return: interpolated raster
-    :rtype: 2D np.array
-    """
-
-    if options["type"] == "fillnodata":
-        interpol_raster_tmp = np.copy(raster)
-        interpol_raster_tmp = fillnodata(
-            interpol_raster_tmp,
-            mask=~mask,
-            max_search_distance=options["max_search_distance"],
-            smoothing_iterations=options["smoothing_iterations"],
-        )
-        interpol_raster = median_filter(interpol_raster_tmp, size=(3, 3))
-    elif options["type"] == "pandora" and options["method"] == "mc_cnn":
-        interpol_raster, __ = fill_disp_pandora(raster, mask, 16)
-    elif options["type"] == "pandora" and options["method"] == "sgm":
-        interpol_raster, __ = fill_disp_pandora(raster, mask, 8)
-    else:
-        raise RuntimeError("Invalid interpolation type.")
-    return interpol_raster
-
-
-def fill_disp_pandora(
-    disp: np.ndarray, msk_fill_disp: np.ndarray, nb_directions: int
-) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    Interpolation of the left disparity map to fill holes.
-    Interpolate invalid pixel by finding the nearest correct pixels in
-    8/16 different directions and use the median of their disparities.
-    ?bontar, J., & LeCun, Y. (2016). Stereo matching by training
-    a convolutional neural network to compare image
-    patches. The journal of machine learning research, 17(1), 2287-2318.
-    HIRSCHMULLER, Heiko. Stereo processing by semiglobal matching
-    and mutual information.
-    IEEE Transactions on pattern analysis and machine intelligence,
-    2007, vol. 30, no 2, p. 328-341.
-
-    Copied/adapted fct from pandora/validation/interpolated_disparity.py
-
-    :param disp: disparity map
-    :type disp: 2D np.array (row, col)
-    :param msk_fill_disp: validity mask
-    :type msk_fill_disp: 2D np.array (row, col)
-    :param nb_directions: nb directions to explore
-    :type nb_directions: integer
-
-    :return: the interpolate left disparity map,
-        with the validity mask update :
-    :rtype: tuple(2D np.array (row, col), 2D np.array (row, col))
-    """
-    return dense_match_filling_cpp.fill_disp_pandora(
-        disp, msk_fill_disp, nb_directions
-    )
-
-
-def estimate_poly_with_disp(poly, dmin=0, dmax=0):
-    """
-    Estimate new polygone using disparity range
-
-    :param poly: polygone to estimate
-    :type poly: Polygon
-    :param dmin: minimum disparity
-    :type dmin: int
-    :param dmax: maximum disparity
-    :type dmax: int
-
-    :return: polygon in disparity range
-    :rtype: Polygon
-
-    """
-
-    dmin = int(math.floor(dmin))
-    dmax = int(math.ceil(dmax))
-
-    new_poly = copy.copy(poly)
-    for disp in range(dmin, dmax + 1):
-        translated_poly = affinity.translate(poly, xoff=0.0, yoff=disp)
-        new_poly = new_poly.union(translated_poly)
-
-    return poly
-
-
-def get_corresponding_holes(tile_poly, holes_poly_list):
-    """
-    Get list of holes situated in tile
-
-    :param tile_poly: envelop of tile
-    :type tile_poly: Polygon
-    :param holes_poly_list: envelop of holes
-    :type holes_poly_list: list(Polygon)
-
-
-    :return: list of holes envelops
-    :rtype: list(Polygon)
-
-    """
-
-    corresponding_holes = []
-    for poly in holes_poly_list:
-        if tile_poly.intersects(poly):
-            corresponding_holes.append(poly)
-
-    return corresponding_holes
-
-
-def get_corresponding_tiles(tiles_polygones, corresponding_holes, epi_disp_map):
-    """
-    Get list of tiles intersecting with holes
-
-    :param tiles_polygones: envelop of tiles
-    :type tiles_polygones: list(Polygon)
-    :param corresponding_holes: envelop of holes
-    :type corresponding_holes: list(Polygon)
-    :param epi_disp_map: disparity map cars dataset
-    :type epi_disp_map: CarsDataset
-
-
-    :return: list of tiles to use (window, overlap, xr.Dataset)
-    :rtype: list(tuple)
-
-    """
-    corresponding_tiles_row_col = []
-    corresponding_tiles = []
-
-    for key_tile, poly_tile in tiles_polygones.items():
-        for poly_hole in corresponding_holes:
-            if poly_tile.intersects(poly_hole):
-                if key_tile not in corresponding_tiles_row_col:
-                    corresponding_tiles_row_col.append(key_tile)
-
-    for row, col in corresponding_tiles_row_col:
-        corresponding_tiles.append(
-            (
-                epi_disp_map.tiling_grid[row, col],
-                epi_disp_map.overlaps[row, col],
-                epi_disp_map[row, col],
-            )
-        )
-
-    return corresponding_tiles
-
-
-def get_polygons_from_cars_ds(cars_ds):
-    """
-    Get the holes envelops computed in holes detection application
-    cars_ds must contain dicts, and not delayed.
-    This function must be called after an orchestrator.breakpoint()
-
-    :param cars_ds: holes cars dataset
-    :type cars_ds: CarsDataset
-
-
-    :return: list of holes
-    :rtype: list(Polygon)
-    """
-
-    list_poly = []
-
-    if cars_ds is not None:
-        for row in range(cars_ds.shape[0]):
-            for col in range(cars_ds.shape[1]):
-                if cars_ds[row, col] is not None:
-                    list_poly += cars_ds[row, col].data["list_bbox"]
-
-    return list_poly
-
-
-def merge_intersecting_polygones(list_poly):
-    """
-    Merge polygons that intersects each other
-
-    :param list_poly: list of holes
-    :type list_poly: list(Polygon)
-
-
-    :return: list of holes
-    :rtype: list(Polygon)
-    """
-
-    new_list_poly = list_poly
-
-    merged_list = []
-
-    while len(new_list_poly) > 0:
-        current_poly = new_list_poly[0]
-
-        new_poly = current_poly
-        to_delete = [0]
-
-        for element_id in range(1, len(new_list_poly)):
-            if new_poly.intersects(new_list_poly[element_id]):
-                # Delete from list
-                to_delete.append(element_id)
-                # Merge with current
-                new_poly = new_poly.union(new_list_poly[element_id])
-
-        # Add new poly to merged list
-        merged_list.append(new_poly)
-
-        # Delete element
-        for _ in range(len(to_delete)):
-            # Start with last ones
-            pos = to_delete.pop()
-            new_list_poly.pop(pos)
-
-    return merged_list

cars/applications/dense_match_filling/zero_padding_app.py

@@ -94,6 +94,10 @@ class ZerosPadding(
         overloaded_conf["method"] = conf.get("method", "zero_padding")
 
         overloaded_conf["classification"] = conf.get("classification", None)
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
         overloaded_conf["fill_valid_pixels"] = conf.get(
             "fill_valid_pixels", True
         )
@@ -234,7 +238,7 @@ class ZerosPadding(
                                 epipolar_disparity_map[row, col],
                                 window,
                                 overlap,
-                                classif_index=self.classification,
+                                classif=self.classification,
                                 fill_valid_pixels=self.fill_valid_pixels,
                                 saving_info=full_saving_info,
                             )
@@ -249,11 +253,12 @@ class ZerosPadding(
         return res
 
 
+# pylint: disable=too-many-positional-arguments
 def fill_disparity_zeros_wrapper(
     disp,
     window,
     overlap,
-    classif_index,
+    classif,
     fill_valid_pixels,
     saving_info=None,
 ):
@@ -266,8 +271,8 @@ def fill_disparity_zeros_wrapper(
     :type window: list
     :param overlap: overlap [row min, row max, col min col max]
     :type overlap: list
-    :param class_index: class index according to the classification tag
-    :type class_index: list
+    :param classif: classification tags
+    :type classif: list
     :param fill_valid_pixels: option to fill valid pixels
     :type fill_valid_pixels: bool
     :param saving_info: saving infos
@@ -278,7 +283,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, fill_valid_pixels)
+    fd_algo.fill_disp_using_zero_padding(disp, classif, fill_valid_pixels)
     result = copy.copy(disp)
 
     # Fill with attributes

cars/applications/dense_matching/abstract_dense_matching_app.py

@@ -126,6 +126,7 @@ class DenseMatching(ApplicationTemplate, metaclass=ABCMeta):
 
         """
 
+    # pylint: disable=too-many-positional-arguments
     @abstractmethod
     def generate_disparity_grids(
         self,
@@ -184,7 +185,7 @@ class DenseMatching(ApplicationTemplate, metaclass=ABCMeta):
         """
 
     @abstractmethod
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         epipolar_images_left,
         epipolar_images_right,

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,8 +78,10 @@ class CensusMccnnSgm(
         "census_sgm_mountain_and_vegetation",
         "census_sgm_homogeneous",
         "mccnn_sgm",
+        "auto",
+        "custom",
     ],
-):  # pylint: disable=R0903,disable=R0902
+):  # pylint: disable=R0903,disable=R0902,disable=C0302
     """
     Census SGM & MCCNN SGM matching class
     """
@@ -168,7 +170,6 @@ class CensusMccnnSgm(
         :rtype: dict
 
         """
-
         # init conf
         if conf is not None:
             overloaded_conf = conf.copy()
@@ -177,9 +178,21 @@ class CensusMccnnSgm(
             overloaded_conf = {}
 
         # Overload conf
+        # check loader
+        loader_conf = conf.get("loader_conf", None)
+        default_method = "auto"
+        if loader_conf is not None:
+            default_method = "custom"
+        loader = conf.get("loader", "pandora")
         overloaded_conf["method"] = conf.get(
-            "method", "census_sgm_default"
+            "method", default_method
         )  # change it if census_sgm is not default
+        if overloaded_conf["method"] == "auto" and loader_conf is not None:
+            raise RuntimeError(
+                "It's not possible to use auto method with custom "
+                "loader configuration"
+            )
+
         # method called in abstract_dense_matching_app.py
         overloaded_conf["min_epi_tile_size"] = conf.get(
             "min_epi_tile_size", 300
@@ -278,10 +291,6 @@ class CensusMccnnSgm(
 
         overloaded_conf["performance_map_method"] = perf_map_method
 
-        # check loader
-        loader_conf = conf.get("loader_conf", None)
-        loader = conf.get("loader", "pandora")
-
         if overloaded_conf["use_cross_validation"] is True:
             overloaded_conf["use_cross_validation"] = "fast"
 
@@ -311,13 +320,20 @@ class CensusMccnnSgm(
         # Get params from loader
         self.loader = pandora_loader
         self.corr_config = collections.OrderedDict(pandora_loader.get_conf())
-
         # Instantiate margins from pandora check conf
         # create the dataset
+        classif_bands = pandora_loader.get_classif_bands()
         fake_dataset = xr.Dataset(
-            data_vars={},
+            data_vars={
+                "image": (["row", "col"], np.zeros((10, 10))),
+                "classif": (
+                    ["row", "col", "band_classif"],
+                    np.zeros((10, 10, len(classif_bands)), dtype=np.int32),
+                ),
+            },
             coords={
                 "band_im": [overloaded_conf["used_band"]],
+                "band_classif": classif_bands,
                 "row": np.arange(10),
                 "col": np.arange(10),
             },
@@ -327,7 +343,6 @@ class CensusMccnnSgm(
         pandora.import_plugin()
         pandora_machine = PandoraMachine()
         corr_config_pipeline = {"pipeline": dict(self.corr_config["pipeline"])}
-
         saved_schema = copy.deepcopy(
             pandora.matching_cost.matching_cost.AbstractMatchingCost.schema
         )
@@ -340,7 +355,11 @@ class CensusMccnnSgm(
         )
         self.margins = pandora_machine.margins.global_margins
 
-        overloaded_conf["loader_conf"] = self.corr_config
+        if overloaded_conf["method"] != "auto":
+            # not final configuration
+            overloaded_conf["loader_conf"] = self.corr_config
+        else:
+            overloaded_conf["loader_conf"] = None
 
         application_schema = {
             "method": str,
@@ -417,7 +436,6 @@ class CensusMccnnSgm(
                 "Maximal disparity should be bigger than "
                 "minimal disparity for dense matching"
             )
-
         return overloaded_conf
 
     def check_conf_confidence_filtering(self, overloaded_conf):
@@ -471,6 +489,7 @@ class CensusMccnnSgm(
             overloaded_conf["confidence_filtering"]
         )
 
+    @cars_profile(name="Get margin fun")
     def get_margins_fun(self, grid_left, disp_range_grid):
         """
         Get Margins function that generates margins needed by
@@ -597,6 +616,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):
         """
@@ -706,6 +732,7 @@ class CensusMccnnSgm(
         required_bands["right"] = self.required_bands
         return required_bands
 
+    # pylint: disable=too-many-positional-arguments
     @cars_profile(name="Disp Grid Generation")
     def generate_disparity_grids(  # noqa: C901
         self,
@@ -714,8 +741,6 @@ class CensusMccnnSgm(
         geom_plugin_with_dem_and_geoid,
         dmin=None,
         dmax=None,
-        altitude_delta_min=None,
-        altitude_delta_max=None,
         dem_median=None,
         dem_min=None,
         dem_max=None,
@@ -740,10 +765,6 @@ class CensusMccnnSgm(
         :type dmin: float
         :param dmax: maximum disparity
         :type dmax: float
-        :param altitude_delta_max: Delta max of altitude
-        :type altitude_delta_max: int
-        :param altitude_delta_min: Delta min of altitude
-        :type altitude_delta_min: int
         :param dem_median: path to median dem
         :type dem_median: str
         :param dem_min: path to minimum dem
@@ -792,26 +813,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
@@ -832,19 +834,13 @@ class CensusMccnnSgm(
 
         if None not in (dmin, dmax):
             # use global disparity range
-            if None not in (dem_min, dem_max) or None not in (
-                altitude_delta_min,
-                altitude_delta_max,
-            ):
+            if None not in (dem_min, dem_max):
                 raise RuntimeError("Mix between local and global mode")
 
             # Only one tile
             grid_disp_range.tiling_grid = np.array([[[0, nb_rows, 0, nb_cols]]])
 
-        elif None not in (dem_min, dem_max, dem_median) or None not in (
-            altitude_delta_min,
-            altitude_delta_max,
-        ):
+        elif None not in (dem_min, dem_max, dem_median):
 
             # Generate multiple tiles
             grid_tile_size = self.epi_disp_grid_tile_size
@@ -902,10 +898,7 @@ class CensusMccnnSgm(
 
         if None not in (dmin, dmax):
             # use global disparity range
-            if None not in (dem_min, dem_max) or None not in (
-                altitude_delta_min,
-                altitude_delta_max,
-            ):
+            if None not in (dem_min, dem_max):
                 raise RuntimeError("Mix between local and global mode")
 
             saving_info_global_infos_full = ocht.update_saving_infos(
@@ -930,10 +923,7 @@ class CensusMccnnSgm(
                 saving_info_global_infos_full,
             )
 
-        elif None not in (dem_min, dem_max, dem_median) or None not in (
-            altitude_delta_min,
-            altitude_delta_max,
-        ):
+        elif None not in (dem_min, dem_max, dem_median):
 
             # use filter to propagate min and max
             filter_overlap = (
@@ -970,8 +960,6 @@ class CensusMccnnSgm(
                         dem_median,
                         dem_min,
                         dem_max,
-                        altitude_delta_min,
-                        altitude_delta_max,
                         raster_profile,
                         full_saving_info,
                         saving_info_global_infos_full,
@@ -1002,7 +990,7 @@ class CensusMccnnSgm(
 
         return grid_disp_range_dict
 
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         epipolar_images_left,
         epipolar_images_right,
@@ -1075,7 +1063,6 @@ class CensusMccnnSgm(
 
         :rtype: CarsDataset
         """
-
         # Default orchestrator
         if orchestrator is None:
             # Create default sequential orchestrator for current application
@@ -1221,6 +1208,7 @@ class CensusMccnnSgm(
             for col in range(epipolar_disparity_map.shape[1]):
                 for row in range(epipolar_disparity_map.shape[0]):
                     use_tile = False
+                    crop_with_range = None
                     if type(None) not in (
                         type(epipolar_images_left[row, col]),
                         type(epipolar_images_right[row, col]),
@@ -1287,7 +1275,7 @@ class CensusMccnnSgm(
         return epipolar_disparity_map
 
 
-def compute_disparity_wrapper(
+def compute_disparity_wrapper(  # pylint: disable=too-many-positional-arguments
     left_image_object: xr.Dataset,
     right_image_object: xr.Dataset,
     corr_cfg: dict,