pyopenrivercam 0.8.11__py3-none-any.whl → 0.9.0__py3-none-any.whl

{pyopenrivercam-0.8.11.dist-info → pyopenrivercam-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenrivercam
-Version: 0.8.11
+Version: 0.9.0
 Summary: pyorc: free and open-source image-based surface velocity and discharge.
 Author-email: Hessel Winsemius <winsemius@rainbowsensing.com>
 Requires-Python: >=3.9
@@ -21,23 +21,22 @@ Requires-Dist: click
 Requires-Dist: cython; platform_machine == 'armv7l'
 Requires-Dist: dask
 Requires-Dist: descartes
-Requires-Dist: ffpiv>=0.1.4
+Requires-Dist: ffpiv>=0.2.0
 Requires-Dist: flox
 Requires-Dist: geojson
 Requires-Dist: geopandas
 Requires-Dist: matplotlib
 Requires-Dist: netCDF4
-Requires-Dist: numba
-Requires-Dist: numpy>=1.23, <2
+Requires-Dist: numba>0.56
+Requires-Dist: numpy>2
 Requires-Dist: opencv-python
-Requires-Dist: openpiv
 Requires-Dist: packaging; platform_machine == 'armv7l'
 Requires-Dist: pip
 Requires-Dist: pyproj
 Requires-Dist: pythran; platform_machine == 'armv7l'
 Requires-Dist: pyyaml
-Requires-Dist: rasterio<1.4.0
-Requires-Dist: scikit-image
+Requires-Dist: rasterio<1.4.0; python_version <= '3.12'
+Requires-Dist: rasterio; python_version > '3.12'
 Requires-Dist: scipy
 Requires-Dist: shapely
 Requires-Dist: tqdm
@@ -112,11 +111,15 @@ We are seeking funding for the following frequently requested functionalities:
 
 If you wish to fund this or other work on features, please contact us at info@rainbowsensing.com.
 
-> **_note:_**  For instructions how to get Anaconda (with lots of pre-installed libraries) or Miniconda (light weight) installed, please go to https://docs.conda.io/projects/conda/en/latest/
+> [!NOTE]
+> For instructions how to get Anaconda (with lots of pre-installed libraries) or Miniconda (light weight) installed,
+> please go to https://docs.conda.io/projects/conda/en/latest/
 
-> **_manual:_** Please go to https://localdevices.github.io/pyorc for the latest documentation
+> [!TIP]
+> Please go to https://localdevices.github.io/pyorc for the latest documentation
 
-> **_compatibility:_** At this moment **pyorc** works with any video compatible with OpenCV as long as it has proper metadata.
+> [!IMPORTANT]
+> At this moment **pyorc** works with any video compatible with OpenCV as long as it has proper metadata.
 
 ## Installation
 You need a python environment. We recommend using the Miniforge project. Download
@@ -158,6 +161,18 @@ pip install pyopenrivercam[extra]
 The `[extra]` section ensures that also geographical plotting is supported, which we recommend especially for the
 set up of a camera configuration with RTK-GPS measured control points.
 
+> [!NOTE]
+>
+> Most of the heavy lifting is done while deriving cross-correlations for estimation of velocity vectors with Particle
+> Image Velocimetry. You can speed up this process (x2) by installing `rocket-fft`. With `python <= 3.12` this
+> is automatically included. With higher versions, you need, for the moment, to install it separately as follows:
+>
+> ```shell
+> pip install git+https://github.com/localdevices/rocket-fft.git
+> ```
+>
+> Once rocket-fft gets updated in PyPi you will no longer need this separate installation procedure.
+
 ### Upgrading from pypi with pip
 
 Did you read about a new version and you want to upgrade? Simply activate your virtual environment, type
@@ -175,6 +190,8 @@ If you use `mamba` as a package manager, then the steps are the same, except for
 ```shell
 mamba install pyopenrivercam
 ```
+The version installed may not have the latest underlying libraries and therefore may be slower than the latest PyPi
+version. We therefore recommend using `pip` for installation (see above).
 
 ### Installation from latest code base
 

pyopenrivercam-0.9.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+pyorc/__init__.py,sha256=yPY8lllCcJb3rKv4-9O6b393ZSX86dAiOSRqAbEBmaQ,523
+pyorc/const.py,sha256=Ia0KRkm-E1lJk4NxQVPDIfN38EBB7BKvxmwIHJrGPUY,2597
+pyorc/cv.py,sha256=t2ZR4eyGbiwlIaGHysOheWdaDQuqpWLKjcTiAUzWAR0,50261
+pyorc/helpers.py,sha256=jed0YyywnpvsZS-8mcA7Lfzn9np1MTlmVLE_PDn2QY0,30454
+pyorc/plot_helpers.py,sha256=gLKslspsF_Z4jib5jkBv2wRjKnHTbuRFgkp_PCmv-uU,1803
+pyorc/project.py,sha256=CGKfICkQEpFRmh_ZeDEfbQ-wefJt7teWJd6B5IPF038,7747
+pyorc/pyorc.sh,sha256=-xOSUNnMAwVbdNkjKNKMZMaBljWsGLhadG-j0DNlJP4,5
+pyorc/sample_data.py,sha256=_yxtjhHc1sjHXZJRWQgBNOOn0Qqs2A5CavyFOQX5p8U,3241
+pyorc/api/__init__.py,sha256=k2OQQH4NrtXTuVm23d0g_SX6H5DhnKC9_kDyzJ4dWdk,428
+pyorc/api/cameraconfig.py,sha256=NP9F7LhPO3aO6FRWkrGl6XpX8O3K59zfTtaYR3Kujqw,65419
+pyorc/api/cross_section.py,sha256=MH0AEw5K1Kc1ClZeQRBUYkShZYVk41fshLn6GzCZAas,65212
+pyorc/api/frames.py,sha256=BnglhmHdbKlIip5tym3x-aICOpQRmm853109A7JkWk8,23189
+pyorc/api/mask.py,sha256=A3TRMqi30L4N491C4FoYY0zvV1GwQ1U31OEkCJp_Nzc,16698
+pyorc/api/orcbase.py,sha256=C23QTKOyxHUafyJsq_t7xn_BzAEvf4DDfzlYAopons8,4189
+pyorc/api/plot.py,sha256=MxIEIS8l46bUaca0GtMazx8-k2_TbfQLrPCPAjuWos8,31082
+pyorc/api/transect.py,sha256=wENKWt0u0lHtT0lPYv47faHf_iAN9Mmeev-vwWjnz6E,13382
+pyorc/api/velocimetry.py,sha256=bfU_XPbUbrdBI2XGprzh_3YADbGHfy4OuS1oBlbLEEI,12047
+pyorc/api/video.py,sha256=lGD6bcV6Uu2u3zuGF_m3KxX2Cyp9k-YHUiXA42TOE3E,22458
+pyorc/cli/__init__.py,sha256=A7hOQV26vIccPnDc8L2KqoJOSpMpf2PiMOXS18pAsWg,32
+pyorc/cli/cli_elements.py,sha256=zX9wv9-1KWC_E3cInGMm3g9jh4uXmT2NqooAMhhXR9s,22165
+pyorc/cli/cli_utils.py,sha256=S7qOO4bintxXDSUl26u3Ujqu4JHb_TNhw5d6psyDrFo,15085
+pyorc/cli/log.py,sha256=Vg8GznmrEPqijfW6wv4OCl8R00Ld_fVt-ULTitaDijY,2824
+pyorc/cli/main.py,sha256=qhAZkUuAViCpHh9c19tpcpbs_xoZJkYHhOsEXJBFXfM,12742
+pyorc/service/__init__.py,sha256=vPrzFlZ4e_GjnibwW6-k8KDz3b7WpgmGcwSDk0mr13Y,55
+pyorc/service/camera_config.py,sha256=OsRLpe5jd-lu6HT4Vx5wEg554CMS-IKz-q62ir4VbPo,2375
+pyorc/service/velocimetry.py,sha256=bPI1OdN_fi0gZES08mb7yqCS_4I-lKSZ2JvWSGTRD1E,34434
+pyorc/velocimetry/__init__.py,sha256=5oShoMocCalcCZuIsBqlZlqQuKJgDDBUvXQIo-uqFPA,88
+pyorc/velocimetry/ffpiv.py,sha256=92XDgzCW4mEZ5ow82zV0APOhfDc1OVftBjKqYdw1zzc,17494
+pyopenrivercam-0.9.0.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
+pyopenrivercam-0.9.0.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+pyopenrivercam-0.9.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pyopenrivercam-0.9.0.dist-info/METADATA,sha256=d2rvFtUmIHAhMBruxLKJ8qEukxEl3y4fZWzAbeeNZ0w,12383
+pyopenrivercam-0.9.0.dist-info/RECORD,,

pyorc/__init__.py

@@ -1,6 +1,6 @@
 """pyorc: free and open-source image-based surface velocity and discharge."""
 
-__version__ = "0.8.11"
+__version__ = "0.9.0"
 
 from .api import CameraConfig, CrossSection, Frames, Transect, Velocimetry, Video, get_camera_config, load_camera_config  # noqa
 from .project import *  # noqa

pyorc/api/cross_section.py

@@ -278,7 +278,7 @@ class CrossSection:
         Parameters
         ----------
         h : float
-            water level [m]
+            water level [m].
         sz : bool, optional
             If set, return water level line in y-z projection, by default False.
         extend_by : float, optional
@@ -613,7 +613,9 @@ class CrossSection:
             raise ValueError("Amount of water line crossings must be 2 for a planar surface estimate.")
         return geometry.Polygon(list(wls[0].coords) + list(wls[1].coords[::-1]))
 
-    def get_wetted_surface_sz(self, h: float, perimeter: bool = False) -> Union[geometry.MultiPolygon, geometry.MultiLineString]:
+    def get_wetted_surface_sz(
+        self, h: float, perimeter: bool = False
+    ) -> Union[geometry.MultiPolygon, geometry.MultiLineString]:
         """Retrieve a wetted surface or perimeter perpendicular to flow direction (SZ) for a water level.
 
         This returns a `geometry.MultiPolygon` when a surface is requested (`perimeter=False`), and
@@ -1097,6 +1099,182 @@ class CrossSection:
             )
         return ax
 
+    def _preprocess_level_range(
+        self,
+        min_h: Optional[float] = None,
+        max_h: Optional[float] = None,
+        min_z: Optional[float] = None,
+        max_z: Optional[float] = None,
+    ):
+        """Set minimum and maximum z-levels (if not provided) based on the camera config."""
+        if min_z is None:
+            if min_h is not None:
+                min_z = self.camera_config.h_to_z(min_h)
+                min_z = np.maximum(min_z, self.z.min())
+        if max_z is None:
+            if max_h is not None:
+                max_z = self.camera_config.h_to_z(max_h)
+                max_z = np.minimum(max_z, self.z.max())
+        if min_z and max_z:
+            # check for z_min < z_max
+            if min_z > max_z:
+                raise ValueError("Minimum water level is higher than maximum water level.")
+        return min_z, max_z
+
+    def _preprocess_l_range(self, l_min: float, l_max: float, ds_max=0.5, dz_max=0.02) -> List[float]:
+        """Generate a list of evaluation points between l_min and l_max for water level detection.
+
+        Controls on evaluation are that vertically (using `self.z`), points are at least `dz_max` meters apart and
+        horizontally (using `self.s`), points are included if the distance between them exceeds `dz_min` meters.
+
+        Parameters
+        ----------
+        l_min: float
+            Minimum l value for evaluation.
+        l_max: float
+            Maximum l value for evaluation.
+        ds_max : float, optional
+            maximum step size between evaluation points in horizontal direction, by default 0.5.
+        dz_max : float, optional
+            maximum step size between evaluation points in vertical direction, by default 0.02.
+
+        Returns
+        -------
+        Tuple[List[float], List[float]]
+            lists of l-coordinates and associated z-coordinates for evaluation.
+
+        """
+        # # Initial list of evaluation points
+        # l_range = []
+        # z_range = []
+        # Start with the first point within the range
+        current_l = l_min
+        last_z = None
+        last_s = None
+
+        # Add all points from self.l that lie within [l_min, l_max]
+        valid_l_indices = (self.l >= l_min) & (self.l <= l_max)  # Logical filter
+        l_range = list(self.l[valid_l_indices])
+        z_range = list(self.z[valid_l_indices])
+
+        # Iterate over the self.l values by interpolating within the range
+        while current_l <= l_max:
+            # Interpolate x, y, z, and s using the available properties
+            # x = self.interp_x(current_l)
+            # y = self.interp_y(current_l)
+            z = self.interp_z(current_l)
+            s = self.interp_s_from_l(current_l)
+
+            # Append the point if it satisfies the required criteria
+            if last_z is None or last_s is None or abs(z - last_z) >= dz_max or abs(s - last_s) >= ds_max:
+                l_range.append(current_l)
+                z_range.append(z)
+                last_z = z
+                last_s = s
+
+            # Increment l
+            current_l += 0.01  # Increment in steps small enough to meet any constraint
+
+        # add the final l
+        if current_l > l_max:
+            l_range.append(l_max)
+            z_range.append(self.interp_z(l_max))
+
+        # sort l_range and z_range by incremental l_range
+        sorted_indices = np.argsort(l_range)
+        l_range = np.array(l_range)[sorted_indices]
+        z_range = np.array(z_range)[sorted_indices]
+
+        return l_range, z_range
+
+    def _water_level_score_range(
+        self,
+        img: np.ndarray,
+        bank: BANK_OPTIONS = "far",
+        bin_size: int = 5,
+        length: float = 2.0,
+        padding: float = 0.5,
+        offset: float = 0.0,
+        ds_max: Optional[float] = 0.5,
+        dz_max: Optional[float] = 0.02,
+        min_h: Optional[float] = None,
+        max_h: Optional[float] = None,
+        min_z: Optional[float] = None,
+        max_z: Optional[float] = None,
+    ) -> float:
+        """Evaluate a range of scores for water level detection.
+
+        This computes the histogram score for a range of l values and returns all scores for further evaluation.
+        The histogram score is a measure of dissimilarity (low means very dissimilar) of pixel intensity distributions
+        left and right of hypothesized water lines. The evaluation points along the cross section (l-values) are
+        determined by two parameters max_ds (maximum step in horizontal direction) and max_dz (maximum step in vertical
+        direction).
+
+        Parameters
+        ----------
+        img : np.ndarray
+            image (uint8) used to estimate water level from.
+        bank: Literal["far", "near", "both"], optional
+            select from which bank to detect the water level. Use this if camera is positioned in a way that only
+            one shore is clearly distinguishable and not obscured. Typically you will use "far" if the camera is
+            positioned on one bank, aimed perpendicular to the flow. Use "near" if not the full cross section is
+            visible, but only the part nearest the camera. And leave empty when both banks are clearly visible and
+            approximately the same in distance (e.g. middle of a bridge). If not provided, the bank is detected based
+            on the best estimate from both banks.
+        bin_size : int, optional
+            Size of bins for histogram calculation of the provided image intensities, default 5.
+        length : float, optional
+            length of the waterline [m], by default 2.0
+        padding : float, optional
+            amount of distance [m] to extend the polygon beyond the waterline, by default 0.5. Two polygons are drawn
+            left and right of hypothesized water line at -padding and +padding.
+        offset : float, optional
+            perpendicular offset of the waterline from the cross-section [m], by default 0.0
+        ds_max : float, optional
+            maximum step size between evaluation points in horizontal direction, by default 0.5.
+        dz_max : float, optional
+            maximum step size between evaluation points in vertical direction, by default 0.02.
+        min_h : float, optional
+            minimum water level to try detection [m]. If not provided, the minimum water level is taken from the
+            cross section.
+        max_h : float, optional
+            maximum water level to try detection [m]. If not provided, the maximum water level is taken from the
+            cross section.
+        min_z : float, optional
+            same as min_h but using z-coordinates instead of local datum, min_z overrules min_h
+        max_z : float, optional
+            same as max_z but using z-coordinates instead of local datum, max_z overrules max_h
+
+        """
+        l_min, l_max = self.get_line_of_interest(bank=bank)
+        min_z, max_z = self._preprocess_level_range(min_h, max_h, min_z, max_z)
+        l_range, z_range = self._preprocess_l_range(l_min=l_min, l_max=l_max, ds_max=ds_max, dz_max=dz_max)
+        if len(img.shape) == 3:
+            # flatten image first if it his a time dimension
+            img = img.mean(axis=2)
+        assert (
+            img.shape[0] == self.camera_config.height
+        ), f"Image height {img.shape[0]} is not the same as camera_config height {self.camera_config.height}"
+        assert (
+            img.shape[1] == self.camera_config.width
+        ), f"Image width {img.shape[1]} is not the same as camera_config width {self.camera_config.width}"
+
+        # gridded results
+        results = [
+            self.get_histogram_score(
+                x=[l],
+                img=img,
+                bin_size=bin_size,
+                offset=offset,
+                padding=padding,
+                length=length,
+                min_z=min_z,
+                max_z=max_z,
+            )
+            for l in l_range
+        ]
+        return l_range, z_range, results
+
     def detect_water_level(
         self,
         img: np.ndarray,
@@ -1110,11 +1288,11 @@ class CrossSection:
         min_z: Optional[float] = None,
         max_z: Optional[float] = None,
     ) -> float:
-        """Detect water level optically from provided image.
+        """Detect water level from provided image through optimization.
 
         Water level detection is done by first detecting the water line along the cross-section by comparisons
         of distribution functions left and right of hypothesized water lines, and then looking up the water level
-        associated with the water line location.
+        associated with the water line location. A differential evolution optimization is used to find the optimum.
 
         Parameters
         ----------
@@ -1147,19 +1325,14 @@ class CrossSection:
         max_z : float, optional
             same as max_z but using z-coordinates instead of local datum, max_z overrules max_h
 
-        """
-        if min_z is None:
-            if min_h is not None:
-                min_z = self.camera_config.h_to_z(min_h)
-                min_z = np.maximum(min_z, self.z.min())
-        if max_z is None:
-            if max_h is not None:
-                max_z = self.camera_config.h_to_z(max_h)
-                max_z = np.minimum(max_z, self.z.max())
-        if min_z and max_z:
-            if min_z > max_z:
-                raise ValueError("Minimum water level is higher than maximum water level.")
+        Returns
+        -------
+        float
+            Most likely water level, according to optimization and scoring (most distinct intensity PDF)
 
+        """
+        l_min, l_max = self.get_line_of_interest(bank=bank)
+        min_z, max_z = self._preprocess_level_range(min_h, max_h, min_z, max_z)
         if len(img.shape) == 3:
             # flatten image first if it his a time dimension
             img = img.mean(axis=2)
@@ -1169,9 +1342,7 @@ class CrossSection:
         assert (
             img.shape[1] == self.camera_config.width
         ), f"Image width {img.shape[1]} is not the same as camera_config width {self.camera_config.width}"
-        # determine the relevant start point if only one is used
-        # import pdb;pdb.set_trace()
-        l_min, l_max = self.get_line_of_interest(bank=bank)
+
         opt = differential_evolution(
             self.get_histogram_score,
             popsize=50,
@@ -1190,3 +1361,93 @@ class CrossSection:
                 stacklevel=2,
             )
         return h
+
+    def detect_water_level_s2n(
+        self,
+        img: np.ndarray,
+        bank: BANK_OPTIONS = "far",
+        bin_size: int = 5,
+        length: float = 2.0,
+        padding: float = 0.5,
+        offset: float = 0.0,
+        ds_max: Optional[float] = 0.5,
+        dz_max: Optional[float] = 0.02,
+        min_h: Optional[float] = None,
+        max_h: Optional[float] = None,
+        min_z: Optional[float] = None,
+        max_z: Optional[float] = None,
+    ) -> float:
+        """Detect water level optically from provided image, through evaluation of a vector of locations.
+
+        Water level detection is done by first detecting the water line along the cross-section by comparisons
+        of distribution functions left and right of hypothesized water lines, and then looking up the water level
+        associated with the water line location. Because a full vector of results is evaluated, the signal to noise
+        ratio can be evaluated and used to understand the quality of the water level detection. Two parameters are used
+        to control the spacing between l (location) coordinates: `ds_max` controls the maximum step size in horizontal
+        direction, `dz_max` controls the maximum step size in vertical direction.
+
+        Parameters
+        ----------
+        img : np.ndarray
+            image (uint8) used to estimate water level from.
+        bank: Literal["far", "near", "both"], optional
+            select from which bank to detect the water level. Use this if camera is positioned in a way that only
+            one shore is clearly distinguishable and not obscured. Typically you will use "far" if the camera is
+            positioned on one bank, aimed perpendicular to the flow. Use "near" if not the full cross section is
+            visible, but only the part nearest the camera. And leave empty when both banks are clearly visible and
+            approximately the same in distance (e.g. middle of a bridge). If not provided, the bank is detected based
+            on the best estimate from both banks.
+        bin_size : int, optional
+            Size of bins for histogram calculation of the provided image intensities, default 5.
+        length : float, optional
+            length of the waterline [m], by default 2.0.
+        padding : float, optional
+            amount of distance [m] to extend the polygon beyond the waterline, by default 0.5. Two polygons are drawn
+            left and right of hypothesized water line at -padding and +padding.
+        offset : float, optional
+            perpendicular offset of the waterline from the cross-section [m], by default 0.0.
+        ds_max : float, optional
+            maximum step size between evaluation points in horizontal direction, by default 0.5.
+        dz_max : float, optional
+            maximum step size between evaluation points in vertical direction, by default 0.02.
+        min_h : float, optional
+            minimum water level to try detection [m]. If not provided, the minimum water level is taken from the
+            cross section.
+        max_h : float, optional
+            maximum water level to try detection [m]. If not provided, the maximum water level is taken from the
+            cross section.
+        min_z : float, optional
+            same as min_h but using z-coordinates instead of local datum, min_z overrules min_h.
+        max_z : float, optional
+            same as max_z but using z-coordinates instead of local datum, max_z overrules max_h.
+
+        Returns
+        -------
+        float
+            Most likely water level, according to optimization and scoring (most distinct intensity PDF).
+        float
+            Signal to noise ratio, calculated as the mean of all computed scores divided by the optimum (lowest) score
+            found in the entire l-range.
+
+        """
+        l_range, z_range, results = self._water_level_score_range(
+            img=img,
+            bank=bank,
+            bin_size=bin_size,
+            length=length,
+            padding=padding,
+            offset=offset,
+            ds_max=ds_max,
+            dz_max=dz_max,
+            min_h=min_h,
+            max_h=max_h,
+            min_z=min_z,
+            max_z=max_z,
+        )
+        # find optimum (minimum score)
+        idx = np.argmin(results)
+        s2n = np.mean(results) / results[idx]
+        z = z_range[idx]
+        h = self.camera_config.z_to_h(z)
+        # warning if the optimum is on the edge of the search space for l
+        return h, s2n

pyorc/api/frames.py

@@ -12,7 +12,7 @@ from matplotlib.animation import FuncAnimation
 from tqdm import tqdm
 
 from pyorc import const, cv, helpers, project
-from pyorc.velocimetry import ffpiv, openpiv
+from pyorc.velocimetry import ffpiv
 
 from .orcbase import ORCBase
 from .plot import _frames_plot
@@ -124,14 +124,12 @@ class Frames(ORCBase):
         overlap : (int, int), optional
             amount of overlap between interrogation windows in pixels (y, x)
         engine : str, optional
-            select the compute engine, can be "openpiv" (default), "numba", or "numpy". "numba" will give the fastest
-            performance but is still experimental. It can boost performance by almost an order of magnitude compared
-            to openpiv or numpy. both "numba" and "numpy" use the FF-PIV library as back-end.
+            select the compute engine, can be "numba" (default), or "numpy". "numba" will give the fastest
+            performance. It can boost performance by almost an order of magnitude compared
+            to numpy. both "numba" and "numpy" use the FF-PIV library as back-end.
         ensemble_corr : bool, optional
-            only used with `engine="numba"` or `engine="numpy"`.
             If True, performs PIV by first averaging cross-correlations across all frames and then deriving velocities.
             If False, computes velocities for each frame pair separately. Default is True.
-
         **kwargs : dict
             keyword arguments to pass to the piv engine. For "numba" and "numpy" the argument `chunks` can be provided
             with an integer defining in how many batches of work the total velocimetry problem should be subdivided.
@@ -143,7 +141,6 @@ class Frames(ORCBase):
 
         See Also
         --------
-        OpenPIV project: https://github.com/OpenPIV/openpiv-python
         FF-PIV project: https://github.com/localdevices/ffpiv
 
         """
@@ -167,43 +164,19 @@ class Frames(ORCBase):
         # get all required coordinates for the PIV result
         coords, mesh_coords = self.get_piv_coords(window_size, search_area_size, overlap)
         # provide kwargs for OpenPIV analysis
-        if engine == "openpiv":
-            # thresholds are not used.
-
-            import warnings
-
-            warnings.warn(
-                '"openpiv" is deprecated, please use "numba" or "numpy" as engine',
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            # Remove threshold parameters from kwargs
-            kwargs.pop("corr_min", None)
-            kwargs.pop("s2n_min", None)
-            kwargs.pop("count_min", None)
-            kwargs = {
-                **kwargs,
-                "search_area_size": search_area_size[0],
-                "window_size": window_size[0],
-                "overlap": overlap[0],
-                "res_x": camera_config.resolution,
-                "res_y": camera_config.resolution,
-            }
-            ds = openpiv.get_openpiv(self._obj, coords["y"], coords["x"], dt, **kwargs)
-        elif engine in ["numba", "numpy"]:
-            kwargs = {
-                **kwargs,
-                "search_area_size": search_area_size,
-                "window_size": window_size,
-                "overlap": overlap,
-                "res_x": camera_config.resolution,
-                "res_y": camera_config.resolution,
-            }
-            ds = ffpiv.get_ffpiv(
-                self._obj, coords["y"], coords["x"], dt, engine=engine, ensemble_corr=ensemble_corr, **kwargs
-            )
-        else:
+        if engine not in ["numba", "numpy"]:
             raise ValueError(f"Selected PIV engine {engine} does not exist.")
+        kwargs = {
+            **kwargs,
+            "search_area_size": search_area_size,
+            "window_size": window_size,
+            "overlap": overlap,
+            "res_x": camera_config.resolution,
+            "res_y": camera_config.resolution,
+        }
+        ds = ffpiv.get_ffpiv(
+            self._obj, coords["y"], coords["x"], dt, engine=engine, ensemble_corr=ensemble_corr, **kwargs
+        )
         # add all 2D-coordinates
         ds = ds.velocimetry.add_xy_coords(mesh_coords, coords, {**const.PERSPECTIVE_ATTRS, **const.GEOGRAPHICAL_ATTRS})
         # ensure all metadata is transferred
@@ -359,7 +332,7 @@ class Frames(ORCBase):
             keep_attrs=True,
         )
 
-    def minmax(self, min=-np.Inf, max=np.Inf):
+    def minmax(self, min=-np.inf, max=np.inf):
         """Minimum / maximum intensity filter.
 
         All pixels will be thresholded to a minimum and maximum value.