| |
| """SAM3 常驻模型服务:启动时把 SAM3 video model 载入一次,之后跨视频复用。 |
| |
| 服务的 op: |
| - "masks": 进程内调 qwen_sam3_video_masks.main()(args.argv = 原 step2 CLI 参数列表) |
| - "shutdown" |
| |
| 载入一次的模型:SAM3 video model(默认 ckpt 由 step2 传入;Qwen 标签在 masks 模式走 API, |
| 无需常驻本地模型)。跑在 sam3 env: |
| python masking/sam3_server.py --queue <dir> |
| """ |
| import argparse |
| import json |
| import os |
| import sys |
| from pathlib import Path |
|
|
| os.environ.setdefault("PYOPENGL_PLATFORM", "egl") |
|
|
| _QWEN_DIR = Path(__file__).resolve().parent |
| _OVOW_ROOT = _QWEN_DIR.parent |
| _ENGINE_DIR = Path(os.environ.get("ENGINE_DIR", str(_OVOW_ROOT / "engine"))) |
| _SAM3_DIR = Path(os.environ.get("SAM3_DIR", str(_OVOW_ROOT / "third_party" / "sam3"))) |
| _IPC_DIR = str(_ENGINE_DIR / "tools" / "model_server") |
| for p in (_IPC_DIR, str(_QWEN_DIR)): |
| if p not in sys.path: |
| sys.path.insert(0, p) |
|
|
| import ipc |
|
|
| _DEFAULT_SAM3_CKPT = os.environ.get("SAM3_CKPT", str(_SAM3_DIR / "checkpoints" / "sam3" / "sam3.pt")) |
|
|
|
|
| def _warm_models(): |
| """一次性加载 SAM3 video model(常驻)。""" |
| print("[sam3-server] 加载 SAM3 video model(常驻)...", flush=True) |
| import qwen_sam3_video_masks as qsvm |
| qsvm.load_once(os.environ.get("SAM3_CKPT") or _DEFAULT_SAM3_CKPT) |
| print("[sam3-server] SAM3 ckpt 载入完成。", flush=True) |
|
|
|
|
| def _handle_masks(args): |
| """进程内单视频 mask 生成:复用常驻 SAM3,init_state 按视频新建。""" |
| import qwen_sam3_video_masks as qsvm |
| argv = args["argv"] |
| old = sys.argv |
| try: |
| sys.argv = ["qwen_sam3_video_masks.py"] + list(argv) |
| qsvm.main() |
| finally: |
| sys.argv = old |
| return {"video": args.get("video_name", "")} |
|
|
|
|
| def _as_bool_mask(mask): |
| import numpy as np |
|
|
| arr = np.asarray(mask) |
| arr = np.squeeze(arr) |
| if arr.ndim != 2: |
| raise RuntimeError(f"Unexpected SAM3 mask shape: {arr.shape}") |
| return arr > 0 |
|
|
|
|
| def _normalize_points(raw_points, width: int, height: int): |
| points = [] |
| labels = [] |
| for item in raw_points: |
| if isinstance(item, dict): |
| x = float(item.get("x", item.get("px", 0.0))) |
| y = float(item.get("y", item.get("py", 0.0))) |
| label = int(item.get("label", 1)) |
| else: |
| x = float(item[0]) |
| y = float(item[1]) |
| label = int(item[2]) if len(item) > 2 else 1 |
| if x > 1.0 or y > 1.0: |
| x = x / max(1, width) |
| y = y / max(1, height) |
| x = min(1.0, max(0.0, x)) |
| y = min(1.0, max(0.0, y)) |
| points.append([x, y]) |
| labels.append(1 if label else 0) |
| if not any(labels): |
| raise RuntimeError("manual SAM3 points need at least one positive point") |
| return points, labels |
|
|
|
|
| def _prime_empty_cached_outputs(inference_state, num_frames: int): |
| """Point prompts are tracker refinements; SAM3 expects a per-frame VG cache.""" |
| cached = inference_state.setdefault("cached_frame_outputs", {}) |
| for frame_idx in range(max(0, int(num_frames))): |
| cached.setdefault(frame_idx, {}) |
|
|
|
|
| def _collect_obj_masks(masks_by_frame: dict, frame_idx: int, out: dict | None, obj_id: int): |
| if out is None: |
| return |
| for oid, mask in zip(out.get("out_obj_ids", []), out.get("out_binary_masks", [])): |
| if int(oid) != obj_id: |
| continue |
| arr = _as_bool_mask(mask) |
| if int(arr.sum()) > 0: |
| masks_by_frame[int(frame_idx)] = arr |
|
|
|
|
| def _save_sparse_masks(obj_dir: Path, masks_by_frame: dict) -> None: |
| obj_dir.mkdir(parents=True, exist_ok=True) |
| from PIL import Image |
|
|
| for fid, mask in sorted(masks_by_frame.items()): |
| out = (_as_bool_mask(mask).astype("uint8") * 255) |
| Image.fromarray(out).save(obj_dir / f"frame_{int(fid):06d}.png") |
|
|
|
|
| def _click_boxes_from_points(points, point_labels, specs): |
| positives = [p for p, label in zip(points, point_labels) if int(label)] |
| if not positives: |
| raise RuntimeError("manual box prompt needs at least one positive point") |
| x, y = positives[-1] |
| boxes = [] |
| for spec in specs or []: |
| if isinstance(spec, dict): |
| bw = float(spec.get("w", spec.get("width", 0.55))) |
| bh = float(spec.get("h", spec.get("height", 0.45))) |
| else: |
| bw = float(spec[0]) |
| bh = float(spec[1] if len(spec) > 1 else spec[0]) |
| bw = min(0.98, max(0.03, bw)) |
| bh = min(0.98, max(0.03, bh)) |
| x0 = min(max(float(x) - bw * 0.5, 0.0), 1.0 - bw) |
| y0 = min(max(float(y) - bh * 0.5, 0.0), 1.0 - bh) |
| boxes.append([x0, y0, bw, bh]) |
| if not boxes: |
| raise RuntimeError("manual box prompt has no valid click box sizes") |
| return boxes |
|
|
|
|
| def _mask_has_point(mask, points, point_labels, radius: int = 4) -> bool: |
| positives = [p for p, label in zip(points, point_labels) if int(label)] |
| if not positives: |
| return False |
| h, w = mask.shape[:2] |
| for x_norm, y_norm in positives: |
| x = int(round(float(x_norm) * max(1, w - 1))) |
| y = int(round(float(y_norm) * max(1, h - 1))) |
| x0, x1 = max(0, x - radius), min(w, x + radius + 1) |
| y0, y1 = max(0, y - radius), min(h, y + radius + 1) |
| if bool(mask[y0:y1, x0:x1].any()): |
| return True |
| return False |
|
|
|
|
| def _select_prompt_object(out: dict | None, points, point_labels): |
| if out is None: |
| return None, None, 0 |
| best = None |
| for oid, mask in zip(out.get("out_obj_ids", []), out.get("out_binary_masks", [])): |
| arr = _as_bool_mask(mask) |
| area = int(arr.sum()) |
| if area <= 0: |
| continue |
| has_point = _mask_has_point(arr, points, point_labels) |
| score = (1 if has_point else 0, area) |
| if best is None or score > best[0]: |
| best = (score, int(oid), arr, area) |
| if best is None: |
| return None, None, 0 |
| return best[1], best[2], best[3] |
|
|
|
|
| def _next_object_name(mask_root: Path, label: str) -> str: |
| safe = label |
| idx = 1 |
| while (mask_root / f"{safe}_{idx:02d}").exists(): |
| idx += 1 |
| return f"{safe}_{idx:02d}" |
|
|
|
|
| def _append_unique(items, value): |
| if value not in items: |
| items.append(value) |
| return items |
|
|
|
|
| def _labels_per_keyframe_dict(payload: dict) -> dict: |
| out = {} |
| for key, values in (payload.get("labels_per_keyframe") or {}).items(): |
| try: |
| frame = int(key) |
| except (TypeError, ValueError): |
| continue |
| out[frame] = [str(v) for v in (values or [])] |
| return out |
|
|
|
|
| def _as_bool(value, default: bool = True) -> bool: |
| if value is None: |
| return default |
| if isinstance(value, bool): |
| return value |
| text = str(value).strip().lower() |
| if text in {"1", "true", "yes", "on"}: |
| return True |
| if text in {"0", "false", "no", "off"}: |
| return False |
| return default |
|
|
|
|
| def _commit_object_metadata( |
| *, output_root, video_path, video_name, num_frames, fps, width, height, |
| mask_root, obj_dir, obj_name, label, category, frame_idx, points, point_labels, |
| object_summary, args, |
| ): |
| """Upsert one manual object into labels_json / mask_summary / pipeline_config. |
| |
| Shared by the single-object and batch manual handlers so both emit identical |
| metadata (upsert-by-name, same schema the review UI + run_recon consume).""" |
| import qwen_sam3_video_masks as qsvm |
| meta_dir = output_root / "metadata" |
| labels_json = meta_dir / f"{video_name}_labels.json" |
| label_norm = qsvm._simple_normalize(label) |
| if labels_json.is_file(): |
| labels_payload = json.loads(labels_json.read_text(encoding="utf-8")) |
| else: |
| qsvm._write_labels_json( |
| labels_json, video_path, num_frames, fps, width, height, [], [], {}, |
| ) |
| labels_payload = json.loads(labels_json.read_text(encoding="utf-8")) |
| keyframes = [int(x) for x in (labels_payload.get("keyframes") or [])] |
| _append_unique(keyframes, int(frame_idx)) |
| labels = [str(x) for x in (labels_payload.get("labels") or [])] |
| _append_unique(labels, label) |
| labels_per_keyframe = _labels_per_keyframe_dict(labels_payload) |
| labels_per_keyframe.setdefault(int(frame_idx), []) |
| _append_unique(labels_per_keyframe[int(frame_idx)], label) |
| label_categories = dict(labels_payload.get("label_categories") or {}) |
| label_categories[label_norm] = category |
| labels_payload.update({ |
| "video": str(video_path), |
| "video_name": video_name, |
| "num_frames": int(num_frames), |
| "fps": float(fps), |
| "width": int(width), |
| "height": int(height), |
| "keyframes": sorted(keyframes), |
| "labels": labels, |
| "labels_per_keyframe": {str(k): v for k, v in sorted(labels_per_keyframe.items())}, |
| "label_categories": label_categories, |
| }) |
| labels_payload["label_category_source"] = "manual_click" |
| manual_points = list(labels_payload.get("manual_points") or []) |
| manual_points.append({ |
| "object": obj_name, |
| "label": label, |
| "points": points, |
| "point_labels": point_labels, |
| "frame_idx": frame_idx, |
| }) |
| labels_payload["manual_points"] = manual_points |
| labels_json.write_text(json.dumps(labels_payload, indent=2), encoding="utf-8") |
|
|
| objects_summary = [object_summary] |
| summary_path = meta_dir / f"{video_name}_mask_summary.json" |
| meta_dir.mkdir(parents=True, exist_ok=True) |
| if summary_path.is_file(): |
| summary = json.loads(summary_path.read_text(encoding="utf-8")) |
| else: |
| summary = { |
| "video": str(video_path), |
| "video_name": video_name, |
| "num_frames": int(num_frames), |
| "fps": float(fps), |
| "width": int(width), |
| "height": int(height), |
| "keyframes": [], |
| "labels": [], |
| "labels_per_keyframe": {}, |
| "moving_labels": [], |
| "objects": [], |
| "mask_root": str(mask_root), |
| "labels_json": str(labels_json), |
| "qwen_label_category_mode": "manual_click", |
| "label_category_source": "manual_click", |
| "label_categories": {}, |
| "label_category_reasons": {}, |
| "label_visual_descriptions": {}, |
| "label_prompt_aliases": {}, |
| } |
| summary.update({ |
| "video": str(video_path), |
| "video_name": video_name, |
| "num_frames": int(num_frames), |
| "fps": float(fps), |
| "width": int(width), |
| "height": int(height), |
| "mask_root": str(mask_root), |
| "labels_json": str(labels_json), |
| "qwen_label_category_mode": "manual_click", |
| "label_category_source": "manual_click", |
| }) |
| keyframes = [int(x) for x in (summary.get("keyframes") or [])] |
| _append_unique(keyframes, int(frame_idx)) |
| labels = [str(x) for x in (summary.get("labels") or [])] |
| _append_unique(labels, label) |
| labels_per_keyframe = _labels_per_keyframe_dict(summary) |
| labels_per_keyframe.setdefault(int(frame_idx), []) |
| _append_unique(labels_per_keyframe[int(frame_idx)], label) |
| moving_labels = [str(x) for x in (summary.get("moving_labels") or [])] |
| if category in {"rigid", "deform"}: |
| _append_unique(moving_labels, label) |
| else: |
| moving_labels = [x for x in moving_labels if x != label] |
| label_categories = dict(summary.get("label_categories") or {}) |
| label_categories[label_norm] = category |
| existing_objects = [ |
| obj for obj in (summary.get("objects") or []) |
| if str(obj.get("name", "")) != obj_name |
| ] |
| summary["keyframes"] = sorted(keyframes) |
| summary["labels"] = labels |
| summary["labels_per_keyframe"] = {str(k): v for k, v in sorted(labels_per_keyframe.items())} |
| summary["moving_labels"] = moving_labels |
| summary["label_categories"] = label_categories |
| summary["objects"] = existing_objects + objects_summary |
| summary_path.write_text(json.dumps(summary, indent=2), encoding="utf-8") |
|
|
| recon_root = output_root / "recon_ready" / video_name |
| recon_root.mkdir(parents=True, exist_ok=True) |
| batch_config = args.get("batch_config") or str(_ENGINE_DIR / "config" / "batch_config_example_legacy.json") |
| cfg_path = recon_root / "pipeline_config.json" |
| if cfg_path.is_file(): |
| pipeline_cfg = json.loads(cfg_path.read_text(encoding="utf-8")) |
| else: |
| pipeline_cfg = { |
| "batch_config": str(Path(batch_config).resolve()), |
| "video_path": str(video_path), |
| "output_root": str(output_root), |
| "mask_glob": "frame_*.png", |
| "tracker_mask_mode": "static", |
| "objects": [], |
| } |
| pipeline_cfg.update({ |
| "batch_config": str(Path(pipeline_cfg.get("batch_config") or batch_config).resolve()), |
| "video_path": str(video_path), |
| "output_root": str(output_root), |
| "mask_glob": "frame_*.png", |
| "tracker_mask_mode": "static", |
| }) |
| existing_cfg_objects = [ |
| obj for obj in (pipeline_cfg.get("objects") or []) |
| if str(obj.get("name", "")) != obj_name |
| ] |
| existing_cfg_objects.append({ |
| "name": obj_name, |
| "masks_dir": str(obj_dir), |
| "category": category, |
| }) |
| pipeline_cfg["objects"] = existing_cfg_objects |
| cfg_path.write_text(json.dumps(pipeline_cfg, indent=2), encoding="utf-8") |
|
|
| return { |
| "video": video_name, |
| "object": obj_name, |
| "category": category, |
| "frames_with_mask": int(object_summary.get("frames_with_mask", 0)), |
| "summary": str(summary_path), |
| "pipeline_config": str(cfg_path), |
| } |
|
|
|
|
| def _handle_manual_points_batch(args): |
| """Segment several manually-clicked objects in ONE video pass. |
| |
| A single click only masks one frame; every object still needs its mask propagated |
| across the whole video (Motion324 wants every frame; the scene animation gates each |
| object's visibility on masked frames). Running one ``manual_points`` request per object |
| re-encodes all video frames each time (~50s each) because SAM3 evicts per-frame features |
| as it propagates (sliding window). Here we point-prompt every object into ONE |
| ``inference_state`` (distinct obj_ids) and propagate once per prompt-frame group, so each |
| frame's image features are computed once and shared by every object's tracker at that |
| frame → ~N× faster. Instance identity is preserved: each obj_id yields its own binary |
| mask written to its own ``masks/<video>/<obj>`` dir; masks are never merged.""" |
| import numpy as np |
| import qwen_sam3_video_masks as qsvm |
|
|
| video_path = Path(args["video_path"]).resolve() |
| output_root = Path(args["output_root"]).resolve() |
| objects_in = list(args.get("objects") or []) |
| if not objects_in: |
| raise RuntimeError("manual_points_batch needs a non-empty 'objects' list") |
| min_obj_area = int(args.get("min_obj_area", 200)) |
| num_frames, fps, width, height = qsvm._video_info(video_path) |
| video_name = video_path.stem |
| mask_root = output_root / "masks" / video_name |
|
|
| sam3_model, _ = qsvm.load_once(args.get("sam3_ckpt") or os.environ.get("SAM3_CKPT") or _DEFAULT_SAM3_CKPT) |
| inference_state = sam3_model.init_state(resource_path=str(video_path)) |
|
|
| specs = [] |
| for i, obj in enumerate(objects_in, start=1): |
| label = str(obj.get("label") or "object").strip() or "object" |
| category = str(obj.get("category") or "rigid").strip().lower() |
| if category not in {"static", "rigid", "deform"}: |
| raise RuntimeError(f"invalid manual category: {category}") |
| frame_idx = min(max(0, int(obj.get("frame_idx", 0))), max(0, num_frames - 1)) |
| pts, plabels = _normalize_points(obj.get("points") or [], width, height) |
| name = str(obj.get("object_name") or "").strip() or _next_object_name(mask_root, qsvm._safe_id(label)) |
| specs.append({ |
| "obj_id": i, "label": label, "category": category, "frame_idx": frame_idx, |
| "points": pts, "point_labels": plabels, "object_name": name, |
| "masks_by_frame": {}, |
| }) |
|
|
| by_id = {s["obj_id"]: s for s in specs} |
|
|
| frames = sorted({s["frame_idx"] for s in specs}) |
| for gi, gframe in enumerate(frames): |
| group = [s for s in specs if s["frame_idx"] == gframe] |
| if gi > 0: |
| sam3_model.reset_state(inference_state) |
| _prime_empty_cached_outputs(inference_state, num_frames) |
| for s in group: |
| _, prompt_out = sam3_model.add_prompt( |
| inference_state, |
| frame_idx=gframe, |
| points=s["points"], |
| point_labels=s["point_labels"], |
| obj_id=s["obj_id"], |
| ) |
| _collect_obj_masks(s["masks_by_frame"], gframe, prompt_out, s["obj_id"]) |
| group_ids = {s["obj_id"] for s in group} |
| directions = [False] + ([True] if gframe > 0 else []) |
| for reverse in directions: |
| for fid, out in sam3_model.propagate_in_video( |
| inference_state, |
| start_frame_idx=gframe, |
| max_frame_num_to_track=num_frames, |
| reverse=reverse, |
| ): |
| if out is None: |
| continue |
| for oid in group_ids: |
| _collect_obj_masks(by_id[oid]["masks_by_frame"], fid, out, oid) |
|
|
| results = [] |
| for s in specs: |
| masks_by_frame = s["masks_by_frame"] |
| if not masks_by_frame: |
| results.append({"object": s["object_name"], "error": "no mask; refine click points"}) |
| continue |
| max_area = max(int(m.sum()) for m in masks_by_frame.values()) |
| if max_area < min_obj_area: |
| results.append({"object": s["object_name"], |
| "error": f"mask too small: {max_area} < {min_obj_area}"}) |
| continue |
| obj_dir = mask_root / s["object_name"] |
| qsvm._save_masks(obj_dir, num_frames, masks_by_frame) |
| is_static, med_iou, med_motion, valid_frames, occluded_frames, area_med = qsvm._classify_static( |
| masks_by_frame, |
| static_iou_thresh=float(args.get("static_iou_thresh", 0.6)), |
| static_motion_px=float(args.get("static_motion_px", 10.0)), |
| occlusion_area_ratio=float(args.get("occlusion_area_ratio", 0.6)), |
| min_valid_frames=int(args.get("min_valid_frames", 10)), |
| high_iou_thresh=float(args.get("high_iou_static", 0.8)), |
| high_iou_motion_mult=float(args.get("high_iou_motion_mult", 3.0)), |
| ) |
| category = s["category"] |
| object_summary = { |
| "name": s["object_name"], |
| "label": s["label"], |
| "sam3_obj_id": s["obj_id"], |
| "frames_with_mask": len(masks_by_frame), |
| "max_area": int(max_area), |
| "median_area": float(area_med), |
| "valid_frames": int(valid_frames), |
| "occluded_frames": int(occluded_frames), |
| "median_iou": float(med_iou), |
| "median_motion_px": float(med_motion), |
| "is_static": category == "static" or bool(is_static and category == "static"), |
| "category": category, |
| "category_source": "manual_click", |
| "force_static": category == "static", |
| "force_dynamic": category in {"rigid", "deform"}, |
| "prompt_frame": int(s["frame_idx"]), |
| "prompt_mode": "points", |
| "prompt_box_xywh": None, |
| "manual_points": s["points"], |
| "manual_point_labels": s["point_labels"], |
| } |
| res = _commit_object_metadata( |
| output_root=output_root, video_path=video_path, video_name=video_name, |
| num_frames=num_frames, fps=fps, width=width, height=height, |
| mask_root=mask_root, obj_dir=obj_dir, obj_name=s["object_name"], |
| label=s["label"], category=category, frame_idx=s["frame_idx"], |
| points=s["points"], point_labels=s["point_labels"], |
| object_summary=object_summary, args=args, |
| ) |
| results.append(res) |
|
|
| return {"video": video_name, "num_frames": int(num_frames), "objects": results} |
|
|
|
|
| def _handle_manual_points(args): |
| """Point-prompt SAM3 masks for Gradio manual mode; writes OVOW mask summary/config.""" |
| import numpy as np |
| import qwen_sam3_video_masks as qsvm |
|
|
| video_path = Path(args["video_path"]).resolve() |
| output_root = Path(args["output_root"]).resolve() |
| label = str(args.get("label") or "object").strip() or "object" |
| category = str(args.get("category") or "rigid").strip().lower() |
| if category not in {"static", "rigid", "deform"}: |
| raise RuntimeError(f"invalid manual category: {category}") |
| commit = _as_bool(args.get("commit"), True) |
|
|
| num_frames, fps, width, height = qsvm._video_info(video_path) |
| frame_idx = int(args.get("frame_idx", 0)) |
| frame_idx = min(max(0, frame_idx), max(0, num_frames - 1)) |
| min_obj_area = int(args.get("min_obj_area", 200)) |
| points, point_labels = _normalize_points(args.get("points") or [], width, height) |
|
|
| sam3_model, _ = qsvm.load_once(args.get("sam3_ckpt") or os.environ.get("SAM3_CKPT") or _DEFAULT_SAM3_CKPT) |
| inference_state = None |
| requested_mode = str(args.get("prompt_mode") or "points").strip().lower() |
| prompt_mode = "box" if requested_mode in {"box", "click_box", "visual_box"} else "points" |
| masks_by_frame = {} |
| prompt_box = None |
| obj_id = int(args.get("obj_id", 1)) |
| if prompt_mode == "box": |
| prompt_out = None |
| for prompt_box in _click_boxes_from_points( |
| points, |
| point_labels, |
| args.get("click_boxes") or [[0.55, 0.45], [0.75, 0.60]], |
| ): |
| inference_state = sam3_model.init_state(resource_path=str(video_path)) |
| prompt_frame, prompt_out = sam3_model.add_prompt( |
| inference_state, |
| frame_idx=frame_idx, |
| boxes_xywh=[prompt_box], |
| box_labels=[1], |
| ) |
| selected_obj_id, selected_mask, selected_area = _select_prompt_object( |
| prompt_out, |
| points, |
| point_labels, |
| ) |
| if selected_obj_id is None: |
| continue |
| obj_id = int(selected_obj_id) |
| masks_by_frame = {int(prompt_frame): selected_mask} |
| if int(selected_area) >= min_obj_area: |
| break |
| else: |
| inference_state = sam3_model.init_state(resource_path=str(video_path)) |
| _prime_empty_cached_outputs(inference_state, num_frames) |
| prompt_frame, prompt_out = sam3_model.add_prompt( |
| inference_state, |
| frame_idx=frame_idx, |
| points=points, |
| point_labels=point_labels, |
| obj_id=obj_id, |
| ) |
| _collect_obj_masks(masks_by_frame, prompt_frame, prompt_out, obj_id) |
|
|
| if commit: |
| directions = [False] |
| if frame_idx > 0: |
| directions.append(True) |
| for reverse in directions: |
| for fid, out in sam3_model.propagate_in_video( |
| inference_state, |
| start_frame_idx=frame_idx, |
| max_frame_num_to_track=num_frames, |
| reverse=reverse, |
| ): |
| if out is None: |
| continue |
| _collect_obj_masks(masks_by_frame, fid, out, obj_id) |
|
|
| if not masks_by_frame: |
| raise RuntimeError("manual SAM3 produced no mask; add/refine click points") |
| max_area = max(int(m.sum()) for m in masks_by_frame.values()) |
| if max_area < min_obj_area: |
| raise RuntimeError( |
| f"manual SAM3 mask too small: max_area={max_area}, min_obj_area={min_obj_area}" |
| ) |
|
|
| video_name = video_path.stem |
| mask_root = output_root / "masks" / video_name |
| pending_root = output_root / "_pending" / video_name |
| safe_label = qsvm._safe_id(label) |
| obj_name = str(args.get("object_name") or "").strip() or _next_object_name(mask_root, safe_label) |
| obj_dir = (mask_root if commit else pending_root) / obj_name |
| if commit: |
| qsvm._save_masks(obj_dir, num_frames, masks_by_frame) |
| else: |
| _save_sparse_masks(obj_dir, masks_by_frame) |
|
|
| is_static, med_iou, med_motion, valid_frames, occluded_frames, area_med = qsvm._classify_static( |
| masks_by_frame, |
| static_iou_thresh=float(args.get("static_iou_thresh", 0.6)), |
| static_motion_px=float(args.get("static_motion_px", 10.0)), |
| occlusion_area_ratio=float(args.get("occlusion_area_ratio", 0.6)), |
| min_valid_frames=int(args.get("min_valid_frames", 10)), |
| high_iou_thresh=float(args.get("high_iou_static", 0.8)), |
| high_iou_motion_mult=float(args.get("high_iou_motion_mult", 3.0)), |
| ) |
| object_summary = { |
| "name": obj_name, |
| "label": label, |
| "sam3_obj_id": obj_id, |
| "frames_with_mask": len(masks_by_frame), |
| "max_area": int(max_area), |
| "median_area": float(area_med), |
| "valid_frames": int(valid_frames), |
| "occluded_frames": int(occluded_frames), |
| "median_iou": float(med_iou), |
| "median_motion_px": float(med_motion), |
| "is_static": category == "static" or bool(is_static and category == "static"), |
| "category": category, |
| "category_source": "manual_click", |
| "force_static": category == "static", |
| "force_dynamic": category in {"rigid", "deform"}, |
| "prompt_frame": int(frame_idx), |
| "prompt_mode": prompt_mode, |
| "prompt_box_xywh": prompt_box, |
| "manual_points": points, |
| "manual_point_labels": point_labels, |
| } |
|
|
| if not commit: |
| return { |
| "video": video_name, |
| "object": obj_name, |
| "label": label, |
| "category": category, |
| "frames_with_mask": len(masks_by_frame), |
| "max_area": int(max_area), |
| "masks_dir": str(obj_dir), |
| "prompt_frame": int(frame_idx), |
| "num_frames": int(num_frames), |
| "fps": float(fps), |
| "width": int(width), |
| "height": int(height), |
| "object_summary": object_summary, |
| } |
|
|
| return _commit_object_metadata( |
| output_root=output_root, |
| video_path=video_path, |
| video_name=video_name, |
| num_frames=num_frames, |
| fps=fps, |
| width=width, |
| height=height, |
| mask_root=mask_root, |
| obj_dir=obj_dir, |
| obj_name=obj_name, |
| label=label, |
| category=category, |
| frame_idx=frame_idx, |
| points=points, |
| point_labels=point_labels, |
| object_summary=object_summary, |
| args=args, |
| ) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--queue", required=True, help="请求队列目录") |
| args = ap.parse_args() |
| handlers = { |
| "masks": _handle_masks, |
| "manual_points": _handle_manual_points, |
| "manual_points_batch": _handle_manual_points_batch, |
| } |
| ipc.server_loop(args.queue, handlers, on_start=_warm_models) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
