cars 1.0.0a1__cp39-cp39-win_amd64.whl → 1.0.0a2__cp39-cp39-win_amd64.whl

cars/applications/dense_matching/dense_matching_algo.py

@@ -40,15 +40,20 @@ from scipy.interpolate import (
     RegularGridInterpolator,
 )
 
-# CARS imports
-from cars.applications.dense_matching import (
-    dense_matching_constants as dense_match_cst,
-)
 from cars.applications.dense_matching import dense_matching_wrappers as dm_wrap
+
+# CARS imports
 from cars.core import constants as cst
+from cars.core import inputs
 
 
-def compute_disparity_grid(disp_range_grid, left_image_object):
+def compute_disparity_grid(
+    disp_range_grid,
+    left_image_object,
+    right_image_object,
+    used_band,
+    threshold_disp_range_to_borders,
+):
     """
     Compute dense disparity grids min and max for pandora
     superposable to left image
@@ -61,20 +66,30 @@ def compute_disparity_grid(disp_range_grid, left_image_object):
     :return disp min map, disp_max_map
     :rtype np.ndarray, np.ndarray
     """
+
+    disp_min_grid_arr, _ = inputs.rasterio_read_as_array(
+        disp_range_grid["grid_min_path"]
+    )
+    disp_max_grid_arr, _ = inputs.rasterio_read_as_array(
+        disp_range_grid["grid_max_path"]
+    )
+    row_range = disp_range_grid["row_range"]
+    col_range = disp_range_grid["col_range"]
+
     # Create interpolators
     interp_min = RegularGridInterpolator(
         (
-            disp_range_grid.attributes["row_range"],
-            disp_range_grid.attributes["col_range"],
+            row_range,
+            col_range,
         ),
-        disp_range_grid[0, 0][dense_match_cst.DISP_MIN_GRID].values,
+        disp_min_grid_arr,
     )
     interp_max = RegularGridInterpolator(
         (
-            disp_range_grid.attributes["row_range"],
-            disp_range_grid.attributes["col_range"],
+            row_range,
+            col_range,
         ),
-        disp_range_grid[0, 0][dense_match_cst.DISP_MAX_GRID].values,
+        disp_max_grid_arr,
     )
 
     # Interpolate disp on grid
@@ -88,6 +103,39 @@ def compute_disparity_grid(disp_range_grid, left_image_object):
     disp_min_grid = interp_min((row_grid, col_grid)).astype("float32")
     disp_max_grid = interp_max((row_grid, col_grid)).astype("float32")
 
+    # Compute extremums of disparity considering left image borders
+    if threshold_disp_range_to_borders:
+        disp_min_from_borders = np.zeros_like(disp_min_grid)
+        disp_max_from_borders = np.zeros_like(disp_max_grid)
+        right_msk = (
+            np.array(right_image_object[cst.EPI_MSK].loc[used_band]) == 0
+        )
+        index_of_first_valid_pixel = np.argmax(right_msk, axis=1)
+        index_of_last_valid_pixel = np.argmax(
+            np.flip(right_msk, axis=1), axis=1
+        )
+        index_of_last_valid_pixel = (
+            right_msk.shape[1] - index_of_last_valid_pixel
+        )
+        any_valid_pixel_exists = np.any(right_msk, axis=1)
+        right_msk_indices = zip(  # noqa: B905
+            index_of_first_valid_pixel,
+            index_of_last_valid_pixel,
+            any_valid_pixel_exists,
+        )
+        for row_id, (first, last, exists) in enumerate(right_msk_indices):
+            if exists:
+                disp_min_from_borders[row_id, first:last] = np.flip(
+                    np.arange(first - last, 0)
+                )
+                disp_max_from_borders[row_id, first:last] = np.flip(
+                    np.arange(0, last - first)
+                )
+        disp_min_from_borders = np.minimum(disp_max_grid, disp_min_from_borders)
+        disp_max_from_borders = np.maximum(disp_min_grid, disp_max_from_borders)
+        disp_min_grid = np.maximum(disp_min_from_borders, disp_min_grid)
+        disp_max_grid = np.minimum(disp_max_from_borders, disp_max_grid)
+
     # Interpolation might create min > max
     disp_min_grid, disp_max_grid = dm_wrap.to_safe_disp_grid(
         disp_min_grid, disp_max_grid

cars/applications/dense_matching/dense_matching_wrappers.py

@@ -658,17 +658,32 @@ def add_confidence(
         disp.confidence_measure.indicator
     )
     for key in confidence_measure_indicator_list:
-        confidence_idx = list(disp.confidence_measure.indicator).index(key)
-        output_dataset[key] = xr.DataArray(
-            np.copy(
-                disp.confidence_measure.data[
-                    :,
-                    :,
-                    confidence_idx,
-                ]
-            ),
-            dims=[cst.ROW, cst.COL],
-        )
+        if key == "confidence_from_ambiguity.cars_1":
+            confidence_idx = list(disp.confidence_measure.indicator).index(key)
+
+            output_dataset["ambiguity"] = xr.DataArray(
+                1
+                - np.copy(
+                    disp.confidence_measure.data[
+                        :,
+                        :,
+                        confidence_idx,
+                    ]
+                ),
+                dims=[cst.ROW, cst.COL],
+            )
+        else:
+            confidence_idx = list(disp.confidence_measure.indicator).index(key)
+            output_dataset[str(key)] = xr.DataArray(
+                np.copy(
+                    disp.confidence_measure.data[
+                        :,
+                        :,
+                        confidence_idx,
+                    ]
+                ),
+                dims=[cst.ROW, cst.COL],
+            )
 
 
 def to_safe_disp_grid(grid_disp_min, grid_disp_max):
@@ -880,34 +895,39 @@ def confidence_filtering(
     :type conf_filtering: dict
     """
 
-    data_risk = dataset[requested_confidence[0]].values
-    data_bounds_sup = dataset[requested_confidence[1]].values
+    data_risk_inf = dataset[requested_confidence[0]].values
+    data_risk_sup = dataset[requested_confidence[1]].values
+    risk_range = data_risk_sup - data_risk_inf
+
+    data_bounds_inf = dataset[requested_confidence[2]].values
+    data_bounds_sup = dataset[requested_confidence[3]].values
+    bounds_range = data_bounds_sup - data_bounds_inf
+
+    disp_min = dataset["disp_min_grid"].values
+    disp_max = dataset["disp_max_grid"].values
+
+    risk_ratio = risk_range / (disp_max - disp_min)
+    bounds_ratio = bounds_range / (disp_max - disp_min)
 
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=RuntimeWarning)
         nan_ratio = generic_filter(
             disp_map, nan_ratio_func, size=conf_filtering["win_nanratio"]
         )
-        var_map = generic_filter(
-            data_risk, np.nanmean, size=conf_filtering["win_mean_risk_max"]
-        )
 
-    mask = (
-        (data_bounds_sup > conf_filtering["upper_bound"])
-        | (data_bounds_sup <= conf_filtering["lower_bound"])
-    ) | (
-        (var_map > conf_filtering["risk_max"])
-        & (nan_ratio > conf_filtering["nan_threshold"])
+    bounds_mask = (bounds_ratio > conf_filtering["bounds_ratio_threshold"]) & (
+        bounds_range > conf_filtering["bounds_range_threshold"]
     )
-
+    risk_mask = (risk_ratio > conf_filtering["risk_ratio_threshold"]) & (
+        risk_range > conf_filtering["risk_range_threshold"]
+    )
+    mask = bounds_mask | risk_mask
     dataset["disp"].values[mask] = np.nan
     dataset["disp_msk"].values[mask] = 0
 
-    dims = list(dataset.sizes.keys())[:2]
-
-    var_mean_risk = xr.DataArray(var_map, dims=dims)
-    var_nan_ratio = xr.DataArray(nan_ratio, dims=dims)
-
-    # We add the new variables to the dataset
-    dataset["confidence_from_mean_risk_max"] = var_mean_risk
-    dataset["confidence_from_nanratio"] = var_nan_ratio
+    mask = (nan_ratio > conf_filtering["nan_threshold"]) & (
+        (bounds_range > conf_filtering["bounds_range_threshold"])
+        | (risk_range > conf_filtering["risk_range_threshold"])
+    )
+    dataset["disp"].values[mask] = np.nan
+    dataset["disp_msk"].values[mask] = 0