Week 4: Layer Proposal Engine, logo decomposer, image classifier, component architecture, undo/redo, selection modes, properties panel

grounding.py

@@ -20,10 +20,6 @@ print(f"[GDINO] Using device: {DEVICE}")
 
 
 def load_grounding_model():
-    """
-    Load GroundingDINO model into memory.
-    Call once at startup — takes ~5 seconds.
-    """
     model = load_model(GROUNDING_CONFIG, GROUNDING_WEIGHTS)
     model = model.to(DEVICE)
     print("[GDINO] Model loaded successfully")
@@ -44,9 +40,12 @@ def detect_objects(image_path: str, model, text_prompt: str = None) -> list:
       All coordinates are absolute pixels.
     """
     if text_prompt is None:
+        # text_prompt = (
+        #     "product . text . logo . background . "
+        #     "image . graphic . illustration . icon . button"
+        # )
         text_prompt = (
-            "product . text . logo . background . "
-            "image . graphic . illustration . icon . button"
+            "product . logo . person . icon . illustration . graphic"
         )
 
     # load_image returns (PIL image, transformed tensor) — both needed

layer_extractor.py

@@ -1,5 +1,4 @@
 import os
-import sys
 import json
 import base64
 import io
@@ -10,106 +9,198 @@ from PIL import Image
 
 from grounding import load_grounding_model, detect_objects
 from ocr import extract_text
+from proposal_engine import run_proposal_engine, compute_groups, reject_text_inside_objects
+from logo_decomposer import decompose_logo, get_text_inside_logo
 
 BACKEND_DIR = os.path.dirname(os.path.abspath(__file__))
-SKIP_LABELS = {"background", "text", "button"}
 
+LOGO_AREA_THRESHOLD = 0.20
 
 def pil_to_base64(img: Image.Image, fmt: str = "PNG") -> str:
-    """Convert PIL image to base64 string."""
     buffer = io.BytesIO()
     img.save(buffer, format=fmt)
     return base64.b64encode(buffer.getvalue()).decode("utf-8")
 
 
-def crop_text_layer(image_path: str, x: int, y: int, w: int, h: int) -> str:
-    """
-    Crop text region as transparent PNG.
-    Text layers use simple rectangular crop with white pixels made transparent.
-    """
+def crop_text_layer(image_path, x, y, w, h):
     img  = Image.open(image_path).convert("RGBA")
     crop = img.crop((x, y, x + w, y + h))
     return pil_to_base64(crop, "PNG")
 
 
-def build_layers(image_path: str) -> list:
-    """
-    Full layer extraction pipeline:
-    1. GroundingDINO finds named objects with bounding boxes
-    2. SAM2 refines each box into a precise pixel mask
-    3. PaddleOCR finds all text blocks
-    4. Each layer gets a transparent PNG crop
+def classify_image_type(detections, img_w, img_h):
+    image_area = img_w * img_h
 
-    Returns flat list of layers ready for Fabric.js canvas.
-    """
-    layers   = []
-    layer_id = 1
+    best_det      = None
+    best_fraction = 0.0
+
+    for d in detections:
+        label    = d["label"].strip().lower()
+        fraction = (d["x2"] - d["x1"]) * (d["y2"] - d["y1"]) / image_area
+        if label in {"logo", "logo icon"} and fraction > LOGO_AREA_THRESHOLD and fraction > best_fraction:
+            best_fraction = fraction
+            best_det      = d
+
+    if best_det:
+        print(f"[LAYERS] Image classified as: logo (logo covers {best_fraction:.1%})")
+        return "logo", best_det
+
+    print("[LAYERS] Image classified as: not-logo")
+    return "not-logo", None
 
-    # --- load image ---
+def build_layers(image_path: str) -> tuple:
     image_bgr = cv2.imread(image_path)
     image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
     img_h, img_w = image_rgb.shape[:2]
 
-    # --- step 1: GroundingDINO object detection ---
+    # --- GroundingDINO ---
     print("[LAYERS] Running GroundingDINO...")
     gdino_model = load_grounding_model()
     detections  = detect_objects(image_path, gdino_model)
 
-    # filter background/text labels
-    obj_detections = [d for d in detections if d["label"].lower() not in SKIP_LABELS]
-    print(f"[LAYERS] {len(obj_detections)} objects to segment with SAM2")
+    object_proposals = [
+        {
+            "type":       "object",
+            "label":      d["label"],
+            "x":          d["x1"],
+            "y":          d["y1"],
+            "w":          d["x2"] - d["x1"],
+            "h":          d["y2"] - d["y1"],
+            "confidence": d["confidence"],
+        }
+        for d in detections
+    ]
+
+    # --- OCR ---
+    print("[LAYERS] Running OCR...")
+    text_blocks = extract_text(image_path)
+
+    # --- classify and route ---
+    image_type, logo_detection = classify_image_type(detections, img_w, img_h)
+
+    if image_type == "logo":
+        from segment import load_sam2_model
+        predictor      = load_sam2_model()
+        layers, groups = decompose_logo(
+            image_path, image_rgb, logo_detection, text_blocks, predictor
+        )
+        del predictor
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        print("[LAYERS] SAM2 VRAM freed")
+
+        logo_box_dict = {
+            "x": logo_detection["x1"],
+            "y": logo_detection["y1"],
+            "w": logo_detection["x2"] - logo_detection["x1"],
+            "h": logo_detection["y2"] - logo_detection["y1"],
+        }
+        text_inside_ids = {id(b) for b in get_text_inside_logo(text_blocks, logo_box_dict)}
+        next_id = max((l["id"] for l in layers), default=0) + 1
+
+        for block in text_blocks:
+            if id(block) in text_inside_ids:
+                continue
+            b64 = crop_text_layer(image_path, block["x"], block["y"], block["w"], block["h"])
+            layers.append({
+                "id":         next_id,
+                "type":       "text",
+                "text":       block["text"],
+                "label":      block["text"],
+                "x":          block["x"],
+                "y":          block["y"],
+                "w":          block["w"],
+                "h":          block["h"],
+                "confidence": block["confidence"],
+                "base64":     b64,
+                "format":     "png",
+                "group_id":   None,
+                "group_role": None,
+            })
+            next_id += 1
+
+        print(f"[LAYERS] Built {len(layers)} layers, {len(groups)} groups")
+        return layers, groups
+
+    # --- not-logo path ---
+    clean_objects = run_proposal_engine(object_proposals, img_w, img_h)
+    print(f"[LAYERS] {len(clean_objects)} objects passed proposal engine")
+
+    layers   = []
+    layer_id = 1
 
-    # --- step 2: SAM2 precise masks for each object ---
-    if obj_detections:
+    if clean_objects:
+        print(f"[LAYERS] Running SAM2 on {len(clean_objects)} objects...")
         from segment import load_sam2_model, get_mask_for_box, mask_to_transparent_png
         predictor = load_sam2_model()
 
-        for det in obj_detections:
-            box = [det["x1"], det["y1"], det["x2"], det["y2"]]
-
+        for proposal in clean_objects:
+            box = [
+                proposal["x"],
+                proposal["y"],
+                proposal["x"] + proposal["w"],
+                proposal["y"] + proposal["h"],
+            ]
             try:
                 mask = get_mask_for_box(predictor, image_rgb, box)
-
-                # get tight bounding box from mask
-                rows     = np.where(mask.any(axis=1))[0]
-                cols     = np.where(mask.any(axis=0))[0]
-                if len(rows) == 0: continue
+                rows = np.where(mask.any(axis=1))[0]
+                cols = np.where(mask.any(axis=0))[0]
+                if len(rows) == 0:
+                    continue
 
                 y1, y2 = int(rows.min()), int(rows.max())
                 x1, x2 = int(cols.min()), int(cols.max())
-
-                # create transparent PNG
                 png_img = mask_to_transparent_png(image_rgb, mask)
                 b64     = pil_to_base64(png_img, "PNG")
 
                 layers.append({
                     "id":         layer_id,
                     "type":       "object",
-                    "label":      det["label"],
+                    "label":      proposal["label"],
                     "x":          x1,
                     "y":          y1,
                     "w":          x2 - x1,
                     "h":          y2 - y1,
-                    "confidence": det["confidence"],
+                    "confidence": proposal["confidence"],
                     "base64":     b64,
                     "format":     "png",
                 })
                 layer_id += 1
 
             except Exception as e:
-                print(f"[LAYERS] SAM2 failed for {det['label']}: {e}")
+                print(f"[LAYERS] SAM2 failed for '{proposal['label']}': {e}")
                 continue
 
-        # free SAM2 VRAM before OCR
         del predictor
-        torch.cuda.empty_cache() if __import__('torch').cuda.is_available() else None
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
         print("[LAYERS] SAM2 VRAM freed")
 
-    # --- step 3: OCR text layers ---
-    print("[LAYERS] Running OCR...")
-    text_blocks = extract_text(image_path)
+    # --- text layers: reject any that sit inside an accepted object box ---
+    object_boxes = [
+        {"x": l["x"], "y": l["y"], "w": l["w"], "h": l["h"]}
+        for l in layers
+    ]
 
-    for block in text_blocks:
+    text_proposals = [
+        {
+            "type":       "text",
+            "text":       b["text"],
+            "label":      b["text"],
+            "x":          b["x"],
+            "y":          b["y"],
+            "w":          b["w"],
+            "h":          b["h"],
+            "confidence": b["confidence"],
+        }
+        for b in text_blocks
+    ]
+
+    clean_text, rejected_text = reject_text_inside_objects(text_proposals, object_boxes)
+    if rejected_text:
+        print(f"[LAYERS] Rejected {len(rejected_text)} text blocks inside object layers")
+
+    for block in clean_text:
         b64 = crop_text_layer(
             image_path,
             block["x"], block["y"],
@@ -119,6 +210,7 @@ def build_layers(image_path: str) -> list:
             "id":         layer_id,
             "type":       "text",
             "text":       block["text"],
+            "label":      block["text"],
             "x":          block["x"],
             "y":          block["y"],
             "w":          block["w"],
@@ -129,43 +221,7 @@ def build_layers(image_path: str) -> list:
         })
         layer_id += 1
 
-    print(f"[LAYERS] Built {len(layers)} layers ({len(obj_detections)} objects + {len(text_blocks)} text)")
-    return layers
-
-
-def save_layers(layers: list, output_dir: str = None) -> str:
-    if output_dir is None:
-        output_dir = os.path.join(BACKEND_DIR, "outputs")
-    os.makedirs(output_dir, exist_ok=True)
-
-    output_path = os.path.join(output_dir, "layers.json")
-    with open(output_path, "w", encoding="utf-8") as f:
-        json.dump(layers, f, indent=2, ensure_ascii=False)
-
-    print(f"[LAYERS] Saved → {output_path}")
-    return output_path
-
-
-if __name__ == "__main__":
-    TEST_IMAGE = os.path.join(BACKEND_DIR, "test_images", "sale_img.jpg")
-
-    if not os.path.exists(TEST_IMAGE):
-        print("ERROR: Test image missing")
-        exit(1)
-
-    print("=" * 50)
-    print("Building Transparent Layers")
-    print("=" * 50)
-
-    layers = build_layers(TEST_IMAGE)
-
-    print(f"\nGenerated {len(layers)} layers:")
-    for layer in layers:
-        fmt = layer.get("format", "jpg")
-        if layer["type"] == "text":
-            print(f"  [{layer['id']}] TEXT   '{layer['text']}' at ({layer['x']},{layer['y']}) [{fmt}]")
-        else:
-            print(f"  [{layer['id']}] OBJECT '{layer['label']}' at ({layer['x']},{layer['y']}) [{fmt}]")
+    annotated, groups = compute_groups(layers)
 
-    save_layers(layers)
-    print("=" * 50)
+    print(f"[LAYERS] Built {len(annotated)} layers ({len(clean_objects)} objects + {len(clean_text)} text), {len(groups)} groups")
+    return annotated, groups

logo_decomposer.py

@@ -0,0 +1,148 @@
+import numpy as np
+from PIL import Image
+import io
+import base64
+
+
+def pil_to_base64(img: Image.Image, fmt: str = "PNG") -> str:
+    buffer = io.BytesIO()
+    img.save(buffer, format=fmt)
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+
+def crop_text_layer(image_path, x, y, w, h):
+    img  = Image.open(image_path).convert("RGBA")
+    crop = img.crop((x, y, x + w, y + h))
+    return pil_to_base64(crop, "PNG")
+
+
+def get_text_inside_logo(text_blocks, logo_box, tolerance=10):
+    lx2 = logo_box["x"] + logo_box["w"]
+    ly2 = logo_box["y"] + logo_box["h"]
+    return [
+        b for b in text_blocks
+        if (b["x"] >= logo_box["x"] - tolerance and
+            b["y"] >= logo_box["y"] - tolerance and
+            b["x"] + b["w"] <= lx2 + tolerance and
+            b["y"] + b["h"] <= ly2 + tolerance)
+    ]
+
+
+def subtract_text_from_mask(mask, text_blocks, logo_box, tolerance=10):
+    """
+    Zeroes out OCR text regions from the SAM2 mask.
+    What remains is the graphic-only pixels — no text baked in.
+    Works on any image regardless of content.
+    """
+    result = mask.copy()
+    lx1 = logo_box["x"] - tolerance
+    ly1 = logo_box["y"] - tolerance
+    lx2 = logo_box["x"] + logo_box["w"] + tolerance
+    ly2 = logo_box["y"] + logo_box["h"] + tolerance
+
+    for block in text_blocks:
+        # only subtract text that sits inside the logo region
+        bx1 = max(0, block["x"] - tolerance)
+        by1 = max(0, block["y"] - tolerance)
+        bx2 = block["x"] + block["w"] + tolerance
+        by2 = block["y"] + block["h"] + tolerance
+
+        if (block["x"] >= lx1 and block["y"] >= ly1 and
+                block["x"] + block["w"] <= lx2 and
+                block["y"] + block["h"] <= ly2):
+            result[by1:by2, bx1:bx2] = False
+
+    return result
+
+
+def decompose_logo(image_path, image_rgb, logo_detection, text_blocks, predictor):
+    """
+    v1: logo graphic (SAM2 mask minus text regions) + individual text layers.
+    v2 can add SAM2 auto-segmentation for internal shapes by extending only
+    this function — nothing outside this file changes.
+    """
+    from segment import get_mask_for_box, mask_to_transparent_png
+
+    layers   = []
+    layer_id = 1
+
+    logo_box_list = [
+        logo_detection["x1"],
+        logo_detection["y1"],
+        logo_detection["x2"],
+        logo_detection["y2"],
+    ]
+
+    logo_box_dict = {
+        "x": logo_detection["x1"],
+        "y": logo_detection["y1"],
+        "w": logo_detection["x2"] - logo_detection["x1"],
+        "h": logo_detection["y2"] - logo_detection["y1"],
+    }
+
+    text_inside = get_text_inside_logo(text_blocks, logo_box_dict)
+
+    graphic_created = False
+    try:
+        mask = get_mask_for_box(predictor, image_rgb, logo_box_list)
+
+        # remove text pixel regions from graphic mask
+        if text_inside:
+            mask = subtract_text_from_mask(mask, text_inside, logo_box_dict)
+
+        rows = np.where(mask.any(axis=1))[0]
+        cols = np.where(mask.any(axis=0))[0]
+
+        if len(rows) > 0:
+            y1, y2 = int(rows.min()), int(rows.max())
+            x1, x2 = int(cols.min()), int(cols.max())
+            png_img = mask_to_transparent_png(image_rgb, mask)
+            b64     = pil_to_base64(png_img, "PNG")
+
+            layers.append({
+                "id":         layer_id,
+                "type":       "object",
+                "label":      "logo",
+                "x":          x1,
+                "y":          y1,
+                "w":          x2 - x1,
+                "h":          y2 - y1,
+                "confidence": logo_detection["confidence"],
+                "base64":     b64,
+                "format":     "png",
+                "group_id":   "group_0",
+                "group_role": "root",
+            })
+            layer_id += 1
+            graphic_created = True
+
+    except Exception as e:
+        print(f"[LOGO] SAM2 failed for logo graphic: {e}")
+
+    for block in text_inside:
+        b64 = crop_text_layer(
+            image_path,
+            block["x"], block["y"],
+            block["w"], block["h"]
+        )
+        layers.append({
+            "id":         layer_id,
+            "type":       "text",
+            "text":       block["text"],
+            "label":      block["text"],
+            "x":          block["x"],
+            "y":          block["y"],
+            "w":          block["w"],
+            "h":          block["h"],
+            "confidence": block["confidence"],
+            "base64":     b64,
+            "format":     "png",
+            "group_id":   "group_0" if graphic_created else None,
+            "group_role": "child"   if graphic_created else None,
+        })
+        layer_id += 1
+
+    groups = [{"id": "group_0", "label": "Logo", "type": "group"}] if graphic_created else []
+
+    print(f"[LOGO] Decomposed: 1 graphic + {len(text_inside)} text = {len(layers)} layers")
+    return layers, groups

pipeline.py

@@ -24,15 +24,9 @@ def pil_to_base64(img: Image.Image, fmt: str = "PNG") -> str:
 
 
 def reconstruct_background(image_path: str, layers: list) -> str:
-    """
-    Build ONE combined mask covering all detected layers.
-    Run a single OpenCV TELEA inpaint to reconstruct the clean background.
-    Returns base64 JPEG of the clean background.
-    """
     image_bgr = cv2.imread(image_path)
     h, w      = image_bgr.shape[:2]
 
-    # combined mask — white where any layer exists
     combined_mask = np.zeros((h, w), dtype=np.uint8)
 
     for layer in layers:
@@ -42,7 +36,6 @@ def reconstruct_background(image_path: str, layers: list) -> str:
         y2 = min(h, layer["y"] + layer["h"])
         combined_mask[y:y2, x:x2] = 255
 
-    # single TELEA inpaint — fast, works for MVP, replaceable later
     clean_bg = cv2.inpaint(
         image_bgr,
         combined_mask,
@@ -50,49 +43,35 @@ def reconstruct_background(image_path: str, layers: list) -> str:
         flags=cv2.INPAINT_TELEA
     )
 
-    # encode to base64
     _, buffer = cv2.imencode('.jpg', clean_bg, [cv2.IMWRITE_JPEG_QUALITY, 95])
     return base64.b64encode(buffer).decode("utf-8")
 
 
 def run_pipeline(image_path: str) -> dict:
-    """
-    Full pipeline:
-    1. Extract all layers as transparent PNGs
-    2. Build combined mask of all layer regions
-    3. Reconstruct clean background in ONE inpaint pass
-    4. Return clean background + independent layers
-
-    Editor renders: clean background + layer PNGs
-    Every element exists exactly once — no duplicates possible.
-    Editing is instant — no AI calls needed during editing.
-    """
     start = time.time()
     print(f"\n[PIPELINE] Starting: {os.path.basename(image_path)}")
 
-    img      = Image.open(image_path)
+    img          = Image.open(image_path)
     img_w, img_h = img.size
     print(f"[PIPELINE] Image: {img_w}x{img_h}")
 
-    # step 1 — extract all layers
-    layers = build_layers(image_path)
-    print(f"[PIPELINE] Extracted {len(layers)} layers")
+    layers, groups = build_layers(image_path)
+    print(f"[PIPELINE] {len(layers)} layers, {len(groups)} groups")
 
-    # step 2 — reconstruct background once using combined mask
-    print("[PIPELINE] Reconstructing clean background...")
+    print("[PIPELINE] Reconstructing background...")
     bg_base64 = reconstruct_background(image_path, layers)
-    print("[PIPELINE] Background reconstructed")
 
     elapsed = round(time.time() - start, 2)
     print(f"[PIPELINE] Done in {elapsed}s")
 
     return {
-        "image_w":              img_w,
-        "image_h":              img_h,
-        "background_base64":    bg_base64,     # clean background, no elements
-        "original_base64":      image_to_base64(image_path),  # for inpainting reference
-        "layers":               layers,
-        "processing_time_s":    elapsed,
+        "image_w":           img_w,
+        "image_h":           img_h,
+        "background_base64": bg_base64,
+        "original_base64":   image_to_base64(image_path),
+        "layers":            layers,
+        "groups":            groups,
+        "processing_time_s": elapsed,
     }
 
 
@@ -106,6 +85,8 @@ def save_pipeline_output(result: dict, output_dir: str = None) -> str:
         "image_h":           result["image_h"],
         "processing_time_s": result["processing_time_s"],
         "layer_count":       len(result["layers"]),
+        "group_count":       len(result["groups"]),
+        "groups":            result["groups"],
         "layers": [
             {k: v for k, v in layer.items() if k != "base64"}
             for layer in result["layers"]
@@ -117,25 +98,4 @@ def save_pipeline_output(result: dict, output_dir: str = None) -> str:
         json.dump(result_slim, f, indent=2, ensure_ascii=False)
 
     print(f"[PIPELINE] Saved → {out_path}")
-    return out_path
-
-
-if __name__ == "__main__":
-    TEST_IMAGE = os.path.join(BACKEND_DIR, "test_images", "sale_img.jpg")
-
-    if not os.path.exists(TEST_IMAGE):
-        print("ERROR: Test image missing")
-        exit(1)
-
-    print("=" * 50)
-    print("Running Editify Pipeline")
-    print("=" * 50)
-
-    result = run_pipeline(TEST_IMAGE)
-    save_pipeline_output(result)
-
-    print("=" * 50)
-    print(f"Layers:     {len(result['layers'])}")
-    print(f"Image:      {result['image_w']}x{result['image_h']}")
-    print(f"Time:       {result['processing_time_s']}s")
-    print("=" * 50)
+    return out_path

proposal_engine.py

@@ -0,0 +1,171 @@
+import numpy as np
+
+SEMANTIC_REJECT = {
+    "background", "wall", "sky", "floor", "ground",
+    "ceiling", "road", "pavement", "surface"
+}
+
+MIN_AREA_FRACTION = 0.001
+MAX_AREA_FRACTION = 0.80
+DUPLICATE_IOU_THRESHOLD = 0.70
+
+
+def compute_iou(a, b):
+    ax2 = a["x"] + a["w"]
+    ay2 = a["y"] + a["h"]
+    bx2 = b["x"] + b["w"]
+    by2 = b["y"] + b["h"]
+
+    ix1 = max(a["x"], b["x"])
+    iy1 = max(a["y"], b["y"])
+    ix2 = min(ax2, bx2)
+    iy2 = min(ay2, by2)
+
+    if ix2 <= ix1 or iy2 <= iy1:
+        return 0.0
+
+    intersection = (ix2 - ix1) * (iy2 - iy1)
+    union = a["w"] * a["h"] + b["w"] * b["h"] - intersection
+    return intersection / union if union > 0 else 0.0
+
+
+def is_fully_inside(inner, outer):
+    return (
+        inner["x"] >= outer["x"] and
+        inner["y"] >= outer["y"] and
+        inner["x"] + inner["w"] <= outer["x"] + outer["w"] and
+        inner["y"] + inner["h"] <= outer["y"] + outer["h"]
+    )
+
+
+def semantic_filter(proposals):
+    accepted, rejected = [], []
+    for p in proposals:
+        label = p.get("label", "").lower().strip()
+        if label in SEMANTIC_REJECT:
+            rejected.append((p, "semantic"))
+        else:
+            accepted.append(p)
+    return accepted, rejected
+
+
+def area_filter(proposals, img_w, img_h):
+    image_area = img_w * img_h
+    accepted, rejected = [], []
+    for p in proposals:
+        fraction = (p["w"] * p["h"]) / image_area
+        if fraction < MIN_AREA_FRACTION:
+            rejected.append((p, "too small"))
+        elif fraction > MAX_AREA_FRACTION:
+            rejected.append((p, "too large"))
+        else:
+            accepted.append(p)
+    return accepted, rejected
+
+
+def deduplicate(proposals):
+    kept, rejected = [], []
+    for candidate in proposals:
+        duplicate = False
+        for accepted in kept:
+            if compute_iou(candidate, accepted) > DUPLICATE_IOU_THRESHOLD:
+                duplicate = True
+                break
+        if duplicate:
+            rejected.append((candidate, "duplicate"))
+        else:
+            kept.append(candidate)
+    return kept, rejected
+
+
+def container_filter(proposals):
+    accepted, rejected = [], []
+    for i, candidate in enumerate(proposals):
+        others = [p for j, p in enumerate(proposals) if j != i]
+        children_inside = sum(1 for o in others if is_fully_inside(o, candidate))
+        if children_inside >= 2:
+            rejected.append((candidate, "container"))
+        else:
+            accepted.append(candidate)
+    return accepted, rejected
+
+
+def reject_text_inside_objects(text_proposals, accepted_objects):
+    kept, rejected = [], []
+    for t in text_proposals:
+        inside = any(is_fully_inside(t, obj) for obj in accepted_objects)
+        if inside:
+            rejected.append((t, "inside object"))
+        else:
+            kept.append(t)
+    return kept, rejected
+
+
+def compute_groups(layers):
+    groups = []
+    group_counter = 0
+    annotated = [dict(l, group_id=None, group_role=None) for l in layers]
+
+    for i, root in enumerate(annotated):
+        children = []
+        for j, other in enumerate(annotated):
+            if i == j:
+                continue
+            if is_fully_inside(other, root):
+                children.append(j)
+
+        if not children:
+            continue
+
+        free = [j for j in children if annotated[j]["group_id"] is None]
+        if not free:
+            continue
+
+        group_id    = f"group_{group_counter}"
+        group_label = root.get("label") or root.get("text") or f"Group {group_counter}"
+        group_counter += 1
+
+        annotated[i]["group_id"]   = group_id
+        annotated[i]["group_role"] = "root"
+        for j in free:
+            annotated[j]["group_id"]   = group_id
+            annotated[j]["group_role"] = "child"
+
+        groups.append({
+            "id":    group_id,
+            "label": group_label,
+            "type":  "group",
+        })
+
+    return annotated, groups
+
+
+def print_proposal_report(accepted, all_rejected):
+    print("\n[PROPOSAL] ── Proposal Report ──────────────────")
+    for p in accepted:
+        label = p.get("label") or p.get("text", "")[:20]
+        print(f"[PROPOSAL]   {label:<25} Accepted")
+    for p, reason in all_rejected:
+        label = p.get("label") or p.get("text", "")[:20]
+        print(f"[PROPOSAL]   {label:<25} Rejected ({reason})")
+    print("[PROPOSAL] ─────────────────────────────────────\n")
+
+
+def run_proposal_engine(object_proposals, img_w, img_h):
+    all_rejected = []
+
+    after_semantic, rej = semantic_filter(object_proposals)
+    all_rejected.extend(rej)
+
+    after_area, rej = area_filter(after_semantic, img_w, img_h)
+    all_rejected.extend(rej)
+
+    after_dedup, rej = deduplicate(after_area)
+    all_rejected.extend(rej)
+
+    after_container, rej = container_filter(after_dedup)
+    all_rejected.extend(rej)
+
+    print_proposal_report(after_container, all_rejected)
+
+    return after_container