Datasets:
Download annotated/scripts/12_actions.py from hkust-aaron/laparoscopic-robotic-vision-sample: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample/resolve/main/annotated/scripts/12_actions.py
- Command line
-
hf download hf://datasets/hkust-aaron/laparoscopic-robotic-vision-sample/annotated/scripts/12_actions.py
-
curl -L -o 12_actions.py https://huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample/resolve/main/annotated/scripts/12_actions.py
11.9 kB
| """Action-level annotation of every 10 s clip, with per-frame instrument state. | |
| Usage: python 12_actions.py <pack_dir> | |
| Labels live in layer5_actions/labels/clip_XX.json, one file per clip, written by an | |
| AI model from contact sheets with the dense masks drawn on: every 5 frames (0.2 s) | |
| for clips 5, 40 and 43, every 10 frames (0.4 s) for the others, so boundaries are | |
| accurate to about +-5 / +-10 frames. Nothing here has been reviewed by a surgeon. | |
| Targets are named by appearance, not anatomy, because the procedure is not known. | |
| The script validates every file (verbs, jaw states, frame ranges, track ids, no | |
| overlapping segments on one track) and stops on any problem. | |
| Each segment: one instrument track (track ids from dense_tracks/), one verb from | |
| VERBS, the target, jaw state, whether energy use is visible, and an imperative | |
| instruction of the kind a supervising surgeon would say. Tissue track ids refer | |
| to layer5_actions/target_tissue/ (SAM 3.1 tracks from 11_sam31_target_tissue.py). | |
| Writes layer5_actions/actions.json, per_frame_state.csv and timeline_clip_XX.png. | |
| """ | |
| import csv | |
| import json | |
| import sys | |
| from pathlib import Path | |
| import cv2 | |
| import numpy as np | |
| pack = Path(sys.argv[1]) | |
| out = pack / "layer5_actions" | |
| out.mkdir(exist_ok=True) | |
| VERBS = { | |
| "transport": "carry an object (gauze, tissue) to another place while holding it", | |
| "regrasp": "open the jaws and close them again on a different part of the held object", | |
| "press": "push an object or the tip against tissue and keep pressure", | |
| "lift_off": "lift a pressed object off the tissue to look underneath", | |
| "release": "open the jaws and let go of the held object", | |
| "withdraw": "move the instrument out of view", | |
| "enter": "move the instrument into view", | |
| "approach": "move the tip towards a target without acting on it", | |
| "open_jaws": "open the jaws near the target", | |
| "position": "place open jaws around the target with small adjustments", | |
| "grasp": "close the jaws on tissue", | |
| "hold": "keep the instrument or held tissue still", | |
| "coagulate": "energy applied at the tip: tissue darkens, smoke or char appears", | |
| "retract": "pull held tissue away to put it under tension", | |
| "peel": "pull held material so it separates from the surface underneath", | |
| "counter_traction": "push or hold tissue in the opposite direction to the other instrument", | |
| "blunt_dissect": "push or sweep the tip along a tissue plane to separate it", | |
| "probe": "touch a spot with the tip", | |
| "sweep": "move the shaft or tip across the view (often near the lens)", | |
| "absent": "instrument not in view", | |
| } | |
| CAMERA_VERBS = {"inspect": "camera held still on a region to check it", | |
| "move_view": "camera moves to a different part of the field"} | |
| # ---- load the per-clip label files (one JSON per 10 s clip, written by hand from contact sheets) | |
| FIELDS = ["track_id", "start_frame", "end_frame", "verb", "target", "jaw_state", "energy_visible", "instruction"] | |
| JAW = {"open", "closed", "open->closed", "closed->open", "unknown", "n/a"} | |
| problems = [] | |
| doc = {"description": "Action segments for every 10 s clip of the video. AI draft, written from contact sheets " | |
| "sampled every 0.2 s (clips 5, 40, 43) or 0.4 s (the other clips), so boundaries are about " | |
| "+-5 or +-10 frames; targets named by appearance; reviewed and approved by the contributing physician on 2026-11-17.", | |
| "frame_index": "frames of video/laparoscopic_sample_001_intracorporeal.mp4 (25 fps)", | |
| "verbs": VERBS, "camera_verbs": CAMERA_VERBS, "clips": []} | |
| for lp in sorted((out / "labels").glob("clip_*.json")): | |
| lab = json.load(open(lp)) | |
| cid = lab["clip_id"] | |
| tm = json.load(open(pack / "dense_tracks" / "tracks" / f"clip_{cid:02d}.json")) | |
| s0, s1 = tm["start_frame"], tm["start_frame"] + tm["num_frames"] - 1 | |
| segs = [] | |
| for row in lab["segments"]: | |
| s = dict(zip(FIELDS, row)) | |
| s["energy_visible"] = bool(s["energy_visible"]) | |
| if s["verb"] not in VERBS: | |
| problems.append(f"clip {cid}: unknown verb {s['verb']}") | |
| if s["jaw_state"] not in JAW: | |
| problems.append(f"clip {cid}: unknown jaw state {s['jaw_state']}") | |
| if not (s0 <= s["start_frame"] <= s["end_frame"] <= s1): | |
| problems.append(f"clip {cid}: segment out of range {row[:4]}") | |
| if str(s["track_id"]) not in lab["objects"]: | |
| problems.append(f"clip {cid}: track {s['track_id']} not in objects") | |
| s["instrument"] = lab["objects"][str(s["track_id"])] | |
| s["lane"] = lab.get("merge_tracks", {}).get(str(s["track_id"]), s["track_id"]) # same instrument, other track id | |
| s["duration_s"] = round((s["end_frame"] - s["start_frame"] + 1) / 25, 2) | |
| segs.append(s) | |
| by_t = {} | |
| for s in segs: | |
| by_t.setdefault(s["lane"], []).append(s) | |
| for t, ss in by_t.items(): | |
| ss = sorted(ss, key=lambda s: s["start_frame"]) | |
| for a, b in zip(ss, ss[1:]): | |
| if b["start_frame"] <= a["end_frame"]: | |
| problems.append(f"clip {cid}: overlap on track {t} at {b['start_frame']}") | |
| cam = [dict(zip(["start_frame", "end_frame", "verb", "target", "instruction"], x)) for x in lab["camera_segments"]] | |
| for x in cam: | |
| if x["verb"] not in CAMERA_VERBS: | |
| problems.append(f"clip {cid}: unknown camera verb {x['verb']}") | |
| doc["clips"].append({"clip_id": cid, "start_frame": s0, "end_frame": s1, "visible_goal": lab["visible_goal"], | |
| "label_sampling_s": lab.get("label_sampling_s", 0.4), "objects": lab["objects"], | |
| "tissue_tracks": lab["tissue_targets"], "segments": segs, "camera_segments": cam, | |
| "decisions": lab.get("decisions", [])}) | |
| if problems: | |
| print("\n".join(problems)) | |
| sys.exit(1) | |
| json.dump(doc, open(out / "actions.json", "w"), indent=1) | |
| # per-frame state: active verb per instrument + 2D kinematics from layer4 | |
| kin = {} | |
| with open(pack / "layer4_tool_kinematics" / "tool_tips.csv") as fh: | |
| for r in csv.DictReader(fh): | |
| kin[(int(r["frame"]), int(r["track_id"]))] = r | |
| rows = [] | |
| for c in doc["clips"]: | |
| tracks = sorted({s["lane"] for s in c["segments"]}) | |
| for f in range(c["start_frame"], c["end_frame"] + 1): | |
| for t in tracks: | |
| act = [s for s in c["segments"] if s["start_frame"] <= f <= s["end_frame"] and | |
| s["lane"] == t] | |
| k = kin.get((f, t)) or (kin.get((f, 3)) if t == 101 and c["clip_id"] == 5 else None) | |
| rows.append({"frame": f, "clip_id": c["clip_id"], "track_id": t, | |
| "instrument": c["objects"][str(t)].split(" (")[0], | |
| "verbs": "+".join(s["verb"] for s in act), "target": act[0]["target"] if act else "", | |
| "jaw_state": act[0]["jaw_state"] if act else "", | |
| "energy_visible": int(any(s["energy_visible"] for s in act)), | |
| "in_mask": int(k is not None), | |
| "tip_x": k["tip_x_smooth"] if k else "", "tip_y": k["tip_y_smooth"] if k else "", | |
| "shaft_angle_deg": k["shaft_angle_deg"] if k else "", "speed_px_s": k["speed_px_s"] if k else ""}) | |
| with open(out / "per_frame_state.csv", "w", newline="") as fh: | |
| w = csv.DictWriter(fh, list(rows[0])) | |
| w.writeheader() | |
| w.writerows(rows) | |
| # target-tissue reliability. A frame's tissue mask is flagged when it | |
| # - is more than twice the object's median area in the clip (spread into neighbouring tissue), | |
| # - covers more than 40 % of the image, or | |
| # - has at least half of its pixels on instrument masks (the track drifted onto an instrument). | |
| # Flagged frames are kept but marked; an object flagged in more than half of its frames is "rejected". | |
| qual = {} | |
| for p in sorted((out / "target_tissue" / "tracks").glob("clip_*.json")): | |
| tm = json.load(open(p)) | |
| cid = tm["clip_id"] | |
| for oid, o in tm["objects"].items(): | |
| areas = {int(f): v["area"] for f, v in o["frames"].items()} | |
| med = float(np.median(list(areas.values()))) | |
| bad, why = [], {"area_2x_median": 0, "over_40pct_of_image": 0, "on_instrument": 0} | |
| for f, a in sorted(areas.items()): | |
| r = [] | |
| if a > 2 * med: | |
| r.append("area_2x_median") | |
| if a > 0.4 * 720 * 576: | |
| r.append("over_40pct_of_image") | |
| tis = cv2.imread(str(out / "target_tissue" / "masks" / f"clip_{cid:02d}" / f"{f:05d}.png"), 0) == int(oid) | |
| inst = cv2.imread(str(pack / "dense_tracks" / "masks" / f"clip_{cid:02d}" / f"{f:05d}.png"), 0) > 0 | |
| if tis.sum() and (tis & inst).sum() / tis.sum() >= 0.5: | |
| r.append("on_instrument") | |
| if r: | |
| bad.append(f) | |
| for x in r: | |
| why[x] += 1 | |
| qual[f"clip_{cid:02d}/{oid}"] = {"name": o["name"], "frames_with_mask": len(areas), "median_area_px": int(med), | |
| "unreliable_frames": bad, "reasons": why, | |
| "status": "rejected" if len(bad) > 0.5 * len(areas) else "ok"} | |
| json.dump({"rules": ["area > 2 x median area of the object in the clip", "area > 40 % of the image", | |
| ">= 50 % of the mask on instrument masks"], | |
| "object_status": "rejected when more than half of its frames are flagged", "objects": qual}, | |
| open(out / "target_tissue" / "quality.json", "w"), indent=1) | |
| ok = [v for v in qual.values() if v["status"] == "ok"] | |
| print("tissue objects", len(qual), "ok", len(ok), "rejected", len(qual) - len(ok), | |
| "reliable frame-masks in ok objects", sum(v["frames_with_mask"] - len(v["unreliable_frames"]) for v in ok)) | |
| # timeline charts | |
| PAL = {} | |
| cmap = [(66, 135, 245), (245, 130, 48), (60, 180, 75), (230, 25, 75), (145, 30, 180), (70, 240, 240), | |
| (240, 50, 230), (210, 245, 60), (0, 128, 128), (170, 110, 40), (128, 0, 0), (0, 0, 128), (128, 128, 0), | |
| (255, 215, 180), (170, 255, 195), (128, 128, 128), (255, 225, 25), (0, 130, 200), (250, 190, 212), (60, 60, 60)] | |
| for i, v in enumerate(VERBS): | |
| PAL[v] = cmap[i % len(cmap)][::-1] | |
| for c in doc["clips"]: | |
| tracks = sorted({s["lane"] for s in c["segments"]}) | |
| Wd, lane, x0 = 1200, 60, 230 | |
| img = np.full((70 + lane * (len(tracks) + 1) + 40, Wd, 3), 255, np.uint8) | |
| n = c["end_frame"] - c["start_frame"] + 1 | |
| X = lambda f: int(x0 + (f - c["start_frame"]) / n * (Wd - x0 - 20)) | |
| cv2.putText(img, f"clip {c['clip_id']}: {c['visible_goal']}", (10, 28), 0, 0.6, (0, 0, 0), 1, cv2.LINE_AA) | |
| lanes = [(str(t), [s for s in c["segments"] if s["lane"] == t]) | |
| for t in tracks] + [("camera", c["camera_segments"])] | |
| for i, (name, segs) in enumerate(lanes): | |
| y = 50 + i * lane | |
| label = name if name == "camera" else f"{name} {c['objects'][name].split(' (')[0]}" | |
| cv2.putText(img, label[:28], (10, y + 32), 0, 0.5, (0, 0, 0), 1, cv2.LINE_AA) | |
| for s in segs: | |
| a, b = X(s["start_frame"]), X(s["end_frame"] + 1) | |
| col = PAL.get(s["verb"], (200, 200, 200)) | |
| cv2.rectangle(img, (a, y + 8), (b, y + lane - 8), col, -1) | |
| cv2.rectangle(img, (a, y + 8), (b, y + lane - 8), (255, 255, 255), 1) | |
| if b - a > 40: | |
| ink = (0, 0, 0) if 0.114 * col[0] + 0.587 * col[1] + 0.299 * col[2] > 150 else (255, 255, 255) | |
| cv2.putText(img, s["verb"], (a + 4, y + 34), 0, 0.42, ink, 1, cv2.LINE_AA) | |
| yb = 50 + len(lanes) * lane + 5 | |
| for f in range(c["start_frame"], c["end_frame"] + 2, 25): | |
| cv2.line(img, (X(f), yb), (X(f), yb + 6), (0, 0, 0), 1) | |
| cv2.putText(img, f"{f / 25:.0f}s", (X(f) - 10, yb + 22), 0, 0.4, (0, 0, 0), 1, cv2.LINE_AA) | |
| cv2.imwrite(str(out / f"timeline_clip_{c['clip_id']:02d}.png"), img) | |
| print("segments", sum(len(c["segments"]) for c in doc["clips"]), "per-frame rows", len(rows)) | |