improving compatibility

Author: alexlib

src/openptv_python/_native_compat.py

@@ -68,6 +68,40 @@ def _optional_import(module_name: str) -> ModuleType | None:
 )
 
 
+def _install_property_alias(cls: Any, attr_name: str, getter_name: str, setter_name: str | None = None) -> None:
+    if hasattr(cls, attr_name):
+        return
+
+    def getter(self):
+        getter = getattr(self, getter_name)
+        return getter()
+
+    def setter(self, value):
+        if setter_name is None:
+            raise AttributeError(f"{attr_name} is read-only")
+        setter = getattr(self, setter_name)
+        return setter(value)
+
+    try:
+        setattr(cls, attr_name, property(getter, None if setter_name is None else setter))
+    except (TypeError, AttributeError):
+        return
+
+
+if optv_parameters is not None:
+    volume_params_cls = getattr(optv_parameters, "VolumeParams", None)
+    if volume_params_cls is not None:
+        _install_property_alias(volume_params_cls, "x_lay", "get_X_lay", "set_X_lay")
+        _install_property_alias(volume_params_cls, "z_min_lay", "get_Zmin_lay", "set_Zmin_lay")
+        _install_property_alias(volume_params_cls, "z_max_lay", "get_Zmax_lay", "set_Zmax_lay")
+        _install_property_alias(volume_params_cls, "cn", "get_cn", "set_cn")
+        _install_property_alias(volume_params_cls, "cnx", "get_cnx", "set_cnx")
+        _install_property_alias(volume_params_cls, "cny", "get_cny", "set_cny")
+        _install_property_alias(volume_params_cls, "csumg", "get_csumg", "set_csumg")
+        _install_property_alias(volume_params_cls, "corrmin", "get_corrmin", "set_corrmin")
+        _install_property_alias(volume_params_cls, "eps0", "get_eps0", "set_eps0")
+
+
 def _emit_engine_warning(reason: str) -> None:
     global _ENGINE_WARNING_EMITTED
     if _ENGINE_WARNING_EMITTED:

src/openptv_python/_native_convert.py

@@ -55,23 +55,26 @@ 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
+    try:
+        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
+    except (TypeError, ValueError, AttributeError):
+        return calibration_obj
 
 
 def to_native_control_par(cpar: ControlPar):

src/openptv_python/epi.py

@@ -48,6 +48,24 @@ def sort_coord2d_y(crd: np.ndarray) -> np.ndarray:
     return np.sort(crd, order="y")
 
 
+def _volume_x_lay(vpar: VolumePar) -> list[float]:
+    if hasattr(vpar, "get_X_lay"):
+        return list(vpar.get_X_lay())
+    return list(vpar.x_lay)
+
+
+def _volume_z_min_lay(vpar: VolumePar) -> list[float]:
+    if hasattr(vpar, "get_Zmin_lay"):
+        return list(vpar.get_Zmin_lay())
+    return list(vpar.z_min_lay)
+
+
+def _volume_z_max_lay(vpar: VolumePar) -> list[float]:
+    if hasattr(vpar, "get_Zmax_lay"):
+        return list(vpar.get_Zmax_lay())
+    return list(vpar.z_max_lay)
+
+
 def epi_mm(xl, yl, cal1, cal2, mmp, vpar) -> Tuple[float, float, float, float]:
     """Return the end points of the epipolar line in the "second" camera.
 
@@ -85,15 +103,19 @@ def epi_mm(xl, yl, cal1, cal2, mmp, vpar) -> Tuple[float, float, float, float]:
     pos, v = ray_tracing(xl, yl, cal1, mmp)
 
     # calculate min and max depth for position (valid only for one setup)
-    z_min = vpar.z_min_lay[0] + (pos[0] - vpar.x_lay[0]) * (
-        vpar.z_min_lay[1] - vpar.z_min_lay[0]
-    ) / (vpar.x_lay[1] - vpar.x_lay[0])
+    x_lay = _volume_x_lay(vpar)
+    z_min_lay = _volume_z_min_lay(vpar)
+    z_max_lay = _volume_z_max_lay(vpar)
+
+    z_min = z_min_lay[0] + (pos[0] - x_lay[0]) * (
+        z_min_lay[1] - z_min_lay[0]
+    ) / (x_lay[1] - x_lay[0])
 
     z_max = float(
-        vpar.z_max_lay[0]
-        + (pos[0] - vpar.x_lay[0])
-        * (vpar.z_max_lay[1] - vpar.z_max_lay[0])
-        / (vpar.x_lay[1] - vpar.x_lay[0])
+        z_max_lay[0]
+        + (pos[0] - x_lay[0])
+        * (z_max_lay[1] - z_max_lay[0])
+        / (x_lay[1] - x_lay[0])
     )
 
     X = move_along_ray(z_min, pos, v)
@@ -142,12 +164,16 @@ def epi_mm_2D(
     """
     pos, v = ray_tracing(xl, yl, cal1, mmp)
 
-    z_min = vpar.z_min_lay[0] + (pos[0] - vpar.x_lay[0]) * (
-        vpar.z_min_lay[1] - vpar.z_min_lay[0]
-    ) / (vpar.x_lay[1] - vpar.x_lay[0])
-    z_max = vpar.z_max_lay[0] + (pos[0] - vpar.x_lay[0]) * (
-        vpar.z_max_lay[1] - vpar.z_max_lay[0]
-    ) / (vpar.x_lay[1] - vpar.x_lay[0])
+    x_lay = _volume_x_lay(vpar)
+    z_min_lay = _volume_z_min_lay(vpar)
+    z_max_lay = _volume_z_max_lay(vpar)
+
+    z_min = z_min_lay[0] + (pos[0] - x_lay[0]) * (
+        z_min_lay[1] - z_min_lay[0]
+    ) / (x_lay[1] - x_lay[0])
+    z_max = z_max_lay[0] + (pos[0] - x_lay[0]) * (z_max_lay[1] - z_max_lay[0]) / (
+        x_lay[1] - x_lay[0]
+    )
 
     out = move_along_ray(0.5 * (z_min + z_max), pos, v)
     return out

src/openptv_python/ray_tracing.py

@@ -44,12 +44,26 @@ def ray_tracing(
     -------
             _type_: _description_
     """
-    primary_point = np.r_[cal.ext_par.x0, cal.ext_par.y0, cal.ext_par.z0]
-    glass = np.ascontiguousarray(cal.glass_par)
-    camera = np.array([x, y, -cal.int_par.cc], dtype=np.float64, order="C")
+    if hasattr(cal, "get_primary_point"):
+        primary_point = np.asarray(cal.get_primary_point(), dtype=np.float64)
+    else:
+        primary_point = np.r_[cal.ext_par.x0, cal.ext_par.y0, cal.ext_par.z0]
+
+    if hasattr(cal, "get_rotation_matrix"):
+        distortion_matrix = np.asarray(cal.get_rotation_matrix(), dtype=np.float64)
+    else:
+        distortion_matrix = np.asarray(cal.ext_par.dm, dtype=np.float64)
+
+    if hasattr(cal, "get_glass_vec"):
+        glass = np.ascontiguousarray(cal.get_glass_vec())
+    else:
+        glass = np.ascontiguousarray(cal.glass_par)
+
+    camera_cc = float(primary_point[2]) if primary_point.shape[0] >= 3 else float(cal.int_par.cc)
+    camera = np.array([x, y, -camera_cc], dtype=np.float64, order="C")
     return fast_ray_tracing(
         camera,
-        cal.ext_par.dm,
+        distortion_matrix,
         primary_point,
         glass,
         mm.d[0],

src/openptv_python/segmentation.py

@@ -5,7 +5,7 @@
 from numba import njit
 from scipy.ndimage import center_of_mass, gaussian_filter, label, maximum_filter
 
-from ._native_compat import native_target_recognition, should_use_native
+from ._native_compat import HAS_NATIVE_SEGMENTATION, native_target_recognition, should_use_native
 from ._native_convert import (
     from_native_target_array,
     to_native_control_par,

src/pyptv/legacy_parameters.py

@@ -765,7 +765,7 @@ def write(self):
             f.write("%g\n" % self.dvzmin)
             f.write("%g\n" % self.dvzmax)
             f.write("%g\n" % self.angle)
-            f.write("%g\n" % self.dacc)
+            f.write(f"{self.dacc}\n")
             f.write("%d\n" % self.flagNewParticles)
             f.close()
             return True