Update app.py

app.py

@@ -2,13 +2,10 @@
 
 import os
 import re
-import tempfile
 import gc
 from collections.abc import Iterator
 from threading import Thread
-import json
 import requests
-import cv2
 import gradio as gr
 import spaces
 import torch
@@ -18,12 +15,7 @@ from PIL import Image
 from transformers import AutoProcessor, Gemma3ForConditionalGeneration, TextIteratorStreamer
 import time
 import warnings
-from typing import Dict, List, Optional, Union
-
-# CSV/TXT 분석
-import pandas as pd
-# PDF 텍스트 추출
-import PyPDF2
+from typing import Union
 
 warnings.filterwarnings('ignore')
 
@@ -32,9 +24,7 @@ print("🎮 로봇 시각 시스템 초기화 (Gemma3-R1984-4B)...")
 ##############################################################################
 # 상수 정의
 ##############################################################################
-MAX_CONTENT_CHARS = 2000
 MAX_INPUT_LENGTH = 2096
-MAX_NUM_IMAGES = 5
 SERPHOUSE_API_KEY = os.getenv("SERPHOUSE_API_KEY", "")
 
 ##############################################################################
@@ -85,17 +75,17 @@ def do_web_search(query: str) -> str:
             "domain": "google.com",
             "serp_type": "web",
             "device": "desktop",
-            "lang": "ko",  # 한국어 우선
-            "num": "10"   # 10개로 제한
+            "lang": "ko",
+            "num": "5"  # 5개로 제한 (로봇 작업에 충분)
         }
         
         headers = {
             "Authorization": f"Bearer {SERPHOUSE_API_KEY}"
         }
         
-        logger.info(f"웹 검색 중... 검색어: {query}")
+        logger.info(f"로봇 작업 관련 검색: {query}")
         
-        response = requests.get(url, headers=headers, params=params, timeout=60)
+        response = requests.get(url, headers=headers, params=params, timeout=30)
         response.raise_for_status()
         
         data = response.json()
@@ -104,91 +94,22 @@ def do_web_search(query: str) -> str:
         organic = results.get("organic", []) if isinstance(results, dict) else []
         
         if not organic:
-            return "검색 결과를 찾을 수 없습니다."
-        
-        max_results = min(10, len(organic))
-        limited_organic = organic[:max_results]
-        
-        summary_lines = []
-        for idx, item in enumerate(limited_organic, start=1):
-            title = item.get("title", "제목 없음")
-            link = item.get("link", "#")
-            snippet = item.get("snippet", "설명 없음")
-            displayed_link = item.get("displayed_link", link)
+            return "검색 결과가 없습니다."
+        
+        # 로봇 작업에 유용한 정보만 추출
+        search_info = "# 로봇 작업 참고 정보\n\n"
+        for idx, item in enumerate(organic[:5], 1):
+            title = item.get("title", "")
+            snippet = item.get("snippet", "")
+            link = item.get("link", "")
             
-            summary_lines.append(
-                f"### 결과 {idx}: {title}\n\n"
-                f"{snippet}\n\n"
-                f"**출처**: [{displayed_link}]({link})\n\n"
-                f"---\n"
-            )
-        
-        instructions = """# 웹 검색 결과
-아래는 검색 결과입니다. 답변 시 이 정보를 활용하세요:
-1. 각 결과의 제목, 내용, 출처 링크를 참조하세요
-2. 관련 출처를 명시적으로 인용하세요
-3. 여러 출처의 정보를 종합하여 답변하세요
-"""
+            search_info += f"{idx}. {title}\n{snippet}\n출처: {link}\n\n"
         
-        search_results = instructions + "\n".join(summary_lines)
-        return search_results
+        return search_info
     
     except Exception as e:
         logger.error(f"웹 검색 실패: {e}")
-        return f"웹 검색 실패: {str(e)}"
-
-##############################################################################
-# 문서 처리 함수
-##############################################################################
-def analyze_csv_file(path: str) -> str:
-    """CSV 파일 분석"""
-    try:
-        df = pd.read_csv(path)
-        if df.shape[0] > 50 or df.shape[1] > 10:
-            df = df.iloc[:50, :10]
-        df_str = df.to_string()
-        if len(df_str) > MAX_CONTENT_CHARS:
-            df_str = df_str[:MAX_CONTENT_CHARS] + "\n...(중략)..."
-        return f"**[CSV 파일: {os.path.basename(path)}]**\n\n{df_str}"
-    except Exception as e:
-        return f"CSV 읽기 실패 ({os.path.basename(path)}): {str(e)}"
-
-def analyze_txt_file(path: str) -> str:
-    """TXT 파일 분석"""
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            text = f.read()
-        if len(text) > MAX_CONTENT_CHARS:
-            text = text[:MAX_CONTENT_CHARS] + "\n...(중략)..."
-        return f"**[TXT 파일: {os.path.basename(path)}]**\n\n{text}"
-    except Exception as e:
-        return f"TXT 읽기 실패 ({os.path.basename(path)}): {str(e)}"
-
-def pdf_to_markdown(pdf_path: str) -> str:
-    """PDF를 마크다운으로 변환"""
-    text_chunks = []
-    try:
-        with open(pdf_path, "rb") as f:
-            reader = PyPDF2.PdfReader(f)
-            max_pages = min(5, len(reader.pages))
-            for page_num in range(max_pages):
-                page = reader.pages[page_num]
-                page_text = page.extract_text() or ""
-                page_text = page_text.strip()
-                if page_text:
-                    if len(page_text) > MAX_CONTENT_CHARS // max_pages:
-                        page_text = page_text[:MAX_CONTENT_CHARS // max_pages] + "...(중략)"
-                    text_chunks.append(f"## 페이지 {page_num+1}\n\n{page_text}\n")
-            if len(reader.pages) > max_pages:
-                text_chunks.append(f"\n...({max_pages}/{len(reader.pages)} 페이지 표시)...")
-    except Exception as e:
-        return f"PDF 읽기 실패 ({os.path.basename(pdf_path)}): {str(e)}"
-
-    full_text = "\n".join(text_chunks)
-    if len(full_text) > MAX_CONTENT_CHARS:
-        full_text = full_text[:MAX_CONTENT_CHARS] + "\n...(중략)..."
-
-    return f"**[PDF 파일: {os.path.basename(pdf_path)}]**\n\n{full_text}"
+        return ""
 
 ##############################################################################
 # 모델 로드
@@ -224,12 +145,12 @@ def load_model():
         return False
 
 ##############################################################################
-# 이미지 분석 (로봇 태스크 중심)
+# 로봇 작업 분석 함수
 ##############################################################################
 @spaces.GPU(duration=60)
-def analyze_image_for_robot(
+def analyze_for_robot_task(
     image: Union[np.ndarray, Image.Image],
-    prompt: str,
+    task_description: str,
     task_type: str = "general",
     use_web_search: bool = False,
     enable_thinking: bool = True,
@@ -247,44 +168,78 @@ def analyze_image_for_robot(
         if isinstance(image, np.ndarray):
             image = Image.fromarray(image).convert('RGB')
         
-        # 태스크별 시스템 프롬프트 구성
+        # 태스크별 시스템 프롬프트
         system_prompts = {
-            "general": "당신은 로봇 시각 시스템입니다. 이미지를 자세히 분석하고 설명하세요.",
-            "planning": """당신은 로봇 작업 계획을 수립하는 AI입니다. 
-주어진 이미지와 작업을 분석하여 단계별 실행 계획을 작성하세요.
-형식: Step_1: xxx\nStep_2: xxx\n...\nStep_n: xxx""",
-            "grounding": "당신은 객체 위치를 찾는 로봇 시각 시스템입니다. 요청된 객체의 위치를 [x1, y1, x2, y2] 좌표로 반환하세요.",
-            "affordance": "당신은 로봇 파지점을 분석하는 AI입니다. 주어진 작업을 위한 최적의 파지 영역을 [x1, y1, x2, y2] 좌표로 예측하세요.",
-            "trajectory": "당신은 로봇 경로를 계획하는 AI입니다. 목표 지점까지의 경로를 [(x1,y1), (x2,y2), ...] 형식으로 제시하세요.",
-            "pointing": "당신은 다중 지점을 지정하는 로봇 시각 시스템입니다. 요청된 위치들을 [(x1,y1), (x2,y2), ...] 형식으로 반환하세요."
+            "general": """당신은 고급 로봇 시각 시스템입니다. 
+이미지를 분석하여 로봇이 수행할 수 있는 작업을 식별하고 설명하세요.
+환경의 객체, 위치, 잠재적 위험 요소를 포함하여 상세히 분석하세요.""",
+            
+            "planning": """당신은 로봇 작업 계획 전문가입니다.
+주어진 작업을 위한 단계별 실행 계획을 작성하세요.
+각 단계는 명확하고 실행 가능해야 합니다.
+
+형식:
+Step_1: [동작] - [상세 설명]
+Step_2: [동작] - [상세 설명]
+...
+Step_n: [동작] - [상세 설명]
+
+안전 고려사항: [주의사항]""",
+            
+            "grounding": """당신은 정밀한 객체 위치 파악 시스템입니다.
+요청된 객체의 정확한 위치를 찾아 바운딩 박스 좌표를 제공하세요.
+
+출력 형식: [x1, y1, x2, y2]
+- (x1, y1): 좌상단 좌표
+- (x2, y2): 우하단 좌표
+- 좌표는 0-1000 범위의 정수""",
+            
+            "affordance": """당신은 로봇 그리퍼 제어 전문가입니다.
+주어진 작업을 위한 최적의 파지 위치와 방법을 분석하세요.
+
+출력 형식:
+파지 영역: [x1, y1, x2, y2]
+파지 방향: [수직/수평/각도]
+파지 강도: [약함/중간/강함]
+주의사항: [특별 고려사항]""",
+            
+            "trajectory": """당신은 로봇 경로 계획 전문가입니다.
+시작점에서 목표점까지의 최적 경로를 계획하세요.
+
+출력 형식:
+경로: [(x1,y1), (x2,y2), ..., (xn,yn)]
+예상 소요 시간: [초]
+장애물 회피: [설명]
+안전 여유: [cm]"""
         }
         
         system_prompt = system_prompts.get(task_type, system_prompts["general"])
         
         # Chain-of-Thought 추가
         if enable_thinking:
-            system_prompt += "\n\n추론 과정을 <thinking></thinking> 태그 안에 상세히 작성한 후 최종 답변을 제시��세요."
+            system_prompt += "\n\n먼저 <thinking> 태그 안에 분석 과정을 상세히 작성한 후, <answer> 태그 안에 최종 결과를 제시하세요."
+        
+        # 웹 검색 수행 (로봇 작업 관련)
+        web_info = ""
+        if use_web_search and task_type in ["planning", "affordance"]:
+            # 로봇 작업 관련 키워드로 검색
+            search_query = f"로봇 {task_description} 방법 가이드"
+            web_info = do_web_search(search_query)
         
-        # 웹 검색 수행
-        combined_system = system_prompt
-        if use_web_search:
-            keywords = extract_keywords(prompt, top_k=5)
-            if keywords:
-                logger.info(f"웹 검색 키워드: {keywords}")
-                search_results = do_web_search(keywords)
-                combined_system = f"{search_results}\n\n{system_prompt}"
+        # 최종 시스템 프롬프트
+        final_system = web_info + "\n\n" + system_prompt if web_info else system_prompt
         
         # 메시지 구성
         messages = [
             {
                 "role": "system",
-                "content": [{"type": "text", "text": combined_system}]
+                "content": [{"type": "text", "text": final_system}]
             },
             {
                 "role": "user",
                 "content": [
                     {"type": "image", "url": image},
-                    {"type": "text", "text": prompt}
+                    {"type": "text", "text": f"작업: {task_description}"}
                 ]
             }
         ]
@@ -324,312 +279,220 @@ def analyze_image_for_robot(
         return response
         
     except Exception as e:
-        logger.error(f"이미지 분석 오류: {e}")
+        logger.error(f"로봇 작업 분석 오류: {e}")
         import traceback
         return f"❌ 분석 오류: {str(e)}\n{traceback.format_exc()}"
     finally:
         clear_cuda_cache()
 
 ##############################################################################
-# 문서 분석 (스트리밍)
-##############################################################################
-def _model_gen_with_oom_catch(**kwargs):
-    """OOM 처리를 위한 생성 함수"""
-    global model
-    try:
-        model.generate(**kwargs)
-    except torch.cuda.OutOfMemoryError:
-        raise RuntimeError("GPU 메모리 부족. Max Tokens를 줄여주세요.")
-    finally:
-        clear_cuda_cache()
-
-@spaces.GPU(duration=120)
-def analyze_documents_streaming(
-    files: List[str],
-    prompt: str,
-    use_web_search: bool = False,
-    max_new_tokens: int = 2048
-) -> Iterator[str]:
-    """문서 분석 (스트리밍)"""
-    global model, processor
-    
-    if not model_loaded:
-        if not load_model():
-            yield "❌ 모델 로딩 실패"
-            return
-    
-    try:
-        # 시스템 프롬프트
-        system_content = "당신은 문서를 분석하고 요약하는 전문 AI입니다."
-        
-        # 웹 검색
-        if use_web_search:
-            keywords = extract_keywords(prompt, top_k=5)
-            if keywords:
-                search_results = do_web_search(keywords)
-                system_content = f"{search_results}\n\n{system_content}"
-        
-        # 문서 내용 처리
-        doc_contents = []
-        for file_path in files:
-            if file_path.lower().endswith('.csv'):
-                content = analyze_csv_file(file_path)
-            elif file_path.lower().endswith('.txt'):
-                content = analyze_txt_file(file_path)
-            elif file_path.lower().endswith('.pdf'):
-                content = pdf_to_markdown(file_path)
-            else:
-                continue
-            doc_contents.append(content)
-        
-        # 메시지 구성
-        messages = [
-            {
-                "role": "system",
-                "content": [{"type": "text", "text": system_content}]
-            },
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "\n\n".join(doc_contents) + f"\n\n{prompt}"}
-                ]
-            }
-        ]
-        
-        # 입력 처리
-        inputs = processor.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            tokenize=True,
-            return_dict=True,
-            return_tensors="pt",
-        ).to(device=model.device, dtype=torch.bfloat16)
-        
-        # 스트리밍 설정
-        streamer = TextIteratorStreamer(processor, timeout=30.0, skip_prompt=True, skip_special_tokens=True)
-        gen_kwargs = dict(
-            inputs,
-            streamer=streamer,
-            max_new_tokens=max_new_tokens,
-            temperature=0.8,
-            top_p=0.9,
-        )
-        
-        # 별도 스레드에서 생성
-        t = Thread(target=_model_gen_with_oom_catch, kwargs=gen_kwargs)
-        t.start()
-        
-        # 스트리밍 출력
-        output = ""
-        for new_text in streamer:
-            output += new_text
-            yield output
-            
-    except Exception as e:
-        logger.error(f"문서 분석 오류: {e}")
-        yield f"❌ 오류 발생: {str(e)}"
-    finally:
-        clear_cuda_cache()
-
-##############################################################################
-# Gradio UI (로봇 시각화 중심)
+# Gradio UI (로봇 작업 중심)
 ##############################################################################
 css = """
 .robot-header {
     text-align: center;
     background: linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #667eea 100%);
     color: white;
-    padding: 20px;
-    border-radius: 10px;
+    padding: 25px;
+    border-radius: 15px;
     margin-bottom: 20px;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+}
+.robot-header h1 {
+    margin: 0 0 10px 0;
+    font-size: 2.5em;
 }
 .status-box {
     text-align: center;
-    padding: 10px;
-    border-radius: 5px;
-    margin: 10px 0;
+    padding: 12px;
+    border-radius: 8px;
+    margin: 15px 0;
     font-weight: bold;
+    font-size: 1.1em;
 }
-.info-box {
-    background: #f0f0f0;
-    padding: 15px;
-    border-radius: 8px;
-    margin: 10px 0;
-    border-left: 4px solid #2a5298;
+.task-card {
+    background: white;
+    padding: 20px;
+    border-radius: 10px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+    margin-bottom: 20px;
 }
 .task-button {
-    min-height: 60px;
-    font-size: 1.1em;
+    min-height: 80px;
+    font-size: 1.2em;
+    font-weight: bold;
+    transition: all 0.3s ease;
+}
+.task-button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
 }
 .webcam-container {
     border: 3px solid #2a5298;
-    border-radius: 10px;
-    padding: 10px;
+    border-radius: 15px;
+    padding: 15px;
     background: #f8f9fa;
 }
+.result-container {
+    background: #f0f8ff;
+    border-left: 5px solid #2a5298;
+    padding: 20px;
+    border-radius: 10px;
+}
 """
 
-with gr.Blocks(title="🤖 로봇 시각 시스템 (Gemma3-4B)", css=css) as demo:
+with gr.Blocks(title="🤖 로봇 시각 시스템", css=css) as demo:
     gr.HTML("""
     <div class="robot-header">
         <h1>🤖 로봇 시각 시스템</h1>
-        <h3>🎮 Gemma3-R1984-4B + 📷 실시간 웹캠 + 🔍 웹 검색</h3>
-        <p>⚡ 최신 멀티모달 AI로 로봇 작업 분석 및 계획 수립!</p>
-    </div>
-    """)
-    
-    gr.HTML("""
-    <div class="info-box">
-        <h4>🌟 시스템 특징:</h4>
-        <ul>
-            <li>🖼️ 고급 이미지/비디오 분석 (Gemma3-4B VLM)</li>
-            <li>📋 다단계 작업 계획 및 추론</li>
-            <li>📍 정밀한 객체 위치 파악 (Grounding)</li>
-            <li>🤏 로봇 파지점 분석 (Affordance)</li>
-            <li>🛤️ 경로 계획 (Trajectory Planning)</li>
-            <li>🔍 실시간 웹 검색 통합</li>
-            <li>📄 문서 분석 (PDF, CSV, TXT)</li>
-        </ul>
+        <p style="font-size: 1.2em; margin: 0;">실시간 작업 분석 및 계획 수립</p>
+        <p style="font-size: 0.9em; opacity: 0.9; margin-top: 5px;">Powered by Gemma3-R1984-4B</p>
     </div>
     """)
     
     with gr.Row():
-        # 왼쪽: 웹캠 및 입력
+        # 왼쪽: 웹캠 영역
         with gr.Column(scale=1):
-            gr.Markdown("### 📷 실시간 웹캠")
-            
             with gr.Group(elem_classes="webcam-container"):
+                gr.Markdown("## 📷 실시간 웹캠")
+                
                 webcam = gr.Image(
                     sources=["webcam"], 
                     streaming=True,
                     type="numpy",
                     label="실시간 스트리밍",
-                    height=350
+                    height=400
                 )
                 
-                # 캡처된 이미지 표시
+                with gr.Row():
+                    capture_btn = gr.Button("📸 캡처", variant="primary", size="lg")
+                    clear_btn = gr.Button("🗑️ 초기화", size="lg")
+                
                 captured_image = gr.Image(
                     label="캡처된 이미지",
-                    height=200,
+                    height=300,
                     visible=False
                 )
-            
-            # 로봇 작업 버튼들
-            gr.Markdown("### 🎯 로봇 작업 선택")
-            with gr.Row():
-                capture_btn = gr.Button("📸 캡처", variant="primary", elem_classes="task-button")
-                clear_capture_btn = gr.Button("🗑️ 초기화", elem_classes="task-button")
-            
-            with gr.Row():
-                planning_btn = gr.Button("📋 작업 계획", elem_classes="task-button")
-                grounding_btn = gr.Button("📍 객체 위치", elem_classes="task-button")
-            
-            with gr.Row():
-                affordance_btn = gr.Button("🤏 파지점 분석", elem_classes="task-button")
-                trajectory_btn = gr.Button("🛤️ ��로 계획", elem_classes="task-button")
         
-        # 오른쪽: 분석 설정 및 결과
+        # 오른쪽: 작업 제어 및 결과
         with gr.Column(scale=2):
-            gr.Markdown("### ⚙️ 분석 설정")
-            
-            with gr.Row():
-                with gr.Column():
-                    task_prompt = gr.Textbox(
-                        label="작업 설명 / 질문",
-                        placeholder="예: 테이블 위의 컵을 잡아서 싱크대에 놓기",
-                        value="이 장면에서 로봇이 수행할 수 있는 작업을 분석하세요.",
-                        lines=2
+            # 작업 설정
+            with gr.Group(elem_classes="task-card"):
+                gr.Markdown("## ⚙️ 작업 설정")
+                
+                task_input = gr.Textbox(
+                    label="작업 설명",
+                    placeholder="예: 빨간색 컵을 잡아서 파란색 박스에 넣기",
+                    value="이 장면에서 수행할 로봇 작업을 설명하세요",
+                    lines=2
+                )
+                
+                with gr.Row():
+                    use_search = gr.Checkbox(
+                        label="🔍 웹 검색 사용",
+                        value=False,
+                        info="작업 수행 방법을 웹에서 검색"
                     )
                     
-                    with gr.Row():
-                        use_web_search = gr.Checkbox(
-                            label="🔍 웹 검색 사용",
-                            value=False,
-                            info="관련 정보를 웹에서 검색합니다"
-                        )
-                        
-                        enable_thinking = gr.Checkbox(
-                            label="🤔 추론 과정 표시",
-                            value=True,
-                            info="Chain-of-Thought 추론 과정을 보여줍니다"
-                        )
-                    
-                    max_tokens = gr.Slider(
-                        label="최대 토큰 수",
-                        minimum=256,
-                        maximum=4096,
-                        value=1024,
-                        step=256
+                    show_thinking = gr.Checkbox(
+                        label="🤔 추론 과정 표시",
+                        value=True,
+                        info="AI의 분석 과정을 투명하게 표시"
                     )
-            
-            gr.Markdown("### 📊 분석 결과")
-            result_output = gr.Textbox(
-                label="AI 분석 결과",
-                lines=20,
-                max_lines=40,
-                show_copy_button=True,
-                elem_id="result"
-            )
-            
-            status_display = gr.HTML(
-                '<div class="status-box" style="background:#d4edda; color:#155724;">🎮 시스템 준비 완료</div>'
-            )
-    
-    # 문서 분석 탭
-    with gr.Tab("📄 문서 분석"):
-        with gr.Row():
-            with gr.Column():
-                doc_files = gr.File(
-                    label="문서 업로드",
-                    file_count="multiple",
-                    file_types=[".pdf", ".csv", ".txt"],
-                    type="filepath"
-                )
                 
-                doc_prompt = gr.Textbox(
-                    label="분석 요청",
-                    placeholder="예: 이 문서들의 핵심 내용을 요약하고 비교 분석하세요.",
-                    lines=3
+                max_tokens = gr.Slider(
+                    label="응답 길이",
+                    minimum=256,
+                    maximum=2048,
+                    value=1024,
+                    step=256
                 )
+            
+            # 로봇 작업 버튼
+            with gr.Group(elem_classes="task-card"):
+                gr.Markdown("## 🎯 로봇 작업 분석")
                 
-                doc_web_search = gr.Checkbox(
-                    label="🔍 웹 검색 사용",
-                    value=False
-                )
+                with gr.Row():
+                    analyze_btn = gr.Button(
+                        "🔍 장면 분석",
+                        variant="secondary",
+                        elem_classes="task-button"
+                    )
+                    planning_btn = gr.Button(
+                        "📋 작업 계획",
+                        variant="primary",
+                        elem_classes="task-button"
+                    )
                 
-                analyze_docs_btn = gr.Button("📊 문서 분석", variant="primary")
-            
-            with gr.Column():
-                doc_result = gr.Textbox(
-                    label="분석 결과",
-                    lines=25,
-                    max_lines=50
+                with gr.Row():
+                    grounding_btn = gr.Button(
+                        "📍 객체 위치",
+                        variant="secondary",
+                        elem_classes="task-button"
+                    )
+                    affordance_btn = gr.Button(
+                        "🤏 파지점 분석",
+                        variant="secondary",
+                        elem_classes="task-button"
+                    )
+                
+                trajectory_btn = gr.Button(
+                    "🛤️ 경로 계획",
+                    variant="secondary",
+                    elem_classes="task-button",
+                    elem_id="trajectory"
                 )
+            
+            # 상태 표시
+            status_display = gr.HTML(
+                '<div class="status-box" style="background:#d4edda; color:#155724;">🟢 시스템 준비 완료</div>'
+            )
     
-    # 이벤트 핸들러
-    webcam_state = gr.State(None)
+    # 분석 결과
+    with gr.Group(elem_classes="result-container"):
+        gr.Markdown("## 📊 분석 결과")
+        result_output = gr.Textbox(
+            label="",
+            lines=20,
+            max_lines=40,
+            show_copy_button=True
+        )
     
-    def capture_webcam(frame):
+    # 상태 관리
+    captured_state = gr.State(None)
+    
+    # 이벤트 핸들러
+    def capture_frame(frame):
         """웹캠 프레임 캡처"""
         if frame is None:
-            return None, None, '<div class="status-box" style="background:#f8d7da; color:#721c24;">❌ 웹캠 프레임 없음</div>'
-        return frame, gr.update(value=frame, visible=True), '<div class="status-box" style="background:#d4edda; color:#155724;">✅ 이미지 캡처 완료</div>'
+            return None, gr.update(visible=False), '<div class="status-box" style="background:#f8d7da; color:#721c24;">❌ 웹캠이 연결되지 않았습니다</div>'
+        
+        return frame, gr.update(value=frame, visible=True), '<div class="status-box" style="background:#d1ecf1; color:#0c5460;">📸 이미지가 캡처되었습니다</div>'
     
     def clear_capture():
         """캡처 초기화"""
-        return None, gr.update(visible=False), '<div class="status-box" style="background:#d4edda; color:#155724;">🎮 시스템 준비 완료</div>'
+        return None, gr.update(visible=False), '<div class="status-box" style="background:#d4edda; color:#155724;">🟢 시스템 준비 완료</div>', ""
     
-    def analyze_with_task(image, prompt, task_type, use_search, thinking, tokens):
-        """특정 태스크로 이미지 분석"""
+    def analyze_task(image, task_desc, task_type, use_search, thinking, tokens):
+        """로봇 작업 분석"""
         if image is None:
-            return "❌ 먼저 이미지를 캡처하세요.", '<div class="status-box" style="background:#f8d7da; color:#721c24;">❌ 이미지 없음</div>'
+            return "❌ 먼저 이미지를 캡처하세요!", '<div class="status-box" style="background:#f8d7da; color:#721c24;">❌ 이미지가 없습니다</div>'
         
-        status = f'<div class="status-box" style="background:#cce5ff; color:#004085;">🚀 {task_type} 분석 중...</div>'
+        # 작업 유형별 상태 메시지
+        task_messages = {
+            "general": "장면 분석",
+            "planning": "작업 계획 수립",
+            "grounding": "객체 위치 파악",
+            "affordance": "파지점 분석",
+            "trajectory": "경로 계획"
+        }
+        
+        status_msg = f'<div class="status-box" style="background:#cce5ff; color:#004085;">🔄 {task_messages[task_type]} 중...</div>'
         
-        result = analyze_image_for_robot(
+        # 분석 수행
+        result = analyze_for_robot_task(
             image=image,
-            prompt=prompt,
+            task_description=task_desc,
             task_type=task_type,
             use_web_search=use_search,
             enable_thinking=thinking,
@@ -637,101 +500,83 @@ with gr.Blocks(title="🤖 로봇 시각 시스템 (Gemma3-4B)", css=css) as dem
         )
         
         # 결과 포맷팅
-        timestamp = time.strftime("%H:%M:%S")
-        task_names = {
-            "planning": "작업 계획",
-            "grounding": "객체 위치 파악",
-            "affordance": "파지점 분석",
-            "trajectory": "경로 계획"
-        }
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
         
-        formatted_result = f"""🤖 로봇 {task_names.get(task_type, '분석')} 결과:
+        formatted_result = f"""╔══════════════════════════════════════════════════════════╗
+║ 🤖 로봇 작업 분석 결과                                   ║
+╚══════════════════════════════════════════════════════════╝
+
+📋 작업 유형: {task_messages[task_type]}
+📝 작업 설명: {task_desc}
+⏰ 분석 시간: {timestamp}
 
-📸 **작��**: {prompt}
+════════════════════════════════════════════════════════════
 
-📝 **분석 결과**:
 {result}
 
-⏰ 분석 시간: {timestamp}
+════════════════════════════════════════════════════════════
+
 🎯 모델: {model_name}
-🔧 태스크: {task_type}"""
+🔧 분석 완료"""
         
-        complete_status = '<div class="status-box" style="background:#d4edda; color:#155724;">✅ 분석 완료!</div>'
+        complete_status = '<div class="status-box" style="background:#d4edda; color:#155724;">✅ 분석이 완료되었습니다</div>'
         return formatted_result, complete_status
     
-    # 웹캠 스트리밍
-    webcam.stream(
-        fn=lambda x: x,
+    # 버튼 이벤트 연결
+    capture_btn.click(
+        fn=lambda frame: capture_frame(frame) if frame is not None else capture_frame(webcam.value),
         inputs=[webcam],
-        outputs=[webcam_state]
+        outputs=[captured_state, captured_image, status_display]
     )
     
-    # 캡처 버튼
-    capture_btn.click(
-        fn=capture_webcam,
-        inputs=[webcam_state],
-        outputs=[webcam_state, captured_image, status_display]
+    clear_btn.click(
+        fn=clear_capture,
+        outputs=[captured_state, captured_image, status_display, result_output]
     )
     
-    # 초기화 버튼
-    clear_capture_btn.click(
-        fn=clear_capture,
-        outputs=[webcam_state, captured_image, status_display]
+    # 작업 분석 버튼들
+    analyze_btn.click(
+        fn=lambda img, desc, s, t, tk: analyze_task(img, desc, "general", s, t, tk),
+        inputs=[captured_state, task_input, use_search, show_thinking, max_tokens],
+        outputs=[result_output, status_display]
     )
     
-    # 작업 버튼들
     planning_btn.click(
-        fn=lambda img, p, s, t, tk: analyze_with_task(img, p, "planning", s, t, tk),
-        inputs=[captured_image, task_prompt, use_web_search, enable_thinking, max_tokens],
+        fn=lambda img, desc, s, t, tk: analyze_task(img, desc, "planning", s, t, tk),
+        inputs=[captured_state, task_input, use_search, show_thinking, max_tokens],
         outputs=[result_output, status_display]
     )
     
     grounding_btn.click(
-        fn=lambda img, p, s, t, tk: analyze_with_task(img, p, "grounding", s, t, tk),
-        inputs=[captured_image, task_prompt, use_web_search, enable_thinking, max_tokens],
+        fn=lambda img, desc, s, t, tk: analyze_task(img, desc, "grounding", s, t, tk),
+        inputs=[captured_state, task_input, use_search, show_thinking, max_tokens],
         outputs=[result_output, status_display]
     )
     
     affordance_btn.click(
-        fn=lambda img, p, s, t, tk: analyze_with_task(img, p, "affordance", s, t, tk),
-        inputs=[captured_image, task_prompt, use_web_search, enable_thinking, max_tokens],
+        fn=lambda img, desc, s, t, tk: analyze_task(img, desc, "affordance", s, t, tk),
+        inputs=[captured_state, task_input, use_search, show_thinking, max_tokens],
         outputs=[result_output, status_display]
     )
     
     trajectory_btn.click(
-        fn=lambda img, p, s, t, tk: analyze_with_task(img, p, "trajectory", s, t, tk),
-        inputs=[captured_image, task_prompt, use_web_search, enable_thinking, max_tokens],
+        fn=lambda img, desc, s, t, tk: analyze_task(img, desc, "trajectory", s, t, tk),
+        inputs=[captured_state, task_input, use_search, show_thinking, max_tokens],
         outputs=[result_output, status_display]
     )
     
-    # 문서 분석
-    def analyze_docs(files, prompt, use_search):
-        if not files:
-            return "❌ 문서를 업로드하세요."
-        
-        output = ""
-        for chunk in analyze_documents_streaming(files, prompt, use_search):
-            output = chunk
-        return output
-    
-    analyze_docs_btn.click(
-        fn=analyze_docs,
-        inputs=[doc_files, doc_prompt, doc_web_search],
-        outputs=[doc_result]
-    )
-    
     # 초기 모델 로드
     def initial_load():
         load_model()
-        return "시스템 준비 완료! 🚀"
+        return '<div class="status-box" style="background:#d4edda; color:#155724;">🚀 시스템이 준비되었습니다!</div>'
     
     demo.load(
         fn=initial_load,
-        outputs=None
+        outputs=[status_display]
     )
 
 if __name__ == "__main__":
-    print("🚀 로봇 시각 시스템 시작 (Gemma3-R1984-4B)...")
+    print("🚀 로봇 시각 시스템 시작...")
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,