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

pyorc/cv.py

@@ -2,13 +2,14 @@
 
 import copy
 import os
+import warnings
 
 import cv2
 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
@@ -87,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.
 
@@ -151,7 +202,53 @@ def _get_dist_coefs(k1):
     return dist
 
 
-def _get_cam_mtx(height, width, c=2.0, focal_length=None):
+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.
 
     Parameters
@@ -906,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
     -------
@@ -922,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
 
 
@@ -958,7 +1046,7 @@ def get_polygon_pixels(img, pol, reverse_y=False):
     return img[mask == 255]
 
 
-def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None):
+def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None, camera_matrix=None, dist_coeffs=None):
     """Optimize the intrinsic parameters of a camera model.
 
     The function finds optimal intrinsic camera parameters, including focal length and distortion coefficients, by
@@ -980,6 +1068,11 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None):
         Center parameter of the camera matrix.
     lens_position : array_like, optional
         The assumed position of the lens in the 3D space.
+    camera_matrix : Optional[List[List]]
+        Predefined camera matrix. If not provided focal length will be fitted and camera matrix returned
+    dist_coeffs : Optional[List[List]]
+        Distortion coefficients to be used for the camera. If not provided, the first two (k1, k2)
+        distortion coefficients are fitted on data.
 
     Returns
     -------
@@ -989,7 +1082,7 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None):
 
     """
 
-    def error_intrinsic(x, src, dst, height, width, c=2.0, lens_position=None, dist_coeffs=DIST_COEFFS):
+    def error_intrinsic(x, src, dst, height, width, c=2.0, lens_position=None, camera_matrix=None, dist_coeffs=None):
         """Compute the reprojection error for the intrinsic parameters of a camera model.
 
         This function optimizes for the focal length and first two distortion coefficients based on the source and
@@ -1014,6 +1107,8 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None):
             center parameter of camera matrix.
         lens_position : array_like, optional
             The assumed position of the lens in the 3D space.
+        camera_matrix : array_like, optional
+            camera matrix [3x3]
         dist_coeffs : array_like, optional
             Distortion coefficients.
 
@@ -1024,24 +1119,43 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None):
             the camera position error if the lens position is provided.
 
         """
+        param_nr = 0
+        # set the parameters
+        if camera_matrix is None:
+            f = x[param_nr] * width
+            camera_matrix_sample = get_cam_mtx(height, width, c=c, focal_length=f)
+            param_nr += 1
+        else:
+            # take the existing camera matrix
+            camera_matrix_sample = camera_matrix.copy()
+        if dist_coeffs is None:
+            dist_coeffs_sample = DIST_COEFFS.copy()
+            k1 = x[param_nr]
+            k2 = x[param_nr + 1]
+            dist_coeffs_sample[0][0] = k1
+            dist_coeffs_sample[1][0] = k2
+        else:
+            # take the existing distortion coefficients
+            dist_coeffs_sample = dist_coeffs.copy()
+            k1 = dist_coeffs_sample[0][0]
+            k2 = dist_coeffs_sample[1][0]
+
+        # initialize error
         err = 100
         cam_err = None
-        f = x[0] * width  # only one parameter to optimize for now, can easily be extended!
-        dist_coeffs[0][0] = float(x[1])
-        dist_coeffs[1][0] = float(x[2])
-        # dist_coeffs[4][0] = float(x[3])
-        # dist_coeffs[3][0] = float(x[4])
+
+        # reduce problem space to centered around gcp average
         coord_mean = np.array(dst).mean(axis=0)
         _dst = np.float64(np.array(dst) - coord_mean)
         zs = np.zeros(4) if len(_dst[0]) == 2 else np.array(_dst)[:, -1]
         if lens_position is not None:
             _lens_pos = np.array(lens_position) - coord_mean
 
-        camera_matrix = _get_cam_mtx(height, width, c=c, focal_length=f)
-        success, rvec, tvec = solvepnp(_dst, src, camera_matrix, dist_coeffs)
+        # camera_matrix = _get_cam_mtx(height, width, c=c, focal_length=f)
+        success, rvec, tvec = solvepnp(_dst, src, camera_matrix_sample, dist_coeffs_sample)
         if success:
             # estimate destination locations from pose
-            dst_est = unproject_points(src, zs, rvec, tvec, camera_matrix, dist_coeffs)
+            dst_est = unproject_points(src, zs, rvec, tvec, camera_matrix_sample, dist_coeffs_sample)
             # src_est = np.array([list(point[0]) for point in src_est])
             dist_xy = np.array(_dst)[:, 0:2] - np.array(dst_est)[:, 0:2]
             dist = (dist_xy**2).sum(axis=1) ** 0.5
@@ -1054,27 +1168,51 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None):
             err = float(0.1 * cam_err + gcp_err) if cam_err is not None else gcp_err
         return err  # assuming gcp pixel distance is about 5 cm
 
-    if len(dst) == 4:
-        bnds_k1 = (-0.0, 0.0)
-        bnds_k2 = (-0.0, 0.0)
+    # determine optimization bounds
+    bounds = []
+    if camera_matrix is not None and dist_coeffs is not None:
+        # both are already known, so nothing to do
+        return camera_matrix, dist_coeffs, None
+    if camera_matrix is None:
+        bounds.append([float(0.25), float(2)])
+    if len(dst) > 4 and dist_coeffs is None:
+        bounds.append([-0.9, 0.9])  # k1
+        bounds.append([-0.5, 0.5])  # k2
     else:
-        # bnds_k1 = (-0.2501, -0.25)
-        bnds_k1 = (-0.9, 0.9)
-        bnds_k2 = (-0.5, 0.5)
-        # bnds_k1 = (-0.0, 0.0)
-        # bnds_k2 = (-0.0, 0.0)
+        # set a warning if dist_coeffs is provided without sufficient ground control
+        if dist_coeffs:
+            warnings.warn(
+                "You are trying to optimize distortion coefficients with only 4 GCPs. "
+                "This would lead to overfitting, setting distortion coefficients to zero.",
+                stacklevel=2,
+            )
+        dist_coeffs = DIST_COEFFS.copy()
+    # if len(dst) == 4:
+    #     bnds_k1 = (-0.0, 0.0)
+    #     bnds_k2 = (-0.0, 0.0)
+    # else:
+    #     # bnds_k1 = (-0.2501, -0.25)
+    #     bnds_k1 = (-0.9, 0.9)
+    #     bnds_k2 = (-0.5, 0.5)
+    # bnds_k1 = (-0.0, 0.0)
+    # bnds_k2 = (-0.0, 0.0)
     opt = optimize.differential_evolution(
         error_intrinsic,
         # bounds=[(float(0.25), float(2)), bnds_k1],#, (-0.5, 0.5)],
-        bounds=[(float(0.25), float(2)), bnds_k1, bnds_k2],
+        bounds=bounds,
         # bounds=[(1710./width, 1714./width), bnds_k1, bnds_k2],
-        args=(src, dst, height, width, c, lens_position, DIST_COEFFS),
+        args=(src, dst, height, width, c, lens_position, camera_matrix, dist_coeffs),
         atol=0.001,  # one mm
     )
-    camera_matrix = _get_cam_mtx(height, width, focal_length=opt.x[0] * width)
-    dist_coeffs = DIST_COEFFS
-    dist_coeffs[0][0] = opt.x[1]
-    dist_coeffs[1][0] = opt.x[2]
+    param_nr = 0
+    if camera_matrix is None:
+        camera_matrix = get_cam_mtx(height, width, focal_length=opt.x[param_nr] * width)
+        # move to next parameter
+        param_nr += 1
+    if dist_coeffs is None:
+        dist_coeffs = DIST_COEFFS
+        dist_coeffs[0][0] = opt.x[param_nr]
+        dist_coeffs[1][0] = opt.x[param_nr + 1]
     # dist_coeffs[4][0] = opt.x[3]
     # dist_coeffs[3][0] = opt.x[4]
     # print(f"CAMERA MATRIX: {camera_matrix}")