cars 1.0.0rc2__cp312-cp312-win_amd64.whl

cars/__init__.py

@@ -0,0 +1,86 @@
+#!/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 module init file
+"""
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_11_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'cars.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_11_2()
+del _delvewheel_patch_1_11_2
+# end delvewheel patch
+
+import os
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("cars")
+except PackageNotFoundError:
+    # package is not installed
+    __version__ = "unknown"
+
+# Standard imports
+if sys.version_info < (3, 10):
+    from importlib_metadata import entry_points
+else:
+    from importlib.metadata import entry_points
+
+
+__author__ = "CNES"
+__email__ = "cars@cnes.fr"
+
+# Force the use of CARS dask configuration
+dask_config_path = os.path.join(
+    os.path.dirname(__file__), "orchestrator", "cluster", "dask_config"
+)
+if not os.path.isdir(dask_config_path):
+    raise NotADirectoryError("Wrong dask config path")
+os.environ["DASK_CONFIG"] = str(dask_config_path)
+
+# Force monothread for child workers
+os.environ["PANDORA_NUMBA_PARALLEL"] = str(False)
+os.environ["PANDORA_NUMBA_CACHE"] = str(False)
+os.environ["SHARELOC_NUMBA_PARALLEL"] = str(False)
+os.environ["OMP_NUM_THREADS"] = "1"
+os.environ["MKL_NUM_THREADS"] = "1"
+os.environ["GDAL_NUM_THREADS"] = "1"
+
+# Limit GDAL cache per worker to 500MB
+os.environ["GDAL_CACHEMAX"] = "500"
+
+
+def import_plugins() -> None:
+    """
+    Load all the registered entry points
+    :return: None
+    """
+    for entry_point in entry_points(group="cars.plugins"):
+        entry_point.load()
+
+
+import_plugins()

cars/applications/__init__.py

@@ -0,0 +1,40 @@
+#!/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 application module init file
+"""
+
+# Imports needed in order to register application for Application factory
+from . import auxiliary_filling  # noqa: F401
+from . import dem_generation  # noqa: F401
+from . import dense_match_filling  # noqa: F401
+from . import dense_matching  # noqa: F401
+from . import dsm_filling  # noqa: F401
+from . import dsm_merging  # noqa: F401
+from . import grid_correction  # noqa: F401
+from . import grid_generation  # noqa: F401
+from . import ground_truth_reprojection  # noqa: F401
+from . import point_cloud_outlier_removal  # noqa: F401
+from . import rasterization  # noqa: F401
+from . import resampling  # noqa: F401
+from . import sensors_subsampling  # noqa: F401
+from . import sparse_matching  # noqa: F401
+from . import triangulation  # noqa: F401

cars/applications/application.py

@@ -0,0 +1,117 @@
+#!/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 class application factory.
+"""
+
+# Standard imports
+import logging
+
+from cars.applications.application_template import ScalingApplicationTemplate
+
+# CARS imports
+from cars.conf.input_parameters import ConfigType
+
+
+class Application:
+    """
+    Application factory:
+    A class designed for registered all available Cars application and
+    instantiate when needed.
+
+    """
+
+    # Dict (application_name:str, class: object) containing registered
+    # applications
+    available_applications = {}
+
+    def __new__(
+        cls,
+        app_name: str,
+        cfg: ConfigType = None,
+        scaling_coeff: float = 1,
+    ):
+        """
+        Return the instance of application associated with the application
+        name given as parameter
+
+        :param app_name: name of the application.
+        :type app_name: str
+        :param cfg: configuration {'matching_cost_method': value}
+        :type cfg: dictionary
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+        """
+
+        return cls.create_app(app_name, cfg, scaling_coeff)
+
+    @classmethod
+    def create_app(cls, name: str, cfg: ConfigType, scaling_coeff: float = 1):
+        """Factory command to create the application
+        Return the instance of application associated with the application
+        name given as parameter
+
+        :param app_name: name of the application.
+        :type app_name: str
+        :param cfg: configuration {'matching_cost_method': value}
+        :type cfg: dictionary
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+        """
+        try:
+            app_class = cls.available_applications[name]
+        except KeyError:
+            logging.error("No application named {0} supported".format(name))
+            return None
+
+        if issubclass(app_class, ScalingApplicationTemplate):
+            return app_class(scaling_coeff=scaling_coeff, conf=cfg)
+
+        return app_class(conf=cfg)
+
+    @classmethod
+    def print_applications(cls):
+        """
+        Print all registered applications
+        """
+
+        for app_name in cls.available_applications:
+            print(app_name)
+
+    @classmethod
+    def register(cls, app_name: str):
+        """
+        Allows to register the application with its name
+        :param app_name: the application to be registered
+        :type app_name: string
+        """
+
+        def decorator(app):
+            """
+            Registers the class in the available methods
+            :param app: the app class to be registered
+            :type app: object
+            """
+            cls.available_applications[app_name] = app
+            return app
+
+        return decorator

cars/applications/application_constants.py

@@ -0,0 +1,29 @@
+#!/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.
+#
+"""
+application_constants contains constants used in application module
+"""
+
+
+APPLICATION_TAG = "applications"
+
+# common parameters
+SAVE_INTERMEDIATE_DATA = "save_intermediate_data"

cars/applications/application_template.py

@@ -0,0 +1,146 @@
+#!/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 class application template for
+templating the application concept.
+Useful for shared parameters and functions in all applications
+Beware: argument-differ is activated in pylintrc for run parameters different
+in sub application classes
+"""
+
+# Standard imports
+import logging
+import os
+import pprint
+from abc import ABCMeta, abstractmethod
+
+# CARS imports
+from cars.conf.input_parameters import ConfigType
+
+
+class ApplicationTemplate(metaclass=ABCMeta):
+    """
+    Class for general specification of an application
+    Empty for the moment because there is no any common method or function
+    """
+
+    # Define abstract attributes
+    used_config: ConfigType
+
+    @abstractmethod
+    def run(self, *args, **kwargs):
+        """
+        Generic run() function to be defined in subclasses
+        """
+
+    def __init__(self, conf=None):  # pylint: disable=W0613
+        """
+        Init function of ApplicationTemplate
+
+        :param conf: configuration for application
+
+        """
+        # Check conf
+        try:
+            self.used_config = self.check_conf(conf)
+        except Exception:
+            logging.error(
+                "The {} application checking has been failed!".format(
+                    self.__class__.__bases__[0].__name__
+                )
+            )
+            raise
+
+    @abstractmethod
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+        :type conf: dict
+
+        :return: overloaded configuration
+        :rtype: dict
+
+        """
+
+    def print_config(self):
+        """
+        Print used application configuration
+
+        """
+        pretty_printer = pprint.PrettyPrinter(indent=4)
+
+        try:
+            pretty_printer.pprint(self.used_config)
+        except Exception:
+            logging.error("self.used_config not filled by application")
+
+    def get_conf(self):
+        """
+        Get used conf
+
+        :return: used conf
+        """
+
+        return self.used_config
+
+    def generate_unknown_dump_dir(self, orchestrator):
+        """
+        Generate dump dir from orchestrator
+
+        :param orchestrator: orchestrator
+
+        :return: dump dir
+        """
+
+        dump_dir = None
+        if orchestrator is not None:
+            orch_out_dir = orchestrator.out_dir
+            dump_dir = os.path.join(
+                orch_out_dir,
+                "unknown_dump",
+                self.__class__.__bases__[0].__name__,
+            )
+        return dump_dir
+
+
+class ScalingApplicationTemplate(ApplicationTemplate, metaclass=ABCMeta):
+    """
+    Template for applications requiring resolution scaling.
+
+    Inherits from ApplicationTemplate and adds the scaling coefficient
+    as a required argument.
+    """
+
+    def __init__(self, scaling_coeff, conf=None):
+        """
+        Init function of ScalingApplicationTemplate
+
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+
+        :param conf: configuration for application
+        :type conf: dict
+        """
+        self.scaling_coeff = scaling_coeff
+        super().__init__(conf=conf)

cars/applications/auxiliary_filling/__init__.py

@@ -0,0 +1,29 @@
+# !/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.
+#
+"""
+CARS auxiliary filling module init file
+"""
+# flake8: noqa: F401
+
+import cars.applications.auxiliary_filling.abstract_auxiliary_filling_app
+from cars.applications.auxiliary_filling.auxiliary_filling_from_sensors_app import (  # pylint: disable=C0301
+    AuxiliaryFilling,
+)

cars/applications/auxiliary_filling/abstract_auxiliary_filling_app.py

@@ -0,0 +1,105 @@
+# !/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 abstract AuxiliaryFilling 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 ApplicationTemplate
+
+
+@Application.register("auxiliary_filling")
+class AuxiliaryFilling(ApplicationTemplate, metaclass=ABCMeta):
+    """
+    AuxiliaryFilling abstract class
+    """
+
+    available_applications: Dict = {}
+    default_application = "auxiliary_filling_from_sensors"
+
+    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 auxiliary_filling
+        :return: an application_to_use object
+        """
+
+        auxiliary_filling_method = cls.default_application
+
+        if bool(conf) is False or "method" not in conf:
+            logging.info(
+                "Auxiliary filling method not specified, "
+                "default {} is used".format(auxiliary_filling_method)
+            )
+        else:
+            auxiliary_filling_method = conf["method"]
+
+        if auxiliary_filling_method not in cls.available_applications:
+            logging.error(
+                "No auxiliary_filling application named {} registered".format(
+                    auxiliary_filling_method
+                )
+            )
+            raise KeyError(
+                "No auxiliary_filling application named {} registered".format(
+                    auxiliary_filling_method
+                )
+            )
+
+        logging.info(
+            "The AuxiliaryFilling({}) application will be used".format(
+                auxiliary_filling_method
+            )
+        )
+
+        return super(AuxiliaryFilling, cls).__new__(
+            cls.available_applications[auxiliary_filling_method]
+        )
+
+    def __init_subclass__(cls, short_name, **kwargs):  # pylint: disable=E0302
+        super().__init_subclass__(**kwargs)
+        cls.available_applications[short_name] = cls
+
+    @abstractmethod
+    def run(  # pylint: disable=too-many-positional-arguments
+        self,
+        dsm_file,
+        color_file,
+        classif_file,
+        dump_dir,
+        sensor_inputs,
+        pairing,
+        geom_plugin,
+        texture_bands,
+        output_geoid,
+        orchestrator=None,
+        dsm_dir=None,
+    ):
+        """
+        Run Auxiliary filling
+        """