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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenrivercam
-Version: 0.8.12
+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.8.12.dist-info → pyopenrivercam-0.9.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-pyorc/__init__.py,sha256=osrK3G2RA5IsF1ka-QHSPa7gXf7JCXQuUWK8RnR1I1A,524
+pyorc/__init__.py,sha256=yPY8lllCcJb3rKv4-9O6b393ZSX86dAiOSRqAbEBmaQ,523
 pyorc/const.py,sha256=Ia0KRkm-E1lJk4NxQVPDIfN38EBB7BKvxmwIHJrGPUY,2597
-pyorc/cv.py,sha256=fXGqT8vBn9-z6UxS5ho7thP9VQll9RrYHJW5KnUJQjo,50250
-pyorc/helpers.py,sha256=90TDtka0ydAydv3g5Dfc8MgtuSt0_9D9-HOtffpcBds,30636
+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=53NVnVmEksDw8ilbfhFFCiFJiGAIpxdgREbA_xt8P3o,2508
+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=Kls4mpU_4hoUaXs9DJf2S6RHyp2D5emXJkAQWvvT39U,24300
-pyorc/api/mask.py,sha256=-owe66kte2ob3_Zndf21JR-LyEX_1mECbHOuqNfzuMc,16507
+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
@@ -24,11 +24,10 @@ 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=lYM7oJZWxgJ2SpE22xhy7pBYcgkKFHMBHYmDvvMbtZk,148
-pyorc/velocimetry/ffpiv.py,sha256=CYUjgwnB5osQmJ83j3E00B9P0_hS-rFuhyvufxKXtag,17487
-pyorc/velocimetry/openpiv.py,sha256=6BxsbXLzT4iEq7v08G4sOhVlYFodUpY6sIm3jdCxNMs,13149
-pyopenrivercam-0.8.12.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
-pyopenrivercam-0.8.12.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-pyopenrivercam-0.8.12.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyopenrivercam-0.8.12.dist-info/METADATA,sha256=hU0j9dsG6ksjRTM6UdMLVJ15TGzGQ9lW1mHhxDKxJy0,11641
-pyopenrivercam-0.8.12.dist-info/RECORD,,
+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.12"
+__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/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.

pyorc/api/mask.py

@@ -254,14 +254,17 @@ class _Velocimetry_MaskMethods:
             be within tolerance.
 
         """
-        x_std = self[v_x].std(dim="time")
-        y_std = self[v_y].std(dim="time")
-        x_mean = np.maximum(self[v_x].mean(dim="time"), 1e30)
-        y_mean = np.maximum(self[v_y].mean(dim="time"), 1e30)
-        x_var = np.abs(x_std / x_mean)
-        y_var = np.abs(y_std / y_mean)
-        x_condition = x_var < tolerance
-        y_condition = y_var < tolerance
+        with warnings.catch_warnings():
+            # suppress warnings on all-NaN slices
+            warnings.simplefilter("ignore", category=RuntimeWarning)
+            x_std = self[v_x].std(dim="time")
+            y_std = self[v_y].std(dim="time")
+            x_mean = np.maximum(self[v_x].mean(dim="time"), 1e30)
+            y_mean = np.maximum(self[v_y].mean(dim="time"), 1e30)
+            x_var = np.abs(x_std / x_mean)
+            y_var = np.abs(y_std / y_mean)
+            x_condition = x_var < tolerance
+            y_condition = y_var < tolerance
         if mode == "or":
             mask = x_condition | y_condition
         else:

pyorc/cv.py

@@ -243,7 +243,8 @@ def _get_perpendicular_distance(point, line):
     perpendicular_distance = np.linalg.norm(perpendicular_vector)
 
     # Use cross product to calculate side
-    cross_product = np.cross(line_vector, point_vector)
+    # cross_product = np.cross(line_vector, point_vector)
+    cross_product = line_vector[0] * point_vector[1] - line_vector[1] * point_vector[0]
 
     # Determine the sign of the perpendicular distance
     return perpendicular_distance if cross_product > 0 else -perpendicular_distance
@@ -1070,12 +1071,7 @@ def get_polygon_pixels(img, pol, reverse_y=False):
     if 0 in mask.shape:
         # no shape in mask, so return empty array instantly
         return np.array([], dtype=np.uint8)
-    try:
-        cv2.fillPoly(mask, [np.array(cropped_polygon_coords, dtype=np.int32)], color=255)
-    except Exception:
-        import pdb
-
-        pdb.set_trace()
+    cv2.fillPoly(mask, [np.array(cropped_polygon_coords, dtype=np.int32)], color=255)
     return numba_extract_pixels(cropped_img, mask)
 
 

pyorc/helpers.py

@@ -189,15 +189,6 @@ def get_geo_axes(tiles=None, extent=None, zoom_level=19, **kwargs):
 
     """
     _check_cartopy_installed()
-    #
-    # try:
-    #     import cartopy
-    #     import cartopy.crs as ccrs
-    #     import cartopy.io.img_tiles as cimgt
-    # except ModuleNotFoundError:
-    #     raise ModuleNotFoundError(
-    #         'Geographic plotting requires cartopy. Please install it with "conda install cartopy" and try ' "again."
-    #     )
     ccrs, cimgt = _import_cartopy_modules()
     if tiles is not None:
         tiler = getattr(cimgt, tiles)(**kwargs)
@@ -299,6 +290,9 @@ def get_xs_ys(cols, rows, transform):
     """
     xs, ys = xy(transform, rows, cols)
     xs, ys = np.array(xs), np.array(ys)
+    # Ensure data is reshaped (later versions of rasterio return a 1D array only)
+    xs = xs.reshape(rows.shape)
+    ys = ys.reshape(rows.shape)
     return xs, ys
 
 

pyorc/sample_data.py

@@ -1,6 +1,7 @@
 """Retrieval of sample dataset."""
 
 import os
+import time
 import zipfile
 
 
@@ -13,7 +14,7 @@ def get_hommerich_dataset():
 
     # Define the DOI link
     filename = "20241010_081717.mp4"
-    base_url = "doi:10.5281/zenodo.15002591"
+    base_url = "https://zenodo.org/records/15002591/files"
     url = base_url + "/" + filename
     print(f"Retrieving or providing cached version of dataset from {url}")
     # Create a Pooch registry to manage downloads
@@ -26,7 +27,16 @@ def get_hommerich_dataset():
         registry={filename: None},
     )
     # Fetch the dataset
-    file_path = registry.fetch(filename, progressbar=True)
+    for attempt in range(5):
+        try:
+            file_path = registry.fetch(filename, progressbar=True)
+            break
+        except Exception as e:
+            if attempt == 4:
+                raise f"Download failed with error: {e}."
+            else:
+                print(f"Download failed with error: {e}. Retrying...")
+                time.sleep(1)
     print(f"Hommerich video is available in {file_path}")
     return file_path
 
@@ -40,7 +50,7 @@ def get_hommerich_pyorc_zip():
 
     # Define the DOI link
     filename = "hommerich_20241010_081717_pyorc_data.zip.zip"
-    base_url = "doi:10.5281/zenodo.15002591"
+    base_url = "https://zenodo.org/records/15002591/files"
     url = base_url + "/" + filename
     print(f"Retrieving or providing cached version of dataset from {url}")
     # Create a Pooch registry to manage downloads
@@ -54,6 +64,17 @@ def get_hommerich_pyorc_zip():
     )
     # Fetch the dataset
     file_path = registry.fetch(filename, progressbar=True)
+    # Fetch the dataset
+    for attempt in range(5):
+        try:
+            file_path = registry.fetch(filename, progressbar=True)
+            break
+        except Exception as e:
+            if attempt == 4:
+                raise f"Download failed with error: {e}."
+            else:
+                print(f"Download failed with error: {e}. Retrying...")
+                time.sleep(1)
     print(f"Hommerich video is available in {file_path}")
     return file_path
 

pyorc/velocimetry/__init__.py

@@ -1,6 +1,5 @@
 """pyorc velocimetry methods."""
 
 from .ffpiv import get_ffpiv
-from .openpiv import get_openpiv, piv
 
-__all__ = ["get_ffpiv", "piv", "get_openpiv"]
+__all__ = ["get_ffpiv"]

pyorc/velocimetry/ffpiv.py

@@ -412,12 +412,11 @@ def _get_uv_timestep(da, n_cols, n_rows, window_size, overlap, search_area_size,
         verbose=False,
     )
 
-    # get the maximum correlation per interrogation window
-    corr_max = np.nanmax(corr, axis=(-1, -2))
-
     # get signal-to-noise, whilst suppressing nanmean over empty slice warnings
     with warnings.catch_warnings():
+        # get the maximum correlation per interrogation window
         warnings.simplefilter("ignore", category=RuntimeWarning)
+        corr_max = np.nanmax(corr, axis=(-1, -2))
         s2n = corr_max / np.nanmean(corr, axis=(-1, -2))
 
     # reshape corr / s2n to the amount of expected rows and columns

pyorc/velocimetry/openpiv.py

@@ -1,331 +0,0 @@
-"""PIV processing wrappers for OpenPIV."""
-
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import openpiv.pyprocess
-import openpiv.tools
-import xarray as xr
-
-__all__ = [
-    "get_openpiv",
-    "piv",
-]
-
-
-def get_openpiv(frames, y, x, dt, **kwargs):
-    """Compute time-resolved Particle Image Velocimetry (PIV) using Fast Fourier Transform (FFT) within OpenPIV.
-
-    Calculates velocity using the OpenPIV algorithms by processing sequential frames
-    from a dataset and returning the velocity components, signal-to-noise ratio, and
-    correlation values. The function shifts frames in time and applies the PIV algorithm
-    to compute flow fields over the specified spatial axes.
-
-    Parameters
-    ----------
-    frames : xarray.Dataset
-        The input dataset containing time-dependent frames with coordinates.
-    y : array-like
-        The spatial coordinates along the y-axis where the outputs should be interpolated.
-    x : array-like
-        The spatial coordinates along the x-axis where the outputs should be interpolated.
-    dt : float
-        The time step between consecutive frames (used to go from per-frame to per-second displacement).
-    **kwargs : dict
-        Additional keyword arguments to be passed to the PIV function.
-
-    Returns
-    -------
-    xarray.Dataset
-        A dataset containing computed velocity components `v_x` and `v_y`,
-        signal-to-noise ratios `s2n`, and correlation values `corr`. The dataset
-        includes updated x and y coordinates representing the flow field grid.
-
-    """
-    # first get rid of coordinates that need to be recalculated
-    coords_drop = list(set(frames.coords) - set(frames.dims))
-    frames = frames.drop_vars(coords_drop)
-    # get frames and shifted frames in time
-    frames1 = frames.shift(time=1)[1:].chunk({"time": 1})
-    frames2 = frames[1:].chunk({"time": 1})
-    # retrieve all data arrays
-    v_x, v_y, s2n, corr = xr.apply_ufunc(
-        piv,
-        frames1,
-        frames2,
-        dt,
-        kwargs=kwargs,
-        input_core_dims=[["y", "x"], ["y", "x"], []],
-        output_core_dims=[["new_y", "new_x"]] * 4,
-        dask_gufunc_kwargs={
-            "output_sizes": {"new_y": len(y), "new_x": len(x)},
-        },
-        output_dtypes=[np.float32] * 4,
-        vectorize=True,
-        keep_attrs=True,
-        dask="parallelized",
-    )
-    # merge all DataArrays in one Dataset
-    ds = xr.merge([v_x.rename("v_x"), v_y.rename("v_y"), s2n.rename("s2n"), corr.rename("corr")]).rename(
-        {"new_x": "x", "new_y": "y"}
-    )
-    # add y and x-axis values
-    ds["y"] = y
-    ds["x"] = x
-    return ds
-
-
-def piv(
-    frame_a,
-    frame_b,
-    dt,
-    res_x=0.01,
-    res_y=0.01,
-    search_area_size=30,
-    window_size=None,
-    overlap=None,
-    **kwargs,
-):
-    """Perform PIV analysis on two sequential frames following keyword arguments from openpiv.
-
-    This function also computes the correlations per interrogation window, so that poorly correlated values can be
-    filtered out. Furthermore, the resolution is used to convert pixel per second velocity estimates, into meter per
-    second velocity estimates. The centre of search area columns and rows are also returned so that a georeferenced
-    grid can be written from the results.
-
-    Note: Typical openpiv kwargs are for instance
-    window_size=60, overlap=30, search_area_size=60, dt=1./25
-
-    Parameters
-    ----------
-    frame_a: np.ndarray (2D)
-        first frame
-    frame_b: np.ndarray (2D)
-        second frame
-    dt : float
-        time resolution in seconds.
-    res_x: float, optional
-        resolution of x-dir pixels in a user-defined unit per pixel (e.g. m pixel-1) Default: 0.01
-    res_y: float, optional
-        resolution of y-dir pixels in a user-defined unit per pixel (e.g. m pixel-1) Default: 0.01
-    search_area_size: int, optional
-        length of subsetted matrix to search for correlations (default: 30)
-    window_size: int, optional
-        size of interrogation window in amount of pixels. If not set, it is set equal to search_area_size
-        (default: None).
-    overlap: int, optional
-        length of overlap between interrogation windows. If not set, this defaults to 50% of the window_size parameter
-        (default: None).
-    **kwargs: dict
-        keyword arguments related to openpiv. See openpiv manual for further information
-
-    Returns
-    -------
-    v_x: np.ndarray(2D)
-        raw x-dir velocities [m s-1] in interrogation windows (requires filtering to get valid velocities)
-    v_y: np.ndarray (2D)
-        raw y-dir velocities [m s-1] in interrogation windows (requires filtering to get valid velocities)
-    s2n: np.ndarray (2D)
-        signal to noise ratio, measured as maximum correlation found divided by the mean correlation
-        (method="peak2mean") or second to maximum correlation (method="peak2peak") found within search area
-    corr: np.ndarray (2D)
-        correlation values in interrogation windows
-
-    """
-    window_size = search_area_size if window_size is None else window_size
-    overlap = int(round(window_size) / 2) if overlap is None else overlap
-    # modified version of extended_search_area_piv to accomodate exporting corr
-    v_x, v_y, s2n, corr = extended_search_area_piv(
-        frame_a, frame_b, dt=dt, search_area_size=search_area_size, overlap=overlap, window_size=window_size, **kwargs
-    )
-    return v_x * res_x, v_y * res_y, s2n, corr
-
-
-def extended_search_area_piv(
-    frame_a: np.ndarray,
-    frame_b: np.ndarray,
-    window_size: int,
-    overlap: int = 0,
-    dt: float = 1.0,
-    search_area_size: Optional[Union[Tuple[int, int], List[int], int]] = None,
-    correlation_method: str = "circular",
-    subpixel_method: str = "gaussian",
-    sig2noise_method: Optional[str] = "peak2mean",
-    width: int = 2,
-    normalized_correlation: bool = True,
-    use_vectorized: bool = False,
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-    """Perform PIV cross-correlation analysis.
-
-    Extended area search can be used to increased dynamic range. The search region
-    in the second frame is larger than the interrogation window size in the
-    first frame. For Cython implementation see
-    openpiv.process.extended_search_area_piv
-
-    This is a pure python implementation of the standard PIV cross-correlation
-    algorithm. It is a zero order displacement predictor, and no iterative
-    process is performed.
-
-    Parameters
-    ----------
-    frame_a : 2d np.ndarray
-        an two dimensions array of integers containing grey levels of
-        the first frame.
-
-    frame_b : 2d np.ndarray
-        an two dimensions array of integers containing grey levels of
-        the second frame.
-
-    window_size : int
-        the size of the (square) interrogation window, [default: 32 pix].
-
-    overlap : int
-        the number of pixels by which two adjacent windows overlap
-        [default: 16 pix].
-
-    dt : float
-        the time delay separating the two frames [default: 1.0].
-
-    correlation_method : string
-        one of the two methods implemented: 'circular' or 'linear',
-        default: 'circular', it's faster, without zero-padding
-        'linear' requires also normalized_correlation = True (see below)
-
-    subpixel_method : string
-         one of the following methods to estimate subpixel location of the
-         peak:
-         'centroid' [replaces default if correlation map is negative],
-         'gaussian' [default if correlation map is positive],
-         'parabolic'.
-
-    sig2noise_method : string
-        defines the method of signal-to-noise-ratio measure,
-        ('peak2peak' or 'peak2mean'. If None, no measure is performed.)
-
-    width : int
-        the half size of the region around the first
-        correlation peak to ignore for finding the second
-        peak. [default: 2]. Only used if ``sig2noise_method==peak2peak``.
-
-    search_area_size : int
-       the size of the interrogation window in the second frame,
-       default is the same interrogation window size and it is a
-       fallback to the simplest FFT based PIV
-
-    normalized_correlation: bool
-        if True, then the image intensity will be modified by removing
-        the mean, dividing by the standard deviation and
-        the correlation map will be normalized. It's slower but could be
-        more robust
-
-    use_vectorized : bool
-        If set, vectorization is used to speed up analysis.
-
-    Returns
-    -------
-    u : 2d np.ndarray
-        a two dimensional array containing the u velocity component,
-        in pixels/seconds.
-
-    v : 2d np.ndarray
-        a two dimensional array containing the v velocity component,
-        in pixels/seconds.
-
-    sig2noise : 2d np.ndarray ( optional: only if sig2noise_method != None )
-        a two dimensional array the signal to noise ratio for each
-        window pair.
-
-    corr : 2d np.ndarray
-        a two dimensional array with the maximum correlation values found in each interrogation window.
-
-    The implementation of the one-step direct correlation with different
-    size of the interrogation window and the search area. The increased
-    size of the search areas cope with the problem of loss of pairs due
-    to in-plane motion, allowing for a smaller interrogation window size,
-    without increasing the number of outlier vectors.
-
-    See:
-
-    Particle-Imaging Techniques for Experimental Fluid Mechanics
-
-    Annual Review of Fluid Mechanics
-    Vol. 23: 261-304 (Volume publication date January 1991)
-    DOI: 10.1146/annurev.fl.23.010191.001401
-
-    originally implemented in process.pyx in Cython and converted to
-    a NumPy vectorized solution in pyprocess.py
-
-    """
-    if search_area_size is not None:
-        if isinstance(search_area_size, tuple) == False and isinstance(search_area_size, list) == False:
-            search_area_size = [search_area_size, search_area_size]
-    if isinstance(window_size, tuple) == False and isinstance(window_size, list) == False:
-        window_size = [window_size, window_size]
-    if isinstance(overlap, tuple) == False and isinstance(overlap, list) == False:
-        overlap = [overlap, overlap]
-
-    # check the inputs for validity
-    search_area_size = window_size if search_area_size is None else search_area_size
-
-    if overlap[0] >= window_size[0] or overlap[1] >= window_size[1]:
-        raise ValueError("Overlap has to be smaller than the window_size")
-
-    if search_area_size[0] < window_size[0] or search_area_size[1] < window_size[1]:
-        raise ValueError("Search size cannot be smaller than the window_size")
-
-    if (window_size[1] > frame_a.shape[0]) or (window_size[0] > frame_a.shape[1]):
-        raise ValueError("window size cannot be larger than the image")
-
-    # get field shape
-    n_rows, n_cols = openpiv.pyprocess.get_field_shape(frame_a.shape, search_area_size, overlap)
-
-    # We implement the new vectorized code
-    aa = openpiv.pyprocess.sliding_window_array(frame_a, search_area_size, overlap)
-    bb = openpiv.pyprocess.sliding_window_array(frame_b, search_area_size, overlap)
-
-    # for the case of extended seearch, the window size is smaller than
-    # the search_area_size. In order to keep it all vectorized the
-    # approach is to use the interrogation window in both
-    # frames of the same size of search_area_asize,
-    # but mask out the region around
-    # the interrogation window in the frame A
-
-    if search_area_size > window_size:
-        # before masking with zeros we need to remove
-        # edges
-
-        aa = openpiv.pyprocess.normalize_intensity(aa)
-        bb = openpiv.pyprocess.normalize_intensity(bb)
-
-        mask = np.zeros((search_area_size[0], search_area_size[1])).astype(aa.dtype)
-        pady = int((search_area_size[0] - window_size[0]) / 2)
-        padx = int((search_area_size[1] - window_size[1]) / 2)
-        mask[slice(pady, search_area_size[0] - pady), slice(padx, search_area_size[1] - padx)] = 1
-        mask = np.broadcast_to(mask, aa.shape)
-        aa *= mask
-
-    corr = openpiv.pyprocess.fft_correlate_images(
-        aa, bb, correlation_method=correlation_method, normalized_correlation=normalized_correlation
-    )
-    if use_vectorized == True:
-        u, v = openpiv.pyprocess.vectorized_correlation_to_displacements(
-            corr, n_rows, n_cols, subpixel_method=subpixel_method
-        )
-    else:
-        u, v = openpiv.pyprocess.correlation_to_displacement(corr, n_rows, n_cols, subpixel_method=subpixel_method)
-
-    # return output depending if user wanted sig2noise information
-    sig2noise = np.zeros_like(u) * np.nan
-    if sig2noise_method is not None:
-        if use_vectorized == True:
-            sig2noise = openpiv.pyprocess.vectorized_sig2noise_ratio(
-                corr, sig2noise_method=sig2noise_method, width=width
-            )
-        else:
-            sig2noise = openpiv.pyprocess.sig2noise_ratio(corr, sig2noise_method=sig2noise_method, width=width)
-
-    sig2noise = sig2noise.reshape(n_rows, n_cols)
-    # extended code for exporting the maximum found value for corr
-    corr = corr.max(axis=-1).max(axis=-1).reshape((n_rows, n_cols))
-
-    return u / dt, v / dt, sig2noise, corr