cars 1.0.0a2__cp312-cp312-win_amd64.whl → 1.0.0a4__cp312-cp312-win_amd64.whl

cars/pipelines/parameters/sensor_inputs.py

@@ -24,18 +24,18 @@ Used for full_res and low_res pipelines
 """
 
 import logging
+import math
 import os
 
+import numpy as np
 import rasterio as rio
-from json_checker import Checker, OptionalKey, Or
+from json_checker import Checker, Or
 
 # CARS imports
-from cars.core import inputs, preprocessing, roi_tools
+from cars.core import inputs, projection
 from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.utils import make_relative_path_absolute
-from cars.pipelines.parameters import (
-    depth_map_inputs_constants as depth_map_cst,
-)
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
 from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
 
@@ -68,7 +68,6 @@ def sensors_check_inputs(conf, config_dir=None):  # noqa: C901
         sens_cst.PAIRING: Or([[str]], None),
         sens_cst.INITIAL_ELEVATION: Or(str, dict, None),
         sens_cst.ROI: Or(str, dict, None),
-        OptionalKey(depth_map_cst.DEPTH_MAPS): dict,
     }
 
     checker_inputs = Checker(inputs_schema)
@@ -111,12 +110,12 @@ def check_sensors(conf, overloaded_conf, config_dir=None):  # noqa: C901
             sens_cst.INPUT_IMG, None
         )
         if isinstance(image, str):
-            loader_name = "basic"
+            loader_name = "basic_image"
         elif isinstance(image, dict):
-            loader_name = image.get("loader", "basic")
+            loader_name = image.get("loader", "basic_image")
         else:
             raise TypeError(f"Image {image} is not of type str or dict")
-        image_loader = SensorLoader(loader_name, image, "image", config_dir)
+        image_loader = SensorLoader(loader_name, image, config_dir)
         image_as_pivot_format = (
             image_loader.get_pivot_format()  # pylint: disable=E1101
         )
@@ -145,14 +144,12 @@ def check_sensors(conf, overloaded_conf, config_dir=None):  # noqa: C901
         )
         if classif is not None:
             if isinstance(classif, str):
-                loader_name = "basic"
+                loader_name = "basic_classif"
             elif isinstance(classif, dict):
-                loader_name = classif.get("loader", "basic")
+                loader_name = classif.get("loader", "basic_classif")
             else:
                 raise TypeError(f"Classif {classif} is not of type str or dict")
-            classif_loader = SensorLoader(
-                loader_name, classif, "classification", config_dir
-            )
+            classif_loader = SensorLoader(loader_name, classif, config_dir)
             classif_as_pivot_format = (
                 classif_loader.get_pivot_format()  # pylint: disable=E1101
             )
@@ -235,7 +232,68 @@ def check_sensors(conf, overloaded_conf, config_dir=None):  # noqa: C901
     return overloaded_conf
 
 
-def check_geometry_plugin(conf_inputs, conf_geom_plugin):
+def get_sensor_resolution(
+    geom_plugin, sensor_path, geomodel, target_epsg=32631
+):
+    """
+    Estimate the sensor image resolution in meters per pixel
+    using geolocation of 3 corners of the image.
+
+    :param geom_plugin: geometry plugin instance
+    :param sensor_path: path to the sensor image
+    :type sensor_path: dict
+    :param geomodel: geometric model for the sensor image
+    :param target_epsg: target EPSG code for projection
+    :type target_epsg: int
+    :return: average resolution in meters/pixel along x and y
+    :rtype: float
+    """
+    width, height = inputs.rasterio_get_size(sensor_path[sens_cst.MAIN_FILE])
+
+    upper_left = (0.5, 0.5)
+    upper_right = (width - 0.5, 0.5)
+    bottom_left = (0.5, height - 0.5)
+
+    # get geodetic coordinates
+    lat_ul, lon_ul, _ = geom_plugin.direct_loc(
+        sensor_path[sens_cst.MAIN_FILE],
+        geomodel,
+        np.array([upper_left[0]]),
+        np.array([upper_left[1]]),
+    )
+    lat_ur, lon_ur, _ = geom_plugin.direct_loc(
+        sensor_path[sens_cst.MAIN_FILE],
+        geomodel,
+        np.array([upper_right[0]]),
+        np.array([upper_right[1]]),
+    )
+    lat_bl, lon_bl, _ = geom_plugin.direct_loc(
+        sensor_path[sens_cst.MAIN_FILE],
+        geomodel,
+        np.array([bottom_left[0]]),
+        np.array([bottom_left[1]]),
+    )
+
+    coords_ll = np.array(
+        [[lon_ul, lat_ul, 0], [lon_ur, lat_ur, 0], [lon_bl, lat_bl, 0]]
+    )
+
+    # Convert to target CRS
+    coords_xy = projection.point_cloud_conversion(coords_ll, 4326, target_epsg)
+
+    diff_x = np.linalg.norm(coords_xy[1] - coords_xy[0])  # UL to UR (width)
+    diff_y = np.linalg.norm(coords_xy[2] - coords_xy[0])  # UL to BL (height)
+
+    # resolution in meters per pixel
+    res_x = diff_x / (width - 1)
+    res_y = diff_y / (height - 1)
+
+    return (res_x + res_y) / 2
+
+
+def check_geometry_plugin(
+    conf_inputs, conf_geom_plugin, epipolar_resolution, output_dem_dir
+):
     """
     Check the geometry plugin with inputs
 
@@ -245,6 +303,8 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
     :type conf_advanced: type
     :param conf_geom_plugin: name of geometry plugin
     :type conf_geom_plugin: str
+    :param epipolar_resolution: epipolar resolution
+    :type epipolar_resolution: int
     :return: overload inputs conf
              overloaded geometry plugin conf
              geometry plugin without dem
@@ -253,11 +313,41 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
     if conf_geom_plugin is None:
         conf_geom_plugin = "SharelocGeometry"
 
+    # Initialize a temporary plugin, to get the product's resolution
+    temp_geom_plugin = (
+        AbstractGeometry(  # pylint: disable=abstract-class-instantiated
+            conf_geom_plugin,
+            default_alt=sens_cst.CARS_DEFAULT_ALT,
+        )
+    )
+    average_sensor_resolution = 0
+    for _, sensor_image in conf_inputs[sens_cst.SENSORS].items():
+        sensor = sensor_image[sens_cst.INPUT_IMG]
+        geomodel = sensor_image[sens_cst.INPUT_GEO_MODEL]
+        (
+            sensor,
+            geomodel,
+        ) = temp_geom_plugin.check_product_consistency(sensor, geomodel)
+        average_sensor_resolution += (
+            get_sensor_resolution(temp_geom_plugin, sensor, geomodel)
+            * epipolar_resolution
+        )
+    average_sensor_resolution /= len(conf_inputs[sens_cst.SENSORS])
+    # approximate resolution to the highest digit:
+    #  0.47 -> 0.5
+    #  7.52 -> 8
+    #  12.9 -> 10
+    nb_digits = int(math.floor(math.log10(abs(average_sensor_resolution))))
+    scaling_coeff = round(average_sensor_resolution, -nb_digits)
+    # make it so 0.5 (CO3D) is the baseline for parameters
+    scaling_coeff *= 2
+
     # Initialize the desired geometry plugin without elevation information
     geom_plugin_without_dem_and_geoid = (
         AbstractGeometry(  # pylint: disable=abstract-class-instantiated
             conf_geom_plugin,
             default_alt=sens_cst.CARS_DEFAULT_ALT,
+            scaling_coeff=scaling_coeff,
         )
     )
 
@@ -280,75 +370,29 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
         ] = geomodel
 
     geom_plugin_with_dem_and_geoid = generate_geometry_plugin_with_dem(
-        conf_geom_plugin, conf_inputs
+        conf_geom_plugin,
+        conf_inputs,
+        scaling_coeff=scaling_coeff,
+        output_dem_dir=output_dem_dir,
     )
 
-    # Check dem is big enough
-    dem_generation_roi_poly = None
-    needed_dem_roi = geom_plugin_with_dem_and_geoid.dem_roi
-    needed_dem_roi_epsg = geom_plugin_with_dem_and_geoid.dem_roi_epsg
-    if needed_dem_roi is not None:
-        needed_dem_roi_poly = roi_tools.bounds_to_poly(needed_dem_roi)
-        # convert to 4326 roi
-        dem_generation_roi_poly = preprocessing.compute_roi_poly(
-            needed_dem_roi_poly, needed_dem_roi_epsg, 4326
-        )
-
-        if (
-            conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-            is not None
-        ):
-            # get dem total roi
-            total_input_roi_poly = roi_tools.bounds_to_poly(
-                inputs.rasterio_get_bounds(
-                    conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-                )
-            )
-            total_input_roi_epsg = inputs.rasterio_get_epsg_code(
-                conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-            )
-            if not isinstance(total_input_roi_epsg, int):
-                total_input_roi_epsg = total_input_roi_epsg.to_epsg()
-            total_input_roi_poly = preprocessing.compute_roi_poly(
-                total_input_roi_poly, total_input_roi_epsg, 4326
-            )
-
-            # if needed roi not inside dem, raise error
-            if not total_input_roi_poly.contains_properly(
-                dem_generation_roi_poly
-            ):
-                base_message = (
-                    "Given initial elevation ROI is not covering needed ROI: "
-                    " EPSG:4326, ROI: {}".format(dem_generation_roi_poly.bounds)
-                )
-
-                if total_input_roi_poly.intersects(dem_generation_roi_poly):
-                    logging.warning(
-                        "{}. Only a part of it intersects. "
-                        "Errors might occur".format(base_message)
-                    )
-                else:
-                    # Exit, Error is certain to occur
-                    raise RuntimeError(base_message)
-
-    else:
-        logging.warning(
-            "Current geometry plugin doesnt compute dem roi needed "
-            "for later computations. Errors related to unsufficient "
-            "dem roi might occur."
-        )
-
     return (
         overloaded_conf_inputs,
         conf_geom_plugin,
         geom_plugin_without_dem_and_geoid,
         geom_plugin_with_dem_and_geoid,
-        dem_generation_roi_poly,
+        scaling_coeff,
     )
 
 
+# pylint: disable=too-many-positional-arguments
 def generate_geometry_plugin_with_dem(
-    conf_geom_plugin, conf_inputs, dem=None, crop_dem=True
+    conf_geom_plugin,
+    conf_inputs,
+    dem=None,
+    crop_dem=True,
+    output_dem_dir=None,
+    scaling_coeff=1,
 ):
     """
     Generate geometry plugin with dem and geoid
@@ -356,6 +400,8 @@ def generate_geometry_plugin_with_dem(
     :param conf_geom_plugin: plugin configuration
     :param conf_inputs: inputs configuration
     :param dem: dem to overide the one in inputs
+    :param scaling_coeff: scaling factor for resolution
+    :type scaling_coeff: float
 
     :return: geometry plugin object, with a dem
     """
@@ -389,6 +435,8 @@ def generate_geometry_plugin_with_dem(
             geoid=conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.GEOID],
             default_alt=sens_cst.CARS_DEFAULT_ALT,
             pairs_for_roi=pairs_for_roi,
+            scaling_coeff=scaling_coeff,
+            output_dem_dir=output_dem_dir,
         )
     )
 
@@ -644,6 +692,7 @@ def check_all_nbits_equal_one(nbits):
     return False
 
 
+@cars_profile(name="Generate inputs")
 def generate_inputs(conf, geometry_plugin):
     """
     Generate sensors inputs form inputs conf :

cars/pipelines/parameters/sensor_inputs_constants.py

@@ -34,8 +34,6 @@ CHECK_INPUTS = "check_inputs"
 ROI = "roi"
 GEOID = "geoid"
 DEM_PATH = "dem"
-ALTITUDE_DELTA_MIN = "altitude_delta_min"
-ALTITUDE_DELTA_MAX = "altitude_delta_max"
 
 INPUT_IMG = "image"
 INPUT_MSK = "mask"

cars/pipelines/parameters/sensor_loaders/__init__.py

@@ -22,6 +22,7 @@
 CARS application module init file
 """
 
-# Imports needed in order to register application for Application factory
-from .basic_sensor_loader import BasicSensorLoader  # noqa: F401
-from .pivot_sensor_loader import PivotSensorLoader  # noqa: F401
+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

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