misc: removed numba from deps, removed mentions of numba in comments

Author: Marian Rassat

.github/workflows/pandora_ci.yml

@@ -26,7 +26,6 @@ jobs:
 
     - name: Test with pytest
       run: |
-        export NUMBA_DISABLE_JIT="1"
         pytest -m "not notebook_tests" --junitxml=pytest-report.xml --cov-config=.coveragerc --cov-report xml --cov
 
     - name: Upload coverage to Codecov

NOTICE

@@ -27,11 +27,6 @@ Copyright (C) 2016 Jason R Coombs <[email protected]>
 Website: https://setuptools.readthedocs.io/
 License: MIT.
 
-Numba: NumPy aware dynamic Python compiler using LLVM
-Copyright (c) 2012, Anaconda, Inc.
-Website: https://numba.pydata.org/
-License: BSD 2 Clause.
-
 Xarray: N-D labeled arrays and datasets in Python
 Copyright 2014-2019, xarray Developers
 Website: http://xarray.pydata.org

docs/source/getting_started.rst

@@ -64,7 +64,7 @@ Credits
 
 Pandora uses `transitions <https://github.com/pytransitions/transitions>`_ to manage the pipelines one can create.
 Images I/O are provided by `rasterio <https://github.com/mapbox/rasterio>`_ and we use `xarray <https://github.com/pydata/xarray>`_
-to handle 3D Cost Volumes with few `numba <https://github.com/numba/numba>`_ optimisations.
+to handle 3D Cost Volumes.
 
 Our data test sample is based on the 2003 Middleburry dataset [Scharstein2003]_.
 

docs/source/userguide/faq.rst

@@ -120,15 +120,3 @@ And the python script.
 
     # Check datasets: shape, format and content
     check_datasets(img_left, img_right)
-
-How can I disable numba parallelization?
-****************************************
-
-Some functions of Pandora are parallelized using the numba package. To prevent the use of this tool, it is possible to set
-an environment variable named **PANDORA_NUMBA_PARALLEL** to **false**.
-
-How can I disable numba cache?
-******************************
-
-Some Pandora functions have a cache of the numba package. This cache can improve execution speed. To do this, you can set
-an environment variable named **PANDORA_NUMBA_PAR** to **true**.

mypy.ini

@@ -17,8 +17,6 @@ mypy_path = stubs
 ignore_missing_imports = True
 [mypy-setuptools.*]
 ignore_missing_imports = True
-[mypy-numba.*]
-ignore_missing_imports = True
 [mypy-json_checker.*]
 ignore_missing_imports = True
 [mypy-scipy.*]

notebooks/notebook_requirements.txt

@@ -4,8 +4,6 @@ xarray>=0.13.0
 scipy
 rasterio
 json-checker
-numba>=0.55.2;python_version>'3.7'
-numba>=0.47.0;python_version<'3.8'
 transitions
 scikit-image>=0.19.0
 jupyter-dash

pandora/aggregation/cbca.py

@@ -241,7 +241,7 @@ def computes_cross_supports(
         left_masked = filter_.median_filter(left_masked)  # type: ignore
         # Convert nan to inf to be able to use the comparison operators < and > in cross_support function
         np.nan_to_num(left_masked, copy=False, nan=np.inf)
-        # Compute left cross support using numba to reduce running time
+        # Compute left cross support using C++ to reduce running time
         if offset != 0:
             # Cross support to the size of the cost volume
             cross_left = aggregation_cpp.cross_support(
@@ -289,7 +289,7 @@ def computes_cross_supports(
             right_masked = filter_.median_filter(right_masked)  # type: ignore
             # Convert nan to inf to be able to use the comparison operators < and > in cross_support function
             np.nan_to_num(right_masked, copy=False, nan=np.inf)
-            # Compute right cross support using numba to reduce running time
+            # Compute right cross support using C++ to reduce running time
             if offset != 0:
                 # Cross support to the size of the cost volume
                 curr_c_r = aggregation_cpp.cross_support(

pandora/aggregation/cpp/aggregation_cpp.pyi

@@ -86,4 +86,3 @@ def cross_support(image, len_arms, intensity):
     :rtype:  3D np.array ( row, col, [left, right, top, bot] ), dtype=np.int16
     """
     ...
-

pandora/cost_volume_confidence/ambiguity.py

@@ -135,13 +135,9 @@ def confidence_prediction(
 
         type_measure_min = cv.attrs["type_measure"] == "min"
 
-        # This silences numba's TBB threading layer warning
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore")
-            # Computes ambiguity using numba in parallel for memory and computation time optimization
-            ambiguity = cost_volume_confidence_cpp.compute_ambiguity(
-                cv["cost_volume"].data, self._etas, self._nbr_etas, grids, disparity_range, type_measure_min
-            )
+        ambiguity = cost_volume_confidence_cpp.compute_ambiguity(
+            cv["cost_volume"].data, self._etas, self._nbr_etas, grids, disparity_range, type_measure_min
+        )
 
         # If activated, ambiguity normalization with percentile
         if self._normalization:

pandora/cost_volume_confidence/interval_bounds.py

@@ -157,31 +157,28 @@ def confidence_prediction(
         else:
             type_factor = 1.0
 
-        # This silences numba's TBB threading layer warning
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore")
-            # Computes interval bounds using numpy
-            interval_bound_inf, interval_bound_sup = self.compute_interval_bounds(
-                cv["cost_volume"].data, cv["disp"].data.astype(np.float32), self._possibility_threshold, type_factor
+        # Computes interval bounds using numpy
+        interval_bound_inf, interval_bound_sup = self.compute_interval_bounds(
+            cv["cost_volume"].data, cv["disp"].data.astype(np.float32), self._possibility_threshold, type_factor
+        )
+        if self._regularization:
+            indicator = (
+                "confidence_from_ambiguity"
+                if (self._ambiguity_indicator == "")
+                else "confidence_from_ambiguity." + self._ambiguity_indicator
             )
-            if self._regularization:
-                indicator = (
-                    "confidence_from_ambiguity"
-                    if (self._ambiguity_indicator == "")
-                    else "confidence_from_ambiguity." + self._ambiguity_indicator
-                )
-                interval_bound_inf, interval_bound_sup, _ = interval_regularization(
-                    interval_bound_inf,
-                    interval_bound_sup,
-                    cv.confidence_measure.sel({"indicator": indicator}).data,
-                    self._ambiguity_threshold,
-                    self._ambiguity_kernel_size,
-                    self._vertical_depth,
-                    self._quantile_regularization,
-                )
-            # For empty cost volume, the interval gets its max length
-            # interval_bound_inf[np.isnan(interval_bound_inf)] = cv["disp"].data.astype(np.float32)[0]
-            # interval_bound_sup[np.isnan(interval_bound_sup)] = cv["disp"].data.astype(np.float32)[-1]
+            interval_bound_inf, interval_bound_sup, _ = interval_regularization(
+                interval_bound_inf,
+                interval_bound_sup,
+                cv.confidence_measure.sel({"indicator": indicator}).data,
+                self._ambiguity_threshold,
+                self._ambiguity_kernel_size,
+                self._vertical_depth,
+                self._quantile_regularization,
+            )
+        # For empty cost volume, the interval gets its max length
+        # interval_bound_inf[np.isnan(interval_bound_inf)] = cv["disp"].data.astype(np.float32)[0]
+        # interval_bound_sup[np.isnan(interval_bound_sup)] = cv["disp"].data.astype(np.float32)[-1]
 
         disp, cv = self.allocate_confidence_map(self._indicator_inf, interval_bound_inf, disp, cv)
         disp, cv = self.allocate_confidence_map(self._indicator_sup, interval_bound_sup, disp, cv)

pandora/cost_volume_confidence/risk.py

@@ -130,31 +130,26 @@ def confidence_prediction(
         )
         # Get disparity intervals parameters
         disparity_range = cv["disp"].data.astype(np.float32)
-        # This silences numba's TBB threading layer warning
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore")
-
-            _, sampled_ambiguity = cost_volume_confidence_cpp.compute_ambiguity_and_sampled_ambiguity(
-                cv["cost_volume"].data, self._etas, self._nbr_etas, grids, disparity_range
-            )
-
-            if "global_disparity" in img_left.attrs:
-                sampled_ambiguity = self.normalize_with_extremum(sampled_ambiguity, img_left, self._nbr_etas)
-                logging.info(
-                    "You are using normalization by \n a specific case with the instantiation of global_disparity"
-                )
-            # in case of cross correlation
-            elif "global_disparity" in img_right.attrs:
-                sampled_ambiguity = self.normalize_with_extremum(sampled_ambiguity, img_right, self._nbr_etas)
-
-            risk_max, risk_min = self.compute_risk(
-                cv["cost_volume"].data,
-                sampled_ambiguity,
-                self._etas,
-                self._nbr_etas,
-                grids,
-                disparity_range,
-            )
+
+        _, sampled_ambiguity = cost_volume_confidence_cpp.compute_ambiguity_and_sampled_ambiguity(
+            cv["cost_volume"].data, self._etas, self._nbr_etas, grids, disparity_range
+        )
+
+        if "global_disparity" in img_left.attrs:
+            sampled_ambiguity = self.normalize_with_extremum(sampled_ambiguity, img_left, self._nbr_etas)
+            logging.info("You are using normalization by \n a specific case with the instantiation of global_disparity")
+        # in case of cross correlation
+        elif "global_disparity" in img_right.attrs:
+            sampled_ambiguity = self.normalize_with_extremum(sampled_ambiguity, img_right, self._nbr_etas)
+
+        risk_max, risk_min = self.compute_risk(
+            cv["cost_volume"].data,
+            sampled_ambiguity,
+            self._etas,
+            self._nbr_etas,
+            grids,
+            disparity_range,
+        )
 
         disp, cv = self.allocate_confidence_map(self._indicator_max, risk_max, disp, cv)
         disp, cv = self.allocate_confidence_map(self._indicator_min, risk_min, disp, cv)

pandora/cpp/img_tools_cpp.pyi

@@ -22,6 +22,7 @@ def find_valid_neighbors(dirs, disp, valid, row, col, msk_pixel_invalid):
     :rtype: 2D np.ndarray
     """
     ...
+
 def interpolate_nodata_sgm(
     img: np.ndarray, valid: np.ndarray, msk_pixel_invalid: int, msk_pixel_filled_nodata: int
 ) -> Tuple[np.ndarray, np.ndarray]:

pandora/img_tools.py

@@ -552,7 +552,7 @@ def fill_nodata_image(dataset: xr.Dataset) -> Tuple[np.ndarray, np.ndarray]:
             img = dataset["im"].data
             msk = dataset["msk"].data
             nband = dataset["im"].data.shape[0]
-            # We call the function for each band because of numba
+
             for band in range(nband):
                 img[band, :, :], msk[:, :] = interpolate_nodata_sgm(
                     dataset["im"].data[band, :, :],

pandora/refinement/cpp/refinement_cpp.pyi

@@ -100,6 +100,7 @@ def loop_approximate_refinement(
     :rtype: tuple(2D numpy array (row, col), 2D numpy array (row, col), 2D numpy array (row, col))
     """
     ...
+
 def vfit_refinement_method(
     cost, disp, measure, cst_pandora_msk_pixel_stopped_interpolation
 ) -> tuple[float, float, int]:

pandora/refinement/refinement.py

@@ -96,26 +96,22 @@ def subpixel_refinement(self, cv: xr.Dataset, disp: xr.Dataset) -> None:
         subpixel = cv.attrs["subpixel"]
         measure = cv.attrs["type_measure"]
 
-        # This silences numba's TBB threading layer warning
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore")
-            # Conversion to numpy array ( .data ), because Numba does not support Xarray
-            (
-                itp_coeff,
-                disp["disparity_map"].data,
-                disp["validity_mask"].data,
-            ) = refinement_cpp.loop_refinement(
-                cv["cost_volume"].data,
-                disp["disparity_map"].data,
-                disp["validity_mask"].data,
-                d_min,
-                d_max,
-                subpixel,
-                measure,
-                self.refinement_method,
-                cst.PANDORA_MSK_PIXEL_INVALID,
-                cst.PANDORA_MSK_PIXEL_STOPPED_INTERPOLATION,
-            )
+        (
+            itp_coeff,
+            disp["disparity_map"].data,
+            disp["validity_mask"].data,
+        ) = refinement_cpp.loop_refinement(
+            cv["cost_volume"].data,
+            disp["disparity_map"].data,
+            disp["validity_mask"].data,
+            d_min,
+            d_max,
+            subpixel,
+            measure,
+            self.refinement_method,
+            cst.PANDORA_MSK_PIXEL_INVALID,
+            cst.PANDORA_MSK_PIXEL_STOPPED_INTERPOLATION,
+        )
 
         disp.attrs["refinement"] = self._refinement_method_name
         disp["interpolated_coeff"] = xr.DataArray(
@@ -154,26 +150,22 @@ def approximate_subpixel_refinement(self, cv_left: xr.Dataset, disp_right: xr.Da
         subpixel = cv_left.attrs["subpixel"]
         measure = cv_left.attrs["type_measure"]
 
-        # This silences numba's TBB threading layer warning
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore")
-            # Conversion to numpy array ( .data ), because Numba does not support Xarray
-            (
-                itp_coeff,
-                disp_right["disparity_map"].data,
-                disp_right["validity_mask"].data,
-            ) = refinement_cpp.loop_approximate_refinement(
-                cv_left["cost_volume"].data,
-                disp_right["disparity_map"].data,
-                disp_right["validity_mask"].data,
-                d_min,
-                d_max,
-                subpixel,
-                measure,
-                self.refinement_method,
-                cst.PANDORA_MSK_PIXEL_INVALID,
-                cst.PANDORA_MSK_PIXEL_STOPPED_INTERPOLATION,
-            )
+        (
+            itp_coeff,
+            disp_right["disparity_map"].data,
+            disp_right["validity_mask"].data,
+        ) = refinement_cpp.loop_approximate_refinement(
+            cv_left["cost_volume"].data,
+            disp_right["disparity_map"].data,
+            disp_right["validity_mask"].data,
+            d_min,
+            d_max,
+            subpixel,
+            measure,
+            self.refinement_method,
+            cst.PANDORA_MSK_PIXEL_INVALID,
+            cst.PANDORA_MSK_PIXEL_STOPPED_INTERPOLATION,
+        )
 
         disp_right.attrs["refinement"] = self._refinement_method_name
         disp_right["interpolated_coeff"] = xr.DataArray(

pandora/state_machine.py

@@ -61,11 +61,8 @@
 
 from pandora.criteria import validity_mask
 
-# This silences numba's TBB threading layer warning
-with warnings.catch_warnings():
-    warnings.filterwarnings("ignore")
-    from pandora import validation
-    from pandora import cost_volume_confidence
+from pandora import validation
+from pandora import cost_volume_confidence
 from .img_tools import prepare_pyramid
 
 

pandora/validation/cpp/validation_cpp.pyi

@@ -1,5 +1,5 @@
 # pylint: skip-file
-def interpolate_occlusion_sgm(disp, valid, msk_pixel_occlusion, msk_pixel_filled_occlusion, msk_pixel_invalid): 
+def interpolate_occlusion_sgm(disp, valid, msk_pixel_occlusion, msk_pixel_filled_occlusion, msk_pixel_invalid):
     """
     Interpolation of the left disparity map to resolve occlusion conflicts.
     Interpolate occlusion by moving by selecting

pyproject.toml

@@ -24,7 +24,6 @@ dependencies = [
     "scipy",
     "rasterio",
     "json-checker",
-    "numba>=0.55.2;python_version>'3.7'",
     "transitions",
     "scikit-image>=0.19.0",
     "importlib-metadata;python_version<'3.10'"