cars 1.0.0a2__cp313-cp313-win_amd64.whl → 1.0.0a3__cp313-cp313-win_amd64.whl

cars/pipelines/parameters/advanced_parameters.py

@@ -60,6 +60,10 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         adv_cst.SAVE_INTERMEDIATE_DATA, False
     )
 
+    overloaded_conf[adv_cst.LAND_COVER_MAP] = conf.get(
+        adv_cst.LAND_COVER_MAP, "global_land_cover_map.tif"
+    )
+
     overloaded_conf[adv_cst.KEEP_LOW_RES_DIR] = conf.get(
         adv_cst.KEEP_LOW_RES_DIR, True
     )
@@ -68,6 +72,10 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         adv_cst.DEBUG_WITH_ROI, False
     )
 
+    overloaded_conf[adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING] = conf.get(
+        adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING, "config_mapping.json"
+    )
+
     overloaded_conf[adv_cst.PHASING] = conf.get(adv_cst.PHASING, None)
 
     overloaded_conf[adv_cst.EPIPOLAR_RESOLUTIONS] = conf.get(
@@ -144,6 +152,7 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
                     ]
                 )
 
+    scaling_coeff = None
     if inputs[sens_cst.SENSORS] is not None:
         # Check geometry plugin and overwrite geomodel in conf inputs
         (
@@ -152,10 +161,13 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
             geom_plugin_without_dem_and_geoid,
             geom_plugin_with_dem_and_geoid,
             dem_generation_roi,
+            scaling_coeff,
         ) = sensor_inputs.check_geometry_plugin(
             inputs, conf.get(adv_cst.GEOMETRY_PLUGIN, None)
         )
     elif depth_cst.DEPTH_MAPS in inputs or dsm_cst.DSMS in inputs:
+        # assume the input comes from 0.5m sensor images
+        scaling_coeff = 1
         # If there's an initial elevation with
         # point clouds as inputs, generate a plugin (used in dsm_filling)
         (
@@ -182,6 +194,8 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         adv_cst.DSM_MERGING_TILE_SIZE: And(int, lambda x: x > 0),
         adv_cst.TEXTURE_BANDS: list,
         adv_cst.EPIPOLAR_RESOLUTIONS: Or(int, list),
+        adv_cst.LAND_COVER_MAP: str,
+        adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING: str,
     }
     if check_epipolar_a_priori:
         schema[adv_cst.USE_EPIPOLAR_A_PRIORI] = bool
@@ -245,6 +259,9 @@ def check_advanced_parameters(inputs, conf, check_epipolar_a_priori=True):
         geom_plugin_without_dem_and_geoid,
         geom_plugin_with_dem_and_geoid,
         dem_generation_roi,
+        scaling_coeff,
+        overloaded_conf[adv_cst.LAND_COVER_MAP],
+        overloaded_conf[adv_cst.CLASSIFICATION_TO_CONFIGURATION_MAPPING],
     )
 
 

cars/pipelines/parameters/advanced_parameters_constants.py

@@ -27,6 +27,10 @@ SAVE_INTERMEDIATE_DATA = "save_intermediate_data"
 KEEP_LOW_RES_DIR = "keep_low_res_dir"
 PHASING = "phasing"
 DEBUG_WITH_ROI = "debug_with_roi"
+LAND_COVER_MAP = "land_cover_map"
+CLASSIFICATION_TO_CONFIGURATION_MAPPING = (
+    "classification_to_configuration_mapping"
+)
 
 USE_EPIPOLAR_A_PRIORI = "use_epipolar_a_priori"
 EPIPOLAR_A_PRIORI = "epipolar_a_priori"

cars/pipelines/parameters/output_parameters.py

@@ -26,7 +26,7 @@ This module contains the output definition
 import logging
 import os
 
-from json_checker import Checker, Or
+from json_checker import And, Checker, Or
 from pyproj import CRS
 
 import cars.core.constants as cst
@@ -34,12 +34,29 @@ from cars.core.utils import safe_makedirs
 from cars.pipelines.parameters import output_constants
 
 
-def check_output_parameters(conf):
+def is_valid_epsg(epsg) -> bool:
+    """
+    Check if the given EPSG code is valid using pyproj.
+    """
+    if epsg is None:
+        return True
+
+    try:
+        # Try creating a CRS
+        CRS(f"EPSG:{epsg}")
+        return True
+    except Exception:
+        return False
+
+
+def check_output_parameters(conf, scaling_coeff):
     """
     Check the output json configuration and fill in default values
 
     :param conf: configuration of output
     :type conf: dict
+    :param scaling_coeff: scaling factor for resolution
+    :type scaling_coeff: float
     :param pipeline_name: name of corresponding pipeline
     :type pipeline_name: str
     """
@@ -64,15 +81,34 @@ def check_output_parameters(conf):
             raise RuntimeError("Unknown product level {}".format(level))
 
     overloaded_conf[output_constants.OUT_GEOID] = overloaded_conf.get(
-        output_constants.OUT_GEOID, False
+        output_constants.OUT_GEOID, True
     )
     overloaded_conf[output_constants.EPSG] = overloaded_conf.get(
         output_constants.EPSG, None
     )
 
-    overloaded_conf[output_constants.RESOLUTION] = overloaded_conf.get(
-        output_constants.RESOLUTION, 0.5
-    )
+    resolution = None
+    overloaded_scaling_coeff = scaling_coeff
+    if output_constants.RESOLUTION in overloaded_conf:
+        resolution = overloaded_conf[output_constants.RESOLUTION]
+        # update scaling coeff so the parameters are right for the dsm
+        # overloaded_scaling_coeff = 2*resolution
+
+        if resolution < 0.5 * scaling_coeff:
+            logging.warning(
+                "The requested DSM resolution of "
+                f"{overloaded_conf[output_constants.RESOLUTION]} seems "
+                "too low for the sensor images' resolution. "
+                "The pipeline will still continue with it."
+            )
+
+    else:
+        resolution = float(0.5 * scaling_coeff)
+        logging.warning(
+            "The resolution of the output DSM will be " f"{resolution} meters. "
+        )
+
+    overloaded_conf[output_constants.RESOLUTION] = resolution
 
     overloaded_conf[output_constants.SAVE_BY_PAIR] = overloaded_conf.get(
         output_constants.SAVE_BY_PAIR, False
@@ -145,7 +181,7 @@ def check_output_parameters(conf):
         output_constants.OUT_DIRECTORY: str,
         output_constants.PRODUCT_LEVEL: list,
         output_constants.OUT_GEOID: Or(bool, str),
-        output_constants.EPSG: Or(int, None),
+        output_constants.EPSG: And(Or(int, str, None), is_valid_epsg),
         output_constants.RESOLUTION: Or(int, float),
         output_constants.SAVE_BY_PAIR: bool,
         output_constants.AUXILIARY: dict,
@@ -181,7 +217,7 @@ def check_output_parameters(conf):
                     + "fixed according to the epsg"
                 )
 
-    return overloaded_conf
+    return overloaded_conf, overloaded_scaling_coeff
 
 
 def intialize_product_index(orchestrator, product_levels, input_pairs):

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 (
@@ -235,6 +237,65 @@ def check_sensors(conf, overloaded_conf, config_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
@@ -253,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,
         )
     )
 
@@ -280,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
@@ -344,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
@@ -356,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
     """
@@ -389,6 +482,7 @@ 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,
         )
     )