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

cars/pipelines/parameters/sensor_inputs.py

@@ -24,13 +24,15 @@ 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
 
 # CARS imports
-from cars.core import inputs, preprocessing, roi_tools
+from cars.core import inputs, preprocessing, projection, roi_tools
 from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.utils import make_relative_path_absolute
 from cars.pipelines.parameters import (
@@ -42,14 +44,14 @@ from cars.pipelines.parameters.sensor_loaders.sensor_loader import SensorLoader
 CARS_GEOID_PATH = "geoid/egm96.grd"  # Path in cars package (pkg)
 
 
-def sensors_check_inputs(conf, config_json_dir=None):  # noqa: C901
+def sensors_check_inputs(conf, config_dir=None):  # noqa: C901
     """
     Check the inputs given
 
     :param conf: configuration of inputs
     :type conf: dict
-    :param config_json_dir: path to dir containing json
-    :type config_json_dir: str
+    :param config_dir: path to dir containing json
+    :type config_dir: str
     """
 
     overloaded_conf = conf.copy()
@@ -74,7 +76,7 @@ def sensors_check_inputs(conf, config_json_dir=None):  # noqa: C901
     checker_inputs = Checker(inputs_schema)
     checker_inputs.validate(overloaded_conf)
 
-    check_sensors(conf, overloaded_conf, config_json_dir)
+    check_sensors(conf, overloaded_conf, config_dir)
 
     # Check srtm dir
     check_srtm(overloaded_conf[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH])
@@ -82,7 +84,7 @@ def sensors_check_inputs(conf, config_json_dir=None):  # noqa: C901
     return overloaded_conf
 
 
-def check_sensors(conf, overloaded_conf, config_json_dir=None):  # noqa: C901
+def check_sensors(conf, overloaded_conf, config_dir=None):  # noqa: C901
     """
     Check sensors
 
@@ -116,9 +118,7 @@ def check_sensors(conf, overloaded_conf, config_json_dir=None):  # noqa: C901
             loader_name = image.get("loader", "basic")
         else:
             raise TypeError(f"Image {image} is not of type str or dict")
-        image_loader = SensorLoader(
-            loader_name, image, "image", config_json_dir
-        )
+        image_loader = SensorLoader(loader_name, image, "image", config_dir)
         image_as_pivot_format = (
             image_loader.get_pivot_format()  # pylint: disable=E1101
         )
@@ -153,7 +153,7 @@ def check_sensors(conf, overloaded_conf, config_json_dir=None):  # noqa: C901
             else:
                 raise TypeError(f"Classif {classif} is not of type str or dict")
             classif_loader = SensorLoader(
-                loader_name, classif, "classification", config_json_dir
+                loader_name, classif, "classification", config_dir
             )
             classif_as_pivot_format = (
                 classif_loader.get_pivot_format()  # pylint: disable=E1101
@@ -172,8 +172,8 @@ def check_sensors(conf, overloaded_conf, config_json_dir=None):  # noqa: C901
         )
 
     # Modify to absolute path
-    if config_json_dir is not None:
-        modify_to_absolute_path(config_json_dir, overloaded_conf)
+    if config_dir is not None:
+        modify_to_absolute_path(config_dir, overloaded_conf)
 
     # Check image, msk and color size compatibility
     for sensor_image_key in overloaded_conf[sens_cst.SENSORS]:
@@ -220,8 +220,8 @@ def check_sensors(conf, overloaded_conf, config_json_dir=None):  # noqa: C901
             raise RuntimeError("{} not in sensors images".format(key2))
 
     # Modify to absolute path
-    if config_json_dir is not None:
-        modify_to_absolute_path(config_json_dir, overloaded_conf)
+    if config_dir is not None:
+        modify_to_absolute_path(config_dir, overloaded_conf)
     else:
         logging.debug(
             "path of config file was not given,"
@@ -237,6 +237,65 @@ def check_sensors(conf, overloaded_conf, config_json_dir=None):  # noqa: C901
     return overloaded_conf
 
 
+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):
     """
     Check the geometry plugin with inputs
@@ -255,11 +314,40 @@ 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
+        )
+    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,
         )
     )
 
@@ -282,7 +370,7 @@ 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
     )
 
     # Check dem is big enough
@@ -346,11 +434,12 @@ def check_geometry_plugin(conf_inputs, conf_geom_plugin):
         geom_plugin_without_dem_and_geoid,
         geom_plugin_with_dem_and_geoid,
         dem_generation_roi_poly,
+        scaling_coeff,
     )
 
 
 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, scaling_coeff=1
 ):
     """
     Generate geometry plugin with dem and geoid
@@ -358,6 +447,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
     """
@@ -383,6 +474,7 @@ def generate_geometry_plugin_with_dem(
         pairs_for_roi = None
 
     # Initialize a second geometry plugin with elevation information
+
     geom_plugin_with_dem_and_geoid = (
         AbstractGeometry(  # pylint: disable=abstract-class-instantiated
             conf_geom_plugin,
@@ -390,18 +482,19 @@ 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,
         )
     )
 
     return geom_plugin_with_dem_and_geoid
 
 
-def modify_to_absolute_path(config_json_dir, overloaded_conf):
+def modify_to_absolute_path(config_dir, overloaded_conf):
     """
     Modify input file path to absolute path
 
-    :param config_json_dir: directory of the json configuration
-    :type config_json_dir: str
+    :param config_dir: directory of the json configuration
+    :type config_dir: str
     :param overloaded_conf: overloaded configuration json
     :dict overloaded_conf: dict
     """
@@ -414,11 +507,11 @@ def modify_to_absolute_path(config_json_dir, overloaded_conf):
         ]:
             if isinstance(sensor_image[tag], dict):
                 sensor_image[tag]["path"] = make_relative_path_absolute(
-                    sensor_image[tag]["path"], config_json_dir
+                    sensor_image[tag]["path"], config_dir
                 )
             elif sensor_image[tag] is not None:
                 sensor_image[tag] = make_relative_path_absolute(
-                    sensor_image[tag], config_json_dir
+                    sensor_image[tag], config_dir
                 )
         for tag in [
             sens_cst.INPUT_IMG,
@@ -429,14 +522,14 @@ def modify_to_absolute_path(config_json_dir, overloaded_conf):
                     sensor_image[tag]["bands"][band]["path"] = (
                         make_relative_path_absolute(
                             sensor_image[tag]["bands"][band]["path"],
-                            config_json_dir,
+                            config_dir,
                         )
                     )
 
     if overloaded_conf[sens_cst.ROI] is not None:
         if isinstance(overloaded_conf[sens_cst.ROI], str):
             overloaded_conf[sens_cst.ROI] = make_relative_path_absolute(
-                overloaded_conf[sens_cst.ROI], config_json_dir
+                overloaded_conf[sens_cst.ROI], config_dir
             )
 
     for tag in [sens_cst.DEM_PATH, sens_cst.GEOID]:
@@ -447,7 +540,7 @@ def modify_to_absolute_path(config_json_dir, overloaded_conf):
                 overloaded_conf[sens_cst.INITIAL_ELEVATION][tag] = (
                     make_relative_path_absolute(
                         overloaded_conf[sens_cst.INITIAL_ELEVATION][tag],
-                        config_json_dir,
+                        config_dir,
                     )
                 )
 

cars/pipelines/parameters/sensor_loaders/basic_sensor_loader.py

@@ -53,7 +53,7 @@ class BasicSensorLoader(SensorLoaderTemplate):
         """
         if isinstance(conf, str):
             overloaded_conf = {}
-            image_path = make_relative_path_absolute(conf, self.json_dir)
+            image_path = make_relative_path_absolute(conf, self.config_dir)
             overloaded_conf["path"] = image_path
             overloaded_conf["loader"] = "basic"
             if self.input_type == "image":
@@ -63,7 +63,7 @@ class BasicSensorLoader(SensorLoaderTemplate):
         elif isinstance(conf, dict):
             overloaded_conf = conf.copy()
             image_path = make_relative_path_absolute(
-                conf["path"], self.json_dir
+                conf["path"], self.config_dir
             )
             overloaded_conf["path"] = image_path
             overloaded_conf["loader"] = conf.get("loader", "basic")
@@ -103,6 +103,6 @@ class BasicSensorLoader(SensorLoaderTemplate):
             }
         pivot_config["texture_bands"] = None
         pivot_sensor_loader = PivotSensorLoader(
-            pivot_config, self.input_type, self.json_dir
+            pivot_config, self.input_type, self.config_dir
         )
         self.pivot_format = pivot_sensor_loader.get_pivot_format()

cars/pipelines/parameters/sensor_loaders/pivot_sensor_loader.py

@@ -53,7 +53,7 @@ class PivotSensorLoader(SensorLoaderTemplate):
         for band in overloaded_conf["bands"]:
             overloaded_conf["bands"][band]["path"] = (
                 make_relative_path_absolute(
-                    overloaded_conf["bands"][band]["path"], self.json_dir
+                    overloaded_conf["bands"][band]["path"], self.config_dir
                 )
             )
         # Check consistency between files
@@ -92,7 +92,7 @@ class PivotSensorLoader(SensorLoaderTemplate):
             ]
         else:
             overloaded_conf["main_file"] = make_relative_path_absolute(
-                overloaded_conf["main_file"], self.json_dir
+                overloaded_conf["main_file"], self.config_dir
             )
         overloaded_conf["texture_bands"] = conf.get("texture_bands", None)
         if overloaded_conf["texture_bands"] is not None:

cars/pipelines/parameters/sensor_loaders/sensor_loader.py

@@ -39,7 +39,7 @@ class SensorLoader:
     available_loaders = {}
 
     def __new__(
-        cls, app_name: str, cfg: dict, input_type: str, config_json_dir: str
+        cls, app_name: str, cfg: dict, input_type: str, config_dir: str
     ):
         """
         Return the instance of sensor loader associated with the sensor loader
@@ -51,12 +51,10 @@ class SensorLoader:
         :type cfg: dictionary
         """
 
-        return cls.create_app(app_name, cfg, input_type, config_json_dir)
+        return cls.create_app(app_name, cfg, input_type, config_dir)
 
     @classmethod
-    def create_app(
-        cls, name: str, cfg: dict, input_type: str, config_json_dir: str
-    ):
+    def create_app(cls, name: str, cfg: dict, input_type: str, config_dir: str):
         """
         Factory command to create the sensor loader
         Return the instance of sensor loader associated with the sensor loader
@@ -74,7 +72,7 @@ class SensorLoader:
         except KeyError:
             logging.error("No sensor loader named {0} supported".format(name))
             return None
-        loader = loader_class(cfg, input_type, config_json_dir)
+        loader = loader_class(cfg, input_type, config_dir)
         return loader
 
     @classmethod

cars/pipelines/parameters/sensor_loaders/sensor_loader_template.py

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

cars/pipelines/pipeline.py

@@ -43,7 +43,7 @@ class Pipeline:
         cls,
         pipeline_name: str,
         cfg: Dict[str, Union[str, int]],
-        config_json_dir,
+        config_dir,
     ):
         """
         Return the instance of pipeline associated with the pipeline
@@ -53,15 +53,15 @@ class Pipeline:
         :type pipeline_name: str
         :param cfg: configuration {'matching_cost_method': value}
         :type cfg: dictionary
-        :param config_json_dir: path to dir containing json
-        :type config_json_dir: str
+        :param config_dir: path to dir containing json or yaml file
+        :type config_dir: str
         """
 
-        return cls.create_pipeline(pipeline_name, cfg, config_json_dir)
+        return cls.create_pipeline(pipeline_name, cfg, config_dir)
 
     @classmethod
     def create_pipeline(
-        cls, name: str, cfg: Dict[str, Union[str, int]], config_json_dir
+        cls, name: str, cfg: Dict[str, Union[str, int]], config_dir
     ):
         """Factory command to create the pipeline
         Return the instance of pipeline associated with the pipeline
@@ -71,8 +71,8 @@ class Pipeline:
         :type pipeline_name: str
         :param cfg: cars input configuration
         :type cfg: dictionary
-        :param config_json_dir: path to dir containing json
-        :type config_json_dir: str
+        :param config_dir: path to dir containing json
+        :type config_dir: str
         """
 
         pipeline = None
@@ -85,7 +85,7 @@ class Pipeline:
                 "No pipeline named {0} supported".format(name)
             ) from kerr
 
-        pipeline = pipeline_class(cfg, config_json_dir)
+        pipeline = pipeline_class(cfg, config_dir)
 
         return pipeline