File size: 7,018 Bytes
1fc8465
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
"""2D tool kinematics from the dense SAM 3.1 tracks: tip, shaft entry and shaft angle per frame.

Usage: python 10_tool_tips.py <pack_dir>

For every instrument track (gauze is skipped) in every frame:
  mask   = largest connected piece of the track's mask (stray fragments ignored)
  entry  = centroid of the mask pixels closest to the image border (where the shaft
           comes into view); masks often stop a few pixels short of the edge
  tip    = mean of the mask pixels farthest from the entry (top 0.5 % by distance)
  angle  = direction entry -> tip, degrees, 0 = pointing right, 90 = pointing down
A mask that comes no closer than NEAR px to the border has no defined entry; tip is
left empty and flagged. Tips are then median-filtered over 5 frames within a track, and speed is
the frame-to-frame displacement of the smoothed tip in px/s (25 fps).

Validation: on the 69 keyframes the computed tip is compared with the hand-placed
tip in gold_subset/instances_coco_v2.json for the same instance.

Writes layer4_tool_kinematics/tool_tips.csv, track_summary.csv, validation.json.
"""
import csv
import json
import sys
from pathlib import Path

import cv2
import numpy as np

pack = Path(sys.argv[1])
dense, out = pack / "dense_tracks", pack / "layer4_tool_kinematics"
out.mkdir(exist_ok=True)
H, W, FPS, EDGE, NEAR = 576, 720, 25, 3, 25
yy, xx = np.mgrid[0:H, 0:W]
border_dist = np.minimum.reduce([xx, yy, W - 1 - xx, H - 1 - yy])

rows = []
for tp in sorted((dense / "tracks").glob("clip_*.json")):
    meta = json.load(open(tp))
    c = meta["clip_id"]
    tools = {int(k): v for k, v in meta["tracks"].items() if v["category"] != "gauze"}
    for f in range(meta["start_frame"], meta["start_frame"] + meta["num_frames"]):
        inst = cv2.imread(str(dense / "masks" / f"clip_{c:02d}" / f"{f:05d}.png"), 0)
        for tid in np.unique(inst)[1:]:
            tid = int(tid)
            if tid not in tools:
                continue
            m = inst == tid
            r = {"frame": f, "time_s": round(f / FPS, 2), "clip_id": c, "track_id": tid,
                 "source": tools[tid]["source"], "category": tools[tid]["category"], "area": int(m.sum())}
            # largest connected piece only, so stray fragments cannot become the tip
            n_cc, lab, stats, _ = cv2.connectedComponentsWithStats(m.astype(np.uint8), connectivity=8)
            m = lab == 1 + int(np.argmax(stats[1:, cv2.CC_STAT_AREA]))
            ys, xs = np.nonzero(m)
            # entry: mask pixels closest to the image border, if that is within NEAR px
            bd = border_dist[ys, xs]
            sel = bd <= bd.min() + EDGE
            bx, by = (xs[sel], ys[sel]) if bd.min() <= NEAR else (np.array([]), np.array([]))
            if len(bx) == 0:
                r.update(tip_x=None, tip_y=None, entry_x=None, entry_y=None, shaft_angle_deg=None,
                         flag="no_border_contact")
            else:
                ex, ey = bx.mean(), by.mean()
                d = np.hypot(xs - ex, ys - ey)
                far = d >= np.quantile(d, 0.995)
                tx, ty = xs[far].mean(), ys[far].mean()
                r.update(tip_x=round(float(tx), 1), tip_y=round(float(ty), 1), entry_x=round(float(ex), 1),
                         entry_y=round(float(ey), 1),
                         shaft_angle_deg=round(float(np.degrees(np.arctan2(ty - ey, tx - ex))), 1),
                         flag="tip_on_border" if (tx < EDGE + 2 or tx > W - EDGE - 3 or ty < EDGE + 2 or
                                                  ty > H - EDGE - 3) else "")
            rows.append(r)

# smoothing and speed, per (clip, track)
rows.sort(key=lambda r: (r["clip_id"], r["track_id"], r["frame"]))
groups = {}
for r in rows:
    groups.setdefault((r["clip_id"], r["track_id"]), []).append(r)
for g in groups.values():
    for i, r in enumerate(g):
        win = [q for q in g[max(0, i - 2):i + 3] if q["tip_x"] is not None and abs(q["frame"] - r["frame"]) <= 2]
        if r["tip_x"] is None or len(win) < 3:
            r["tip_x_smooth"] = r["tip_y_smooth"] = None
        else:
            r["tip_x_smooth"] = round(float(np.median([q["tip_x"] for q in win])), 1)
            r["tip_y_smooth"] = round(float(np.median([q["tip_y"] for q in win])), 1)
        p = g[i - 1] if i else None
        if p and p["frame"] == r["frame"] - 1 and p.get("tip_x_smooth") is not None and r["tip_x_smooth"] is not None:
            r["speed_px_s"] = round(float(np.hypot(r["tip_x_smooth"] - p["tip_x_smooth"],
                                                   r["tip_y_smooth"] - p["tip_y_smooth"]) * FPS), 1)
        else:
            r["speed_px_s"] = None

cols = ["frame", "time_s", "clip_id", "track_id", "source", "category", "tip_x", "tip_y", "tip_x_smooth",
        "tip_y_smooth", "entry_x", "entry_y", "shaft_angle_deg", "speed_px_s", "area", "flag"]
rows.sort(key=lambda r: (r["frame"], r["track_id"]))
with open(out / "tool_tips.csv", "w", newline="") as fh:
    w = csv.DictWriter(fh, cols)
    w.writeheader()
    w.writerows(rows)

with open(out / "track_summary.csv", "w", newline="") as fh:
    w = csv.writer(fh)
    w.writerow(["clip_id", "track_id", "source", "category", "first_frame", "last_frame", "frames",
                "frames_with_tip", "path_length_px", "median_speed_px_s", "max_speed_px_s"])
    for (c, t), g in sorted(groups.items()):
        sp = [r["speed_px_s"] for r in g if r["speed_px_s"] is not None]
        w.writerow([c, t, g[0]["source"], g[0]["category"], g[0]["frame"], g[-1]["frame"], len(g),
                    sum(r["tip_x"] is not None for r in g), round(sum(sp) / FPS, 1),
                    round(float(np.median(sp)), 1) if sp else "", round(max(sp), 1) if sp else ""])

# validation against hand-placed keyframe tips
coco = json.load(open(pack / "gold_subset" / "instances_coco_v2.json"))
cat = {c["id"]: c["name"] for c in coco["categories"]}
idx = {(r["frame"], r["track_id"]): r for r in rows}
errs, n_ref, no_tip = [], 0, 0
for a in coco["annotations"]:
    if not a["tip"] or cat[a["category_id"]] == "gauze":
        continue
    r = idx.get((a["image_id"], 100 + a["instance_index_in_mask_png"]))
    if r is None:
        continue
    n_ref += 1
    if r["tip_x"] is None:
        no_tip += 1
        continue
    errs.append(float(np.hypot(r["tip_x"] - a["tip"][0], r["tip_y"] - a["tip"][1])))
e = np.array(errs)
val = {"reference": "hand-placed tips on keyframes (instances_coco_v2.json), click tracks only",
       "instances_compared": n_ref, "no_computed_tip": no_tip,
       "median_error_px": round(float(np.median(e)), 1), "p90_error_px": round(float(np.quantile(e, 0.9)), 1),
       "within_20px": round(float((e <= 20).mean()), 3), "within_40px": round(float((e <= 40).mean()), 3),
       "errors_px": [round(x, 1) for x in errs]}
json.dump(val, open(out / "validation.json", "w"), indent=1)
print("rows", len(rows), "tracks", len(groups), "with tip", sum(r["tip_x"] is not None for r in rows))
print({k: v for k, v in val.items() if k != "errors_px"})