pyopenrivercam 0.8.5__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_elements.py

@@ -360,7 +360,7 @@ class AoiSelect(BaseSelect):
 class GcpSelect(BaseSelect):
     """Selector tool to provide source GCP coordinates to pyOpenRiverCam."""
 
-    def __init__(self, img, dst, crs=None, lens_position=None, logger=logging):
+    def __init__(self, img, dst, crs=None, camera_matrix=None, dist_coeffs=None, lens_position=None, logger=logging):
         """Set up interactive GCP selection plot."""
         super(GcpSelect, self).__init__(img, dst, crs=crs, logger=logger)
         # make empty plot
@@ -389,6 +389,8 @@ class GcpSelect(BaseSelect):
         self.ax_geo.legend()
         self.ax.legend()
         self.lens_position = lens_position
+        self.camera_matrix_input = camera_matrix
+        self.dist_coeffs_input = dist_coeffs
         # add dst coords in the intended CRS
         if crs is not None and use_cartopy:
             self.dst_crs = helpers.xyz_transform(self.dst, 4326, crs)
@@ -407,7 +409,14 @@ class GcpSelect(BaseSelect):
                 self.title.set_text("Fitting pose and camera parameters...")
                 self.ax.figure.canvas.draw()
                 src_fit, dst_fit, camera_matrix, dist_coeffs, rvec, tvec, err = cli_utils.get_gcps_optimized_fit(
-                    self.src, self.dst_crs, self.height, self.width, c=2.0, lens_position=self.lens_position
+                    self.src,
+                    self.dst_crs,
+                    self.height,
+                    self.width,
+                    c=2.0,
+                    camera_matrix=self.camera_matrix_input,
+                    dist_coeffs=self.dist_coeffs_input,
+                    lens_position=self.lens_position,
                 )
                 self.p_fit.set_data(*list(zip(*src_fit)))
                 self.camera_matrix = camera_matrix

pyorc/cli/cli_utils.py

@@ -4,6 +4,7 @@ import hashlib
 import json
 import logging
 import os
+from typing import Optional
 
 import click
 import cv2
@@ -57,15 +58,39 @@ def get_corners_interactive(
 
 
 def get_gcps_interactive(
-    fn, dst, crs=None, crs_gcps=None, frame_sample=0, lens_position=None, rotation=None, logger=logging
+    fn,
+    dst,
+    crs=None,
+    crs_gcps=None,
+    frame_sample=0,
+    focal_length=None,
+    k1=None,
+    k2=None,
+    lens_position=None,
+    rotation=None,
+    logger=logging,
 ):
     """Select GCP points in interactive display using first selected video frame."""
     vid = Video(fn, start_frame=frame_sample, end_frame=frame_sample + 1, rotation=rotation)
     # get first frame
     frame = vid.get_frame(0, method="rgb")
+    # construct camera matrix and distortion coefficients
+    # parse items
+    camera_matrix, dist_coeffs = parse_lens_params(
+        height=frame.shape[0], width=frame.shape[1], focal_length=focal_length, k1=k1, k2=k2
+    )
+
     if crs_gcps is not None:
         dst = helpers.xyz_transform(dst, crs_from=crs_gcps, crs_to=4326)
-    selector = GcpSelect(frame, dst, crs=crs, lens_position=lens_position, logger=logger)
+    selector = GcpSelect(
+        frame,
+        dst,
+        crs=crs,
+        camera_matrix=camera_matrix,
+        dist_coeffs=dist_coeffs,
+        lens_position=lens_position,
+        logger=logger,
+    )
     plt.show(block=True)
     return selector.src, selector.camera_matrix, selector.dist_coeffs
 
@@ -90,21 +115,16 @@ def get_file_hash(fn):
     return hash256
 
 
-def get_gcps_optimized_fit(src, dst, height, width, c=2.0, lens_position=None):
+def get_gcps_optimized_fit(src, dst, height, width, c=2.0, camera_matrix=None, dist_coeffs=None, lens_position=None):
     """Fit intrinsic and extrinsic parameters on provided set of src and dst points."""
     # optimize cam matrix and dist coeffs with provided control points
     if np.array(dst).shape == (4, 2):
         _dst = np.c_[np.array(dst), np.zeros(4)]
     else:
         _dst = np.array(dst)
+    print(camera_matrix)
     camera_matrix, dist_coeffs, err = cv.optimize_intrinsic(
-        src,
-        _dst,
-        height,
-        width,
-        c=c,
-        lens_position=lens_position,
-        # dist_coeffs=cv.DIST_COEFFS
+        src, _dst, height, width, c=c, lens_position=lens_position, camera_matrix=camera_matrix, dist_coeffs=dist_coeffs
     )
     # once optimized, solve the perspective, and estimate the GCP locations with the perspective rot/trans
     coord_mean = np.array(_dst).mean(axis=0)
@@ -116,7 +136,12 @@ def get_gcps_optimized_fit(src, dst, height, width, c=2.0, lens_position=None):
     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
 
 
@@ -152,6 +177,29 @@ def parse_corners(ctx, param, value):
     return [[int(x), int(y)] for x, y in corners]
 
 
+def parse_lens_params(
+    height: int,
+    width: int,
+    focal_length: Optional[float] = None,
+    k1: Optional[float] = None,
+    k2: Optional[float] = None,
+):
+    """Parse lens parameters to camera matrix and distortion coefficients vector."""
+    if focal_length is not None:
+        camera_matrix = cv.get_cam_mtx(height, width, c=2.0, focal_length=focal_length)
+    else:
+        camera_matrix = None
+    if k1 is not None or k2 is not None:
+        dist_coeffs = cv.DIST_COEFFS.copy()
+        if k1 is not None:
+            dist_coeffs[0][0] = k1
+        if k2 is not None:
+            dist_coeffs[1][0] = k2
+    else:
+        dist_coeffs = None
+    return camera_matrix, dist_coeffs
+
+
 def validate_file(ctx, param, value):
     """Validate existence of file."""
     if value is not None:
@@ -283,6 +331,18 @@ def read_shape_as_gdf(fn=None, geojson=None, gdf=None):
     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)
     # 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/cli/main.py

@@ -99,6 +99,17 @@ def cli(ctx, info, license):
     help="Coordinate reference system in which destination GCP points (--dst) are measured",
 )
 @click.option("--resolution", type=float, help="Target resolution [m] for ortho-projection.")
+@click.option("--focal_length", type=float, help="Focal length [pix] of lens.")
+@click.option(
+    "--k1",
+    type=float,
+    help="First lens radial distortion coefficient k1 [-]. See also https://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html",
+)
+@click.option(
+    "--k2",
+    type=float,
+    help="Second lens radial distortion coefficient k2 [-]. See also https://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html",
+)
 @click.option(
     "--window_size", type=int, help="Target window size [px] for interrogation window for Particle Image Velocimetry"
 )
@@ -148,6 +159,9 @@ def camera_config(
     z_0: Optional[float],
     h_ref: Optional[float],
     crs_gcps: Optional[Union[str, int]],
+    focal_length: Optional[float],
+    k1: Optional[float],
+    k2: Optional[float],
     resolution: Optional[float],
     window_size: Optional[int],
     lens_position: Optional[List[float]],
@@ -207,6 +221,9 @@ def camera_config(
                 crs=crs,
                 crs_gcps=crs_gcps,
                 frame_sample=frame_sample,
+                focal_length=focal_length,
+                k1=k1,
+                k2=k2,
                 lens_position=lens_position,
                 rotation=rotation,
                 logger=logger,
@@ -295,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"
-    " 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,
 )
@@ -316,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)
@@ -328,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,