example csv and json pose data saving

app.py

@@ -5,28 +5,70 @@ import json
 import csv
 import os
 from datetime import datetime
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional
+import numpy as np
 
 # Load OpenPose detector
 openpose = OpenposeDetector.from_pretrained("lllyasviel/ControlNet")
 
-def extract_joint_positions(openpose_result) -> Dict[str, Any]:
-    """Extract joint positions from OpenPose result."""
-    # OpenPose returns a PIL Image with encoded pose data
-    # We need to access the pose data from the result
-    if hasattr(openpose_result, 'pose_keypoints_2d'):
-        # If OpenPose returns structured data
-        return {
-            "keypoints": openpose_result.pose_keypoints_2d,
-            "timestamp": datetime.now().isoformat()
-        }
-    else:
-        # Fallback: extract from image if possible
-        return {
-            "keypoints": [],
-            "timestamp": datetime.now().isoformat(),
-            "note": "No structured pose data available"
-        }
+# OpenPose joint mapping (COCO format - 18 joints)
+JOINT_NAMES = [
+    "Nose",           # 0
+    "Neck",           # 1
+    "RShoulder",      # 2
+    "RElbow",         # 3
+    "RWrist",         # 4
+    "LShoulder",      # 5
+    "LElbow",         # 6
+    "LWrist",         # 7
+    "RHip",           # 8
+    "RKnee",          # 9
+    "RAnkle",         # 10
+    "LHip",           # 11
+    "LKnee",          # 12
+    "LAnkle",         # 13
+    "REye",           # 14
+    "LEye",           # 15
+    "REar",           # 16
+    "LEar"            # 17
+]
+
+def extract_joint_positions_from_detect_poses(pose_results: List[Any]) -> Dict[str, Any]:
+    """Extract joint positions from OpenPose detect_poses result."""
+    all_poses = []
+
+    for idx, pose in enumerate(pose_results):
+        body = pose.body
+        keypoints = []
+
+        for joint_idx, keypoint in enumerate(body.keypoints):
+            if keypoint is not None:
+                keypoints.append({
+                    "x": keypoint.x,
+                    "y": keypoint.y,
+                    "score": getattr(keypoint, 'score', 0.0),
+                    "name": JOINT_NAMES[joint_idx] if joint_idx < len(JOINT_NAMES) else f"Joint_{joint_idx}"
+                })
+            else:
+                keypoints.append({
+                    "x": None,
+                    "y": None,
+                    "score": None,
+                    "name": JOINT_NAMES[joint_idx] if joint_idx < len(JOINT_NAMES) else f"Joint_{joint_idx}"
+                })
+
+        all_poses.append({
+            "pose_id": idx,
+            "total_score": body.total_score,
+            "total_parts": body.total_parts,
+            "keypoints": keypoints
+        })
+
+    return {
+        "poses": all_poses,
+        "timestamp": datetime.now().isoformat(),
+        "joint_names": JOINT_NAMES
+    }
 
 def save_to_csv(joint_data: Dict[str, Any], filename: str = None) -> str:
     """Save joint positions to CSV file."""
@@ -39,30 +81,29 @@ def save_to_csv(joint_data: Dict[str, Any], filename: str = None) -> str:
 
     with open(filepath, 'w', newline='') as csvfile:
         writer = csv.writer(csvfile)
-        writer.writerow(["Joint", "X", "Y", "Confidence"])
-
-        keypoints = joint_data.get("keypoints", [])
-        if keypoints and isinstance(keypoints, list):
-            # OpenPose format: [x1, y1, c1, x2, y2, c2, ...]
-            joint_names = [
-                "Nose", "Neck", "RShoulder", "RElbow", "RWrist",
-                "LShoulder", "LElbow", "LWrist", "RHip", "RKnee",
-                "RAnkle", "LHip", "LKnee", "LAnkle", "REye",
-                "LEye", "REar", "LEar", "LBigToe", "LSmallToe",
-                "LHeel", "RBigToe", "RSmallToe", "RHeel"
-            ]
-
-            for i in range(0, len(keypoints), 3):
-                if i + 2 < len(keypoints):
-                    joint_idx = i // 3
-                    joint_name = joint_names[joint_idx] if joint_idx < len(joint_names) else f"Joint_{joint_idx}"
-                    writer.writerow([
-                        joint_name,
-                        keypoints[i],      # X
-                        keypoints[i + 1],  # Y
-                        keypoints[i + 2]   # Confidence
-                    ])
-
+        writer.writerow(["Pose_ID", "Joint", "X", "Y", "Confidence", "Visible"])
+
+        poses = joint_data.get("poses", [])
+        for pose in poses:
+            pose_id = pose.get("pose_id", 0)
+            for kp in pose.get("keypoints", []):
+                x = kp.get("x")
+                y = kp.get("y")
+                score = kp.get("score")
+                name = kp.get("name", "Unknown")
+
+                visible = "Yes" if x is not None and y is not None else "No"
+
+                writer.writerow([
+                    pose_id,
+                    name,
+                    f"{x:.2f}" if x is not None else "N/A",
+                    f"{y:.2f}" if y is not None else "N/A",
+                    f"{score:.3f}" if score is not None else "N/A",
+                    visible
+                ])
+
+        writer.writerow([])
         writer.writerow(["Timestamp", joint_data.get("timestamp", "")])
 
     return filepath
@@ -81,82 +122,110 @@ def save_to_json(joint_data: Dict[str, Any], filename: str = None) -> str:
 
     return filepath
 
-def generate_pose(image, use_openpose=True, save_outputs=True):
+def generate_pose(image, use_openpose=True, save_outputs=True, include_hands=False, include_face=False):
+    """Generate pose estimation and extract joint positions."""
     img = image.convert("RGB")
+
     if use_openpose:
+        # Convert PIL Image to numpy array for detect_poses
+        img_array = np.array(img)
+
+        # Use detect_poses to get structured data
+        pose_results = openpose.detect_poses(
+            img_array,
+            include_hand=include_hands,
+            include_face=include_face
+        )
+
+        # Extract joint positions from pose results
+        joint_data = extract_joint_positions_from_detect_poses(pose_results)
+
+        # Generate the annotated image
         result = openpose(img)
+
+        # Save pose data if requested
+        if save_outputs:
+            csv_path = save_to_csv(joint_data)
+            json_path = save_to_json(joint_data)
+            joint_data["csv_path"] = csv_path
+            joint_data["json_path"] = json_path
     else:
         result = img
+        joint_data = {
+            "poses": [],
+            "timestamp": datetime.now().isoformat(),
+            "note": "OpenPose disabled - no pose data extracted"
+        }
+
     if not isinstance(result, Image.Image):
         result = Image.fromarray(result)
 
-    # Extract and save pose data if OpenPose was used
-    joint_data = {}
-    if use_openpose and save_outputs:
-        joint_data = extract_joint_positions(result)
-        csv_path = save_to_csv(joint_data)
-        json_path = save_to_json(joint_data)
-        joint_data["csv_path"] = csv_path
-        joint_data["json_path"] = json_path
-
     return result, joint_data
 
-# Gradio UI with pose data outputs
 def format_pose_output(joint_data: Dict[str, Any]) -> str:
-    """Format pose data for display."""
-    if not joint_data or not joint_data.get("keypoints"):
-        return "No pose data available."
-
-    output = "### Joint Positions\n\n"
+    """Format pose data for display in Gradio."""
+    if not joint_data.get("poses"):
+        return "No pose data available.\n\n" + \
+               f"**Timestamp:** {joint_data.get('timestamp', 'N/A')}\n" + \
+               f"**CSV File:** `{joint_data.get('csv_path', 'N/A')}`\n" + \
+               f"**JSON File:** `{joint_data.get('json_path', 'N/A')}`"
+
+    output = "### Detected Poses\n\n"
     output += f"**Timestamp:** {joint_data.get('timestamp', 'N/A')}\n\n"
 
-    keypoints = joint_data.get("keypoints", [])
-    if keypoints and isinstance(keypoints, list):
-        joint_names = [
-            "Nose", "Neck", "RShoulder", "RElbow", "RWrist",
-            "LShoulder", "LElbow", "LWrist", "RHip", "RKnee",
-            "RAnkle", "LHip", "LKnee", "LAnkle", "REye",
-            "LEye", "REar", "LEar", "LBigToe", "LSmallToe",
-            "LHeel", "RBigToe", "RSmallToe", "RHeel"
-        ]
-
-        output += "| Joint | X | Y | Confidence |\n"
-        output += "|-------|---|---|------------|\n"
-
-        for i in range(0, min(len(keypoints), 72), 3):
-            if i + 2 < len(keypoints):
-                joint_idx = i // 3
-                joint_name = joint_names[joint_idx] if joint_idx < len(joint_names) else f"Joint_{joint_idx}"
-                x = keypoints[i]
-                y = keypoints[i + 1]
-                confidence = keypoints[i + 2]
-                output += f"| {joint_name} | {x:.1f} | {y:.1f} | {confidence:.3f} |\n"
-
-    output += f"\n**CSV File:** `{joint_data.get('csv_path', 'N/A')}`\n"
+    for pose in joint_data.get("poses", []):
+        output += f"#### Pose #{pose.get('pose_id', 0)}\n"
+        output += f"- **Total Score:** {pose.get('total_score', 0):.3f}\n"
+        output += f"- **Total Parts:** {pose.get('total_parts', 0)}\n\n"
+
+        output += "| Joint | X | Y | Confidence | Visible |\n"
+        output += "|-------|---|---|------------|---------|\n"
+
+        for kp in pose.get("keypoints", []):
+            name = kp.get("name", "Unknown")
+            x = kp.get("x")
+            y = kp.get("y")
+            score = kp.get("score")
+
+            x_str = f"{x:.1f}" if x is not None else "N/A"
+            y_str = f"{y:.1f}" if y is not None else "N/A"
+            score_str = f"{score:.3f}" if score is not None else "N/A"
+            visible = "Yes" if x is not None and y is not None else "No"
+
+            output += f"| {name} | {x_str} | {y_str} | {score_str} | {visible} |\n"
+
+        output += "\n"
+
+    output += f"**CSV File:** `{joint_data.get('csv_path', 'N/A')}`\n"
     output += f"**JSON File:** `{joint_data.get('json_path', 'N/A')}`\n"
 
     return output
 
-def process_and_display(image, use_openpose=True):
+def process_and_display(image, use_openpose=True, include_hands=False, include_face=False):
     """Process image and return pose output with data files."""
-    result, joint_data = generate_pose(image, use_openpose, save_outputs=True)
-
-    if use_openpose and joint_data:
-        pose_info = format_pose_output(joint_data)
-        return result, pose_info
-    else:
-        return result, "Pose data extraction skipped."
-
-# Gradio UI with pose data outputs
+    result, joint_data = generate_pose(
+        image,
+        use_openpose=use_openpose,
+        save_outputs=True,
+        include_hands=include_hands,
+        include_face=include_face
+    )
+
+    pose_info = format_pose_output(joint_data)
+    return result, pose_info
+
+# Gradio UI
 demo = gr.Interface(
     fn=process_and_display,
     inputs=[
         gr.Image(type="pil", label="Upload Image"),
         gr.Checkbox(value=True, label="Use OpenPose (default: true)"),
+        gr.Checkbox(value=False, label="Include Hands"),
+        gr.Checkbox(value=False, label="Include Face"),
     ],
     outputs=[
         gr.Image(type="pil", label="Pose Output"),
-        gr.Textbox(label="Pose Data", lines=10)
+        gr.Textbox(label="Pose Data", lines=15)
     ],
     title="OpenPose Pose Generator",
     description="Generate full body pose including face and hands. Extracts and stores joint positions in CSV and JSON formats."

pose_outputs/pose_data_20260404_105941.csv

@@ -0,0 +1,21 @@
+Pose_ID,Joint,X,Y,Confidence,Visible
+0,Nose,0.56,0.24,1.000,Yes
+0,Neck,0.62,0.33,1.000,Yes
+0,RShoulder,0.52,0.32,1.000,Yes
+0,RElbow,0.39,0.30,1.000,Yes
+0,RWrist,0.33,0.22,1.000,Yes
+0,LShoulder,0.71,0.34,1.000,Yes
+0,LElbow,0.76,0.45,1.000,Yes
+0,LWrist,0.67,0.48,1.000,Yes
+0,RHip,0.48,0.51,1.000,Yes
+0,RKnee,0.50,0.69,1.000,Yes
+0,RAnkle,0.51,0.86,1.000,Yes
+0,LHip,0.58,0.53,1.000,Yes
+0,LKnee,0.66,0.69,1.000,Yes
+0,LAnkle,0.77,0.86,1.000,Yes
+0,REye,0.55,0.24,1.000,Yes
+0,LEye,0.59,0.23,1.000,Yes
+0,REar,N/A,N/A,N/A,No
+0,LEar,0.66,0.24,1.000,Yes
+
+Timestamp,2026-04-04T10:59:40.316720

pose_outputs/pose_data_20260404_105941.json

@@ -0,0 +1,140 @@
+{
+  "poses": [
+    {
+      "pose_id": 0,
+      "total_score": 31.495056734426026,
+      "total_parts": 17.0,
+      "keypoints": [
+        {
+          "x": 0.5646766169154229,
+          "y": 0.24378109452736318,
+          "score": 1.0,
+          "name": "Nose"
+        },
+        {
+          "x": 0.6169154228855721,
+          "y": 0.3283582089552239,
+          "score": 1.0,
+          "name": "Neck"
+        },
+        {
+          "x": 0.5199004975124378,
+          "y": 0.3200663349917081,
+          "score": 1.0,
+          "name": "RShoulder"
+        },
+        {
+          "x": 0.3880597014925373,
+          "y": 0.29850746268656714,
+          "score": 1.0,
+          "name": "RElbow"
+        },
+        {
+          "x": 0.3308457711442786,
+          "y": 0.2155887230514096,
+          "score": 1.0,
+          "name": "RWrist"
+        },
+        {
+          "x": 0.7114427860696517,
+          "y": 0.34328358208955223,
+          "score": 1.0,
+          "name": "LShoulder"
+        },
+        {
+          "x": 0.7611940298507462,
+          "y": 0.44776119402985076,
+          "score": 1.0,
+          "name": "LElbow"
+        },
+        {
+          "x": 0.6716417910447762,
+          "y": 0.48092868988391374,
+          "score": 1.0,
+          "name": "LWrist"
+        },
+        {
+          "x": 0.47761194029850745,
+          "y": 0.5140961857379768,
+          "score": 1.0,
+          "name": "RHip"
+        },
+        {
+          "x": 0.49502487562189057,
+          "y": 0.6865671641791045,
+          "score": 1.0,
+          "name": "RKnee"
+        },
+        {
+          "x": 0.5124378109452736,
+          "y": 0.8557213930348259,
+          "score": 1.0,
+          "name": "RAnkle"
+        },
+        {
+          "x": 0.5845771144278606,
+          "y": 0.527363184079602,
+          "score": 1.0,
+          "name": "LHip"
+        },
+        {
+          "x": 0.6616915422885572,
+          "y": 0.6898839137645107,
+          "score": 1.0,
+          "name": "LKnee"
+        },
+        {
+          "x": 0.7686567164179104,
+          "y": 0.8590381426202321,
+          "score": 1.0,
+          "name": "LAnkle"
+        },
+        {
+          "x": 0.554726368159204,
+          "y": 0.23548922056384744,
+          "score": 1.0,
+          "name": "REye"
+        },
+        {
+          "x": 0.5895522388059702,
+          "y": 0.23217247097844113,
+          "score": 1.0,
+          "name": "LEye"
+        },
+        {
+          "x": null,
+          "y": null,
+          "score": null,
+          "name": "REar"
+        },
+        {
+          "x": 0.6567164179104478,
+          "y": 0.24046434494195687,
+          "score": 1.0,
+          "name": "LEar"
+        }
+      ]
+    }
+  ],
+  "timestamp": "2026-04-04T10:59:40.316720",
+  "joint_names": [
+    "Nose",
+    "Neck",
+    "RShoulder",
+    "RElbow",
+    "RWrist",
+    "LShoulder",
+    "LElbow",
+    "LWrist",
+    "RHip",
+    "RKnee",
+    "RAnkle",
+    "LHip",
+    "LKnee",
+    "LAnkle",
+    "REye",
+    "LEye",
+    "REar",
+    "LEar"
+  ]
+}