cars 1.0.0rc2__cp312-cp312-win_amd64.whl

cars/applications/auxiliary_filling/auxiliary_filling_wrappers.py

@@ -0,0 +1,90 @@
+# !/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2024 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 AuxiliaryFillingFromSensors application class.
+"""
+
+from pyproj import CRS
+from shapely.geometry import Polygon
+
+from cars.core.projection import polygon_projection_crs
+
+
+def compute_sensor_bounds(sensor_inputs, geom_plugin, output_crs):
+    """
+    Compute bounds of each input sensor that have an associated color or
+    classification image
+
+    :param sensor_inputs: dictionary containing paths to input images and models
+    :type sensor_inputs: dict
+    :param geom_plugin: geometry plugin used for inverse locations
+    :type geom_plugin: AbstractGeometry
+    :param geom_plugin: geometry plugin used for inverse locations
+    :type geom_plugin: AbstractGeometry
+    :param output_crs: crs of the output polygons
+    :type output_crs: CRS
+
+    :return: a dictionary containing a Polygon in output geometry for each
+        valid input sensor
+    """
+
+    sensor_bounds = {}
+
+    for sensor_name, sensor in sensor_inputs.items():
+        reference_sensor_image = sensor["image"]["bands"]["b0"]["path"]
+        # no data for this sensor, no need to compute its bounds
+        if reference_sensor_image is None:
+            continue
+
+        u_l, u_r, l_l, l_r = geom_plugin.image_envelope(
+            reference_sensor_image, sensor["geomodel"]
+        )
+
+        poly_geo = Polygon([u_l, u_r, l_r, l_l, u_l])
+
+        sensor_bounds[sensor_name] = polygon_projection_crs(
+            poly_geo, CRS(4326), output_crs
+        )
+
+    return sensor_bounds
+
+
+def filter_sensor_inputs(sensor_inputs, sensor_bounds, ground_polygon):
+    """
+    Filter input sensors by comparing their bounds to a reference Polygon
+
+    :param sensor_inputs: dictionary containing paths to input images and models
+    :type sensor_inputs: dict
+    :param sensor_bounds: dictionary containing bounds of input sensors
+    :type sensor_bounds: dict
+    :param ground_polygon: reference polygon, in ground geometry
+    :type ground_polygon: Polygon
+
+    :return: a fitlered version of sensor_inputs
+    """
+
+    filtered_sensor_inputs = sensor_inputs.copy()
+
+    for sensor_name, bound in sensor_bounds.items():
+        if not bound.intersects(ground_polygon):
+            del filtered_sensor_inputs[sensor_name]
+
+    return filtered_sensor_inputs

cars/applications/dem_generation/__init__.py

@@ -0,0 +1,30 @@
+# !/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 dem generation init file
+"""
+# flake8: noqa: F401
+
+from cars.applications.dem_generation.abstract_dem_generation_app import (
+    DemGeneration,
+)
+
+from . import bulldozer_dem_app

cars/applications/dem_generation/abstract_dem_generation_app.py

@@ -0,0 +1,116 @@
+#!/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 dem_generation application class.
+"""
+import logging
+from abc import ABCMeta, abstractmethod
+from typing import Dict
+
+from cars.applications.application import Application
+from cars.applications.application_template import ScalingApplicationTemplate
+
+
+@Application.register("dem_generation")
+class DemGeneration(ScalingApplicationTemplate, metaclass=ABCMeta):
+    """
+    DemGeneration
+    """
+
+    available_applications: Dict = {}
+    default_application = "bulldozer_on_raster"
+
+    def __new__(cls, scaling_coeff, conf=None):  # pylint: disable=W0613
+        """
+        Return the required application
+        :raises:
+         - KeyError when the required application is not registered
+
+        :param orchestrator: orchestrator used
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+        :param conf: configuration for resampling
+        :return: an application_to_use object
+        """
+
+        dem_generation_method = cls.default_application
+        if bool(conf) is False or "method" not in conf:
+            logging.info(
+                "MntGeneration method not specified, default"
+                " {} is used".format(dem_generation_method)
+            )
+        else:
+            dem_generation_method = conf["method"]
+
+        if dem_generation_method not in cls.available_applications:
+            logging.error(
+                "No dem_generation application named {} registered".format(
+                    dem_generation_method
+                )
+            )
+            raise KeyError(
+                "No dem_generation application named {} registered".format(
+                    dem_generation_method
+                )
+            )
+
+        logging.info(
+            "The DemGeneration {} application will be used".format(
+                dem_generation_method
+            )
+        )
+
+        return super(DemGeneration, cls).__new__(
+            cls.available_applications[dem_generation_method]
+        )
+
+    def __init_subclass__(cls, short_name, **kwargs):  # pylint: disable=E0302
+        super().__init_subclass__(**kwargs)
+        cls.available_applications[short_name] = cls
+
+    def __init__(self, scaling_coeff, conf=None):
+        """
+        Init function of MntGeneration
+
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+        :param conf: configuration
+        :return: an application_to_use object
+        """
+
+        super().__init__(scaling_coeff, conf=conf)
+
+    @abstractmethod
+    def run(self, triangulated_matches_list, output_dir):
+        """
+        Run dem generation using matches
+
+        :param triangulated_matches_list: list of triangulated matches
+            positions must be in a metric system
+        :type triangulated_matches_list: list(pandas.Dataframe)
+        :param output_dir: directory to save dem
+        :type output_dir: str
+
+        :return: dem data computed with mean, min and max.
+            dem is also saved in disk, and paths are available in attributes.
+            (DEM_MEDIAN_PATH, DEM_MIN_PATH, DEM_MAX_PATH)
+        :rtype: CarsDataset
+        """

cars/applications/dem_generation/bulldozer_config/base_config.yaml

@@ -0,0 +1,42 @@
+#-------------------------#
+#       Parameters        #
+#-------------------------#
+# [Required] - Input DSM path (expected format: "<folder_1>/<folder_2>/<file>.<[tif/tiff]>") 
+dsm_path : "input_dsm_path/dsm.tif"
+# [Required] - Output directory path (if the directory doesn't exist, create it)
+output_dir : "output_dir_path"
+
+#-------------------------#
+#         Options         #
+#-------------------------#
+# [Optional] - If True, generates the Digital Height Model (DHM=DSM-DTM) in the output directory 
+generate_dhm : True
+# [Optional] - Foreground max object size (in meter)
+max_object_size : 16
+# [Optional] - Path to the binary ground classification mask (expected format: "<folder_1>/<folder_2>/<mask>.<[tif/tiff]>") 
+ground_mask_path : null
+# [Optional] - If True, activate ground anchor detection (ground pre-detection)
+activate_ground_anchors : False
+# [Optional] - Max number of CPU core to use. If null, use maximum number of available CPU core 
+nb_max_workers : null
+# [Optional] - If True, keep the intermediate results
+developer_mode : False
+
+#-------------------------#
+#     Expert options      #
+#-------------------------#
+# /!\ Modify those data at your own risk (it is suggested to keep the default values) /!\
+
+# [Optional] - Number of regular mask filtering iterations. If null, use the default value: max_object_size/4
+reg_filtering_iter: null
+# [Optional] - Altimetric height accuracy of the input DSM (m). If null, use the default value: 2*planimetric resolution
+dsm_z_accuracy: null
+# [Optional] - Maximum slope of the observed landscape terrain (%)
+max_ground_slope: 20.0
+# [Optional] - Number of unhook iterations
+prevent_unhook_iter : 10
+# [Optional] - Number of gravity step iterations
+num_outer_iter : 25
+# [Optional] - Number of tension iterations
+num_inner_iter : 5
+