preparing track additional tests, on the way changed half of the code :)

Author: alexlib

pyptv/ptv.py

@@ -43,6 +43,7 @@
 DEFAULT_FRAME_NUM = 123456789
 DEFAULT_HIGHPASS_FILTER_SIZE = 25
 DEFAULT_NO_FILTER = 0
+SHORT_BASE = "cam"  # Use this as the short base for camera file naming
 
 
 
@@ -378,13 +379,48 @@ def py_correspondences_proc_c(exp):
     else:
         print("Warning: No way to determine base names, skipping target writing")
 
-    print(
-        "Frame "
-        + str(frame)
-        + " had "
-        + repr([s.shape[1] for s in sorted_pos])
-        + " correspondences."
-    )
+    # Generate short_file_bases once per experiment
+    img_base_names = [exp.spar.get_img_base_name(i) for i in range(exp.num_cams)]
+    exp.short_file_bases = generate_short_file_bases(img_base_names)
+
+    for frame in range(exp.spar.get_first(), exp.spar.get_last() + 1):
+        detections = []
+        corrected = []
+        for i_cam in range(exp.num_cams):
+            targs = read_targets(exp.short_file_bases[i_cam], frame)
+            targs.sort_y()
+            detections.append(targs)
+            matched_coords = MatchedCoords(targs, exp.cpar, exp.cals[i_cam])
+            pos, _ = matched_coords.as_arrays()
+            corrected.append(matched_coords)
+        sorted_pos, sorted_corresp, _ = correspondences(
+            detections, corrected, exp.cals, exp.vpar, exp.cpar
+        )
+        print(
+            "Frame "
+            + str(frame)
+            + " had "
+            + repr([s.shape[1] for s in sorted_pos])
+            + " correspondences."
+        )
+        sorted_pos = np.concatenate(sorted_pos, axis=1)
+        sorted_corresp = np.concatenate(sorted_corresp, axis=1)
+        flat = np.array(
+            [corrected[i].get_by_pnrs(sorted_corresp[i]) for i in range(len(exp.cals))]
+        )
+        pos, _ = point_positions(flat.transpose(1, 0, 2), exp.cpar, exp.cals, exp.vpar)
+        if len(exp.cals) < 4:
+            print_corresp = -1 * np.ones((4, sorted_corresp.shape[1]))
+            print_corresp[: len(exp.cals), :] = sorted_corresp
+        else:
+            print_corresp = sorted_corresp
+        rt_is_filename = default_naming["corres"].decode()
+        rt_is_filename = f"{rt_is_filename}.{frame}"
+        with open(rt_is_filename, "w", encoding="utf8") as rt_is:
+            rt_is.write(str(pos.shape[0]) + "\n")
+            for pix, pt in enumerate(pos):
+                pt_args = (pix + 1,) + tuple(pt) + tuple(print_corresp[:, pix])
+                rt_is.write("%4d %9.3f %9.3f %9.3f %4d %4d %4d %4d\n" % pt_args)
 
     return sorted_pos, sorted_corresp, num_targs
 
@@ -532,31 +568,30 @@ def py_sequence_loop(exp) -> None:
 
     first_frame = spar.get_first()
     last_frame = spar.get_last()
-    print(f" From {first_frame = } to {last_frame = }")
+    # Generate short_file_bases once per experiment
+    img_base_names = [spar.get_img_base_name(i) for i in range(num_cams)]
+    short_file_bases = generate_short_file_bases(img_base_names)
+    exp.short_file_bases = short_file_bases
 
     for frame in range(first_frame, last_frame + 1):
         detections = []
         corrected = []
         for i_cam in range(num_cams):
-            base_image_name = spar.get_img_base_name(i_cam)
             if existing_target:
-                targs = read_targets(base_image_name, frame)
+                targs = read_targets(short_file_bases[i_cam], frame)
             else:
-                imname = Path(base_image_name % frame)
+                imname = Path(img_base_names[i_cam] % frame)
                 if not imname.exists():
                     raise FileNotFoundError(f"{imname} does not exist")
                 else:
                     img = imread(imname)
                     if img.ndim > 2:
                         img = rgb2gray(img)
-
                     if img.dtype != np.uint8:
                         img = img_as_ubyte(img)
-
                 if parameter_manager.get_parameter('ptv', {}).get('inverse', False):
                     print("Invert image")
                     img = negative(img)
-
                 masking_params = parameter_manager.get_parameter('masking')
                 if masking_params and masking_params.get('mask_flag', False):
                     try:
@@ -566,85 +601,71 @@ def py_sequence_loop(exp) -> None:
                         )
                         background = imread(background_name)
                         img = np.clip(img - background, 0, 255).astype(np.uint8)
-
                     except (ValueError, FileNotFoundError):
                         print("failed to read the mask")
-
                 high_pass = simple_highpass(img, cpar)
                 targs = target_recognition(high_pass, tpar, i_cam, cpar)
-
             targs.sort_y()
-            # print(len(targs))
             detections.append(targs)
             matched_coords = MatchedCoords(targs, cpar, cals[i_cam])
             pos, _ = matched_coords.as_arrays()
             corrected.append(matched_coords)
-
         sorted_pos, sorted_corresp, _ = correspondences(
             detections, corrected, cals, vpar, cpar
         )
-
         for i_cam in range(num_cams):
-            base_name = spar.get_img_base_name(i_cam)
-            write_targets(detections[i_cam], base_name, frame)
-
+            write_targets(detections[i_cam], short_file_bases[i_cam], frame)
         print(
             "Frame "
             + str(frame)
             + " had "
             + repr([s.shape[1] for s in sorted_pos])
             + " correspondences."
         )
-
         sorted_pos = np.concatenate(sorted_pos, axis=1)
         sorted_corresp = np.concatenate(sorted_corresp, axis=1)
-
         flat = np.array(
             [corrected[i].get_by_pnrs(sorted_corresp[i]) for i in range(len(exp.cals))]
         )
         pos, _ = point_positions(flat.transpose(1, 0, 2), exp.cpar, exp.cals, exp.vpar)
-
         if len(exp.cals) < 4:
             print_corresp = -1 * np.ones((4, sorted_corresp.shape[1]))
             print_corresp[: len(exp.cals), :] = sorted_corresp
         else:
             print_corresp = sorted_corresp
-
         rt_is_filename = default_naming["corres"].decode()
         rt_is_filename = f"{rt_is_filename}.{frame}"
         with open(rt_is_filename, "w", encoding="utf8") as rt_is:
             rt_is.write(str(pos.shape[0]) + "\n")
             for pix, pt in enumerate(pos):
                 pt_args = (pix + 1,) + tuple(pt) + tuple(print_corresp[:, pix])
                 rt_is.write("%4d %9.3f %9.3f %9.3f %4d %4d %4d %4d\n" % pt_args)
+            for pix, pt in enumerate(pos):
+                pt_args = (pix + 1,) + tuple(pt) + tuple(print_corresp[:, pix])
+                rt_is.write("%4d %9.3f %9.3f %9.3f %4d %4d %4d %4d\n" % pt_args)
 
 
 def py_trackcorr_init(exp):
     """Reads all the necessary stuff into Tracker"""
 
-    for cam_id in range(exp.cpar.get_num_cams()):
-        img_base_name = exp.spar.get_img_base_name(cam_id)
-        short_name = Path(img_base_name).parent / f'cam{cam_id+1}.'
-        print(f" Renaming {img_base_name} to {short_name} before C library tracker")
-        exp.spar.set_img_base_name(cam_id, str(short_name))
+    img_base_names = [exp.spar.get_img_base_name(cam_id) for cam_id in range(exp.cpar.get_num_cams())]
+    short_file_bases = generate_short_file_bases(img_base_names)
+
+    # Generate short_file_bases once per experiment
+    img_base_names = [exp.spar.get_img_base_name(i) for i in range(exp.cpar.get_num_cams())]
+    short_file_bases = generate_short_file_bases(img_base_names)
+    exp.short_file_bases = short_file_bases
+
+    for cam_id, short_name in enumerate(short_file_bases):
+        print(f"Setting tracker image base name for cam {cam_id+1}: {Path(short_name).resolve()}")
+        exp.spar.set_img_base_name(cam_id, str(Path(short_name).resolve()))
 
     tracker = Tracker(
         exp.cpar, exp.vpar, exp.track_par, exp.spar, exp.cals, default_naming
     )
 
     return tracker
 
-
-def py_trackcorr_loop():
-    """Supposedly returns some lists of the linked targets at every step of a tracker"""
-    pass
-
-
-def py_traject_loop():
-    """Used to plot trajectories after the full run
-    """
-
-
 # ------- Utilities ----------#
 
 
@@ -775,9 +796,33 @@ def py_calibration(selection, exp):
         return targs_all, targ_ix_all, residuals_all
 
 
-def read_targets(file_base: str, frame: int = 123456789) -> TargetArray:
+def write_targets(targets: TargetArray, short_file_base: str, frame: int) -> bool:
+    """Write targets to a file."""
+    filename = f"{short_file_base}.{frame:04d}_targets"
+    num_targets = len(targets)
+    success = False
+    try:
+        target_arr = np.array(
+            [
+                ([t.pnr(), *t.pos(), *t.count_pixels(), t.sum_grey_value(), t.tnr()])
+                for t in targets
+            ]
+        )
+        np.savetxt(
+            filename,
+            target_arr,
+            fmt="%4d %9.4f %9.4f %5d %5d %5d %5d %5d",
+            header=f"{num_targets}",
+            comments="",
+        )
+        success = True
+    except IOError:
+        print(f"Can't open targets file: {filename}")
+    return success
+
+def read_targets(short_file_base: str, frame: int) -> TargetArray:
     """Read targets from a file."""
-    filename = file_base_to_filename(file_base, frame)
+    filename = f"{short_file_base}.{frame:04d}_targets"
     print(f" filename: {filename}")
 
     try:
@@ -805,44 +850,48 @@ def read_targets(file_base: str, frame: int = 123456789) -> TargetArray:
     return targs
 
 
-def write_targets(targets: TargetArray, file_base: str, frame: int = 123456789) -> bool:
-    """Write targets to a file."""
-    success = False
-    filename = file_base_to_filename(file_base, frame)
-    num_targets = len(targets)
-
-    try:
-        target_arr = np.array(
-            [
-                ([t.pnr(), *t.pos(), *t.count_pixels(), t.sum_grey_value(), t.tnr()])
-                for t in targets
-            ]
-        )
-        np.savetxt(
-            filename,
-            target_arr,
-            fmt="%4d %9.4f %9.4f %5d %5d %5d %5d %5d",
-            header=f"{num_targets}",
-            comments="",
-        )
-        success = True
-    except IOError:
-        print(f"Can't open targets file: {filename}")
-
-    return success
-
-
-def file_base_to_filename(file_base, frame):
-    """Convert file base name to a filename"""
-    file_base = os.path.splitext(file_base)[0]
-    file_base = re.sub(r"_\d*d", "", file_base)
-    if re.search(r"%\d*d", file_base):
-        _ = re.sub(r"%\d*d", "%04d", file_base)
-        filename = Path(f"{_ % frame}_targets")
-    else:
-        filename = Path(f"{file_base}.{frame:04d}_targets")
+from typing import Union
 
-    return filename
+def extract_cam_id(file_base: str) -> int:
+    """
+    Extracts the camera ID (number only) from a file base string.
+    Returns the camera id as a string (e.g., "1", "2"), or "0" if not found.
+    it's possible that our files are not named as cam0,1,2,3 but can be anything
+    like cam_1, cam-2, cam.3, etc. or any number that is not the order, e.g. 
+    cam4,cam7 and cam12.
+    If no camera ID is found, returns 0.
+    """
+    base = os.path.splitext(file_base)[0]
+    base = re.sub(r'([_.-]?%+0?\d*d)$', '', base)
+    # Only strip trailing frame numbers (e.g., .0001 or _0001) or _targets, not camera IDs
+    # base = re.sub(r'([_.-]?\d{3,5})?(_targets)?$', '', base)
+    # base = re.sub(r'([_.-]?\d+(_targets)?)$', '', base)
+    # Look for 'cam' followed by digits anywhere in the string
+    match = re.search(r'cam[_ -]*0*(\d+)', base, re.IGNORECASE)
+    if match:
+        return int(match.group(1))
+    # Otherwise, look for the last group of digits in the string
+    matches = list(re.finditer(r'(\d+)', base))
+    if matches:
+        return int(matches[-1].group(1))
+    return 0
+
+def generate_short_file_bases(img_base_names: List[str]) -> List[str]:
+    """
+    Given a list of image base names for all cameras, extract their camera IDs
+    and generate a list of short_file_base strings for targets.
+    This ensures target files are named with the correct camera ID, not just their order.
+    """
+    short_file_bases = []
+    for img_base_name in img_base_names:
+        file_cam_id = extract_cam_id(img_base_name)
+        parent = str(Path(img_base_name).parent)
+        if parent == ".":
+            parent = ""
+        base = f"{SHORT_BASE}{file_cam_id}"
+        short_file_base = str(Path(parent) / base) if parent else base
+        short_file_bases.append(short_file_base)
+    return short_file_bases
 
 
 def read_rt_is_file(filename) -> List[List[float]]: