fighting with Cores_dtype, whether to make it a list of array

Author: alexlib

openptv_python/correspondences.py

@@ -5,10 +5,10 @@
 
 from .calibration import Calibration
 from .constants import COORD_UNUSED, CORRES_NONE, MAX_TARGETS, MAXCAND, NMAX, PT_UNUSED
-from .epi import Coord2d, epi_mm
+from .epi import epi_mm
 from .find_candidate import find_candidate
 from .parameters import ControlPar, VolumePar
-from .tracking_frame_buf import Frame, Target, n_tupel
+from .tracking_frame_buf import Frame, Target, n_tupel_dtype
 from .trafo import dist_to_flat, pixel_to_metric
 
 
@@ -99,15 +99,13 @@ def __del__(self):
         del self.buf
 
 
-class Correspond:
-    """Correspondence between two points in two cameras."""
-
-    def __init__(self):
-        self.p1 = PT_UNUSED
-        self.n = 0
-        self.p2 = np.array([0] * MAXCAND)
-        self.corr = np.array([0.0] * MAXCAND)
-        self.dist = np.array([0.0] * MAXCAND)
+Correspond_dtype = np.dtype([
+    ('p1', np.int32), # PT_UNUSED
+    ('n', np.int32), # 0
+    ('p2', (np.float64, MAXCAND)), # np.zeros
+    ('corr', (np.float64, MAXCAND)), # np.zeros
+    ('dist', (np.float64, MAXCAND)) # np.zeros
+])
 
 def safely_allocate_target_usage_marks(
     num_cams: int, nmax: int = NMAX
@@ -138,21 +136,26 @@ def safely_allocate_target_usage_marks(
 
 def safely_allocate_adjacency_lists(
     num_cams: int, target_counts: List[int]
-) -> List[List[List[Correspond]]]:
+) -> List[List[List[np.recarray]]]:
     """Allocate space for the adjacency lists."""
+    one_element = np.array(
+        [(PT_UNUSED, 0, np.zeros(MAXCAND), np.zeros(MAXCAND), np.zeros(MAXCAND))],
+        dtype=Correspond_dtype).view(np.recarray)
+
     try:
         lists = [
-            [[Correspond() for _ in range(target_counts[c1])] for _ in range(num_cams)]
+            [[one_element for _ in range(target_counts[c1])] for _ in range(num_cams)]
             for c1 in range(num_cams)
         ]
+
     except MemoryError:
         print("Memory allocation failed.")
-        lists = []
+        lists = [[[one_element]]]
 
     return lists
 
 def four_camera_matching(
-    corr_list: List[List[List[Correspond]]],
+    corr_list: List[List[List[np.recarray]]],
     base_target_count,
     accept_corr,
     scratch,
@@ -228,7 +231,7 @@ def four_camera_matching(
 
 
 def three_camera_matching(
-    corr_list: List[List[List[Correspond]]],
+    corr_list: List[List[List[np.recarray]]],
     num_cams,
     target_counts,
     accept_corr,
@@ -307,7 +310,7 @@ def three_camera_matching(
 
 
 def consistent_pair_matching(
-    corr_list: List[List[List[Correspond]]],
+    corr_list: List[List[List[np.recarray]]],
     num_cams: int,
     target_counts: List[int],
     accept_corr: float,
@@ -353,8 +356,8 @@ def consistent_pair_matching(
 
 
 def match_pairs(
-    corr_lists: List[List[List[Correspond]]],
-    corrected: List[List[Coord2d]],
+    corr_lists: List[List[List[np.recarray]]],
+    corrected: np.ndarray, # List[List[Coord2d]],
     frm: Frame,
     vpar: VolumePar,
     cpar: ControlPar,
@@ -454,7 +457,7 @@ def match_pairs(
 
 
 def take_best_candidates(
-    src: List[n_tupel], dst: List[n_tupel], num_cams: int, tusage: List[List[int]]
+    src: np.recarray, dst: np.recarray, num_cams: int, tusage: List[List[int]] #List[n_tupel]
 ):
     """
     Take the best candidates from the candidate list based on their correlation measure.
@@ -497,7 +500,8 @@ def take_best_candidates(
     taken = 0
 
     # Sort candidates by match quality (.corr)
-    src.sort(key=lambda x: x.corr, reverse=True)
+    src.sort(order='corr') # by corr
+    src = src[::-1] # reverse order
 
     # Take candidates from the top to the bottom of the sorted list
     # Only take if none of the corresponding targets have been used
@@ -528,7 +532,7 @@ def take_best_candidates(
 
 def py_correspondences(
     img_pts: List[List[Target]],  # num_cams * num_targets[cam]
-    flat_coords: List[List[Coord2d]],
+    flat_coords: List[List[np.recarray]],
     calib: List[Calibration],
     vparam: VolumePar,
     cparam: ControlPar,
@@ -644,12 +648,12 @@ def py_correspondences(
 
 def correspondences(
     frm: Frame,
-    corrected: List[List[Coord2d]],
+    corrected: List[List[np.recarray]],  # List[List[Coord2d]],
     vpar: VolumePar,
     cpar: ControlPar,
     calib: List[Calibration],
     match_counts: List[int],
-) -> List[n_tupel]:
+) -> List[np.ndarray]: # n_tupel
     """Find correspondences between cameras.
 
     /*  correspondences() generates a list of tuple target numbers (one for each
@@ -686,8 +690,9 @@ def correspondences(
     nmax = NMAX
 
     # Allocation of scratch buffers for internal tasks and return-value space
-    con0 = [n_tupel() for _ in range(nmax * cpar.num_cams)]
-    con = [n_tupel() for _ in range(nmax * cpar.num_cams)]
+    con0 = np.empty((nmax * cpar.num_cams,), dtype=n_tupel_dtype)
+    con = np.empty((nmax * cpar.num_cams,), dtype=n_tupel_dtype)
+
     tim = safely_allocate_target_usage_marks(cpar.num_cams, nmax)
 
     # allocate memory for lists of correspondences
@@ -752,7 +757,7 @@ def correspondences(
 
 
 def single_cam_correspondences(
-    img_pts: List[Target], corrected: List[Coord2d]
+    img_pts: List[Target], corrected: np.recarray #List[Coord2d]
 ) -> Tuple[List[np.ndarray], List[np.ndarray], int]:
     """
     Single camera correspondence is not a real correspondence, it will be only a projection.

openptv_python/epi.py

@@ -1,80 +1,44 @@
 """Epipolar geometry."""
-from typing import List, Tuple
+from typing import Tuple
 
 import numpy as np
-from numba import float64, int32, njit
-from numba.experimental import jitclass
 
+# from numba import float64, int32
 from .calibration import Calibration
-from .constants import PT_UNUSED
 from .imgcoord import flat_image_coord, img_coord
 from .multimed import move_along_ray
 from .parameters import ControlPar, MultimediaPar, VolumePar
 from .ray_tracing import ray_tracing
 from .trafo import dist_to_flat, metric_to_pixel, pixel_to_metric
 
-spec = [
-    ('pnr', int32),
-    ('tol', float64),
-    ('corr', float64),
-]
+Candidate_dtype = np.dtype([
+    ('pnr', np.int32),
+    ('tol', np.float64),
+    ('corr', np.float64),
+])
 
-@jitclass(spec)
-class Candidate:
-    """Candidate point in the second image."""
+Coord2d_dtype = np.dtype([
+    ('pnr', np.int32),
+    ('x', np.float64),
+    ('y', np.float64),
+])
 
-    def __init__(self, pnr=PT_UNUSED, tol=0.0, corr=0.0):
-        self.pnr = pnr
-        self.tol = tol
-        self.corr = corr
+Coord3d_dtype = np.dtype([
+    ('pnr', np.int32),
+    ('x', np.float64),
+    ('y', np.float64),
+    ('z', np.float64),
+])
 
-    # def __repr__(self):
-    #     return f"Candidate(pnr={self.pnr}, tol={self.tol}, corr={self.corr})"
 
-spec = [
-    ('pnr', int32),
-    ('x', float64),
-    ('y', float64),
-]
 
-@jitclass(spec)
-class Coord2d:
-    """2D coordinates in the image space."""
-
-    def __init__(self, pnr=PT_UNUSED, x=0.0, y=0.0):
-        self.pnr = pnr
-        self.x = x
-        self.y = y
-
-    # def __repr__(self):
-    #     return f"Coord2d(pnr={self.pnr}, x={self.x}, y={self.y})"
-
-@njit
-def sort_coord2d_x(crd: List[Coord2d]) -> List[Coord2d]:
+def sort_coord2d_x(crd: np.ndarray) -> np.ndarray:
     """Quicksort for coordinates by x ."""
-    return sorted(crd, key=lambda p: p.x)
+    return np.sort(crd, order='x')
 
-@njit
-def sort_coord2d_y(crd: List[Coord2d]) -> List[Coord2d]:
+def sort_coord2d_y(crd: np.ndarray) -> np.ndarray:
     """Sort coordinates by y."""
-    return sorted(crd, key=lambda p: p.y)
-
-spec = [
-    ('pnr', int32),
-    ('x', float64),
-    ('y', float64),
-    ('z', float64),
-]
-
-@jitclass(spec)
-class Coord3d:
-    """2D coordinates in the image space."""
-
-    def __init__(self, pnr=PT_UNUSED, x=0.0, y=0.0, z=0.0):
-        self.pnr = pnr
-        self.x = x
-        self.y = y
-        self.z = z
+    return np.sort(crd, order='y')
 
 
 def epi_mm(xl, yl, cal1, cal2, mmp, vpar) -> Tuple[float, float, float, float]:

openptv_python/sortgrid.py

@@ -4,7 +4,7 @@
 
 from .calibration import Calibration
 from .constants import POS_INF, PT_UNUSED, SORTGRID_EPS
-from .epi import Coord3d
+from .epi import Coord3d_dtype
 from .imgcoord import img_coord
 from .parameters import ControlPar
 from .tracking_frame_buf import Target
@@ -119,7 +119,7 @@ def read_sortgrid_par(filename) -> int:
     return eps
 
 
-def read_calblock(filename: str) -> List[Coord3d]:
+def read_calblock(filename: str) -> np.recarray: #List[Coord3d]:
     """
     Read the calibration block file into the structure of 3D positions and pointers.
 
@@ -142,13 +142,14 @@ def read_calblock(filename: str) -> List[Coord3d]:
                 x = float(values[1])
                 y = float(values[2])
                 z = float(values[3])
-                coord = Coord3d(pnr, x, y, z)
+                # coord = Coord3d(pnr, x, y, z)
+                coord = np.array([(pnr, x, y, z)], dtype=Coord3d_dtype)
                 coords.append(coord)
     except FileNotFoundError:
         print(f"Can't open calibration block file: {filename}")
-        return []
+        return np.recarray(0, dtype=Coord3d_dtype)
     except ValueError:
         print(f"Empty or badly formatted file: {filename}")
-        return []
+        return np.recarray(0, dtype = Coord3d_dtype)
 
-    return coords
+    return np.array(coords).view(np.recarray)

openptv_python/track.py

@@ -23,7 +23,7 @@
 from .imgcoord import img_coord
 from .orientation import point_position
 from .parameters import ControlPar, SequencePar, TrackPar, VolumePar
-from .tracking_frame_buf import Corres, Frame, Pathinfo, Target
+from .tracking_frame_buf import Corres_dtype, Frame, Pathinfo, Target
 from .tracking_run import TrackingRun
 from .trafo import dist_to_flat, metric_to_pixel, pixel_to_metric
 from .vec_utils import vec_copy, vec_diff_norm, vec_subt
@@ -761,8 +761,7 @@ def add_particle(frm: Frame, pos: np.ndarray, cand_inds: np.ndarray) -> None:
         ref_path_inf = Pathinfo()
         frm.path_info.append(ref_path_inf)
 
-        ref_corres = Corres()
-        frm.correspond.append(ref_corres)
+        frm.correspond.append(np.recarray((1,), dtype=Corres_dtype))
 
     ref_path_inf.x = vec_copy(pos)
     ref_path_inf.reset_links()