| |
| """ |
| 读取 scene.json（包含 objects + prompt），调用 GroundingDINO + SAM2 分割每个物体， |
| 按 object 的 id 命名 mask 文件，写入 masks/，并回填 scene.json 的 mask 字段。 |
| |
| 示例： |
| conda activate qwen |
| python Grounded_SAM2/qwen/grsam_from_scene_json.py \ |
| --scene-dir data_pose/scenes/scene_12 |
| """ |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import List, Optional, Tuple |
|
|
| import cv2 |
| import numpy as np |
| import torch |
| from PIL import Image |
| from torchvision import transforms as TF |
| from torchvision.ops import box_convert |
|
|
| from sam2.build_sam import build_sam2 |
| from sam2.sam2_image_predictor import SAM2ImagePredictor |
| from grounding_dino.groundingdino.util.inference import load_model, predict |
|
|
|
|
| def find_single_image_file(scene_dir: Path) -> Optional[str]: |
| exts = {".jpg", ".jpeg", ".png", ".JPG", ".JPEG", ".PNG"} |
| candidates = [p.name for p in scene_dir.iterdir() if p.is_file() and p.suffix in exts] |
| if len(candidates) == 1: |
| return candidates[0] |
| return None |
|
|
|
|
| def load_image_for_models(image_path: Path, mode: str = "crop"): |
| """与 segment.py 一致的预处理：宽度 518px，保持长宽比并根据模式裁剪/填充。""" |
| if mode not in ("crop", "pad"): |
| raise ValueError("mode 必须是 'crop' 或 'pad'") |
|
|
| img = Image.open(image_path) |
| if img.mode == "RGBA": |
| bg = Image.new("RGBA", img.size, (255, 255, 255, 255)) |
| img = Image.alpha_composite(bg, img) |
| img = img.convert("RGB") |
|
|
| target_size = 518 |
| to_tensor = TF.ToTensor() |
| width, height = img.size |
|
|
| if mode == "pad": |
| if width >= height: |
| new_width = target_size |
| new_height = round(height * (new_width / width) / 14) * 14 |
| else: |
| new_height = target_size |
| new_width = round(width * (new_height / height) / 14) * 14 |
| else: |
| new_width = target_size |
| new_height = round(height * (new_width / width) / 14) * 14 |
|
|
| img = img.resize((new_width, new_height), Image.Resampling.BICUBIC) |
| img_tensor = to_tensor(img) |
|
|
| if mode == "crop" and new_height > target_size: |
| start_y = (new_height - target_size) // 2 |
| img_tensor = img_tensor[:, start_y : start_y + target_size, :] |
|
|
| if mode == "pad": |
| h_padding = target_size - img_tensor.shape[1] |
| w_padding = target_size - img_tensor.shape[2] |
| if h_padding > 0 or w_padding > 0: |
| pad_top = h_padding // 2 |
| pad_bottom = h_padding - pad_top |
| pad_left = w_padding // 2 |
| pad_right = w_padding - pad_left |
| img_tensor = torch.nn.functional.pad( |
| img_tensor, |
| (pad_left, pad_right, pad_top, pad_bottom), |
| mode="constant", |
| value=1.0, |
| ) |
|
|
| image_tensor = img_tensor |
| image_np = (image_tensor.permute(1, 2, 0).numpy() * 255).astype(np.uint8) |
| image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR) |
| h, w = image_tensor.shape[1], image_tensor.shape[2] |
| return image_tensor, image_bgr, h, w |
|
|
|
|
| def ensure_mask_dir(scene_dir: Path, mask_dir_name: str) -> Path: |
| mask_dir = scene_dir / mask_dir_name |
| mask_dir.mkdir(parents=True, exist_ok=True) |
| return mask_dir |
|
|
|
|
| def parse_scene_spec(spec: str) -> List[int]: |
| ids: List[int] = [] |
| for chunk in spec.split(","): |
| chunk = chunk.strip() |
| if not chunk: |
| continue |
| if "-" in chunk: |
| a, b = chunk.split("-", 1) |
| start, end = int(a), int(b) |
| if end < start: |
| start, end = end, start |
| ids.extend(range(start, end + 1)) |
| else: |
| ids.append(int(chunk)) |
| return sorted(set(ids)) |
|
|
|
|
| def normalize_phrase(text: str) -> str: |
| """小写并去掉尾部标点，便于匹配 GDINO 返回的 label。""" |
| t = text.strip().lower() |
| while t.endswith((".", ",", ";", " ")): |
| t = t[:-1] |
| return t |
|
|
|
|
| def build_joint_caption(objects: List[dict]) -> Tuple[str, List[str]]: |
| """ |
| 把所有 object.prompt 拼成一个 GDINO caption，并返回标准化后的子句列表。 |
| - 子句形如 "red car on the road" |
| - caption 形如 "red car on the road. house on the left." |
| """ |
| clauses = [] |
| for obj in objects: |
| p = obj.get("prompt") or obj.get("name") or "" |
| p = p.strip() |
| if not p: |
| continue |
| clauses.append(p) |
| normalized_clauses = [normalize_phrase(c) for c in clauses] |
| caption = ". ".join(normalized_clauses) |
| if not caption.endswith("."): |
| caption += "." |
| return caption, normalized_clauses |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description="Grounded SAM2 根据 scene.json 的 prompt 分割物体并写回 mask 路径" |
| ) |
| parser.add_argument( |
| "--scene-dir", |
| type=Path, |
| help="单个 scene 目录", |
| ) |
| parser.add_argument( |
| "--scene-range", |
| type=str, |
| help='批量模式，形如 "1-4,6,8"（按 scene_{:02d} 命名）', |
| ) |
| parser.add_argument( |
| "--root-dir", |
| type=Path, |
| default=Path(__file__).resolve().parents[2] / "data_pose" / "scenes", |
| help="场景根目录（默认 data_pose/scenes）", |
| ) |
| parser.add_argument( |
| "--sam2-ckpt", |
| type=Path, |
| default=Path("checkpoints/sam2.1_hiera_large.pt"), |
| help="SAM2 checkpoint 路径", |
| ) |
| parser.add_argument( |
| "--sam2-config", |
| type=Path, |
| default=Path("configs/sam2.1/sam2.1_hiera_l.yaml"), |
| help="SAM2 config 路径", |
| ) |
| parser.add_argument( |
| "--gdino-config", |
| type=Path, |
| default=Path("grounding_dino/groundingdino/config/GroundingDINO_SwinB_cfg.py"), |
| help="GroundingDINO 配置", |
| ) |
| parser.add_argument( |
| "--gdino-ckpt", |
| type=Path, |
| default=Path("gdino_checkpoints/groundingdino_swinb_cogcoor.pth"), |
| help="GroundingDINO checkpoint", |
| ) |
| parser.add_argument( |
| "--box-threshold", |
| type=float, |
| default=0.2, |
| help="GroundingDINO box threshold", |
| ) |
| parser.add_argument( |
| "--text-threshold", |
| type=float, |
| default=0.2, |
| help="GroundingDINO text threshold", |
| ) |
| parser.add_argument( |
| "--mask-dir-name", |
| type=str, |
| default="masks", |
| help="mask 输出目录名（相对 scene_dir）", |
| ) |
| parser.add_argument( |
| "--per-object", |
| action="store_true", |
| help="逐物体调用 GDINO/SAM2（默认关闭，使用一次性拼接 caption 的模式）", |
| ) |
| parser.add_argument( |
| "--dump-preprocessed", |
| action="store_true", |
| help="保存预处理后的检测输入，便于调试（默认关闭）", |
| ) |
|
|
| args = parser.parse_args() |
|
|
| scene_dirs: List[Path] = [] |
| if args.scene_dir: |
| scene_dirs = [args.scene_dir.resolve()] |
| if args.scene_range: |
| for sid in parse_scene_spec(args.scene_range): |
| scene_dirs.append(args.root_dir / f"scene_{sid:02d}") |
| if not scene_dirs: |
| raise ValueError("必须提供 --scene-dir 或 --scene-range") |
|
|
| device = "cuda" if torch.cuda.is_available() else "cpu" |
| gdino = load_model( |
| model_config_path=str(args.gdino_config), |
| model_checkpoint_path=str(args.gdino_ckpt), |
| device=device, |
| ).to(device) |
| sam2_model = build_sam2( |
| str(args.sam2_config), |
| str(args.sam2_ckpt), |
| device=device, |
| ).to(device) |
| sam2_predictor = SAM2ImagePredictor(sam2_model) |
|
|
| for scene_dir in scene_dirs: |
| if not scene_dir.is_dir(): |
| print(f"[WARN] scene 目录不存在，跳过: {scene_dir}") |
| continue |
|
|
| scene_json = scene_dir / "scene.json" |
| if not scene_json.is_file(): |
| print(f"[WARN] scene.json 不存在，跳过: {scene_json}") |
| continue |
|
|
| with scene_json.open("r", encoding="utf-8") as f: |
| data = json.load(f) |
|
|
| image_name = data.get("image") or find_single_image_file(scene_dir) |
| if not image_name: |
| print(f"[WARN] 未找到场景图片，跳过: {scene_dir}") |
| continue |
| image_path = scene_dir / image_name |
| if not image_path.is_file(): |
| print(f"[WARN] 场景图片不存在，跳过: {image_path}") |
| continue |
|
|
| objects = data.get("objects", []) |
| if not objects: |
| print(f"[WARN] {scene_dir} objects 为空，未执行分割。") |
| continue |
|
|
| image_tensor, image_bgr, h, w = load_image_for_models(image_path) |
| if args.dump_preprocessed: |
| debug_dir = scene_dir / "debug_inputs" |
| debug_dir.mkdir(exist_ok=True, parents=True) |
| dump_name = debug_dir / f"{scene_dir.name}_{image_path.stem}_preprocessed.png" |
| cv2.imwrite(str(dump_name), image_bgr) |
| print(f"[DEBUG] 已保存预处理图像: {dump_name}") |
| sam2_predictor.set_image(image_bgr) |
|
|
| mask_dir = ensure_mask_dir(scene_dir, args.mask_dir_name) |
|
|
| print(f"\n===== 处理 {scene_dir.name} =====") |
|
|
| if args.per_object: |
| for idx, obj in enumerate(objects): |
| prompt = obj.get("prompt") or obj.get("name") |
| if not prompt: |
| print(f"[WARN] object[{idx}] 缺少 prompt/name，跳过") |
| continue |
|
|
| print(f"[PROMPT][per-object] idx={idx}: {prompt}") |
|
|
| caption = prompt.lower().strip() |
| if not caption.endswith("."): |
| caption = caption + "." |
|
|
| print(caption) |
| |
| boxes, confidences, labels = predict( |
| model=gdino, |
| image=image_tensor, |
| caption=caption, |
| box_threshold=args.box_threshold, |
| text_threshold=args.text_threshold, |
| device=device, |
| ) |
| if boxes is None or len(boxes) == 0: |
| print(f"[WARN] GroundingDINO 未检测到：{prompt}") |
| continue |
|
|
| best_idx = int(torch.argmax(confidences).item()) |
| box = boxes[best_idx].to(device) |
| box = box * torch.tensor([w, h, w, h], device=box.device) |
| box_xyxy = ( |
| box_convert(boxes=box.unsqueeze(0), in_fmt="cxcywh", out_fmt="xyxy") |
| .cpu() |
| .numpy() |
| ) |
|
|
| masks, scores, _ = sam2_predictor.predict( |
| point_coords=None, |
| point_labels=None, |
| box=box_xyxy, |
| multimask_output=False, |
| ) |
| mask = masks[0].astype(np.uint8) * 255 |
|
|
| obj_id = obj.get("id") or f"obj{idx+1}" |
| mask_rel = obj.get("mask") or f"{args.mask_dir_name}/{obj_id}.png" |
| mask_path = scene_dir / mask_rel |
| mask_path.parent.mkdir(parents=True, exist_ok=True) |
| cv2.imwrite(str(mask_path), mask) |
|
|
| obj["id"] = obj_id |
| obj["mask"] = str(mask_rel) |
|
|
| print(f"[OK] {prompt} -> {mask_rel}") |
|
|
| else: |
| caption, clauses = build_joint_caption(objects) |
| if not caption.strip(): |
| print(f"[WARN] 无有效 prompt，跳过 {scene_dir}") |
| continue |
|
|
| print(f"[PROMPT][joint] caption: {caption}") |
|
|
| boxes, confidences, labels = predict( |
| model=gdino, |
| image=image_tensor, |
| caption=caption, |
| box_threshold=args.box_threshold, |
| text_threshold=args.text_threshold, |
| device=device, |
| ) |
| if boxes is None or len(boxes) == 0: |
| print(f"[WARN] GDINO 未检测到任何框，跳过 {scene_dir}") |
| continue |
|
|
| norm_labels = [normalize_phrase(l) for l in labels] |
| boxes = boxes * torch.tensor([w, h, w, h], device=boxes.device) |
| boxes_xyxy = box_convert(boxes=boxes, in_fmt="cxcywh", out_fmt="xyxy").cpu().numpy() |
|
|
| used = set() |
| for idx, obj in enumerate(objects): |
| target = normalize_phrase(obj.get("prompt") or obj.get("name") or "") |
| match_idx = None |
| for j, lbl in enumerate(norm_labels): |
| if j in used: |
| continue |
| if lbl == target: |
| match_idx = j |
| break |
| if match_idx is None: |
| for j in range(len(norm_labels)): |
| if j not in used: |
| match_idx = j |
| break |
| if match_idx is None: |
| print(f"[WARN] 没有可用的检测结果分配给 object[{idx}]") |
| continue |
|
|
| used.add(match_idx) |
| box_xyxy = boxes_xyxy[match_idx : match_idx + 1] |
| masks, scores, _ = sam2_predictor.predict( |
| point_coords=None, |
| point_labels=None, |
| box=box_xyxy, |
| multimask_output=False, |
| ) |
| mask = masks[0].astype(np.uint8) * 255 |
|
|
| obj_id = obj.get("id") or f"obj{idx+1}" |
| mask_rel = obj.get("mask") or f"{args.mask_dir_name}/{obj_id}.png" |
| mask_path = scene_dir / mask_rel |
| mask_path.parent.mkdir(parents=True, exist_ok=True) |
| cv2.imwrite(str(mask_path), mask) |
|
|
| obj["id"] = obj_id |
| obj["mask"] = str(mask_rel) |
|
|
| print(f"[OK] {obj.get('prompt') or obj.get('name')} -> {mask_rel}") |
|
|
| with scene_json.open("w", encoding="utf-8") as f: |
| json.dump(data, f, ensure_ascii=False, indent=2) |
| print(f"[DONE] 已更新 {scene_json}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
