cars 1.0.0rc2__cp312-cp312-win_amd64.whl

cars/pipelines/parameters/sensor_inputs_constants.py

@@ -0,0 +1,51 @@
+#!/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 used in sensor_to_full_resolution
+pipeline.
+"""
+
+# Sensor input
+
+SENSORS = "sensors"
+PAIRING = "pairing"
+RECTIFICATION_GRIDS = "rectification_grids"
+
+INITIAL_ELEVATION = "initial_elevation"
+LOW_RES_DSM = "low_res_dsm"
+
+ROI = "roi"
+GEOID = "geoid"
+DEM_PATH = "dem"
+LOADERS = "loaders"
+FILLING = "filling"
+
+INPUT_IMG = "image"
+INPUT_MSK = "mask"
+INPUT_CLASSIFICATION = "classification"
+INPUT_GEO_MODEL = "geomodel"
+INPUT_GEO_MODEL_TYPE = "geomodel_type"
+INPUT_GEO_MODEL_FILTER = "geomodel_filters"
+INPUT_NODATA = "no_data"
+INPUT_PATH = "path"
+INPUT_VALUES = "values"
+
+CARS_DEFAULT_ALT = 0  # Default altitude used in cars pipelines

cars/pipelines/parameters/sensor_loaders/__init__.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.
+#
+"""
+CARS application module init file
+"""
+
+from .basic_classif_loader import BasicClassifSensorLoader  # noqa: F401
+from .basic_image_loader import BasicImageSensorLoader  # noqa: F401
+from .pivot_classif_loader import PivotClassifSensorLoader  # noqa: F401
+from .pivot_image_loader import PivotImageSensorLoader  # noqa: F401
+from .slurp_classif_loader import SlurpClassifSensorLoader  # noqa: F401

cars/pipelines/parameters/sensor_loaders/basic_classif_loader.py

@@ -0,0 +1,86 @@
+# !/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 ClassifSensorLoader class.
+"""
+
+from json_checker import Checker
+
+from cars.core import inputs
+from cars.core.utils import make_relative_path_absolute
+from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
+from cars.pipelines.parameters.sensor_loaders.pivot_classif_loader import (
+    PivotClassifSensorLoader,
+)
+from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
+from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
+    SensorLoaderTemplate,
+)
+
+
+@SensorLoader.register("basic_classification")
+class BasicClassifSensorLoader(SensorLoaderTemplate):
+    """
+    Default sensor loader (used when no sensor loader is specified)
+    """
+
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+
+        :return: overloaded configuration
+        :rtype: dict
+        """
+        if isinstance(conf, str):
+            overloaded_conf = {}
+            image_path = make_relative_path_absolute(conf, self.config_dir)
+            overloaded_conf[sens_cst.INPUT_PATH] = image_path
+        else:
+            raise TypeError(f"Input {conf} is not a string")
+
+        sensor_schema = {
+            sens_cst.INPUT_PATH: str,
+        }
+
+        # Check conf
+        checker = Checker(sensor_schema)
+        checker.validate(overloaded_conf)
+
+        return overloaded_conf
+
+    def set_pivot_format(self):
+        """
+        Transform input configuration to pivot format and store it
+        """
+        pivot_config = {
+            sens_cst.INPUT_PATH: self.used_config[sens_cst.INPUT_PATH],
+        }
+        pivot_config["values"] = inputs.rasterio_get_classif_values(
+            self.used_config[sens_cst.INPUT_PATH]
+        )
+        # Remove value 0 because it corresponds to unclassified data
+        pivot_config["values"].remove(0)
+        pivot_sensor_loader = PivotClassifSensorLoader(
+            pivot_config, self.config_dir
+        )
+        self.pivot_format = pivot_sensor_loader.get_pivot_format()

cars/pipelines/parameters/sensor_loaders/basic_image_loader.py

@@ -0,0 +1,98 @@
+# !/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 BasicImageSensorLoader class.
+"""
+
+from json_checker import Checker, Or
+
+from cars.core import inputs
+from cars.core.utils import make_relative_path_absolute
+from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
+from cars.pipelines.parameters.sensor_loaders.pivot_image_loader import (
+    PivotImageSensorLoader,
+)
+from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
+from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
+    SensorLoaderTemplate,
+)
+
+
+@SensorLoader.register("basic_image")
+class BasicImageSensorLoader(SensorLoaderTemplate):
+    """
+    Default sensor loader for image (used when no sensor loader is specified)
+    """
+
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+
+        :return: overloaded configuration
+        :rtype: dict
+        """
+        if isinstance(conf, str):
+            overloaded_conf = {}
+            image_path = make_relative_path_absolute(conf, self.config_dir)
+            overloaded_conf[sens_cst.INPUT_PATH] = image_path
+            overloaded_conf[sens_cst.INPUT_NODATA] = 0
+        elif isinstance(conf, dict):
+            overloaded_conf = conf.copy()
+            image_path = make_relative_path_absolute(
+                conf[sens_cst.INPUT_PATH], self.config_dir
+            )
+            overloaded_conf[sens_cst.INPUT_PATH] = image_path
+            overloaded_conf[sens_cst.INPUT_NODATA] = conf.get(
+                sens_cst.INPUT_NODATA, 0
+            )
+        else:
+            raise TypeError(f"Input {conf} is not a string ot dict")
+
+        sensor_schema = {
+            sens_cst.INPUT_PATH: str,
+            sens_cst.INPUT_NODATA: Or(None, int),
+        }
+
+        # Check conf
+        checker = Checker(sensor_schema)
+        checker.validate(overloaded_conf)
+
+        return overloaded_conf
+
+    def set_pivot_format(self):
+        """
+        Transform input configuration to pivot format and store it
+        """
+        pivot_config = {"bands": {}}
+        for band_id in range(
+            inputs.rasterio_get_nb_bands(self.used_config[sens_cst.INPUT_PATH])
+        ):
+            band_name = "b" + str(band_id)
+            pivot_config["bands"][band_name] = {
+                sens_cst.INPUT_PATH: self.used_config[sens_cst.INPUT_PATH],
+                "band": band_id,
+            }
+        pivot_sensor_loader = PivotImageSensorLoader(
+            pivot_config, self.config_dir
+        )
+        self.pivot_format = pivot_sensor_loader.get_pivot_format()

cars/pipelines/parameters/sensor_loaders/pivot_classif_loader.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 PivotImageSensorLoader class.
+"""
+
+from json_checker import Checker
+
+from cars.core import inputs
+from cars.core.utils import make_relative_path_absolute
+from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
+from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
+from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
+    SensorLoaderTemplate,
+)
+
+
+@SensorLoader.register("pivot_classification")
+class PivotClassifSensorLoader(SensorLoaderTemplate):
+    """
+    Pivot image sensor loader : used by CARS to read inputs
+    """
+
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+
+        :return: overloaded configuration
+        :rtype: dict
+        """
+        overloaded_conf = conf.copy()
+        # Make relative path absolute
+        overloaded_conf["path"] = make_relative_path_absolute(
+            overloaded_conf["path"], self.config_dir
+        )
+        overloaded_conf[sens_cst.INPUT_VALUES] = conf.get(
+            sens_cst.INPUT_VALUES, []
+        )
+        # Check dtype and number of bands
+        classif_file = overloaded_conf["path"]
+        classif_dtype = inputs.rasterio_get_dtype(classif_file)
+        if classif_dtype != "uint8":
+            raise TypeError(
+                "Classification file {} has type {} which is not supported "
+                "for classification : type must be uint8".format(
+                    classif_file, classif_dtype
+                )
+            )
+        classif_nb_bands = inputs.rasterio_get_nb_bands(classif_file)
+        if classif_nb_bands != 1:
+            raise TypeError(
+                "Classification file {} has {} bands but only mono-band "
+                "classification is allowed".format(
+                    classif_file, classif_nb_bands
+                )
+            )
+
+        sensor_schema = {
+            sens_cst.INPUT_PATH: str,
+            sens_cst.INPUT_VALUES: list,
+        }
+
+        # Check conf
+        checker = Checker(sensor_schema)
+        checker.validate(overloaded_conf)
+
+        return overloaded_conf
+
+    def set_pivot_format(self):
+        self.pivot_format = self.used_config

cars/pipelines/parameters/sensor_loaders/pivot_image_loader.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 PivotImageSensorLoader class.
+"""
+
+from json_checker import Checker, Or
+
+from cars.core import inputs
+from cars.core.utils import make_relative_path_absolute
+from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
+from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
+from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
+    SensorLoaderTemplate,
+)
+
+
+@SensorLoader.register("pivot_image")
+class PivotImageSensorLoader(SensorLoaderTemplate):
+    """
+    Pivot image sensor loader : used by CARS to read inputs
+    """
+
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+
+        :return: overloaded configuration
+        :rtype: dict
+        """
+        overloaded_conf = conf.copy()
+        # Make relative paths absolutes
+        for band in overloaded_conf["bands"]:
+            overloaded_conf["bands"][band]["path"] = (
+                make_relative_path_absolute(
+                    overloaded_conf["bands"][band]["path"], self.config_dir
+                )
+            )
+        # Check consistency between files
+        b0_path = overloaded_conf["bands"]["b0"]["path"]
+        b0_size = inputs.rasterio_get_size(b0_path)
+        b0_transform = inputs.rasterio_get_transform(b0_path)
+        for band in overloaded_conf["bands"]:
+            band_path = overloaded_conf["bands"][band]["path"]
+            band_id = overloaded_conf["bands"][band]["band"]
+            nb_bands = inputs.rasterio_get_nb_bands(band_path)
+            if band_id >= nb_bands:
+                raise RuntimeError(
+                    "Band id {} is not valid for sensor which "
+                    "has only {} bands".format(band_id, nb_bands)
+                )
+            if band_path != b0_path:
+                band_size = inputs.rasterio_get_size(band_path)
+                band_transform = inputs.rasterio_get_transform(band_path)
+                if b0_size != band_size:
+                    raise RuntimeError(
+                        "The files {} and {} do not have the same size "
+                        "but are in the same image".format(b0_path, band_path)
+                    )
+                if b0_transform != band_transform:
+                    raise RuntimeError(
+                        "The files {} and {} do not have the same transform "
+                        "but are in the same image".format(
+                            b0_path,
+                            band_path,
+                        )
+                    )
+
+        overloaded_conf[sens_cst.INPUT_NODATA] = conf.get(
+            sens_cst.INPUT_NODATA, 0
+        )
+
+        sensor_schema = {
+            "bands": dict,
+            sens_cst.INPUT_NODATA: Or(None, int),
+        }
+
+        # Check conf
+        checker = Checker(sensor_schema)
+        checker.validate(overloaded_conf)
+
+        return overloaded_conf
+
+    def set_pivot_format(self):
+        self.pivot_format = self.used_config

cars/pipelines/parameters/sensor_loaders/sensor_loader.py

@@ -0,0 +1,93 @@
+#!/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 sensor loader factory.
+"""
+
+import logging
+
+
+class SensorLoader:
+    """
+    SensorLoader factory:
+    A class designed for registered all available Cars sensor loader and
+    instantiate when needed.
+
+    """
+
+    # Dict (loader_name:str, class: object) containing registered
+    # sensor loaders
+    available_loaders = {}
+
+    def __new__(cls, app_name: str, cfg: dict, config_dir: str):
+        """
+        Return the instance of sensor loader associated with the sensor loader
+        name given as parameter
+
+        :param app_name: name of the sensor loader.
+        :type app_name: str
+        :param cfg: configuration {'matching_cost_method': value}
+        :type cfg: dictionary
+        """
+
+        return cls.create_app(app_name, cfg, config_dir)
+
+    @classmethod
+    def create_app(cls, name: str, cfg: dict, config_dir: str):
+        """
+        Factory command to create the sensor loader
+        Return the instance of sensor loader associated with the sensor loader
+        name given as parameter
+
+        :param app_name: name of the sensor loader.
+        :type app_name: str
+        :param cfg: sensor loader configuration
+        :type cfg: dictionary
+        """
+        loader = None
+
+        try:
+            loader_class = cls.available_loaders[name]
+        except KeyError:
+            logging.error("No sensor loader named {0} supported".format(name))
+            return None
+        loader = loader_class(cfg, config_dir)
+        return loader
+
+    @classmethod
+    def register(cls, app_name: str):
+        """
+        Allows to register the sensor loader with its name
+        :param app_name: the sensor loader 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_loaders[app_name] = app
+            return app
+
+        return decorator

cars/pipelines/parameters/sensor_loaders/sensor_loader_template.py

@@ -0,0 +1,71 @@
+# !/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 AbstractSensorLoader class.
+"""
+
+from abc import abstractmethod
+
+
+class SensorLoaderTemplate:
+    """
+    Class for general specification of a sensor loader
+    """
+
+    def __init__(self, conf, config_dir):
+        """
+        Init function of SensorLoaderTemplate
+
+        :param conf: configuration for sensor loader
+        """
+        self.config_dir = config_dir
+        self.used_config = self.check_conf(conf)
+
+        self.pivot_format = None
+
+    @abstractmethod
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+
+        :return: overloaded configuration
+        :rtype: dict
+        """
+
+    def get_pivot_format(self):
+        """
+        Return sensor configuration as pivot format
+
+        :return: pivot format configuration
+        :rtype: dict
+        """
+        if self.pivot_format is None:
+            self.set_pivot_format()
+
+        return self.pivot_format
+
+    @abstractmethod
+    def set_pivot_format(self):
+        """
+        Transform input configuration to pivot format and store it
+        """