pyopenrivercam 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

{pyopenrivercam-0.8.7.dist-info → pyopenrivercam-0.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenrivercam
-Version: 0.8.7
+Version: 0.8.9
 Summary: pyorc: free and open-source image-based surface velocity and discharge.
 Author-email: Hessel Winsemius <winsemius@rainbowsensing.com>
 Requires-Python: >=3.9

{pyopenrivercam-0.8.7.dist-info → pyopenrivercam-0.8.9.dist-info}/RECORD

@@ -1,34 +1,34 @@
-pyorc/__init__.py,sha256=_JX6boGMN0gvbSQsupo5ay0JrNhZadgNNKAuhMi0CeM,523
+pyorc/__init__.py,sha256=mvuksjtx7rr3dGsP3AIlI2DOsT-dK-WNkLnRv2hBqSA,523
 pyorc/const.py,sha256=Ia0KRkm-E1lJk4NxQVPDIfN38EBB7BKvxmwIHJrGPUY,2597
 pyorc/cv.py,sha256=CTv0TbbcKeSQmKsX8mdVDXpSkhKZmr8SgT20YXMvZ0s,49156
-pyorc/helpers.py,sha256=2HN9_NQ5wp1xVtHFcFm0Ri7mwAKYT8jlmWLQ45Xs9GY,29871
-pyorc/plot_helpers.py,sha256=i6pcZHfpGCMkPNHWSkoE0N9-nuKfqXR7V5wgdT184IY,1274
+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=9dve85lZElPsdZxbwPZOKBxwjp5JukkkgpZE0SEVthY,49550
+pyorc/api/cross_section.py,sha256=un7_VFHMOpBM8FE7lQnZIsaxidnABzFWlyaDHIUfzoA,52039
 pyorc/api/frames.py,sha256=QJfcftmh47nClw5yGsMULdJXEsAVzucseiLb4LbpVJU,23671
 pyorc/api/mask.py,sha256=HVag3RkMu4ZYQg_pIZFhiJYkBGYLVBxeefdmWvFTR-4,14371
 pyorc/api/orcbase.py,sha256=C23QTKOyxHUafyJsq_t7xn_BzAEvf4DDfzlYAopons8,4189
-pyorc/api/plot.py,sha256=pPAmOmkVOsTOt0Zhyn5a1RJb0w3U3qEE4OJqEqg2q1k,29989
+pyorc/api/plot.py,sha256=-rDmEccwpJXojCyBEKFCd8NpBwLhcZ8tsOq62n26zu4,30898
 pyorc/api/transect.py,sha256=KU0ZW_0NqYD4jeDxvuWJi7X06KqrcgO9afP7QmWuixA,14162
 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=ySBiXUnrzA75hxLXNAwqOQxtN_CYPHpGsqYJln587M4,15548
+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=mGGy_5Ri5ooENyEy2w_04mz5_3AW4Lik9XVkDxd6hMI,33257
+pyorc/service/velocimetry.py,sha256=UFjxmq5Uhk8wnBLScAyTaVWTPTCnH9hJdKOYBFrGZ_Y,33288
 pyorc/velocimetry/__init__.py,sha256=lYM7oJZWxgJ2SpE22xhy7pBYcgkKFHMBHYmDvvMbtZk,148
 pyorc/velocimetry/ffpiv.py,sha256=MW_6fQ0vxRTA-HYwncgeWHGWiUQFSmM4unYxT7EfnEI,7372
 pyorc/velocimetry/openpiv.py,sha256=6BxsbXLzT4iEq7v08G4sOhVlYFodUpY6sIm3jdCxNMs,13149
-pyopenrivercam-0.8.7.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
-pyopenrivercam-0.8.7.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-pyopenrivercam-0.8.7.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyopenrivercam-0.8.7.dist-info/METADATA,sha256=0OPtN1ITIIFV6oQuiTWA1G-GrqPHJNRr0mcjYNsXZiY,11633
-pyopenrivercam-0.8.7.dist-info/RECORD,,
+pyopenrivercam-0.8.9.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
+pyopenrivercam-0.8.9.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+pyopenrivercam-0.8.9.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pyopenrivercam-0.8.9.dist-info/METADATA,sha256=8NK4zolq3oMRgMuTKCWZTypoLjzPcev_-it5frg8aac,11633
+pyopenrivercam-0.8.9.dist-info/RECORD,,

pyorc/__init__.py

@@ -1,6 +1,6 @@
 """pyorc: free and open-source image-based surface velocity and discharge."""
 
-__version__ = "0.8.7"
+__version__ = "0.8.9"
 
 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

@@ -146,9 +146,11 @@ class CrossSection:
         """
         # if cross_section is a GeoDataFrame, check if it has a CRS, if yes, convert coordinates to crs of CameraConfig
         if isinstance(cross_section, gpd.GeoDataFrame):
-            if cross_section.crs is not None and camera_config.crs is not None:
+            crs_cs = getattr(cross_section, "crs", None)
+            crs_cam = getattr(camera_config, "crs", None)
+            if crs_cs is not None and crs_cam is not None:
                 cross_section.to_crs(camera_config.crs, inplace=True)
-            elif cross_section.crs is not None or camera_config.crs is not None:
+            elif crs_cs is not None or crs_cam is not None:
                 raise ValueError("if a CRS is used, then both camera_config and cross_section must have a CRS.")
             g = cross_section.geometry
             x, y, z = g.x.values, g.y.values, g.z.values
@@ -270,7 +272,7 @@ class CrossSection:
         # check if there are any points within the image objective and return result
         return bool(np.any(within_image))
 
-    def get_cs_waterlevel(self, h: float, sz=False) -> geometry.LineString:
+    def get_cs_waterlevel(self, h: float, sz=False, extend_by=None) -> geometry.LineString:
         """Retrieve LineString of water surface at cross-section at a given water level.
 
         Parameters
@@ -279,18 +281,44 @@ class CrossSection:
             water level [m]
         sz : bool, optional
             If set, return water level line in y-z projection, by default False.
+        extend_by : float, optional
+            If set, the line will be extended left and right using the defined float in meters
 
         Returns
         -------
         geometry.LineString
-            horizontal line at water level (2d if sz=True, 3d if yz=False)
+            horizontal line at water level (2d if `sz`=True, 3d if `yz`=False)
 
         """
         # get water level in camera config vertical datum
         z = self.camera_config.h_to_z(h)
         if sz:
-            return geometry.LineString(zip(self.s, [z] * len(self.s)))
-        return geometry.LineString(zip(self.x, self.y, [z] * len(self.x)))
+            if extend_by is None:
+                s_coords = self.s
+            else:
+                s_coords = np.concatenate([[-np.abs(extend_by)], self.s, [self.s[-1] + np.abs(extend_by)]])
+            return geometry.LineString(zip(s_coords, [z] * len(s_coords)))
+        if extend_by is not None:
+            alpha = np.arctan((self.x[1] - self.x[0]) / (self.y[1] - self.y[0]))
+            x_coords = np.concatenate(
+                [
+                    [self.x[0] - np.cos(alpha) * np.abs(extend_by)],
+                    self.x,
+                    [self.x[-1] + np.cos(alpha) * np.abs(extend_by)],
+                ]
+            )
+            y_coords = np.concatenate(
+                [
+                    [self.y[0] - np.sin(alpha) * np.abs(extend_by)],
+                    self.y,
+                    [self.y[-1] + np.sin(alpha) * np.abs(extend_by)],
+                ]
+            )
+        else:
+            x_coords = self.x
+            y_coords = self.y
+
+        return geometry.LineString(zip(x_coords, y_coords, [z] * len(x_coords)))
 
     def get_csl_point(
         self, h: Optional[float] = None, l: Optional[float] = None, camera: bool = False, swap_y_coords: bool = False
@@ -602,16 +630,32 @@ class CrossSection:
             Wetted surface as a polygon, in Y-Z projection.
 
         """
-        wl = self.get_cs_waterlevel(h=h, sz=True)
+        wl = self.get_cs_waterlevel(
+            h=h, sz=True, extend_by=0.1
+        )  # extend a small bit to guarantee crossing with the bottom coordinates
+        zl = wl.xy[1][0]
         # create polygon by making a union
-        pol = list(polygonize(wl.union(self.cs_linestring_sz)))
+        bottom_points = self.cs_points_sz
+        # add a point left and right slightly above the level if the level is below the water level
+        if bottom_points[0].y < zl:
+            bottom_points.insert(0, geometry.Point(bottom_points[0].x, zl + 0.1))
+        if bottom_points[-1].y < zl:
+            bottom_points.append(geometry.Point(bottom_points[-1].x, zl + 0.1))
+        bottom_line = geometry.LineString(bottom_points)
+        pol = list(polygonize(wl.union(bottom_line)))
         if len(pol) == 0:
-            raise ValueError("Water level is not crossed by cross section and therefore undefined.")
+            # create infinitely small polygon at lowest z coordinate
+            lowest_z = min(self.z)
+            lowest_s = self.s[list(self.z).index(lowest_z)]
+            # make an infinitely small polygon around the lowest point in the cross section
+            pol = [geometry.Polygon([(lowest_s, lowest_z)] * 3)]
         elif len(pol) > 1:
-            raise ValueError("Water level is crossed by multiple polygons.")
-        else:
-            pol = pol[0]
-        return pol
+            # detect which polygons have their average z coordinate below the defined water level
+            pol = [p for p in pol if p.centroid.xy[1][0] < zl]
+            # raise ValueError("Water level is crossed by multiple polygons.")
+        # else:
+        #     pol = pol[0]
+        return geometry.MultiPolygon(pol)
 
     def get_wetted_surface(self, h: float, camera: bool = False, swap_y_coords=False) -> geometry.Polygon:
         """Retrieve a wetted surface for a given water level, as a geometry.Polygon.
@@ -633,13 +677,16 @@ class CrossSection:
 
 
         """
-        pol = self.get_wetted_surface_sz(h=h)
-        coords = [[self.interp_x_from_s(p[0]), self.interp_y_from_s(p[0]), p[1]] for p in pol.exterior.coords]
-        if camera:
-            coords_proj = self.camera_config.project_points(coords, swap_y_coords=swap_y_coords)
-            return geometry.Polygon(coords_proj)
-        else:
-            return geometry.Polygon(coords)
+        pols = self.get_wetted_surface_sz(h=h)
+        pols_proj = []
+        for pol in pols.geoms:
+            coords = [[self.interp_x_from_s(p[0]), self.interp_y_from_s(p[0]), p[1]] for p in pol.exterior.coords]
+            if camera:
+                coords_proj = self.camera_config.project_points(coords, swap_y_coords=swap_y_coords)
+                pols_proj.append(geometry.Polygon(coords_proj))
+            else:
+                pols_proj.append(geometry.Polygon(coords))
+        return geometry.MultiPolygon(pols_proj)
 
     def get_line_of_interest(self, bank: BANK_OPTIONS = "far") -> List[float]:
         """Retrieve the points of interest within the cross-section for water level detection.
@@ -881,12 +928,20 @@ class CrossSection:
         plt.axes
 
         """
-        surf = self.get_planar_surface(h=h, length=length, offset=offset, swap_y_coords=swap_y_coords, camera=camera)
-        if camera:
-            p = plot_helpers.plot_polygon(surf, ax=ax, label="surface", **kwargs)
-        else:
-            p = plot_helpers.plot_3d_polygon(surf, ax=ax, label="surface", **kwargs)
-        return p.axes
+        try:
+            surf = self.get_planar_surface(
+                h=h, length=length, offset=offset, swap_y_coords=swap_y_coords, camera=camera
+            )
+            if camera:
+                p = plot_helpers.plot_polygon(surf, ax=ax, label="surface", **kwargs)
+            else:
+                p = plot_helpers.plot_3d_polygon(surf, ax=ax, label="surface", **kwargs)
+            return p.axes
+        except Exception:
+            warnings.warn(
+                "Cannot plot planar surface as there are too many crossings",
+                stacklevel=2,
+            )
 
     def plot_bottom_surface(
         self, length: float = 2.0, offset: float = 0.0, camera: bool = False, ax=None, swap_y_coords=False, **kwargs

pyorc/api/plot.py

@@ -6,6 +6,8 @@ import functools
 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
@@ -184,16 +186,32 @@ def _base_plot(plot_func):
                         planar=False,
                         bottom=False,
                     )
-                    ref._obj.transect.cross_section.plot_water_level(
-                        h=ref._obj.transect.h_a,
-                        length=2.0,
-                        linewidth=3.0,
-                        ax=ax,
-                        camera=True,
-                        swap_y_coords=True,
-                        color="r",
-                        label="water level",
+                    # check if water level is above the lowest level
+                    check_low = (
+                        ref._obj.transect.camera_config.h_to_z(ref._obj.transect.h_a)
+                        > ref._obj.transect.cross_section.z.min()
+                    )
+                    check_high = (
+                        ref._obj.transect.camera_config.h_to_z(ref._obj.transect.h_a)
+                        < ref._obj.transect.cross_section.z.max()
                     )
+                    if check_low and check_high:
+                        try:
+                            ref._obj.transect.cross_section.plot_water_level(
+                                h=ref._obj.transect.h_a,
+                                length=2.0,
+                                linewidth=3.0,
+                                ax=ax,
+                                camera=True,
+                                swap_y_coords=True,
+                                color="r",
+                                label="water level",
+                            )
+                        except:
+                            warnings.warn(
+                                "Not able to find a unique location for plotting of water level",
+                                stacklevel=2
+                            )
 
                     # draw some depth lines for better visual interpretation.
                     depth_lines = ref._obj.transect.get_depth_perspective(h=ref._obj.transect.h_a)

pyorc/cli/cli_utils.py

@@ -329,20 +329,8 @@ def read_shape_as_gdf(fn=None, geojson=None, gdf=None):
             crs = None
         gdf = gpd.GeoDataFrame().from_features(geojson, crs=crs)
     else:
-        gdf = gpd.read_file(fn)
-        crs = gdf.crs if hasattr(gdf, "crs") else None
-        # also read raw json, and check if crs attribute exists
-        if isinstance(fn, str):
-            with open(fn, "r") as f:
-                raw_json = json.load(f)
-        else:
-            # apparently a file object was provided
-            fn.seek(0)
-            raw_json = json.load(fn)
-        if "crs" not in raw_json:
-            # override the crs
-            crs = None
-            gdf = gdf.set_crs(None, allow_override=True)
+        gdf = helpers.read_shape_safe_crs(fn)
+        crs = gdf.crs
     # check if all geometries are points
     assert all([isinstance(geom, Point) for geom in gdf.geometry]), (
         "shapefile may only contain geometries of type " '"Point"'

pyorc/helpers.py

@@ -2,8 +2,10 @@
 
 import copy
 import importlib.util
+import json
 
 import cv2
+import geopandas as gpd
 import matplotlib.pyplot as plt
 import numpy as np
 import xarray as xr
@@ -582,6 +584,27 @@ def optimize_log_profile(
     return {"z0": z0, "k_max": k_max, "s0": s0, "s1": s1}
 
 
+def read_shape_safe_crs(fn):
+    """Read a shapefile with geopandas, but ensure that CRS is set to None when not available.
+
+    This function is required in cases where geometries must be read that do not have a specified CRS. Geopandas
+    defaults to WGS84 EPSG 4326 if the CRS is not specified.
+    """
+    gdf = gpd.read_file(fn)
+    # also read raw json, and check if crs attribute exists
+    if isinstance(fn, str):
+        with open(fn, "r") as f:
+            raw_json = json.load(f)
+    else:
+        # apparently a file object was provided
+        fn.seek(0)
+        raw_json = json.load(fn)
+    if "crs" not in raw_json:
+        # override the crs
+        gdf = gdf.set_crs(None, allow_override=True)
+    return gdf
+
+
 def rotate_u_v(u, v, theta, deg=False):
     """Rotate u and v components of vector counterclockwise by an amount of rotation.
 

pyorc/plot_helpers.py

@@ -2,10 +2,11 @@
 
 import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+from shapely import geometry
 
 
-def plot_3d_polygon(polygon, ax=None, **kwargs):
-    """Plot a shapely.geometry.Polygon on matplotlib 3d ax."""
+def _plot_3d_pol(polygon, ax=None, **kwargs):
+    """Plot single polygon on matplotlib 3d ax."""
     x, y, z = zip(*polygon.exterior.coords)
     verts = [list(zip(x, y, z))]
 
@@ -17,13 +18,27 @@ def plot_3d_polygon(polygon, ax=None, **kwargs):
     return p
 
 
+def plot_3d_polygon(polygon, ax=None, **kwargs):
+    """Plot a shapely.geometry.Polygon or MultiPolygon on matplotlib 3d ax."""
+    if isinstance(polygon, geometry.MultiPolygon):
+        for pol in polygon.geoms:
+            p = _plot_3d_pol(pol, ax=ax, **kwargs)
+    else:
+        p = _plot_3d_pol(polygon, ax=ax, **kwargs)
+    return p
+
+
 def plot_polygon(polygon, ax=None, **kwargs):
-    """Plot a shapely.geometry.Polygon on matplotlib ax."""
-    # x, y = zip(*polygon.exterior.coords)
+    """Plot a shapely.geometry.Polygon or MultiPolygon on matplotlib ax."""
     if ax is None:
         ax = plt.axes()
-    patch = plt.Polygon(polygon.exterior.coords, **kwargs)
-    p = ax.add_patch(patch)
+    if isinstance(polygon, geometry.MultiPolygon):
+        for pol in polygon.geoms:
+            patch = plt.Polygon(pol.exterior.coords, **kwargs)
+            p = ax.add_patch(patch)
+    else:
+        patch = plt.Polygon(polygon.exterior.coords, **kwargs)
+        p = ax.add_patch(patch)
     return p
 
 

pyorc/service/velocimetry.py

@@ -9,7 +9,6 @@ import subprocess
 from typing import Dict, Optional
 
 import click
-import geopandas as gpd
 import numpy as np
 import xarray as xr
 import yaml
@@ -19,6 +18,7 @@ from matplotlib.colors import Normalize
 import pyorc
 from pyorc import CameraConfig, CrossSection, Video, const
 from pyorc.cli import cli_utils
+from pyorc.helpers import read_shape_safe_crs
 
 __all__ = ["velocity_flow", "velocity_flow_subprocess"]
 
@@ -287,7 +287,7 @@ class VelocityFlowProcessor(object):
                 "Cross section for water level detection provided, and no water level set, "
                 " water level will be estimated optically."
             )
-            gdf = gpd.read_file(cross)
+            gdf = read_shape_safe_crs(cross_wl)
             cross_section_wl = pyorc.CrossSection(camera_config=camera_config, cross_section=gdf)
             if "water_level" not in recipe:
                 # make sure water_level is represented