fixed compatibility

Author: alexlib

src/openptv_python/_native_compat.py

@@ -101,6 +101,17 @@ def setter(self, value):
         _install_property_alias(volume_params_cls, "corrmin", "get_corrmin", "set_corrmin")
         _install_property_alias(volume_params_cls, "eps0", "get_eps0", "set_eps0")
 
+    tracking_params_cls = getattr(optv_parameters, "TrackingParams", None)
+    if tracking_params_cls is not None:
+        _install_property_alias(tracking_params_cls, "dvxmin", "get_dvxmin", "set_dvxmin")
+        _install_property_alias(tracking_params_cls, "dvxmax", "get_dvxmax", "set_dvxmax")
+        _install_property_alias(tracking_params_cls, "dvymin", "get_dvymin", "set_dvymin")
+        _install_property_alias(tracking_params_cls, "dvymax", "get_dvymax", "set_dvymax")
+        _install_property_alias(tracking_params_cls, "dvzmin", "get_dvzmin", "set_dvzmin")
+        _install_property_alias(tracking_params_cls, "dvzmax", "get_dvzmax", "set_dvzmax")
+        _install_property_alias(tracking_params_cls, "dangle", "get_dangle", "set_dangle")
+        _install_property_alias(tracking_params_cls, "add", "get_add", "set_add")
+
 
 def _emit_engine_warning(reason: str) -> None:
     global _ENGINE_WARNING_EMITTED

src/openptv_python/multimed.py

@@ -12,6 +12,7 @@
 )
 from .ray_tracing import ray_tracing
 from .trafo import correct_brown_affine, pixel_to_metric
+from .trafo import _calibration_added_par
 from .vec_utils import vec_norm
 
 
@@ -408,26 +409,45 @@ def volumedimension(
 ) -> 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]
-
-    z_min = vpar.z_min_lay[0]
-    z_max = vpar.z_max_lay[0]
-
-    if vpar.z_min_lay[1] < z_min:
-        z_min = vpar.z_min_lay[1]
-    if vpar.z_max_lay[1] > z_max:
-        z_max = vpar.z_max_lay[1]
+    if hasattr(cpar, "imx") and hasattr(cpar, "imy"):
+        imx = cpar.imx
+        imy = cpar.imy
+    else:
+        imx, imy = cpar.get_image_size()
+
+    xc = [0.0, imx]
+    yc = [0.0, imy]
+
+    if hasattr(vpar, "z_min_lay") and hasattr(vpar, "z_max_lay"):
+        z_min_lay = vpar.z_min_lay
+        z_max_lay = vpar.z_max_lay
+    else:
+        z_min_lay = vpar.get_Zmin_lay()
+        z_max_lay = vpar.get_Zmax_lay()
+
+    z_min = z_min_lay[0]
+    z_max = z_max_lay[0]
+
+    if z_min_lay[1] < z_min:
+        z_min = z_min_lay[1]
+    if z_max_lay[1] > z_max:
+        z_max = z_max_lay[1]
 
     for i_cam in range(get_num_cams(cpar)):
+        if hasattr(cal[i_cam], "int_par"):
+            xh = cal[i_cam].int_par.xh
+            yh = cal[i_cam].int_par.yh
+        else:
+            xh, yh, _ = cal[i_cam].get_primary_point()
+
         for i in range(2):
             for j in range(2):
                 x, y = pixel_to_metric(xc[i], yc[j], cpar)
 
-                x -= cal[i_cam].int_par.xh
-                y -= cal[i_cam].int_par.yh
+                x -= xh
+                y -= yh
 
-                x, y = correct_brown_affine(x, y, cal[i_cam].added_par)
+                x, y = correct_brown_affine(x, y, _calibration_added_par(cal[i_cam]))
 
                 pos, a = ray_tracing(x, y, cal[i_cam], mm)
 

src/openptv_python/track.py

@@ -1345,6 +1345,30 @@ def trackback_c(run_info: TrackingRun):
 }
 
 
+def _sequence_first(seq_par: SequencePar) -> int:
+    value = getattr(seq_par, "first", None)
+    if value is not None:
+        return int(value)
+
+    getter = getattr(seq_par, "get_first", None)
+    if callable(getter):
+        return int(getter())
+
+    raise AttributeError("SequenceParams object does not expose first")
+
+
+def _sequence_last(seq_par: SequencePar) -> int:
+    value = getattr(seq_par, "last", None)
+    if value is not None:
+        return int(value)
+
+    getter = getattr(seq_par, "get_last", None)
+    if callable(getter):
+        return int(getter())
+
+    raise AttributeError("SequenceParams object does not expose last")
+
+
 class Tracker:
     """Compatibility wrapper for the legacy Tracker workflow."""
 
@@ -1374,16 +1398,16 @@ def __init__(
             cals,
             flatten_tol,
         )
-        self.step = self.run_info.seq_par.first
+        self.step = _sequence_first(self.run_info.seq_par)
 
     def restart(self):
         """Prepare a tracking run."""
-        self.step = self.run_info.seq_par.first
+        self.step = _sequence_first(self.run_info.seq_par)
         track_forward_start(self.run_info)
 
     def step_forward(self):
         """Perform one tracking step for the current frame."""
-        if self.step >= self.run_info.seq_par.last:
+        if self.step >= _sequence_last(self.run_info.seq_par):
             return False
 
         trackcorr_c_loop(self.run_info, self.step)

src/openptv_python/tracking_run.py

@@ -23,6 +23,52 @@
 )
 
 
+def _tracking_param_value(tpar, name: str):
+    """Read a tracking parameter from either attribute or getter access."""
+    value = getattr(tpar, name, None)
+    if value is not None:
+        return value
+
+    getter = getattr(tpar, f"get_{name}", None)
+    if callable(getter):
+        return getter()
+
+    raise AttributeError(f"TrackingParams object does not expose {name}")
+
+
+def _volume_param_value(vpar, name: str):
+    """Read a volume parameter from either attribute or legacy getter access."""
+    value = getattr(vpar, name, None)
+    if value is not None:
+        return value
+
+    getter_name = {
+        "x_lay": "get_X_lay",
+        "z_min_lay": "get_Zmin_lay",
+        "z_max_lay": "get_Zmax_lay",
+    }.get(name, f"get_{name}")
+    getter = getattr(vpar, getter_name, None)
+    if callable(getter):
+        return getter()
+
+    raise AttributeError(f"VolumeParams object does not expose {name}")
+
+
+def _set_volume_param_value(vpar, name: str, value) -> None:
+    """Write a volume parameter through either a setter or direct attribute."""
+    setter_name = {
+        "x_lay": "set_X_lay",
+        "z_min_lay": "set_Zmin_lay",
+        "z_max_lay": "set_Zmax_lay",
+    }.get(name, f"set_{name}")
+    setter = getattr(vpar, setter_name, None)
+    if callable(setter):
+        setter(value)
+        return
+
+    setattr(vpar, name, value)
+
+
 @dataclass
 class TrackingRun:
     """A tracking run."""
@@ -61,41 +107,57 @@ def __init__(
         self.cal = cal
         self.flatten_tol = flatten_tol
 
+        if hasattr(seq_par, "img_base_name"):
+            img_base_names = seq_par.img_base_name
+        else:
+            img_base_names = [
+                seq_par.get_img_base_name(cam_index)
+                for cam_index in range(get_num_cams(cpar))
+            ]
+
         self.fb = FrameBuf(
             buf_len,
             get_num_cams(cpar),
             max_targets,
             corres_file_base,
             linkage_file_base,
             prio_file_base,
-            seq_par.img_base_name,
+            img_base_names,
         )
 
         self.lmax = math.sqrt(
-            (tpar.dvxmin - tpar.dvxmax) ** 2
-            + (tpar.dvymin - tpar.dvymax) ** 2
-            + (tpar.dvzmin - tpar.dvzmax) ** 2
+            (_tracking_param_value(tpar, "dvxmin") - _tracking_param_value(tpar, "dvxmax")) ** 2
+            + (_tracking_param_value(tpar, "dvymin") - _tracking_param_value(tpar, "dvymax")) ** 2
+            + (_tracking_param_value(tpar, "dvzmin") - _tracking_param_value(tpar, "dvzmax")) ** 2
         )
 
+        x_lay = list(_volume_param_value(vpar, "x_lay"))
+        z_min_lay = list(_volume_param_value(vpar, "z_min_lay"))
+        z_max_lay = list(_volume_param_value(vpar, "z_max_lay"))
+
         (
-            vpar.x_lay[1],
-            vpar.x_lay[0],
+            x_lay[1],
+            x_lay[0],
             self.ymax,
             self.ymin,
-            vpar.z_max_lay[1],
-            vpar.z_min_lay[0],
+            z_max_lay[1],
+            z_min_lay[0],
         ) = volumedimension(
-            vpar.x_lay[1],
-            vpar.x_lay[0],
+            x_lay[1],
+            x_lay[0],
             self.ymax,
             self.ymin,
-            vpar.z_max_lay[1],
-            vpar.z_min_lay[0],
+            z_max_lay[1],
+            z_min_lay[0],
             vpar,
             cpar,
             cal,
         )
 
+        _set_volume_param_value(vpar, "x_lay", x_lay)
+        _set_volume_param_value(vpar, "z_min_lay", z_min_lay)
+        _set_volume_param_value(vpar, "z_max_lay", z_max_lay)
+
         self.npart = 0
         self.nlinks = 0
 

tests/pyptv/test_ext_sequence_splitter.py

@@ -2,14 +2,20 @@
 
 import sys
 import subprocess
+import shutil
 from pathlib import Path
 
 
-def test_ext_sequence_splitter():
+def _copy_splitter_case(tmp_path):
+    source = Path(__file__).parent.parent / "testing_folder" / "test_splitter"
+    destination = tmp_path / "test_splitter"
+    shutil.copytree(source, destination, dirs_exist_ok=True)
+    return destination
+
+
+def test_ext_sequence_splitter(tmp_path):
     """Test the ext_sequence_splitter plugin using batch command (proven working approach)"""
-    
-    # Path to the test data (in tests/ directory)
-    test_path = copy_test_case("test_splitter")
+    test_path = _copy_splitter_case(tmp_path)
 
     if not test_path.exists():
         print(f"❌ Test data not found: {test_path}")
@@ -84,12 +90,12 @@ def test_ext_sequence_splitter():
         return False
 
 
-def test_batch_command():
+def test_batch_command(tmp_path):
     """Test using the batch command line interface"""
 
     # Fix paths for running from tests/ directory
     script_path = Path(__file__).parent.parent / "pyptv" / "pyptv_batch_plugins.py"
-    test_exp_path = copy_test_case("test_splitter")
+    test_exp_path = _copy_splitter_case(tmp_path)
 
     if not script_path.exists():
         print(f"❌ Batch script not found: {script_path}")

tests/pyptv/test_ptv_file_io.py

@@ -4,6 +4,7 @@
 import numpy as np
 from pathlib import Path
 from unittest.mock import Mock, patch, mock_open
+from openptv_python.parameters import ControlPar, VolumePar
 from pyptv.ptv import (
     _ensure_directory_writable,
     _ensure_target_output_writable,
@@ -169,10 +170,10 @@ class TestCorrespondenceWritePreflight:
     def test_correspondences_checks_target_directory_before_writing(self):
         exp = Mock()
         exp.detections = [Mock()]
-        exp.corrected = Mock()
-        exp.cals = Mock()
-        exp.vpar = Mock()
-        exp.cpar = Mock()
+        exp.corrected = [Mock()]
+        exp.cals = [Mock()]
+        exp.vpar = VolumePar()
+        exp.cpar = ControlPar(num_cams=1, img_base_name=['cam1'], cal_img_base_name=['cam1'])
         exp.num_cams = 1
         exp.target_filenames = ['cam1']
 

tests/pyptv/test_ptv_utilities.py

@@ -6,13 +6,13 @@
 from pathlib import Path
 from unittest.mock import Mock, patch, MagicMock
 from optv.correspondences import MatchedCoords
+from openptv_python.parameters import ControlPar, VolumePar
 from pyptv.ptv import (
     _read_calibrations, generate_short_file_bases, py_pre_processing_c, py_determination_proc_c,
     run_sequence_plugin, run_tracking_plugin, py_sequence_loop,
     py_trackcorr_init
 )
 from pyptv.experiment import Experiment
-from optv.parameters import ControlParams
 from optv.calibration import Calibration
 
 
@@ -182,8 +182,8 @@ def test_py_determination_proc_c_basic(self, mock_point_positions, tmp_path, mon
         sorted_corresp = [np.array([[0]])]
         corrected = [Mock()]
         corrected[0].get_by_pnrs.return_value = np.array([[1.0, 2.0]])
-        cpar = Mock(spec=ControlParams)
-        vpar = Mock()
+        cpar = ControlPar(num_cams=1, img_base_name=['cam1'], cal_img_base_name=['cam1'])
+        vpar = VolumePar()
         cals = [Calibration()]
         mock_point_positions.return_value = (np.array([[1.0, 2.0, 3.0]]), None)
 
@@ -220,8 +220,8 @@ def test_py_determination_proc_c_invalid_calibrations(self):
         sorted_pos = [np.array([[1.0, 2.0], [3.0, 4.0]])]
         sorted_corresp = [np.array([[0, 1]])]
         corrected = [Mock()]
-        cpar = Mock(spec=ControlParams)
-        vpar = Mock()
+        cpar = ControlPar(num_cams=2, img_base_name=['cam1', 'cam2'], cal_img_base_name=['cam1', 'cam2'])
+        vpar = VolumePar()
         cals = []  # Empty calibrations
 
         with pytest.raises((IndexError, ValueError)):