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

pyorc/api/plot.py

@@ -6,8 +6,7 @@ import functools
 import matplotlib.pyplot as plt
 import matplotlib.ticker as mticker
 import numpy as np
-from matplotlib import patheffects
-from matplotlib.collections import QuadMesh
+from matplotlib import colors, patheffects
 
 from pyorc import helpers
 
@@ -132,7 +131,7 @@ def _base_plot(plot_func):
 
         # check if dataset is a transect or not
         is_transect = True if "points" in ref._obj.dims else False
-
+        kwargs = set_default_kwargs(kwargs, method=plot_func.__name__, mode=mode)
         assert mode in ["local", "geographical", "camera"], 'Mode must be "local", "geographical" or "camera"'
         if mode == "local":
             x = ref._obj["x"].values
@@ -279,23 +278,22 @@ def _frames_plot(ref, ax=None, mode="local", **kwargs):
         x = "xp"
         y = "yp"
     assert all(v in ref._obj.coords for v in [x, y]), f'required coordinates "{x}" and/or "{y}" are not available'
-    if len(ref._obj.shape) == 3 and ref._obj.shape[-1] == 3:
-        # looking at an rgb image
-        facecolors = ref._obj.values.reshape(ref._obj.shape[0] * ref._obj.shape[1], 3) / 255
-        facecolors = np.hstack([facecolors, np.ones((len(facecolors), 1))])
-        primitive = ax.pcolormesh(
-            ref._obj[x],
-            ref._obj[y],
-            ref._obj.mean(dim="rgb"),
-            shading="nearest",
-            facecolors=facecolors,
-            **kwargs,
-        )
-        # remove array values, override .set_array, needed in case GeoAxes is provided, because GeoAxes asserts if
-        # array has dims
-        QuadMesh.set_array(primitive, None)
-    else:
+    if x == "x":
+        # use a simple imshow, much faster
+        dx = abs(float(ref._obj[x][1] - ref._obj[x][0]))  # x grid cell size
+        dy = abs(float(ref._obj[y][1] - ref._obj[y][0]))  # y grid cell size
+        # Calculate extent with half grid cell expansion
+        extent = [
+            ref._obj[x].min().item() - 0.5 * dx,
+            ref._obj[x].max().item() + 0.5 * dx,
+            ref._obj[y].min().item() - 0.5 * dy,
+            ref._obj[y].max().item() + 0.5 * dy,
+        ]
+
+    if x != "x":
         primitive = ax.pcolormesh(ref._obj[x], ref._obj[y], ref._obj, **kwargs)
+    else:
+        primitive = ax.imshow(ref._obj, origin="upper", extent=extent, aspect="auto", **kwargs)
     # fix axis limits to min and max of extent of frames
     if mode == "geographical":
         ax.set_extent(
@@ -371,7 +369,8 @@ class _Transect_PlotMethods:
         _u = self._obj[v_eff] * np.sin(self._obj[v_dir])
         _v = self._obj[v_eff] * np.cos(self._obj[v_dir])
         s = np.abs(self._obj[v_eff].values)
-        x_moved, y_moved = x + _u * dt, y + _v * dt
+        # x_moved, y_moved = x + _u * dt, y + _v * dt
+        x_moved, y_moved = x + _u, y + _v
         # transform to real-world
         cols_moved, rows_moved = x_moved / camera_config.resolution, y_moved / camera_config.resolution
         rows_moved = camera_config.shape[0] - rows_moved
@@ -496,9 +495,11 @@ class _Velocimetry_PlotMethods:
         """
         # select lon and lat variables as coordinates
         velocimetry = self._obj.velocimetry
-        u = self._obj["v_x"]
-        v = -self._obj["v_y"]
-        s = (u**2 + v**2) ** 0.5
+        v_x = self._obj["v_x"].values
+        v_y = self._obj["v_y"].values
+        u = v_x / (2 * 1e5)  # 1e5 is aobut the amount of meters per degree
+        v = -v_y / (2 * 1e5)
+        s = (v_x**2 + v_y**2) ** 0.5
         aff = velocimetry.camera_config.transform
         theta = np.arctan2(aff.d, aff.a)
         # rotate velocity vectors along angle theta to match the requested projection. this only changes values
@@ -519,9 +520,14 @@ class _Velocimetry_PlotMethods:
             scalar velocity
 
         """
-        u = self._obj["v_x"].values
-        v = -self._obj["v_y"].values
-        s = (u**2 + v**2) ** 0.5
+        # u and v should be scaled to a nice proportionality for local plots. This is typically about 2x smaller
+        # than the m/s values
+        v_x = self._obj["v_x"].values
+        v_y = self._obj["v_y"].values
+
+        u = v_x / 2
+        v = -v_y / 2
+        s = (v_x**2 + v_y**2) ** 0.5
         return u, v, s
 
     def get_uv_camera(self, dt=0.1):
@@ -552,7 +558,8 @@ class _Velocimetry_PlotMethods:
         yi = np.flipud(yi)
 
         # follow the velocity vector over a short distance (dt*velocity)
-        x_moved, y_moved = xi + self._obj["v_x"] * dt, yi + self._obj["v_y"] * dt
+        # x_moved, y_moved = xi + self._obj["v_x"] * dt, yi + self._obj["v_y"] * dt
+        x_moved, y_moved = xi + self._obj["v_x"] / 2, yi + self._obj["v_y"] / 2
         # transform to real-world
         cols_moved, rows_moved = x_moved / camera_config.resolution, y_moved / camera_config.resolution
         xs_moved, ys_moved = helpers.get_xs_ys(cols_moved, rows_moved, camera_config.transform)
@@ -578,10 +585,51 @@ class _Velocimetry_PlotMethods:
         return u, v, s
 
 
+def set_default_kwargs(kwargs, method="quiver", mode="local"):
+    """Set color mapping default kwargs if no vmin and/or vmax is supplied."""
+    if mode == "local":
+        # width scale is in cm
+        width_scale = 0.02
+    elif mode == "geographical":
+        # widths are in degrees
+        width_scale = 0.00000025
+    elif mode == "camera":
+        # widths in pixels
+        width_scale = 3.0
+    else:
+        raise ValueError("mode must be one of 'local', 'geographical' or 'camera'")
+    if "cmap" not in kwargs:
+        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]
+        kwargs["norm"] = colors.BoundaryNorm(norm, ncolors=256, extend="max")
+    if method == "quiver":
+        if "scale" not in kwargs:
+            kwargs["scale"] = 1  # larger quiver arrows
+        if "units" not in kwargs:
+            kwargs["units"] = "xy"
+        # for width, it will matter a lot what mode is used, width should be a dimensionless number
+        if "width" not in kwargs:
+            kwargs["width"] = width_scale
+        else:
+            kwargs["width"] *= width_scale  # multiply
+
+    return kwargs
+
+
 @_base_plot
 def quiver(_, x, y, u, v, s=None, ax=None, **kwargs):
     """Create quiver plot from velocimetry results on new or existing axes.
 
+    Note that the `width` parameter is always in a unitless scale, with `1` providing a nice-looking default value
+    for all plot modes. The default value is usually very nice. If you do want to change:
+
+    The `scale` parameter defaults to 1, providing a nice looking arrow length. With a smaller (larger) value,
+    quivers will become longer (shorter).
+
+    The `width` parameter is in a unitless scale, with `1` providing a nice-looking default value.
+
     Wraps :py:func:`matplotlib:matplotlib.pyplot.quiver`.
     """
     if "color" in kwargs:

pyorc/cli/cli_utils.py

@@ -136,7 +136,12 @@ def get_gcps_optimized_fit(src, dst, height, width, c=2.0, camera_matrix=None, d
     src_est, jacobian = cv2.projectPoints(_dst, rvec, tvec, camera_matrix, np.array(dist_coeffs))
     src_est = np.array([list(point[0]) for point in src_est])
     dst_est = cv.unproject_points(_src, _dst[:, -1], rvec, tvec, camera_matrix, dist_coeffs)
+    # add mean coordinates to estimated locations
     dst_est = np.array(dst_est)[:, 0 : len(coord_mean)] + coord_mean
+    # also reverse rvec and tvec to real-world (rw), add mean coordinate, and reverse again.
+    rvec_cam, tvec_cam = cv.pose_world_to_camera(rvec, tvec)
+    tvec_cam += coord_mean
+    rvec, tvec = cv.pose_world_to_camera(rvec_cam, tvec_cam)
     return src_est, dst_est, camera_matrix, dist_coeffs, rvec, tvec, err
 
 
@@ -327,8 +332,13 @@ def read_shape_as_gdf(fn=None, geojson=None, gdf=None):
         gdf = gpd.read_file(fn)
         crs = gdf.crs if hasattr(gdf, "crs") else None
         # also read raw json, and check if crs attribute exists
-        with open(fn, "r") as f:
-            raw_json = json.load(f)
+        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

pyorc/cli/main.py

@@ -312,9 +312,17 @@ def camera_config(
 @click.option(
     "--cross",
     type=click.Path(exists=True, resolve_path=True, dir_okay=False, file_okay=True),
+    help="Cross section file (*.geojson). This will be used for discharge estimation if the `transect` "
+    " section is provided in your recipe.",
+    callback=cli_utils.parse_cross_section_gdf,
+    required=False,
+)
+@click.option(
+    "--cross_wl",
+    type=click.Path(exists=True, resolve_path=True, dir_okay=False, file_okay=True),
     help="Cross section file (*.geojson). If you provide this, you may add water level retrieval settings to the"
-    " recipe section video: water_level: For more information see"
-    " [PyORC docs](https://localdevices.github.io/pyorc/user-guide/video/index.html)",
+    " recipe in the section `water_level`. For more information see"
+    " [PyORC docs](https://localdevices.github.io/pyorc/user-guide/cross_section/index.html)",
     callback=cli_utils.parse_cross_section_gdf,
     required=False,
 )
@@ -333,7 +341,7 @@ def camera_config(
 )
 @verbose_opt
 @click.pass_context
-def velocimetry(ctx, output, videofile, recipe, cameraconfig, prefix, h_a, cross, update, lowmem, verbose):
+def velocimetry(ctx, output, videofile, recipe, cameraconfig, prefix, h_a, cross, cross_wl, update, lowmem, verbose):
     """CLI subcommand for velocimetry."""
     log_level = max(10, 20 - 10 * verbose)
     logger = log.setuplog("velocimetry", os.path.abspath("pyorc.log"), append=False, log_level=log_level)
@@ -345,6 +353,7 @@ def velocimetry(ctx, output, videofile, recipe, cameraconfig, prefix, h_a, cross
         cameraconfig=cameraconfig,
         h_a=h_a,
         cross=cross,
+        cross_wl=cross_wl,
         prefix=prefix,
         output=output,
         update=update,

pyorc/cv.py

@@ -9,7 +9,7 @@ import numpy as np
 import rasterio
 from scipy import optimize
 from shapely.affinity import rotate
-from shapely.geometry import LineString, Polygon
+from shapely.geometry import LineString, Point, Polygon
 from tqdm import tqdm
 
 from . import helpers
@@ -88,6 +88,56 @@ def _combine_m(m1, m2):
     return m_combi
 
 
+def _get_aoi_corners(dst_corners, resolution=None):
+    polygon = Polygon(dst_corners)
+    coords = np.array(polygon.exterior.coords)
+    # estimate the angle of the bounding box
+    # retrieve average line across AOI
+    point1 = (coords[0] + coords[3]) / 2
+    point2 = (coords[1] + coords[2]) / 2
+    diff = point2 - point1
+    angle = np.arctan2(diff[1], diff[0])
+    # rotate the polygon over this angle to get a proper bounding box
+    polygon_rotate = rotate(polygon, -angle, origin=tuple(dst_corners[0]), use_radians=True)
+
+    xmin, ymin, xmax, ymax = polygon_rotate.bounds
+    if resolution is not None:
+        xmin = helpers.round_to_multiple(xmin, resolution)
+        xmax = helpers.round_to_multiple(xmax, resolution)
+        ymin = helpers.round_to_multiple(ymin, resolution)
+        ymax = helpers.round_to_multiple(ymax, resolution)
+
+    bbox_coords = [(xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin), (xmin, ymax)]
+    bbox = Polygon(bbox_coords)
+    # now rotate back
+    bbox = rotate(bbox, angle, origin=tuple(dst_corners[0]), use_radians=True)
+    return bbox
+
+
+def _get_aoi_width_length(dst_corners):
+    points = [Point(x, y) for x, y, _ in dst_corners]
+    linecross = LineString([points[0], points[1]])
+    # linecross = LineString(dst_corners[0:2])
+    length = np.abs(_get_perpendicular_distance(points[-1], linecross))
+    point1 = np.array(dst_corners[0][0:2])
+    point2 = np.array(dst_corners[1][0:2])
+    diff = np.array(point2 - point1)
+    angle = np.arctan2(diff[1], diff[0])
+
+    # compute xy distance from line to other line making up the bounding box
+    xy_diff = np.array([np.sin(-angle) * length, np.cos(angle) * length])
+    points_pol = np.array([point1 - xy_diff, point1 + xy_diff, point2 + xy_diff, point2 - xy_diff])
+    # always make sure the order of the points of upstream-left, downstream-left, downstream-right, upstream-right
+    # if length <= 0:
+    #     # negative length means the selected length is selected upstream of left-right cross section
+    #     points_pol = np.array([point1 + xy_diff, point1, point2, point2 + xy_diff])
+    # else:
+    #     # postive means it is selected downstream of left-right cross section
+    #     points_pol = np.array([point1, point1 + xy_diff, point2 + xy_diff, point2])
+
+    return Polygon(points_pol)
+
+
 def _smooth(img, stride):
     """Blur image through gaussian smoothing.
 
@@ -152,6 +202,52 @@ def _get_dist_coefs(k1):
     return dist
 
 
+def _get_perpendicular_distance(point, line):
+    """Calculate perpendicular distance from point to line.
+
+    Line is extended if perpendicular distance is larger than the distance to the endpoints.
+
+    Parameters
+    ----------
+    point : shapely.geometry.Point
+        x, y coordinates of point
+    line : shapely.geometry.LineString
+        line to calculate distance to
+
+    Returns
+    -------
+    float
+        perpendicular distance from point to line
+
+    """
+    # Get coordinates of line endpoints
+    p1 = np.array(line.coords[0])
+    p2 = np.array(line.coords[1])
+    # Convert point to numpy array
+    p3 = np.array(point.coords[0])
+
+    # Calculate line vector
+    line_vector = p2 - p1
+    # Calculate vector from point to line start
+    point_vector = p3 - p1
+
+    # Calculate unit vector of line
+    unit_line = line_vector / np.linalg.norm(line_vector)
+
+    # Calculate projection length
+    projection_length = np.dot(point_vector, unit_line)
+
+    # Calculate perpendicular vector
+    perpendicular_vector = point_vector - projection_length * unit_line
+    perpendicular_distance = np.linalg.norm(perpendicular_vector)
+
+    # Use cross product to calculate side
+    cross_product = np.cross(line_vector, point_vector)
+
+    # Determine the sign of the perpendicular distance
+    return perpendicular_distance if cross_product > 0 else -perpendicular_distance
+
+
 def get_cam_mtx(height, width, c=2.0, focal_length=None):
     """Compute camera matrix based on the given parameters for height, width, scaling factor, and focal length.
 
@@ -907,15 +1003,19 @@ def get_ortho(img, M, shape, flags=cv2.INTER_AREA):
     return cv2.warpPerspective(img, M, shape, flags=flags)
 
 
-def get_aoi(dst_corners, resolution=None):
-    """Get rectangular AOI from 4 user defined points within frames.
+def get_aoi(dst_corners, resolution=None, method="corners"):
+    """Get rectangular AOI from 3 or 4 user defined points within frames.
 
     Parameters
     ----------
     dst_corners : np.ndarray
-        corners of aoi, in order: upstream-left, downstream-left, downstream-right, upstream-right
+        corners of aoi, with `method="width_length"` in order: left-bank, right-bank, up/downstream point,
+        with `method="corners"` in order: upstream-left, downstream-left, downstream-right, upstream-right.
     resolution : float
         resolution of intended reprojection, used to round the bbox to a whole number of intended pixels
+    method : str
+        can be "corners" or "width_length". With "corners", the AOI is defined by the four corners of the rectangle.
+        With "width" length, the AOI is defined by the width (2 points) and length (1 point) of the rectangle.
 
     Returns
     -------
@@ -923,27 +1023,14 @@ def get_aoi(dst_corners, resolution=None):
         bounding box of aoi (with rotated affine)
 
     """
-    polygon = Polygon(dst_corners)
-    coords = np.array(polygon.exterior.coords)
-    # estimate the angle of the bounding box
-    # retrieve average line across AOI
-    point1 = (coords[0] + coords[3]) / 2
-    point2 = (coords[1] + coords[2]) / 2
-    diff = point2 - point1
-    angle = np.arctan2(diff[1], diff[0])
-    # rotate the polygon over this angle to get a proper bounding box
-    polygon_rotate = rotate(polygon, -angle, origin=tuple(dst_corners[0]), use_radians=True)
-    xmin, ymin, xmax, ymax = polygon_rotate.bounds
-    if resolution is not None:
-        xmin = helpers.round_to_multiple(xmin, resolution)
-        xmax = helpers.round_to_multiple(xmax, resolution)
-        ymin = helpers.round_to_multiple(ymin, resolution)
-        ymax = helpers.round_to_multiple(ymax, resolution)
+    if method == "corners":
+        bbox = _get_aoi_corners(dst_corners, resolution)
+    elif method == "width_length":
+        bbox = _get_aoi_width_length(dst_corners)
+
+    else:
+        raise ValueError("method must be 'corners' or 'width_length'")
 
-    bbox_coords = [(xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin), (xmin, ymax)]
-    bbox = Polygon(bbox_coords)
-    # now rotate back
-    bbox = rotate(bbox, angle, origin=tuple(dst_corners[0]), use_radians=True)
     return bbox