Add list of artists and make eyes only capture one eye with square.

app/view_extractor.py

@@ -70,6 +70,69 @@ def _shrink(img: np.ndarray, limit: int):
     return small, s
 
 
+def _pad_to_square_rgb(img: np.ndarray) -> np.ndarray:
+    """
+    Pad an RGB crop to a square (1:1) using edge-padding.
+    This guarantees 1:1 aspect ratio without stretching content.
+    """
+    if img is None or img.size == 0:
+        return img
+    h, w = img.shape[:2]
+    if h == w:
+        return img
+    s = max(h, w)
+    pad_y = s - h
+    pad_x = s - w
+    top = pad_y // 2
+    bottom = pad_y - top
+    left = pad_x // 2
+    right = pad_x - left
+    return np.pad(img, ((top, bottom), (left, right), (0, 0)), mode="edge")
+
+
+def _square_box_from_rect(rect, *, scale: float, W: int, H: int):
+    """
+    Convert a rectangle (x1,y1,x2,y2) into a square box centered on the rect,
+    scaled by `scale`, clamped to image bounds.
+    """
+    x1, y1, x2, y2 = [int(v) for v in rect]
+    cx = (x1 + x2) / 2.0
+    cy = (y1 + y2) / 2.0
+    bw = max(1.0, float(x2 - x1))
+    bh = max(1.0, float(y2 - y1))
+    side = max(bw, bh) * float(scale)
+    nx1 = int(round(cx - side / 2.0))
+    ny1 = int(round(cy - side / 2.0))
+    nx2 = int(round(cx + side / 2.0))
+    ny2 = int(round(cy + side / 2.0))
+    nx1 = max(0, min(W, nx1))
+    ny1 = max(0, min(H, ny1))
+    nx2 = max(0, min(W, nx2))
+    ny2 = max(0, min(H, ny2))
+    if nx2 <= nx1 or ny2 <= ny1:
+        return None
+    return nx1, ny1, nx2, ny2
+
+
+def _split_box_by_midline(box, mid_x: int):
+    """
+    If a box crosses the vertical midline, split into left/right boxes.
+    Returns list of (tag, box).
+    """
+    x1, y1, x2, y2 = [int(v) for v in box]
+    if x1 < mid_x < x2:
+        left = (x1, y1, mid_x, y2)
+        right = (mid_x, y1, x2, y2)
+        out = []
+        if left[2] > left[0]:
+            out.append(("left", left))
+        if right[2] > right[0]:
+            out.append(("right", right))
+        return out
+    tag = "left" if (x1 + x2) / 2.0 <= mid_x else "right"
+    return [(tag, (x1, y1, x2, y2))]
+
+
 def _best_pair(boxes, W: int, H: int):
     clean = [(int(b[0]), int(b[1]), int(b[2]), int(b[3])) for b in boxes]
     if len(clean) < 2:
@@ -268,7 +331,7 @@ class AnimeFaceEyeExtractor:
         Args:
             whole_rgb: HWC RGB uint8
         Returns:
-            (face_rgb, eyes_rgb) as RGB uint8 crops (or None if not found)
+            (face_rgb, eye_rgb) as RGB uint8 crops (or None if not found)
         """
         import cv2
 
@@ -324,22 +387,31 @@ class AnimeFaceEyeExtractor:
                 labs = [("left", cand[0])]
                 origin = cand_origin
 
-        eyes_crop = None
+        eye_crop = None
         if labs:
             src_img = roi if origin == "roi" else face
             bound_h = roi.shape[0] if origin == "roi" else H
-
-            boxes_only = [b for _, b in labs]
-            # union of eye boxes -> single eyes crop (works for the "eyes" view encoder)
-            ux1 = min(b[0] for b in boxes_only)
-            uy1 = min(b[1] for b in boxes_only)
-            ux2 = max(b[2] for b in boxes_only)
-            uy2 = max(b[3] for b in boxes_only)
-            ex1, ey1, ex2, ey2 = _expand((ux1, uy1, ux2, uy2), float(self.cfg.eye_margin), W, bound_h)
-            crop = src_img[ey1:ey2, ex1:ex2]
-            if crop.size > 0 and min(crop.shape[0], crop.shape[1]) >= int(self.cfg.eye_min_size):
-                eyes_crop = crop.copy()
-
-        return face, eyes_crop
+            mid_x = int(round(W / 2.0))
+
+            # Build candidate eye boxes; split any box that crosses the midline
+            candidates = []
+            for tag, b in labs:
+                candidates.extend(_split_box_by_midline(b, mid_x))
+
+            # Deterministically choose the LEFT eye if present; otherwise fall back to largest
+            left_boxes = [b for (t, b) in candidates if t == "left"]
+            pick_from = left_boxes if left_boxes else [b for (_, b) in candidates]
+            chosen = max(pick_from, key=lambda bb: max(1, (bb[2] - bb[0]) * (bb[3] - bb[1])))
+
+            # Square crop around the chosen eye (no stretching); pad to square to guarantee 1:1.
+            scale = 1.0 + float(self.cfg.eye_margin)
+            sq = _square_box_from_rect(chosen, scale=scale, W=W, H=bound_h)
+            if sq is not None:
+                ex1, ey1, ex2, ey2 = sq
+                crop = src_img[ey1:ey2, ex1:ex2]
+                if crop.size > 0 and min(crop.shape[0], crop.shape[1]) >= int(self.cfg.eye_min_size):
+                    eye_crop = _pad_to_square_rgb(crop.copy())
+
+        return face, eye_crop
 
 

webui_gradio.py

@@ -339,6 +339,30 @@ def classify_and_analyze(
         return (f"❌ Failed: {e}",) + empty_result[1:]
 
 
+def list_artists_in_db():
+    """
+    List all artists present in the currently loaded prototype DB.
+    Returns: status, rows [artist, prototype_count]
+    """
+    if APP_STATE.db is None:
+        return "❌ Click **Load** first.", []
+
+    db = APP_STATE.db
+    # Count prototypes per label id
+    counts: dict[int, int] = {}
+    for lid in db.labels.detach().cpu().tolist():
+        counts[int(lid)] = counts.get(int(lid), 0) + 1
+
+    rows: list[list] = []
+    for lid, name in enumerate(db.label_names):
+        c = int(counts.get(int(lid), 0))
+        if c > 0:
+            rows.append([name, c])
+
+    rows.sort(key=lambda r: (-int(r[1]), str(r[0]).lower()))
+    return f"✅ {len(rows)} artists in DB (total prototypes: {int(db.centers.shape[0])}).", rows
+
+
 def _gallery_item_to_pil(item) -> Optional[Image.Image]:
     """Convert a Gradio gallery item to PIL Image (handles various formats)."""
     if item is None:
@@ -600,6 +624,17 @@ def build_ui() -> gr.Blocks:
             uploader.change(_files_to_gallery, inputs=[uploader], outputs=[imgs])
             add_btn.click(add_prototype, inputs=[label, imgs, k_proto, n_trips], outputs=[add_status])
 
+        with gr.Tab("Artists (in DB)"):
+            gr.Markdown(
+                "### Artists in Prototype DB\n"
+                "Shows which artist labels exist in the currently loaded prototype database "
+                "(including any temporary prototypes added in this session)."
+            )
+            refresh_artists = gr.Button("Refresh", variant="secondary")
+            artists_status = gr.Markdown("")
+            artists_table = gr.Dataframe(headers=["Artist", "#Prototypes"], datatype=["str", "number"], interactive=False)
+            refresh_artists.click(list_artists_in_db, inputs=[], outputs=[artists_status, artists_table])
+
     return demo