fix: better handling of disparity grids, test fixes, disparity range inversion

Author: Marian Rassat

src/pandora/matching_cost/cpp/includes/matching_cost.hpp

@@ -41,4 +41,16 @@ py::array_t<float> reverse_cost_volume(
     int min_disp
 );
 
+/**
+ * @brief Create the right disp ranges from the left disp ranges
+ *
+ * @param left_min: the 2D left disp min array, with dimensions row, col
+ * @param left_max: the 2D left disp min array, with dimensions row, col
+ * @return: The min and max disp ranges for the right image
+ */
+std::tuple<py::array_t<float>, py::array_t<float>> reverse_disp_range(
+    py::array_t<float> left_min,
+    py::array_t<float> left_max
+);
+
 #endif  // MATCHING_COST_HPP

src/pandora/matching_cost/cpp/matching_cost_cpp.pyi

@@ -49,3 +49,15 @@ def reverse_cost_volume(left_cv, disp_min):
     :rtype: 3D np.ndarray of type float32
     """
     ...
+
+def reverse_disp_range(left_min, left_max):
+    """
+    Create the right disp ranges from the left disp ranges
+    :param left_min: the 2D left disp min array, with dimensions row, col
+    :type left_min: np.ndarray(dtype=float32)
+    :param left_max: the 2D left disp max array, with dimensions row, col
+    :type left_max: np.ndarray(dtype=float32)
+    :return: The min and max disp ranges for the right image
+    :rtype: Tuple[np.ndarray(dtype=float32), np.ndarray(dtype=float32)]
+    """
+    return None, None

src/pandora/matching_cost/cpp/src/bindings.cpp

@@ -38,4 +38,10 @@ PYBIND11_MODULE(matching_cost_cpp, m) {
         "Computes right cost volume from left cost volume."
     );
 
+    m.def(
+        "reverse_disp_range",
+        &reverse_disp_range,
+        "Computes the right disp range from the left one."
+    );
+
 }

src/pandora/matching_cost/cpp/src/matching_cost.cpp

@@ -18,6 +18,8 @@
  */
 
 #include "matching_cost.hpp"
+#include <cmath>
+#include <limits>
 
 namespace py = pybind11;
 
@@ -51,4 +53,80 @@ py::array_t<float> reverse_cost_volume(
     }
 
     return right_cv;
+}
+
+
+std::tuple<py::array_t<float>, py::array_t<float>> reverse_disp_range(
+    py::array_t<float> left_min,
+    py::array_t<float> left_max
+) {
+    auto r_left_min = left_min.unchecked<2>();
+    auto r_left_max = left_max.unchecked<2>();
+    
+    size_t n_row = r_left_min.shape(0);
+    size_t n_col = r_left_min.shape(1);
+
+    py::array_t<float> right_min = py::array_t<float>({n_row, n_col});
+    py::array_t<float> right_max = py::array_t<float>({n_row, n_col});
+    auto rw_right_min = right_min.mutable_unchecked<2>();
+    auto rw_right_max = right_max.mutable_unchecked<2>();
+
+    // init the min and max values at inf
+    for (size_t row = 0; row < n_row; ++row) {
+        for (size_t col = 0; col < n_col; ++col) {
+            rw_right_min(row, col) =  std::numeric_limits<float>::infinity();
+            rw_right_max(row, col) = -std::numeric_limits<float>::infinity();
+        }
+    }
+
+    for (size_t row = 0; row < n_row; ++row) {
+        for (size_t col = 0; col < n_col; ++col) {
+
+            float d_min_raw = r_left_min(row, col);
+            float d_max_raw = r_left_max(row, col);
+
+            // skip nans
+            if (std::isnan(d_min_raw))
+                continue;
+            if (std::isnan(d_max_raw))
+                continue;
+
+            int d_min = static_cast<int>(d_min_raw);
+            int d_max = static_cast<int>(d_max_raw);
+            
+            for (int d = d_min; d <= d_max; d++) {
+                
+                int right_col = static_cast<int>(col) + d;
+                
+                // increment d when right_col is too low, break when too high
+                if (right_col < 0)
+                    continue;
+                if (right_col >= static_cast<int>(n_col))
+                    break;
+
+                // update mins and maxs with -d to reach left_img(row, col) from
+                // right_img(row, right_col)
+                rw_right_min(row, right_col) = std::min(
+                    rw_right_min(row, right_col), static_cast<float>(-d)
+                );
+                rw_right_max(row, right_col) = std::max(
+                    rw_right_max(row, right_col), static_cast<float>(-d)
+                );
+                
+            }
+
+        }
+    }
+
+    // set the disp ranges that have not been filled to nan
+    for (size_t row = 0; row < n_row; ++row) {
+        for (size_t col = 0; col < n_col; ++col) {
+            if ( std::isinf(rw_right_min(row, col)) ) {
+                rw_right_min(row, col) = std::nanf("");
+                rw_right_max(row, col) = std::nanf("");
+            }
+        }
+    }
+
+    return {right_min, right_max};
 }

src/pandora/matching_cost/matching_cost.py

@@ -915,3 +915,17 @@ def reverse_cost_volume(left_cv: np.ndarray, disp_min: int) -> np.ndarray:
         :rtype: 3D np.ndarray of type float32
         """
         return matching_cost_cpp.reverse_cost_volume(left_cv, disp_min)
+
+    @staticmethod
+    def reverse_disp_range(left_min: np.ndarray, left_max: np.ndarray) -> np.ndarray:
+        """
+        Create the right disp ranges from the left disp ranges
+
+        :param left_min: the 2D left disp min array, with dimensions row, col
+        :type left_min: np.ndarray(dtype=float32)
+        :param left_max: the 2D left disp max array, with dimensions row, col
+        :type left_max: np.ndarray(dtype=float32)
+        :return: The min and max disp ranges for the right image
+        :rtype: Tuple[np.ndarray(dtype=float32), np.ndarray(dtype=float32)]
+        """
+        return matching_cost_cpp.reverse_disp_range(left_min, left_max)

src/pandora/state_machine.py

@@ -57,7 +57,6 @@
     semantic_segmentation,
 )
 from pandora.margins import GlobalMargins
-from pandora.img_tools import rasterio_open
 
 from pandora.criteria import validity_mask
 
@@ -315,9 +314,19 @@ def matching_cost_prepare(self, cfg: Dict[str, dict], input_step: str) -> None:
             self.right_disp_min = self.right_disp_min * self.scale_factor
             self.right_disp_max = self.right_disp_max * self.scale_factor
 
-            self.right_cv = self.matching_cost_.allocate_cost_volume(
-                self.right_img, (self.right_disp_min, self.right_disp_max), cfg
-            )
+            if self.right_disp_map == "cross_checking_accurate":
+                # allocate the cost volume the standard way
+                self.right_cv = self.matching_cost_.allocate_cost_volume(
+                    self.right_img, (self.right_disp_min, self.right_disp_max), cfg
+                )
+
+            elif self.right_disp_map == "cross_checking_fast":
+                # the right cv may have a different size from left cv if created from its disp range
+                # (ex: with the test disparity grids)
+                # create it from the left disps instead, to match the left cv's size
+                self.right_cv = self.matching_cost_.allocate_cost_volume(
+                    self.right_img, (-self.disp_max, -self.disp_min), cfg
+                )
 
             # Compute validity mask to identify invalid points in cost volume
             self.right_cv = validity_mask(self.right_img, self.left_img, self.right_cv)
@@ -426,7 +435,7 @@ def disparity_run(self, cfg: Dict[str, dict], input_step: str) -> None:
             # Fast cross checking is used, compute right cv at wta time
             # Compute right cost volume and mask it
             self.right_cv["cost_volume"].data = matching_cost.AbstractMatchingCost.reverse_cost_volume(
-                self.left_cv["cost_volume"].data, self.right_disp_min.min()
+                self.left_cv["cost_volume"].data, np.nanmin(self.right_disp_min)
             )
 
             self.right_cv.attrs["type_measure"] = self.left_cv.attrs["type_measure"]
@@ -638,8 +647,10 @@ def run_prepare(
                 self.right_disp_min = right_img["disparity"].sel(band_disp="min").data
                 self.right_disp_max = right_img["disparity"].sel(band_disp="max").data
             else:
-                self.right_disp_min = -left_img["disparity"].sel(band_disp="max").data
-                self.right_disp_max = -left_img["disparity"].sel(band_disp="min").data
+                # Right disparities : always infered from left disparities
+                self.right_disp_min, self.right_disp_max = matching_cost.AbstractMatchingCost.reverse_disp_range(
+                    self.disp_min, self.disp_max
+                )
 
         # Initiate output disparity datasets
         self.left_disparity = xr.Dataset()
@@ -875,31 +886,11 @@ def validation_check_conf(self, cfg: Dict[str, dict], input_step: str) -> None:
         # If both disp bounds are lists, check that they add up
         if isinstance(ds_left, list) and isinstance(ds_right, list):
             if ds_left[0] != -ds_right[1] or ds_left[1] != -ds_right[0]:
-                raise AttributeError(
-                    "The cross-checking step can't be processed if disp_min, disp_max, disp_right_min, disp_right_max "
-                    "are all ints and disp_min != -disp_right_max or disp_max != -disp_right_min"
-                )
+                raise AttributeError("disp_min != -disp_right_max or disp_max != -disp_right_min")
 
-        # If both disp bounds are strs, check that their global min/max adds up
+        # If both disp bounds are strs, warn that the right disp will be ignored
         elif isinstance(ds_left, str) and isinstance(ds_right, str):
-            left_img = rasterio_open(ds_left).read()
-            right_img = rasterio_open(ds_right).read()
-
-            left_min = left_img.min()
-            left_max = left_img.max()
-            right_min = right_img.min()
-            right_max = right_img.max()
-
-            if left_min != -right_max or left_max != -right_min:
-                raise AttributeError(
-                    "The cross-checking step can't be processed if "
-                    "disp_min != -disp_right_max or disp_max != -disp_right_min"
-                )
-
-        elif type(ds_left) != type(ds_right) and ds_left is not None and ds_right is not None:
-            raise AttributeError(
-                "The cross-checking step does not support left and right disparities of different kinds at this time."
-            )
+            logging.warning("The right disp will be ignored, and instead computed from the left disp.")
 
     def multiscale_check_conf(self, cfg: Dict[str, dict], input_step: str) -> None:
         """

tests/functional_tests/test_validation.py

@@ -158,29 +158,3 @@ def test_validation_fast(self, tmp_path, user_cfg):
 
         # Check they are *strictly* equal
         assert error(result_fast, result_accurate, threshold=0) == 0
-
-    def test_validation_method_is_mandatory(self):
-        """
-        Test that there's a crash when not giving validation_method
-        """
-        with pytest.raises(KeyError):
-            validation_ = validation.AbstractValidation(**{"something's wrong": "b"})  # type: ignore
-
-    def test_fails_with_invalid_method(self):
-        """
-        Test that there's a crash when giving a validation method that doesn't exist
-        """
-        with pytest.raises(KeyError):
-            validation_ = validation.AbstractValidation(**{"validation_method": "hello"})  # type: ignore
-
-    def test_right_instance_created(self):
-        """
-        Test that the right instance is created when creating specific validation method objects
-        """
-        validation_ = validation.AbstractValidation(**{"validation_method": "cross_checking_fast"})  # type: ignore
-        assert isinstance(validation_, validation.AbstractValidation)
-        assert isinstance(validation_, CrossCheckingAccurate)  # the instance is the same for both methods
-
-        validation_ = validation.AbstractValidation(**{"validation_method": "cross_checking_accurate"})  # type: ignore
-        assert isinstance(validation_, validation.AbstractValidation)
-        assert isinstance(validation_, CrossCheckingAccurate)

tests/test_config.py

@@ -522,8 +522,8 @@ def test_check_conf(self):
             "pipeline": copy.deepcopy(common.validation_pipeline_cfg),
         }
 
-        # When left disparities are grids and right are none, cross checking method cannot be used : the program exits
-        self.assertRaises(MachineError, check_configuration.check_conf, cfg, pandora_machine)
+        # When left disparities are grids and right are none, cross checking should succeed
+        check_configuration.check_conf(cfg, pandora_machine)
 
         # Check the configuration returned with left and right disparity grids and cross checking method
         cfg = {

tests/test_validation.py

@@ -25,13 +25,15 @@
 """
 
 import unittest
+import pytest
 
 import numpy as np
 import xarray as xr
 
 from tests import common
 import pandora.constants as cst
 from pandora import validation
+from pandora.validation.validation import CrossCheckingAccurate
 
 
 class TestValidation(unittest.TestCase):
@@ -73,6 +75,32 @@ def setUp(self):
         )
         self.right.attrs["offset_row_col"] = 0
 
+    def test_validation_method_is_mandatory(self):
+        """
+        Test that there's a crash when not giving validation_method
+        """
+        with pytest.raises(KeyError):
+            validation.AbstractValidation(**{"something's wrong": "b"})  # type: ignore
+
+    def test_fails_with_invalid_method(self):
+        """
+        Test that there's a crash when giving a validation method that doesn't exist
+        """
+        with pytest.raises(KeyError):
+            validation.AbstractValidation(**{"validation_method": "hello"})  # type: ignore
+
+    def test_right_instance_created(self):
+        """
+        Test that the right instance is created when creating specific validation method objects
+        """
+        validation_ = validation.AbstractValidation(**{"validation_method": "cross_checking_fast"})  # type: ignore
+        assert isinstance(validation_, validation.AbstractValidation)
+        assert isinstance(validation_, CrossCheckingAccurate)  # the instance is the same for both methods
+
+        validation_ = validation.AbstractValidation(**{"validation_method": "cross_checking_accurate"})  # type: ignore
+        assert isinstance(validation_, validation.AbstractValidation)
+        assert isinstance(validation_, CrossCheckingAccurate)
+
     def test_cross_checking(self):
         """
         Test the confidence measure and the validity_mask for the cross checking method,