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

cars/applications/dense_matching/dense_matching_algo.py

@@ -144,7 +144,7 @@ def compute_disparity_grid(
     return disp_min_grid, disp_max_grid
 
 
-def compute_disparity(
+def compute_disparity(  # pylint: disable=too-many-positional-arguments
     left_dataset,
     right_dataset,
     corr_cfg,
@@ -257,19 +257,53 @@ def compute_disparity(
         right_dataset = right_dataset.drop_vars([cst.EPI_MSK])
         right_dataset[cst.EPI_MSK] = right_msk
 
-    # Instantiate pandora state machine
-    pandora_machine = PandoraMachine()
-
-    # check datasets
-    check_datasets(left_dataset, right_dataset)
-
-    # Run the Pandora pipeline
-    ref, _ = pandora.run(
-        pandora_machine,
-        left_dataset,
-        right_dataset,
-        corr_cfg,
-    )
+    # Check that the datasets are not full of nan (would crash later)
+    if left_dataset["msk"].all() or right_dataset["msk"].all():
+        height = left_dataset.sizes["row"]
+        width = left_dataset.sizes["col"]
+        ref = xr.Dataset(
+            coords={
+                "row": left_dataset.coords["row"],
+                "col": left_dataset.coords["col"],
+                "indicator": [
+                    "confidence_from_ambiguity.cars_1",
+                    "confidence_from_risk_max.cars_2",
+                    "confidence_from_risk_min.cars_2",
+                    "confidence_from_disp_sup_from_risk.cars_2",
+                    "confidence_from_disp_inf_from_risk.cars_2",
+                    "confidence_from_interval_bounds_inf.cars_3",
+                    "confidence_from_interval_bounds_sup.cars_3",
+                    "confidence_from_left_right_consistency",
+                ],
+            },
+            data_vars={
+                "disparity_map": (
+                    ("row", "col"),
+                    np.full((height, width), np.nan, dtype=np.float32),
+                ),
+                "validity_mask": (
+                    ("row", "col"),
+                    np.ones((height, width), dtype=np.int64),
+                ),
+                "confidence_measure": (
+                    ("row", "col", "indicator"),
+                    np.full((height, width, 8), np.nan, dtype=np.float32),
+                ),
+            },
+        )
+    else:
+        # Instantiate pandora state machine
+        pandora_machine = PandoraMachine()
+        # check datasets
+        check_datasets(left_dataset, right_dataset)
+
+        # Run the Pandora pipeline
+        ref, _ = pandora.run(
+            pandora_machine,
+            left_dataset,
+            right_dataset,
+            corr_cfg,
+        )
 
     disp_dataset = dm_wrap.create_disp_dataset(
         ref,

cars/applications/dense_matching/dense_matching_wrappers.py

@@ -21,10 +21,11 @@
 This module is responsible for the dense matching algorithms:
 - thus it creates a disparity map from a pair of images
 """
-# pylint: disable=too-many-lines
+# pylint: disable=C0302
 
 # Standard imports
 import logging
+import math
 import warnings
 from typing import Dict
 
@@ -281,6 +282,7 @@ def compute_cropped_roi(
     )
 
 
+# pylint: disable=too-many-positional-arguments
 def create_disp_dataset(  # noqa: C901
     disp: xr.Dataset,
     ref_dataset: xr.Dataset,
@@ -513,6 +515,7 @@ def add_crop_info(disp_ds, cropped_range):
     return disp_ds
 
 
+# pylint: disable=too-many-positional-arguments
 def estimate_right_classif_on_left(
     right_classif,
     disp_map,
@@ -752,6 +755,7 @@ def estimate_right_grid_disp(disp_min_grid, disp_max_grid):
     )
 
 
+# pylint: disable=too-many-positional-arguments
 def optimal_tile_size_pandora_plugin_libsgm(
     disp_min: int,
     disp_max: int,
@@ -779,7 +783,7 @@ def optimal_tile_size_pandora_plugin_libsgm(
     """
 
     memory = max_ram_per_worker
-    disp = disp_max - disp_min
+    disp = max(3, abs(disp_max - disp_min))
 
     image = 32 * 2
     disp_ref = 32
@@ -809,13 +813,17 @@ def optimal_tile_size_pandora_plugin_libsgm(
         # but sqrt(nb_pixels + (disp/2)**2) - disp/2
         tile_size = np.sqrt(row_or_col + (disp / 2) ** 2) - disp / 2
         tile_size = (1.0 - margin / 100.0) * tile_size
-        tile_size = tile_size_rounding * int(tile_size / tile_size_rounding)
+
+    if math.isinf(tile_size):
+        logging.warning("Tile size infinite")
 
     if tile_size > max_tile_size:
         tile_size = max_tile_size
     elif tile_size < min_tile_size:
         tile_size = min_tile_size
 
+    tile_size = tile_size_rounding * int(tile_size / tile_size_rounding)
+
     return tile_size
 
 

cars/applications/dense_matching/disparity_grid_algo.py

@@ -27,7 +27,6 @@ import itertools
 import logging
 
 # Third party imports
-import affine
 import numpy as np
 import rasterio
 import xarray as xr
@@ -45,6 +44,7 @@ from cars.core.projection import point_cloud_conversion
 from cars.data_structures import cars_dataset, cars_dict
 
 
+# pylint: disable=too-many-positional-arguments
 def generate_disp_grids_dataset(
     grid_min,
     grid_max,
@@ -103,6 +103,7 @@ def generate_disp_grids_dataset(
     return disp_range_tile
 
 
+# pylint: disable=too-many-positional-arguments
 def generate_disp_range_const_tile_wrapper(
     row_range,
     col_range,
@@ -152,6 +153,7 @@ def generate_disp_range_const_tile_wrapper(
     return disp_range, global_infos
 
 
+# pylint: disable=too-many-positional-arguments
 def generate_disp_range_from_dem_wrapper(
     epipolar_grid_array_window,
     full_epi_row_range,
@@ -162,8 +164,6 @@ def generate_disp_range_from_dem_wrapper(
     dem_median,
     dem_min,
     dem_max,
-    altitude_delta_min,
-    altitude_delta_max,
     raster_profile,
     saving_info,
     saving_info_global_infos,
@@ -193,10 +193,6 @@ def generate_disp_range_from_dem_wrapper(
     :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.
@@ -216,6 +212,13 @@ def generate_disp_range_from_dem_wrapper(
     :rtype: dict
     """
 
+    # compute reverse matrix
+    transform_sensor = inputs.rasterio_get_transform(
+        sensor_image_right["image"]["main_file"], convention="north"
+    )
+
+    trans_inv_sensor = ~transform_sensor
+
     # Geometry plugin
     geo_plugin = geom_plugin_with_dem_and_geoid
 
@@ -275,15 +278,14 @@ def generate_disp_range_from_dem_wrapper(
         (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)
-    transform_sensor = inputs.rasterio_get_transform(
-        sensor_image_right["image"]["main_file"]
+    sensor_bbox = geo_plugin.sensor_position_from_grid(
+        grid_right, epi_bbox, interpolation_method="linear"
     )
     row_sensor_bbox, col_sensor_bbox = transform_physical_point_to_index(
-        ~transform_sensor, sensor_bbox[:, 1], sensor_bbox[:, 0]
+        trans_inv_sensor, sensor_bbox[:, 1], sensor_bbox[:, 0]
     )
 
-    terrain_bbox = geo_plugin.direct_loc(
+    terrain_bbox = geo_plugin.safe_direct_loc(
         sensor_image_right["image"]["main_file"],
         sensor_image_right["geomodel"],
         col_sensor_bbox,
@@ -340,18 +342,26 @@ def generate_disp_range_from_dem_wrapper(
     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
+    # 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
+    )
+    if dem_min_list is None or dem_max_list is None:
+        logging.warning("DEM min and DEM max does not cover this tile")
+        disp_range, global_infos = empty_disparity_grids(
+            row_range_no_margin,
+            col_range_no_margin,
+            epipolar_grid_array_window,
+            raster_profile,
+            saving_info,
+            saving_info_global_infos,
         )
-        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
+        return disp_range, global_infos
+
+    nan_mask = nan_mask & ~np.isnan(dem_min_list) & ~np.isnan(dem_max_list)
 
     # filter nan value from input points
     lon_mean = lon_mean[nan_mask]
@@ -365,7 +375,7 @@ def generate_disp_range_from_dem_wrapper(
         ind_cols_sensor,
         ind_rows_sensor,
         _,
-    ) = geom_plugin_with_dem_and_geoid.inverse_loc(
+    ) = geom_plugin_with_dem_and_geoid.safe_inverse_loc(
         sensor_image_right["image"]["main_file"],
         sensor_image_right["geomodel"],
         lat_mean,
@@ -394,71 +404,27 @@ def generate_disp_range_from_dem_wrapper(
                     2,
                 ),
             ),
+            interpolation_method="linear",
         )
     )
 
-    # compute reverse matrix
-    transform_sensor = rasterio.Affine(
-        *np.abs(
-            inputs.rasterio_get_transform(
-                sensor_image_right["image"]["main_file"]
-            )
+    # 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]
         )
     )
 
-    trans_inv = ~transform_sensor
-    # Transform to positive values
-    trans_inv = np.array(trans_inv)
-    trans_inv = np.reshape(trans_inv, (3, 3))
-    if trans_inv[0, 0] < 0:
-        trans_inv[0, :] *= -1
-    if trans_inv[1, 1] < 0:
-        trans_inv[1, :] *= -1
-    trans_inv = affine.Affine(*list(trans_inv.flatten()))
-
-    # Transform physical position to index
-    index_positions = np.empty(sensors_positions.shape)
-    for row_point in range(index_positions.shape[0]):
-        row_geo, col_geo = sensors_positions[row_point, :]
-        col, row = trans_inv * (row_geo, col_geo)
-        index_positions[row_point, :] = (row, col)
-
-    ind_rows_sensor_grid = index_positions[:, 0] - 0.5
-    ind_cols_sensor_grid = index_positions[:, 1] - 0.5
-
     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,
+        disp_range, global_infos = empty_disparity_grids(
+            row_range_no_margin,
+            col_range_no_margin,
+            epipolar_grid_array_window,
             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
+            saving_info,
+            saving_info_global_infos,
         )
-
         return disp_range, global_infos
 
     # Interpolate disparity
@@ -548,6 +514,56 @@ def generate_disp_range_from_dem_wrapper(
     return disp_range, global_infos
 
 
+def empty_disparity_grids(  # pylint: disable=too-many-positional-arguments
+    row_range_no_margin,
+    col_range_no_margin,
+    epipolar_grid_array_window,
+    raster_profile,
+    saving_info,
+    saving_info_global_infos,
+):
+    """
+    Return empty disparity grids
+    :param row_range_no_margin: Rows id in grid
+    :type row_range_no_margin: int
+    :param col_range_no_margin: Cols id in grid
+    :type col_range_no_margin: int
+    :param epipolar_grid_array_window: ROI of grid
+    :type epipolar_grid_array_window: dict
+    :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
+    """
+    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
+
+
 def create_circular_mask(height, width):
     """
     Create a circular mask for footprint around pixel

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"
+}