cars 1.0.0a2__cp310-cp310-win_amd64.whl → 1.0.0a4__cp310-cp310-win_amd64.whl

cars/pipelines/parameters/depth_map_inputs.py

@@ -1,314 +0,0 @@
-#!/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 depth map inputs
-"""
-
-import logging
-
-from json_checker import Checker, Or
-
-import cars.pipelines.parameters.depth_map_inputs_constants as depth_map_cst
-
-# CARS imports
-from cars.core import constants as cst
-from cars.core import inputs
-from cars.core.geometry.abstract_geometry import AbstractGeometry
-from cars.core.utils import make_relative_path_absolute
-from cars.pipelines.parameters import sensor_inputs as sens_inp
-from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
-
-
-def check_depth_maps_inputs(conf, config_dir=None):
-    """
-    Check the inputs given
-
-    :param conf: configuration of inputs
-    :type conf: dict
-    :param config_dir: directory of used json, if
-        user filled paths with relative paths
-    :type config_dir: str
-
-    :return: overloader inputs
-    :rtype: dict
-    """
-
-    overloaded_conf = {}
-
-    # Overload some optional parameters
-    overloaded_conf[sens_cst.ROI] = conf.get(sens_cst.ROI, None)
-    overloaded_conf[depth_map_cst.DEPTH_MAPS] = {}
-
-    overloaded_conf[sens_cst.INITIAL_ELEVATION] = (
-        sens_inp.get_initial_elevation(
-            conf.get(sens_cst.INITIAL_ELEVATION, None)
-        )
-    )
-
-    overloaded_conf[sens_cst.SENSORS] = conf.get(sens_cst.SENSORS, None)
-
-    overloaded_conf[sens_cst.PAIRING] = conf.get(sens_cst.PAIRING, None)
-
-    # Validate inputs
-    inputs_schema = {
-        depth_map_cst.DEPTH_MAPS: dict,
-        sens_cst.ROI: Or(str, dict, None),
-        sens_cst.INITIAL_ELEVATION: Or(dict, None),
-        sens_cst.SENSORS: Or(dict, None),
-        sens_cst.PAIRING: Or([[str]], None),
-    }
-
-    checker_inputs = Checker(inputs_schema)
-    checker_inputs.validate(overloaded_conf)
-
-    # Validate depth maps
-
-    pc_schema = {
-        cst.X: str,
-        cst.Y: str,
-        cst.Z: str,
-        cst.EPI_Z_INF: Or(str, None),
-        cst.EPI_Z_SUP: Or(str, None),
-        cst.POINT_CLOUD_CLASSIF_KEY_ROOT: Or(str, None),
-        cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT: Or(str, None),
-        cst.POINT_CLOUD_CLR_KEY_ROOT: str,
-        cst.POINT_CLOUD_FILLING_KEY_ROOT: Or(str, None),
-        cst.POINT_CLOUD_MSK: Or(str, None),
-        cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT: Or(str, None),
-        cst.PC_EPSG: Or(str, int, None),
-    }
-    checker_pc = Checker(pc_schema)
-    for depth_map_key in conf[depth_map_cst.DEPTH_MAPS]:
-        # Get depth maps with default
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key] = {}
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.X] = conf[
-            depth_map_cst.DEPTH_MAPS
-        ][depth_map_key].get("x", None)
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Y] = conf[
-            depth_map_cst.DEPTH_MAPS
-        ][depth_map_key].get("y", None)
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Z] = conf[
-            depth_map_cst.DEPTH_MAPS
-        ][depth_map_key].get("z", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.EPI_Z_INF
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            cst.EPI_Z_INF, None
-        )
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.EPI_Z_SUP
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            cst.EPI_Z_SUP, None
-        )
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_CLR_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("texture", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_MSK
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("mask", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_CLASSIF_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            "classification", None
-        )
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get(
-            "performance_map", None
-        )
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_FILLING_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("filling", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("ambiguity", None)
-
-        overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-            cst.PC_EPSG
-        ] = conf[depth_map_cst.DEPTH_MAPS][depth_map_key].get("epsg", 4326)
-        # validate
-        checker_pc.validate(
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key]
-        )
-
-    # Modify to absolute path
-    if config_dir is not None:
-        modify_to_absolute_path(config_dir, overloaded_conf)
-    else:
-        logging.debug(
-            "path of config file was not given,"
-            "relative path are not transformed to absolute paths"
-        )
-
-    for depth_map_key in conf[depth_map_cst.DEPTH_MAPS]:
-        # check sizes
-        check_input_size(
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.X],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Y],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][cst.Z],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_MSK
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CLR_KEY_ROOT
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_CLASSIF_KEY_ROOT
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_FILLING_KEY_ROOT
-            ],
-            overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key][
-                cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
-            ],
-        )
-
-    # Check srtm dir
-    sens_inp.check_srtm(
-        overloaded_conf[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-    )
-
-    if sens_cst.SENSORS in conf and conf[sens_cst.SENSORS] is not None:
-        sens_inp.check_sensors(conf, overloaded_conf, config_dir)
-
-    return overloaded_conf
-
-
-def check_geometry_plugin(conf_inputs, conf_geom_plugin):
-    """
-    Check the geometry plugin with inputs
-    :param conf_geom_plugin: name of geometry plugin
-    :type conf_geom_plugin: str
-    :param conf_inputs: checked configuration of inputs
-    :type conf_inputs: type
-
-    :return: geometry plugin with dem
-    """
-    if conf_geom_plugin is None:
-        conf_geom_plugin = "SharelocGeometry"
-
-    dem_path = conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
-
-    if dem_path is None:
-        return conf_geom_plugin, None
-
-    # Initialize a geometry plugin with elevation information
-    geom_plugin_with_dem_and_geoid = (
-        AbstractGeometry(  # pylint: disable=abstract-class-instantiated
-            conf_geom_plugin,
-            dem=dem_path,
-            geoid=conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.GEOID],
-            default_alt=sens_cst.CARS_DEFAULT_ALT,
-        )
-    )
-
-    return conf_geom_plugin, geom_plugin_with_dem_and_geoid
-
-
-def check_input_size(
-    x_path, y_path, z_path, mask, color, classif, filling, ambiguity
-):
-    """
-    Check x, y, z, mask, color, classif and ambiguity given
-
-    Images must have same size
-
-    :param x_path: x path
-    :type x_path: str
-    :param y_path: y path
-    :type y_path: str
-    :param z_path: z path
-    :type z_path: str
-    :param mask: mask path
-    :type mask: str
-    :param color: color path
-    :type color: str
-    :param classif: classif path
-    :type classif: str
-    :param filling: filling path
-    :type filling: str
-    :param ambiguity: ambiguity path
-    :type ambiguity: str
-    """
-
-    for path in [x_path, y_path, z_path]:
-        if inputs.rasterio_get_nb_bands(path) != 1:
-            raise RuntimeError("{} is not mono-band image".format(path))
-
-    for path in [mask, color, classif, filling, ambiguity]:
-        if path is not None:
-            if inputs.rasterio_get_size(x_path) != inputs.rasterio_get_size(
-                path
-            ):
-                raise RuntimeError(
-                    "The image {} and {} "
-                    "do not have the same size".format(x_path, path)
-                )
-
-
-def modify_to_absolute_path(config_dir, overloaded_conf):
-    """
-    Modify input file path to absolute path
-
-    :param config_dir: directory of the json/yaml configuration
-    :type config_dir: str
-    :param overloaded_conf: overloaded configuration json
-    :dict overloaded_conf: dict
-    """
-    for depth_map_key in overloaded_conf[depth_map_cst.DEPTH_MAPS]:
-        depth_map = overloaded_conf[depth_map_cst.DEPTH_MAPS][depth_map_key]
-        for tag in [
-            cst.X,
-            cst.Y,
-            cst.Z,
-            cst.POINT_CLOUD_CLR_KEY_ROOT,
-            cst.POINT_CLOUD_MSK,
-            cst.POINT_CLOUD_CLASSIF_KEY_ROOT,
-            cst.POINT_CLOUD_FILLING_KEY_ROOT,
-            cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT,
-        ]:
-            if tag != cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT:
-                if depth_map[tag] is not None:
-                    depth_map[tag] = make_relative_path_absolute(
-                        depth_map[tag], config_dir
-                    )
-            else:
-                if depth_map[tag] is not None:
-                    for confidence_name in depth_map[tag]:
-                        if depth_map[tag][confidence_name] is not None:
-                            depth_map[tag][confidence_name] = (
-                                make_relative_path_absolute(
-                                    depth_map[tag][confidence_name],
-                                    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_dir
-            )

cars/pipelines/parameters/dsm_inputs.py

@@ -42,6 +42,7 @@ from cars.applications.rasterization.rasterization_wrappers import (
 )
 from cars.core import constants as cst
 from cars.core import inputs, preprocessing, tiling
+from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.utils import make_relative_path_absolute, safe_makedirs
 from cars.data_structures import cars_dataset
 from cars.pipelines.parameters import sensor_inputs as sens_inp
@@ -213,6 +214,37 @@ def check_dsm_inputs(conf, config_dir=None):
     return overloaded_conf
 
 
+def check_geometry_plugin(conf_inputs, conf_geom_plugin):
+    """
+    Check the geometry plugin with inputs
+    :param conf_geom_plugin: name of geometry plugin
+    :type conf_geom_plugin: str
+    :param conf_inputs: checked configuration of inputs
+    :type conf_inputs: type
+
+    :return: geometry plugin with dem
+    """
+    if conf_geom_plugin is None:
+        conf_geom_plugin = "SharelocGeometry"
+
+    dem_path = conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.DEM_PATH]
+
+    if dem_path is None:
+        return conf_geom_plugin, None
+
+    # Initialize a geometry plugin with elevation information
+    geom_plugin_with_dem_and_geoid = (
+        AbstractGeometry(  # pylint: disable=abstract-class-instantiated
+            conf_geom_plugin,
+            dem=dem_path,
+            geoid=conf_inputs[sens_cst.INITIAL_ELEVATION][sens_cst.GEOID],
+            default_alt=sens_cst.CARS_DEFAULT_ALT,
+        )
+    )
+
+    return conf_geom_plugin, geom_plugin_with_dem_and_geoid
+
+
 def check_input_size(dsm, classif, color, mask):
     """
     Check dsm, mask, color, classif given
@@ -318,6 +350,7 @@ def check_phasing(dsm_dict):
             raise RuntimeError(f"DSM {dsm_key} and {ref_key} are not phased")
 
 
+# pylint: disable=too-many-positional-arguments
 def merge_dsm_infos(  # noqa: C901 function is too complex
     dict_path,
     orchestrator,
@@ -378,6 +411,9 @@ def merge_dsm_infos(  # noqa: C901 function is too complex
     terrain_raster = cars_dataset.CarsDataset("arrays", name="rasterization")
 
     # find the global bounds of the dataset
+    dsm_nodata = None
+    epsg = None
+    resolution = None
     for index, path in enumerate(dict_path["dsm"]):
         with rasterio.open(path) as src:
             if index == 0:
@@ -544,7 +580,7 @@ def merge_dsm_infos(  # noqa: C901 function is too complex
     return terrain_raster
 
 
-def dsm_merging_wrapper(  # noqa C901
+def dsm_merging_wrapper(  # pylint: disable=too-many-positional-arguments # noqa C901
     dict_path,
     tile_bounds,
     resolution,
@@ -744,7 +780,7 @@ def dsm_merging_wrapper(  # noqa C901
     return dataset
 
 
-def assemblage(
+def assemblage(  # pylint: disable=too-many-positional-arguments
     out,
     current_weights,
     method,
@@ -828,11 +864,11 @@ def assemblage(
                 # doesn't equal to the entire tile
                 x_offset = int(
                     (intersect_bounds[idx][0] - tile_bounds[0])
-                    * np.abs(src.res[0])
+                    / np.abs(src.res[0])
                 )
                 y_offset = int(
                     (tile_bounds[3] - intersect_bounds[idx][3])
-                    * np.abs(src.res[1])
+                    / np.abs(src.res[1])
                 )
 
                 if cols > 0 and rows > 0:

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 overloaded_conf.get(output_constants.RESOLUTION, None) is not None:
+        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.info(
+            "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):