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

{pyopenrivercam-0.8.5.dist-info → pyopenrivercam-0.8.6.dist-info}/METADATA

@@ -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.dist-info → pyopenrivercam-0.8.6.dist-info}/RECORD

@@ -1,14 +1,14 @@
-pyorc/__init__.py,sha256=is1wDrt1OO9qnnm9kD_1OJt8NUdlLXNhsEtnjfD5cWs,523
+pyorc/__init__.py,sha256=wbzL3QPC8KrCa1QKwZs-oKJ3yeUhfDa8wLQMsRoKwyk,523
 pyorc/const.py,sha256=Ia0KRkm-E1lJk4NxQVPDIfN38EBB7BKvxmwIHJrGPUY,2597
-pyorc/cv.py,sha256=_H4dcQmqX_SlGbnJCG48pK0hvvWOM1jDusykIsIR230,43734
+pyorc/cv.py,sha256=qhz0y03k3CwMxFChodGW8kIcJNvWYJ4vFvQLj16JAr0,45841
 pyorc/helpers.py,sha256=2HN9_NQ5wp1xVtHFcFm0Ri7mwAKYT8jlmWLQ45Xs9GY,29871
 pyorc/plot_helpers.py,sha256=i6pcZHfpGCMkPNHWSkoE0N9-nuKfqXR7V5wgdT184IY,1274
 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=jErzIETxDkCEaUcXCP01illXnX_yqSjRCFQOSzfB8p0,62226
-pyorc/api/cross_section.py,sha256=rvCHlM6_HX-qlbZkiQfEsSwwYhqmwLgSEL6JEGzUpKA,46935
+pyorc/api/cameraconfig.py,sha256=IyhaX5IZHOwY_CMjVQiYTKUWLyzpGXFfY_tT3aV1y8c,60979
+pyorc/api/cross_section.py,sha256=p8DMFIAuxMzF6_9CYOtN4Fn25L1XAwslKJj5ovxouuw,46935
 pyorc/api/frames.py,sha256=u0ZUgs-DKdWTUTPMrpMrHtV5VMeCfL3h5SKTfn88wsk,25754
 pyorc/api/mask.py,sha256=HVag3RkMu4ZYQg_pIZFhiJYkBGYLVBxeefdmWvFTR-4,14371
 pyorc/api/orcbase.py,sha256=C23QTKOyxHUafyJsq_t7xn_BzAEvf4DDfzlYAopons8,4189
@@ -17,18 +17,18 @@ 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=D9t1DOYgqa-FfZSjFiOkoV_6ARksonPe4deMoNM5maM,21816
-pyorc/cli/cli_utils.py,sha256=AOfnnbvd8FfMjCDHRL6yLIzHr-hymQ3r7j0rK4aaD60,13626
+pyorc/cli/cli_elements.py,sha256=zX9wv9-1KWC_E3cInGMm3g9jh4uXmT2NqooAMhhXR9s,22165
+pyorc/cli/cli_utils.py,sha256=uQ0I8wRMSJBOTvxxxMXSizDR7Qmn1KeaQwUHHhaQxU0,15090
 pyorc/cli/log.py,sha256=Vg8GznmrEPqijfW6wv4OCl8R00Ld_fVt-ULTitaDijY,2824
-pyorc/cli/main.py,sha256=YVH8vi_gCQ6K26ZZcnsQVtc0fXRvh-zynHZdfTX1BBw,11671
+pyorc/cli/main.py,sha256=YtS_st119N-SFpRJDPv2O4ttBGhKRfH_DQSl3OZkNlA,12358
 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=bPEuy6TOpC22OY1E8gNnKSL0diF5ja2FtwNsj3-NdFg,29268
 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.5.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
-pyopenrivercam-0.8.5.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-pyopenrivercam-0.8.5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyopenrivercam-0.8.5.dist-info/METADATA,sha256=kjVpUC1BR3CMw0X5PGDBlVMTYdMXS5SBg3U3sfNDqKg,11513
-pyopenrivercam-0.8.5.dist-info/RECORD,,
+pyopenrivercam-0.8.6.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
+pyopenrivercam-0.8.6.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+pyopenrivercam-0.8.6.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pyopenrivercam-0.8.6.dist-info/METADATA,sha256=xwryCN_ptr7C_o59bbD8NiXqv3ob549hIlgUYWatCRc,11513
+pyopenrivercam-0.8.6.dist-info/RECORD,,

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

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

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

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)
@@ -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"'

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,
 )

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}")