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

cars/applications/hole_detection/__init__.py

@@ -1,30 +0,0 @@
-# !/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.
-#
-"""
-CARS holes detection module init file
-"""
-# flake8: noqa: F401
-
-from cars.applications.hole_detection.abstract_hole_detection_app import (
-    HoleDetection,
-)
-
-from . import cloud_to_bbox_app

cars/applications/hole_detection/abstract_hole_detection_app.py

@@ -1,125 +0,0 @@
-# !/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.
-#
-"""
-CARS hole detection module init file
-"""
-
-import logging
-from abc import ABCMeta, abstractmethod
-from typing import Dict
-
-from cars.applications.application import Application
-from cars.applications.application_template import ApplicationTemplate
-
-
-@Application.register("hole_detection")
-class HoleDetection(ApplicationTemplate, metaclass=ABCMeta):
-    """
-    HoleDetection
-    """
-
-    available_applications: Dict = {}
-    default_application = "cloud_to_bbox"
-
-    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 hole_detection
-        :return: a application_to_use object
-        """
-
-        hole_detection_method = cls.default_application
-        if bool(conf) is False or "method" not in conf:
-            logging.info(
-                "Holes Detection method not specified, "
-                "default {} is used".format(hole_detection_method)
-            )
-        else:
-            hole_detection_method = conf["method"]
-
-        if hole_detection_method not in cls.available_applications:
-            logging.error(
-                "No hole_detection application named {} registered".format(
-                    hole_detection_method
-                )
-            )
-            raise KeyError(
-                "No hole_detection application named {} registered".format(
-                    hole_detection_method
-                )
-            )
-
-        logging.info(
-            "The HoleDetection({}) application will be used".format(
-                hole_detection_method
-            )
-        )
-
-        return super(HoleDetection, cls).__new__(
-            cls.available_applications[hole_detection_method]
-        )
-
-    def __init_subclass__(cls, short_name, **kwargs):  # pylint: disable=E0302
-        super().__init_subclass__(**kwargs)
-        cls.available_applications[short_name] = cls
-
-    @abstractmethod
-    def run(
-        self,
-        epipolar_images_left,
-        epipolar_images_right,
-        is_activated=True,
-        margin=0,
-        mask_holes_to_fill_left=None,
-        mask_holes_to_fill_right=None,
-        orchestrator=None,
-        pair_folder=None,
-        pair_key="PAIR_0",
-    ):
-        """
-        Run Refill application using plane method.
-
-        :param epipolar_images_left:  left epipolar image
-        :type epipolar_images_left: CarsDataset
-        :param epipolar_images_right:  right epipolar image
-        :type epipolar_images_right: CarsDataset
-        :param is_activated:  activate application
-        :type is_activated: bool
-        :param margin: margin to use
-        :type margin: int
-        :param mask_holes_to_fill_left: mask classes to use
-        :type mask_holes_to_fill_left: list(int)
-        :param mask_holes_to_fill_right: mask classes to use
-        :type mask_holes_to_fill_right: list(int)
-        :param orchestrator: orchestrator used
-        :type orchestrator: Orchestrator
-        :param pair_folder: folder used for current pair
-        :type pair_folder: str
-        :param pair_key: pair id
-        :type pair_key: str
-
-        :return: left holes, right holes
-        :rtype: Tuple(CarsDataset, CarsDataset)
-
-        """

cars/applications/hole_detection/cloud_to_bbox_app.py

@@ -1,346 +0,0 @@
-# !/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.
-#
-"""
-CARS holes detection module init file
-"""
-
-import logging
-
-# Standard imports
-import os
-
-# Third party imports
-from json_checker import Checker, OptionalKey
-
-import cars.orchestrator.orchestrator as ocht
-from cars.applications import application_constants
-from cars.applications.hole_detection import hole_detection_algo
-from cars.applications.hole_detection.abstract_hole_detection_app import (
-    HoleDetection,
-)
-
-# CARS imports
-from cars.core.utils import safe_makedirs
-from cars.data_structures import cars_dataset, cars_dict
-
-
-class CloudToBbox(
-    HoleDetection, short_name="cloud_to_bbox"
-):  # pylint: disable=R0903
-    """
-    CloudToBbox
-    """
-
-    # pylint: disable=too-many-instance-attributes
-
-    def __init__(self, conf=None):
-        """
-        Init function of CloudToBbox
-
-        :param conf: configuration for hole detection
-        :return: a application_to_use object
-        """
-
-        super().__init__(conf=conf)
-
-        # check conf
-
-        # get rasterization parameter
-        self.used_method = self.used_config["method"]
-
-        # Init orchestrator
-        self.orchestrator = None
-
-    def check_conf(self, conf):
-        """
-        Check configuration
-
-        :param conf: configuration to check
-        :type conf: dict
-
-        :return: overloaded configuration
-        :rtype: dict
-
-        """
-
-        # init conf
-        if conf is not None:
-            overloaded_conf = conf.copy()
-        else:
-            conf = {}
-            overloaded_conf = {}
-
-        # Overload conf
-
-        # get rasterization parameter
-        overloaded_conf["method"] = conf.get("method", "cloud_to_bbox")
-
-        hole_detection_schema = {
-            "method": str,
-            OptionalKey(application_constants.SAVE_INTERMEDIATE_DATA): bool,
-        }
-
-        # Check conf
-        checker = Checker(hole_detection_schema)
-        checker.validate(overloaded_conf)
-
-        return overloaded_conf
-
-    def run(
-        self,
-        epipolar_images_left,
-        epipolar_images_right,
-        classification=None,
-        margin=0,
-        orchestrator=None,
-        pair_folder=None,
-        pair_key="PAIR_0",
-    ):
-        """
-        Run Refill application using plane method.
-
-        :param epipolar_images_left:  left epipolar image
-        :type epipolar_images_left: CarsDataset
-        :param epipolar_images_right:  right epipolar image
-        :type epipolar_images_right: CarsDataset
-        :param is_activated:  activate application
-        :type is_activated: bool
-        :param margin: margin to use
-        :type margin: int
-        :param classification: mask classes to use
-        :type classification: list(str)
-        :param orchestrator: orchestrator used
-        :type orchestrator: Orchestrator
-        :param pair_folder: folder used for current pair
-        :type pair_folder: str
-        :param pair_key: pair id
-        :type pair_key: str
-
-        :return: left holes, right holes
-        :rtype: Tuple(CarsDataset, CarsDataset)
-
-        """
-
-        # Default orchestrator
-        if orchestrator is None:
-            # Create default sequential orchestrator for current application
-            # be awere, no out_json will be shared between orchestrators
-            # No files saved
-            self.orchestrator = ocht.Orchestrator(
-                orchestrator_conf={"mode": "sequential"}
-            )
-        else:
-            self.orchestrator = orchestrator
-
-        if pair_folder is None:
-            pair_folder = os.path.join(self.orchestrator.out_dir, "tmp")
-            safe_makedirs(pair_folder)
-
-        if epipolar_images_left.dataset_type == "arrays":
-            # Create CarsDataset
-            # Epipolar_disparity
-            left_bbox_cars_ds = cars_dataset.CarsDataset(
-                "dict", name="cloud_to_bbox_left_" + pair_key
-            )
-            left_bbox_cars_ds.create_empty_copy(epipolar_images_left)
-            left_bbox_cars_ds.overlaps *= 0
-
-            right_bbox_cars_ds = cars_dataset.CarsDataset(
-                "dict", name="cloud_to_bbox_left_" + pair_key
-            )
-            right_bbox_cars_ds.create_empty_copy(epipolar_images_right)
-            right_bbox_cars_ds.overlaps *= 0
-
-            # Add infos to orchestrator.out_json
-            updating_dict = {
-                application_constants.APPLICATION_TAG: {pair_key: {}}
-            }
-            self.orchestrator.update_out_info(updating_dict)
-            logging.info(
-                "Compute bbox: number tiles: {}".format(
-                    epipolar_images_left.shape[1]
-                    * epipolar_images_left.shape[0]
-                )
-            )
-
-            if classification not in (None, []):
-                # Get saving infos in order to save tiles when they are computed
-                [
-                    saving_info_left,
-                    saving_info_right,
-                ] = self.orchestrator.get_saving_infos(
-                    [left_bbox_cars_ds, right_bbox_cars_ds]
-                )
-
-                # Add to replace list so tiles will be readble at the same time
-                self.orchestrator.add_to_replace_lists(
-                    left_bbox_cars_ds, cars_ds_name="epi_msk_bbox_left"
-                )
-                self.orchestrator.add_to_replace_lists(
-                    right_bbox_cars_ds, cars_ds_name="epi_msk_bbox_right"
-                )
-
-                # Generate disparity maps
-                for col in range(epipolar_images_left.shape[1]):
-                    for row in range(epipolar_images_left.shape[0]):
-                        if (epipolar_images_left[row, col] is not None) or (
-                            epipolar_images_right[row, col] is not None
-                        ):
-                            # update saving_info with row and col needed for
-                            # replacement
-                            full_saving_info_left = ocht.update_saving_infos(
-                                saving_info_left, row=row, col=col
-                            )
-                            full_saving_info_right = ocht.update_saving_infos(
-                                saving_info_right, row=row, col=col
-                            )
-
-                            # get window and overlaps
-                            window_left = epipolar_images_left.tiling_grid[
-                                row, col, :
-                            ]
-                            window_right = epipolar_images_right.tiling_grid[
-                                row, col, :
-                            ]
-                            overlap_left = epipolar_images_left.overlaps[
-                                row, col, :
-                            ]
-                            overlap_right = epipolar_images_right.overlaps[
-                                row, col, :
-                            ]
-
-                            # Compute bbox
-                            (
-                                left_bbox_cars_ds[row, col],
-                                right_bbox_cars_ds[row, col],
-                            ) = self.orchestrator.cluster.create_task(
-                                compute_mask_bboxes_wrapper, nout=2
-                            )(
-                                epipolar_images_left[row, col],
-                                epipolar_images_right[row, col],
-                                window_left,
-                                window_right,
-                                overlap_left,
-                                overlap_right,
-                                classification,
-                                saving_info_left=full_saving_info_left,
-                                saving_info_right=full_saving_info_right,
-                            )
-        else:
-            logging.error(
-                "CloudToBbox application doesn't "
-                "support this input data format"
-            )
-
-        return left_bbox_cars_ds, right_bbox_cars_ds
-
-
-def compute_mask_bboxes_wrapper(
-    left_image_dataset,
-    right_image_dataset,
-    window_left,
-    window_right,
-    overlap_left,
-    overlap_right,
-    classification,
-    margin=20,
-    saving_info_left=None,
-    saving_info_right=None,
-):
-    """
-    Compute mask bounding boxes.
-
-    :param left_image_dataset: tiled Left image
-      - dataset with :
-
-            - cst.EPI_IMAGE
-            - cst.EPI_MSK (if given)
-            - cst.EPI_TEXTURE (for left, if given)
-    :type left_image_dataset: xr.Dataset
-      - dataset with :
-
-            - cst.EPI_IMAGE
-            - cst.EPI_MSK (if given)
-            - cst.EPI_TEXTURE (for left, if given)
-    :param right_image_dataset: tiled Right image
-    :type right_image_dataset: xr.Dataset
-    :param window_left: left window
-    :type window_left: dict
-    :param window_right: right window
-    :type window_right: dict
-    :param overlap_left: left  overlpas
-    :type overlap_left: dict
-    :param overlap_right: right overlaps
-    :type overlap_right: dict
-    :param classification: mask classes to use
-    :type classification: list(str)
-    :param margin: margin to use
-    :type margin: int
-    :param saving_info_left: saving infos left
-    :type saving_info_left: dict
-    :param saving_info_right: saving infos right
-    :type saving_info_right: dict
-
-    :return: Left image object, Right image object (if exists)
-
-    Returned objects are composed of dataset with :
-
-            - cst.EPI_IMAGE
-            - cst.EPI_MSK (if given)
-            - cst.EPI_TEXTURE (for left, if given)
-    """
-
-    # compute offsets
-    row_offset_left = window_left[0] - overlap_left[0]
-    col_offset_left = window_left[2] - overlap_left[2]
-    row_offset_right = window_right[0] - overlap_right[0]
-    col_offset_right = window_right[2] - overlap_right[2]
-
-    bbox_left = {}
-
-    if left_image_dataset is not None:
-        bbox_left = hole_detection_algo.localize_masked_areas(
-            left_image_dataset,
-            classification,
-            row_offset=row_offset_left,
-            col_offset=col_offset_left,
-            margin=margin,
-        )
-
-    bbox_right = {}
-
-    if right_image_dataset is not None:
-        bbox_right = hole_detection_algo.localize_masked_areas(
-            right_image_dataset,
-            classification,
-            row_offset=row_offset_right,
-            col_offset=col_offset_right,
-            margin=margin,
-        )
-
-    # add saving infos
-    bbox_left_dict = cars_dict.CarsDict({"list_bbox": bbox_left})
-    cars_dataset.fill_dict(bbox_left_dict, saving_info=saving_info_left)
-
-    bbox_right_dict = cars_dict.CarsDict({"list_bbox": bbox_right})
-    cars_dataset.fill_dict(bbox_right_dict, saving_info=saving_info_right)
-
-    return bbox_left_dict, bbox_right_dict

cars/applications/hole_detection/hole_detection_algo.py

@@ -1,144 +0,0 @@
-#!/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 function for holes detection.
-"""
-# pylint: disable=too-many-lines
-
-import logging
-
-# Standard imports
-from typing import List
-
-# Third party imports
-import numpy as np
-import rasterio
-import rasterio.features
-import xarray as xr
-from affine import Affine
-from scipy.ndimage import binary_dilation, generate_binary_structure, label
-from shapely.geometry import Polygon
-
-from cars.applications.hole_detection import (
-    hole_detection_wrappers as hole_wrap,
-)
-from cars.core import constants as cst
-
-
-def get_roi_coverage_as_poly_with_margins(
-    msk_values: np.ndarray, row_offset=0, col_offset=0, margin=0
-) -> List[Polygon]:
-    """
-    Finds all roi existing in binary msk and stores their coverage as
-    list of Polygon
-
-    :param msk_values: msk layer of left/right epipolar image dataset
-    :type msk_values: np.ndarray
-    :param row_offset: offset on row to apply
-    :type row_offset: int
-    :param col_offset: offset on col to apply
-    :type col_offset: int
-    :param margin: margin added to bbox in case masked region is
-        localized at tile border (to ensure later disparity values
-        at mask border extraction)
-    :type margin: int
-
-    :return: list of polygon
-
-    """
-
-    bbox = []
-    coord_shapes = []
-    # Check if at least one masked area in roi
-    if np.sum(msk_values) != 0:
-        msk_values_dil = msk_values
-        if margin != 0:
-            # Dilates areas in mask according to parameter 'margin' in order
-            # to get enough disparity values if region is near a tile border
-            # 1. Generates a structuring element that will consider features
-            # connected even if they touch diagonally
-            struct = generate_binary_structure(2, 2)
-            # 2. Dilation operation
-            msk_values_dil = binary_dilation(
-                msk_values, structure=struct, iterations=margin
-            )
-        labeled_array, __ = label(np.array(msk_values_dil).astype("int"))
-        shapes = rasterio.features.shapes(
-            labeled_array,
-            transform=Affine(1.0, 0.0, 0.0, 0.0, 1.0, 0.0),
-        )
-        for geometry, value in shapes:
-            if value != 0:
-                # Get polygon coordinates of labelled region
-                coords = geometry["coordinates"][0]
-                coords = [
-                    (c[1] + row_offset, c[0] + col_offset) for c in coords
-                ]
-                coord_shapes.append(coords)
-        bbox.extend([Polygon(c) for c in coord_shapes])
-    return bbox
-
-
-def localize_masked_areas(
-    dataset: xr.Dataset,
-    classification: List[str],
-    row_offset: int = 0,
-    col_offset: int = 0,
-    margin: int = 0,
-) -> np.ndarray:
-    """
-    Calculates bbox of masked region(s) if mask exists for
-    input image file (see configuration "mask" and "mask_classes"
-    in input .json configuration file)
-
-    :param dataset: epipolar image dataset
-    :type dataset: CarsDataset
-    :param classification: label of masked region to use
-    :type classification: List of str
-    :param row_offset: offset on row to apply
-    :type row_offset: int
-    :param col_offset: offset on col to apply
-    :type col_offset: int
-    :param margin: margin added to bbox in case masked region is
-        localized at tile border (to ensure later disparity values
-        at mask border extraction)
-    :type margin: int
-
-    :return: bounding box of masked area(s)
-
-    """
-    # binarize msk layer of epipolar image dataset
-    # 0: 'valid' data, 1: masked data according to key_id
-    if cst.EPI_CLASSIFICATION not in dataset:
-        logging.debug("No classif provided")
-        bbox = []
-    else:
-        if not isinstance(classification, list):
-            logging.error("no mask classes provided for DisparityFilling")
-            raise RuntimeError("no mask classes provided for DisparityFilling")
-        msk_values = hole_wrap.classif_to_stacked_array(dataset, classification)
-        # Finds roi in msk and stores its localization as polygon list
-        bbox = get_roi_coverage_as_poly_with_margins(
-            msk_values,
-            row_offset=row_offset,
-            col_offset=col_offset,
-            margin=margin,
-        )
-    return bbox

cars/applications/hole_detection/hole_detection_wrappers.py

@@ -1,53 +0,0 @@
-#!/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 function for holes detection.
-"""
-
-# Third party imports
-import numpy as np
-
-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