fixed all the tests, there was a bug with Calibraiton initalization

Author: alexlib

openptv_python/calibration.py

@@ -1,5 +1,6 @@
 """Calibration data structures and functions."""
 
+import copy
 import pathlib
 from typing import Optional
 
@@ -104,15 +105,15 @@ def __init__(self,
                  mmlut=None,
                  mmlut_data=None):
         if ext_par is None:
-            ext_par = Exterior.copy()
+            ext_par = copy.deepcopy(Exterior)
         if int_par is None:
-            int_par = Interior.copy()
+            int_par = copy.deepcopy(Interior)
         if glass_par is None:
             glass_par = np.array([0.0, 0.0, 1.0])
         if added_par is None:
-            added_par = ap_52.copy()
+            added_par = np.array((0, 0, 0, 0, 0, 1, 0), dtype = np.float64)
         if mmlut is None:
-            mmlut = mm_lut.copy() # (np.zeros(3), 0, 0, 0)
+            mmlut = copy.deepcopy(mm_lut) # (np.zeros(3), 0, 0, 0)
         if mmlut_data is None:
             mmlut_data = np.zeros((mmlut.nr, mmlut.nz), dtype=np.float64)
 
@@ -378,7 +379,7 @@ def get_glass_vec(self) -> np.ndarray:
     def set_added_par(self, ap52_array: np.ndarray):
         """Set added par from an numpy array of parameters."""
         # self.added_par = np.array(tuple(ap52_array.tolist()), dtype = ap52_dtype).view(np.recarray)
-        self.added_par = ap52_array
+        self.added_par = ap52_array.astype(np.float64)
 
     def copy(self, new_copy):
         """Copy the calibration data to a new object."""
@@ -415,8 +416,8 @@ def write_ori(
 
     with open(add_file, "w", encoding="utf-8") as fp:
         fp.write(
-            f"{added_par.k1:.8f} {added_par.k2:.8f} {added_par.k3:.8f} "
-            f"{added_par.p1:.8f} {added_par.p2:.8f} {added_par.scx:.8f} {added_par.she:.8f}\n"
+            f"{added_par[0]:.8f} {added_par[1]:.8f} {added_par[2]:.8f} "
+            f"{added_par[3]:.8f} {added_par[4]:.8f} {added_par[5]:.8f} {added_par[6]:.8f}\n"
         )
         success = True
 
@@ -491,15 +492,7 @@ def compare_calibration(c1: Calibration, c2: Calibration) -> bool:
 
 def compare_addpar(a1, a2):
     """Compare added parameters."""
-    return (
-        (a1.k1 == a2.k1)
-        and (a1.k2 == a2.k2)
-        and (a1.k3 == a2.k3)
-        and (a1.p1 == a2.p1)
-        and (a1.p2 == a2.p2)
-        and (a1.scx == a2.scx)
-        and (a1.she == a2.she)
-    )
+    return np.array_equal(a1, a2)
 
 
 def read_calibration(ori_file: str, addpar_file: str) -> Calibration:

tests/test_calibration_binding.py

@@ -55,14 +55,17 @@ def test_full_instantiate(self):
 
         G = np.array(glass)
 
-        addpar = np.array((
+        addpar = np.array(
+            [
             rad_dist[0],
             rad_dist[1],
             rad_dist[2],
             decent[0],
             decent[1],
             affine[0],
-            affine[1]),dtype=ap_52.dtype).view(np.recarray)
+            affine[1]
+            ]
+        )
 
 
         cal = Calibration()

tests/test_calibration_class.py

@@ -31,14 +31,8 @@ def test_glass_initialization(self):
 
     def test_ap_52_initialization(self):
         """Test ap_52 parameters initialization."""
-        ap = self.cal.added_par
-        assert ap.k1 == 0.0
-        assert ap.k2 == 0.0
-        assert ap.k3 == 0.0
-        assert ap.p1 == 0.0
-        assert ap.p2 == 0.0
-        assert ap.scx == 1.0
-        assert ap.she == 0.0
+        assert np.array_equal(self.cal.added_par, \
+            np.array([0,0,0,0,0,1,0],dtype=np.float64))
 
     def test_mmlut_initialization(self):
         """Test mmlut parameters initialization."""
@@ -59,7 +53,7 @@ def test_calibration_initialization(self):
         assert self.cal.added_par.dtype == ap_52.dtype
         assert self.cal.mmlut.dtype == mm_lut.dtype
 
-        assert isinstance(self.cal.added_par, np.recarray)
+        assert isinstance(self.cal.added_par, np.ndarray)
         assert isinstance(self.cal.mmlut, np.recarray)
 
     def test_exterior_initialization(self):

tests/test_trafo.py

@@ -60,15 +60,7 @@ def test_round_trip(self):
 
         cal = Calibration()
         cal.int_par.xh, cal.int_par.yh, cal.int_par.cc = 1.5, 1.5, 60.0
-        (
-            cal.added_par.k1,
-            cal.added_par.k2,
-            cal.added_par.k3,
-            cal.added_par.p1,
-            cal.added_par.p2,
-            cal.added_par.scx,
-            cal.added_par.she,
-        ) = (1e-5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
+        cal.added_par = np.array((1e-5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0),dtype=np.float64)
 
         xdist, ydist = flat_to_dist(x, y, cal)
         xflat, yflat = dist_to_flat(xdist, ydist, cal, iter_eps)
@@ -79,8 +71,8 @@ def test_round_trip(self):
     def test_shear_distortion(self):
         """Test the shear distortion parameter."""
         x, y = 1.0, 1.0
-        ap = ap_52.copy()
-        ap.she=1.0
+        ap = ap_52[:]
+        ap[6]=1.0
         xp, yp = distort_brown_affine(x, y, ap)
         self.assertAlmostEqual(xp, 0.158529)
         self.assertAlmostEqual(yp, 0.5403023)
@@ -137,7 +129,7 @@ def test_round_trip2(self):
         """
         x, y = 1.0, 1.0
         eps = 1e-5
-        ap = ap_52.copy()  # no distortion
+        ap = ap_52[:]  # no distortion
 
         xres, yres = distort_brown_affine(x, y, ap)
         xres, yres = correct_brown_affine(xres, yres, ap)
@@ -153,7 +145,7 @@ def test_shear_round_trip(self):
         """
         x, y = -1.0, 10.0
         eps = 1e-5
-        ap = ap_52.copy()
+        ap = ap_52[:]
         # ap.she = 1.0  # no distortion
 
         xres, yres = distort_brown_affine(x, y, ap)

tests/test_trafo_mockup.py

@@ -1,9 +1,9 @@
-import copy
+
 import unittest
 
 import numpy as np
 
-from openptv_python.calibration import Calibration, Interior
+from openptv_python.calibration import Calibration, interior_dtype
 from openptv_python.parameters import ControlPar
 from openptv_python.trafo import (
     dist_to_flat,
@@ -19,48 +19,47 @@ class TestFlatToDist(unittest.TestCase):
     """Test the flat_to_dist function."""
 
     def setUp(self):
-        self.cal = Calibration()
-        print(f" k1 = {self.cal.added_par.k1}")
-
         self.cpar = ControlPar()
         self.cpar.imx = 1024
         self.cpar.imy = 1008
         self.cpar.pix_x = 0.010
         self.cpar.pix_y = 0.010
 
     def test_zero_coordinates(self):
-        dist_x, dist_y = flat_to_dist(0, 0, self.cal)
+        """Test the case when the input coordinates are zero."""
+        cal = Calibration()
+        dist_x, dist_y = flat_to_dist(0, 0, cal)
         self.assertEqual(dist_x, 0)
         self.assertEqual(dist_y, 0)
 
     def test_positive_coordinates(self):
-        cal = copy.copy(self.cal)
+        """Test the case when the input coordinates are positive."""
+        cal = Calibration()
         cal.int_par.xh = 100
         cal.int_par.yh = 50
-        print("inside test_positive_coordinates\n")
-        print(f"cal.added_par.k1 = {cal.added_par.k1}\n")
-        print(f"self.cal.added_par.k1 = {self.cal.added_par.k1}\n")
         dist_x, dist_y = flat_to_dist(50, 25, cal)
         self.assertEqual(dist_x, 150)
         self.assertEqual(dist_y, 75)
 
     def test_distortion(self):
-        cal = copy.copy(self.cal)
-        cal.set_added_par(np.array([1e-5, 0, 0, 0, 0, 1, 0]))
+        """Test the case when the distortion is not zero."""
+        cal = Calibration()
+        cal.set_added_par(np.array([1e-5, 0, 0, 0, 0, 1, 0], dtype=np.float64))
         dist_x, dist_y = flat_to_dist(100, 200, cal)
         self.assertAlmostEqual(dist_x, 150, places=3)
         self.assertAlmostEqual(dist_y, 300, places=3)
 
     def test_pixel_to_metric_and_back(self):
-        cpar = copy.copy(self.cpar)
-        cpar.from_file("tests/testing_folder/control_parameters/control.par")
+        """Test the pixel_to_metric and metric_to_pixel functions."""
+        cpar = ControlPar().from_file("tests/testing_folder/control_parameters/control.par")
 
         x, y = metric_to_pixel(1, 1, cpar)
         x, y = pixel_to_metric(x, y, cpar)
         self.assertTrue(abs(x - 1) < EPS)
         self.assertTrue(abs(y - 1) < EPS)
 
     def test_0_0(self):
+        """Test the case when the input coordinates are zero."""
         xc = 0.0
         yc = 0.0
 
@@ -71,6 +70,7 @@ def test_0_0(self):
         self.assertTrue(abs(yc1 - yc) < EPS)
 
     def test_1_0(self):
+        """Test the case when the input coordinates are (1, 0)."""
         xc = 1.0
         yc = 0.0
 
@@ -81,6 +81,7 @@ def test_1_0(self):
         self.assertTrue(abs(yc1 - yc) < EPS)
 
     def test_0_neg1(self):
+        """Test the case when the input coordinates are (0, -1)."""
         xc = 0.0
         yc = -1.0
 
@@ -91,6 +92,7 @@ def test_0_neg1(self):
         self.assertTrue(abs(yc1 - yc) < EPS)
 
     def dist_flat_round_trip(self):
+        """Test the round trip from flat to distorted and back."""
         # /*  Cheks that the order of operations in converting metric flat image to
         #     distorted image coordinates and vice-versa is correct.
 
@@ -104,9 +106,9 @@ def dist_flat_round_trip(self):
         y = 10.0
         iter_eps = 1e-5
 
-        cal = copy.copy(self.cal)
-        cal.int_par = Interior(1.5, 1.5, 60.0)
-        cal.set_added_par([0.0005, 0, 0, 0, 0, 1, 0])
+        cal = Calibration()
+        cal.int_par = np.array( (1.5, 1.5, 60.0), dtype = interior_dtype).view(np.recarray)
+        cal.set_added_par(np.array([0.0005, 0, 0, 0, 0, 1, 0], dtype=np.float64))
 
         xres, yres = flat_to_dist(x, y, cal)
         xres, yres = dist_to_flat(xres, yres, cal, 0.00001)