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

cars/applications/dense_matching/disparity_grid_algo.py

@@ -0,0 +1,566 @@
+#!/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.
+#
+"""
+this module contains the wrapper used in disparity grid computation.
+"""
+
+# Standard imports
+import itertools
+import logging
+
+# Third party imports
+import affine
+import numpy as np
+import rasterio
+import xarray as xr
+from scipy.ndimage import maximum_filter, minimum_filter
+from shareloc.proj_utils import transform_physical_point_to_index
+
+# CARS imports
+import cars.applications.dense_matching.dense_matching_constants as dm_cst
+import cars.orchestrator.orchestrator as ocht
+from cars.applications.dense_matching.dense_matching_algo import (
+    LinearInterpNearestExtrap,
+)
+from cars.core import inputs, projection
+from cars.core.projection import point_cloud_conversion
+from cars.data_structures import cars_dataset, cars_dict
+
+
+def generate_disp_grids_dataset(
+    grid_min,
+    grid_max,
+    saving_info,
+    raster_profile,
+    window=None,
+    row_coords=None,
+    col_coords=None,
+):
+    """
+    Generate disparity grids xarray dataset
+
+    :param grid_min: disp grid min
+    :type grid_min: np.ndarray
+    :param grid_max: disp grid max
+    :type grid_max: np.ndarray
+    :param saving_info: saving infos
+    :type saving_info: dict
+    :param raster_profile: raster_profile
+    :type raster_profile: dict
+    :param row_coords: row cooordinates
+    :type row_coords: np.ndarray, optional
+    :param col_coords: col coordinates
+    :type col_coords: np.ndarray, optional
+
+    :return: disp range dataset
+    :rtype: xarray.Dataset
+    """
+
+    if row_coords is None:
+        row_coords = np.arange(0, grid_min.shape[0])
+
+    if col_coords is None:
+        col_coords = np.arange(0, grid_min.shape[1])
+
+    disp_range_tile = xr.Dataset(
+        data_vars={
+            dm_cst.DISP_MIN_GRID: (["row", "col"], grid_min),
+            dm_cst.DISP_MAX_GRID: (["row", "col"], grid_max),
+        },
+        coords={
+            "row": row_coords,
+            "col": col_coords,
+        },
+    )
+
+    cars_dataset.fill_dataset(
+        disp_range_tile,
+        saving_info=saving_info,
+        window=window,
+        profile=raster_profile,
+        attributes=None,
+        overlaps=None,
+    )
+
+    return disp_range_tile
+
+
+def generate_disp_range_const_tile_wrapper(
+    row_range,
+    col_range,
+    dmin,
+    dmax,
+    raster_profile,
+    saving_info,
+    saving_info_global_infos,
+):
+    """
+    Generate disparity range dataset from constant dmin and dmax
+
+    :param row_range: Row range
+    :type row_range: list
+    :param col_range: Column range.
+    :type col_range: list
+    :param dmin:  disparity minimum.
+    :type dmin: float
+    :param dmax: disparity maximum.
+    :type dmax: float
+    :param raster_profile: The raster profile.
+    :type raster_profile: dict
+    :param saving_info: The disp range grid saving information.
+    :type saving_info: dict
+    :param saving_info_global_infos: Global info saving infos.
+    :type saving_info_global_infos: dict
+
+    :return: Disparity range grid
+    :rtype: dict
+    """
+    grid_min = np.empty((len(row_range), len(col_range)))
+    grid_max = np.empty((len(row_range), len(col_range)))
+    grid_min[:, :] = dmin
+    grid_max[:, :] = dmax
+
+    mono_tile_saving_info = ocht.update_saving_infos(saving_info, row=0, col=0)
+    disp_range = generate_disp_grids_dataset(
+        grid_min, grid_max, mono_tile_saving_info, raster_profile, window=None
+    )
+
+    # Generate infos on global min and max
+    global_infos = cars_dict.CarsDict(
+        {"global_min": np.nanmin(dmin), "global_max": np.nanmin(dmax)}
+    )
+    cars_dataset.fill_dict(global_infos, saving_info=saving_info_global_infos)
+
+    return disp_range, global_infos
+
+
+def generate_disp_range_from_dem_wrapper(
+    epipolar_grid_array_window,
+    full_epi_row_range,
+    full_epi_col_range,
+    sensor_image_right,
+    grid_right,
+    geom_plugin_with_dem_and_geoid,
+    dem_median,
+    dem_min,
+    dem_max,
+    altitude_delta_min,
+    altitude_delta_max,
+    raster_profile,
+    saving_info,
+    saving_info_global_infos,
+    filter_overlap,
+    disp_to_alt_ratio,
+    disp_min_threshold=None,
+    disp_max_threshold=None,
+):
+    """
+    Generate disparity range dataset from dems
+
+    :param epipolar_grid_array_window: The window of the epipolar grid array.
+    :type epipolar_grid_array_window: dict
+    :param full_epi_row_range: The full range of rows in the epipolar grid.
+    :type full_epi_row_range: list
+    :param full_epi_col_range: The full range of columns in the epipolar grid.
+    :type full_epi_col_range: list
+    :param sensor_image_right: The right sensor image.
+    :type sensor_image_right:  dict
+    :param grid_right: The right epipolar grid.
+    :type grid_right: dict
+    :param geom_plugin_with_dem_and_geoid: The geometry plugin with DEM.
+    :type geom_plugin_with_dem_and_geoid: object
+    :param dem_median: Path of dem median.
+    :type dem_median: str
+    :param dem_min: Path of dem min.
+    :type dem_min: str
+    :param dem_max: Path of dem max.
+    :type dem_max: srt
+    :param altitude_delta_min: The minimum altitude delta.
+    :type altitude_delta_min: float
+    :param altitude_delta_max: The maximum altitude delta.
+    :type altitude_delta_max: float
+    :param raster_profile: The raster profile.
+    :type raster_profile: dict
+    :param saving_info: The disp range grid saving information.
+    :type saving_info: dict
+    :param saving_info_global_infos: Global info saving infos.
+    :type saving_info_global_infos: dict
+    :param filter_overlap: The overlap to use for filtering.
+    :type filter_overlap: int
+    :param disp_to_alt_ratio: disparity to altitude ratio
+    :type disp_to_alt_ratio: float
+    :param disp_min_threshold: The minimum disparity threshold.
+    :type disp_min_threshold: float, optional
+    :param disp_max_threshold: The maximum disparity threshold.
+    :type disp_max_threshold: float, optional
+
+    :return: Disparity range grid
+    :rtype: dict
+    """
+
+    # compute reverse matrix
+    transform_sensor = rasterio.Affine(
+        *np.abs(
+            inputs.rasterio_get_transform(
+                sensor_image_right["image"]["main_file"]
+            )
+        )
+    )
+
+    trans_inv_sensor = ~transform_sensor
+    # Transform to positive values
+    trans_inv_sensor = np.array(trans_inv_sensor)
+    trans_inv_sensor = np.reshape(trans_inv_sensor, (3, 3))
+    if trans_inv_sensor[0, 0] < 0:
+        trans_inv_sensor[0, :] *= -1
+    if trans_inv_sensor[1, 1] < 0:
+        trans_inv_sensor[1, :] *= -1
+    trans_inv_sensor = affine.Affine(*list(trans_inv_sensor.flatten()))
+
+    # Geometry plugin
+    geo_plugin = geom_plugin_with_dem_and_geoid
+
+    # get epsg
+    terrain_epsg = inputs.rasterio_get_epsg(dem_median)
+
+    # Get epipolar position of all dem mean
+    transform_dem_median = inputs.rasterio_get_transform(dem_median)
+
+    # use local disparity
+
+    # Get associated alti mean / min / max values
+    dem_median_shape = inputs.rasterio_get_size(dem_median)
+    dem_median_width, dem_median_height = dem_median_shape
+
+    # get corresponding window from epipolar_array_window
+    epi_grid_margin = filter_overlap + 1
+    epi_grid_row_min = epipolar_grid_array_window["row_min"]
+    epi_grid_row_max = epipolar_grid_array_window["row_max"]
+    epi_grid_col_min = epipolar_grid_array_window["col_min"]
+    epi_grid_col_max = epipolar_grid_array_window["col_max"]
+
+    def clip(value, min_value, max_value):
+        """
+        Clip a value inside bounds
+        """
+        return int(max(min_value, min(value, max_value)))
+
+    # Epi grid tile coordinate to use, with and without margins
+    epi_grid_row_min_with_margin = clip(
+        epi_grid_row_min - epi_grid_margin, 0, len(full_epi_row_range)
+    )
+    epi_grid_row_max_with_margin = clip(
+        epi_grid_row_max + epi_grid_margin, 0, len(full_epi_row_range)
+    )
+    epi_grid_col_min_with_margin = clip(
+        epi_grid_col_min - epi_grid_margin, 0, len(full_epi_col_range)
+    )
+    epi_grid_col_max_with_margin = clip(
+        epi_grid_col_max + epi_grid_margin, 0, len(full_epi_col_range)
+    )
+
+    # range to use for epipolar interpolation
+    row_range_with_margin = full_epi_row_range[
+        epi_grid_row_min_with_margin:epi_grid_row_max_with_margin
+    ]
+    row_range_no_margin = full_epi_row_range[epi_grid_row_min:epi_grid_row_max]
+    col_range_with_margin = full_epi_col_range[
+        epi_grid_col_min_with_margin:epi_grid_col_max_with_margin
+    ]
+    col_range_no_margin = full_epi_col_range[epi_grid_col_min:epi_grid_col_max]
+
+    # Loc on dem median
+    epi_bbox = [
+        (np.min(col_range_with_margin), np.min(row_range_with_margin)),
+        (np.min(col_range_with_margin), np.max(row_range_with_margin)),
+        (np.max(col_range_with_margin), np.min(row_range_with_margin)),
+        (np.max(col_range_with_margin), np.max(row_range_with_margin)),
+    ]
+    sensor_bbox = geo_plugin.sensor_position_from_grid(grid_right, epi_bbox)
+    row_sensor_bbox, col_sensor_bbox = transform_physical_point_to_index(
+        trans_inv_sensor, sensor_bbox[:, 1], sensor_bbox[:, 0]
+    )
+
+    terrain_bbox = geo_plugin.safe_direct_loc(
+        sensor_image_right["image"]["main_file"],
+        sensor_image_right["geomodel"],
+        col_sensor_bbox,
+        row_sensor_bbox,
+    )
+
+    # reshape terrain bbox
+    terrain_bbox = terrain_bbox[0:2].T
+    terrain_bbox[:, [1, 0]] = terrain_bbox[:, [0, 1]]
+
+    # get pixel location on dem median
+    pixel_roi_dem_mean = inputs.rasterio_get_pixel_points(
+        dem_median, terrain_bbox
+    )
+
+    # Add margins (for interpolation) and clip
+    dem_margin = 10  # arbitrary
+    roi_lower_row = np.floor(np.min(pixel_roi_dem_mean[:, 0])) - dem_margin
+    roi_upper_row = np.ceil(np.max(pixel_roi_dem_mean[:, 0])) + dem_margin
+    roi_lower_col = np.floor(np.min(pixel_roi_dem_mean[:, 1])) - dem_margin
+    roi_upper_col = np.ceil(np.max(pixel_roi_dem_mean[:, 1])) + dem_margin
+
+    min_row = clip(roi_lower_row, 0, dem_median_height)
+    max_row = clip(roi_upper_row, 0, dem_median_height)
+    min_col = clip(roi_lower_col, 0, dem_median_width)
+    max_col = clip(roi_upper_col, 0, dem_median_width)
+
+    # compute terrain positions to use (all dem min and max)
+    row_indexes = range(min_row, max_row)
+    col_indexes = range(min_col, max_col)
+    transformer = rasterio.transform.AffineTransformer(transform_dem_median)
+
+    indexes = np.array(list(itertools.product(row_indexes, col_indexes)))
+
+    row = indexes[:, 0]
+    col = indexes[:, 1]
+    x_mean, y_mean = transformer.xy(row, col)
+    terrain_positions = np.transpose(np.array([x_mean, y_mean]))
+
+    # dem mean in terrain_epsg
+    x_mean = terrain_positions[:, 0]
+    y_mean = terrain_positions[:, 1]
+
+    dem_median_list = inputs.rasterio_get_values(
+        dem_median, x_mean, y_mean, point_cloud_conversion
+    )
+
+    nan_mask = ~np.isnan(dem_median_list)
+
+    # transform to lon lat
+    terrain_position_lon_lat = projection.point_cloud_conversion(
+        terrain_positions, terrain_epsg, 4326
+    )
+    lon_mean = terrain_position_lon_lat[:, 0]
+    lat_mean = terrain_position_lon_lat[:, 1]
+
+    if None not in (dem_min, dem_max, dem_median):
+        # dem min and max are in 4326
+        dem_min_list = inputs.rasterio_get_values(
+            dem_min, lon_mean, lat_mean, point_cloud_conversion
+        )
+        dem_max_list = inputs.rasterio_get_values(
+            dem_max, lon_mean, lat_mean, point_cloud_conversion
+        )
+        nan_mask = nan_mask & ~np.isnan(dem_min_list) & ~np.isnan(dem_max_list)
+    else:
+        dem_min_list = dem_median_list - altitude_delta_min
+        dem_max_list = dem_median_list + altitude_delta_max
+
+    # filter nan value from input points
+    lon_mean = lon_mean[nan_mask]
+    lat_mean = lat_mean[nan_mask]
+    dem_median_list = dem_median_list[nan_mask]
+    dem_min_list = dem_min_list[nan_mask]
+    dem_max_list = dem_max_list[nan_mask]
+
+    # sensors physical positions
+    (
+        ind_cols_sensor,
+        ind_rows_sensor,
+        _,
+    ) = geom_plugin_with_dem_and_geoid.safe_inverse_loc(
+        sensor_image_right["image"]["main_file"],
+        sensor_image_right["geomodel"],
+        lat_mean,
+        lon_mean,
+        z_coord=dem_median_list,
+    )
+
+    # Generate epipolar disp grids
+    # Get epipolar positions
+    (epipolar_positions_row, epipolar_positions_col) = np.meshgrid(
+        col_range_with_margin,
+        row_range_with_margin,
+    )
+    epipolar_positions = np.stack(
+        [epipolar_positions_row, epipolar_positions_col], axis=2
+    )
+
+    # Get sensor position
+    sensors_positions = (
+        geom_plugin_with_dem_and_geoid.sensor_position_from_grid(
+            grid_right,
+            np.reshape(
+                epipolar_positions,
+                (
+                    epipolar_positions.shape[0] * epipolar_positions.shape[1],
+                    2,
+                ),
+            ),
+        )
+    )
+
+    # Transform physical position to index
+    ind_rows_sensor_grid, ind_cols_sensor_grid = (
+        transform_physical_point_to_index(
+            trans_inv_sensor, sensors_positions[:, 1], sensors_positions[:, 0]
+        )
+    )
+
+    if len(ind_rows_sensor) < 5:
+        # QH6214 needs at least 4 points for interpolation
+
+        grid_min = np.empty(
+            (len(row_range_no_margin), len(col_range_no_margin))
+        )
+        grid_max = np.empty(
+            (len(row_range_no_margin), len(col_range_no_margin))
+        )
+        grid_min[:, :] = 0
+        grid_max[:, :] = 0
+
+        disp_range = generate_disp_grids_dataset(
+            grid_min,
+            grid_max,
+            saving_info,
+            raster_profile,
+            window=epipolar_grid_array_window,
+            row_coords=row_range_no_margin,
+            col_coords=col_range_no_margin,
+        )
+
+        # Generate infos on global min and max
+        global_infos = cars_dict.CarsDict(
+            {
+                "global_min": 0,
+                "global_max": 0,
+            }
+        )
+        cars_dataset.fill_dict(
+            global_infos, saving_info=saving_info_global_infos
+        )
+
+        return disp_range, global_infos
+
+    # Interpolate disparity
+    disp_min_points = -(dem_max_list - dem_median_list) / disp_to_alt_ratio
+    disp_max_points = -(dem_min_list - dem_median_list) / disp_to_alt_ratio
+
+    interp_min_linear = LinearInterpNearestExtrap(
+        list(zip(ind_rows_sensor, ind_cols_sensor)),  # noqa: B905
+        disp_min_points,
+    )
+    interp_max_linear = LinearInterpNearestExtrap(
+        list(zip(ind_rows_sensor, ind_cols_sensor)),  # noqa: B905
+        disp_max_points,
+    )
+
+    grid_min = np.reshape(
+        interp_min_linear(ind_rows_sensor_grid, ind_cols_sensor_grid),
+        (
+            epipolar_positions.shape[0],
+            epipolar_positions.shape[1],
+        ),
+    )
+
+    grid_max = np.reshape(
+        interp_max_linear(ind_rows_sensor_grid, ind_cols_sensor_grid),
+        (
+            epipolar_positions.shape[0],
+            epipolar_positions.shape[1],
+        ),
+    )
+
+    # Add margin
+    diff = grid_max - grid_min
+    logging.info("Max grid max - grid min : {} disp ".format(np.max(diff)))
+
+    if disp_min_threshold is not None:
+        if np.any(grid_min < disp_min_threshold):
+            logging.warning(
+                "Override disp_min  with disp_min_threshold {}".format(
+                    disp_min_threshold
+                )
+            )
+            grid_min[grid_min < disp_min_threshold] = disp_min_threshold
+    if disp_max_threshold is not None:
+        if np.any(grid_max > disp_max_threshold):
+            logging.warning(
+                "Override disp_max with disp_max_threshold {}".format(
+                    disp_max_threshold
+                )
+            )
+            grid_max[grid_max > disp_max_threshold] = disp_max_threshold
+
+    # generate footprint
+    footprint_mask = create_circular_mask(filter_overlap, filter_overlap)
+    grid_min = minimum_filter(
+        grid_min, footprint=footprint_mask, mode="nearest"
+    )
+    grid_max = maximum_filter(
+        grid_max, footprint=footprint_mask, mode="nearest"
+    )
+
+    # Create xarray dataset
+    disp_range = generate_disp_grids_dataset(
+        grid_min,
+        grid_max,
+        saving_info,
+        raster_profile,
+        window=epipolar_grid_array_window,
+        row_coords=row_range_with_margin,
+        col_coords=col_range_with_margin,
+    )
+
+    # crop epipolar grid from margin added for propagation filter
+    disp_range = disp_range.sel(
+        row=list(row_range_no_margin), col=list(col_range_no_margin)
+    )
+
+    # Generate infos on global min and max
+    global_infos = cars_dict.CarsDict(
+        {
+            "global_min": np.floor(np.nanmin(grid_min)),
+            "global_max": np.ceil(np.nanmax(grid_max)),
+        }
+    )
+    cars_dataset.fill_dict(global_infos, saving_info=saving_info_global_infos)
+
+    return disp_range, global_infos
+
+
+def create_circular_mask(height, width):
+    """
+    Create a circular mask for footprint around pixel
+
+    :param height: height of footprint
+    :type height: int
+    :param width: width of footprint
+    :type width: int
+
+    :return: mask representing circular footprint
+    :rtype: np.ndarray
+    """
+    center = (int(width / 2), int(height / 2))
+    radius = min(center[0], center[1], width - center[0], height - center[1])
+
+    y_grid, x_grid = np.ogrid[:height, :width]
+    dist_from_center = np.sqrt(
+        (x_grid - center[0]) ** 2 + (y_grid - center[1]) ** 2
+    )
+
+    mask = dist_from_center <= radius
+    return mask.astype(bool)

cars/applications/dense_matching/loaders/config_mapping.json

@@ -0,0 +1,13 @@
+{
+    "10": "census_sgm_mountain_and_vegetation",
+    "20": "census_sgm_mountain_and_vegetation",
+    "30": "census_sgm_mountain_and_vegetation",
+    "40": "census_sgm_mountain_and_vegetation",
+    "50": "census_sgm_urban",
+    "60": "census_sgm_homogeneous",
+    "70": "census_sgm_mountain_and_vegetation",
+    "80": "census_sgm_mountain_and_vegetation",
+    "90": "census_sgm_mountain_and_vegetation",
+    "95": "census_sgm_mountain_and_vegetation",
+    "100": "census_sgm_mountain_and_vegetation"
+}

cars/applications/dense_matching/loaders/pandora_loader.py

@@ -31,6 +31,7 @@ from typing import Dict
 
 import numpy as np
 import pandora
+import rasterio
 from json_checker import Checker, Or
 from pandora.check_configuration import (
     check_pipeline_section,
@@ -40,6 +41,10 @@ from pandora.check_configuration import (
 )
 from pandora.img_tools import get_metadata
 from pandora.state_machine import PandoraMachine
+from rasterio.mask import mask
+from shapely.geometry import mapping
+
+from cars.core.projection import polygon_projection
 
 
 class PandoraLoader:
@@ -135,7 +140,7 @@ class PandoraLoader:
                 # read conf
                 with open(conf_file_path, "r", encoding="utf8") as fstream:
                     conf = json.load(fstream)
-            elif method_name == "census_sgm_default":
+            elif method_name in ("census_sgm_default", "auto"):
                 # Use census sgm conf
                 conf_file_path = os.path.join(
                     package_path, "config_census_sgm_default.json"
@@ -300,6 +305,78 @@ class PandoraLoader:
 
         return self.pandora_config
 
+    def find_auto_conf(
+        self, intersection_poly, land_cover_map, classif_to_config_mapping, epsg
+    ):
+        """
+        Find the configuration that suits the most on the
+        land cover map based on the roi
+        """
+        package_path = os.path.dirname(__file__)
+
+        # construct the path to the land_cover_map
+        if os.path.dirname(land_cover_map) == "":
+            land_cover_map_path = os.path.join(package_path, land_cover_map)
+        else:
+            land_cover_map_path = land_cover_map
+
+        with rasterio.open(land_cover_map_path) as src:
+            # Project the polygon to the right epsg
+            if src.crs != epsg:
+                poly = polygon_projection(
+                    intersection_poly, epsg, src.crs.to_epsg()
+                )
+            else:
+                poly = intersection_poly
+
+            # Use a buffer because the land_cover_map resolution is coarse
+            data_land_cover, _ = mask(
+                src, [mapping(poly)], crop=True, all_touched=True
+            )
+
+            # Find the most common class in the roi
+            data_squeeze = data_land_cover.squeeze()
+            valid_data = data_squeeze[data_squeeze != src.nodata]
+
+            most_common_class = None
+            if valid_data.size > 0:
+                classes, counts = np.unique(valid_data, return_counts=True)
+                max_index = np.argmax(counts)
+                most_common_class = classes[max_index]
+
+        # Construct the path to the classification to configuration mapping
+        if os.path.dirname(classif_to_config_mapping) == "":
+            conf_file_path = os.path.join(
+                package_path, classif_to_config_mapping
+            )
+        else:
+            conf_file_path = classif_to_config_mapping
+
+        # read conf
+        with open(conf_file_path, "r", encoding="utf8") as fstream:
+            conf_mapping = json.load(fstream)
+
+        # Find the configuration that corresponds to the most common class
+        corresponding_conf_name = conf_mapping.get(str(most_common_class), None)
+
+        # If no equivalence has been found, we use the default configuration
+        if corresponding_conf_name is None:
+            corresponding_conf_name = "census_sgm_default"
+
+        logging.info(
+            "The conf that has been chosen regarding the "
+            "world classification map is {}".format(corresponding_conf_name)
+        )
+
+        # We return the corresponding configuration
+        json_conf_name = os.path.join(
+            package_path, "config_" + corresponding_conf_name + ".json"
+        )
+        with open(json_conf_name, "r", encoding="utf8") as fstream:
+            conf = json.load(fstream)
+
+        return conf
+
     def check_conf(
         self,
         user_cfg,