feat(smart): accurate pose + intelligent whole-image tags

- wholebody_pose: aspect-preserving crop (fix distortion), single 25% box expand,
TTA-flip for body keypoints, area-weighted person selection, confidence gate
- tag_categorizer: 0MB new models - categorize WD14 tags into emotion/lighting/
style/concept + k-means palette on full frame (true smart tool)
- ensemble_tagger: integrate categorizer (emotion/lighting/style/concept/palette)
+ pose consensus (geometry+WD14) with boosted scores
- app: new sections Emotion/Lighting/Style/Concept/Palette in tagger panel
- i18n: EN/RU labels for new sections

app.py

@@ -536,6 +536,25 @@ def _build_tagger_html(result: dict, lc: str) -> str:
                 + "</div>"
             )
 
+    # ---- Categorized tags (emotion / lighting / style / concept / palette) ----
+    for key, label_key, emoji, css_class in [
+        ("emotion_tags", "tagger_emotion_label", "🎭", "whyx-tagger-emotion-tags"),
+        ("lighting_tags", "tagger_lighting_label", "💡", "whyx-tagger-lighting-tags"),
+        ("style_tags", "tagger_style_label", "🎨", "whyx-tagger-style-tags"),
+        ("concept_tags", "tagger_concept_label", "💭", "whyx-tagger-concept-tags"),
+        ("palette_tags", "tagger_palette_label", "🌈", "whyx-tagger-palette-tags"),
+    ]:
+        cat_tags = result.get(key) or []
+        if cat_tags:
+            lines.append(
+                f"<div class='whyx-tagger-panel-title' style='margin-top:10px;'>{emoji} {t(label_key, lc)}</div>"
+            )
+            lines.append(
+                f"<div class='{css_class}'>"
+                + ", ".join(html.escape(p) for p in cat_tags)
+                + "</div>"
+            )
+
     # ---- Rating distribution ---------------------------------------------------
     lines.append(f"<div class='whyx-tagger-panel-title' style='margin-top:10px;'>{t('tagger_ratings', lc)}</div>")
     rating_colors = {"general": "#34D399", "sensitive": "#FBBF24", "questionable": "#F97316", "explicit": "#EF4444"}
@@ -1044,6 +1063,11 @@ input[type="range"]::-moz-range-thumb { width: 16px !important; height: 16px !im
 .whyx-tagger-bg-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(79,70,229,0.1) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
 .whyx-tagger-seg-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(16,185,129,0.16) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
 .whyx-tagger-depth-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(37,99,235,0.18) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
+.whyx-tagger-emotion-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(244,63,94,0.18) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
+.whyx-tagger-lighting-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(251,191,36,0.18) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
+.whyx-tagger-style-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(168,85,247,0.18) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
+.whyx-tagger-concept-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(59,130,246,0.18) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
+.whyx-tagger-palette-tags { font-size: 12px !important; color: var(--text-dim) !important; line-height: 1.4 !important; background: var(--input-bg) !important; border: 1px solid rgba(16,185,129,0.18) !important; border-radius: var(--radius-sm) !important; padding: 6px 10px !important; margin-top: 4px !important; }
 .whyx-tagger-control-img { border-radius: var(--radius-md) !important; overflow: hidden !important; border: 1px solid var(--glass-border) !important; }
 .whyx-tagger-control-img img { border-radius: var(--radius-md) !important; }
 

scripts/validate_smart_accuracy.py

@@ -0,0 +1,124 @@
+"""Validate pose + smart analysis accuracy on real images.
+
+Runs the wholebody pose estimator and tag categorizer on images from a
+directory, reports detection rate / confidence / tags, and saves skeleton
+overlays for visual inspection.
+
+Usage:
+    python scripts/validate_smart_accuracy.py <image_dir> [--limit N] [--out DIR]
+"""
+import os
+import sys
+import argparse
+import json
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageOps
+
+_COCO_SKELETON = [
+    (0, 1), (0, 2), (1, 3), (2, 4),
+    (5, 6), (5, 7), (7, 9),
+    (6, 8), (8, 10),
+    (5, 11), (6, 12), (11, 12),
+    (11, 13), (13, 15),
+    (12, 14), (14, 16),
+]
+
+
+def draw_skeleton(img, kpts, color=(0, 255, 100), width=2):
+    canvas = img.convert("RGB").copy()
+    draw = ImageDraw.Draw(canvas)
+    kpts = np.asarray(kpts)
+    if kpts.ndim != 2 or kpts.shape[0] < 17:
+        return canvas
+    for a, b in _COCO_SKELETON:
+        if kpts[a, 2] >= 0.3 and kpts[b, 2] >= 0.3:
+            draw.line([kpts[a, 0], kpts[a, 1], kpts[b, 0], kpts[b, 1]],
+                      fill=color, width=width)
+    for i in range(17):
+        if kpts[i, 2] >= 0.3:
+            x, y = int(kpts[i, 0]), int(kpts[i, 1])
+            draw.ellipse([x - 3, y - 3, x + 3, y + 3], fill=(255, 80, 80))
+    return canvas
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("image_dir")
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--out", default=None)
+    args = parser.parse_args()
+
+    img_dir = Path(args.image_dir)
+    files = sorted([f for f in img_dir.iterdir()
+                    if f.suffix.lower() in (".jpg", ".jpeg", ".png", ".webp")])
+    if args.limit > 0:
+        files = files[:args.limit]
+
+    out_dir = Path(args.out) if args.out else img_dir / "smart_validation"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    from src.wholebody_pose import get_wholebody_tagger
+    from src.tag_categorizer import categorize_tags
+
+    tagger = get_wholebody_tagger()
+    results = []
+    detected = 0
+    total_conf = 0.0
+
+    for i, f in enumerate(files):
+        try:
+            pil = ImageOps.exif_transpose(Image.open(f).convert("RGB"))
+        except Exception as e:
+            print(f"[{i+1}/{len(files)}] SKIP {f.name}: {e}")
+            continue
+
+        res = tagger.estimate(pil)
+        n_people = res.get("people_count", 0)
+        conf = res.get("pose_score", 0.0)
+        tags = res.get("pose_tags", [])
+        kpts = res.get("keypoints", [])
+
+        if n_people > 0 and kpts:
+            detected += 1
+            total_conf += conf
+            overlay = draw_skeleton(pil, kpts)
+            overlay.save(out_dir / f"pose_{f.stem}.jpg", quality=90)
+
+        # Categorize (use dummy WD14 tags from pose for demo)
+        cat = categorize_tags(tags, np.asarray(pil))
+
+        entry = {
+            "image": f.name,
+            "people": n_people,
+            "pose_score": round(conf, 4),
+            "pose_tags": tags,
+            "categories": {k: v for k, v in cat.items() if v},
+        }
+        results.append(entry)
+        status = "OK" if n_people > 0 else "MISS"
+        print(f"[{i+1}/{len(files)}] {status} {f.name}: people={n_people} "
+              f"conf={conf:.3f} tags={tags[:5]}")
+
+    summary = {
+        "total": len(files),
+        "detected": detected,
+        "detection_rate": round(detected / max(len(files), 1), 4),
+        "avg_confidence": round(total_conf / max(detected, 1), 4),
+        "results": results,
+    }
+    (out_dir / "smart_summary.json").write_text(
+        json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    print(f"\n=== SUMMARY ===")
+    print(f"Total: {len(files)}, Detected: {detected} "
+          f"({summary['detection_rate']:.1%})")
+    print(f"Avg confidence: {summary['avg_confidence']:.3f}")
+    print(f"Output: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

src/ensemble_tagger.py

@@ -280,13 +280,49 @@ class EnsembleTagger:
             {"primary": w_primary, "joy": w_joy},
         )
 
+    # Geometry pose tag → WD14 equivalents for consensus boosting.
+    _POSE_CONSENSUS_MAP = {
+        "standing": {"standing"},
+        "sitting": {"sitting"},
+        "lying": {"lying", "on_back", "on_side", "on_stomach"},
+        "jumping": {"jumping"},
+        "squatting": {"squatting", "crouching"},
+        "crouching": {"crouching", "squatting"},
+        "bent_over": {"bent_over"},
+        "arms_up": {"arms_up", "arm_up", "arms_raised"},
+        "one_arm_up": {"arm_up", "arms_up"},
+        "arms_behind_head": {"arms_behind_head", "arm_behind_head"},
+        "arms_crossed": {"arms_crossed", "crossed_arms"},
+        "arms_at_sides": {"arms_at_sides"},
+        "hands_on_hips": {"hands_on_hips", "hand_on_hip"},
+        "legs_apart": {"legs_apart", "spread_legs"},
+        "crossed_legs": {"crossed_legs", "leg_cross"},
+        "splits": {"splits", "split"},
+        "tiptoes": {"tiptoes"},
+        "looking_left": {"looking_to_the_side"},
+        "looking_right": {"looking_to_the_side"},
+        "open_mouth": {"open_mouth", "mouth_open"},
+        "closed_eyes": {"closed_eyes", "eyes_closed"},
+    }
+
     @staticmethod
     def _fold_pose(result: dict, pose_tags: list[str]) -> dict:
-        """Fold geometry-derived pose tags into the general tag list."""
+        """Fold geometry-derived pose tags into the general tag list.
+
+        Applies consensus: tags confirmed by both geometry AND WD14 get a
+        stronger boost; geometry-only tags get a weaker boost.
+        """
         gen = dict(result.get("general", {}))
+        wd14_lower = {t.lower().replace(" ", "_") for t in gen.keys()}
         for pt in pose_tags:
             if pt not in gen:
-                gen[pt] = _POSE_BOOST
+                # Check if WD14 has a matching tag (consensus)
+                wd_matches = EnsembleTagger._POSE_CONSENSUS_MAP.get(pt, {pt})
+                has_consensus = any(m in wd14_lower for m in wd_matches)
+                if has_consensus:
+                    gen[pt] = min(_POSE_BOOST * 1.4, 0.95)
+                else:
+                    gen[pt] = _POSE_BOOST * 0.7
         result["general"] = dict(sorted(gen.items(), key=lambda kv: -kv[1]))
         result["pose_tags"] = pose_tags
         result["caption"] = _esc_for_output(", ".join(result["general"].keys()))
@@ -390,6 +426,14 @@ class EnsembleTagger:
             except Exception:
                 seg_tags = []
 
+        # Tag categorization (emotion / lighting / style / concept / palette)
+        cat_tags: dict[str, list[str]] = {}
+        try:
+            from src.tag_categorizer import categorize_tags
+            cat_tags = categorize_tags(wd14_tags, arr)
+        except Exception:
+            cat_tags = {}
+
         # Fold all smart tags at once
         self._fold_smart_tags(result, {
             "anatomy": anatomy_tags,
@@ -398,6 +442,8 @@ class EnsembleTagger:
         })
         self._fold_extra_tags(result, depth_tags, "depth")
         self._fold_extra_tags(result, seg_tags, "segmentation")
+        for cat in ("emotion", "lighting", "style", "concept", "palette"):
+            self._fold_extra_tags(result, cat_tags.get(cat, []), cat)
 
         return result
 

src/i18n.py

@@ -351,6 +351,11 @@ L10N = {
         "tagger_background_label": "Background",
         "tagger_segmentation_label": "Scene (segmentation)",
         "tagger_depth_label": "Depth / composition",
+        "tagger_emotion_label": "Emotion",
+        "tagger_lighting_label": "Lighting",
+        "tagger_style_label": "Art style",
+        "tagger_concept_label": "Concept / theme",
+        "tagger_palette_label": "Color palette",
         "tagger_pose_single": "{n} person detected",
         "tagger_pose_many": "{n} people detected",
         "tagger_caption_label": "Natural-language caption",
@@ -743,6 +748,11 @@ L10N = {
         "tagger_background_label": "Фон",
         "tagger_segmentation_label": "Сцена (сегментация)",
         "tagger_depth_label": "Глубина / композиция",
+        "tagger_emotion_label": "Эмоции",
+        "tagger_lighting_label": "Освещение",
+        "tagger_style_label": "Стиль рисовки",
+        "tagger_concept_label": "Концепция / тема",
+        "tagger_palette_label": "Цветовая палитра",
         "tagger_pose_single": "Обнаружен {n} человек",
         "tagger_pose_many": "Обнаружено {n} человек",
         "tagger_caption_label": "Языковое описание сцены",

src/tag_categorizer.py

@@ -0,0 +1,295 @@
+"""Tag categorizer: organizes WD14 tags into semantic categories + image analysis.
+
+Extracts structured categories from the WD14 general tag list and the image
+itself, producing Danbooru-format tags for:
+
+- **emotion**   — facial expression / mood (from WD14 + expression pool)
+- **lighting**  — lighting conditions (from WD14 + lighting pool)
+- **style**     — art style / medium (from WD14 + style pool)
+- **concept**   — theme / genre (rule-based from tag combinations)
+- **palette**   — dominant color analysis (k-means on the full frame)
+
+Zero new model downloads — everything runs on existing WD14 output + numpy.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+
+_DATA_DIR = Path(__file__).resolve().parent.parent / "data" / "tag_pools"
+
+# ---------------------------------------------------------------------------
+# Pool loading (cached)
+# ---------------------------------------------------------------------------
+_pool_cache: dict[str, set[str]] = {}
+
+
+def _load_pool(name: str) -> set[str]:
+    if name in _pool_cache:
+        return _pool_cache[name]
+    path = _DATA_DIR / f"{name}.json"
+    tags: set[str] = set()
+    if path.exists():
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            if isinstance(data, list):
+                for item in data:
+                    if isinstance(item, dict) and "tag" in item:
+                        tags.add(item["tag"].lower().replace(" ", "_"))
+                    elif isinstance(item, str):
+                        tags.add(item.lower().replace(" ", "_"))
+            elif isinstance(data, dict):
+                for v in data.values():
+                    if isinstance(v, list):
+                        for item in v:
+                            if isinstance(item, str):
+                                tags.add(item.lower().replace(" ", "_"))
+        except Exception:
+            pass
+    _pool_cache[name] = tags
+    return tags
+
+
+# ---------------------------------------------------------------------------
+# Category extraction from WD14 tags
+# ---------------------------------------------------------------------------
+
+def _match_pool(wd14_tags: list[str], pool_name: str) -> list[str]:
+    """Return WD14 tags that appear in the given pool."""
+    pool = _load_pool(pool_name)
+    if not pool:
+        return []
+    matched = []
+    for tag in wd14_tags:
+        norm = tag.lower().replace(" ", "_")
+        if norm in pool:
+            matched.append(tag)
+    return matched
+
+
+def categorize_emotions(wd14_tags: list[str]) -> list[str]:
+    """Extract emotion / expression tags from WD14 output."""
+    return _match_pool(wd14_tags, "expression")
+
+
+def categorize_lighting(wd14_tags: list[str]) -> list[str]:
+    """Extract lighting tags from WD14 output."""
+    return _match_pool(wd14_tags, "lighting")
+
+
+def categorize_style(wd14_tags: list[str]) -> list[str]:
+    """Extract art style / medium tags from WD14 output."""
+    return _match_pool(wd14_tags, "style")
+
+
+# ---------------------------------------------------------------------------
+# Concept / theme detection (rule-based)
+# ---------------------------------------------------------------------------
+
+_CONCEPT_RULES: list[tuple[str, set[str], int]] = [
+    # (concept_tag, required_keywords, min_matches)
+    ("cyberpunk", {"neon", "neon_lights", "cyberpunk", "hologram", "futuristic",
+                   "sci-fi", "robot", "android", "mecha", "city", "night"}, 2),
+    ("fantasy", {"fantasy", "magic", "dragon", "elf", "fairy", "wizard",
+                 "castle", "sword", "mythical", "enchanted"}, 2),
+    ("sci-fi", {"sci-fi", "space", "spaceship", "alien", "futuristic",
+                "robot", "android", "mecha", "planet", "stars"}, 2),
+    ("gothic", {"gothic", "dark", "cathedral", "vampire", "bat", "moonlight",
+                "cemetery", "cross", "gargoyle"}, 2),
+    ("steampunk", {"steampunk", "gears", "clockwork", "brass", "victorian",
+                   "airship", "steam"}, 2),
+    ("post-apocalyptic", {"post-apocalyptic", "ruins", "wasteland", "destroyed",
+                          "abandoned", "overgrown", "desolate"}, 2),
+    ("military", {"military", "soldier", "gun", "tank", "war", "battlefield",
+                  "uniform", "camouflage"}, 2),
+    ("school", {"school", "classroom", "uniform", "blackboard", "desk",
+                "school_uniform", "chalkboard"}, 2),
+    ("beach", {"beach", "ocean", "sand", "waves", "seashell", "palm_tree",
+               "swimsuit", "shore"}, 2),
+    ("winter", {"snow", "winter", "ice", "frozen", "snowflake", "cold",
+                "scarf", "snowing"}, 2),
+    ("autumn", {"autumn", "fall_leaves", "maple", "harvest", "orange_leaves",
+                "fallen_leaves", "autumn_leaves"}, 2),
+    ("spring", {"spring", "cherry_blossoms", "sakura", "petals", "blossom",
+                "flower_field"}, 2),
+    ("night_scene", {"night", "moon", "stars", "starry_sky", "moonlight",
+                     "night_sky", "constellation"}, 2),
+    ("underwater", {"underwater", "aquarium", "fish", "coral", "seaweed",
+                    "bubble", "deep_sea"}, 2),
+    ("horror", {"horror", "blood", "gore", "skull", "zombie", "ghost",
+                "haunted", "creepy", "demon"}, 2),
+    ("romantic", {"romantic", "couple", "kiss", "heart", "rose", "candlelight",
+                  "embrace", "holding_hands"}, 2),
+    ("action", {"action", "fighting", "explosion", "dynamic", "battle",
+                "combat", "punch", "kick", "weapon"}, 2),
+    ("slice_of_life", {"slice_of_life", "cozy", "cafe", "cooking", "reading",
+                       "tea", "daily_life", "relaxing"}, 2),
+]
+
+
+def categorize_concept(wd14_tags: list[str]) -> list[str]:
+    """Detect theme / genre concepts from WD14 tag combinations."""
+    tag_set = {t.lower().replace(" ", "_") for t in wd14_tags}
+    concepts = []
+    for concept, keywords, min_matches in _CONCEPT_RULES:
+        matches = sum(1 for kw in keywords if kw in tag_set)
+        if matches >= min_matches:
+            concepts.append(concept)
+    return sorted(concepts)
+
+
+# ---------------------------------------------------------------------------
+# Color palette analysis (k-means on full frame)
+# ---------------------------------------------------------------------------
+
+def _kmeans(pixels: np.ndarray, k: int = 5, max_iter: int = 20) -> np.ndarray:
+    """Simple k-means clustering. Returns (k, 3) centroids."""
+    n = len(pixels)
+    if n == 0:
+        return np.zeros((k, 3), dtype=np.float32)
+    if n < k:
+        k = n
+    rng = np.random.default_rng(42)
+    centroids = pixels[rng.choice(n, k, replace=False)].astype(np.float32)
+    for _ in range(max_iter):
+        dists = np.linalg.norm(pixels[:, None, :] - centroids[None, :, :], axis=2)
+        labels = np.argmin(dists, axis=1)
+        new_centroids = np.zeros_like(centroids)
+        for j in range(k):
+            mask = labels == j
+            if mask.any():
+                new_centroids[j] = pixels[mask].mean(axis=0)
+            else:
+                new_centroids[j] = centroids[j]
+        if np.allclose(centroids, new_centroids, atol=1.0):
+            break
+        centroids = new_centroids
+    return centroids
+
+
+def _rgb_to_hsv(r: float, g: float, b: float) -> tuple[float, float, float]:
+    """Convert RGB [0-255] to HSV (h: 0-360, s: 0-1, v: 0-1)."""
+    r, g, b = r / 255.0, g / 255.0, b / 255.0
+    mx, mn = max(r, g, b), min(r, g, b)
+    d = mx - mn
+    v = mx
+    s = 0.0 if mx == 0 else d / mx
+    if d == 0:
+        h = 0.0
+    elif mx == r:
+        h = 60.0 * (((g - b) / d) % 6)
+    elif mx == g:
+        h = 60.0 * (((b - r) / d) + 2)
+    else:
+        h = 60.0 * (((r - g) / d) + 4)
+    return h, s, v
+
+
+def analyze_palette(img_arr: np.ndarray) -> list[str]:
+    """Analyze dominant colors of the full frame via k-means.
+
+    Returns Danbooru-style color/mood tags.
+    """
+    if img_arr is None or img_arr.size == 0 or img_arr.ndim != 3:
+        return []
+    h, w = img_arr.shape[:2]
+    if h < 16 or w < 16:
+        return []
+
+    # Subsample for speed (max 2000 pixels)
+    pixels = img_arr.reshape(-1, 3).astype(np.float32)
+    if len(pixels) > 2000:
+        idx = np.random.default_rng(42).choice(len(pixels), 2000, replace=False)
+        pixels = pixels[idx]
+
+    centroids = _kmeans(pixels, k=5)
+    tags: set[str] = set()
+
+    # Analyze each centroid
+    hues = []
+    sats = []
+    vals = []
+    for c in centroids:
+        hue, sat, val = _rgb_to_hsv(float(c[0]), float(c[1]), float(c[2]))
+        hues.append(hue)
+        sats.append(sat)
+        vals.append(val)
+
+    avg_sat = float(np.mean(sats))
+    avg_val = float(np.mean(vals))
+
+    # Saturation-based tags
+    if avg_sat < 0.15:
+        tags.add("monochrome")
+    elif avg_sat < 0.30:
+        tags.add("muted_colors")
+    elif avg_sat > 0.65:
+        tags.add("vibrant_colors")
+
+    # Brightness-based tags
+    if avg_val < 0.25:
+        tags.add("dark_colors")
+    elif avg_val > 0.80:
+        tags.add("bright_colors")
+    if 0.55 < avg_val < 0.80 and avg_sat < 0.45:
+        tags.add("pastel_colors")
+
+    # Dominant hue analysis
+    warm_count = sum(1 for h_ in hues if (h_ < 60 or h_ > 300))
+    cool_count = sum(1 for h_ in hues if 150 < h_ < 270)
+    if warm_count >= 3 and warm_count > cool_count:
+        tags.add("warm_colors")
+    elif cool_count >= 3 and cool_count > warm_count:
+        tags.add("cool_colors")
+
+    # Specific dominant colors
+    for c in centroids:
+        hue, sat, val = _rgb_to_hsv(float(c[0]), float(c[1]), float(c[2]))
+        if sat < 0.2 or val < 0.15:
+            continue
+        if hue < 15 or hue > 345:
+            tags.add("red_theme")
+        elif 15 <= hue < 45:
+            tags.add("orange_theme")
+        elif 45 <= hue < 70:
+            tags.add("yellow_theme")
+        elif 70 <= hue < 160:
+            tags.add("green_theme")
+        elif 160 <= hue < 200:
+            tags.add("cyan_theme")
+        elif 200 <= hue < 260:
+            tags.add("blue_theme")
+        elif 260 <= hue < 300:
+            tags.add("purple_theme")
+        elif 300 <= hue < 345:
+            tags.add("pink_theme")
+
+    return sorted(tags)
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+def categorize_tags(wd14_tags: list[str], img_arr: np.ndarray | None = None) -> dict[str, list[str]]:
+    """Categorize WD14 tags and analyze image palette.
+
+    Args:
+        wd14_tags: General tags from WD14 ensemble.
+        img_arr: RGB image as numpy array (H, W, 3 uint8), optional.
+
+    Returns:
+        Dict with keys: emotion, lighting, style, concept, palette.
+        Each maps to a list of Danbooru-style tags.
+    """
+    result = {
+        "emotion": categorize_emotions(wd14_tags),
+        "lighting": categorize_lighting(wd14_tags),
+        "style": categorize_style(wd14_tags),
+        "concept": categorize_concept(wd14_tags),
+        "palette": analyze_palette(img_arr) if img_arr is not None else [],
+    }
+    return result

src/wholebody_pose.py

@@ -130,6 +130,24 @@ _DET_CONF = 0.30
 _DET_NMS = 0.65
 _KPT_CONF = 0.30
 
+# TTA (test-time augmentation): flip the crop horizontally, run DWPose again,
+# flip the body keypoints back and average. Improves keypoint stability at the
+# cost of ~2x inference time. Face/hands are NOT flipped (risky index mapping).
+_POSE_TTA = os.environ.get("WHYX_POSE_TTA", "1").strip().lower() in ("1", "true", "yes")
+
+# COCO-17 horizontal flip pairs (indices into the 17 body keypoints).
+_COCO_FLIP_PAIRS = [
+    (1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12), (13, 14), (15, 16),
+]
+
+# Minimum mean body-keypoint confidence to emit pose tags. Below this the
+# detection is considered unreliable and tags are suppressed (keypoints kept).
+_POSE_TAG_CONF_GATE = 0.35
+
+# Single aspect-aware box expansion applied before cropping (replaces the old
+# double 15%+20% expansion that shrank the person too much).
+_BOX_EXPAND = 1.25
+
 
 def _sigmoid(x: np.ndarray) -> np.ndarray:
     return 1.0 / (1.0 + np.exp(-np.clip(x, -15, 15)))
@@ -151,6 +169,76 @@ def _letterbox(im: np.ndarray, size: int = _DET_SIZE) -> tuple[np.ndarray, float
     return canvas, scale, float(px), float(py)
 
 
+def _aspect_crop(arr: np.ndarray, x1: int, y1: int, x2: int, y2: int,
+                 target_w: int = _POSE_W, target_h: int = _POSE_H,
+                 expand: float = _BOX_EXPAND):
+    """Aspect-preserving crop around a person box, letterboxed to target size.
+
+    Instead of naively resizing the box to ``target_w x target_h`` (which
+    distorts the person when the box aspect != target aspect), this expands
+    the box to match the target aspect ratio, then letterboxes the crop.
+
+    Returns ``(crop_resized, inv_scale, inv_pad_x, inv_pad_y, crop_x1, crop_y1)``
+    where the inverse values map keypoints from crop space back to original
+    image coordinates: ``orig_x = kp_x / inv_scale - inv_pad_x + crop_x1``.
+    """
+    img_h, img_w = arr.shape[:2]
+    bw, bh = x2 - x1, y2 - y1
+    if bw < 10 or bh < 10:
+        return None
+
+    # Expand box
+    mx, my = (x1 + x2) / 2.0, (y1 + y2) / 2.0
+    ebw, ebh = bw * expand, bh * expand
+
+    # Match target aspect ratio (target_w / target_h)
+    target_aspect = target_w / target_h
+    box_aspect = ebw / max(ebh, 1e-6)
+    if box_aspect > target_aspect:
+        # Box is wider than target → expand height
+        ebh = ebw / target_aspect
+    else:
+        # Box is taller than target → expand width
+        ebw = ebh * target_aspect
+
+    # Compute crop region (clamped to image)
+    cx1 = max(0, int(mx - ebw / 2))
+    cy1 = max(0, int(my - ebh / 2))
+    cx2 = min(img_w, int(mx + ebw / 2))
+    cy2 = min(img_h, int(my + ebh / 2))
+    cw, ch = cx2 - cx1, cy2 - cy1
+    if cw < 10 or ch < 10:
+        return None
+
+    crop = arr[cy1:cy2, cx1:cx2]
+
+    # Letterbox crop into target_w x target_h
+    scale = min(target_w / cw, target_h / ch)
+    nw, nh = int(round(cw * scale)), int(round(ch * scale))
+    resized = np.array(Image.fromarray(crop).resize((nw, nh), Image.LANCZOS))
+    canvas = np.full((target_h, target_w, 3), 114, dtype=np.uint8)
+    px = (target_w - nw) // 2
+    py = (target_h - nh) // 2
+    canvas[py:py + nh, px:px + nw] = resized
+
+    return canvas, scale, float(px), float(py), cx1, cy1
+
+
+def _flip_body_kpts(kpts: np.ndarray, width: int) -> np.ndarray:
+    """Horizontally flip body keypoints (first 17) and swap left/right pairs.
+
+    ``kpts`` is ``(133, 3)`` — only the first 17 (COCO body) are flipped.
+    Face/hands are returned unchanged.
+    """
+    out = kpts.copy()
+    body = out[0:17].copy()
+    body[:, 0] = width - 1 - body[:, 0]
+    for a, b in _COCO_FLIP_PAIRS:
+        body[a], body[b] = body[b].copy(), body[a].copy()
+    out[0:17] = body
+    return out
+
+
 def _yolo_decode(out: np.ndarray, scale: float, pad_x: float, pad_y: float,
                  conf_thresh: float = _DET_CONF, nms_thresh: float = _DET_NMS) -> np.ndarray:
     """Decode YOLOX-L output ``(1, 8400, 85)`` into ``(N, 6)`` boxes.
@@ -651,18 +739,9 @@ class WholebodyPoseEstimator:
             y2 = int(min(img_h, cy + h / 2))
             if x2 - x1 < 20 or y2 - y1 < 20:
                 continue
-            # Expand box by 15% to include hands/face context.
-            bw, bh = x2 - x1, y2 - y1
-            mx, my = (x1 + x2) / 2, (y1 + y2) / 2
-            nw = int(bw * 1.15)
-            nh = int(bh * 1.15)
-            cx1 = max(0, int(mx - nw / 2))
-            cy1 = max(0, int(my - nh / 2))
-            cx2 = min(img_w, int(mx + nw / 2))
-            cy2 = min(img_h, int(my + nh / 2))
-            if cx2 - cx1 < 20 or cy2 - cy1 < 20:
-                continue
-            boxes.append([cx1, cy1, cx2, cy2, score, 0.0])
+            # No expansion here — _aspect_crop applies a single aspect-aware
+            # expansion (_BOX_EXPAND) before cropping.
+            boxes.append([x1, y1, x2, y2, score, 0.0])
 
         if not boxes:
             return np.zeros((0, 6), dtype=np.float32)
@@ -695,45 +774,64 @@ class WholebodyPoseEstimator:
 
         persons: list[np.ndarray] = []
         confs: list[float] = []
+        areas: list[float] = []
         for box in boxes:
             x1, y1, x2, y2 = (int(round(v)) for v in box[:4])
             x1, y1 = max(0, x1), max(0, y1)
             x2, y2 = min(img_w, x2), min(img_h, y2)
             if x2 - x1 < 10 or y2 - y1 < 10:
                 continue
-            # Expand crop by 20% to include hands/face context.
-            bw, bh = x2 - x1, y2 - y1
-            mx, my = (x1 + x2) / 2, (y1 + y2) / 2
-            nw = int(bw * 1.2)
-            nh = int(bh * 1.2)
-            cx1 = max(0, int(mx - nw / 2))
-            cy1 = max(0, int(my - nh / 2))
-            cx2 = min(img_w, int(mx + nw / 2))
-            cy2 = min(img_h, int(my + nh / 2))
-            crop = arr[cy1:cy2, cx1:cx2]
-            crop_resized = np.array(Image.fromarray(crop).resize((_POSE_W, _POSE_H), Image.LANCZOS))
+
+            # Aspect-preserving crop (fixes the old distortion bug).
+            crop_data = _aspect_crop(arr, x1, y1, x2, y2)
+            if crop_data is None:
+                continue
+            crop_resized, inv_scale, inv_px, inv_py, crop_x1, crop_y1 = crop_data
+
             kpts = self._estimate_crop(crop_resized)
+
+            # TTA: flip horizontally, re-run, flip body kpts back, average.
+            if _POSE_TTA:
+                flipped_img = crop_resized[:, ::-1, :].copy()
+                kpts_flip = self._estimate_crop(flipped_img)
+                kpts_flip = _flip_body_kpts(kpts_flip, _POSE_W)
+                # Average body keypoints (0-16); keep face/hands from original.
+                avg_body = (kpts[0:17] + kpts_flip[0:17]) / 2.0
+                kpts[0:17] = avg_body
+
             # Map keypoints from crop space back to original image coords.
-            kpts[:, 0] = kpts[:, 0] / _POSE_W * (cx2 - cx1) + cx1
-            kpts[:, 1] = kpts[:, 1] / _POSE_H * (cy2 - cy1) + cy1
+            kpts[:, 0] = (kpts[:, 0] - inv_px) / inv_scale + crop_x1
+            kpts[:, 1] = (kpts[:, 1] - inv_py) / inv_scale + crop_y1
+
             persons.append(kpts)
-            confs.append(float(np.mean(kpts[:, 2])))
+            body_conf = float(np.mean(kpts[0:17, 2]))
+            confs.append(body_conf)
+            areas.append(float((x2 - x1) * (y2 - y1)))
 
         if not persons:
             return {"pose_tags": [], "people_count": 0, "pose_score": 0.0,
                     "keypoints": [], "body_kpts": [], "face_kpts": [], "hand_kpts": []}
 
-        best = int(np.argmax(confs))
+        # Select primary person: weighted by box area * body confidence.
+        max_area = max(areas) if areas else 1.0
+        scores = [c * (0.5 + 0.5 * (a / max_area)) for c, a in zip(confs, areas)]
+        best = int(np.argmax(scores))
         best_kpts = persons[best]
-        pose_tags = _wholebody_tags(best_kpts, img_w, img_h)
+        best_conf = confs[best]
+
+        # Confidence gate: suppress pose tags when body keypoints are unreliable.
+        if best_conf >= _POSE_TAG_CONF_GATE:
+            pose_tags = _wholebody_tags(best_kpts, img_w, img_h)
+        else:
+            pose_tags = []
 
         if _DEBUG:
-            print(f"[wholebody] persons={len(persons)} score={confs[best]:.3f} tags={pose_tags}")
+            print(f"[wholebody] persons={len(persons)} conf={best_conf:.3f} tags={pose_tags}")
 
         return {
             "pose_tags": pose_tags,
             "people_count": len(persons),
-            "pose_score": round(confs[best], 4),
+            "pose_score": round(best_conf, 4),
             "keypoints": best_kpts.tolist(),
             "body_kpts": best_kpts[0:17].tolist(),
             "face_kpts": best_kpts[23:91].tolist(),

tests/test_ensemble.py

@@ -4,6 +4,7 @@ import sys
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 import numpy as np
+import pytest
 from PIL import Image
 
 from src.ensemble_tagger import (
@@ -84,14 +85,32 @@ def test_merge_wd_joy_none_second_vote():
 def test_fold_pose_injects_tags():
     result = _primary_result()
     EnsembleTagger._fold_pose(result, ["standing", "arms_up"])
-    assert result["general"]["standing"] == _POSE_BOOST
-    assert result["general"]["arms_up"] == _POSE_BOOST
+    # No WD14 consensus → weaker boost (0.7 * _POSE_BOOST)
+    assert result["general"]["standing"] == pytest.approx(_POSE_BOOST * 0.7)
+    assert result["general"]["arms_up"] == pytest.approx(_POSE_BOOST * 0.7)
     assert result["pose_tags"] == ["standing", "arms_up"]
     # pose tag lands in the caption/taglist
     assert "standing" in result["caption"]
     assert "standing" in result["taglist"]
 
 
+def test_fold_pose_consensus_boost():
+    """Pose tags confirmed by WD14 get a stronger boost."""
+    result = _primary_result()
+    # Add a WD14 tag that matches "sitting" consensus
+    result["general"]["sitting"] = 0.6
+    EnsembleTagger._fold_pose(result, ["sitting"])
+    # "sitting" already in general → keeps its own confidence
+    assert result["general"]["sitting"] == 0.6
+
+    # Test consensus with a tag NOT already in general but WD14 has equivalent
+    result2 = _primary_result()
+    result2["general"]["on_back"] = 0.5  # WD14 equivalent of "lying"
+    EnsembleTagger._fold_pose(result2, ["lying"])
+    # "lying" not in general, but "on_back" matches consensus → strong boost
+    assert result2["general"]["lying"] == pytest.approx(min(_POSE_BOOST * 1.4, 0.95))
+
+
 def test_fold_pose_keeps_existing_tag():
     result = _primary_result()
     EnsembleTagger._fold_pose(result, ["a"])

tests/test_tag_categorizer.py

@@ -0,0 +1,188 @@
+"""Tests for tag_categorizer and wholebody_pose geometry fixes."""
+import numpy as np
+import pytest
+
+from src.tag_categorizer import (
+    categorize_tags, categorize_emotions, categorize_lighting,
+    categorize_style, categorize_concept, analyze_palette,
+)
+from src.wholebody_pose import (
+    _aspect_crop, _flip_body_kpts, _COCO_FLIP_PAIRS, _POSE_W, _POSE_H,
+)
+
+
+# ---------------------------------------------------------------------------
+# Tag categorizer tests
+# ---------------------------------------------------------------------------
+
+def test_categorize_emotions():
+    tags = ["1girl", "smile", "blush", "blue_hair", "angry"]
+    result = categorize_emotions(tags)
+    assert "smile" in result
+    assert "blush" in result
+    assert "angry" in result
+    assert "1girl" not in result
+    assert "blue_hair" not in result
+
+
+def test_categorize_lighting():
+    tags = ["cinematic lighting", "backlighting", "1girl", "sky"]
+    result = categorize_lighting(tags)
+    assert "cinematic lighting" in result
+    assert "backlighting" in result
+    assert "1girl" not in result
+
+
+def test_categorize_style():
+    tags = ["watercolor", "sketch", "1girl", "smile"]
+    result = categorize_style(tags)
+    assert "watercolor" in result
+    assert "sketch" in result
+    assert "1girl" not in result
+
+
+def test_categorize_concept_cyberpunk():
+    tags = ["neon", "city", "night", "futuristic", "1girl"]
+    result = categorize_concept(tags)
+    assert "cyberpunk" in result
+
+
+def test_categorize_concept_winter():
+    tags = ["snow", "winter", "scarf", "1girl"]
+    result = categorize_concept(tags)
+    assert "winter" in result
+
+
+def test_categorize_concept_no_match():
+    tags = ["1girl", "smile", "blue_hair"]
+    result = categorize_concept(tags)
+    assert result == []
+
+
+def test_analyze_palette_warm():
+    # Create a warm-toned image (reds/oranges)
+    img = np.zeros((100, 100, 3), dtype=np.uint8)
+    img[:, :, 0] = 200  # high red
+    img[:, :, 1] = 100  # medium green
+    img[:, :, 2] = 50   # low blue
+    result = analyze_palette(img)
+    assert "warm_colors" in result
+
+
+def test_analyze_palette_cool():
+    # Create a cool-toned image (blues)
+    img = np.zeros((100, 100, 3), dtype=np.uint8)
+    img[:, :, 0] = 50
+    img[:, :, 1] = 100
+    img[:, :, 2] = 200
+    result = analyze_palette(img)
+    assert "cool_colors" in result
+
+
+def test_analyze_palette_monochrome():
+    # Grayscale image
+    img = np.full((100, 100, 3), 128, dtype=np.uint8)
+    result = analyze_palette(img)
+    assert "monochrome" in result
+
+
+def test_analyze_palette_empty():
+    assert analyze_palette(None) == []
+    assert analyze_palette(np.zeros((5, 5, 3), dtype=np.uint8)) == []
+
+
+def test_categorize_tags_full():
+    tags = ["1girl", "smile", "cinematic lighting", "watercolor", "neon", "city"]
+    img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+    result = categorize_tags(tags, img)
+    assert "emotion" in result
+    assert "lighting" in result
+    assert "style" in result
+    assert "concept" in result
+    assert "palette" in result
+    assert "smile" in result["emotion"]
+    assert "cinematic lighting" in result["lighting"]
+    assert "watercolor" in result["style"]
+
+
+# ---------------------------------------------------------------------------
+# Geometry tests (aspect crop + flip)
+# ---------------------------------------------------------------------------
+
+def test_aspect_crop_square_box():
+    """Square box should produce a valid crop at target size."""
+    arr = np.random.randint(0, 255, (400, 400, 3), dtype=np.uint8)
+    result = _aspect_crop(arr, 100, 100, 300, 300)
+    assert result is not None
+    crop, scale, px, py, cx1, cy1 = result
+    assert crop.shape == (_POSE_H, _POSE_W, 3)
+
+
+def test_aspect_crop_wide_box():
+    """Wide box should be letterboxed vertically, not distorted."""
+    arr = np.random.randint(0, 255, (400, 600, 3), dtype=np.uint8)
+    result = _aspect_crop(arr, 50, 150, 550, 250)  # 500x100 wide box
+    assert result is not None
+    crop, scale, px, py, cx1, cy1 = result
+    assert crop.shape == (_POSE_H, _POSE_W, 3)
+    # Wide box → letterboxed top/bottom → py > 0
+    assert py > 0
+
+
+def test_aspect_crop_tall_box():
+    """Tall box should be letterboxed horizontally, not distorted."""
+    arr = np.random.randint(0, 255, (600, 400, 3), dtype=np.uint8)
+    result = _aspect_crop(arr, 150, 50, 250, 550)  # 100x500 tall box
+    assert result is not None
+    crop, scale, px, py, cx1, cy1 = result
+    assert crop.shape == (_POSE_H, _POSE_W, 3)
+    # Tall box → letterboxed left/right → px > 0
+    assert px > 0
+
+
+def test_aspect_crop_too_small():
+    """Tiny box should return None."""
+    arr = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
+    result = _aspect_crop(arr, 10, 10, 15, 15)
+    assert result is None
+
+
+def test_flip_body_kpts_symmetry():
+    """Flipping twice should return to original (for body keypoints)."""
+    kpts = np.random.rand(133, 3).astype(np.float32)
+    kpts[:, 0] *= _POSE_W  # x in crop space
+    kpts[:, 1] *= _POSE_H  # y in crop space
+    kpts[:, 2] = 0.9       # confidence
+
+    flipped = _flip_body_kpts(kpts, _POSE_W)
+    double_flipped = _flip_body_kpts(flipped, _POSE_W)
+
+    # Body keypoints should be back to original
+    np.testing.assert_allclose(double_flipped[0:17], kpts[0:17], atol=1.0)
+    # Face/hands should be unchanged after both flips
+    np.testing.assert_allclose(double_flipped[17:], kpts[17:], atol=1e-5)
+
+
+def test_flip_body_kpts_swaps_pairs():
+    """Flip should swap left/right keypoint pairs."""
+    kpts = np.zeros((133, 3), dtype=np.float32)
+    # Set left shoulder (index 5) at x=100, right shoulder (index 6) at x=200
+    kpts[5] = [100, 50, 0.9]
+    kpts[6] = [200, 50, 0.9]
+
+    flipped = _flip_body_kpts(kpts, _POSE_W)
+
+    # After flip: left shoulder should be at (POSE_W-1-200), right at (POSE_W-1-100)
+    # But they're also swapped, so index 5 gets old index 6's flipped position
+    expected_x5 = _POSE_W - 1 - 200
+    expected_x6 = _POSE_W - 1 - 100
+    assert abs(flipped[5, 0] - expected_x5) < 1.0
+    assert abs(flipped[6, 0] - expected_x6) < 1.0
+
+
+def test_flip_pairs_cover_all_limbs():
+    """All COCO flip pairs should be valid indices in 0-16."""
+    for a, b in _COCO_FLIP_PAIRS:
+        assert 0 <= a <= 16
+        assert 0 <= b <= 16
+        assert a != b