cars 1.0.0rc3__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

cars/applications/grid_generation/grid_generation_algo.py

@@ -0,0 +1,388 @@
+#!/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.
+#
+"""
+Grids module:
+contains functions used for epipolar grid creation and correction
+"""
+
+# Standard imports
+from __future__ import absolute_import
+
+import logging
+import math
+import os
+
+# Third party imports
+import numpy as np
+import pandas
+import rasterio as rio
+import xarray as xr
+from affine import Affine
+
+# TODO depends on another step (and a later one) : make it independent
+from cars.applications.triangulation.triangulation_algo import (
+    triangulate_matches,
+)
+from cars.core import constants as cst
+from cars.core import inputs, projection, tiling
+from cars.orchestrator.cluster.log_wrapper import cars_profile
+
+
+def get_new_path(path):
+    """
+    Check path, if exists, creates new one
+
+    :param path: path to check
+    :type path: str
+
+    :return : new path
+    :rtype: str
+    """
+
+    current_increment = 0
+    head, tail = os.path.splitext(path)
+
+    current_path = path
+    while os.path.exists(current_path):
+        current_increment += 1
+        current_path = head + "_" + repr(current_increment) + tail
+
+    return current_path
+
+
+def write_grid(grid, fname, origin, spacing):
+    """
+    Write an epipolar rectification grid to file
+
+    :param grid: the grid to write
+    :type grid: 3D numpy array
+    :param fname: the filename to which the grid will be written
+    :type fname: string
+    :param origin: origin of the grid
+    :type origin: (float, float)
+    :param spacing: spacing of the grid
+    :type spacing: (float, float)
+    """
+
+    geotransform = (
+        origin[0] - 0.5 * spacing[0],
+        spacing[0],
+        0.0,
+        origin[1] - 0.5 * spacing[1],
+        0.0,
+        spacing[1],
+    )
+
+    transform = Affine.from_gdal(*geotransform)
+
+    with rio.open(
+        fname,
+        "w",
+        height=grid.shape[0],
+        width=grid.shape[1],
+        count=2,
+        driver="GTiff",
+        dtype=grid.dtype,
+        transform=transform,
+    ) as dst:
+        dst.write_band(1, grid[:, :, 0])
+        dst.write_band(2, grid[:, :, 1])
+
+
+def generate_epipolar_grids(  # pylint: disable=too-many-positional-arguments
+    sensor1, sensor2, geomodel1, geomodel2, geometry_plugin, epipolar_step
+):
+    """
+    Computes the left and right epipolar grids
+
+    :param sensor1: path to left sensor image
+    :param sensor2: path to right sensor image
+    :param geomodel1: path and attributes for left geomodel
+    :param geomodel2: path and attributes for right geomodel
+    :param geometry_plugin: geometry plugin to use
+    :type geometry_plugin: AbstractGeometry
+    :param epipolar_step: step to use to construct the epipolar grids
+    :return: Tuple composed of :
+
+        - the left epipolar grid as a numpy array
+        - the right epipolar grid as a numpy array
+        - the left grid origin as a list of float
+        - the left grid spacing as a list of float
+        - the epipolar image size as a list of int\
+        (x-axis size is given with the index 0, y-axis size with index 1)
+        - the disparity to altitude ratio as a float
+    """
+    logging.info("Generating epipolar rectification grid ...")
+
+    return geometry_plugin.generate_epipolar_grids(
+        sensor1,
+        sensor2,
+        geomodel1,
+        geomodel2,
+        epipolar_step=epipolar_step,
+    )
+
+
+# pylint: disable=too-many-positional-arguments
+@cars_profile(name="Compute epipolar grid min max", interval=0.5)
+def compute_epipolar_grid_min_max(
+    geometry_plugin,
+    grid,
+    sensor1,
+    sensor2,
+    geomodel1,
+    geomodel2,
+    grid1,
+    grid2,
+    epsg,
+    disp_min_tiling,
+    disp_max_tiling,
+):
+    """
+    Compute ground terrain location of epipolar grids at disp_min and disp_max
+
+    :param geometry_plugin: geometry plugin to use
+    :type geometry_plugin: AbstractGeometry
+    :param grid: The epipolar grid to project
+    :type grid: np.ndarray of shape (N,M,2)
+    :param sensor1: path to left sensor image
+    :type sensor1: str
+    :param sensor2: path to right sensor image
+    :type sensor2: str
+    :param geomodel1: path and attributes for left geomodel
+    :type geomodel1: dict
+    :param geomodel2: path and attributes for right geomodel
+    :type geomodel2: dict
+    :param grid1: dict of the reference image grid file
+    :type grid1: dict
+    :param grid2: dict of the secondary image grid file
+    :type grid2: dict
+    :param epsg: EPSG code of the terrain projection
+    :type epsg: Int
+    :param disp_min_tiling: Minimum disparity tiling
+    :type disp_min_tiling: np ndarray or int
+    :param disp_max_tiling: Maximum disparity tiling
+    :type disp_max_tiling: np ndarray or int
+    :return: a tuple of location grid at disp_min and disp_max
+    :rtype: Tuple(np.ndarray, np.ndarray) same shape as grid param
+    """
+
+    if isinstance(disp_min_tiling, np.ndarray):
+        disp_min_tiling = np.floor(disp_min_tiling).flatten()
+    else:
+        disp_min_tiling = math.floor(disp_min_tiling)
+    if isinstance(disp_max_tiling, np.ndarray):
+        disp_max_tiling = np.ceil(disp_max_tiling).flatten()
+    else:
+        disp_max_tiling = math.ceil(disp_max_tiling)
+
+    image_bounds = inputs.rasterio_get_bounds(grid2["path"])
+    min_px_right = image_bounds[0]
+    max_px_right = image_bounds[2]
+
+    # Generate disp_min and disp_max matches
+    right_cols_min = grid[:, :, 0].flatten() + disp_min_tiling
+    matches_min = np.stack(
+        (
+            grid[:, :, 0].flatten(),
+            grid[:, :, 1].flatten(),
+            np.clip(right_cols_min, min_px_right, max_px_right),
+            grid[:, :, 1].flatten(),
+        ),
+        axis=1,
+    )
+
+    right_cols_max = grid[:, :, 0].flatten() + disp_max_tiling
+    matches_max = np.stack(
+        (
+            grid[:, :, 0].flatten(),
+            grid[:, :, 1].flatten(),
+            np.clip(right_cols_max, min_px_right, max_px_right),
+            grid[:, :, 1].flatten(),
+        ),
+        axis=1,
+    )
+
+    # If the matches had to be clipped, log it
+    clipped_matches_min = np.argwhere(right_cols_min != matches_min[:, 2])
+    clipped_matches_max = np.argwhere(right_cols_max != matches_max[:, 2])
+
+    nb_elems_clipped = len(clipped_matches_min) + len(clipped_matches_max)
+    if nb_elems_clipped > 0:
+        logging.info(
+            f"{nb_elems_clipped} points were clipped to the right "
+            "image's bounds."
+        )
+
+    # Generate corresponding point clouds
+    pc_min = triangulate_matches(
+        geometry_plugin,
+        sensor1,
+        sensor2,
+        geomodel1,
+        geomodel2,
+        grid1,
+        grid2,
+        matches_min,
+        interpolation_method="linear",
+    )
+    pc_max = triangulate_matches(
+        geometry_plugin,
+        sensor1,
+        sensor2,
+        geomodel1,
+        geomodel2,
+        grid1,
+        grid2,
+        matches_max,
+        interpolation_method="linear",
+    )
+
+    # Convert to correct EPSG
+    projection.point_cloud_conversion_dataset(pc_min, epsg)
+    projection.point_cloud_conversion_dataset(pc_max, epsg)
+
+    # Form grid_min and grid_max
+    grid_min = None
+    grid_max = None
+    if isinstance(pc_min, xr.Dataset):
+        grid_min = np.concatenate(
+            (pc_min[cst.X].values, pc_min[cst.Y].values), axis=1
+        )
+        grid_max = np.concatenate(
+            (pc_max[cst.X].values, pc_max[cst.Y].values), axis=1
+        )
+    elif isinstance(pc_min, pandas.DataFrame):
+        grid_min = np.stack(
+            (pc_min[cst.X].to_numpy(), pc_min[cst.Y].to_numpy()), axis=-1
+        )
+        grid_max = np.stack(
+            (pc_max[cst.X].to_numpy(), pc_max[cst.Y].to_numpy()), axis=-1
+        )
+    else:
+        logging.error("pc min/max error: point cloud is unknown")
+
+    return grid_min, grid_max
+
+
+def terrain_region_to_epipolar(  # pylint: disable=too-many-positional-arguments
+    region,
+    sensor1,
+    sensor2,
+    geomodel1,
+    geomodel2,
+    grid_left,
+    grid_right,
+    geometry_plugin,
+    epsg=4326,
+    disp_min=0,
+    disp_max=0,
+    tile_size=100,
+    epipolar_size_x=None,
+    epipolar_size_y=None,
+):
+    """
+    Transform terrain region to epipolar region
+
+    :param region: terrain region to use
+    :param sensor1: path to left sensor image
+    :param sensor2: path to right sensor image
+    :param geomodel1: path and attributes for left geomodel
+    :param geomodel2: path and attributes for right geomodel
+    :param grid1: dataset of the reference image grid file
+    :param grid2: dataset of the secondary image grid file
+    :param geometry_plugin: geometry plugin to use
+    :param epsg: epsg
+    :param disp_min: minimum disparity
+    :param disp_max: maximum disparity
+    :param tile_size: tile size for grid
+    :param epipolar_size_x: epipolar_size_x
+    :param epipolar_size_y: epipolar_size_y
+
+    :return: epipolar region to use, with tile_size a sample
+    """
+
+    disp_min = int(disp_min)
+    disp_max = int(disp_max)
+
+    # Generate terrain grid only on roi
+    xmin = region[0]
+    xmax = region[2]
+    ymin = region[1]
+    ymax = region[3]
+    opt_terrain_size = max((xmax - xmin), (ymax - ymin))
+    region_grid = tiling.generate_tiling_grid(
+        xmin,
+        ymin,
+        xmax,
+        ymax,
+        opt_terrain_size,
+        opt_terrain_size,
+    )
+
+    # Generate fake epipolar grid
+    epipolar_grid = tiling.generate_tiling_grid(
+        0,
+        0,
+        epipolar_size_y,
+        epipolar_size_x,
+        tile_size,
+        tile_size,
+    )
+
+    # Compute disp_min and disp_max location for epipolar grid
+    (
+        epipolar_grid_min,
+        epipolar_grid_max,
+    ) = compute_epipolar_grid_min_max(
+        geometry_plugin,
+        tiling.transform_four_layers_to_two_layers_grid(epipolar_grid),
+        sensor1,
+        sensor2,
+        geomodel1,
+        geomodel2,
+        grid_left,
+        grid_right,
+        epsg,
+        disp_min,
+        disp_max,
+    )
+
+    # Compute epipolar points min and max on terrain region
+    points_min, points_max = tiling.terrain_grid_to_epipolar(
+        region_grid, epipolar_grid, epipolar_grid_min, epipolar_grid_max, epsg
+    )
+
+    # Bouding region of corresponding cell
+    epipolar_region_minx = np.min(points_min[:, :, 0])
+    epipolar_region_miny = np.min(points_min[:, :, 1])
+    epipolar_region_maxx = np.max(points_max[:, :, 0])
+    epipolar_region_maxy = np.max(points_max[:, :, 1])
+
+    # Generate epipolar region
+    epipolar_region = [
+        epipolar_region_miny,
+        epipolar_region_maxy,
+        epipolar_region_minx,
+        epipolar_region_maxx,
+    ]
+
+    return epipolar_region

cars/applications/grid_generation/grid_generation_constants.py

@@ -0,0 +1,46 @@
+#!/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.
+#
+"""
+grid_generation_constants contains all the constants
+used in grid_generation module
+"""
+
+
+GRID_GENERATION_RUN_TAG = "grid_generation"
+
+# Run infos
+
+GRID_CORRECTION_TAG = "grid_correction"
+CORRECTED_MATCHES_TAG = "corrected_filtered_matches"
+
+EPIPOLAR_SIZE_X_TAG = "epipolar_size_x"
+EPIPOLAR_SIZE_Y_TAG = "epipolar_size_y"
+EPIPOLAR_ORIGIN_X_TAG = "epipolar_origin_x"
+EPIPOLAR_ORIGIN_Y_TAG = "epipolar_origin_y"
+EPIPOLAR_SPACING_X_TAG = "epipolar_spacing_x"
+EPIPOLAR_SPACING_Y_TAG = "epipolar_spacing_y"
+
+DISP_TO_ALT_RATIO_TAG = "disp_to_alt_ratio"
+LEFT_AZIMUTH_ANGLE_TAG = "left_azimuth_angle"
+LEFT_ELEVATION_ANGLE_TAG = "left_elevation_angle"
+RIGHT_AZIMUTH_ANGLE_TAG = "right_azimuth_angle"
+RIGHT_ELEVATION_ANGLE_TAG = "right_elevation_angle"
+CONVERGENCE_ANGLE_TAG = "convergence_angle"

cars/applications/grid_generation/transform_grid.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2025 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.
+#
+"""
+Grids module:
+contains functions used for grid transformation
+"""
+
+import numpy as np
+import rasterio
+
+from cars.applications.grid_generation import grid_generation_algo
+
+
+def transform_grid_func(grid, resolution, right=False):
+    """
+    Transform the grid for low res resampling
+
+    :param grid: the grid
+    :type grid: cars_dataset
+    :param resolution: the resolution for the resampling
+    :type resolution: int
+    """
+    for key, value in grid.items():
+        if right:
+            if key not in ("grid_origin", "grid_spacing"):
+                scale(key, value, grid, resolution)
+        else:
+            scale(key, value, grid, resolution)
+
+    # we need to charge the data to override it
+    with rasterio.open(grid["path"]) as src:
+        data_left = src.read()
+
+    grid_generation_algo.write_grid(
+        np.transpose(data_left, (1, 2, 0)),
+        grid["path"],
+        grid["grid_origin"],
+        grid["grid_spacing"],
+    )
+
+    return grid
+
+
+def scale(key, value, grid, resolution):
+    """
+    Scale attributes by the resolution
+    """
+
+    if key == "grid_origin":
+        for i, _ in enumerate(value):
+            grid[key][i] = np.floor(value[i] / resolution)
+    elif key == "grid_spacing":
+        for i, _ in enumerate(value):
+            grid[key][i] = np.floor(value[i] / resolution)
+    elif key == "disp_to_alt_ratio":
+        grid[key] = value * resolution
+    elif key == "epipolar_size_x":
+        grid[key] = np.floor(value / resolution)
+    elif key == "epipolar_size_y":
+        grid[key] = np.floor(value / resolution)
+    elif key == "epipolar_origin_x":
+        grid[key] = np.floor(value / resolution)
+    elif key == "epipolar_origin_y":
+        grid[key] = np.floor(value / resolution)
+    elif key == "epipolar_spacing_x":
+        grid[key] = np.floor(value / resolution)
+    elif key == "epipolar_spacing":
+        grid[key] = np.floor(value / resolution)
+    elif key == "epipolar_step":
+        grid[key] = np.floor(value / resolution)

cars/applications/ground_truth_reprojection/__init__.py

@@ -0,0 +1,30 @@
+# !/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.
+#
+"""
+CARS core epipolar matches ground truth generation module init file
+"""
+# flake8: noqa: F401, E501
+
+from cars.applications.ground_truth_reprojection import (
+    abstract_ground_truth_reprojection_app,
+)
+
+from . import direct_localization_app

cars/applications/ground_truth_reprojection/abstract_ground_truth_reprojection_app.py

@@ -0,0 +1,137 @@
+#!/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 abstract ground_truth_reprojection
+application class.
+"""
+
+import logging
+from abc import ABCMeta, abstractmethod
+from typing import Dict
+
+from cars.applications.application import Application
+from cars.applications.application_template import ApplicationTemplate
+
+
+@Application.register("ground_truth_reprojection")
+class GroundTruthReprojection(ApplicationTemplate, metaclass=ABCMeta):
+    """
+    Epipolar matches ground truth computation
+
+    """
+
+    available_applications: Dict = {}
+    default_application = "direct_loc"
+
+    def __new__(cls, conf=None):  # pylint: disable=W0613
+        """
+        Return the required application
+        :raises: KeyError when the required application is not registered
+        :param conf: configuration for grid generation
+        :return: an application_to_use object
+
+        """
+
+        ground_truth_computation_method = cls.default_application
+
+        if bool(conf) is False or "method" not in conf:
+            logging.info(
+                "Ground truth reprojection method not specified"
+                ", default {} is used".format(ground_truth_computation_method)
+            )
+        else:
+            ground_truth_computation_method = conf.get(
+                "method", cls.default_application
+            )
+
+        if ground_truth_computation_method not in cls.available_applications:
+            logging.error(
+                "No GroundTruthReprojection application named {} "
+                "registered".format(ground_truth_computation_method)
+            )
+            raise KeyError(
+                "No GroundTruthReprojection application named {} "
+                "registered".format(ground_truth_computation_method)
+            )
+
+        logging.info(
+            "The GroundTruthReprojection({}) application will be "
+            "used".format(ground_truth_computation_method)
+        )
+
+        return super(GroundTruthReprojection, cls).__new__(
+            cls.available_applications[ground_truth_computation_method]
+        )
+
+    def __init_subclass__(cls, short_name, **kwargs):  # pylint: disable=E0302
+        super().__init_subclass__(**kwargs)
+        cls.available_applications[short_name] = cls
+
+    def __init__(self, conf=None):
+        """
+        Init function of Epipolar matches ground truth computation
+
+        :param conf: configuration
+        :return: an application_to_use object
+
+        """
+
+        super().__init__(conf=conf)
+
+    @abstractmethod
+    def run(  # pylint: disable=too-many-positional-arguments
+        self,
+        sensor_left,
+        sensor_right,
+        grid_left,
+        grid_right,
+        geom_plugin,
+        geom_plugin_dem_median,
+        disp_to_alt_ratio,
+        auxiliary_values,
+        auxiliary_interp,
+        orchestrator=None,
+        pair_folder=None,
+    ):  # noqa: C901
+        """
+        Compute disparity maps from a DSM. This function will be run
+        as a delayed task. If user want to correctly save dataset, the user must
+        provide saving_info_left and right.  See cars_dataset.fill_dataset.
+
+        :param geom_plugin_dem_median: Geometry plugin with dem median
+        :type geom_plugin_dem_median: geometry_plugin
+        :param sensor_left: Tiled sensor left image.
+            Dict must contain keys: "image", "texture", "geomodel",
+            "no_data", "mask". Paths must be absolute.
+        :type sensor_left: CarsDataset
+        :param grid_left: Grid left.
+        :type grid_left: CarsDataset
+        :param geom_plugin: Geometry plugin with user's DSM used to generate
+            epipolar grids.
+        :type geom_plugin: GeometryPlugin
+        :param disp_to_alt_ratio: Disp to altitude ratio used for
+            performance map.
+        :type disp_to_alt_ratio: float
+        :param orchestrator: Orchestrator used.
+        :type orchestrator: Any
+        :param pair_folder: Folder used for current pair.
+        :type pair_folder: str
+        """