Update app.py

app.py

@@ -4,7 +4,6 @@ import json
 import requests
 import os
 from typing import Dict, List, Tuple
-import base64
 from PIL import Image, ImageDraw
 import io
 
@@ -33,7 +32,7 @@ POSE_CONNECTIONS = [
 
 # Pose templates
 POSE_TEMPLATES = {
-    "서있기 (Standing)": {
+    "Standing": {
         "Nose": [256, 80], "Neck": [256, 120],
         "RShoulder": [220, 140], "RElbow": [200, 220], "RWrist": [190, 300],
         "LShoulder": [292, 140], "LElbow": [312, 220], "LWrist": [322, 300],
@@ -41,7 +40,7 @@ POSE_TEMPLATES = {
         "LHip": [272, 280], "LKnee": [277, 380], "LAnkle": [282, 480],
         "REye": [246, 70], "LEye": [266, 70], "REar": [236, 75], "LEar": [276, 75]
     },
-    "앉기 (Sitting)": {
+    "Sitting": {
         "Nose": [256, 120], "Neck": [256, 160],
         "RShoulder": [220, 180], "RElbow": [200, 240], "RWrist": [190, 300],
         "LShoulder": [292, 180], "LElbow": [312, 240], "LWrist": [322, 300],
@@ -49,7 +48,7 @@ POSE_TEMPLATES = {
         "LHip": [272, 320], "LKnee": [232, 380], "LAnkle": [192, 400],
         "REye": [246, 110], "LEye": [266, 110], "REar": [236, 115], "LEar": [276, 115]
     },
-    "달리기 (Running)": {
+    "Running": {
         "Nose": [256, 80], "Neck": [256, 120],
         "RShoulder": [220, 140], "RElbow": [180, 180], "RWrist": [150, 140],
         "LShoulder": [292, 140], "LElbow": [332, 200], "LWrist": [362, 260],
@@ -57,7 +56,7 @@ POSE_TEMPLATES = {
         "LHip": [272, 280], "LKnee": [252, 360], "LAnkle": [222, 440],
         "REye": [246, 70], "LEye": [266, 70], "REar": [236, 75], "LEar": [276, 75]
     },
-    "요가 (Yoga)": {
+    "Yoga": {
         "Nose": [256, 100], "Neck": [256, 140],
         "RShoulder": [200, 160], "RElbow": [150, 120], "RWrist": [100, 100],
         "LShoulder": [312, 160], "LElbow": [362, 120], "LWrist": [412, 100],
@@ -65,20 +64,26 @@ POSE_TEMPLATES = {
         "LHip": [272, 300], "LKnee": [292, 400], "LAnkle": [312, 480],
         "REye": [246, 90], "LEye": [266, 90], "REar": [236, 95], "LEar": [276, 95]
     },
-    "춤추기 (Dancing)": {
+    "Dancing": {
         "Nose": [256, 80], "Neck": [256, 120],
         "RShoulder": [220, 140], "RElbow": [180, 120], "RWrist": [140, 100],
         "LShoulder": [292, 140], "LElbow": [332, 160], "LWrist": [372, 140],
         "RHip": [240, 280], "RKnee": [260, 380], "RAnkle": [250, 480],
         "LHip": [272, 280], "LKnee": [252, 380], "LAnkle": [262, 480],
         "REye": [246, 70], "LEye": [266, 70], "REar": [236, 75], "LEar": [276, 75]
+    },
+    "Waving": {
+        "Nose": [256, 80], "Neck": [256, 120],
+        "RShoulder": [220, 140], "RElbow": [200, 100], "RWrist": [180, 60],
+        "LShoulder": [292, 140], "LElbow": [312, 220], "LWrist": [322, 300],
+        "RHip": [240, 280], "RKnee": [235, 380], "RAnkle": [230, 480],
+        "LHip": [272, 280], "LKnee": [277, 380], "LAnkle": [282, 480],
+        "REye": [246, 70], "LEye": [266, 70], "REar": [236, 75], "LEar": [276, 75]
     }
 }
 
 def draw_pose(keypoints: Dict, width: int = 512, height: int = 512) -> Image.Image:
-    """
-    키포인트를 기반으로 포즈 이미지 그리기
-    """
+    """Draw pose skeleton on image"""
     img = Image.new('RGB', (width, height), color='white')
     draw = ImageDraw.Draw(img)
     
@@ -96,13 +101,13 @@ def draw_pose(keypoints: Dict, width: int = 512, height: int = 512) -> Image.Ima
             x, y = point
             radius = 5
             draw.ellipse([x-radius, y-radius, x+radius, y+radius], fill='red', outline='darkred')
+            # Add label
+            draw.text((x+8, y-8), part[:3], fill='black')
     
     return img
 
 def generate_pose_from_llm(prompt: str) -> Dict:
-    """
-    LLM을 사용하여 텍스트로부터 포즈 생성
-    """
+    """Generate pose using LLM"""
     system_prompt = """You are an expert in generating human pose keypoints.
     Given a description, generate 18 keypoint coordinates for OpenPose.
     
@@ -150,86 +155,72 @@ def generate_pose_from_llm(prompt: str) -> Dict:
     return get_template_from_prompt(prompt)
 
 def get_template_from_prompt(prompt: str) -> Dict:
-    """
-    프롬프트에서 키워드를 찾아 적절한 템플릿 선택
-    """
+    """Select appropriate template based on prompt"""
     prompt_lower = prompt.lower()
     
-    if any(word in prompt_lower for word in ["앉", "sit", "chair", "의자"]):
-        return POSE_TEMPLATES["앉기 (Sitting)"]
-    elif any(word in prompt_lower for word in ["달리", "run", "jog", "뛰"]):
-        return POSE_TEMPLATES["달리기 (Running)"]
-    elif any(word in prompt_lower for word in ["요가", "yoga", "명상", "meditation"]):
-        return POSE_TEMPLATES["요가 (Yoga)"]
-    elif any(word in prompt_lower for word in ["춤", "dance", "댄스"]):
-        return POSE_TEMPLATES["춤추기 (Dancing)"]
+    if any(word in prompt_lower for word in ["sit", "chair", "seated"]):
+        return POSE_TEMPLATES["Sitting"]
+    elif any(word in prompt_lower for word in ["run", "jog", "sprint"]):
+        return POSE_TEMPLATES["Running"]
+    elif any(word in prompt_lower for word in ["yoga", "meditation", "stretch"]):
+        return POSE_TEMPLATES["Yoga"]
+    elif any(word in prompt_lower for word in ["dance", "dancing"]):
+        return POSE_TEMPLATES["Dancing"]
+    elif any(word in prompt_lower for word in ["wave", "waving", "hello"]):
+        return POSE_TEMPLATES["Waving"]
     else:
-        return POSE_TEMPLATES["서있기 (Standing)"]
+        return POSE_TEMPLATES["Standing"]
 
 def refine_pose(current_keypoints: Dict, instruction: str) -> Dict:
-    """
-    기존 포즈를 지시사항에 따라 수정
-    """
-    if FIREWORKS_API_KEY == "YOUR_API_KEY_HERE":
-        # Simple rule-based refinement
-        keypoints = current_keypoints.copy()
-        instruction_lower = instruction.lower()
-        
-        if "팔" in instruction_lower or "arm" in instruction_lower:
-            if "올리" in instruction_lower or "raise" in instruction_lower:
-                # Raise arms
-                if "RWrist" in keypoints:
-                    keypoints["RWrist"][1] -= 50
+    """Refine existing pose based on instruction"""
+    keypoints = current_keypoints.copy()
+    instruction_lower = instruction.lower()
+    
+    # Simple rule-based refinement
+    if "raise" in instruction_lower or "lift" in instruction_lower:
+        if "arm" in instruction_lower or "hand" in instruction_lower:
+            if "left" in instruction_lower:
                 if "LWrist" in keypoints:
                     keypoints["LWrist"][1] -= 50
-            elif "내리" in instruction_lower or "lower" in instruction_lower:
-                # Lower arms
+                if "LElbow" in keypoints:
+                    keypoints["LElbow"][1] -= 30
+            elif "right" in instruction_lower:
                 if "RWrist" in keypoints:
-                    keypoints["RWrist"][1] += 50
-                if "LWrist" in keypoints:
-                    keypoints["LWrist"][1] += 50
-        
-        return keypoints
-    
-    # Use LLM for refinement
-    system_prompt = """Modify the given pose keypoints based on the instruction.
-    Return the modified keypoints in the same JSON format."""
+                    keypoints["RWrist"][1] -= 50
+                if "RElbow" in keypoints:
+                    keypoints["RElbow"][1] -= 30
+            else:  # Both arms
+                for part in ["LWrist", "RWrist"]:
+                    if part in keypoints:
+                        keypoints[part][1] -= 50
+                for part in ["LElbow", "RElbow"]:
+                    if part in keypoints:
+                        keypoints[part][1] -= 30
     
-    headers = {
-        "Accept": "application/json",
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {FIREWORKS_API_KEY}"
-    }
+    elif "lower" in instruction_lower:
+        if "arm" in instruction_lower or "hand" in instruction_lower:
+            for part in ["LWrist", "RWrist"]:
+                if part in keypoints:
+                    keypoints[part][1] += 50
     
-    payload = {
-        "model": "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507",
-        "max_tokens": 1024,
-        "temperature": 0.2,
-        "messages": [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"Current keypoints: {json.dumps(current_keypoints)}\nInstruction: {instruction}"}
-        ]
-    }
+    elif "spread" in instruction_lower or "wide" in instruction_lower:
+        if "leg" in instruction_lower:
+            if "LAnkle" in keypoints:
+                keypoints["LAnkle"][0] -= 30
+            if "RAnkle" in keypoints:
+                keypoints["RAnkle"][0] += 30
     
-    try:
-        response = requests.post(FIREWORKS_API_URL, headers=headers, json=payload, timeout=30)
-        if response.status_code == 200:
-            data = response.json()
-            content = data['choices'][0]['message']['content']
-            
-            import re
-            json_match = re.search(r'\{.*\}', content, re.DOTALL)
-            if json_match:
-                return json.loads(json_match.group())
-    except Exception as e:
-        print(f"Refinement error: {e}")
+    elif "bend" in instruction_lower:
+        if "knee" in instruction_lower:
+            for part in ["LKnee", "RKnee"]:
+                if part in keypoints:
+                    keypoints[part][1] += 20
+                    keypoints[part][0] += 10 if "L" in part else -10
     
-    return current_keypoints
+    return keypoints
 
 def keypoints_to_openpose_format(keypoints: Dict) -> str:
-    """
-    키포인트를 OpenPose JSON 형식으로 변환
-    """
+    """Convert keypoints to OpenPose JSON format"""
     candidate = []
     for i in range(18):
         part_name = None
@@ -249,213 +240,231 @@ def keypoints_to_openpose_format(keypoints: Dict) -> str:
     
     return json.dumps({"candidate": candidate, "subset": subset}, indent=2)
 
-# Gradio Interface
-with gr.Blocks(title="AI Pose Generator", theme=gr.themes.Soft()) as demo:
-    current_keypoints = gr.State({})
-    
-    gr.Markdown("""
-    # 🎨 AI 포즈 생성기 (Line Art Pose Generator)
-    ### 텍스트 설명으로 정확한 포즈를 생성합니다
-    """)
-    
-    with gr.Tabs():
-        with gr.TabItem("🤖 AI 포즈 생성"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    # LLM 설정
-                    use_llm = gr.Checkbox(
-                        label="🚀 고급 AI 모델 사용 (Fireworks API)", 
-                        value=False,
-                        info="체크하면 더 정확한 포즈 생성 (API 키 필요)"
-                    )
-                    
-                    api_status = gr.Markdown("⚠️ API 키 미설정 - 템플릿 모드")
-                    
-                    # 텍스트 입력
-                    prompt = gr.Textbox(
-                        label="포즈 설명",
-                        placeholder="예: 의자에 앉아 책을 읽는 사람",
-                        lines=3
-                    )
-                    
-                    # 예제
-                    gr.Examples(
-                        examples=[
-                            "팔을 높이 들고 승리의 포즈",
-                            "의자에 앉아 노트북 타이핑",
-                            "한쪽 다리로 서서 요가 포즈",
-                            "양손을 허리에 올린 자신감 있는 포즈",
-                            "달리기 자세",
-                            "무릎 꿇고 기도하는 자세"
-                        ],
-                        inputs=prompt
-                    )
-                    
-                    generate_btn = gr.Button("🎯 포즈 생성", variant="primary", size="lg")
-                    
-                    # 템플릿 선택
-                    with gr.Accordion("📚 템플릿 선택", open=False):
-                        template_select = gr.Dropdown(
-                            choices=list(POSE_TEMPLATES.keys()),
-                            label="포즈 템플릿",
-                            value="서있기 (Standing)"
+# Create Gradio interface
+def create_demo():
+    with gr.Blocks(title="AI Pose Generator", theme=gr.themes.Soft()) as demo:
+        current_keypoints = gr.State({})
+        
+        gr.Markdown("""
+        # 🎨 AI Line Art Pose Generator
+        ### Generate precise poses from text descriptions using AI
+        """)
+        
+        with gr.Tabs():
+            with gr.TabItem("🤖 Generate Pose"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        # Input section
+                        use_llm = gr.Checkbox(
+                            label="🚀 Use Advanced AI Model (Fireworks API)", 
+                            value=False,
+                            info="Enable for more accurate pose generation (requires API key)"
                         )
-                        use_template_btn = gr.Button("템플릿 적용")
-                
-                with gr.Column(scale=1):
-                    # 포즈 이미지 출력
-                    pose_image = gr.Image(
-                        label="생성된 포즈",
-                        type="pil",
-                        height=512
-                    )
-                    
-                    # JSON 출력
-                    with gr.Accordion("📋 OpenPose JSON", open=False):
-                        json_output = gr.Code(
-                            label="JSON 데이터",
-                            language="json",
-                            lines=10
+                        
+                        api_status = gr.Markdown("⚠️ API key not set - Template mode active")
+                        
+                        prompt = gr.Textbox(
+                            label="Pose Description",
+                            placeholder="e.g., A person sitting cross-legged reading a book",
+                            lines=3
                         )
                         
-                        download_btn = gr.Button("💾 JSON 다운로드", size="sm")
-        
-        with gr.TabItem("✏️ 포즈 수정"):
-            with gr.Row():
-                with gr.Column():
-                    refinement_instruction = gr.Textbox(
-                        label="수정 지시사항",
-                        placeholder="예: 왼쪽 팔을 더 높이 들어주세요",
-                        lines=2
-                    )
+                        gr.Examples(
+                            examples=[
+                                "A person standing with arms raised in victory",
+                                "Someone sitting at a desk typing on a laptop",
+                                "A dancer in arabesque position",
+                                "A person doing yoga warrior pose",
+                                "Someone waving hello",
+                                "A person running with arms pumping"
+                            ],
+                            inputs=prompt
+                        )
+                        
+                        generate_btn = gr.Button("🎯 Generate Pose", variant="primary", size="lg")
+                        
+                        # Template selection
+                        with gr.Accordion("📚 Quick Templates", open=False):
+                            template_select = gr.Dropdown(
+                                choices=list(POSE_TEMPLATES.keys()),
+                                label="Select Template",
+                                value="Standing"
+                            )
+                            use_template_btn = gr.Button("Apply Template")
                     
-                    refine_btn = gr.Button("✨ 포즈 수정", variant="secondary")
+                    with gr.Column(scale=1):
+                        # Output section
+                        pose_image = gr.Image(
+                            label="Generated Pose",
+                            type="pil",
+                            height=512
+                        )
+                        
+                        with gr.Accordion("📋 OpenPose JSON", open=False):
+                            json_output = gr.Code(
+                                label="JSON Data",
+                                language="json",
+                                lines=10
+                            )
+            
+            with gr.TabItem("✏️ Refine Pose"):
+                with gr.Row():
+                    with gr.Column():
+                        refinement_instruction = gr.Textbox(
+                            label="Refinement Instructions",
+                            placeholder="e.g., Raise the left arm higher",
+                            lines=2
+                        )
+                        
+                        refine_btn = gr.Button("✨ Refine Pose", variant="secondary")
+                        
+                        gr.Markdown("""
+                        **Quick commands:**
+                        - "Raise left/right arm"
+                        - "Lower arms"
+                        - "Spread legs wider"
+                        - "Bend knees"
+                        """)
+                        
+                        # Manual adjustment
+                        with gr.Accordion("🎛️ Manual Adjustment", open=False):
+                            selected_part = gr.Dropdown(
+                                choices=list(BODY_PARTS.keys()),
+                                label="Select Body Part",
+                                value="RWrist"
+                            )
+                            x_adjust = gr.Slider(-100, 100, 0, label="X Adjustment")
+                            y_adjust = gr.Slider(-100, 100, 0, label="Y Adjustment")
+                            apply_adjust_btn = gr.Button("Apply Adjustment")
                     
-                    # 미세 조정
-                    with gr.Accordion("🎛️ 수동 조정", open=False):
-                        selected_part = gr.Dropdown(
-                            choices=list(BODY_PARTS.keys()),
-                            label="조정할 부위",
-                            value="RWrist"
+                    with gr.Column():
+                        refined_image = gr.Image(
+                            label="Refined Pose",
+                            type="pil",
+                            height=512
                         )
-                        x_adjust = gr.Slider(-50, 50, 0, label="X 조정")
-                        y_adjust = gr.Slider(-50, 50, 0, label="Y 조정")
-                        apply_adjust_btn = gr.Button("적용")
+                        
+                        with gr.Accordion("📋 Updated JSON", open=False):
+                            refined_json = gr.Code(
+                                label="JSON Data",
+                                language="json",
+                                lines=10
+                            )
+            
+            with gr.TabItem("ℹ️ Help"):
+                gr.Markdown("""
+                ## How to Use
+                
+                ### 1. Generate Pose
+                - Enter a natural language description of the pose
+                - Click "Generate Pose" to create the pose
+                - Or select a template for quick start
                 
-                with gr.Column():
-                    refined_image = gr.Image(
-                        label="수정된 포즈",
-                        type="pil",
-                        height=512
-                    )
+                ### 2. Refine Pose (Optional)
+                - Use natural language commands to adjust the pose
+                - Or manually adjust individual body parts
+                
+                ### 3. Export
+                - Copy the OpenPose JSON format for use in other applications
+                - Compatible with ControlNet and other pose-based tools
+                
+                ### API Setup (Optional)
+                For better results, set up Fireworks API:
+                ```bash
+                export FIREWORKS_API_KEY="your_api_key"
+                ```
+                
+                ### Features
+                - 🚀 No GPU required - runs on CPU
+                - 🎨 Clean line art style
+                - 📊 OpenPose compatible format
+                - 🔧 Easy refinement tools
+                - 💾 JSON export for integration
+                """)
         
-        with gr.TabItem("ℹ️ 사용법"):
-            gr.Markdown("""
-            ## 사용 방법
+        # Event handlers
+        def check_api_status():
+            if FIREWORKS_API_KEY != "YOUR_API_KEY_HERE":
+                return "✅ API key configured - Advanced AI ready"
+            return "⚠️ API key not set - Template mode active"
+        
+        def generate_pose(prompt_text, use_llm_flag):
+            if not prompt_text:
+                keypoints = POSE_TEMPLATES["Standing"]
+            elif use_llm_flag and FIREWORKS_API_KEY != "YOUR_API_KEY_HERE":
+                keypoints = generate_pose_from_llm(prompt_text)
+            else:
+                keypoints = get_template_from_prompt(prompt_text)
             
-            ### 1. AI 포즈 생성
-            - **텍스트 설명**: 원하는 포즈를 자연어로 설명하세요
-            - **고급 AI 모델**: Fireworks API 키가 있으면 더 정확한 생성 가능
-            - **템플릿**: 빠른 시작을 위한 기본 포즈 제공
+            pose_img = draw_pose(keypoints)
+            json_str = keypoints_to_openpose_format(keypoints)
             
-            ### 2. 포즈 수정
-            - **자연어 수정**: "팔을 올려주세요" 같은 지시로 수정
-            - **수동 조정**: 특정 관절을 직접 이동
+            return pose_img, json_str, keypoints
+        
+        def use_template(template_name):
+            keypoints = POSE_TEMPLATES[template_name]
+            pose_img = draw_pose(keypoints)
+            json_str = keypoints_to_openpose_format(keypoints)
+            return pose_img, json_str, keypoints
+        
+        def refine_existing_pose(instruction, keypoints_state):
+            if not keypoints_state:
+                gr.Warning("Please generate a pose first")
+                return None, None, keypoints_state
             
-            ### 3. 내보내기
-            - OpenPose 형식 JSON으로 다운로드
-            - ControlNet 등에서 사용 가능
+            refined_keypoints = refine_pose(keypoints_state, instruction)
+            pose_img = draw_pose(refined_keypoints)
+            json_str = keypoints_to_openpose_format(refined_keypoints)
+            return pose_img, json_str, refined_keypoints
+        
+        def manual_adjust(part, x_adj, y_adj, keypoints_state):
+            if not keypoints_state:
+                gr.Warning("Please generate a pose first")
+                return None, None, keypoints_state
             
-            ### API 키 설정 (선택사항)
-            ```bash
-            export FIREWORKS_API_KEY="your_api_key"
-            ```
+            if part not in keypoints_state:
+                gr.Warning(f"Part {part} not found in current pose")
+                return None, None, keypoints_state
             
-            ### 특징
-            - 🚀 GPU 불필요 - CPU만으로 작동
-            - 🎨 깔끔한 라인 아트 스타일
-            - 📊 OpenPose 호환 형식
-            - 🔧 쉬운 수정 도구
-            """)
-    
-    # Event handlers
-    def check_api_status():
-        if FIREWORKS_API_KEY != "YOUR_API_KEY_HERE":
-            return "✅ API 키 설정됨 - 고급 AI 사용 가능"
-        return "⚠️ API 키 미설정 - 템플릿 모드"
-    
-    def generate_pose(prompt_text, use_llm_flag):
-        if not prompt_text and not use_llm_flag:
-            # Use default template
-            keypoints = POSE_TEMPLATES["서있기 (Standing)"]
-        elif use_llm_flag and FIREWORKS_API_KEY != "YOUR_API_KEY_HERE":
-            keypoints = generate_pose_from_llm(prompt_text)
-        else:
-            keypoints = get_template_from_prompt(prompt_text)
+            adjusted_keypoints = keypoints_state.copy()
+            adjusted_keypoints[part][0] += x_adj
+            adjusted_keypoints[part][1] += y_adj
+            
+            pose_img = draw_pose(adjusted_keypoints)
+            json_str = keypoints_to_openpose_format(adjusted_keypoints)
+            return pose_img, json_str, adjusted_keypoints
         
-        # Draw pose
-        pose_img = draw_pose(keypoints)
-        json_str = keypoints_to_openpose_format(keypoints)
+        # Connect events
+        demo.load(check_api_status, outputs=api_status)
         
-        return pose_img, json_str, keypoints
-    
-    def use_template(template_name):
-        keypoints = POSE_TEMPLATES[template_name]
-        pose_img = draw_pose(keypoints)
-        json_str = keypoints_to_openpose_format(keypoints)
-        return pose_img, json_str, keypoints
-    
-    def refine_existing_pose(instruction, keypoints_state):
-        if not keypoints_state:
-            return None
+        generate_btn.click(
+            generate_pose,
+            inputs=[prompt, use_llm],
+            outputs=[pose_image, json_output, current_keypoints]
+        )
         
-        refined_keypoints = refine_pose(keypoints_state, instruction)
-        pose_img = draw_pose(refined_keypoints)
-        return pose_img, refined_keypoints
-    
-    def manual_adjust(part, x_adj, y_adj, keypoints_state):
-        if not keypoints_state or part not in keypoints_state:
-            return None, keypoints_state
+        use_template_btn.click(
+            use_template,
+            inputs=[template_select],
+            outputs=[pose_image, json_output, current_keypoints]
+        )
         
-        adjusted_keypoints = keypoints_state.copy()
-        adjusted_keypoints[part][0] += x_adj
-        adjusted_keypoints[part][1] += y_adj
+        refine_btn.click(
+            refine_existing_pose,
+            inputs=[refinement_instruction, current_keypoints],
+            outputs=[refined_image, refined_json, current_keypoints]
+        )
         
-        pose_img = draw_pose(adjusted_keypoints)
-        return pose_img, adjusted_keypoints
-    
-    # Connect events
-    demo.load(check_api_status, outputs=api_status)
-    
-    generate_btn.click(
-        generate_pose,
-        inputs=[prompt, use_llm],
-        outputs=[pose_image, json_output, current_keypoints]
-    )
-    
-    use_template_btn.click(
-        use_template,
-        inputs=[template_select],
-        outputs=[pose_image, json_output, current_keypoints]
-    )
-    
-    refine_btn.click(
-        refine_existing_pose,
-        inputs=[refinement_instruction, current_keypoints],
-        outputs=[refined_image, current_keypoints]
-    )
-    
-    apply_adjust_btn.click(
-        manual_adjust,
-        inputs=[selected_part, x_adjust, y_adjust, current_keypoints],
-        outputs=[refined_image, current_keypoints]
-    )
+        apply_adjust_btn.click(
+            manual_adjust,
+            inputs=[selected_part, x_adjust, y_adjust, current_keypoints],
+            outputs=[refined_image, refined_json, current_keypoints]
+        )
+        
+        return demo
+
+# Create and launch the app
+app = create_demo()
 
-# Launch
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_api=False
-    )
+    app.launch()