"""SAM 3 text-prompted segmentation helpers (model loading and per-prompt segmentation), used by the render worker, the SAM 3 audit and the mask export. The command line segments a folder of images per class. """ import argparse import json import os import random import re import tempfile from pathlib import Path from typing import Optional def _atomic_write_json(path: Path, data) -> None: """Write JSON to ``path`` atomically. On some shared filesystems, ``open('w')`` doesn't truncate cleanly — if the new content is shorter than the old, NULL bytes can appear between new EOF and old EOF, leaving a corrupt mixed file. This helper writes to a sibling tempfile then ``os.replace``s it onto the target path; ``os.replace`` is atomic, so readers always see either the old complete file or the new complete file. """ fd, tmp = tempfile.mkstemp(prefix=path.name + '.', suffix='.tmp', dir=str(path.parent)) try: with os.fdopen(fd, 'w') as f: json.dump(data, f, indent=2) os.replace(tmp, path) except Exception: try: os.unlink(tmp) except OSError: pass raise import cv2 import numpy as np import torch from PIL import Image def load_sam3_processor(bpe_path: str, confidence_threshold: float = 0.5, device: str = 'cuda', checkpoint_path: Optional[str] = None): """Build SAM3 image model + processor.""" from sam3 import build_sam3_image_model from sam3.model.sam3_image_processor import Sam3Processor if checkpoint_path is not None: model = build_sam3_image_model( bpe_path=bpe_path, checkpoint_path=checkpoint_path, load_from_HF=False, ) else: model = build_sam3_image_model(bpe_path=bpe_path) model = model.to(device).eval() processor = Sam3Processor( model, confidence_threshold=confidence_threshold) return processor def load_clip_scorer(device: str = 'cuda', model_name: str = 'ViT-L/14'): """OpenAI CLIP for the optional white-bg re-score (paper metric).""" import clip model, preprocess = clip.load(model_name, device=device) model = model.eval() return model, preprocess, clip.tokenize def category_name_for_prompt(cat_dir_name: str) -> str: """Reverse-clean directory name into a natural phrase. Mirrors ``segment_sam.py`` so dir-name conventions stay shared. """ name = cat_dir_name.replace('_', ' ') name = re.sub(r'\s+', ' ', name).strip() return name def get_largest_connect_component(mask: np.ndarray) -> np.ndarray: """Keep only the largest connected blob of a binary mask.""" contours, _ = cv2.findContours( mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if not contours: return mask areas = [cv2.contourArea(c) for c in contours] max_idx = int(np.argmax(areas)) out = np.zeros_like(mask) cv2.fillPoly(out, [contours[max_idx]], 1) return out @torch.no_grad() def clip_rescore( image_rgb: np.ndarray, mask: np.ndarray, category_phrase: str, clip_model, clip_preprocess, clip_tokenizer, device: str = 'cuda', ) -> float: mask_bin = (mask > 128).astype(np.float32)[:, :, None] white = np.full_like(image_rgb, 255) composite = (image_rgb * mask_bin + white * (1.0 - mask_bin)).astype( np.uint8) img_tensor = clip_preprocess(Image.fromarray(composite)).unsqueeze(0) img_tensor = img_tensor.to(device) text_tokens = clip_tokenizer( [f"a photo of a {category_phrase}"]).to(device) image_features = clip_model.encode_image(img_tensor) text_features = clip_model.encode_text(text_tokens) image_features = image_features / image_features.norm( dim=-1, keepdim=True) text_features = text_features / text_features.norm( dim=-1, keepdim=True) similarity = (100.0 * text_features @ image_features.T).squeeze() return float(similarity.cpu()) def _to_numpy_mask(m) -> np.ndarray: """Coerce a SAM3 mask output (torch/np, bool/uint8/float) to HxW uint8.""" if isinstance(m, torch.Tensor): if m.dtype not in (torch.bool, torch.uint8, torch.float32): m = m.float() m = m.detach().cpu().numpy() m = np.asarray(m) while m.ndim > 2: m = m[0] if m.dtype == np.bool_: return m.astype(np.uint8) * 255 if np.issubdtype(m.dtype, np.floating): return ((m > 0.5).astype(np.uint8)) * 255 return ((m > 0).astype(np.uint8)) * 255 def segment_with_text(processor, image_rgb: np.ndarray, prompt: str, top_k: int = 1) -> Optional[tuple]: """Run SAM3 with a text prompt; return (mask, score) or None.""" pil = Image.fromarray(image_rgb) with torch.autocast(device_type='cuda', dtype=torch.bfloat16): state = processor.set_image(pil) out = processor.set_text_prompt(state=state, prompt=prompt) masks = out.get('masks') scores = out.get('scores') if masks is None or scores is None: return None if isinstance(scores, torch.Tensor): scores_np = scores.detach().float().cpu().numpy() else: scores_np = np.asarray(scores) if scores_np.size == 0: return None order = np.argsort(-scores_np)[:max(1, int(top_k))] union_u8 = None for idx in order: m_raw = masks[idx] if isinstance(masks, (list, tuple)) else masks[idx] m_u8 = _to_numpy_mask(m_raw) union_u8 = m_u8 if union_u8 is None else np.maximum(union_u8, m_u8) best_score = float(scores_np[order[0]]) return union_u8, best_score def crop_to_mask_bbox(image: np.ndarray, mask: np.ndarray, padding: int = 5) -> tuple: """Crop image+mask to mask bbox and stack to RGBA. Same as segment_sam.""" coords = np.where(mask > 0) if len(coords[0]) == 0: return None, None y1, y2 = coords[0].min(), coords[0].max() x1, x2 = coords[1].min(), coords[1].max() h, w = image.shape[:2] y1 = max(0, y1 - padding) x1 = max(0, x1 - padding) y2 = min(h, y2 + padding + 1) x2 = min(w, x2 + padding + 1) cropped_img = image[y1:y2, x1:x2] cropped_mask = mask[y1:y2, x1:x2] if cropped_img.shape[2] == 3: rgba = np.concatenate( [cropped_img, cropped_mask[:, :, None]], axis=2) else: rgba = cropped_img.copy() rgba[:, :, 3] = cropped_mask return rgba, (x1, y1, x2, y2) def process_category_dir( processor, cat_dir: Path, output_dir: Path, crop: bool = True, clip_components: tuple = None, device: str = 'cuda', max_per_class: int = None, min_area_ratio: float = 0.02, max_area_ratio: float = 0.85, prompt_template: str = 'a {category}', min_score: float = 0.2, per_class_min_score: Optional[dict] = None, per_class_prompt: Optional[dict] = None, per_class_confidence_threshold: Optional[dict] = None, per_class_top_k: Optional[dict] = None, sample_seed: Optional[int] = 42, ) -> list: """Segment every img_*.png in cat_dir using SAM3 text prompts.""" cat_name = cat_dir.name category_phrase = category_name_for_prompt(cat_name) cls_template = (per_class_prompt or {}).get(cat_name, prompt_template) prompt = cls_template.format(category=category_phrase) out_cat_dir = output_dir / cat_name out_cat_dir.mkdir(parents=True, exist_ok=True) cls_min_score = (per_class_min_score or {}).get(cat_name, min_score) pcct = per_class_confidence_threshold or {} saved_proc_thr = None if cat_name in pcct: saved_proc_thr = getattr(processor, 'confidence_threshold', None) processor.confidence_threshold = float(pcct[cat_name]) cls_top_k = int((per_class_top_k or {}).get(cat_name, 1)) meta_path = out_cat_dir / 'metadata.json' if meta_path.exists(): with open(meta_path) as f: existing = json.load(f) existing_names = {m['image'] for m in existing} else: existing = [] existing_names = set() src_meta_path = cat_dir / 'metadata.json' src_meta = {} if src_meta_path.exists(): with open(src_meta_path) as f: src_meta_list = json.load(f) src_meta = {m['image']: m for m in src_meta_list} image_files = sorted(cat_dir.glob('img_*.png')) if max_per_class is not None: if sample_seed is None: image_files = image_files[:max_per_class] else: rng = random.Random(f"{sample_seed}:{cat_name}") k = min(max_per_class, len(image_files)) image_files = rng.sample(image_files, k) image_files.sort() results = list(existing) flush_every = 500 n_processed_this_run = 0 for img_path in image_files: out_name = img_path.stem + '.png' if out_name in existing_names: continue try: image = np.array(Image.open(img_path).convert('RGB')) except Exception as e: print(f" [WARN] skipping {img_path.name}: {type(e).__name__}: {e}") continue try: seg = segment_with_text(processor, image, prompt, top_k=cls_top_k) except Exception as e: print(f" [WARN] segment failed on {img_path.name}: " f"{type(e).__name__}: {e}") continue if seg is None: continue mask, sam3_score = seg if sam3_score < cls_min_score: continue if cls_top_k <= 1: mask01 = (mask > 0).astype(np.uint8) mask01 = get_largest_connect_component(mask01) mask = mask01 * 255 mask_area = mask.sum() / 255.0 total_area = mask.shape[0] * mask.shape[1] area_ratio = mask_area / total_area if area_ratio < min_area_ratio or area_ratio > max_area_ratio: continue seg_clip_score = None if clip_components is not None: cm, cp, ct = clip_components seg_clip_score = clip_rescore( image, mask, category_phrase, cm, cp, ct, device=device) if crop: rgba, bbox = crop_to_mask_bbox(image, mask) if rgba is None: continue else: rgba = np.concatenate([image, mask[:, :, None]], axis=2) bbox = (0, 0, image.shape[1], image.shape[0]) out_path = out_cat_dir / out_name Image.fromarray(rgba).save(out_path) meta = { 'image': out_name, 'source_image': img_path.name, 'width': int(rgba.shape[1]), 'height': int(rgba.shape[0]), 'mask_area_ratio': float(area_ratio), 'bbox': [int(x) for x in bbox], 'sam3_score': float(sam3_score), 'prompt': prompt, } raw_score = src_meta.get(img_path.name, {}).get('clip_score') if raw_score is not None: meta['raw_clip_score'] = raw_score if seg_clip_score is not None: meta['clip_score'] = seg_clip_score elif raw_score is not None: meta['clip_score'] = raw_score results.append(meta) n_processed_this_run += 1 if n_processed_this_run % flush_every == 0: _atomic_write_json(meta_path, results) _atomic_write_json(meta_path, results) if saved_proc_thr is not None: processor.confidence_threshold = saved_proc_thr return results def main(): parser = argparse.ArgumentParser( description='SAM 3 text-prompt segmentation of a folder of images, per class.') parser.add_argument('--input_dir', required=True) parser.add_argument('--output_dir', required=True) parser.add_argument('--sam3_bpe_path', required=True, help='Path to assets/bpe_simple_vocab_16e6.txt.gz ' 'from the cloned sam3 repo.') parser.add_argument('--sam3_checkpoint_path', type=str, default=None, help='Optional local path to sam3.pt; when set, the Hugging Face Hub is not used.') parser.add_argument('--confidence_threshold', type=float, default=0.05, help='Score threshold inside the SAM 3 processor; --min_score makes the final decision.') parser.add_argument('--min_score', type=float, default=0.2, help='Minimum SAM 3 score of the kept mask.') parser.add_argument('--per_class_min_score_json', type=str, default=None, help="Optional JSON file with per-class min_score " "overrides, e.g. {\"person\": 0.1, " "\"banana\": 0.1}. Falls back to --min_score " "for any class not in the file.") parser.add_argument('--prompt_template', type=str, default='a {category}', help="Global text-prompt template; {category} is " "replaced with the cleaned class name. " "Default 'a {category}' — empirically the " "old 'a photo of a {category}' wrapper " "tanks SAM3 grounding for many classes " "(e.g. bed/donut: 0.04 / 0.01 vs. 0.90 / " "0.97 with 'a {category}').") parser.add_argument('--per_class_prompt_json', type=str, default=None, help="Optional JSON file with per-class prompt " "templates, e.g. " '{"bed": "a picture of a {category}"}. ' "Falls back to --prompt_template otherwise.") parser.add_argument('--per_class_confidence_threshold_json', type=str, default=None, help='Optional JSON file with per-class processor score thresholds, e.g. {"bed": 0.0}.') parser.add_argument('--per_class_top_k_json', type=str, default=None, help='Optional JSON file with per-class top-K: the top-K masks of a class are merged (for plural-noun classes).') parser.add_argument('--no_crop', action='store_true') parser.add_argument('--no_clip_rescore', action='store_true', help='Skip optional white-bg CLIP re-score. Faster; ' 'clean_pool.py will fall back to text2im.py ' 'raw-image CLIP scores.') parser.add_argument('--clip_model', type=str, default='ViT-L/14') parser.add_argument('--min_area_ratio', type=float, default=0.02) parser.add_argument('--max_area_ratio', type=float, default=0.85) parser.add_argument('--classes', type=str, default=None, help='Optional comma-separated class allowlist ' '(e.g. "person,banana,broccoli"). When set, ' 'only those subdirs of --input_dir are ' 'processed; useful for threshold sweeps over ' 'a subset of problem classes.') parser.add_argument('--shard_id', type=int, default=0) parser.add_argument('--num_shards', type=int, default=1) parser.add_argument('--max_per_class', type=int, default=None, help='Cap to N images per class (smoke / sweep). ' 'Sampling is seeded random (see --sample_seed) ' 'so the same N are picked across threshold ' 'sweeps, but the sample is representative ' 'instead of head-take img_0000..img_000N-1.') parser.add_argument('--sample_seed', type=int, default=42, help='Seed for per-class random sampling under ' '--max_per_class. Set to -1 to fall back to ' 'deterministic head-take.') parser.add_argument('--device', type=str, default='cuda') args = parser.parse_args() input_dir = Path(args.input_dir) output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) cat_dirs = sorted([d for d in input_dir.iterdir() if d.is_dir()]) print(f"Found {len(cat_dirs)} category directories") if args.classes: wanted = {c.strip() for c in args.classes.split(',') if c.strip()} cat_dirs = [d for d in cat_dirs if d.name in wanted] missing = wanted - {d.name for d in cat_dirs} if missing: print(f" WARNING: requested classes not found: " f"{sorted(missing)}") print(f"Class allowlist applied: {len(cat_dirs)} categories") cat_dirs = [d for i, d in enumerate(cat_dirs) if i % args.num_shards == args.shard_id] print(f"This shard: {len(cat_dirs)} categories") print(f"Loading SAM3 (bpe={args.sam3_bpe_path}, " f"conf_thr={args.confidence_threshold})...") processor = load_sam3_processor( args.sam3_bpe_path, confidence_threshold=args.confidence_threshold, device=args.device, checkpoint_path=args.sam3_checkpoint_path, ) clip_components = None if not args.no_clip_rescore: print(f"Loading CLIP {args.clip_model} for white-bg re-score...") clip_components = load_clip_scorer( device=args.device, model_name=args.clip_model) per_class_min_score = None if args.per_class_min_score_json: with open(args.per_class_min_score_json) as f: per_class_min_score = json.load(f) print(f"Loaded per-class min_score overrides for " f"{len(per_class_min_score)} classes from " f"{args.per_class_min_score_json}") per_class_prompt = None if args.per_class_prompt_json: with open(args.per_class_prompt_json) as f: per_class_prompt = json.load(f) print(f"Loaded per-class prompt overrides for " f"{len(per_class_prompt)} classes from " f"{args.per_class_prompt_json}") per_class_conf_thr = None if args.per_class_confidence_threshold_json: with open(args.per_class_confidence_threshold_json) as f: per_class_conf_thr = json.load(f) print(f"Loaded per-class confidence_threshold overrides for " f"{len(per_class_conf_thr)} classes from " f"{args.per_class_confidence_threshold_json}") per_class_top_k = None if args.per_class_top_k_json: with open(args.per_class_top_k_json) as f: per_class_top_k = json.load(f) print(f"Loaded per-class top-K overrides for " f"{len(per_class_top_k)} classes from " f"{args.per_class_top_k_json}") total_instances = 0 for idx, cat_dir in enumerate(cat_dirs): print(f"[{idx+1}/{len(cat_dirs)}] {cat_dir.name}...") results = process_category_dir( processor, cat_dir, output_dir, crop=not args.no_crop, clip_components=clip_components, device=args.device, max_per_class=args.max_per_class, min_area_ratio=args.min_area_ratio, max_area_ratio=args.max_area_ratio, prompt_template=args.prompt_template, min_score=args.min_score, per_class_min_score=per_class_min_score, per_class_prompt=per_class_prompt, per_class_confidence_threshold=per_class_conf_thr, per_class_top_k=per_class_top_k, sample_seed=(None if args.sample_seed == -1 else args.sample_seed), ) total_instances += len(results) print(f" {len(results)} instances segmented") print(f"\nDone. Total instances: {total_instances}") if __name__ == '__main__': main()