annotate app

Author: sidxz

annotate/server.py

@@ -55,13 +55,13 @@ def upload():
 def list_pages():
     result = []
     for p in PAGES:
-        boxes = storage.load(p["id"], OUTPUT_DIR)
+        pairs = storage.load(p["id"], OUTPUT_DIR)
         result.append({
             "id":        p["id"],
             "w":         p["w"],
             "h":         p["h"],
-            "annotated": boxes is not None,        # GT JSON exists (even if [])
-            "n_boxes":   len(boxes) if boxes is not None else 0,
+            "annotated": pairs is not None,     # GT JSON exists (even if [])
+            "n_pairs":   len(pairs) if pairs is not None else 0,
         })
     return jsonify(result)
 
@@ -78,11 +78,11 @@ def serve_image(page_id):
 def get_annotations(page_id):
     page = _find(page_id)
     if not page:
-        return jsonify({"boxes": [], "annotated": False, "w": 0, "h": 0})
-    boxes = storage.load(page_id, OUTPUT_DIR)
+        return jsonify({"pairs": [], "annotated": False, "w": 0, "h": 0})
+    pairs = storage.load(page_id, OUTPUT_DIR)
     return jsonify({
-        "boxes":     boxes or [],
-        "annotated": boxes is not None,
+        "pairs":     pairs or [],
+        "annotated": pairs is not None,
         "w":         page["w"],
         "h":         page["h"],
     })
@@ -94,8 +94,8 @@ def post_annotations(page_id):
     if not page:
         return jsonify({"error": "unknown page"}), 404
     data = request.get_json()
-    storage.save(page_id, data["boxes"], page["w"], page["h"], OUTPUT_DIR)
-    return jsonify({"saved": len(data["boxes"]), "annotated": True})
+    storage.save(page_id, data["pairs"], page["w"], page["h"], OUTPUT_DIR)
+    return jsonify({"saved": len(data["pairs"]), "annotated": True})
 
 
 @app.route("/export", methods=["POST"])
@@ -110,8 +110,8 @@ def export():
 
     exported, skipped = 0, 0
     for page in PAGES:
-        boxes = storage.load(page["id"], OUTPUT_DIR)
-        if boxes is None:           # never annotated — discard
+        pairs = storage.load(page["id"], OUTPUT_DIR)
+        if pairs is None:           # never annotated — discard
             skipped += 1
             continue
         src = Path(page["path"])    # currently in tmp/
@@ -141,6 +141,6 @@ def stats():
         "pages":        len(PAGES),
         "annotated":    annotated,
         "pending":      len(PAGES) - annotated,
-        "total_boxes":  sum(p["n_boxes"] for p in pages_data),
+        "total_pairs":  sum(p["n_pairs"] for p in pages_data),
         "output_dir":   str(OUTPUT_DIR),
     })

annotate/storage.py

@@ -1,23 +1,23 @@
 """Annotation persistence — load/save in both GT JSON and YOLO formats.
 
-Ground-truth JSON schema:
+Ground-truth JSON schema (pair format):
     [
       {
-        "class_id":   0,                 # 0 = chemical_structure, 1 = compound_label
-        "bbox":       [x1, y1, x2, y2], # pixel coords of what the user drew
-        "label_text": "",
-        "smiles":     ""
+        "struct_bbox": [x1, y1, x2, y2],   # pixel coords of chemical structure
+        "label_bbox":  [x1, y1, x2, y2],   # pixel coords of label ID  (null = skipped)
+        "label_text":  "",                  # filled in by post-processing, not annotator
+        "smiles":      ""                   # filled in by post-processing, not annotator
       },
       ...
     ]
 
-YOLO .txt (written only when boxes are non-empty):
-    <class_id>  cx  cy  w  h   (all values normalised 0-1)
+YOLO .txt (written only when pairs are non-empty):
+    0  cx  cy  w  h   (normalised 0-1; class 0 = compound_panel = union bbox)
 
 Annotation states:
     - GT JSON absent  → page not yet visited
-    - GT JSON = []    → page explicitly marked as "no panels" (empty page)
-    - GT JSON = [...]  → page annotated with N boxes
+    - GT JSON = []    → page explicitly marked as "no panels"
+    - GT JSON = [...]  → page annotated with N pairs
 """
 
 import json
@@ -33,54 +33,56 @@ def lbl_path(page_id: str, output_dir: Path) -> Path:
 
 
 def load(page_id: str, output_dir: Path) -> list[dict] | None:
-    """Return boxes as [{x1,y1,x2,y2,class_id}] for the canvas, or None if not annotated."""
+    """Return pairs as [{struct_bbox, label_bbox, ...}], or None if not yet annotated."""
     p = gt_path(page_id, output_dir)
     if not p.exists():
         return None                          # not yet visited
-    records = json.loads(p.read_text())
-    boxes = []
-    for r in records:
-        # Support both new schema (bbox + class_id) and legacy (union_bbox)
-        if "bbox" in r:
-            x1, y1, x2, y2 = r["bbox"]
-        else:
-            x1, y1, x2, y2 = r["union_bbox"]
-        boxes.append({"x1": x1, "y1": y1, "x2": x2, "y2": y2,
-                       "class_id": r.get("class_id", 0)})
-    return boxes
-
-
-def save(page_id: str, boxes: list[dict], img_w: int, img_h: int,
+    return json.loads(p.read_text())
+
+
+def save(page_id: str, pairs: list[dict], img_w: int, img_h: int,
          output_dir: Path) -> None:
     """Persist annotations.
 
     GT JSON is *always* written (even for empty pages) so the page is
-    tracked as 'done'.  YOLO .txt is only written when boxes are present.
+    tracked as 'done'.  YOLO .txt is only written when pairs are present.
+
+    YOLO bounding box = union of struct_bbox and label_bbox (class 0).
     """
     gt_dir = output_dir / "ground_truth"
     gt_dir.mkdir(parents=True, exist_ok=True)
 
+    # Ensure each record has the full schema
     records = [
-        {"class_id":   b.get("class_id", 0),
-         "bbox":       [b["x1"], b["y1"], b["x2"], b["y2"]],
-         "label_text": "",
-         "smiles":     ""}
-        for b in boxes
+        {
+            "struct_bbox": pair["struct_bbox"],
+            "label_bbox":  pair.get("label_bbox"),      # None = skipped
+            "label_text":  pair.get("label_text", ""),
+            "smiles":      pair.get("smiles", ""),
+        }
+        for pair in pairs
     ]
     gt_path(page_id, output_dir).write_text(json.dumps(records, indent=2))
 
     lbl = lbl_path(page_id, output_dir)
-    if not boxes:
+    if not pairs:
         lbl.unlink(missing_ok=True)         # no YOLO file for empty pages
         return
 
     lbl.parent.mkdir(parents=True, exist_ok=True)
     with open(lbl, "w") as f:
-        for b in boxes:
-            x1, y1, x2, y2 = b["x1"], b["y1"], b["x2"], b["y2"]
+        for pair in pairs:
+            s = pair["struct_bbox"]          # [x1, y1, x2, y2]
+            l = pair.get("label_bbox")       # [x1, y1, x2, y2] or None
+
+            if l:
+                x1 = min(s[0], l[0]);  y1 = min(s[1], l[1])
+                x2 = max(s[2], l[2]);  y2 = max(s[3], l[3])
+            else:
+                x1, y1, x2, y2 = s
+
             cx = (x1 + x2) / 2 / img_w
             cy = (y1 + y2) / 2 / img_h
             w  = (x2 - x1) / img_w
             h  = (y2 - y1) / img_h
-            cls = b.get("class_id", 0)
-            f.write(f"{cls} {cx:.6f} {cy:.6f} {w:.6f} {h:.6f}\n")
+            f.write(f"0 {cx:.6f} {cy:.6f} {w:.6f} {h:.6f}\n")