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

pyorc/api/mask.py

@@ -10,12 +10,11 @@ from pyorc import helpers
 from pyorc.const import corr, s2n, v_x, v_y
 
 commondoc = """
-    Returns
-    -------
-    mask : xr.DataArray
-        mask applicable to input dataset with ``ds.velocimetry.filter(mask)``.
-        If ``inplace=True``, the dataset will be returned masked with ``mask``.
-
+        Returns
+        -------
+        mask : xr.DataArray
+            mask applicable to input dataset with ``ds.velocimetry.filter(mask)``.
+            If ``inplace=True``, the dataset will be returned masked with ``mask``.
 """
 
 
@@ -203,7 +202,7 @@ class _Velocimetry_MaskMethods:
 
     @_base_mask(time_allowed=True)
     def corr(self, tolerance=0.1):
-        """Mass values with too low correlation.
+        """Mask values with too low correlation.
 
         Parameters
         ----------
@@ -255,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:
@@ -304,16 +306,17 @@ class _Velocimetry_MaskMethods:
             (default: 1) wdw is used to fill wdw_x_min and wdwd_y_min with its negative (-wdw) value, and wdw_y_min and
         kwargs : dict
             keyword arguments to pass to ``helpers.stack_window``. These can be:
-            wdw_x_min : int, optional
-                window size in negative x-direction of grid (must be negative), overrules wdw in negative x-direction
-                if set.
-            wdw_x_max : int, optional
-                window size in positive x-direction of grid, overrules wdw in positive x-direction if set
-            wdw_y_min : int, optional
-                window size in negative y-direction of grid (must be negative), overrules wdw in negative y-direction
-                if set.
-            wdw_y_max : int, optional
-                window size in positive y-direction of grid, overrules wdw in positive x-direction if set.
+
+            - ``wdw_x_min`` : int, optional
+              window size in negative x-direction of grid (must be negative), overrules wdw in negative x-direction if
+              set.
+            - ``wdw_x_max`` : int, optional
+              window size in positive x-direction of grid, overrules wdw in positive x-direction if set.
+            - ``wdw_y_min`` : int, optional
+              window size in negative y-direction of grid (must be negative), overrules wdw in negative y-direction if
+              set.
+            - ``wdw_y_max`` : int, optional
+              window size in positive y-direction of grid, overrules wdw in positive x-direction if set.
 
         """
         # collect points within a stride, collate and analyze for nan fraction
@@ -326,7 +329,7 @@ class _Velocimetry_MaskMethods:
     def window_mean(self, tolerance=0.7, wdw=1, mode="or", **kwargs):
         """Mask values when their value deviates significantly from mean.
 
-        This is computed as relative fraction from the mean of its  neighbours (inc. itself).
+        This is computed as relative fraction from the mean of its neighbours (inc. itself).
 
         Parameters
         ----------
@@ -339,16 +342,17 @@ class _Velocimetry_MaskMethods:
             be within tolerance.
         kwargs : dict
             keyword arguments to pass to ``helpers.stack_window``. These can be:
-            wdw_x_min : int, optional
-                window size in negative x-direction of grid (must be negative), overrules wdw in negative x-direction
-                if set.
-            wdw_x_max : int, optional
-                window size in positive x-direction of grid, overrules wdw in positive x-direction if set.
-            wdw_y_min : int, optional
-                window size in negative y-direction of grid (must be negative), overrules wdw in negative y-direction
-                if set.
-            wdw_y_max : int, optional
-                window size in positive y-direction of grid, overrules wdw in positive x-direction if set.
+
+            - ``wdw_x_min`` : int, optional
+              window size in negative x-direction of grid (must be negative), overrules wdw in negative x-direction
+              if set.
+            - ``wdw_x_max`` : int, optional
+              window size in positive x-direction of grid, overrules wdw in positive x-direction if set.
+            - ``wdw_y_min`` : int, optional
+              window size in negative y-direction of grid (must be negative), overrules wdw in negative y-direction
+              if set.
+            - ``wdw_y_max`` : int, optional
+              window size in positive y-direction of grid, overrules wdw in positive x-direction if set.
 
         """
         # collect points within a stride, collate and analyze for median value and deviation

pyorc/api/plot.py

@@ -2,12 +2,11 @@
 
 import copy
 import functools
+import warnings
 
 import matplotlib.pyplot as plt
 import matplotlib.ticker as mticker
 import numpy as np
-import warnings
-
 from matplotlib import colors, patheffects
 
 from pyorc import helpers
@@ -207,10 +206,9 @@ def _base_plot(plot_func):
                                 color="r",
                                 label="water level",
                             )
-                        except:
+                        except Exception:
                             warnings.warn(
-                                "Not able to find a unique location for plotting of water level",
-                                stacklevel=2
+                                "Not able to find a unique location for plotting of water level", stacklevel=2
                             )
 
                     # draw some depth lines for better visual interpretation.
@@ -620,7 +618,7 @@ def set_default_kwargs(kwargs, method="quiver", mode="local"):
         kwargs["cmap"] = "rainbow"  # the famous rainbow colormap!
     if "vmin" not in kwargs and "vmax" not in kwargs and "norm" not in kwargs:
         # set a normalization array
-        norm = [0, 0.05, 0.1, 0.2, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
+        norm = [0, 0.05, 0.1, 0.2, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 5.0, 10.0]
         kwargs["norm"] = colors.BoundaryNorm(norm, ncolors=256, extend="max")
     if method == "quiver":
         if "scale" not in kwargs:
@@ -755,7 +753,13 @@ def plot_text(ax, ds, prefix, suffix):
     v_surf = _ds.transect.get_v_surf()
     v_bulk = _ds.transect.get_v_bulk()
     string = prefix
-    string += f"$h_a$: {_ds.transect.h_a:1.2f} m | $v_{{surf}}$: {v_surf.values:1.2f} m/s | $\overline{{v}}$: {v_bulk.values:1.2f} m/s\n$Q$: {Q.values:1.2f} m3/s" # .format(_ds.transect.h_a, Q.values)
+    string += (
+        f"$h_a$: {_ds.transect.h_a:1.2f} m | "
+        f"$v_{{surf}}$: {v_surf.values:1.2f} m/s | "
+        f"$\\overline{{v}}$: {v_bulk.values:1.2f} m/s\n"
+        f"$Q$: {Q.values:1.2f} m3/s"
+    )
+
     if "q_nofill" in ds:
         _ds.transect.get_river_flow(q_name="q_nofill")
         Q_nofill = np.abs(_ds.river_flow)

pyorc/cv.py

@@ -7,6 +7,7 @@ import warnings
 import cv2
 import numpy as np
 import rasterio
+from numba import jit, prange
 from scipy import optimize
 from shapely.affinity import rotate
 from shapely.geometry import LineString, Point, Polygon
@@ -242,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
@@ -1034,16 +1036,43 @@ def get_aoi(dst_corners, resolution=None, method="corners"):
     return bbox
 
 
+@jit(nopython=True, cache=True, nogil=True)
+def numba_extract_pixels(img, mask):
+    """Optimized pixel extraction within a polygon-defined mask."""
+    pixel_values = []
+    rows, cols = img.shape
+    for i in prange(rows):
+        for j in prange(cols):
+            if mask[i, j] == 255:
+                pixel_values.append(img[i, j])
+    return np.array(pixel_values)
+
+
 def get_polygon_pixels(img, pol, reverse_y=False):
     """Get pixel intensities within a polygon."""
     if pol.is_empty:
         return np.array([np.nan])
-    polygon_coords = list(pol.exterior.coords)
-    mask = np.zeros_like(img, dtype=np.uint8)
-    cv2.fillPoly(mask, np.array([polygon_coords], np.int32), color=255)
+    min_x, min_y, max_x, max_y = map(int, pol.bounds)
+    # Ensure bounding box remains within the image dimensions
+    min_x = max(min_x, 0)
+    min_y = max(min_y, 0)
+    max_x = min(max_x, img.shape[1])
+    max_y = min(max_y, img.shape[0])
+
     if reverse_y:
-        return np.flipud(img)[mask == 255]
-    return img[mask == 255]
+        img = np.flipud(img)
+
+    # Crop the image based on the bounding box
+    cropped_img = img[min_y:max_y, min_x:max_x]
+    # reduce polygon coordinates to ensure compatibility with cropped_img
+    cropped_polygon_coords = [(x - min_x, y - min_y) for x, y in pol.exterior.coords]
+
+    mask = np.zeros_like(cropped_img, dtype=np.uint8)
+    if 0 in mask.shape:
+        # no shape in mask, so return empty array instantly
+        return np.array([], dtype=np.uint8)
+    cv2.fillPoly(mask, [np.array(cropped_polygon_coords, dtype=np.int32)], color=255)
+    return numba_extract_pixels(cropped_img, mask)
 
 
 def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None, camera_matrix=None, dist_coeffs=None):

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/service/velocimetry.py

@@ -31,29 +31,46 @@ def get_water_level(
     n_start: int = 0,
     n_end: int = 1,
     method: const.ALLOWED_COLOR_METHODS_WATER_LEVEL = "grayscale",
+    s2n_thres: float = 3.0,
     frames_options: Optional[Dict] = None,
     water_level_options: Optional[Dict] = None,
+    logger: logging.Logger = logger,
 ):
     water_level_options = {} if water_level_options is None else water_level_options
     frames_options = {} if frames_options is None else frames_options
-
-    if method not in ["grayscale", "hue", "sat", "val"]:
-        raise ValueError(
-            f"Method {method} not supported for water level detection, choose one"
-            f" of {const.ALLOWED_COLOR_METHODS_WATER_LEVEL}"
-        )
-    da_frames = video.get_frames(method=method)[n_start:n_end]
-    # preprocess
-    da_frames = apply_methods(da_frames, "frames", logger=logger, skip_args=["to_video"], **frames_options)
-    # if preprocessing still results in a time dim, average in time
-    if "time" in da_frames.dims:
-        da_mean = da_frames.mean(dim="time")
-    else:
-        da_mean = da_frames
-    # extract the image
-    img = np.uint8(da_mean.values)
-    h_a = cross_section.detect_water_level(img, **water_level_options)
-    return h_a
+    # if frames_options is list of dict then continue, if not then make list of dict
+    if not isinstance(frames_options, list):
+        frames_options = [frames_options]
+    for frames_options_ in frames_options:
+        # get method from frames_options if available, otherwise use the parent or default one
+        method_ = frames_options_.pop("method", method)
+        s2n_thres_ = frames_options_.pop("s2n_thres", s2n_thres)
+
+        if method_ not in ["grayscale", "hue", "sat", "val"]:
+            raise ValueError(
+                f"Method {method} not supported for water level detection, choose one"
+                f" of {const.ALLOWED_COLOR_METHODS_WATER_LEVEL}"
+            )
+        da_frames = video.get_frames(method=method_)[n_start:n_end]
+        # preprocess
+        logger.debug(f"Applying preprocessing methods {frames_options_}")
+        da_frames = apply_methods(da_frames, "frames", logger=logger, skip_args=["to_video"], **frames_options_)
+        # if preprocessing still results in a time dim, average in time
+        if "time" in da_frames.dims:
+            da_mean = da_frames.mean(dim="time")
+        else:
+            da_mean = da_frames
+        # extract the image
+        img = np.uint8(da_mean.values)
+        h_a, s2n = cross_section.detect_water_level_s2n(img, **water_level_options)
+        if s2n > s2n_thres_:
+            # high enough signal-to-noise ratio, so return, otherwise continue with next frame treatment set
+            logger.debug(f"Found significant water level at h: {h_a:.3f} m with signal-to-noise: {s2n} > {s2n_thres_}")
+            return h_a
+        else:
+            logger.debug(f"Found water level at h: {h_a:.3f} m with too low signal-to-noise: {s2n} < {s2n_thres_}")
+    # if none of frame treatments gives a satisfactory h_a, return None
+    return
 
 
 def vmin_vmax_to_norm(opts):
@@ -434,7 +451,8 @@ class VelocityFlowProcessor(object):
     def water_level(self, **kwargs):
         try:
             self.logger.debug("Estimating water level from video by crossing water line with cross section.")
-            h_a = get_water_level(self.video_obj, cross_section=self.cross_section_wl, **kwargs)
+
+            h_a = get_water_level(self.video_obj, cross_section=self.cross_section_wl, logger=self.logger, **kwargs)
             if h_a is None:
                 self.logger.error("Water level could not be estimated from video. Please set a water level with --h_a.")
                 raise click.Abort()

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

pyopenrivercam-0.8.11.dist-info/RECORD

@@ -1,34 +0,0 @@
-pyorc/__init__.py,sha256=5wLWixrMpcQEFTVDSFHd_K2iG-iNi3WxQydqTrq3xzU,524
-pyorc/const.py,sha256=Ia0KRkm-E1lJk4NxQVPDIfN38EBB7BKvxmwIHJrGPUY,2597
-pyorc/cv.py,sha256=CTv0TbbcKeSQmKsX8mdVDXpSkhKZmr8SgT20YXMvZ0s,49156
-pyorc/helpers.py,sha256=90TDtka0ydAydv3g5Dfc8MgtuSt0_9D9-HOtffpcBds,30636
-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/api/__init__.py,sha256=k2OQQH4NrtXTuVm23d0g_SX6H5DhnKC9_kDyzJ4dWdk,428
-pyorc/api/cameraconfig.py,sha256=NP9F7LhPO3aO6FRWkrGl6XpX8O3K59zfTtaYR3Kujqw,65419
-pyorc/api/cross_section.py,sha256=60n9EPe3HYvJxsX4CKb2pz3pf6hDRzqDrPR6uQOdvD8,53047
-pyorc/api/frames.py,sha256=Kls4mpU_4hoUaXs9DJf2S6RHyp2D5emXJkAQWvvT39U,24300
-pyorc/api/mask.py,sha256=COsL4fxz-Rsn-wgpojpJ1se4FGA8CZ_R1jx3iVUYB30,16462
-pyorc/api/orcbase.py,sha256=C23QTKOyxHUafyJsq_t7xn_BzAEvf4DDfzlYAopons8,4189
-pyorc/api/plot.py,sha256=WUgJ5CJAY6-tstB7wd1vMs-jrcqIQxCmUfEBITtJWMU,31078
-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=UFjxmq5Uhk8wnBLScAyTaVWTPTCnH9hJdKOYBFrGZ_Y,33288
-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.11.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
-pyopenrivercam-0.8.11.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-pyopenrivercam-0.8.11.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyopenrivercam-0.8.11.dist-info/METADATA,sha256=hNo75nJNt8C2xbKpILV2gX_3jq6oLKEOkBgHpaRHLBE,11641
-pyopenrivercam-0.8.11.dist-info/RECORD,,