reflect detection model conf in crop tracking tab

core/drawing.py

@@ -40,3 +40,74 @@ def boxes_to_canvas_json(boxes, scale: float = 1.0, stroke_color: str = "#FF9900
         })
     return {"objects": objects}
 
+def rects_only_json(j: dict) -> dict:
+    """Return a JSON with only rectangle objects (drop labels/others)."""
+    if not j:
+        return {"objects": []}
+    return {"objects": [o for o in (j.get("objects") or []) if o.get("type") == "rect"]}
+
+def get_rect_conf(rect_obj: dict) -> float | None:
+    """Read detector confidence from canvas rect's custom metadata, if any."""
+    meta = rect_obj.get("meta") or {}
+    c = meta.get("det_conf", None)
+    try:
+        return float(c) if c is not None else None
+    except Exception:
+        return None
+
+def inject_index_labels(live_json: dict, offset_px: int = 4, show_conf: bool = True):
+    """
+    Return a copy of live_json with small text labels injected at top-left of each rect.
+    If a rect has meta.det_conf, label becomes 'idx · 0.82' when show_conf=True.
+    """
+    if not live_json:
+        return {"objects": []}
+    objs = list(live_json.get("objects") or [])
+    labeled, idx = [], 1
+    for o in objs:
+        labeled.append(o)
+        if o.get("type") == "rect":
+            text = f"{idx}"
+            if show_conf:
+                conf = get_rect_conf(o)
+                if conf is not None:
+                    text = f"{idx} · {conf:.2f}"
+            left = float(o.get("left", 0.0)) + offset_px
+            top  = float(o.get("top", 0.0)) + offset_px
+            labeled.append({
+                "type": "textbox", "text": text,
+                "left": left, "top": top,
+                "width": max(24, 10*len(text)), "height": 20,
+                "fontSize": 14, "fill": "#ffffff", "backgroundColor": "#111827",
+                "opacity": 0.9, "selectable": False, "evented": False,
+                "hasControls": False, "editable": False, "textAlign": "center",
+                "fontFamily": "sans-serif",
+            })
+            idx += 1
+    return {"objects": labeled}
+
+def seed_canvas_from_boxes(boxes_xyxy, scale: float, det_scores=None):
+    """
+    Build a canvas JSON (rect objects) from xyxy boxes at given display scale.
+    If det_scores provided, store them as rect.meta['det_conf'].
+    """
+    objects = []
+    det_scores = det_scores or [None] * len(boxes_xyxy)
+    for (x0, y0, x1, y1), sc in zip(boxes_xyxy, det_scores):
+        left   = float(x0) * scale
+        top    = float(y0) * scale
+        width  = float(x1 - x0) * scale
+        height = float(y1 - y0) * scale
+        meta = {"origin": "det"}
+        if sc is not None:
+            try:
+                meta["det_conf"] = float(sc)
+            except Exception:
+                pass
+        objects.append({
+            "type": "rect",
+            "left": left, "top": top, "width": width, "height": height,
+            "strokeWidth": 3, "stroke": "#FF9900", "fill": "rgba(0,0,0,0)",
+            "angle": 0, "meta": meta
+        })
+    return {"objects": objects}

ui/workflow.py

@@ -1,17 +1,21 @@
 # ui/workflow.py
-import io
 import streamlit as st
-import numpy as np
 from PIL import Image, ImageOps
-import uuid
 from streamlit_drawable_canvas import st_canvas
-from core.drawing import parse_boxes, boxes_to_canvas_json
-from core.state import set_defaults_from_preds, sync_samples_with_state, update_image_state_from_samples
-from core.exports import export_session
+from core.drawing import (
+    parse_boxes,  # from canvas JSON -> list[xyxy]
+    boxes_to_canvas_json,  # (kept for compatibility; not used here)
+    rects_only_json,
+    get_rect_conf,
+    inject_index_labels,
+    seed_canvas_from_boxes,  # list[xyxy] -> canvas JSON
+)
+from core.state import set_defaults_from_preds, sync_samples_with_state
+from core.exports import export_session  # not used here but retained
 from core.detect_infer import DetConfig
 import torch
 
-# ---- helpers ----
+# ---------------- helpers ----------------
 def _auto_canvas_width():
     try:
         from streamlit_js_eval import get_page_info
@@ -31,17 +35,50 @@ def _det_cfg_from_state():
         half=bool(c.get("half", True)),
     )
 
+def _iou_xyxy(a, b, eps=1e-6):
+    ax1, ay1, ax2, ay2 = map(float, a)
+    bx1, by1, bx2, by2 = map(float, b)
+    ix1, iy1 = max(ax1, bx1), max(ay1, by1)
+    ix2, iy2 = min(ax2, bx2), min(ay2, by2)
+    iw, ih = max(0.0, ix2 - ix1), max(0.0, iy2 - iy1)
+    inter = iw * ih
+    aa = max(0.0, (ax2 - ax1)) * max(0.0, (ay2 - ay1))
+    ba = max(0.0, (bx2 - bx1)) * max(0.0, (by2 - by1))
+    union = aa + ba - inter + eps
+    return inter / union
+
+def _match_det_info_to_live_boxes(item, live_boxes, iou_thresh=0.90):
+    """Align per-box detector info (conf/cls/name) to current live boxes."""
+    base_boxes = item.get("boxes") or []
+    info       = item.get("detector_info") or []
+    out = []
+    for b in live_boxes:
+        best_iou, best_idx = 0.0, -1
+        for j, bb in enumerate(base_boxes):
+            i = _iou_xyxy(b, bb)
+            if i > best_iou:
+                best_iou, best_idx = i, j
+        out.append(info[best_idx] if (best_iou >= iou_thresh and 0 <= best_idx < len(info)) else None)
+    return out
+
+def _reindex_det_info(old_boxes, old_info, new_boxes, iou_thresh=0.90):
+    """Rebuild detector_info aligned to new_boxes by matching from (old_boxes, old_info)."""
+    info_new = []
+    for b in new_boxes:
+        best_iou, best_idx = 0.0, -1
+        for j, ob in enumerate(old_boxes):
+            i = _iou_xyxy(b, ob)
+            if i > best_iou:
+                best_iou, best_idx = i, j
+        info_new.append(old_info[best_idx] if (best_iou >= iou_thresh and 0 <= best_idx < len(old_info)) else None)
+    return info_new
+
 def _run_detection(item):
     det = st.session_state.get("detector")
-    if det is None: return []
+    if det is None:
+        return []
     cfg = _det_cfg_from_state()
-    return det.predict_one(item["pil"], cfg) or []  # list of dicts {'bbox':[x1,y1,x2,y2], 'score', ...}
-
-def _seed_canvas_from_boxes(item, disp_w, base_w):
-    """Write boxes to canvas JSON at display scale (non-destructive)."""
-    if not item.get("boxes"): return
-    scale = float(disp_w) / float(base_w)
-    item["canvas_json"] = boxes_to_canvas_json(item["boxes"], scale=scale)
+    return det.predict_one(item["pil"], cfg) or []  # list of dicts {'bbox':[x1,y1,x2,y2], 'score','cls','name',...}
 
 def _parse_canvas_into_boxes(item, scale, W, H):
     """Read current canvas JSON back into xyxy boxes on the original image grid."""
@@ -50,79 +87,36 @@ def _parse_canvas_into_boxes(item, scale, W, H):
 
 def _classify_now(item, predict_fn):
     """Run classifier on current boxes, then sync to session samples."""
-    if not item.get("boxes"): 
+    if not item.get("boxes"):
         item["preds"] = []; item["user_labels"] = []; item["actions"] = []
         sync_samples_with_state(); return
     crops = [item["pil"].crop(b) for b in item["boxes"]]
     with torch.inference_mode():
         item["preds"] = predict_fn(crops, topk=3)
+    # set_defaults fills current_label/confidence/margin/badges and seeds samples
     set_defaults_from_preds(item)
     item["actions"] = ["pending"] * len(item["boxes"])
     sync_samples_with_state()
 
 def _bump_on_image_switch(ak: str, item: dict):
-    """Force a canvas remount the moment active image changes."""
+    """Force a canvas remount when the active image changes."""
     if st.session_state.get("_last_active_key") != ak:
         item["canvas_rev"] = (item.get("canvas_rev", 0) + 1)
         st.session_state["_last_active_key"] = ak
 
-def _inject_index_labels(live_json: dict, offset_px: int = 4):
-    """
-    Return a copy of live_json with non-selectable numeric labels injected
-    for each rectangle in the order they appear.
-    Labels are Fabric 'textbox' objects and will be ignored by parse_boxes().
-    """
-    if not live_json:
-        return {"objects": []}
-    objs = list(live_json.get("objects") or [])
-    labeled = []
-    idx = 1
-    for o in objs:
-        labeled.append(o)
-        if o.get("type") == "rect":
-            # Place label near rect's top-left in canvas coords
-            left = float(o.get("left", 0.0)) + offset_px
-            top  = float(o.get("top", 0.0)) + offset_px
-            label = {
-                "type": "textbox",
-                "text": str(idx),
-                "left": left,
-                "top": top,
-                "width": 24,
-                "height": 20,
-                "fontSize": 16,
-                "fill": "#ffffff",
-                "backgroundColor": "#111827",  # slate-900
-                "opacity": 0.85,
-                "selectable": False,
-                "evented": False,
-                "hasControls": False,
-                "editable": False,
-                "textAlign": "center",
-                "fontFamily": "sans-serif",
-            }
-            labeled.append(label)
-            idx += 1
-    return {"objects": labeled}
-
-def rects_only_json(j: dict) -> dict:
-    """Return a JSON with only rectangle objects (drop labels/others)."""
-    if not j:
-        return {"objects": []}
-    return {"objects": [o for o in (j.get("objects") or []) if o.get("type") == "rect"]}
-
-# ---- main UI ----
+# ---------------- main UI ----------------
 def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export_root):
     CANVAS_W = _auto_canvas_width()
     if "uploader_rev" not in st.session_state:
         st.session_state.uploader_rev = 0
+
     # =============== (1) Load images ===============
     st.subheader("1) Load image(s)")
     ups = st.file_uploader(
         "Upload one or more images",
         type=["jpg", "jpeg", "png", "bmp"],
         accept_multiple_files=True,
-        key=f"uploader_{st.session_state.uploader_rev}"  # <-- resettable
+        key=f"uploader_{st.session_state.uploader_rev}"  # resettable
     )
     for up in (ups or []):
         key = f"{up.name}-{up.size}"
@@ -131,7 +125,8 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
             st.session_state.images[key] = {
                 "key": key, "name": up.name, "pil": pil,
                 "boxes": [], "preds": [], "user_labels": [], "actions": [],
-                "canvas_json": None,
+                "detector_info": [],  # <— conf/cls/name aligned with boxes
+                "canvas_json": {"objects": []},
                 "canvas_rev": 0,
             }
             if st.session_state.active_key is None:
@@ -142,7 +137,6 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
         st.info("Upload images or load from S3/Drive in the sidebar.")
         return
 
-
     names = [st.session_state.images[k]["name"] for k in keys]
     idx   = keys.index(st.session_state.active_key) if st.session_state.active_key in keys else 0
     chosen = st.selectbox("Active image", names, index=idx)
@@ -161,16 +155,28 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
     if st.session_state.assist_plus and not item.get("boxes") and not item.get("_skip_autodetect_once"):
         det_out = _run_detection(item)
         if det_out:
-            item["boxes"] = [tuple(int(v) for v in o["bbox"]) for o in det_out]
-            _seed_canvas_from_boxes(item, disp_w, base.width)
+            boxes_xyxy = [tuple(int(v) for v in o["bbox"]) for o in det_out]
+            det_info = []
+            for o in det_out:
+                conf  = o.get("score", o.get("conf", o.get("confidence")))
+                clsid = o.get("cls", o.get("class"))
+                name  = o.get("name")
+                det_info.append({
+                    "conf": float(conf) if conf is not None else None,
+                    "cls":  int(clsid) if clsid is not None else None,
+                    "name": name if name is not None else None,
+                })
+            item["boxes"] = boxes_xyxy
+            item["detector_info"] = det_info
+            item["canvas_json"] = seed_canvas_from_boxes(
+                boxes_xyxy, scale, det_scores=[d["conf"] for d in det_info]
+            )
             item["canvas_mode"] = "edit"
-            item["canvas_rev"] = (item.get("canvas_rev", 0) + 1)
-            item["_skip_autodetect_once"] = False
-            _parse_canvas_into_boxes(item, scale, base.width, base.height)  # ensure boxes align with canvas JSON
+            _parse_canvas_into_boxes(item, scale, base.width, base.height)
             _classify_now(item, predict_fn)
             st.rerun()
 
-   # Build an orientation-safe PIL background at display size
+    # Build display background
     bg_pil = ImageOps.exif_transpose(base).resize((disp_w, disp_h), Image.BILINEAR).convert("RGB").copy()
 
     # 2) Draw / edit rectangles
@@ -197,83 +203,124 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
     else:
         st.caption("Tip: Drag on the image to draw new boxes.")
 
-    # ---------- IMPORTANT: prepare initial drawing BEFORE canvas ----------
-    # Use whatever we have persisted so far (no live JSON yet)
-    base_json = rects_only_json(item.get("canvas_json") or {})
-    item["canvas_json"] = base_json  # keep only rects in state
-    display_json = _inject_index_labels(base_json) 
+    # ---------- initial drawing ----------
+    base_json = item.get("canvas_json") or {"objects": []}
+    show_labels = st.checkbox("Show box labels on canvas", value=True, key=f"show_labels_{ak}")
+    display_json = inject_index_labels(base_json, show_conf=False) if show_labels else base_json
 
     # ---------- Canvas ----------
     canvas = st_canvas(
         fill_color="rgba(0,0,0,0)",
         stroke_width=3,
         stroke_color="#FF9900",
-        background_image=bg_pil,                     # PIL image; reliable first paint
+        background_image=bg_pil,
         update_streamlit=True,
         height=disp_h,
         width=disp_w,
-        drawing_mode=drawing_mode,                   # Draw vs Edit (transform)
+        drawing_mode=drawing_mode,
         display_toolbar=True,
-        initial_drawing=display_json,                # labeled copy (not persisted)
+        initial_drawing=display_json,
         key=f"canvas_{ak}_{item.get('canvas_rev', 0)}_{disp_w}x{disp_h}"
     )
 
-    # ---------- Live canvas snapshot (now canvas.json_data exists) ----------
+    # ---------- Live canvas snapshot ----------
     live_json = canvas.json_data or base_json
     objs = list(live_json.get("objects") or [])
-    live_rects_only = rects_only_json(live_json)   # keep only rectangles
-
-    # Re-index labels whenever crop count changes (e.g., a new rectangle drawn)
-    prev_cnt = item.get("_prev_rect_count", None)
-    cur_cnt  = len(live_rects_only["objects"])
-    if prev_cnt is None:
-        item["_prev_rect_count"] = cur_cnt
-    elif cur_cnt != prev_cnt:
-        # persist rects-only, bump rev to redraw with fresh labels 1..N
-        item["canvas_json"] = live_rects_only
-        item["canvas_rev"]  = (item.get("canvas_rev", 0) + 1)
-        item["_prev_rect_count"] = cur_cnt
-        st.rerun()
 
-    # Derive rect indices so Remove buttons target the right object (labels are 'textbox')
+    # Rect indices & objects (ignore overlay textboxes)
     rect_indices = [k for k, o in enumerate(objs) if o.get("type") == "rect"]
+    rect_objs    = [objs[k] for k in rect_indices]
 
-    # Live boxes (original image coords)
+    # Live boxes in original image coords
     live_boxes = parse_boxes(live_json, scale, base.width, base.height)
 
+    # Detector summary (use detector_info matched to live boxes)
+    infos = _match_det_info_to_live_boxes(item, live_boxes)
+    confs = [d["conf"] for d in infos if d and d.get("conf") is not None]
+    if confs:
+        n = len(confs)
+        cmin, cmax = min(confs), max(confs)
+        cmean = sum(confs)/n
+        th = float(st.session_state.get("det_cfg", {}).get("conf", 0.25))
+        below = sum(1 for c in confs if c < th)
+        st.markdown(
+            f"**Active image (detector)** — boxes: {n} · mean **{cmean:.3f}** · "
+            f"min **{cmin:.3f}** · max **{cmax:.3f}** · below {th:.2f}: **{below}/{n}**"
+        )
+
     # ---- Crops on canvas (live) ----
     if live_boxes:
         with st.expander(f"Crops on canvas (live) — {len(live_boxes)}", expanded=False):
             for i, b in enumerate(live_boxes):
-                c1, c2 = st.columns([6, 1])
+                info = infos[i] if i < len(infos) else None
+                det_conf = (info or {}).get("conf", None)
+                # resolve detector class label
+                det_label = None
+                if info:
+                    if info.get("name") is not None:
+                        det_label = str(info["name"])
+                    elif info.get("cls") is not None:
+                        names = st.session_state.get("detector_names") or []
+                        cid = info["cls"]
+                        if isinstance(names, (list, tuple)) and isinstance(cid, int) and 0 <= cid < len(names):
+                            det_label = str(names[cid])
+                        else:
+                            det_label = str(cid)
+
+                c1, c2, c3 = st.columns([6, 3, 1])
                 with c1:
                     st.write(f"#{i+1}  [x0={b[0]}, y0={b[1]}, x1={b[2]}, y1={b[3]}]")
+
                 with c2:
+                    if det_conf is None and not det_label:
+                        st.caption("det: —")
+                    else:
+                        th = float(st.session_state.get("det_cfg", {}).get("conf", 0.25))
+                        status = " ⚠️" if (det_conf is not None and det_conf < th) else ""
+                        parts = []
+                        if det_conf is not None: parts.append(f"{det_conf:.2f}")
+                        if det_label: parts.append(det_label)
+                        st.caption("det: " + " · ".join(parts) + status)
+
+                with c3:
                     if st.button("Remove", key=f"rm_live_{ak}_{i}"):
-                        # Start from the full live JSON, drop the i-th rectangle (labels ignored)
-                        rects = [o for o in (live_json.get("objects") or []) if o.get("type") == "rect"]
-                        if 0 <= i < len(rects):
-                            rects.pop(i)
-                            # Persist rects-only; labels will be re-injected next render and re-indexed 1..N
-                            item["canvas_json"] = {"objects": rects}
+                        # Remove by rect index, then remount canvas
+                        true_idx = rect_indices[i] if i < len(rect_indices) else None
+                        if true_idx is not None and 0 <= true_idx < len(objs):
+                            # snapshot old for detector-info reindex
+                            old_boxes = item.get("boxes") or []
+                            old_info  = item.get("detector_info") or []
+
+                            objs.pop(true_idx)
+                            # if a label textbox immediately follows, drop it too (best-effort)
+                            if true_idx < len(objs) and objs[true_idx].get("type") == "textbox":
+                                objs.pop(true_idx)
+
+                            # update canvas + boxes
+                            live_json["objects"] = objs
+                            item["canvas_json"] = live_json
+                            _parse_canvas_into_boxes(item, scale, base.width, base.height)
+
+                            # reindex detector_info to new boxes
+                            new_boxes = item.get("boxes") or []
+                            item["detector_info"] = _reindex_det_info(old_boxes, old_info, new_boxes)
+
                             item["canvas_mode"] = "edit"
                             item["canvas_rev"]  = (item.get("canvas_rev", 0) + 1)
-                            # predictions are stale after geometry changes
                             item["preds"] = []; item["user_labels"] = []; item["actions"] = []
                             sync_samples_with_state()
                             st.rerun()
 
-
-    # Keep the on-screen count truly live
+    # Always show a live count under the canvas
     st.caption(f"Crops in this image: **{len(live_boxes)}**")
 
-    # Commit canvas into boxes (Save / Lock)
-    # (was: Save/Lock, Clear, Remove). Now: Clear + Remove only.
+    # Commit canvas into boxes (Clear / Remove)
     col_clear, col_remove = st.columns([1, 1])
 
     if col_clear.button("Clear boxes (THIS image)", key=f"clear_{ak}"):
         item["canvas_json"] = {"objects": []}
         item["boxes"] = []; item["preds"] = []; item["user_labels"] = []; item["actions"] = []
+        item["detector_info"] = []  # also clear detector stats
         item["canvas_mode"] = "draw"
         item["canvas_rev"]  = (item.get("canvas_rev", 0) + 1)
         item["_skip_autodetect_once"] = True
@@ -281,45 +328,32 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
         st.rerun()
 
     if col_remove.button("Remove image", key=f"remove_{ak}"):
-        # Choose the next image BEFORE deletion
         remaining_keys = [k for k in st.session_state.images.keys() if k != ak]
         next_key = remaining_keys[0] if remaining_keys else None
-
-        # Delete the image and its samples
         del st.session_state.images[ak]
         st.session_state.all_samples = [s for s in st.session_state.all_samples if s.image_key != ak]
-
-        # Clear the uploader so removed files don't get re-added on rerun
         st.session_state.uploader_rev += 1
-
-        # Switch to the next image (if any) but DO NOT autorun detection once
         st.session_state.active_key = next_key
         if next_key:
             nxt = st.session_state.images[next_key]
             nxt["_skip_autodetect_once"] = True
             nxt["canvas_mode"] = "edit" if nxt.get("boxes") else "draw"
-            nxt["canvas_rev"]  = nxt.get("canvas_rev", 0) + 1  # fresh canvas
-
+            nxt["canvas_rev"]  = nxt.get("canvas_rev", 0) + 1
         st.rerun()
 
-
-
     # =============== (3) Detect / Classify controls ===============
     st.subheader("3) Detect & Classify")
 
     assist_on = bool(st.session_state.get("assist_plus"))
     has_boxes = bool(item.get("boxes"))
 
-    # detect whether the user has drawn rectangles but not saved yet
     canvas_objects = (canvas.json_data or {}).get("objects") or []
     has_canvas_rects = any(obj.get("type") == "rect" for obj in canvas_objects)
     can_classify = has_boxes or has_canvas_rects
 
     # ---------- DETECT ----------
     if assist_on:
-        # Only show detect controls in Assist+ mode
         st.caption("Detect: find objects and write boxes onto the canvas.")
-
         dcol1, dcol2 = st.columns([1, 1])
 
         # First-time Detect (hidden if Assist+ already produced boxes)
@@ -332,8 +366,22 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
                 ):
                     det_out = _run_detection(item)
                     if det_out:
-                        item["boxes"] = [tuple(int(v) for v in o["bbox"]) for o in det_out]
-                        _seed_canvas_from_boxes(item, disp_w, base.width)
+                        boxes_xyxy = [tuple(int(v) for v in o["bbox"]) for o in det_out]
+                        det_info = []
+                        for o in det_out:
+                            conf  = o.get("score", o.get("conf", o.get("confidence")))
+                            clsid = o.get("cls", o.get("class"))
+                            name  = o.get("name")
+                            det_info.append({
+                                "conf": float(conf) if conf is not None else None,
+                                "cls":  int(clsid) if clsid is not None else None,
+                                "name": name if name is not None else None,
+                            })
+                        item["boxes"] = boxes_xyxy
+                        item["detector_info"] = det_info
+                        item["canvas_json"] = seed_canvas_from_boxes(
+                            boxes_xyxy, scale, det_scores=[d["conf"] for d in det_info]
+                        )
                         item["canvas_mode"] = "edit"
                         item["canvas_rev"] = (item.get("canvas_rev", 0) + 1)
                         item["preds"] = []; item["user_labels"] = []; item["actions"] = []
@@ -358,14 +406,34 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
             ):
                 det_out = _run_detection(item)
                 new_boxes = [tuple(int(v) for v in o["bbox"]) for o in det_out]
+                new_info  = []
+                for o in det_out:
+                    conf  = o.get("score", o.get("conf", o.get("confidence")))
+                    clsid = o.get("cls", o.get("class"))
+                    name  = o.get("name")
+                    new_info.append({
+                        "conf": float(conf) if conf is not None else None,
+                        "cls":  int(clsid) if clsid is not None else None,
+                        "name": name if name is not None else None,
+                    })
                 if new_boxes:
                     if rd_mode == "Replace":
                         item["boxes"] = new_boxes
+                        item["detector_info"] = new_info
+                        merged_boxes  = new_boxes
+                        merged_scores = [d["conf"] for d in new_info]
                     else:
-                        item["boxes"] = list(item.get("boxes") or []) + new_boxes
-                    _seed_canvas_from_boxes(item, disp_w, base.width)
+                        old_boxes = list(item.get("boxes") or [])
+                        old_info  = list(item.get("detector_info") or [])
+                        merged_boxes  = old_boxes + new_boxes
+                        item["boxes"] = merged_boxes
+                        item["detector_info"] = old_info + new_info
+                        merged_scores = [d["conf"] for d in (old_info + new_info)]
+
+                    item["canvas_json"] = seed_canvas_from_boxes(
+                        merged_boxes, scale, det_scores=merged_scores
+                    )
                     item["canvas_mode"] = "edit"
-                    item["canvas_rev"] = (item.get("canvas_rev", 0) + 1)
                     item["preds"] = []; item["user_labels"] = []; item["actions"] = []
                     sync_samples_with_state()
                     st.rerun()
@@ -396,27 +464,27 @@ def render_workflow_tab(predict_fn, class_names, class_to_id, model_meta, export
         _classify_now(item, predict_fn)
         st.rerun()
 
-
-    # Quick count
-    st.caption(f"Crops in this image: **{len(live_boxes)}**")
-
     _render_active_summary(class_names)
 
 def _render_active_summary(class_names):
     st.subheader("Summary for Active Image")
-    ak=st.session_state.active_key
+    ak = st.session_state.active_key
     if not st.session_state.all_samples or not ak:
-        st.info("No samples available. Run predictions on images first."); return
-    active=[s for s in st.session_state.all_samples if s.image_key==ak]
-    if not active: st.info("No samples processed for this image yet. Run predictions."); return
-    active.sort(key=lambda s: s.crop_idx); img_data=st.session_state.images[ak]
+        st.info("No samples available. Run predictions on images first.")
+        return
+    active = [s for s in st.session_state.all_samples if s.image_key == ak]
+    if not active:
+        st.info("No samples processed for this image yet. Run predictions.")
+        return
+    active.sort(key=lambda s: s.crop_idx)
+    img_data = st.session_state.images[ak]
     for sample in active:
-        crop_image=img_data["pil"].crop(sample.bbox)
-        col_img,col_details,col_relabel=st.columns([1,2,1.5])
+        crop_image = img_data["pil"].crop(sample.bbox)
+        col_img, col_details, col_relabel = st.columns([1, 2, 1.5])
         with col_img:
             st.image(crop_image, caption=f"Crop {sample.crop_idx+1}", width=180)
         with col_details:
-            top3_str=", ".join([f"{n} ({p:.3f})" for n,p in sample.top3[:3]])
+            top3_str = ", ".join([f"{n} ({p:.3f})" for n, p in sample.top3[:3]])
             st.write(f"**Current Label:** {sample.current_label}")
             st.write(f"**Top-3:** {top3_str}")
             st.write(f"**Confidence:** {sample.confidence:.3f}")
@@ -430,10 +498,16 @@ def _render_active_summary(class_names):
                 idx = class_names.index(sample.current_label) if sample.current_label in class_names else 0
             except Exception:
                 idx = 0
-            new_label = st.selectbox(f"Relabel Crop {sample.crop_idx+1}", class_names, index=idx,
-                                     key=f"wf_summary_relabel_select_{sample.image_key}_{sample.crop_idx}")
+            new_label = st.selectbox(
+                f"Relabel Crop {sample.crop_idx+1}",
+                class_names,
+                index=idx,
+                key=f"wf_summary_relabel_select_{sample.image_key}_{sample.crop_idx}",
+            )
             if new_label != sample.current_label:
-                sample.user_label=new_label; sample.action="relabel"
+                sample.user_label = new_label
+                sample.action = "relabel"
                 from core.state import update_image_state_from_samples
-                update_image_state_from_samples(); st.rerun()
+                update_image_state_from_samples()
+                st.rerun()
         st.divider()