cars 1.0.0a3__cp311-cp311-win_amd64.whl → 1.0.0a4__cp311-cp311-win_amd64.whl

cars/pipelines/parameters/sensor_loaders/basic_classif_loader.py

@@ -0,0 +1,106 @@
+# !/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.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_classif")
+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
+        """
+        default_filling = {
+            "fill_with_geoid": "b0",
+            "interpolate_from_borders": "b1",
+            "fill_with_endogenous_dem": "b2",
+            "fill_with_exogenous_dem": "b3",
+        }
+        if isinstance(conf, str):
+            overloaded_conf = {}
+            image_path = make_relative_path_absolute(conf, self.config_dir)
+            overloaded_conf["path"] = image_path
+            overloaded_conf["loader"] = "basic_classif"
+            overloaded_conf["filling"] = default_filling
+        elif isinstance(conf, dict):
+            overloaded_conf = conf.copy()
+            image_path = make_relative_path_absolute(
+                conf["path"], self.config_dir
+            )
+            overloaded_conf["path"] = image_path
+            overloaded_conf["loader"] = conf.get("loader", "basic")
+            overloaded_conf["filling"] = conf.get("filling", default_filling)
+        else:
+            raise TypeError(f"Input {conf} is not a string ot dict")
+
+        sensor_schema = {"loader": str, "path": str, "filling": dict}
+
+        # 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 = {
+            "loader": "pivot_classif",
+            "main_file": self.used_config["path"],
+            "filling": self.used_config["filling"],
+        }
+        pivot_config["bands"] = {}
+        for band_id in range(
+            inputs.rasterio_get_nb_bands(self.used_config["path"])
+        ):
+            band_name = "b" + str(band_id)
+            pivot_config["bands"][band_name] = {
+                "path": self.used_config["path"],
+                "band": band_id,
+            }
+        pivot_config["texture_bands"] = None
+        pivot_sensor_loader = PivotClassifSensorLoader(
+            pivot_config, self.config_dir
+        )
+        self.pivot_format = pivot_sensor_loader.get_pivot_format()

cars/pipelines/parameters/sensor_loaders/{basic_sensor_loader.py → basic_image_loader.py}

@@ -19,7 +19,7 @@
 # limitations under the License.
 #
 """
-this module contains the BasicSensorLoader class.
+This module contains the BasicImageSensorLoader class.
 """
 
 from json_checker import Checker, Or
@@ -27,8 +27,8 @@ 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_sensor_loader import (
-    PivotSensorLoader,
+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 (
@@ -36,10 +36,10 @@ from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
 )
 
 
-@SensorLoader.register("basic")
-class BasicSensorLoader(SensorLoaderTemplate):
+@SensorLoader.register("basic_image")
+class BasicImageSensorLoader(SensorLoaderTemplate):
     """
-    Default sensor loader (used when no sensor loader is specified)
+    Default sensor loader for image (used when no sensor loader is specified)
     """
 
     def check_conf(self, conf):
@@ -55,26 +55,20 @@ class BasicSensorLoader(SensorLoaderTemplate):
             overloaded_conf = {}
             image_path = make_relative_path_absolute(conf, self.config_dir)
             overloaded_conf["path"] = image_path
-            overloaded_conf["loader"] = "basic"
-            if self.input_type == "image":
-                overloaded_conf[sens_cst.INPUT_NODATA] = 0
-            else:
-                overloaded_conf[sens_cst.INPUT_NODATA] = None
+            overloaded_conf["loader"] = "basic_image"
+            overloaded_conf[sens_cst.INPUT_NODATA] = 0
         elif isinstance(conf, dict):
             overloaded_conf = conf.copy()
             image_path = make_relative_path_absolute(
                 conf["path"], self.config_dir
             )
             overloaded_conf["path"] = image_path
-            overloaded_conf["loader"] = conf.get("loader", "basic")
-            if self.input_type == "image":
-                overloaded_conf[sens_cst.INPUT_NODATA] = conf.get(
-                    sens_cst.INPUT_NODATA, 0
-                )
-            else:
-                overloaded_conf[sens_cst.INPUT_NODATA] = None
+            overloaded_conf["loader"] = conf.get("loader", "basic_image")
+            overloaded_conf[sens_cst.INPUT_NODATA] = conf.get(
+                sens_cst.INPUT_NODATA, 0
+            )
         else:
-            raise TypeError(f"Input {self.input_type} is not a string ot dict")
+            raise TypeError(f"Input {conf} is not a string ot dict")
 
         sensor_schema = {"loader": str, "path": str, "no_data": Or(None, int)}
 
@@ -89,7 +83,7 @@ class BasicSensorLoader(SensorLoaderTemplate):
         Transform input configuration to pivot format and store it
         """
         pivot_config = {
-            "loader": "pivot",
+            "loader": "pivot_image",
             "main_file": self.used_config["path"],
         }
         pivot_config["bands"] = {}
@@ -102,7 +96,7 @@ class BasicSensorLoader(SensorLoaderTemplate):
                 "band": band_id,
             }
         pivot_config["texture_bands"] = None
-        pivot_sensor_loader = PivotSensorLoader(
-            pivot_config, self.input_type, self.config_dir
+        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,121 @@
+# !/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.sensor_loaders.sensor_loader import SensorLoader
+from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
+    SensorLoaderTemplate,
+)
+
+
+@SensorLoader.register("pivot_classif")
+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
+        """
+        default_filling = {
+            "fill_with_geoid": "b0",
+            "interpolate_from_borders": "b1",
+            "fill_with_endogenous_dem": "b2",
+            "fill_with_exogenous_dem": "b3",
+        }
+        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 size"
+                        "but are in the same image".format(
+                            b0_transform,
+                            band_transform,
+                        )
+                    )
+        overloaded_conf["main_file"] = overloaded_conf["bands"]["b0"]["path"]
+        overloaded_conf["filling"] = conf.get("filling", default_filling)
+        overloaded_conf["texture_bands"] = conf.get("texture_bands", None)
+        if overloaded_conf["texture_bands"] is not None:
+            for texture_band in overloaded_conf["texture_bands"]:
+                if texture_band not in overloaded_conf["bands"]:
+                    raise RuntimeError(
+                        "Texture band {} not found in bands {} "
+                        "of sensor image".format(
+                            texture_band, overloaded_conf["bands"]
+                        )
+                    )
+
+        sensor_schema = {
+            "loader": str,
+            "main_file": str,
+            "bands": dict,
+            "filling": dict,
+            "texture_bands": Or(None, [str]),
+        }
+
+        # 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_sensor_loader.py → pivot_image_loader.py}

@@ -19,7 +19,7 @@
 # limitations under the License.
 #
 """
-this module contains the PivotSensorLoader class.
+this module contains the PivotImageSensorLoader class.
 """
 
 from json_checker import Checker, Or
@@ -33,10 +33,10 @@ from cars.pipelines.parameters.sensor_loaders.sensor_loader_template import (
 )
 
 
-@SensorLoader.register("pivot")
-class PivotSensorLoader(SensorLoaderTemplate):
+@SensorLoader.register("pivot_image")
+class PivotImageSensorLoader(SensorLoaderTemplate):
     """
-    Pivot sensor loader : used by CARS to read inputs
+    Pivot image sensor loader : used by CARS to read inputs
     """
 
     def check_conf(self, conf):
@@ -59,7 +59,7 @@ class PivotSensorLoader(SensorLoaderTemplate):
         # Check consistency between files
         b0_path = overloaded_conf["bands"]["b0"]["path"]
         b0_size = inputs.rasterio_get_size(b0_path)
-        b0_transform = 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"]
@@ -71,7 +71,7 @@ class PivotSensorLoader(SensorLoaderTemplate):
                 )
             if band_path != b0_path:
                 band_size = inputs.rasterio_get_size(band_path)
-                band_transform = 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"
@@ -85,15 +85,7 @@ class PivotSensorLoader(SensorLoaderTemplate):
                             band_transform,
                         )
                     )
-        overloaded_conf["main_file"] = conf.get("main_file", None)
-        if overloaded_conf["main_file"] is None:
-            overloaded_conf["main_file"] = overloaded_conf["bands"]["b0"][
-                "path"
-            ]
-        else:
-            overloaded_conf["main_file"] = make_relative_path_absolute(
-                overloaded_conf["main_file"], self.config_dir
-            )
+        overloaded_conf["main_file"] = overloaded_conf["bands"]["b0"]["path"]
         overloaded_conf["texture_bands"] = conf.get("texture_bands", None)
         if overloaded_conf["texture_bands"] is not None:
             for texture_band in overloaded_conf["texture_bands"]:
@@ -105,12 +97,9 @@ class PivotSensorLoader(SensorLoaderTemplate):
                         )
                     )
 
-        if self.input_type == "image":
-            overloaded_conf[sens_cst.INPUT_NODATA] = conf.get(
-                sens_cst.INPUT_NODATA, 0
-            )
-        else:
-            overloaded_conf[sens_cst.INPUT_NODATA] = None
+        overloaded_conf[sens_cst.INPUT_NODATA] = conf.get(
+            sens_cst.INPUT_NODATA, 0
+        )
 
         sensor_schema = {
             "loader": str,

cars/pipelines/parameters/sensor_loaders/sensor_loader.py

@@ -38,9 +38,7 @@ class SensorLoader:
     # sensor loaders
     available_loaders = {}
 
-    def __new__(
-        cls, app_name: str, cfg: dict, input_type: str, config_dir: str
-    ):
+    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
@@ -51,10 +49,10 @@ class SensorLoader:
         :type cfg: dictionary
         """
 
-        return cls.create_app(app_name, cfg, input_type, config_dir)
+        return cls.create_app(app_name, cfg, config_dir)
 
     @classmethod
-    def create_app(cls, name: str, cfg: dict, input_type: str, config_dir: str):
+    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
@@ -72,7 +70,7 @@ class SensorLoader:
         except KeyError:
             logging.error("No sensor loader named {0} supported".format(name))
             return None
-        loader = loader_class(cfg, input_type, config_dir)
+        loader = loader_class(cfg, config_dir)
         return loader
 
     @classmethod

cars/pipelines/parameters/sensor_loaders/sensor_loader_template.py

@@ -30,14 +30,12 @@ class SensorLoaderTemplate:
     Class for general specification of a sensor loader
     """
 
-    def __init__(self, conf, input_type, config_dir):
+    def __init__(self, conf, config_dir):
         """
         Init function of SensorLoaderTemplate
 
         :param conf: configuration for sensor loader
-        :param input_type: type of input : image or classification
         """
-        self.input_type = input_type
         self.config_dir = config_dir
         self.used_config = self.check_conf(conf)
 

cars/pipelines/pipeline_template.py

@@ -91,14 +91,12 @@ class PipelineTemplate(metaclass=ABCMeta):  # pylint: disable=R0903
         """
 
     @abstractmethod
-    def check_output(self, conf, pipeline):
+    def check_output(self, conf):
         """
         Check the output given
 
         :param conf: configuration of output
         :type conf: dict
-        :param pipeline: name of corresponding pipeline
-        :type pipeline_name: str
 
         :return overloader output
         :rtype : dict