pyopenrivercam 0.8.5__tar.gz → 0.8.6__tar.gz

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.8.6] = 2025-05-16
+### Added
+- added options `--k1`, `--k2` and `--focal_length` to command line interface for cases where
+  focal length, and distortion coefficients are already known
+### Changed
+- optimization of intrinsics can now also be done with partly already known data. If k1 and k2 are known
+  these can be passed as camera
+### Deprecated
+### Removed
+### Fixed
+
+
 ## [0.8.5] = 2025-03-25
 ### Added
 - option `--cross` can now also be provided at service level. Only relevant

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenrivercam
-Version: 0.8.5
+Version: 0.8.6
 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.5 → pyopenrivercam-0.8.6}/docs/user-guide/camera_config/index.rst

@@ -93,7 +93,7 @@ middle of the FOV, then velocities at the edges are likely to be overestimated.
     optimize the radial distortion. Therefore we strongly recommend that you measure 6 or more control points in case
     you use a lens with significant radial distortion.
 
-You can also provide a camera intrinsic matrix and distortion coefficients in the API if you have these, or optimize
+You can also provide a camera intrinsic matrix and distortion coefficients in the CLI or API if you have these, or optimize
 the intrinsic matrix and distortion coefficients using a checkerboard pattern. More on this is described below.
 
 Preparing a video for camera calibration
@@ -142,7 +142,13 @@ Lens calibration method
         .. note::
 
             At the moment, manual lens calibration is only available at API level. If you require a command-line option
-            for lens calibration, then please contact us at info@rainbowsensing.com.
+            for lens calibration, then please contact us at info@rainbowsensing.com. If you have the focal length, and
+            k1 and k2 radial distortion parameters available, then you can enter these in the command line interface
+            using the `--focal_length`, `--k1`, `--k2` parameters. The units of the focal length should be in pixels.
+            For focal length, and distortion parameters, we use the OpenCV methods, so please ensure you use
+            the same as input here. For more information please read:
+            `the OpenCV instructions <https://docs.opencv.org/2.4/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html>`_
+
 
     .. tab-item:: API
 

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/pyorc/__init__.py

@@ -1,6 +1,6 @@
 """pyorc: free and open-source image-based surface velocity and discharge."""
 
-__version__ = "0.8.5"
+__version__ = "0.8.6"
 
 from .api import CameraConfig, CrossSection, Frames, Transect, Velocimetry, Video, get_camera_config, load_camera_config  # noqa
 from .project import *  # noqa

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/pyorc/api/cameraconfig.py

@@ -47,7 +47,6 @@ class CameraConfig:
         lens_position: Optional[List[float]] = None,
         corners: Optional[List[List[float]]] = None,
         gcps: Optional[Dict[str, Union[List, float]]] = None,
-        lens_pars: Optional[Dict[str, float]] = None,
         calibration_video: Optional[str] = None,
         is_nadir: Optional[bool] = False,
         stabilize: Optional[List[List]] = None,
@@ -90,10 +89,6 @@ class CameraConfig:
             the same vertical reference as the measured bathymetry and other survey points,
             "crs": int, str or CRS object, CRS in which "dst" points are measured. If None, a local coordinate system is
             assumed (e.g. from spirit level).
-        lens_pars : dict, optional
-            Lens parameters, containing: "k1": float, barrel lens distortion parameter (default: 0.),
-            "c": float, optical center (default: 2.),
-            "focal_length": float, focal length (default: width of image frame)
         calibration_video : str, optional
             local path to video file containing a checkerboard pattern. Must be 9x6 if called directly, otherwise use
             ``.calibrate_camera`` explicitly and provide ``chessboard_size`` explicitly. When used, an automated camera
@@ -141,13 +136,13 @@ class CameraConfig:
             if self.is_nadir:
                 # with nadir, no perspective can be constructed, hence, camera matrix and dist coeffs will be set
                 # to default values
-                self.camera_matrix = cv._get_cam_mtx(self.height, self.width)
+                self.camera_matrix = cv.get_cam_mtx(self.height, self.width)
                 self.dist_coeffs = cv.DIST_COEFFS
             # camera pars are incomplete and need to be derived
             else:
-                self.set_intrinsic(camera_matrix=camera_matrix, lens_pars=lens_pars)
+                self.set_intrinsic(camera_matrix=camera_matrix)
         else:
-            # camera matrix and dist coeffs can also be set hard, this overrules the lens_pars option
+            # camera matrix and dist coeffs can also be set hard
             self.camera_matrix = camera_matrix
             self.dist_coeffs = dist_coeffs
         if calibration_video is not None:
@@ -201,6 +196,27 @@ class CameraConfig:
     def dist_coeffs(self, dist_coeffs):
         self._dist_coeffs = dist_coeffs.tolist() if isinstance(dist_coeffs, np.ndarray) else dist_coeffs
 
+    @property
+    def focal_length(self):
+        """Get focal length."""
+        if not self.camera_matrix:
+            return None
+        return self.camera_matrix[0][0]
+
+    @property
+    def k1(self):
+        """Get first distortion coefficient."""
+        if not self.dist_coeffs:
+            return None
+        return self.dist_coeffs[0]
+
+    @property
+    def k2(self):
+        """Get second distortion coefficient."""
+        if not self.dist_coeffs:
+            return None
+        return self.dist_coeffs[1]
+
     @property
     def gcps_dest(self):
         """Get destination coordinates of GCPs.
@@ -855,7 +871,6 @@ class CameraConfig:
         self,
         camera_matrix: Optional[List[List]] = None,
         dist_coeffs: Optional[List[List]] = None,
-        lens_pars: Optional[Dict[str, float]] = None,
     ):
         """Set lens and distortion parameters.
 
@@ -871,12 +886,13 @@ class CameraConfig:
             Distortion coefficients to be used for the camera. If not provided, it will use default values or those
             derived from GCPs if available.
 
-        lens_pars : Optional[Dict[str, float]]
-            Lens parameters to be set. These will override any default settings or those derived from GCPs if provided.
-
         """
-        # first set a default estimate from pose if 3D gcps are available
-        self.set_lens_pars()  # default parameters use width of frame
+        if camera_matrix is not None and dist_coeffs is not None:
+            # both are provided by user, so no fitting needed
+            self.camera_matrix = camera_matrix
+            self.dist_coeffs = dist_coeffs
+            return
+
         if hasattr(self, "gcps"):
             if len(self.gcps["src"]) >= 4:
                 self.camera_matrix, self.dist_coeffs, err = cv.optimize_intrinsic(
@@ -886,36 +902,9 @@ class CameraConfig:
                     self.height,
                     self.width,
                     lens_position=self.lens_position,
+                    camera_matrix=camera_matrix,
+                    dist_coeffs=dist_coeffs,
                 )
-            if lens_pars is not None:
-                # override with lens parameter set by user
-                self.set_lens_pars(**lens_pars)
-            if camera_matrix is not None and dist_coeffs is not None:
-                # override with
-                self.camera_matrix = camera_matrix
-                self.dist_coeffs = dist_coeffs
-
-    def set_lens_pars(self, k1: Optional[float] = 0.0, c: Optional[float] = 2.0, focal_length: Optional[float] = None):
-        """Set the lens parameters of the given CameraConfig.
-
-        Parameters
-        ----------
-        k1 : float, optional
-            lens curvature [-], zero (default) means no curvature
-        c : float, optional
-            optical centre [1/n], where n is the fraction of the lens diameter, 2.0 (default) means in the
-            centre.
-        focal_length : float, optional
-            focal length [mm], typical values could be 2.8, or 4 (default).
-
-
-        """
-        assert isinstance(k1, (int, float)), "k1 must be a float"
-        assert isinstance(c, (int, float)), "c must be a float"
-        if focal_length is not None:
-            assert isinstance(focal_length, (int, float, None)), "f must be a float"
-        self.dist_coeffs = cv._get_dist_coefs(k1)
-        self.camera_matrix = cv._get_cam_mtx(self.height, self.width, c=c, focal_length=focal_length)
 
     def set_gcps(
         self, src: List[List], dst: List[List], z_0: float, h_ref: Optional[float] = None, crs: Optional[Any] = None

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/pyorc/api/cross_section.py

@@ -986,7 +986,7 @@ class CrossSection:
             lens_position_xy = self.camera_config.estimate_lens_position()[0:2]
             dists = [((p.x - lens_position_xy[0]) ** 2 + (p.y - lens_position_xy[1]) ** 2) ** 0.5 for p in points]
             points = self.get_csl_point(h=h, camera=True, swap_y_coords=swap_y_coords)  # find camera positions
-            x, y = points[np.argmin(dists)].xy
+            x, y = points[np.argmax(dists)].xy
             x, y = float(x[0]), float(y[0])
 
             # only plot text in 2D camera perspective at farthest point

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/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

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/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)
@@ -152,6 +172,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 +326,13 @@ 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
+        with open(fn, "r") as f:
+            raw_json = json.load(f)
+        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"'

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/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,
@@ -297,7 +314,7 @@ def camera_config(
     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",
+    " [PyORC docs](https://localdevices.github.io/pyorc/user-guide/video/index.html)",
     callback=cli_utils.parse_cross_section_gdf,
     required=False,
 )

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/pyorc/cv.py

@@ -2,6 +2,7 @@
 
 import copy
 import os
+import warnings
 
 import cv2
 import numpy as np
@@ -151,7 +152,7 @@ def _get_dist_coefs(k1):
     return dist
 
 
-def _get_cam_mtx(height, width, c=2.0, focal_length=None):
+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
@@ -958,7 +959,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 +981,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 +995,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 +1020,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 +1032,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 +1081,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}")

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/tests/conftest.py

@@ -166,13 +166,14 @@ def camera_matrix():
 
 
 @pytest.fixture()
-def cam_config(gcps, lens_position, lens_pars, corners):
+def cam_config(gcps, lens_position, dist_coeffs, camera_matrix, corners):
     return pyorc.CameraConfig(
         height=1080,
         width=1920,
         gcps=gcps,
         lens_position=lens_position,
-        lens_pars=lens_pars,
+        dist_coeffs=dist_coeffs,
+        camera_matrix=camera_matrix,
         corners=corners,
         window_size=25,
         resolution=0.01,

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/tests/test_cameraconfig.py

@@ -175,13 +175,6 @@ def test_set_bbox_from_corners(cur_cam_config, cur_corners, cur_bbox, request):
     assert np.allclose(cur_cam_config.bbox.bounds, cur_bbox.bounds)
 
 
-def test_set_lens_pars(cam_config, lens_pars, camera_matrix, dist_coeffs):
-    # check if this works
-    cam_config.set_lens_pars(**lens_pars)
-    assert np.allclose(cam_config.camera_matrix, camera_matrix)
-    assert np.allclose(cam_config.dist_coeffs, dist_coeffs)
-
-
 def test_set_gcps(cam_config, gcps):
     cam_config.set_gcps(**gcps)
     assert cam_config.gcps == gcps
@@ -203,13 +196,15 @@ def test_estimate_lens_position(cam_config):
     assert np.allclose(lens_pos, [6.42731099e05, 8.30429131e06, 1.18996749e03])
 
 
-def test_optimize_intrinsic(cam_config):
+@pytest.mark.parametrize("cur_cam_config", ["cam_config", "cam_config_6gcps"])
+def test_optimize_intrinsic(cur_cam_config, request):
+    cur_cam_config = request.getfixturevalue(cur_cam_config)
     camera_matrix, dist_coeffs, err = cv.optimize_intrinsic(
-        cam_config.gcps["src"],
-        cam_config.gcps_dest,
-        cam_config.height,
-        cam_config.width,
-        lens_position=cam_config.lens_position,
+        cur_cam_config.gcps["src"],
+        cur_cam_config.gcps_dest,
+        cur_cam_config.height,
+        cur_cam_config.width,
+        lens_position=cur_cam_config.lens_position,
     )
     print(camera_matrix, dist_coeffs, err)
 

{pyopenrivercam-0.8.5 → pyopenrivercam-0.8.6}/tests/test_cli.py

@@ -65,6 +65,8 @@ def test_cli_cam_config_video(cli_obj, vid_file, gcps_src, gcps_dst, lens_positi
             json.dumps(lens_position),
             "--resolution",
             "0.03",
+            "--focal_length",
+            "1500",
             "--window_size",
             "25",
             "--corners",