Datasets:
Download annotated/scripts/14_showcase.py from hkust-aaron/laparoscopic-robotic-vision-sample: direct link, hf CLI and curl.
- Browser
- Download file 15.9 kB
-
https://huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample/resolve/main/annotated/scripts/14_showcase.py
- Command line
-
hf download hf://datasets/hkust-aaron/laparoscopic-robotic-vision-sample/annotated/scripts/14_showcase.py
-
curl -L -o 14_showcase.py https://huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample/resolve/main/annotated/scripts/14_showcase.py
15.9 kB
| """Presentation-quality showcase videos for the action-annotated clips (1280x720, H.264). | |
| Usage: python 14_showcase.py <pack_dir> [preview_frame] (needs ffmpeg; macOS system fonts) | |
| Same data as 13_action_demo.py, laid out for viewers rather than for checking: | |
| video on the left (1.25x), side panel with each instrument's current action, | |
| jaw / energy state and instruction, tissue legend, and an action timeline with a | |
| playhead. Masks are feathered and translucent, tip trails fade over 0.8 s. | |
| Writes layer5_actions/showcase/clip_XX.mp4, poster_clip_XX.jpg and showreel.mp4 | |
| (intro card, the three clips with title cards, closing card). | |
| With preview_frame, renders only that frame to showcase/preview.jpg. | |
| """ | |
| import csv | |
| import json | |
| import subprocess | |
| import sys | |
| from pathlib import Path | |
| import cv2 | |
| import numpy as np | |
| from PIL import Image, ImageDraw, ImageFont | |
| pack = Path(sys.argv[1]) | |
| PREVIEW = int(sys.argv[2]) if len(sys.argv) > 2 else None | |
| L5 = pack / "layer5_actions" | |
| OUT = L5 / "showcase" | |
| OUT.mkdir(exist_ok=True) | |
| W, H, VW, VH, S = 1280, 720, 900, 720, 1.25 # canvas, video area, scale from 720x576 | |
| FPS, TRAIL = 25, 20 | |
| SF, MONO = "/System/Library/Fonts/SFNS.ttf", "/System/Library/Fonts/SFNSMono.ttf" | |
| def font(size, weight="Regular", path=SF): | |
| f = ImageFont.truetype(path, size) | |
| f.set_variation_by_name(weight) | |
| return f | |
| F = {k: font(*v) for k, v in { | |
| "eyebrow": (11, "Semibold"), "title": (22, "Bold"), "goal": (15, "Regular"), "inst": (13, "Semibold"), | |
| "verb": (26, "Heavy"), "chip": (11, "Semibold"), "quote": (14, "Regular"), "small": (11, "Regular"), | |
| "tag": (12, "Semibold"), "big": (44, "Bold"), "card": (19, "Regular"), "cardsm": (15, "Regular")}.items()} | |
| F["mono"] = font(12, "Medium", MONO) | |
| BG, PANEL, LINE, TXT, MUTED, DIM = (12, 14, 19), (19, 22, 29), (40, 45, 56), (236, 239, 244), (150, 158, 172), (90, 97, 110) | |
| INST = {"dark_rod": ((245, 166, 35), "Dark rod"), "white_insulated_jawed": ((79, 195, 247), "Insulated jaws"), | |
| "fenestrated_grasper": ((102, 214, 120), "Fenestrated grasper"), "jawed instrument": ((79, 195, 247), "Jawed grasper"), | |
| "gauze": ((224, 64, 251), "Gauze"), "instrument_text_detected": ((170, 180, 200), "Instrument")} | |
| TISSUE = [(255, 122, 107), (46, 196, 182)] | |
| FAMILY = {"grasp": "hold", "hold": "hold", "regrasp": "hold", "open_jaws": "hold", "position": "hold", "release": "hold", | |
| "retract": "traction", "peel": "traction", "counter_traction": "traction", "lift_off": "traction", | |
| "blunt_dissect": "dissect", "coagulate": "dissect", "press": "contact", "probe": "contact", | |
| "transport": "move", "approach": "move", "enter": "move", "withdraw": "move", "sweep": "move", | |
| "absent": "absent", "inspect": "move"} | |
| FAM_COL = {"hold": (91, 141, 239), "traction": (157, 120, 245), "dissect": (239, 108, 87), "contact": (60, 196, 138), | |
| "move": (110, 119, 138), "absent": (34, 38, 48)} | |
| FAM_NAME = {"hold": "Grasp / hold", "traction": "Traction", "dissect": "Dissect / energy", "contact": "Contact", | |
| "move": "Move"} | |
| def inst_key(desc): | |
| return desc.split(" (")[0] | |
| def rr(d, box, r, fill=None, outline=None, width=1): | |
| d.rounded_rectangle(box, r, fill=fill, outline=outline, width=width) | |
| def wrap(d, text, f, width): | |
| lines, cur = [], "" | |
| for w in text.split(): | |
| t = (cur + " " + w).strip() | |
| if d.textlength(t, font=f) <= width: | |
| cur = t | |
| else: | |
| lines.append(cur) | |
| cur = w | |
| return lines + [cur] if cur else lines | |
| def chip(d, x, y, text, fg, bg): | |
| w = d.textlength(text, font=F["chip"]) + 16 | |
| rr(d, (x, y, x + w, y + 20), 10, fill=bg) | |
| d.text((x + 8, y + 3), text, font=F["chip"], fill=fg) | |
| return x + w + 6 | |
| def feather(mask, sigma=1.6): | |
| m = cv2.resize(mask.astype(np.float32), (VW, VH), interpolation=cv2.INTER_LINEAR) | |
| return cv2.GaussianBlur(m, (0, 0), sigma) | |
| def blend(img, alpha, col, a): | |
| k = (alpha * a)[..., None] | |
| img[:] = img * (1 - k) + np.array(col, np.float32) * k | |
| def outline(img, mask, col, a=0.95, width=2): | |
| m = (cv2.resize(mask.astype(np.uint8), (VW, VH), interpolation=cv2.INTER_LINEAR) > 0).astype(np.uint8) | |
| edge = cv2.morphologyEx(m, cv2.MORPH_GRADIENT, np.ones((width + 1, width + 1), np.uint8)).astype(np.float32) | |
| blend(img, cv2.GaussianBlur(edge, (0, 0), 0.8), col, a) | |
| tips = {} | |
| with open(pack / "layer4_tool_kinematics" / "tool_tips.csv") as fh: | |
| for r in csv.DictReader(fh): | |
| if r["tip_x_smooth"]: | |
| tips[(int(r["frame"]), int(r["track_id"]))] = (float(r["tip_x_smooth"]) * S, float(r["tip_y_smooth"]) * S) | |
| acts = json.load(open(L5 / "actions.json")) | |
| SHOWCASE = (5, 40, 43) # the clips rendered as videos | |
| acts["clips"] = [c for c in acts["clips"] if c["clip_id"] in SHOWCASE] | |
| unreliable = {k: set(v["unreliable_frames"]) for k, v in json.load(open(L5 / "target_tissue" / "quality.json"))["objects"].items()} | |
| cap = cv2.VideoCapture(str(pack / "video" / "laparoscopic_sample_001_intracorporeal.mp4")) | |
| def active(c, t, f): | |
| return [s for s in c["segments"] if s["start_frame"] <= f <= s["end_frame"] and | |
| s["lane"] == t] | |
| def render(c, f, dmeta, tmeta, tracks): | |
| cid = c["clip_id"] | |
| cap.set(cv2.CAP_PROP_POS_FRAMES, f) | |
| _, bgr = cap.read() | |
| img = cv2.resize(bgr, (VW, VH), interpolation=cv2.INTER_CUBIC)[..., ::-1].astype(np.float32) | |
| img *= 0.92 # slight dim so overlays read | |
| tis = cv2.imread(str(L5 / "target_tissue" / "masks" / f"clip_{cid:02d}" / f"{f:05d}.png"), 0) | |
| labels = [] | |
| for k, (oid, o) in enumerate(tmeta["objects"].items()): | |
| if f in unreliable[f"clip_{cid:02d}/{oid}"]: | |
| continue | |
| m = tis == int(oid) | |
| if m.sum() < 150: | |
| continue | |
| blend(img, feather(m, 2.5), TISSUE[k], 0.30) | |
| outline(img, m, TISSUE[k], 0.55, 1) | |
| dist = cv2.distanceTransform(m.astype(np.uint8), cv2.DIST_L2, 5) | |
| y, x = np.unravel_index(np.argmax(dist), dist.shape) | |
| labels.append((x * S, y * S, o["name"].replace("_", " "), TISSUE[k])) | |
| inst = cv2.imread(str(pack / "dense_tracks" / "masks" / f"clip_{cid:02d}" / f"{f:05d}.png"), 0) | |
| for tid in np.unique(inst)[1:]: | |
| cat = dmeta["tracks"][str(tid)]["category"] | |
| col = INST.get(cat, INST["instrument_text_detected"])[0] | |
| m = inst == tid | |
| blend(img, feather(m), col, 0.08 if cat == "gauze" else 0.12) | |
| outline(img, m, col, 0.6 if cat == "gauze" else 0.95, 2) | |
| # fading tip trails | |
| for t in tracks: | |
| col = INST[inst_key(c["objects"][str(t)])][0] | |
| alpha = np.zeros((VH, VW), np.float32) | |
| for g in range(f - TRAIL + 1, f + 1): | |
| a, b = tips.get((g - 1, t)), tips.get((g, t)) | |
| if a and b and np.hypot(a[0] - b[0], a[1] - b[1]) <= 50: | |
| w = (g - (f - TRAIL)) / TRAIL | |
| cv2.line(alpha, tuple(map(int, a)), tuple(map(int, b)), float(w), 3, cv2.LINE_AA) | |
| if alpha.any(): | |
| blend(img, np.clip(cv2.GaussianBlur(alpha, (0, 0), 4) * 1.2, 0, 1), col, 0.45) # glow | |
| blend(img, alpha, col, 1.0) | |
| canvas = Image.new("RGB", (W, H), BG) | |
| canvas.paste(Image.fromarray(img.astype(np.uint8)), (0, 0)) | |
| d = ImageDraw.Draw(canvas, "RGBA") | |
| for x, y, name, col in labels: # tissue tags | |
| tw = d.textlength(name, font=F["tag"]) | |
| rr(d, (x - tw / 2 - 9, y - 11, x + tw / 2 + 9, y + 11), 11, fill=(10, 12, 16, 170), outline=col + (200,)) | |
| d.text((x - tw / 2, y - 8), name, font=F["tag"], fill=TXT) | |
| for t in tracks: # tip markers + tags | |
| if (f, t) not in tips: | |
| continue | |
| x, y = tips[(f, t)] | |
| col = INST[inst_key(c["objects"][str(t)])][0] | |
| d.ellipse((x - 9, y - 9, x + 9, y + 9), outline=col + (120,), width=3) | |
| d.ellipse((x - 4, y - 4, x + 4, y + 4), fill=(255, 255, 255), outline=col, width=2) | |
| act = active(c, t, f) | |
| if act and act[0]["verb"] != "absent": | |
| txt = act[0]["verb"].replace("_", " ").upper() | |
| tw = d.textlength(txt, font=F["tag"]) | |
| tx, ty = min(x + 14, VW - tw - 24), max(y - 30, 8) | |
| rr(d, (tx, ty, tx + tw + 18, ty + 22), 11, fill=col + (230,)) | |
| d.text((tx + 9, ty + 3), txt, font=F["tag"], fill=(12, 14, 19)) | |
| rr(d, (14, 14, 210, 38), 12, fill=(10, 12, 16, 170)) # HUD | |
| d.text((26, 19), f"FRAME {f:05d} {int(f / FPS // 60)}:{f / FPS % 60:05.2f}", font=F["mono"], fill=TXT) | |
| # side panel | |
| d.rectangle((VW, 0, W, H), fill=PANEL) | |
| d.line((VW, 0, VW, H), fill=LINE) | |
| x0, x1 = VW + 24, W - 24 | |
| d.text((x0, 22), "SURGICAL ACTION DATA · SAMPLE", font=F["eyebrow"], fill=MUTED) | |
| t0 = c["start_frame"] / FPS | |
| d.text((x0, 42), f"Clip {cid} · {int(t0 // 60)}:{int(t0 % 60):02d}–{int((t0 + 10) // 60)}:{int((t0 + 10) % 60):02d}", | |
| font=F["title"], fill=TXT) | |
| y = 76 | |
| for ln in wrap(d, c["visible_goal"], F["goal"], x1 - x0)[:2]: | |
| d.text((x0, y), ln, font=F["goal"], fill=MUTED) | |
| y += 20 | |
| y += 10 | |
| for t in tracks: # instrument cards | |
| col, name = INST[inst_key(c["objects"][str(t)])] | |
| act = active(c, t, f) | |
| rr(d, (x0 - 8, y, x1 + 8, y + 150), 12, fill=(26, 30, 39), outline=LINE) | |
| d.rectangle((x0 - 8, y + 14, x0 - 5, y + 136), fill=col) | |
| d.text((x0 + 6, y + 12), f"{name.upper()} #{t}", font=F["inst"], fill=col) | |
| if not act or act[0]["verb"] == "absent": | |
| d.text((x0 + 6, y + 34), "OUT OF VIEW", font=F["verb"], fill=DIM) | |
| else: | |
| s = act[0] | |
| d.text((x0 + 6, y + 32), s["verb"].replace("_", " ").upper(), font=F["verb"], fill=TXT) | |
| cx = x0 + 6 | |
| if s["jaw_state"] not in ("n/a", "unknown"): | |
| cx = chip(d, cx, y + 68, "JAWS " + s["jaw_state"].upper().replace("->", " → "), TXT, (48, 54, 68)) | |
| if s["energy_visible"]: | |
| cx = chip(d, cx, y + 68, "ENERGY ON", (20, 10, 8), (255, 138, 76)) | |
| fam = FAMILY[s["verb"]] | |
| chip(d, cx, y + 68, FAM_NAME[fam].upper(), FAM_COL[fam], (36, 40, 52)) | |
| yy = y + 96 | |
| for ln in wrap(d, f"“{s['instruction']}”", F["quote"], x1 - x0 - 12)[:2]: | |
| d.text((x0 + 6, yy), ln, font=F["quote"], fill=(205, 210, 220)) | |
| yy += 19 | |
| y += 162 | |
| # tissue legend | |
| d.text((x0, y), "TARGET TISSUE", font=F["eyebrow"], fill=MUTED) | |
| y += 18 | |
| for k, o in enumerate(tmeta["objects"].values()): | |
| d.ellipse((x0, y + 4, x0 + 10, y + 14), fill=TISSUE[k]) | |
| d.text((x0 + 18, y + 1), o["name"].replace("_", " "), font=F["small"], fill=TXT) | |
| y += 18 | |
| # timeline | |
| ty0 = H - 128 | |
| d.text((x0, ty0), "ACTION TIMELINE", font=F["eyebrow"], fill=MUTED) | |
| n = c["end_frame"] - c["start_frame"] + 1 | |
| X = lambda g: x0 + (g - c["start_frame"]) / n * (x1 - x0) | |
| lanes = [(t, [s for s in c["segments"] if s["lane"] == t]) for t in tracks] | |
| for i, (t, segs) in enumerate(lanes): | |
| ly = ty0 + 20 + i * 22 | |
| col = INST[inst_key(c["objects"][str(t)])][0] | |
| rr(d, (x0, ly, x1, ly + 14), 4, fill=(30, 34, 44)) | |
| for s in segs: | |
| fc = FAM_COL[FAMILY[s["verb"]]] | |
| on = s["start_frame"] <= f <= s["end_frame"] | |
| rr(d, (X(s["start_frame"]) + 1, ly + 1, X(s["end_frame"] + 1) - 1, ly + 13), 3, | |
| fill=fc + ((255,) if on else (150,))) | |
| d.ellipse((x0 - 12, ly + 3, x0 - 4, ly + 11), fill=col) | |
| px = X(f) | |
| d.line((px, ty0 + 16, px, ty0 + 20 + len(lanes) * 22), fill=(255, 255, 255), width=2) | |
| ly = ty0 + 24 + len(lanes) * 22 | |
| lx = x0 | |
| for fam in ("hold", "traction", "dissect", "contact", "move"): | |
| d.rounded_rectangle((lx, ly + 3, lx + 8, ly + 11), 2, fill=FAM_COL[fam]) | |
| d.text((lx + 12, ly), FAM_NAME[fam], font=F["small"], fill=MUTED) | |
| lx += d.textlength(FAM_NAME[fam], font=F["small"]) + 24 | |
| d.text((x0, H - 24), "Physician-reviewed labels · SAM 3.1 masks", font=F["small"], fill=DIM) | |
| return canvas | |
| def card(lines, sub=None): | |
| im = Image.new("RGB", (W, H), BG) | |
| d = ImageDraw.Draw(im) | |
| y = H / 2 - 30 * len(lines) - (40 if sub else 0) | |
| for i, (txt, f, col) in enumerate(lines): | |
| tw = d.textlength(txt, font=F[f]) | |
| d.text(((W - tw) / 2, y), txt, font=F[f], fill=col) | |
| y += {"big": 64, "card": 34, "cardsm": 26, "eyebrow": 30}[f] | |
| if sub: | |
| y += 20 | |
| for ln in sub: | |
| tw = d.textlength(ln, font=F["cardsm"]) | |
| d.text(((W - tw) / 2, y), ln, font=F["cardsm"], fill=MUTED) | |
| y += 26 | |
| return im | |
| def write(path, frames_iter): | |
| ff = subprocess.Popen(["ffmpeg", "-y", "-loglevel", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{W}x{H}", | |
| "-r", str(FPS), "-i", "-", "-c:v", "libx264", "-preset", "slow", "-crf", "20", | |
| "-pix_fmt", "yuv420p", "-movflags", "+faststart", str(path)], stdin=subprocess.PIPE) | |
| for im in frames_iter: | |
| ff.stdin.write(np.asarray(im).tobytes()) | |
| ff.stdin.close() | |
| ff.wait() | |
| def fade(im, k): | |
| return Image.fromarray((np.asarray(im).astype(np.float32) * k + np.array(BG) * (1 - k)).astype(np.uint8)) | |
| def hold(im, sec, fade_in=True, fade_out=True): | |
| n = int(sec * FPS) | |
| for i in range(n): | |
| k = min(1, (i + 1) / 8 if fade_in else 1, (n - i) / 8 if fade_out else 1) | |
| yield fade(im, k) | |
| clips = [] | |
| for c in acts["clips"]: | |
| cid = c["clip_id"] | |
| dmeta = json.load(open(pack / "dense_tracks" / "tracks" / f"clip_{cid:02d}.json")) | |
| tmeta = json.load(open(L5 / "target_tissue" / "tracks" / f"clip_{cid:02d}.json")) | |
| tracks = sorted({s["lane"] for s in c["segments"]}) | |
| clips.append((c, dmeta, tmeta, tracks)) | |
| if PREVIEW is not None and c["start_frame"] <= PREVIEW <= c["end_frame"]: | |
| render(c, PREVIEW, dmeta, tmeta, tracks).save(OUT / "preview.jpg", quality=92) | |
| sys.exit(0) | |
| for c, dmeta, tmeta, tracks in clips: | |
| cid = c["clip_id"] | |
| frames = (render(c, f, dmeta, tmeta, tracks) for f in range(c["start_frame"], c["end_frame"] + 1)) | |
| write(OUT / f"clip_{cid:02d}.mp4", frames) | |
| mid = (c["start_frame"] + c["end_frame"]) // 2 | |
| poster = {5: 1300, 40: 10235, 43: 10840}.get(cid, mid) | |
| render(c, poster, dmeta, tmeta, tracks).save(OUT / f"poster_clip_{cid:02d}.jpg", quality=92) | |
| print("clip", cid, "done", flush=True) | |
| def reel(): | |
| intro = card([("LAPAROSCOPIC VIDEO → ACTION-LEVEL TRAINING DATA", "eyebrow", MUTED), | |
| ("Surgical action data sample", "big", TXT)], | |
| ["Instrument & tissue masks · tool-tip kinematics · action segments · surgeon-style instructions", | |
| "One recording, three 10-second clips"]) | |
| yield from hold(intro, 3.0) | |
| for c, dmeta, tmeta, tracks in clips: | |
| t = card([(f"CLIP {c['clip_id']}", "eyebrow", MUTED), (c["visible_goal"], "card", TXT)]) | |
| yield from hold(t, 1.6) | |
| cap_frames = [render(c, f, dmeta, tmeta, tracks) for f in range(c["start_frame"], c["end_frame"] + 1)] | |
| for i, im in enumerate(cap_frames): | |
| k = min(1, (i + 1) / 8, (len(cap_frames) - i) / 8) | |
| yield fade(im, k) if k < 1 else im | |
| outro = card([("WHAT EACH CLIP CARRIES", "eyebrow", MUTED), ("Per frame: masks, tool tips, active action", "card", TXT), | |
| ("Per segment: verb, target, jaw state, energy, instruction", "card", TXT)], | |
| ["Physician-reviewed labels · hand-held laparoscopy", | |
| "huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample"]) | |
| yield from hold(outro, 4.0) | |
| write(OUT / "showreel.mp4", reel()) | |
| print("showreel done") | |