Update

README.md

@@ -1,14 +1,54 @@
 ---
-title: Alpeccaai
-emoji: 💻
-colorFrom: red
-colorTo: blue
+title: Alpeccaai Pose
+emoji: 🦴
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.12'
+sdk_version: 5.9.1
 app_file: app.py
 pinned: false
-short_description: 'Advanced ai prototype '
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Alpeccaai Pose
+
+Whole-body 2D pose estimation (DWPose / RTMPose via `rtmlib`) for **RIGFORGE**.
+Returns keypoints in the exact JSON shape RIGFORGE reads under
+**AI keypoints → Import pose keypoints**, and exposes a `/detect` endpoint the
+in-tool **⚡ Detect via HF Space** button calls.
+
+## Deploy (replace the starter template)
+```bash
+git clone https://huggingface.co/spaces/CREATORJD/Alpeccaai
+cd Alpeccaai
+# copy app.py, requirements.txt, README.md into this folder (overwrite app.py)
+git add app.py requirements.txt README.md
+git commit -m "RIGFORGE pose endpoint (DWPose -> rigpose.json)"
+git push
+```
+Keep **Hardware = ZeroGPU** in Space settings. The model is built lazily inside
+the `@spaces.GPU` function so CUDA is visible during the call; it falls back to
+CPU automatically (fine for single images).
+
+## Make the one-click button work
+Set the Space **Visibility = Public** (Settings → Visibility). Then in RIGFORGE,
+type `CREATORJD/Alpeccaai` into the Space field and click **⚡ Detect via HF Space**.
+A private Space can't be called from the static HTML — use the Colab notebook or
+manual import instead.
+
+## Output format
+```json
+{
+  "format": "coco17",
+  "canvas_width": 1122, "canvas_height": 1402,
+  "keypoints": [[x, y, score], ...17],
+  "people": [{ "pose_keypoints_2d": [x,y,s, ...] }]
+}
+```
+`canvas_width/height` let RIGFORGE scale coordinates to its working image exactly.
+
+## Notes
+- Feed **one** figure. For a character sheet, crop the FRONT panel first.
+- For heavily stylized poses, swap in an anime-trained model (Shuhong Chen,
+  *Pose Estimation of Illustrated Characters*, WACV 2022) — output maps into the
+  same importer.

app.py

@@ -0,0 +1,106 @@
+"""
+Alpeccaai Pose — Hugging Face Space (ZeroGPU)
+Runs DWPose / RTMPose whole-body 2D pose via rtmlib and returns keypoint JSON
+in the exact format RIGFORGE's "AI keypoints -> Import pose keypoints" reads.
+
+Endpoint: /detect  (the RIGFORGE "Detect via HF Space" button calls this).
+"""
+import os, json, tempfile
+import numpy as np
+import cv2
+import gradio as gr
+
+# ZeroGPU: CUDA is only visible INSIDE a @spaces.GPU function, so the model is
+# built lazily on first call (see get_model). Off ZeroGPU this is a no-op.
+try:
+    import spaces
+    gpu = spaces.GPU(duration=60)
+except Exception:
+    def gpu(fn):
+        return fn
+
+# COCO-17 body order == first 17 COCO-WholeBody points == RIGFORGE's order:
+#  0 nose 1 L_eye 2 R_eye 3 L_ear 4 R_ear 5 L_sho 6 R_sho 7 L_elb 8 R_elb
+#  9 L_wri 10 R_wri 11 L_hip 12 R_hip 13 L_knee 14 R_knee 15 L_ank 16 R_ank
+SKELETON = [(5,7),(7,9),(6,8),(8,10),(5,6),(11,12),(5,11),(6,12),
+            (11,13),(13,15),(12,14),(14,16),(0,5),(0,6)]
+
+_model = None
+def get_model():
+    global _model
+    if _model is None:
+        import onnxruntime as ort
+        from rtmlib import Wholebody
+        dev = "cuda" if "CUDAExecutionProvider" in ort.get_available_providers() else "cpu"
+        _model = Wholebody(mode="balanced", backend="onnxruntime", device=dev)
+    return _model
+
+def _openpose18(b):
+    """COCO-17 -> OpenPose-COCO18 flat list (neck = shoulder midpoint)."""
+    neck = [(b[5][0]+b[6][0])/2, (b[5][1]+b[6][1])/2, min(b[5][2], b[6][2])]
+    order = [b[0], neck, b[6], b[8], b[10], b[5], b[7], b[9],
+             b[12], b[14], b[16], b[11], b[13], b[15], b[2], b[1], b[4], b[3]]
+    flat = []
+    for x, y, s in order:
+        flat += [float(x), float(y), float(s)]
+    return flat
+
+@gpu
+def detect(image, conf=0.3):
+    if image is None:
+        raise gr.Error("Upload a single, isolated character figure (not a sheet).")
+    rgb = np.array(image.convert("RGB"))
+    bgr = rgb[:, :, ::-1].copy()
+    h, w = bgr.shape[:2]
+
+    kpts, scores = get_model()(bgr)
+    if kpts is None or len(kpts) == 0:
+        raise gr.Error("No person detected. Use a clean front T/A-pose crop.")
+
+    p = int(np.argmax(scores.mean(axis=1)))
+    kp, sc = kpts[p], scores[p]
+    body = [[float(kp[i][0]), float(kp[i][1]), float(sc[i])] for i in range(17)]
+
+    out = {
+        "format": "coco17",
+        "canvas_width": int(w), "canvas_height": int(h),
+        "keypoints": body,
+        "people": [{"pose_keypoints_2d": _openpose18(body)}],
+        "model": "rtmlib.Wholebody(balanced)",
+    }
+
+    prev = rgb.copy()
+    r = max(3, w // 200); lw = max(2, w // 300)
+    for x, y, s in body:
+        if s >= conf:
+            cv2.circle(prev, (int(x), int(y)), r, (61, 240, 224), -1)
+    for a, b in SKELETON:
+        if body[a][2] >= conf and body[b][2] >= conf:
+            cv2.line(prev, (int(body[a][0]), int(body[a][1])),
+                     (int(body[b][0]), int(body[b][1])), (255, 61, 127), lw)
+
+    path = os.path.join(tempfile.gettempdir(), "rigpose.json")
+    with open(path, "w") as f:
+        json.dump(out, f, indent=2)
+    return prev, path
+
+with gr.Blocks(title="Alpeccaai Pose") as demo:
+    gr.Markdown(
+        "# Alpeccaai Pose — DWPose keypoints\n"
+        "Upload **one isolated character figure** (front T/A-pose is best — *not* a "
+        "multi-pose reference sheet). Returns whole-body 2D keypoints as JSON for "
+        "RIGFORGE → **AI keypoints → Import pose keypoints**, or call `/detect` from "
+        "the in-tool **Detect via HF Space** button."
+    )
+    with gr.Row():
+        inp = gr.Image(type="pil", label="Single character figure")
+        with gr.Column():
+            conf = gr.Slider(0.0, 1.0, value=0.3, label="Keypoint confidence threshold")
+            btn = gr.Button("Detect", variant="primary")
+    with gr.Row():
+        out_img = gr.Image(label="Detected skeleton")
+        out_file = gr.File(label="rigpose.json")
+    btn.click(detect, inputs=[inp, conf], outputs=[out_img, out_file], api_name="detect")
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+gradio
+rtmlib
+onnxruntime-gpu
+opencv-python-headless
+numpy
+pillow
+# ZeroGPU image provides `spaces`. If a GPU/CUDA mismatch appears in build logs,
+# swap onnxruntime-gpu -> onnxruntime (CPU) — single-image inference is still fast.