cars 1.0.0rc2__cp312-cp312-win_amd64.whl

cars/applications/dense_match_filling/abstract_dense_match_filling_app.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""
+this module contains the abstract dense matches filling application class.
+"""
+import logging
+import os
+from abc import ABCMeta, abstractmethod
+from typing import Dict
+
+import numpy as np
+
+from cars.applications.application import Application
+from cars.applications.application_template import ApplicationTemplate
+from cars.core import constants as cst
+from cars.core import constants_disparity as cst_disp
+from cars.core.utils import safe_makedirs
+from cars.data_structures import cars_dataset
+
+
+@Application.register("dense_match_filling")
+class DenseMatchFilling(ApplicationTemplate, metaclass=ABCMeta):
+    """
+    DenseMatchFilling
+    """
+
+    available_applications: Dict = {}
+    default_application = "zero_padding"
+
+    def __new__(cls, conf=None):  # pylint: disable=W0613
+        """
+        Return the required application
+        :raises:
+         - KeyError when the required application is not registered
+
+        :param conf: configuration for matching
+        :return: a application_to_use object
+        """
+
+        fill_method = cls.default_application
+        if bool(conf) is False or "method" not in conf:
+            logging.info(
+                "dense_match_filling method not specified, "
+                "default {} is used".format(fill_method)
+            )
+        else:
+            fill_method = conf.get("method", cls.default_application)
+
+        if fill_method not in cls.available_applications:
+            logging.error(
+                "No DenseMatchFilling application "
+                "named {} registered".format(fill_method)
+            )
+            raise KeyError(
+                "No DenseMatchFilling application"
+                " named {} registered".format(fill_method)
+            )
+
+        logging.info(
+            "The DenseMatchFilling({}) application "
+            "will be used".format(fill_method)
+        )
+
+        return super(DenseMatchFilling, cls).__new__(
+            cls.available_applications[fill_method]
+        )
+
+    def __init_subclass__(cls, short_name, **kwargs):  # pylint: disable=E0302
+        super().__init_subclass__(**kwargs)
+        # init orchestrator
+        cls.orchestrator = None
+
+        # init classification
+        cls.classification = None
+
+        for name in short_name:
+            cls.available_applications[name] = cls
+
+    @abstractmethod
+    def get_poly_margin(self):
+        """
+        Get the margin used for polygon
+
+        :return: self.nb_pix
+        :rtype: int
+        """
+
+    def get_classif(self):
+        """
+        Get classification band list
+        :return: self.classification
+        :rtype: list[str]
+        """
+
+        classif = []
+        if self.classification is not None:
+            classif = self.classification
+
+        return classif
+
+    @abstractmethod
+    def run(
+        self,
+        epipolar_disparity_map,
+        **kwargs,
+    ):
+        """
+        Run filling application.
+
+        :param epipolar_disparity_map:  left disparity
+        :type epipolar_disparity_map: CarsDataset
+
+        :return: filled disparity map: \
+            The CarsDataset contains:
+
+            - N x M Delayed tiles.\
+              Each tile will be a future xarray Dataset containing:
+                - data with keys : "disp", "disp_msk"
+                - attrs with keys: profile, window, overlaps
+            - attributes containing:
+                "largest_epipolar_region","opt_epipolar_tile_size",
+                    "epipolar_regions_grid"
+
+        :rtype: CarsDataset
+
+        """
+
+    def __register_dataset__(  # pylint: disable=too-many-positional-arguments
+        self,
+        epipolar_disparity_map,
+        save_intermediate_data,
+        pair_folder,
+        pair_key,
+        app_name=None,
+        nodata_epi_disp=0,
+    ):
+        """
+        Create dataset and registered the output in the orchestrator
+
+        :param epipolar_disparity_map:  left disparity
+        :type epipolar_disparity_map: CarsDataset
+        :param save_intermediate_data: true to save disparity map
+        :type save_intermediate_data: bool
+        :param pair_folder: path to folder
+        :type pair_folder: str
+        :param pair_key: pair id
+        :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:
+            app_name = ""
+
+        # Create CarsDataset Epipolar_disparity
+        new_epipolar_disparity_map = cars_dataset.CarsDataset(
+            "arrays",
+            name="dense_match_filling_" + app_name + "_" + pair_key,
+        )
+        new_epipolar_disparity_map.create_empty_copy(epipolar_disparity_map)
+
+        # Update attributes to get epipolar info
+        new_epipolar_disparity_map.attributes.update(
+            epipolar_disparity_map.attributes
+        )
+
+        # Save intermediate data (disparity maps)
+        if save_intermediate_data:
+            safe_makedirs(pair_folder)
+            self.orchestrator.add_to_save_lists(
+                os.path.join(
+                    pair_folder, "epi_disp_" + app_name + "_filled.tif"
+                ),
+                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(
+                os.path.join(
+                    pair_folder,
+                    "epi_disp_color_" + app_name + "_filled.tif",
+                ),
+                cst.EPI_TEXTURE,
+                new_epipolar_disparity_map,
+                cars_ds_name="epi_disp_color_" + app_name + "_filled",
+            )
+
+            self.orchestrator.add_to_save_lists(
+                os.path.join(
+                    pair_folder,
+                    "epi_disp_mask_" + app_name + "_filled.tif",
+                ),
+                cst_disp.VALID,
+                new_epipolar_disparity_map,
+                dtype=np.uint8,
+                cars_ds_name="epi_disp_mask_" + app_name + "_filled",
+            )
+
+            self.orchestrator.add_to_save_lists(
+                os.path.join(
+                    pair_folder,
+                    "epi_confidence_" + app_name + "_filled.tif",
+                ),
+                cst_disp.CONFIDENCE,
+                new_epipolar_disparity_map,
+                cars_ds_name="epi_ambiguity_" + app_name + "_filled",
+            )
+
+            self.orchestrator.add_to_save_lists(
+                os.path.join(
+                    pair_folder,
+                    "epi_disp_filling_" + app_name + ".tif",
+                ),
+                cst_disp.FILLING,
+                new_epipolar_disparity_map,
+                dtype=np.uint8,
+                cars_ds_name="epi_disp_filling_" + app_name,
+            )
+
+        return new_epipolar_disparity_map

cars/applications/dense_match_filling/fill_disp_algo.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# pylint: disable=too-many-lines
+"""
+This module is responsible for the filling disparity algorithms:
+thus it fills the disparity map with values estimated according to
+their neighbourhood.
+"""
+
+# Standard imports
+
+
+import numpy as np
+
+# Third party imports
+import xarray as xr
+
+from cars.applications.dense_match_filling import (
+    fill_disp_wrappers as fill_wrap,
+)
+
+# Cars import
+from cars.core import constants as cst
+
+
+def classif_to_stacked_array(disp_map, class_index):
+    """
+    Convert disparity dataset to mask correspoding to all classes
+
+    :param disp_map: disparity dataset
+    :type disp_map: xarray Dataset
+    :param class_index: classification tags
+    :type class_index: list of str
+
+    """
+
+    index_class = np.where(
+        np.isin(
+            np.array(disp_map.coords[cst.BAND_CLASSIF].values),
+            np.array(class_index),
+        )
+    )[0].tolist()
+    # get index for each band classification of the non zero values
+    stack_index = np.any(
+        disp_map[cst.EPI_CLASSIFICATION].values[index_class, :, :] > 0,
+        axis=0,
+    )
+
+    return stack_index
+
+
+def fill_disp_using_zero_padding(
+    disp_map: xr.Dataset,
+    classif_tag,
+    fill_valid_pixels,
+) -> xr.Dataset:
+    """
+    Fill disparity map holes
+
+    :param disp_map: disparity map
+    :type disp_map: xr.Dataset
+    :param classif_tag: classification tags
+    :type classif_tag: list
+    :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
+    if cst.BAND_CLASSIF in disp_map.coords or "nodata" in classif_tag:
+        # get index for each band classification
+        if classif_tag != ["nodata"]:
+            stack_index = classif_to_stacked_array(disp_map, classif_tag)
+        else:
+            stack_index = np.zeros(disp_map[cst.EPI_MSK].values.shape)
+        if "nodata" in classif_tag:
+            nodata_mask = np.logical_or(
+                disp_map[cst.EPI_MSK].values != 0,
+                np.isnan(disp_map["disp"].values),
+            )
+            stack_index = np.logical_or(stack_index, nodata_mask)
+
+        # Exclude pixels invalid in epipolar mask
+        mask = disp_map[cst.EPI_MSK].values == 0
+
+        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] = 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
+        fill_wrap.update_filling(disp_map, stack_index, "zeros_padding")

cars/applications/dense_match_filling/fill_disp_constants.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""
+this module contains the constants of fill_disp.
+"""
+
+
+# USED VARIABLES
+
+FILL_DISP_WITH_PLAN_RUN_TAG = "fill_disparity_with_plan"
+FILL_DISP_WITH_ZEROS_RUN_TAG = "fill_disparity_with_zeros"
+
+# PARAMS
+METHOD = "method"  # default : 'plane'
+INTERP_TYPE = "interpolation_type"
+INTERP_METHOD = "interpolation_method"
+MAX_DIST = "max_search_distance"
+SMOOTH_IT = "smoothing_iterations"
+IGNORE_NODATA = "ignore_nodata_at_disp_mask_borders"
+IGNORE_ZERO = "ignore_zero_fill_disp_mask_values"
+IGNORE_EXTREMA = "ignore_extrema_disp_values"

cars/applications/dense_match_filling/fill_disp_wrappers.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# pylint: disable=too-many-lines
+"""
+This module is responsible for the filling disparity algorithms:
+thus it fills the disparity map with values estimated according to
+their neighbourhood.
+"""
+
+# Third party imports
+import numpy as np
+import xarray as xr
+
+# Cars import
+from cars.core import constants as cst
+
+
+def add_empty_filling_band(
+    output_dataset: xr.Dataset,
+    filling_types: list,
+):
+    """
+    Add filling attribute to dataset or band to filling attribute
+    if it already exists
+
+    :param output_dataset: output dataset
+    :param filling: input mask of filled pixels
+    :param band_filling: type of filling (zero padding or plane)
+
+    """
+    nb_band = len(filling_types)
+    nb_row = len(output_dataset.coords[cst.ROW])
+    nb_col = len(output_dataset.coords[cst.COL])
+    filling = np.zeros((nb_band, nb_row, nb_col), dtype=bool)
+    filling = xr.Dataset(
+        data_vars={
+            cst.EPI_FILLING: ([cst.BAND_FILLING, cst.ROW, cst.COL], filling)
+        },
+        coords={
+            cst.BAND_FILLING: filling_types,
+            cst.ROW: output_dataset.coords[cst.ROW],
+            cst.COL: output_dataset.coords[cst.COL],
+        },
+    )
+    # Add band to EPI_FILLING attribute or create the attribute
+    return xr.merge([output_dataset, filling])
+
+
+def update_filling(
+    output_dataset: xr.Dataset,
+    filling: np.ndarray = None,
+    filling_type: str = None,
+):
+    """
+    Update filling attribute of dataset with an additional mask
+
+    :param output_dataset: output dataset
+    :param filling: input mask of filled pixels
+    :param band_filling: type of filling (zero padding or plane)
+
+    """
+    # Select accurate band of output according to the type of filling
+    filling_type = {cst.BAND_FILLING: filling_type}
+    # Add True values from inputmask to output accurate band
+    filling = filling.astype(bool)
+    output_dataset[cst.EPI_FILLING].sel(**filling_type).values[filling] = True