update

app.py

@@ -1,333 +1,166 @@
 """
 OpenPose Preprocessor for ControlNet
-A Gradio application for pose detection with multiple models and customization options.
+A simple Gradio application for pose detection.
 """
 
 import gradio as gr
 import numpy as np
 from PIL import Image
 import torch
-import json
-from typing import Tuple, Optional, Dict, Any
 
 # Global device detection
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"Using device: {DEVICE}")
 
-# Model cache to avoid reloading
-_model_cache: Dict[str, Any] = {}
+# Model cache
+_openpose_detector = None
+_dwpose_detector = None
 
 
 def get_openpose_detector():
     """Get or create OpenPose detector."""
-    if "openpose" not in _model_cache:
+    global _openpose_detector
+    if _openpose_detector is None:
         from controlnet_aux import OpenposeDetector
-        _model_cache["openpose"] = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-    return _model_cache["openpose"]
+        _openpose_detector = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
+    return _openpose_detector
 
 
 def get_dwpose_detector():
     """Get or create DWPose detector."""
-    if "dwpose" not in _model_cache:
+    global _dwpose_detector
+    if _dwpose_detector is None:
         from controlnet_aux import DWposeDetector
-        _model_cache["dwpose"] = DWposeDetector.from_pretrained("yolox_l.onnx", "dw-ll_ucoco_384.onnx")
-    return _model_cache["dwpose"]
+        _dwpose_detector = DWposeDetector.from_pretrained("yolox_l.onnx", "dw-ll_ucoco_384.onnx")
+    return _dwpose_detector
 
 
-def process_with_openpose(
-    image: Image.Image,
-    mode: str,
-    detect_hand: bool,
-    detect_face: bool,
-    detect_resolution: int,
-) -> Tuple[Image.Image, Optional[dict]]:
-    """Process image using OpenPose detector."""
-    detector = get_openpose_detector()
-    
-    # Determine hand_and_face parameter based on mode and toggles
-    if mode == "OpenPose (Full)":
-        hand_and_face = True
-    elif mode == "OpenPose (Hand)":
-        hand_and_face = detect_hand
-    elif mode == "OpenPose (Face)":
-        hand_and_face = detect_face
-    elif mode == "OpenPose (Face Only)":
-        # Face only mode
-        result = detector(
-            image,
-            detect_resolution=detect_resolution,
-            include_body=False,
-            include_hand=False,
-            include_face=True,
-            output_type="pil"
-        )
-        return result, None
-    else:
-        # Basic OpenPose
-        hand_and_face = detect_hand and detect_face
-    
-    result = detector(
-        image,
-        detect_resolution=detect_resolution,
-        hand_and_face=hand_and_face,
-        output_type="pil"
-    )
-    
-    return result, None
-
-
-def process_with_dwpose(
-    image: Image.Image,
-    detect_hand: bool,
-    detect_face: bool,
-    detect_resolution: int,
-) -> Tuple[Image.Image, Optional[dict]]:
-    """Process image using DWPose detector."""
-    detector = get_dwpose_detector()
-    
-    # controlnet-aux DWposeDetector API
-    result = detector(
-        image,
-        detect_resolution=detect_resolution,
-        image_resolution=detect_resolution,
-        include_hand=detect_hand,
-        include_face=detect_face,
-        include_body=True,
-        output_type="pil"
-    )
-    
-    return result, None
-
-
-def detect_pose(
-    image: Image.Image,
-    model_type: str,
-    detect_hand: bool,
-    detect_face: bool,
-    detect_resolution: int,
-    output_resolution: int,
-    output_format: str,
-) -> Tuple[Optional[Image.Image], str]:
-    """
-    Main pose detection function.
-    
-    Args:
-        image: Input PIL Image
-        model_type: Selected model type
-        detect_hand: Whether to detect hands
-        detect_face: Whether to detect face
-        detect_resolution: Resolution for detection
-        output_resolution: Resolution for output image
-        output_format: "Image", "JSON", or "Both"
-    
-    Returns:
-        Tuple of (output_image, json_string)
-    """
+def detect_pose(image, model_type, detect_hand, detect_face, detect_resolution):
+    """Main pose detection function."""
     if image is None:
-        return None, "Please upload an image first."
+        return None
     
     try:
+        # Convert to PIL if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
         # Convert to RGB if necessary
         if image.mode != "RGB":
             image = image.convert("RGB")
         
         # Process based on model type
         if model_type == "DWPose":
-            result_image, keypoints = process_with_dwpose(
-                image, detect_hand, detect_face, detect_resolution
+            detector = get_dwpose_detector()
+            result = detector(
+                image,
+                detect_resolution=detect_resolution,
+                image_resolution=detect_resolution,
+                include_hand=detect_hand,
+                include_face=detect_face,
+                include_body=True,
+                output_type="pil"
+            )
+        elif model_type == "OpenPose (Full)":
+            detector = get_openpose_detector()
+            result = detector(
+                image,
+                detect_resolution=detect_resolution,
+                hand_and_face=True,
+                output_type="pil"
+            )
+        elif model_type == "OpenPose (Face Only)":
+            detector = get_openpose_detector()
+            result = detector(
+                image,
+                detect_resolution=detect_resolution,
+                include_body=False,
+                include_hand=False,
+                include_face=True,
+                output_type="pil"
             )
         else:
-            result_image, keypoints = process_with_openpose(
-                image, model_type, detect_hand, detect_face, detect_resolution
+            # Basic OpenPose
+            detector = get_openpose_detector()
+            result = detector(
+                image,
+                detect_resolution=detect_resolution,
+                hand_and_face=detect_hand and detect_face,
+                output_type="pil"
             )
         
-        # Resize output if needed
-        if output_resolution > 0:
-            orig_w, orig_h = result_image.size
-            scale = output_resolution / max(orig_w, orig_h)
-            new_w, new_h = int(orig_w * scale), int(orig_h * scale)
-            result_image = result_image.resize((new_w, new_h), Image.Resampling.LANCZOS)
-        
-        # Prepare outputs based on format
-        json_output = ""
-        if output_format == "JSON" or output_format == "Both":
-            json_output = json.dumps({
-                "model": model_type,
-                "detect_hand": detect_hand,
-                "detect_face": detect_face,
-                "detect_resolution": detect_resolution,
-                "output_resolution": output_resolution,
-                "device": DEVICE,
-                "status": "success",
-                "note": "Keypoint extraction requires additional processing. Use the output image for ControlNet."
-            }, indent=2, ensure_ascii=False)
-        
-        if output_format == "JSON":
-            return None, json_output
-        elif output_format == "Image":
-            return result_image, "Processing complete. Image ready for ControlNet."
-        else:  # Both
-            return result_image, json_output
+        return result
             
     except Exception as e:
-        error_msg = f"Error during processing: {str(e)}"
-        return None, error_msg
+        print(f"Error during processing: {str(e)}")
+        return None
 
 
-def create_ui() -> gr.Blocks:
-    """Create the Gradio UI."""
-    
-    css = """
-    .main-title {
-        text-align: center;
-        margin-bottom: 1rem;
-    }
-    .settings-panel {
-        background: var(--background-fill-secondary);
-        padding: 1rem;
-        border-radius: 8px;
-    }
-    """
+# Create Gradio interface
+with gr.Blocks(
+    title="🦴 OpenPose Preprocessor",
+    theme=gr.themes.Soft()
+) as demo:
     
-    with gr.Blocks(
-        title="🦴 OpenPose Preprocessor",
-        css=css,
-        theme=gr.themes.Soft()
-    ) as demo:
+    gr.Markdown(
+        """
+        # 🦴 OpenPose Preprocessor for ControlNet
         
-        # Header
-        gr.Markdown(
-            """
-            # 🦴 OpenPose Preprocessor for ControlNet
+        High-quality pose detection with multiple models. Upload an image and get pose skeleton for ControlNet.
+        """
+    )
+    
+    gr.Markdown(f"**Device**: `{DEVICE}` {'🚀' if DEVICE == 'cuda' else '🐢'}")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(label="📷 Input Image", type="pil", height=400)
             
-            High-quality pose detection with multiple models and customization options.
-            Upload an image and get pose skeleton for ControlNet.
-            """
-        )
-        
-        # Device info
-        gr.Markdown(f"**Device**: `{DEVICE}` {'🚀' if DEVICE == 'cuda' else '🐢'}")
-        
-        with gr.Row():
-            # Left column - Input
-            with gr.Column(scale=1):
-                input_image = gr.Image(
-                    label="📷 Input Image",
-                    type="pil",
-                    height=400
-                )
-                
-                # Settings
-                with gr.Accordion("⚙️ Settings", open=True):
-                    model_type = gr.Dropdown(
-                        label="🤖 Model",
-                        choices=[
-                            "DWPose",
-                            "OpenPose",
-                            "OpenPose (Face)",
-                            "OpenPose (Hand)",
-                            "OpenPose (Full)",
-                            "OpenPose (Face Only)"
-                        ],
-                        value="DWPose",
-                        info="DWPose is recommended for better accuracy"
-                    )
-                    
-                    with gr.Row():
-                        detect_hand = gr.Checkbox(
-                            label="👆 Detect Hands",
-                            value=True
-                        )
-                        detect_face = gr.Checkbox(
-                            label="😊 Detect Face",
-                            value=True
-                        )
-                    
-                    detect_resolution = gr.Slider(
-                        label="📏 Detection Resolution",
-                        minimum=256,
-                        maximum=2048,
-                        value=512,
-                        step=64,
-                        info="Higher = more accurate but slower"
-                    )
-                    
-                    output_resolution = gr.Slider(
-                        label="🖼️ Output Resolution",
-                        minimum=256,
-                        maximum=2048,
-                        value=512,
-                        step=64,
-                        info="Final output image resolution"
-                    )
-                    
-                    output_format = gr.Radio(
-                        label="📊 Output Format",
-                        choices=["Image", "JSON", "Both"],
-                        value="Both"
-                    )
-                
-                # Process button
-                process_btn = gr.Button(
-                    "🚀 Detect Pose",
-                    variant="primary",
-                    size="lg"
-                )
+            model_type = gr.Dropdown(
+                label="🤖 Model",
+                choices=["DWPose", "OpenPose", "OpenPose (Full)", "OpenPose (Face Only)"],
+                value="DWPose",
+                info="DWPose is recommended for better accuracy"
+            )
             
-            # Right column - Output
-            with gr.Column(scale=1):
-                output_image = gr.Image(
-                    label="🎨 Output Pose",
-                    type="pil",
-                    height=400
-                )
-                
-                output_json = gr.Textbox(
-                    label="📋 Output Info",
-                    lines=8,
-                    max_lines=15
-                )
-        
-        # Examples
-        gr.Markdown("### 📌 Tips")
-        gr.Markdown(
-            """
-            - **DWPose** is recommended for best accuracy, especially for hands
-            - **OpenPose (Full)** detects body, face, and hands together
-            - Higher **Detection Resolution** improves accuracy but increases processing time
-            - The output image can be directly used with ControlNet OpenPose models
-            """
-        )
-        
-        # Connect events
-        process_btn.click(
-            fn=detect_pose,
-            inputs=[
-                input_image,
-                model_type,
-                detect_hand,
-                detect_face,
-                detect_resolution,
-                output_resolution,
-                output_format,
-            ],
-            outputs=[output_image, output_json]
-        )
+            with gr.Row():
+                detect_hand = gr.Checkbox(label="👆 Detect Hands", value=True)
+                detect_face = gr.Checkbox(label="😊 Detect Face", value=True)
+            
+            detect_resolution = gr.Slider(
+                label="📏 Detection Resolution",
+                minimum=256,
+                maximum=2048,
+                value=512,
+                step=64,
+                info="Higher = more accurate but slower"
+            )
+            
+            process_btn = gr.Button("🚀 Detect Pose", variant="primary", size="lg")
         
-        # Also clear output on image upload for convenience
-        input_image.change(
-            fn=lambda x: (None, ""),
-            inputs=[input_image],
-            outputs=[output_image, output_json]
-        )
+        with gr.Column(scale=1):
+            output_image = gr.Image(label="🎨 Output Pose", type="pil", height=400)
+    
+    gr.Markdown(
+        """
+        ### 📌 Tips
+        - **DWPose** is recommended for best accuracy, especially for hands
+        - **OpenPose (Full)** detects body, face, and hands together
+        - Higher **Detection Resolution** improves accuracy but increases processing time
+        - The output image can be directly used with ControlNet OpenPose models
+        """
+    )
     
-    return demo
+    process_btn.click(
+        fn=detect_pose,
+        inputs=[input_image, model_type, detect_hand, detect_face, detect_resolution],
+        outputs=[output_image]
+    )
 
 
 if __name__ == "__main__":
-    demo = create_ui()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False
+        ssr_mode=False
     )