improving compatibility

Author: alexlib

src/openptv_python/_native_compat.py

@@ -191,6 +191,56 @@ def should_use_native(feature_name: str | None = None) -> bool:
     return HAS_OPTV
 
 
+def get_num_cams(control_params: Any) -> int:
+    """Return the camera count from either backend's control parameter object."""
+
+    num_cams = getattr(control_params, "num_cams", None)
+    if num_cams is not None:
+        return int(num_cams)
+
+    getter = getattr(control_params, "get_num_cams", None)
+    if callable(getter):
+        return int(getter())
+
+    raise AttributeError("ControlParams object does not expose a camera count")
+    
+def get_multimedia_par(control_params: Any) -> Any:
+    """Return the multimedia-parameter object from either backend."""
+
+    multimedia = getattr(control_params, "mm", None)
+    if multimedia is not None:
+        return multimedia
+
+    getter = getattr(control_params, "get_multimedia_par", None)
+    if callable(getter):
+        multimedia = getter()
+    else:
+        getter = getattr(control_params, "get_multimedia_params", None)
+        if callable(getter):
+            multimedia = getter()
+        else:
+            raise AttributeError(
+                "ControlParams object does not expose multimedia parameters"
+            )
+
+    try:
+        from openptv_python.parameters import MultimediaPar
+    except Exception:
+        return multimedia
+
+    if isinstance(multimedia, MultimediaPar):
+        return multimedia
+
+    converted = MultimediaPar(
+        nlay=int(multimedia.get_nlay()) if hasattr(multimedia, "get_nlay") else 1,
+        n1=float(multimedia.get_n1()) if hasattr(multimedia, "get_n1") else float(getattr(multimedia, "n1", 1.0)),
+        n2=list(multimedia.get_n2()) if hasattr(multimedia, "get_n2") else list(getattr(multimedia, "n2", [1.0])),
+        d=list(multimedia.get_d()) if hasattr(multimedia, "get_d") else list(getattr(multimedia, "d", [0.0])),
+        n3=float(multimedia.get_n3()) if hasattr(multimedia, "get_n3") else float(getattr(multimedia, "n3", 1.0)),
+    )
+    return converted
+
+
 # Initialize once so the default preference is explicit and optv availability
 # is reported immediately in sessions where it is missing.
 set_engine(DEFAULT_ENGINE, warn_once=True)

src/openptv_python/_native_convert.py

@@ -51,6 +51,29 @@ def to_native_calibration(cal: Calibration):
     return native
 
 
+def from_native_calibration(calibration_obj):
+    if isinstance(calibration_obj, Calibration):
+        return calibration_obj
+
+    converted = Calibration()
+    converted.set_pos(np.array(calibration_obj.get_pos()))
+    converted.set_angles(np.array(calibration_obj.get_angles()))
+    converted.set_primary_point(np.array(calibration_obj.get_primary_point()))
+    converted.set_radial_distortion(np.array(calibration_obj.get_radial_distortion()))
+    converted.set_decentering(np.array(calibration_obj.get_decentering()))
+
+    affine = np.array(calibration_obj.get_affine())
+    if hasattr(converted, "set_affine_trans"):
+        converted.set_affine_trans(affine)
+    elif hasattr(converted, "set_affine_distortion"):
+        converted.set_affine_distortion(affine)
+    else:
+        raise AttributeError("Calibration object does not support affine setters")
+
+    converted.set_glass_vec(np.array(calibration_obj.get_glass_vec()))
+    return converted
+
+
 def to_native_control_par(cpar: ControlPar):
     if not isinstance(cpar, ControlPar):
         return cpar

src/openptv_python/correspondences.py

@@ -12,6 +12,7 @@
     NMAX,
     PT_UNUSED,
 )
+from ._native_compat import get_multimedia_par, get_num_cams
 from .epi import epi_mm
 from .find_candidate import find_candidate
 from .parameters import ControlPar, VolumePar
@@ -388,8 +389,9 @@ def match_pairs(
     """
     count = 0
 
-    for i1 in range(cpar.num_cams - 1):
-        for i2 in range(i1 + 1, cpar.num_cams):
+    num_cams = get_num_cams(cpar)
+    for i1 in range(num_cams - 1):
+        for i2 in range(i1 + 1, num_cams):
             for i in range(frm.num_targets[i1]):
                 # if corrected[i1][i].x == PT_UNUSED: # no idea why it's here
                 #     continue
@@ -399,7 +401,7 @@ def match_pairs(
                     corrected[i1][i].y,
                     calib[i1],
                     calib[i2],
-                    cpar.mm,
+                    get_multimedia_par(cpar),
                     vpar,
                 )
 
@@ -554,7 +556,7 @@ def py_correspondences(
     num_targs - total number of targets (must be greater than the sum of
         previous 3).
     """
-    num_cams = cparam.num_cams
+    num_cams = get_num_cams(cparam)
     frm = Frame(num_cams, MAX_TARGETS)
 
     # Special case of a single camera, follow the single_cam_correspondence docstring
@@ -679,20 +681,21 @@ def correspondences(
 
     """
     nmax = NMAX
+    num_cams = get_num_cams(cpar)
 
     # Allocation of scratch buffers for internal tasks and return-value space
-    con0 = np.recarray((nmax * cpar.num_cams,), dtype=n_tupel_dtype)
+    con0 = np.recarray((nmax * num_cams,), dtype=n_tupel_dtype)
     con0.p = 0
     con0.corr = 0.0
 
-    con = np.recarray((nmax * cpar.num_cams,), dtype=n_tupel_dtype)
+    con = np.recarray((nmax * num_cams,), dtype=n_tupel_dtype)
     con.p = 0
     con.corr = 0.0
 
-    tim = safely_allocate_target_usage_marks(cpar.num_cams, nmax)
+    tim = safely_allocate_target_usage_marks(num_cams, nmax)
 
     # allocate memory for lists of correspondences
-    corr_list = safely_allocate_adjacency_lists(cpar.num_cams, frm.num_targets)
+    corr_list = safely_allocate_adjacency_lists(num_cams, frm.num_targets)
 
     # if I understand correctly, the number of matches cannot be more than the number of
     # targets (dots) in the first image. In the future we'll replace it by the maximum
@@ -704,38 +707,38 @@ def correspondences(
     match_pairs(corr_list, corrected, frm, vpar, cpar, calib)
 
     # search consistent quadruplets in the corr_list
-    if cpar.num_cams == 4:
+    if num_cams == 4:
         four_camera_matching(
             corr_list, frm.num_targets[0], vpar.corrmin, con0, 4 * nmax
         )
 
-        match_counts[0] = take_best_candidates(con0, con, cpar.num_cams, tim)
+        match_counts[0] = take_best_candidates(con0, con, num_cams, tim)
         match_counts[3] += match_counts[0]
 
     # search consistent triplets: 123, 124, 134, 234
-    if (cpar.num_cams == 4 and cpar.all_cam_flag == 0) or cpar.num_cams == 3:
+    if (num_cams == 4 and cpar.all_cam_flag == 0) or num_cams == 3:
         three_camera_matching(
-            corr_list, cpar.num_cams, frm.num_targets, vpar.corrmin, con0, 4 * nmax, tim
+            corr_list, num_cams, frm.num_targets, vpar.corrmin, con0, 4 * nmax, tim
         )
 
         match_counts[1] = take_best_candidates(
-            con0, con[match_counts[3] :].view(np.recarray), cpar.num_cams, tim
+            con0, con[match_counts[3] :].view(np.recarray), num_cams, tim
         )
         match_counts[3] += match_counts[1]
 
     # Search consistent pairs: 12, 13, 14, 23, 24, 34
-    if cpar.num_cams > 1 and cpar.all_cam_flag == 0:
+    if num_cams > 1 and cpar.all_cam_flag == 0:
         consistent_pair_matching(
-            corr_list, cpar.num_cams, frm.num_targets, vpar.corrmin, con0, 4 * nmax, tim
+            corr_list, num_cams, frm.num_targets, vpar.corrmin, con0, 4 * nmax, tim
         )
         match_counts[2] = take_best_candidates(
-            con0, con[match_counts[3] :].view(np.recarray), cpar.num_cams, tim
+            con0, con[match_counts[3] :].view(np.recarray), num_cams, tim
         )
         match_counts[3] += match_counts[2]
 
     # Give each used pix the correspondence number
     for i in range(match_counts[3]):
-        for j in range(cpar.num_cams):
+        for j in range(num_cams):
             # Skip cameras without a correspondence obviously.
             if con[i].p[j] < 0:
                 continue

src/openptv_python/multimed.py

@@ -4,6 +4,7 @@
 from numba import njit
 
 from .calibration import Calibration
+from ._native_compat import get_multimedia_par, get_num_cams
 from .parameters import (
     ControlPar,
     MultimediaPar,
@@ -263,17 +264,18 @@ def init_mmlut(vpar: VolumePar, cpar: ControlPar, cal: Calibration) -> Calibrati
 
     # intersect with image vertices rays
     cal_t = Calibration(mmlut=cal.mmlut.copy())
+    mm = get_multimedia_par(cpar)
 
     for i in range(2):
         for j in range(2):
             x, y = pixel_to_metric(xc[i], yc[j], cpar)
             x -= cal.int_par.xh
             y -= cal.int_par.yh
             x, y = correct_brown_affine(x, y, cal.added_par)
-            pos, a = ray_tracing(x, y, cal, cpar.mm)
+            pos, a = ray_tracing(x, y, cal, mm)
             xyz = move_along_ray(z_min, pos, a)
             xyz_t, _, _, cal_t.ext_par.z0 = trans_cam_point(
-                cal.ext_par, cpar.mm, cal.glass_par, xyz
+                cal.ext_par, mm, cal.glass_par, xyz
             )
 
             if xyz_t[2] < z_min_t:
@@ -290,7 +292,7 @@ def init_mmlut(vpar: VolumePar, cpar: ControlPar, cal: Calibration) -> Calibrati
 
             xyz = move_along_ray(z_max, pos, a)
             xyz_t, _, _, cal_t.ext_par.z0 = trans_cam_point(
-                cal.ext_par, cpar.mm, cal.glass_par, xyz
+                cal.ext_par, mm, cal.glass_par, xyz
             )
 
             if xyz_t[2] < z_min_t:
@@ -326,7 +328,7 @@ def init_mmlut(vpar: VolumePar, cpar: ControlPar, cal: Calibration) -> Calibrati
         for i in range(nr):
             for j in range(nz):
                 xyz = np.r_[Ri[i] + cal_t.ext_par.x0, cal_t.ext_par.y0, Zi[j]]
-                cal.mmlut_data.flat[i * nz + j] = multimed_r_nlay(cal_t, cpar.mm, xyz)
+                cal.mmlut_data.flat[i * nz + j] = multimed_r_nlay(cal_t, mm, xyz)
 
         # print(f"filled mmlut data with {data}")
         # cal.mmlut_data = data
@@ -405,6 +407,7 @@ def volumedimension(
     cal: List[Calibration],
 ) -> Tuple[float, float, float, float, float, float]:
     """Calculate the volume dimensions."""
+    mm = get_multimedia_par(cpar)
     xc = [0.0, cpar.imx]
     yc = [0.0, cpar.imy]
 
@@ -416,7 +419,7 @@ def volumedimension(
     if vpar.z_max_lay[1] > z_max:
         z_max = vpar.z_max_lay[1]
 
-    for i_cam in range(cpar.num_cams):
+    for i_cam in range(get_num_cams(cpar)):
         for i in range(2):
             for j in range(2):
                 x, y = pixel_to_metric(xc[i], yc[j], cpar)
@@ -426,7 +429,7 @@ def volumedimension(
 
                 x, y = correct_brown_affine(x, y, cal[i_cam].added_par)
 
-                pos, a = ray_tracing(x, y, cal[i_cam], cpar.mm)
+                pos, a = ray_tracing(x, y, cal[i_cam], mm)
 
                 # TODO: seems that it should be + pos[2] instead of - pos[2]
                 X = pos[0] + (z_min + pos[2]) * a[0] / a[2]

src/openptv_python/track.py

@@ -21,6 +21,7 @@
     TR_MAX_CAMS,
     TR_UNUSED,
 )
+from ._native_compat import get_multimedia_par, get_num_cams
 from .imgcoord import img_coord
 from .orientation import point_position
 from .parameters import ControlPar, SequencePar, TrackPar, TrackParTuple, VolumePar, convert_track_par_to_tuple
@@ -427,11 +428,12 @@ def searchquader(
     mins = np.array([tpar.dvxmin, tpar.dvymin, tpar.dvzmin])
     maxes = np.array([tpar.dvxmax, tpar.dvymax, tpar.dvzmax])
 
+    num_cams = get_num_cams(cpar)
     quader = np.zeros((8, 3))
-    xr = np.zeros(cpar.num_cams)
-    xl = np.zeros(cpar.num_cams)
-    yd = np.zeros(cpar.num_cams)
-    yu = np.zeros(cpar.num_cams)
+    xr = np.zeros(num_cams)
+    xl = np.zeros(num_cams)
+    yd = np.zeros(num_cams)
+    yu = np.zeros(num_cams)
 
     for pt in range(8):
         quader[pt] = point.copy()
@@ -444,7 +446,7 @@ def searchquader(
         # print(f" pt {pt} {quader[pt]}")
 
     # calculation of search area in each camera
-    for i in range(cpar.num_cams):
+    for i in range(num_cams):
         # initially large or small values
         xr[i] = 0
         xl[i] = cpar.imx
@@ -574,7 +576,7 @@ def point_to_pixel(point: np.ndarray, cal: Calibration, cpar: ControlPar) -> np.
     # print(f"cal {cal}")
     # print(f"cpar.mm {cpar.mm}")
 
-    x, y = img_coord(point, cal, cpar.mm)
+    x, y = img_coord(point, cal, get_multimedia_par(cpar))
     # print("img coord x, y", x, y)
     x, y = metric_to_pixel(x, y, cpar)
     # print("metric to pixel x, y", x, y)
@@ -648,18 +650,17 @@ def assess_new_position(
 
     """
     # Output variables
-    targ_pos = np.array(
-        [[COORD_UNUSED, COORD_UNUSED] for _ in range(run.cpar.num_cams)]
-    )
-    cand_inds = np.array([[-1] * MAX_CANDS for _ in range(run.cpar.num_cams)])
+    num_cams = get_num_cams(run.cpar)
+    targ_pos = np.array([[COORD_UNUSED, COORD_UNUSED] for _ in range(num_cams)])
+    cand_inds = np.array([[-1] * MAX_CANDS for _ in range(num_cams)])
 
     # Search rectangle limits
     left, right, up, down = ADD_PART, ADD_PART, ADD_PART, ADD_PART
 
-    # for cam in range(run.cpar.num_cams):
+    # for cam in range(num_cams):
     #     targ_pos[cam] = [COORD_UNUSED, COORD_UNUSED]
 
-    for cam in range(run.cpar.num_cams):
+    for cam in range(num_cams):
         # Convert 3D search position to 2D pixel coordinates
         pixel = point_to_pixel(pos, run.cal[cam], run.cpar)
         # print(f"pos {pos}")
@@ -686,7 +687,7 @@ def assess_new_position(
 
     valid_cams = 0
 
-    for cam in range(run.cpar.num_cams):
+    for cam in range(num_cams):
         if (targ_pos[cam][0] != COORD_UNUSED) and (targ_pos[cam][1] != COORD_UNUSED):
             # Convert pixel coordinates to metric coordinates
             x, y = pixel_to_metric(targ_pos[cam][0], targ_pos[cam][1], run.cpar)
@@ -808,8 +809,9 @@ def trackcorr_c_loop(run_info, step):
     cpar = run_info.cpar
     curr_targets = fb.buf[1].targets
 
-    v1 = np.zeros((cpar.num_cams, 2))  # volume center projection on cameras
-    v2 = np.zeros((cpar.num_cams, 2))  # volume center projection on cameras
+    num_cams = get_num_cams(cpar)
+    v1 = np.zeros((num_cams, 2))  # volume center projection on cameras
+    v2 = np.zeros((num_cams, 2))  # volume center projection on cameras
 
     # try to track correspondences from previous 0 - corp, variable h
     orig_parts = fb.buf[1].num_parts
@@ -936,7 +938,7 @@ def trackcorr_c_loop(run_info, step):
             if quali >= 2:
                 in_volume = 0  # inside volume
 
-                dl, X[4] = point_position(v2, cpar.num_cams, cpar.mm, cal)
+                dl, X[4] = point_position(v2, num_cams, get_multimedia_par(cpar), cal)
 
                 # volume check
                 if (
@@ -1006,7 +1008,7 @@ def trackcorr_c_loop(run_info, step):
                 if quali >= 2:
                     X[3] = vec_copy(X[2])
                     in_volume = 0
-                    dl, X[3] = point_position(v2, fb.num_cams, cpar.mm, cal)
+                    dl, X[3] = point_position(v2, fb.num_cams, get_multimedia_par(cpar), cal)
 
                     # in volume check
                     if (
@@ -1210,7 +1212,7 @@ def trackback_c(run_info: TrackingRun):
                         # vec_copy(X[3], X[2])
                         in_volume = 0
 
-                        _, X[3] = point_position(v2, fb.num_cams, cpar.mm, cal)
+                        _, X[3] = point_position(v2, fb.num_cams, get_multimedia_par(cpar), cal)
 
                         # volume check
                         if (