updating compatability

Author: alexlib

src/openptv_python/_native_convert.py

@@ -32,6 +32,9 @@ def _optv_parameters_module() -> ModuleType:
 
 
 def to_native_calibration(cal: Calibration):
+    if not isinstance(cal, Calibration):
+        return cal
+
     if not HAS_NATIVE_CALIBRATION or optv_calibration is None:
         raise RuntimeError("optv Calibration is not available")
 
@@ -49,6 +52,9 @@ def to_native_calibration(cal: Calibration):
 
 
 def to_native_control_par(cpar: ControlPar):
+    if not isinstance(cpar, ControlPar):
+        return cpar
+
     parameters_module = _optv_parameters_module()
 
     flags = [
@@ -83,6 +89,9 @@ def to_native_control_par(cpar: ControlPar):
 
 
 def to_native_target_par(tpar: TargetPar):
+    if not isinstance(tpar, TargetPar):
+        return tpar
+
     parameters_module = _optv_parameters_module()
 
     thresholds = list(tpar.gvthresh)

src/openptv_python/segmentation.py

@@ -35,6 +35,48 @@ class Peak:
     n_touch: int = 0
 
 
+def _control_image_size(cpar: ControlPar) -> tuple[int, int]:
+    if hasattr(cpar, "get_image_size"):
+        return cpar.get_image_size()
+    return cpar.imx, cpar.imy
+
+
+def _target_thresholds(targ_par: TargetPar) -> list[int]:
+    if hasattr(targ_par, "get_grey_thresholds"):
+        return list(targ_par.get_grey_thresholds())
+    return list(targ_par.gvthresh)
+
+
+def _target_discont(targ_par: TargetPar) -> int:
+    if hasattr(targ_par, "get_max_discontinuity"):
+        return targ_par.get_max_discontinuity()
+    return targ_par.discont
+
+
+def _target_nn_bounds(targ_par: TargetPar) -> tuple[int, int]:
+    if hasattr(targ_par, "get_pixel_count_bounds"):
+        return targ_par.get_pixel_count_bounds()
+    return targ_par.nnmin, targ_par.nnmax
+
+
+def _target_nx_bounds(targ_par: TargetPar) -> tuple[int, int]:
+    if hasattr(targ_par, "get_xsize_bounds"):
+        return targ_par.get_xsize_bounds()
+    return targ_par.nxmin, targ_par.nxmax
+
+
+def _target_ny_bounds(targ_par: TargetPar) -> tuple[int, int]:
+    if hasattr(targ_par, "get_ysize_bounds"):
+        return targ_par.get_ysize_bounds()
+    return targ_par.nymin, targ_par.nymax
+
+
+def _target_min_sum_grey(targ_par: TargetPar) -> int:
+    if hasattr(targ_par, "get_min_sum_grey"):
+        return targ_par.get_min_sum_grey()
+    return targ_par.sumg_min
+
+
 def targ_rec(
     img: np.ndarray,
     targ_par: TargetPar,
@@ -46,12 +88,20 @@ def targ_rec(
     num_cam,
 ) -> List[Target]:
     """Target recognition function."""
+    imx, imy = _control_image_size(cpar)
+    thresholds = _target_thresholds(targ_par)
+    disco = _target_discont(targ_par)
+    nnmin, nnmax = _target_nn_bounds(targ_par)
+    nxmin, nxmax = _target_nx_bounds(targ_par)
+    nymin, nymax = _target_ny_bounds(targ_par)
+    sumg_min = _target_min_sum_grey(targ_par)
+
     if (
         should_use_native("target_recognition")
         and xmin <= 0
         and ymin <= 0
-        and xmax >= cpar.imx
-        and ymax >= cpar.imy
+        and xmax >= imx
+        and ymax >= imy
     ):
         native_tpar = to_native_target_par(targ_par)
         native_cpar = to_native_control_par(cpar)
@@ -64,29 +114,23 @@ def targ_rec(
             subrange_y=None,
         )
         targets = from_native_target_array(native_targets)
-        threshold = targ_par.gvthresh[int(num_cam)]
+        threshold = thresholds[int(num_cam)]
         for target in targets:
             target.sumg -= target.n * threshold
         return targets
 
-    thres = targ_par.gvthresh[num_cam]
-    disco = targ_par.discont
+    thres = thresholds[num_cam]
 
     # Make sure the min/max coordinates don't cause us to access memory
     # outside the image memory.
     if xmin <= 0:
         xmin = 1
     if ymin <= 0:
         ymin = 1
-    if xmax >= cpar.imx:
-        xmax = cpar.imx - 1
-    if ymax >= cpar.imy:
-        ymax = cpar.imy - 1
-
-    nnmin, nnmax = targ_par.nnmin, targ_par.nnmax
-    nxmin, nxmax = targ_par.nxmin, targ_par.nxmax
-    nymin, nymax = targ_par.nymin, targ_par.nymax
-    sumg_min = targ_par.sumg_min
+    if xmax >= imx:
+        xmax = imx - 1
+    if ymax >= imy:
+        ymax = imy - 1
 
     pix = fast_targ_rec(
         img,
@@ -293,13 +337,18 @@ def peak_fit(
     num_cam: int,
 ) -> List[Target]:
     """Fit the peaks in the image to a gaussian."""
-    imx, imy = cpar.imx, cpar.imy
+    imx, imy = _control_image_size(cpar)
+    thresholds = _target_thresholds(targ_par)
+    disco = _target_discont(targ_par)
+    nnmin, nnmax = _target_nn_bounds(targ_par)
+    nxmin, nxmax = _target_nx_bounds(targ_par)
+    nymin, nymax = _target_ny_bounds(targ_par)
+    sumg_min = _target_min_sum_grey(targ_par)
     n_peaks = 0
     n_wait = 0
     x8, y8 = [0, 1, 0, -1], [1, 0, -1, 0]
     p2 = 0
-    thres = targ_par.gvthresh[num_cam]
-    disco = targ_par.discont
+    thres = thresholds[num_cam]
     intx1, inty1 = 0, 0
     unify = 0
     unified = 0
@@ -525,13 +574,13 @@ def peak_fit(
 
         if (
             peaks[i].unr == 0
-            and peaks[i].sumg > targ_par.sumg_min
-            and (peaks[i].xmax - peaks[i].xmin + 1) >= targ_par.nxmin
-            and (peaks[i].ymax - peaks[i].ymin + 1) >= targ_par.nymin
-            and (peaks[i].xmax - peaks[i].xmin) < targ_par.nxmax
-            and (peaks[i].ymax - peaks[i].ymin) < targ_par.nymax
-            and peaks[i].n >= targ_par.nnmin
-            and peaks[i].n <= targ_par.nnmax
+            and peaks[i].sumg > sumg_min
+            and (peaks[i].xmax - peaks[i].xmin + 1) >= nxmin
+            and (peaks[i].ymax - peaks[i].ymin + 1) >= nymin
+            and (peaks[i].xmax - peaks[i].xmin) < nxmax
+            and (peaks[i].ymax - peaks[i].ymin) < nymax
+            and peaks[i].n >= nnmin
+            and peaks[i].n <= nnmax
         ):
             sumg = peaks[i].sumg
 
@@ -641,14 +690,19 @@ def target_recognition(
     -------
     Number of  object holding the targets found.
     """
+    if hasattr(cparam, "get_image_size"):
+        imx, imy = cparam.get_image_size()
+    else:
+        imx, imy = cparam.imx, cparam.imy
+
     # Set the subrange (to default if not given):
     if subrange_x is None:
-        xmin, xmax = 0, cparam.imx
+        xmin, xmax = 0, imx
     else:
         xmin, xmax = subrange_x
 
     if subrange_y is None:
-        ymin, ymax = 0, cparam.imy
+        ymin, ymax = 0, imy
     else:
         ymin, ymax = subrange_y
 

src/openptv_python/trafo.py

@@ -9,6 +9,35 @@
 from .parameters import ControlPar
 
 
+def _control_image_size(parameters: ControlPar) -> tuple[int, int]:
+    if hasattr(parameters, "get_image_size"):
+        return parameters.get_image_size()
+    return parameters.imx, parameters.imy
+
+
+def _control_pixel_size(parameters: ControlPar) -> tuple[float, float]:
+    if hasattr(parameters, "get_pixel_size"):
+        return parameters.get_pixel_size()
+    return parameters.pix_x, parameters.pix_y
+
+
+def _calibration_primary_point(cal: Calibration) -> tuple[float, float]:
+    if hasattr(cal, "get_primary_point"):
+        primary_point = cal.get_primary_point()
+        return float(primary_point[0]), float(primary_point[1])
+    return float(cal.int_par.xh), float(cal.int_par.yh)
+
+
+def _calibration_added_par(cal: Calibration) -> np.ndarray:
+    if hasattr(cal, "added_par"):
+        return np.asarray(cal.added_par, dtype=np.float64)
+
+    radial = np.asarray(cal.get_radial_distortion(), dtype=np.float64)
+    decentering = np.asarray(cal.get_decentering(), dtype=np.float64)
+    affine = np.asarray(cal.get_affine(), dtype=np.float64)
+    return np.r_[radial, decentering, affine]
+
+
 def pixel_to_metric(
     x_pixel: float, y_pixel: float, parameters: ControlPar
 ) -> Tuple[float, float]:
@@ -20,13 +49,15 @@ def pixel_to_metric(
     x_pixel, y_pixel (float): input pixel coordinates.
     parameters (ControlPar): control structure holding image and pixel sizes.
     """
+    imx, imy = _control_image_size(parameters)
+    pix_x, pix_y = _control_pixel_size(parameters)
     return fast_pixel_to_metric(
         x_pixel,
         y_pixel,
-        parameters.imx,
-        parameters.imy,
-        parameters.pix_x,
-        parameters.pix_y,
+        imx,
+        imy,
+        pix_x,
+        pix_y,
     )
 
 
@@ -80,13 +111,15 @@ def metric_to_pixel(
     -------
     x_pixel, y_pixel (float): output pixel coordinates.
     """
+    imx, imy = _control_image_size(parameters)
+    pix_x, pix_y = _control_pixel_size(parameters)
     return fast_metric_to_pixel(
         x_metric,
         y_metric,
-        parameters.imx,
-        parameters.imy,
-        parameters.pix_x,
-        parameters.pix_y,
+        imx,
+        imy,
+        pix_x,
+        pix_y,
     )
 
 
@@ -115,8 +148,11 @@ def arr_metric_to_pixel(metric: np.ndarray, parameters: ControlPar) -> np.ndarra
     """
     metric = np.atleast_2d(metric)
 
+    imx, imy = _control_image_size(parameters)
+    pix_x, pix_y = _control_pixel_size(parameters)
+
     return fast_arr_metric_to_pixel(
-        metric, parameters.imx, parameters.imy, parameters.pix_x, parameters.pix_y
+        metric, imx, imy, pix_x, pix_y
     )
 
 
@@ -228,21 +264,22 @@ def flat_to_dist(flat_x: float, flat_y: float, cal: Calibration) -> Tuple[float,
     image coordinates, because distortion formula assumes it, [1] p.180.
     """
     # print(f"flat_x {flat_x}, flat_y {flat_y}")
-    # print(f"cal.int {cal.int_par.xh}, {cal.int_par.yh}")
-    flat_x += cal.int_par.xh
-    flat_y += cal.int_par.yh
+    xh, yh = _calibration_primary_point(cal)
+    flat_x += xh
+    flat_y += yh
 
     # print(f"flat_x {flat_x}, flat_y {flat_y}")
 
-    dist_x, dist_y = distort_brown_affine(flat_x, flat_y, cal.added_par)
+    dist_x, dist_y = distort_brown_affine(flat_x, flat_y, _calibration_added_par(cal))
     # print(f"dist_x {dist_x}, dist_y {dist_y}")
 
     return dist_x, dist_y
 
 
 def dist_to_flat(dist_x: float, dist_y: float, cal: Calibration, tol: float = 1e-5):
     """Convert real-image coordinates to flat-image coordinates."""
-    flat_x, flat_y = correct_brown_affine(dist_x, dist_y, cal.added_par, tol)
-    flat_x -= cal.int_par.xh
-    flat_y -= cal.int_par.yh
+    xh, yh = _calibration_primary_point(cal)
+    flat_x, flat_y = correct_brown_affine(dist_x, dist_y, _calibration_added_par(cal), tol)
+    flat_x -= xh
+    flat_y -= yh
     return flat_x, flat_y