feat: add counting bench, triage, and dataset modules

This commit includes major additions and updates to the frontend and backend architectures, introducing new dataset management, live counting features, batch processing, and triage logic. Includes new UI pages, components, and API routes.

backend/autolabel.py

@@ -9,11 +9,14 @@ keep the user's own corrections out of the way.
 import os
 from typing import List, Optional
 
+from PIL import Image
 from backend import batches, db, jobs, labeling, projects, review
 from backend.batches import BatchError
 
 DEFAULT_THRESHOLD = 0.35
-DEFAULT_IOU = 0.8
+DEFAULT_IOU = 0.0
+
+
 
 
 def start(batch_id: int, threshold: float = DEFAULT_THRESHOLD,
@@ -88,11 +91,15 @@ def _run_autolabel(job) -> None:
 
     custom_path = job.params.get("custom_model_path")
     target_class_names = job.params.get("target_class_names")
+    engine_classes = job.params.get("engine_classes")
+    if not target_class_names and isinstance(engine_classes, dict):
+        c_names = engine_classes.get(selected_engine) or engine_classes.get("sam3") or []
+        if isinstance(c_names, list) and len(c_names) > 0:
+            target_class_names = c_names
 
     if selected_engine == "sam3" and not custom_path:
         allowed_classes_set = {c.strip().lower() for c in target_class_names} if target_class_names else None
         if allowed_classes_set:
-            sam3_target_classes = [c for c in project["classes"] if c["name"].strip().lower() in allowed_classes_set or c["prompt"].strip().lower() in allowed_classes_set]
             # Add any new target class names that aren't in project classes yet
             existing_names = {c["name"].strip().lower() for c in project["classes"]}
             for name in target_class_names:
@@ -100,11 +107,9 @@ def _run_autolabel(job) -> None:
                     try:
                         updated_proj = projects.add_class(project["id"], name=name.strip(), prompt=name.strip())
                         project["classes"] = updated_proj["classes"]
-                        for new_c in project["classes"]:
-                            if new_c["name"].strip().lower() == name.strip().lower() and new_c not in sam3_target_classes:
-                                sam3_target_classes.append(new_c)
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        job.log(f"Warning adding class '{name}': {exc}")
+            sam3_target_classes = [c for c in project["classes"] if c["name"].strip().lower() in allowed_classes_set or c["prompt"].strip().lower() in allowed_classes_set]
         else:
             sam3_target_classes = [c for c in project["classes"]]
 
@@ -149,6 +154,8 @@ def _run_autolabel(job) -> None:
 
         try:
             frame_file = os.path.join(directory, frame["filename"])
+            fw = max(1, frame.get("width") or 1)
+            fh = max(1, frame.get("height") or 1)
             all_raw_detections = []
 
             if yolo_model is not None:
@@ -157,27 +164,41 @@ def _run_autolabel(job) -> None:
                     model_names = results[0].names
                     for box in results[0].boxes:
                         cls_idx = int(box.cls[0].item())
-                        cls_name = str(model_names.get(cls_idx, cls_idx)).strip().lower()
-                        
-                        if allowed_classes_set is not None and cls_name not in allowed_classes_set:
-                            continue
+                        raw_cls_name = str(model_names.get(cls_idx, cls_idx)).strip().lower()
+
+                        target_class_id = name_to_class_id.get(raw_cls_name)
+                        if target_class_id is None:
+                            for item in project["classes"]:
+                                if item["class_id"] == cls_idx:
+                                    target_class_id = item["class_id"]
+                                    break
+                        if target_class_id is None and 0 <= cls_idx < len(project["classes"]):
+                            target_class_id = project["classes"][cls_idx]["class_id"]
 
-                        target_class_id = name_to_class_id.get(cls_name)
                         if target_class_id is None:
                             continue
 
+                        target_cls_obj = next((c for c in project["classes"] if c["class_id"] == target_class_id), None)
+                        proj_cls_name = target_cls_obj["name"].strip().lower() if target_cls_obj else ""
+
+                        if allowed_classes_set is not None:
+                            if (raw_cls_name not in allowed_classes_set and 
+                                proj_cls_name not in allowed_classes_set and 
+                                str(target_class_id) not in allowed_classes_set):
+                                continue
+
                         score = float(box.conf[0].item())
                         xyxyn = box.xyxyn[0].tolist()
                         all_raw_detections.append(labeling.Detection(
                             class_id=target_class_id,
-                            class_name=cls_name,
-                            box=[xyxyn[0]*frame["width"], xyxyn[1]*frame["height"], xyxyn[2]*frame["width"], xyxyn[3]*frame["height"]],
+                            class_name=proj_cls_name or raw_cls_name,
+                            box=[xyxyn[0]*fw, xyxyn[1]*fh, xyxyn[2]*fw, xyxyn[3]*fh],
                             score=score,
                             mask=None
                         ))
 
-            elif selected_engine == "sam3" and sam3_target_classes:
-                prompts = [c["prompt"] for c in sam3_target_classes]
+            if selected_engine == "sam3" and sam3_target_classes:
+                prompts = [(c.get("prompt") or c["name"]).strip() for c in sam3_target_classes]
                 res = labeling.label_image(
                     frame_file, frame["filename"], prompts, conf,
                     iou_threshold=iou_thresh, min_box_frac=job.params.get("min_box_frac", 0.0)
@@ -189,15 +210,17 @@ def _run_autolabel(job) -> None:
                             det.class_id = real_cls["class_id"]
                             det.class_name = real_cls["name"]
                             all_raw_detections.append(det)
+                elif res.error:
+                    job.log(f"[SAM3 ERROR] {frame['filename']}: {res.error}")
 
             kept = labeling.deduplicate(all_raw_detections, iou_threshold=iou_thresh)
             items = []
             for det in kept:
                 if project["label_type"] == "bbox" or det.mask is None:
-                    geom = review.bbox(det.box[0]/frame["width"], det.box[1]/frame["height"], det.box[2]/frame["width"], det.box[3]/frame["height"])
+                    geom = review.bbox(det.box[0]/fw, det.box[1]/fh, det.box[2]/fw, det.box[3]/fh)
                     items.append({"class_id": det.class_id, "geometry": geom, "score": det.score})
                 else:
-                    for geometry in _geometries(det, frame["width"], frame["height"], project["label_type"]):
+                    for geometry in _geometries(det, fw, fh, project["label_type"]):
                         items.append({"class_id": det.class_id, "geometry": geometry, "score": det.score})
 
             if job.params.get("append"):
@@ -211,6 +234,8 @@ def _run_autolabel(job) -> None:
             job.log(f"[ERROR] {frame['filename']}: {exc}")
             job.progress(index + 1, len(frames))
 
+
+
     # "Every frame failed" is not a finished job with no findings — it is a
     # broken run, and reporting `done` for it would be the system lying about
     # its own state. An empty frame is fine (REQ-033); an errored one is not.
@@ -234,3 +259,125 @@ def _reset_reviewed(batch_id: int) -> None:
             "AND review_status = 'approved'",
             (batch_id,),
         )
+
+
+def preview_frame(
+    batch_id: int,
+    frame_id: int,
+    engine: str,
+    threshold: float = DEFAULT_THRESHOLD,
+    iou_threshold: float = DEFAULT_IOU,
+    min_box_frac: float = 0.0,
+    target_class_names: Optional[List[str]] = None,
+    custom_model_path: Optional[str] = None
+) -> List[dict]:
+    batch = batches.get(batch_id)
+    if not batch:
+        raise ValueError("No such batch")
+    project = projects.get(batch["project_id"])
+    
+    frame = next((f for f in batches.frames(batch_id) if f["id"] == frame_id), None)
+    if not frame:
+        raise ValueError("Frame not found")
+        
+    directory = batches.frames_dir(batch["project_slug"], batch_id)
+    frame_file = os.path.join(directory, frame["filename"])
+    fw = max(1, frame.get("width") or 1)
+    fh = max(1, frame.get("height") or 1)
+
+    yolo_model = None
+    sam3_target_classes = []
+    
+    if engine == "sam3" and not custom_model_path:
+        allowed_classes_set = {c.strip().lower() for c in target_class_names} if target_class_names else None
+        if allowed_classes_set:
+            sam3_target_classes = [c for c in project["classes"] if c["name"].strip().lower() in allowed_classes_set or c["prompt"].strip().lower() in allowed_classes_set]
+        else:
+            sam3_target_classes = [c for c in project["classes"]]
+        
+        prompts = [c["prompt"] for c in sam3_target_classes]
+        if prompts:
+            from backend.sam3_engine import get_engine
+            get_engine()
+    else:
+        from ultralytics import YOLO
+        if custom_model_path and os.path.isfile(custom_model_path):
+            m_path = custom_model_path
+        else:
+            m_path = projects.training_start_point(project)
+            with db.cursor() as cur:
+                cur.execute("SELECT weights_path FROM model_versions WHERE project_id = ? ORDER BY version DESC LIMIT 1", (project["id"],))
+                row = cur.fetchone()
+                if row and os.path.isfile(row[0]):
+                    m_path = row[0]
+        yolo_model = YOLO(m_path)
+
+    name_to_class_id = {item["name"].strip().lower(): item["class_id"] for item in project["classes"]}
+    allowed_classes_set = {c.strip().lower() for c in target_class_names} if target_class_names else None
+
+    all_raw_detections = []
+
+    if yolo_model is not None:
+        results = yolo_model.predict(frame_file, conf=threshold, verbose=False)
+        if results and len(results) > 0:
+            model_names = results[0].names
+            for box in results[0].boxes:
+                cls_idx = int(box.cls[0].item())
+                raw_cls_name = str(model_names.get(cls_idx, cls_idx)).strip().lower()
+
+                target_class_id = name_to_class_id.get(raw_cls_name)
+                if target_class_id is None:
+                    for item in project["classes"]:
+                        if item["class_id"] == cls_idx:
+                            target_class_id = item["class_id"]
+                            break
+                if target_class_id is None and 0 <= cls_idx < len(project["classes"]):
+                    target_class_id = project["classes"][cls_idx]["class_id"]
+
+                if target_class_id is None:
+                    continue
+
+                target_cls_obj = next((c for c in project["classes"] if c["class_id"] == target_class_id), None)
+                proj_cls_name = target_cls_obj["name"].strip().lower() if target_cls_obj else ""
+
+                if allowed_classes_set is not None:
+                    if (raw_cls_name not in allowed_classes_set and 
+                        proj_cls_name not in allowed_classes_set and 
+                        str(target_class_id) not in allowed_classes_set):
+                        continue
+
+                score = float(box.conf[0].item())
+                xyxyn = box.xyxyn[0].tolist()
+                all_raw_detections.append(labeling.Detection(
+                    class_id=target_class_id,
+                    class_name=proj_cls_name or raw_cls_name,
+                    box=[xyxyn[0]*fw, xyxyn[1]*fh, xyxyn[2]*fw, xyxyn[3]*fh],
+                    score=score,
+                    mask=None
+                ))
+
+    if engine == "sam3" and sam3_target_classes:
+        prompts = [(c.get("prompt") or c["name"]).strip() for c in sam3_target_classes]
+        res = labeling.label_image(
+            frame_file, frame["filename"], prompts, threshold,
+            iou_threshold=iou_threshold, min_box_frac=min_box_frac
+        )
+        if not res.error and res.detections:
+            for det in res.detections:
+                if 0 <= det.class_id < len(sam3_target_classes):
+                    real_cls = sam3_target_classes[det.class_id]
+                    det.class_id = real_cls["class_id"]
+                    det.class_name = real_cls["name"]
+                    all_raw_detections.append(det)
+
+    kept = labeling.deduplicate(all_raw_detections, iou_threshold=iou_threshold)
+    items = []
+    for det in kept:
+        if project["label_type"] == "bbox" or det.mask is None:
+            geom = review.bbox(det.box[0]/fw, det.box[1]/fh, det.box[2]/fw, det.box[3]/fh)
+            items.append({"class_id": det.class_id, "geometry": geom, "score": det.score})
+        else:
+            for geometry in _geometries(det, fw, fh, project["label_type"]):
+                items.append({"class_id": det.class_id, "geometry": geometry, "score": det.score})
+                
+    return items