Set shrimp_detection_app as main app (app.py)

- Backup original app.py to app_backup.py
- Copy shrimp_detection_app.py to app.py for deployment
- Main app now includes YOLOv8 model, VIDraft/Shrimp branding, and full features

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -1,299 +1,1150 @@
 # -*- coding: utf-8 -*-
 """
-바운딩 박스 검출 테스트 페이지
-VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 결과 비교
+🦐 새우 검출 통합 시스템
+3개의 앱을 하나로 통합: 자동 검출, 라벨링 도구, 데모
+RT-DETR 또는 VIDraft/Shrimp 클라우드 모델 선택 가능
 """
 import sys
 sys.stdout.reconfigure(encoding='utf-8')
 
 import gradio as gr
 from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import json
 import os
+import glob
+from datetime import datetime
+import torch
+from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+import requests
+import base64
+from io import BytesIO
+from inference_sdk import InferenceHTTPClient
+import tempfile
 
-# VIDraft/Shrimp 전용 검출기
-try:
-    from inference_sdk import InferenceHTTPClient, InferenceConfiguration
+# test_visual_validation에서 가져오기 (지연 import로 변경)
+# from test_visual_validation import (
+#     load_rtdetr_model,
+#     detect_with_rtdetr,
+#     apply_universal_filter,
+#     calculate_morphological_features,
+#     calculate_visual_features
+# )
 
-    vidraft_client = InferenceHTTPClient(
-        api_url="https://serverless.roboflow.com",
-        api_key="azcIL8KDJVJMYrsERzI7"
-    )
-    VIDRAFT_AVAILABLE = True
-    print("✅ VIDraft/Shrimp 모델 사용 가능")
-except Exception as e:
-    VIDRAFT_AVAILABLE = False
-    print(f"❌ VIDraft/Shrimp 모델 사용 불가: {e}")
+# YOLOv8 import
+from ultralytics import YOLO
 
-def detect_with_vidraft(image, confidence, iou_threshold):
-    """VIDraft/Shrimp 전용 모델로 검출"""
-    if not VIDRAFT_AVAILABLE:
-        return None, "❌ VIDraft/Shrimp 모델을 사용할 수 없습니다."
+# ============================================================
+# YOLOv8 모델 설정
+# ============================================================
+YOLO_MODEL_PATH = "runs/train/yolov8m_shrimp2/weights/best.pt"
+yolo_model = None
 
-    if image is None:
-        return None, "⚠️ 이미지를 업로드하세요."
+def load_yolo_model():
+    """YOLOv8 모델 로딩"""
+    global yolo_model
+    if yolo_model is None:
+        print(f"🔄 YOLOv8 모델 로딩 중: {YOLO_MODEL_PATH}")
+        yolo_model = YOLO(YOLO_MODEL_PATH)
+        print("✅ YOLOv8 모델 로딩 완료")
+    return yolo_model
 
+def detect_with_yolo(image, confidence=0.1):
+    """YOLOv8 모델로 검출"""
     try:
-        # 임시 파일로 저장
-        import tempfile
-        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            image.save(tmp.name, quality=95)
-            tmp_path = tmp.name
-
-        # API 호출 with configuration
-        custom_config = InferenceConfiguration(
-            confidence_threshold=confidence,
-            iou_threshold=iou_threshold
+        model = load_yolo_model()
+
+        # 추론 실행
+        results = model.predict(
+            source=image,
+            conf=confidence,
+            verbose=False
         )
 
-        with vidraft_client.use_configuration(custom_config):
-            result = vidraft_client.infer(tmp_path, model_id="shrimp-konvey/2")
+        detections = []
+        for result in results:
+            boxes = result.boxes
+            for box in boxes:
+                x1, y1, x2, y2 = box.xyxy[0].tolist()
+                conf = box.conf[0].item()
 
-        # 임시 파일 삭제
-        os.unlink(tmp_path)
+                detections.append({
+                    'bbox': [x1, y1, x2, y2],
+                    'confidence': conf
+                })
 
-        # 결과 그리기
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
+        print(f"✅ YOLOv8 검출 완료: {len(detections)}개")
+        return detections
 
-        try:
-            font = ImageFont.truetype("arial.ttf", 14)
-        except:
-            font = ImageFont.load_default()
+    except Exception as e:
+        print(f"❌ YOLOv8 검출 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return []
+
+# ============================================================
+# Roboflow SDK 설정 (최적화된 방식)
+# ============================================================
+ROBOFLOW_API_KEY = "azcIL8KDJVJMYrsERzI7"
+
+# Roboflow Inference SDK 클라이언트 (connection pooling 지원)
+roboflow_client = InferenceHTTPClient(
+    api_url="https://serverless.roboflow.com",
+    api_key=ROBOFLOW_API_KEY
+)
+
+def detect_with_roboflow(image, confidence=0.065):
+    """Roboflow API를 사용한 최적화된 검출 (로컬 테스트와 동일)"""
+    try:
+        # 원본 이미지 보존
+        image_original = image
+        original_size = image_original.size
+
+        # 리사이즈 (API 전송용)
+        image_resized = image_original.copy()
+        image_resized.thumbnail((640, 640), Image.Resampling.LANCZOS)
+        print(f"📐 이미지 리사이즈: {original_size} → {image_resized.size}")
 
-        predictions = result["predictions"]
-        detected_count = 0
+        # Base64 인코딩
+        buffered = BytesIO()
+        image_resized.save(buffered, format="JPEG", quality=80)
+        img_base64 = base64.b64encode(buffered.getvalue()).decode()
+        print(f"📦 Base64 크기: {len(img_base64)} bytes")
+
+        print(f"🔄 Roboflow API 추론 시작...")
+
+        # 🚀 최적화 3: requests로 API 호출 (SDK 대신 사용 - 더 안정적)
+        response = requests.post(
+            'https://serverless.roboflow.com/vidraft/workflows/find-shrimp-6',
+            headers={'Content-Type': 'application/json'},
+            json={
+                'api_key': ROBOFLOW_API_KEY,
+                'inputs': {
+                    'image': {'type': 'base64', 'value': img_base64}
+                }
+            },
+            timeout=30
+        )
+
+        if response.status_code != 200:
+            print(f"❌ Roboflow API 오류: {response.status_code}")
+            print(f"응답: {response.text}")
+            return []
+
+        result = response.json()
+        print(f"🔍 Roboflow 응답: {json.dumps(result, indent=2, ensure_ascii=False)[:500]}...")
+
+        # Workflow 응답 구조 파싱
+        detections = []
+        predictions = []
+
+        # 방법 1: outputs[0].predictions.predictions (workflow 형태)
+        if isinstance(result, dict) and 'outputs' in result and len(result['outputs']) > 0:
+            output = result['outputs'][0]
+            if isinstance(output, dict) and 'predictions' in output:
+                pred_data = output['predictions']
+                # predictions가 dict이고 그 안에 predictions 배열이 있는 경우
+                if isinstance(pred_data, dict) and 'predictions' in pred_data:
+                    predictions = pred_data['predictions']
+                # predictions가 바로 배열인 경우
+                elif isinstance(pred_data, list):
+                    predictions = pred_data
+                else:
+                    predictions = [pred_data]
+
+        # 방법 2: 직접 predictions
+        elif isinstance(result, dict) and 'predictions' in result:
+            predictions = result['predictions']
+
+        # 방법 3: 다른 구조
+        elif isinstance(result, list):
+            predictions = result
+
+        print(f"📦 찾은 predictions: {len(predictions)}개")
+
+        # 스케일 계산 (리사이즈된 좌표 → 원본 좌표)
+        scale_x = original_size[0] / image_resized.size[0]
+        scale_y = original_size[1] / image_resized.size[1]
+        print(f"📏 스케일: x={scale_x:.2f}, y={scale_y:.2f}")
 
         for pred in predictions:
-            if pred["confidence"] < confidence:
+            # 클래스 필터링 (shrimp만 검출)
+            pred_class = pred.get('class', '')
+            if pred_class != 'shrimp':
                 continue
 
-            detected_count += 1
+            # 신뢰도 필터링
+            pred_confidence = pred.get('confidence', 0)
+            if pred_confidence < confidence:
+                continue
 
-            x = pred["x"]
-            y = pred["y"]
-            w = pred["width"]
-            h = pred["height"]
-            conf = pred["confidence"]
+            # 바운딩 박스 추출 (리사이즈된 좌표)
+            x = pred.get('x', 0)
+            y = pred.get('y', 0)
+            width = pred.get('width', 0)
+            height = pred.get('height', 0)
 
-            # 바운딩 박스 좌표
-            x1 = x - w/2
-            y1 = y - h/2
-            x2 = x + w/2
-            y2 = y + h/2
+            # 원본 크기로 스케일 변환
+            x_scaled = x * scale_x
+            y_scaled = y * scale_y
+            width_scaled = width * scale_x
+            height_scaled = height * scale_y
 
-            # 신뢰도에 따라 색상
-            if conf > 0.8:
-                color = "lime"
-            elif conf > 0.6:
-                color = "orange"
-            else:
-                color = "yellow"
+            # 중심점 좌표를 좌상단/우하단 좌표로 변환
+            x1 = x_scaled - width_scaled / 2
+            y1 = y_scaled - height_scaled / 2
+            x2 = x_scaled + width_scaled / 2
+            y2 = y_scaled + height_scaled / 2
 
-            # 박스 그리기
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+            detections.append({
+                'bbox': [x1, y1, x2, y2],
+                'confidence': pred_confidence
+            })
+            print(f"  ✓ 검출 (shrimp): conf={pred_confidence:.2%}, bbox=[{x1:.0f},{y1:.0f},{x2:.0f},{y2:.0f}]")
 
-            # 라벨
-            label = f"#{detected_count} {conf:.0%}"
-            bbox = draw.textbbox((x1, y1 - 25), label, font=font)
-            draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 25), label, fill="black", font=font)
+        print(f"✅ Roboflow 검출 완료: {len(detections)}개")
+        return detections
 
-        # 헤더
-        header = f"VIDraft/Shrimp: {detected_count}마리 검출"
-        header_bbox = draw.textbbox((10, 10), header, font=font)
-        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="lime", width=2)
-        draw.text((10, 10), header, fill="lime", font=font)
+    except Exception as e:
+        print(f"❌ Roboflow SDK 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return []
 
-        info = f"""
-        ### 📊 VIDraft/Shrimp 모델 검출 결과
+# ============================================================
+# 전역 모델 변수 (지연 로딩)
+# ============================================================
+processor = None
+model = None
 
-        - **검출 수**: {detected_count}마리
-        - **전체 예측**: {len(predictions)}개
-        - **신뢰도 임계값**: {confidence:.0%}
-        - **IoU 임계값**: {iou_threshold:.0%}
-        - **처리 시간**: {result['time']:.2f}초
-        """
+def load_rtdetr_on_demand():
+    """RT-DETR 모델을 필요시에만 로딩"""
+    global processor, model
+    if processor is None or model is None:
+        print("🔄 RT-DETR 모델 로딩 중...")
+        from test_visual_validation import load_rtdetr_model
+        processor, model = load_rtdetr_model()
+        print("✅ RT-DETR 로딩 완료")
+        return "✅ RT-DETR 모델 로딩 완료"
+    else:
+        return "ℹ️ RT-DETR 모델이 이미 로딩되어 있습니다"
 
-        return img, info
+print("✅ VIDraft/Shrimp 클라우드 모델 사용 가능\n")
 
-    except Exception as e:
-        return None, f"❌ 오류 발생: {str(e)}"
+# ============================================================
+# 라벨링 도구 전역 변수
+# ============================================================
+current_data = {
+    'folder': None,
+    'images': [],
+    'current_idx': 0,
+    'detections': {},
+    'selections': {},
+    'confidence_threshold': 0.2,
+    'image_cache': {},
+    'model_type': 'RT-DETR'  # 현재 선택된 모델
+}
+
+GROUND_TRUTH_FILE = "ground_truth.json"
+DATA_BASE = "data/흰다리새우 실측 데이터_익투스에이아이(주)"
+
+# ============================================================
+# 모델별 검출 함수
+# ============================================================
 
-def detect_with_rtdetr(image, confidence):
-    """RT-DETR로 검출 (간단 버전)"""
+def detect_with_selected_model(image, confidence, model_type):
+    """선택된 모델로 검출"""
+    if model_type == "RT-DETR":
+        if processor is None or model is None:
+            raise ValueError("⚠️ RT-DETR 모델이 로딩되지 않았습니다. '🔄 RT-DETR 로드' 버튼을 먼저 클릭하세요.")
+        from test_visual_validation import detect_with_rtdetr
+        return detect_with_rtdetr(image, processor, model, confidence)
+    elif model_type == "VIDraft/Shrimp":
+        return detect_with_roboflow(image, confidence)
+    elif model_type == "YOLOv8":
+        return detect_with_yolo(image, confidence)
+    else:
+        return []
+
+# ============================================================
+# 탭 1: 자동 검출 (Interactive Validation)
+# ============================================================
+
+def interactive_detect(image, confidence, filter_threshold, show_all, model_type, use_filter):
+    """대화형 검출"""
     if image is None:
         return None, "⚠️ 이미지를 업로드하세요."
 
     try:
-        from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
-        import torch
-
-        # 모델 로드 (캐시 사용)
-        if not hasattr(detect_with_rtdetr, 'model'):
-            print("🔄 RT-DETR 모델 로딩 중...")
-            processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
-            model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
-            model.eval()
-            detect_with_rtdetr.processor = processor
-            detect_with_rtdetr.model = model
-            print("✅ RT-DETR 로딩 완료")
-
-        processor = detect_with_rtdetr.processor
-        model = detect_with_rtdetr.model
-
-        # 추론
-        inputs = processor(images=image, return_tensors="pt")
-        with torch.no_grad():
-            outputs = model(**inputs)
-
-        target_sizes = torch.tensor([image.size[::-1]])
-        results = processor.post_process_object_detection(
-            outputs,
-            target_sizes=target_sizes,
-            threshold=confidence
-        )[0]
-
-        # 결과 그리기
+        # 선택된 모델로 검출
+        all_detections = detect_with_selected_model(image, confidence, model_type)
+
+        # 필터 적용 여부에 따라 처리
+        if not use_filter:
+            # 필터 미사용: 신뢰도만 적용
+            filtered_detections = all_detections
+            for det in filtered_detections:
+                det['filter_score'] = det['confidence'] * 100
+                det['filter_reasons'] = [f"신뢰도: {det['confidence']:.0%} (필터 미사용)"]
+            all_detections_scored = filtered_detections
+        else:
+            # 필터 사용
+            if model_type in ["VIDraft/Shrimp", "YOLOv8"]:
+                # Roboflow & YOLOv8: 신뢰도를 필터 점수로 사용
+                for det in all_detections:
+                    det['filter_score'] = det['confidence'] * 100
+                    det['filter_reasons'] = [f"{model_type} 신뢰도: {det['confidence']:.0%}"]
+                all_detections_scored = all_detections
+            else:
+                # RT-DETR: Universal Filter 사용
+                from test_visual_validation import apply_universal_filter
+                all_detections_scored = apply_universal_filter(all_detections, image, threshold=0)
+
+            # 필터 임계값 적용
+            filtered_detections = [det for det in all_detections_scored if det['filter_score'] >= filter_threshold]
+
+        # 시각화
         img = image.copy()
         draw = ImageDraw.Draw(img)
 
         try:
             font = ImageFont.truetype("arial.ttf", 14)
+            font_large = ImageFont.truetype("arial.ttf", 18)
+            font_small = ImageFont.truetype("arial.ttf", 10)
         except:
             font = ImageFont.load_default()
+            font_large = ImageFont.load_default()
+            font_small = ImageFont.load_default()
 
-        detected_count = len(results["scores"])
+        # 제거된 객체 먼저 표시 (빨간색)
+        rejected_detections = [det for det in all_detections_scored if det['filter_score'] < filter_threshold]
+        for idx, det in enumerate(rejected_detections, 1):
+            x1, y1, x2, y2 = det['bbox']
+            score = det['filter_score']
 
-        for idx, (score, label, box) in enumerate(zip(results["scores"], results["labels"], results["boxes"]), 1):
-            x1, y1, x2, y2 = box.tolist()
-            conf = score.item()
+            # 빨간색 박스 (제거됨)
+            draw.rectangle([x1, y1, x2, y2], outline="red", width=8)
 
-            # 색상
-            if conf > 0.8:
-                color = "cyan"
-            elif conf > 0.6:
-                color = "magenta"
-            else:
+            # 라벨 (작게)
+            label = f"✗{idx} {score:.0f}점"
+            bbox = draw.textbbox((x1, y1 - 20), label, font=font_small)
+            draw.rectangle(bbox, fill="red")
+            draw.text((x1, y1 - 20), label, fill="white", font=font_small)
+
+        # 전체 검출 표시 (옵션) - 회색
+        if show_all:
+            for det in all_detections_scored:
+                if det not in filtered_detections and det not in rejected_detections:
+                    x1, y1, x2, y2 = det['bbox']
+                    draw.rectangle([x1, y1, x2, y2], outline="gray", width=4)
+
+        # 필터링된 결과 (통과) - 녹색/노란색/주황색
+        for idx, det in enumerate(filtered_detections, 1):
+            x1, y1, x2, y2 = det['bbox']
+            score = det['filter_score']
+
+            # 점수에 따라 색상
+            if score >= 75:
+                color = "lime"
+            elif score >= 50:
                 color = "yellow"
+            else:
+                color = "orange"
 
-            # 박스
-            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+            # 박스 (두껍게)
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=10)
 
             # 라벨
-            label_text = f"#{idx} {conf:.0%}"
-            bbox = draw.textbbox((x1, y1 - 25), label_text, font=font)
+            label = f"✓#{idx} {score:.0f}점"
+            bbox = draw.textbbox((x1, y1 - 25), label, font=font)
             draw.rectangle(bbox, fill=color)
-            draw.text((x1, y1 - 25), label_text, fill="black", font=font)
+            draw.text((x1, y1 - 25), label, fill="black", font=font)
+
+            # 세부 정보 (작게)
+            details = f"{model_type}:{det['confidence']:.0%}"
+            draw.text((x1, y2 + 5), details, fill=color, font=font_small)
 
         # 헤더
-        header = f"RT-DETR: {detected_count}개 검출"
-        header_bbox = draw.textbbox((10, 10), header, font=font)
-        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="cyan", width=2)
-        draw.text((10, 10), header, fill="cyan", font=font)
+        header = f"[{model_type}] ✓ {len(filtered_detections)}개 / ✗ {len(rejected_detections)}개 (전체: {len(all_detections_scored)}개)"
+        header_bbox = draw.textbbox((10, 10), header, font=font_large)
+        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10],
+                      fill="black", outline="lime", width=2)
+        draw.text((10, 10), header, fill="lime", font=font_large)
 
+        # 정보 생성
         info = f"""
-        ### 📊 RT-DETR 범용 모델 검출 결과
+### 📊 검출 결과 (모델: {model_type})
+
+- **전체 검출**: {len(all_detections_scored)}개
+- **필터링 후**: {len(filtered_detections)}개
+- **제거됨**: {len(rejected_detections)}개
+
+---
 
-        - **검출 수**: {detected_count}개
-        - **신뢰도 임계값**: {confidence:.0%}
+### 🎯 검출된 객체 상세 (✅ 통과)
 
-        ⚠️ **참고**: RT-DETR은 범용 객체 검출 모델입니다. 새우 검출은 VIDraft/Shrimp 모델을 사용하세요.
-        """
+"""
+
+        for idx, det in enumerate(filtered_detections, 1):
+            info += f"""
+**#{idx} - 점수: {det['filter_score']:.0f}점** ({model_type} 신뢰도: {det['confidence']:.0%})
+
+"""
+            # 주요 특징만 5개
+            for reason in det['filter_reasons'][:5]:
+                info += f"- {reason}\n"
+
+        if not filtered_detections:
+            info += """
+⚠️ **검출된 객체가 없습니다.**
+
+"""
+
+        # 제거된 객체 정보 추가
+        if rejected_detections:
+            info += f"""
+
+---
+
+### ❌ 제거된 객체 ({len(rejected_detections)}개)
+
+"""
+            for idx, det in enumerate(rejected_detections[:3], 1):  # 최대 3개만 표시
+                info += f"""
+**제거 #{idx} - 점수: {det['filter_score']:.0f}점** (임계값 미달)
+- {model_type} 신뢰도: {det['confidence']:.0%}
+
+"""
+                # 실패 이유 표시
+                for reason in det['filter_reasons'][:3]:
+                    info += f"- {reason}\n"
 
         return img, info
 
     except Exception as e:
-        return None, f"❌ 오류 발생: {str(e)}"
+        import traceback
+        error_detail = traceback.format_exc()
+        return None, f"❌ 오류 발생:\n\n```\n{error_detail}\n```"
+
+
+# ============================================================
+# 탭 2: 라벨링 도구 (Labeling Tool)
+# ============================================================
+
+def detect_with_rtdetr_fast(image, confidence=0.3):
+    """RT-DETR 빠른 검출"""
+    inputs = processor(images=image, return_tensors="pt")
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    target_sizes = torch.tensor([image.size[::-1]])
+    results = processor.post_process_object_detection(
+        outputs,
+        target_sizes=target_sizes,
+        threshold=confidence
+    )[0]
+
+    detections = []
+    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+        x1, y1, x2, y2 = box.tolist()
+        detections.append({
+            'bbox': [x1, y1, x2, y2],
+            'confidence': score.item()
+        })
+
+    return detections
+
+
+def load_existing_ground_truth():
+    """기존 ground_truth.json 로드"""
+    if os.path.exists(GROUND_TRUTH_FILE):
+        with open(GROUND_TRUTH_FILE, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return {}
+
+
+def save_ground_truth(data):
+    """ground_truth.json 저장"""
+    backup_dir = "backups"
+    if not os.path.exists(backup_dir):
+        os.makedirs(backup_dir)
+
+    if os.path.exists(GROUND_TRUTH_FILE):
+        backup_name = f"ground_truth_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        backup_path = os.path.join(backup_dir, backup_name)
+        import shutil
+        shutil.copy2(GROUND_TRUTH_FILE, backup_path)
+
+    with open(GROUND_TRUTH_FILE, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+    print(f"✅ Ground Truth 저장 완료: {len(data)}개 이미지")
+
+
+def get_folders():
+    """사용 가능한 폴더 목록"""
+    folders = sorted(glob.glob(os.path.join(DATA_BASE, "2*")))
+    return [os.path.basename(f) for f in folders if os.path.isdir(f)]
+
+
+def start_labeling(folder, conf_threshold, model_type):
+    """라벨링 시작"""
+    if not folder:
+        return None, "❌ 폴더를 선택하세요.", ""
+
+    current_data['folder'] = folder
+    current_data['confidence_threshold'] = conf_threshold
+    current_data['model_type'] = model_type
+
+    folder_path = os.path.join(DATA_BASE, folder)
+    all_images = sorted(glob.glob(os.path.join(folder_path, "*.jpg")))
+
+    # -1, -2 등이 붙은 파일 제외 (예: 251017_01-1.jpg 제외, 251017_01.jpg만 포함)
+    import re
+    images = [img for img in all_images if not re.search(r'-\d+\.jpg$', os.path.basename(img))]
+
+    if not images:
+        return None, "❌ 이미지 없음", ""
+
+    print(f"📁 폴더: {folder}")
+    print(f"   전체 이미지: {len(all_images)}개")
+    print(f"   라벨링 대상: {len(images)}개 (-숫자 파일 제외)")
+
+    current_data['images'] = images
+    current_data['current_idx'] = 0
+    current_data['detections'] = {}
+    current_data['selections'] = {}
+
+    # 기존 GT 로드
+    gt = load_existing_ground_truth()
+
+    # 이미 라벨링된 이미지 건너뛰기
+    for i, img_path in enumerate(images):
+        filename = os.path.basename(img_path)
+        if filename in gt:
+            current_data['selections'][filename] = [j for j in range(len(gt[filename]))]
+            print(f"⏭️  건너뛰기: {filename} (이미 라벨링됨)")
+
+    # 첫 미라벨링 이미지 찾기
+    while current_data['current_idx'] < len(images):
+        filename = os.path.basename(images[current_data['current_idx']])
+        if filename not in current_data['selections']:
+            break
+        current_data['current_idx'] += 1
+
+    if current_data['current_idx'] >= len(images):
+        return None, "✅ 모든 이미지 라벨링 완료!", ""
+
+    return show_current_image()
+
+
+def show_current_image():
+    """현재 이미지 표시"""
+    if current_data['current_idx'] >= len(current_data['images']):
+        return None, "✅ 완료!", ""
+
+    img_path = current_data['images'][current_data['current_idx']]
+    filename = os.path.basename(img_path)
+
+    # 캐시 확인
+    if filename in current_data['image_cache']:
+        image = current_data['image_cache'][filename]
+    else:
+        image = Image.open(img_path)
+        current_data['image_cache'][filename] = image
+
+    # 선택된 모델로 검출
+    if filename not in current_data['detections']:
+        if current_data['model_type'] == 'RT-DETR':
+            detections = detect_with_rtdetr_fast(image, current_data['confidence_threshold'])
+        elif current_data['model_type'] == 'YOLOv8':
+            detections = detect_with_yolo(image, current_data['confidence_threshold'])
+        else:  # VIDraft/Shrimp
+            detections = detect_with_roboflow(image, current_data['confidence_threshold'])
+        current_data['detections'][filename] = detections
+    else:
+        detections = current_data['detections'][filename]
+
+    # 선택된 박스
+    selected_indices = current_data['selections'].get(filename, [])
+
+    # 시각화
+    vis_image = draw_detections(image, detections, selected_indices)
+
+    info = f"""
+### 📁 {current_data['folder']} - 이미지 {current_data['current_idx']+1}/{len(current_data['images'])}
+
+**파일**: {filename}
+**모델**: {current_data['model_type']}
+
+**검출**: {len(detections)}개
+**선택**: {len(selected_indices)}개
+
+---
+
+### 🖱️ 사용 방법:
+1. 이미지를 클릭하여 박스 선택/해제
+2. "다음" 버튼으로 저장 후 이동
+3. "건너뛰기"로 선택 없이 이동
+"""
+
+    return vis_image, info, filename
+
+
+def draw_detections(image, detections, selected_indices):
+    """검출 결과 그리기"""
+    img = image.copy()
+    draw = ImageDraw.Draw(img)
+
+    try:
+        font_tiny = ImageFont.truetype("arial.ttf", 10)
+        font_large = ImageFont.truetype("arial.ttf", 40)
+    except:
+        font_tiny = ImageFont.load_default()
+        font_large = ImageFont.load_default()
+
+    # 선택되지 않은 박스 먼저 (뒤쪽 레이어)
+    for idx, det in enumerate(detections):
+        if idx not in selected_indices:
+            x1, y1, x2, y2 = det['bbox']
+            draw.rectangle([x1, y1, x2, y2], outline="lime", width=20)
+            corner_label = f"#{idx+1}"
+            draw.rectangle([x1-2, y1-24, x1+30, y1-2], fill="lime")
+            draw.text((x1, y1 - 22), corner_label, fill="white", font=font_tiny)
 
-# Gradio 인터페이스
-with gr.Blocks(title="🦐 바운딩 박스 검출 테스트", theme=gr.themes.Soft()) as demo:
+    # 선택된 박스 나중에 (앞쪽 레이어)
+    for idx, det in enumerate(detections):
+        if idx in selected_indices:
+            x1, y1, x2, y2 = det['bbox']
+            draw.rectangle([x1, y1, x2, y2], outline="blue", width=28)
+            corner_label = f"✓#{idx+1}"
+            draw.rectangle([x1-2, y1-24, x1+40, y1-2], fill="blue")
+            draw.text((x1, y1 - 22), corner_label, fill="white", font=font_tiny)
+
+    # 원형 버튼
+    for idx, det in enumerate(detections):
+        x1, y1, x2, y2 = det['bbox']
+        center_x = (x1 + x2) / 2
+        center_y = (y1 + y2) / 2
+
+        selected = idx in selected_indices
+        btn_color = "blue" if selected else "lime"
+        btn_text = f"✓{idx+1}" if selected else f"{idx+1}"
+
+        box_width = x2 - x1
+        box_height = y2 - y1
+        radius = min(55, box_width * 0.18, box_height * 0.35)
+
+        # 원형 버튼
+        draw.ellipse(
+            [center_x - radius, center_y - radius,
+             center_x + radius, center_y + radius],
+            fill=btn_color, outline="white", width=4
+        )
+        draw.text((center_x - radius*0.5, center_y - radius*0.6),
+                 btn_text, fill="white", font=font_large)
+
+    return img
+
+
+def labeling_click(image, filename, evt: gr.SelectData):
+    """이미지 클릭 이벤트"""
+    if not filename or filename not in current_data['detections']:
+        return image, "⚠️ 이미지를 먼저 로드하세요."
+
+    click_x, click_y = evt.index[0], evt.index[1]
+    detections = current_data['detections'][filename]
+    selected_indices = set(current_data['selections'].get(filename, []))
+
+    # 클릭한 박스 찾기
+    clicked_idx = None
+    button_candidates = []
+
+    # 버튼 영역 확인
+    for idx, det in enumerate(detections):
+        x1, y1, x2, y2 = det['bbox']
+        center_x = (x1 + x2) / 2
+        center_y = (y1 + y2) / 2
+
+        box_width = x2 - x1
+        box_height = y2 - y1
+        radius = min(55, box_width * 0.18, box_height * 0.35)
+
+        distance = ((click_x - center_x) ** 2 + (click_y - center_y) ** 2) ** 0.5
+
+        if distance <= radius:
+            button_candidates.append((idx, distance))
+
+    # 버튼 클릭이 있으면 선택
+    if button_candidates:
+        button_candidates.sort(key=lambda x: x[1])
+        clicked_idx = button_candidates[0][0]
+    else:
+        # 박스 영역 클릭 확인
+        for idx, det in enumerate(detections):
+            x1, y1, x2, y2 = det['bbox']
+            if x1 <= click_x <= x2 and y1 <= click_y <= y2:
+                clicked_idx = idx
+                break
+
+    # 선택 토글
+    if clicked_idx is not None:
+        if clicked_idx in selected_indices:
+            selected_indices.remove(clicked_idx)
+            print(f"❌ 선택 해제: 박스 #{clicked_idx+1}")
+        else:
+            selected_indices.add(clicked_idx)
+            print(f"✅ 선택: 박스 #{clicked_idx+1}")
+
+        current_data['selections'][filename] = list(selected_indices)
+
+        # 이미지 다시 그리기
+        img_path = current_data['images'][current_data['current_idx']]
+        image = Image.open(img_path)
+        vis_image = draw_detections(image, detections, list(selected_indices))
+
+        info = f"✅ 박스 #{clicked_idx+1} {'선택' if clicked_idx in selected_indices else '해제'}"
+        return vis_image, info
+
+    return image, "❌ 박스를 찾을 수 없습니다."
+
+
+def save_and_next():
+    """저장 후 다음"""
+    if current_data['current_idx'] >= len(current_data['images']):
+        return None, "✅ 완료!", ""
+
+    img_path = current_data['images'][current_data['current_idx']]
+    filename = os.path.basename(img_path)
+
+    # GT 저장
+    gt = load_existing_ground_truth()
+    selected_indices = current_data['selections'].get(filename, [])
+
+    if selected_indices:
+        detections = current_data['detections'][filename]
+        gt[filename] = [
+            {
+                'bbox': detections[i]['bbox'],
+                'folder': current_data['folder']
+            }
+            for i in selected_indices
+        ]
+        save_ground_truth(gt)
+        print(f"💾 저장: {filename} - {len(selected_indices)}개 박스")
+    else:
+        print(f"⏭️  건너뛰기: {filename} - 선택 없음")
+
+    # 다음 이미지
+    current_data['current_idx'] += 1
+
+    # 다음 미라벨링 이미지 찾기
+    while current_data['current_idx'] < len(current_data['images']):
+        next_filename = os.path.basename(current_data['images'][current_data['current_idx']])
+        if next_filename not in current_data['selections']:
+            break
+        current_data['current_idx'] += 1
+
+    if current_data['current_idx'] >= len(current_data['images']):
+        return None, "✅ 모든 이미지 라벨링 완료!", ""
+
+    return show_current_image()
+
+
+def skip_image():
+    """건너뛰기"""
+    current_data['current_idx'] += 1
+
+    if current_data['current_idx'] >= len(current_data['images']):
+        return None, "✅ 완료!", ""
+
+    return show_current_image()
+
+
+# ============================================================
+# 탭 3: 간단 데모 (App Demo)
+# ============================================================
+
+def demo_detect(image, confidence_threshold, filter_threshold, model_type, use_filter):
+    """간단한 데모 검출"""
+    if image is None:
+        return None, "이미지를 업로드하세요."
+
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+
+    # 선택된 모델로 검출
+    all_detections = detect_with_selected_model(image, confidence_threshold, model_type)
+
+    # 필터 적용 여부
+    if not use_filter:
+        # 필터 미사용
+        filtered_detections = all_detections
+        for det in filtered_detections:
+            det['filter_score'] = det['confidence'] * 100
+    else:
+        # 필터 사용
+        if model_type in ["Roboflow", "YOLOv8"]:
+            # Roboflow & YOLOv8: 신뢰도 기반 필터
+            for det in all_detections:
+                det['filter_score'] = det['confidence'] * 100
+            filtered_detections = [det for det in all_detections if det['filter_score'] >= filter_threshold]
+        else:
+            # RT-DETR: Universal Filter
+            from test_visual_validation import apply_universal_filter
+            filtered_detections = apply_universal_filter(all_detections, image, filter_threshold)
+
+    # 시각화
+    result_image = image.copy()
+    draw = ImageDraw.Draw(result_image)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 20)
+        font_small = ImageFont.truetype("arial.ttf", 14)
+    except:
+        font = ImageFont.load_default()
+        font_small = ImageFont.load_default()
+
+    # 박스 그리기
+    for i, det in enumerate(filtered_detections, 1):
+        x1, y1, x2, y2 = det['bbox']
+        draw.rectangle([x1, y1, x2, y2], outline="lime", width=8)
+
+        score = det['filter_score']
+        conf = det['confidence']
+        label = f"#{i} | Score:{score:.0f} | Conf:{conf:.2f}"
+
+        bbox = draw.textbbox((x1, y1-25), label, font=font_small)
+        draw.rectangle(bbox, fill="lime")
+        draw.text((x1, y1-25), label, fill="black", font=font_small)
+
+    # 결과 텍스트
+    info = f"""
+📊 **검출 결과 (모델: {model_type}):**
+   • 전체 검출: {len(all_detections)}개
+   • 필터 통과: {len(filtered_detections)}개
+   • 제거됨: {len(all_detections) - len(filtered_detections)}개
+
+⚙️ **설정:**
+   • {model_type} Confidence: {confidence_threshold}
+   • Filter Threshold: {filter_threshold}
+
+🎯 **성능 (50개 GT 기준, RT-DETR):**
+   • Precision: 44.2%
+   • Recall: 94.0%
+   • F1 Score: 56.1%
+"""
+
+    if len(filtered_detections) > 0:
+        info += f"\n✅ {len(filtered_detections)}개의 새우를 검출했습니다!"
+    else:
+        info += "\n⚠️ 새우가 검출되지 않았습니다. Threshold를 낮춰보세요."
+
+    return result_image, info
+
+
+# ============================================================
+# Gradio 인터페이스 - 3개 탭으로 통합
+# ============================================================
+
+with gr.Blocks(title="🦐 새우 검출 통합 시스템", theme=gr.themes.Soft()) as demo:
 
     gr.Markdown("""
-    # 🦐 바운딩 박스 검출 비교 테스트
+    # 🦐 새우 검출 통합 시스템
 
-    VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 성능을 비교합니다.
+    **3가지 모델로 새우를 정확하게 검출하세요**
 
     ---
     """)
 
+    # ==================== 최상단: 모델 선택 ====================
     with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(label="입력 이미지", type="pil")
-            confidence_slider = gr.Slider(
-                0.1, 0.9, 0.5,
-                label="신뢰도 임계값 (Confidence)",
-                info="낮을수록 더 많이 검출"
+        with gr.Column(scale=3):
+            model_selector = gr.Radio(
+                choices=["RT-DETR", "VIDraft/Shrimp", "YOLOv8"],
+                value="YOLOv8",
+                label="🤖 검출 모델 선택",
+                info="모든 탭에 적용됩니다"
             )
-            iou_slider = gr.Slider(
-                0.1, 0.9, 0.5,
-                label="IoU 임계값 (Overlap)",
-                info="겹치는 박스 제거 기준 (높을수록 더 많이 유지)"
+        with gr.Column(scale=1):
+            load_rtdetr_btn = gr.Button("🔄 RT-DETR 로드", size="sm", variant="secondary")
+            rtdetr_status = gr.Textbox(label="모델 상태", value="⏸️ RT-DETR 미로드 (VIDraft/Shrimp 클라우드 모델 사용 가능)", interactive=False, lines=1)
+
+    # RT-DETR 로딩 버튼 이벤트
+    load_rtdetr_btn.click(
+        load_rtdetr_on_demand,
+        inputs=[],
+        outputs=[rtdetr_status]
+    )
+
+    gr.Markdown("---")
+
+    with gr.Tabs():
+        # ==================== 탭 1: 자동 검출 ====================
+        with gr.TabItem("🤖 자동 검출 & 검증"):
+            gr.Markdown("""
+            ### 실시간으로 파라미터를 조정하며 검출 결과를 확인
+            최적화된 파라미터로 새우 검출을 테스트하세요.
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    input_image_detect = gr.Image(label="입력 이미지", type="pil")
+
+                    confidence_slider_detect = gr.Slider(
+                        0.01, 1.0, 0.1,
+                        step=0.01,
+                        label="신뢰도 임계값",
+                        info="RT-DETR: 0.065 | VIDraft/Shrimp: 0.3~0.5 | YOLOv8: 0.1~0.3 권장"
+                    )
+
+                    use_filter_check = gr.Checkbox(
+                        label="🔍 필터 점수 임계값 사용",
+                        value=False,
+                        info="체크하면 필터 점수 기준으로 추가 필터링"
+                    )
+
+                    filter_slider_detect = gr.Slider(
+                        0, 100, 90,
+                        step=5,
+                        label="필터 점수 임계값",
+                        info="RT-DETR: Universal Filter | VIDraft/Shrimp: 신뢰도 기반",
+                        visible=True
+                    )
+
+                    show_all_check = gr.Checkbox(
+                        label="전체 검출 결과 표시 (회색)",
+                        value=False
+                    )
+
+                    detect_btn = gr.Button("🚀 검출 실행", variant="primary", size="lg")
+
+                    # 예제 이미지 (결과 파일 제외)
+                    example_images = [
+                        "data/yolo_dataset/images/train/250818_01.jpg",
+                        "data/yolo_dataset/images/train/250818_03.jpg",
+                        "data/yolo_dataset/images/train/250818_04.jpg",
+                        "data/yolo_dataset/images/train/250818_05.jpg",
+                        "data/yolo_dataset/images/train/250818_10.jpg",
+                    ]
+
+                    # 파일이 존재하는 것만 필터링
+                    example_images = [img for img in example_images if os.path.exists(img)]
+
+                    if example_images:
+                        gr.Examples(
+                            examples=[[img] for img in example_images],
+                            inputs=[input_image_detect],
+                            label="📷 예제 이미지"
+                        )
+
+                with gr.Column():
+                    output_image_detect = gr.Image(label="검출 결과")
+                    output_info_detect = gr.Markdown()
+
+            detect_btn.click(
+                interactive_detect,
+                [input_image_detect, confidence_slider_detect, filter_slider_detect, show_all_check, model_selector, use_filter_check],
+                [output_image_detect, output_info_detect]
             )
 
-            # 예제 이미지
-            gr.Examples(
-                examples=[
-                    ["imgs/test_shrimp_tank.png", 0.1, 0.1],
-                ],
-                inputs=[input_image, confidence_slider, iou_slider],
-                label="📷 예제 이미지 (클릭하여 바로 테스트)"
+            # 필터 사용 체크박스에 따라 필터 슬라이더 활성화/비활성화
+            def update_filter_interactivity(use_filter):
+                return gr.update(interactive=use_filter)
+
+            use_filter_check.change(
+                update_filter_interactivity,
+                inputs=[use_filter_check],
+                outputs=[filter_slider_detect]
             )
 
-        with gr.Column():
-            gr.Markdown("### 📝 사용 방법")
             gr.Markdown("""
-            1. **아래 예제 이미지를 클릭**하거나 직접 업로드
-            2. 파라미터 조정:
-               - **Confidence**: 검출 신뢰도 (낮을수록 더 많이 검출)
-               - **IoU**: 중복 박스 제거 기준 (NMS)
-            3. 버튼 클릭하여 검출
-
-            **색상 의미:**
-            - **녹색/청록**: 높은 신뢰도 (>80%)
-            - **주황/자홍**: 중간 신뢰도 (60-80%)
-            - **노란색**: 낮은 신뢰도 (<60%)
+            ### 💡 사용 팁
+            - 모델을 선택하고 신뢰도를 조정하여 검출 결과를 확인하세요
+            - 검출이 적을 때는 신뢰도를 낮추고, 오검출이 많을 때는 높이세요
+            - 필터 기능을 사용하여 더 정확한 결과를 얻을 수 있습니다
+
+            **박스 색상:** 🟢 녹색(높은 확률) | 🟡 노란색(중간 확률) | 🟠 주황색(낮은 확률) | 🔴 빨간색(제거됨)
             """)
 
-    with gr.Tabs():
-        with gr.TabItem("🤖 VIDraft/Shrimp (새우 전용)"):
-            vidraft_btn = gr.Button("🚀 VIDraft/Shrimp 모델로 검출", variant="primary", size="lg")
-            vidraft_result = gr.Image(label="검출 결과")
-            vidraft_info = gr.Markdown()
-
-        with gr.TabItem("🔍 RT-DETR (범용)"):
-            rtdetr_btn = gr.Button("🚀 RT-DETR로 검출", variant="secondary", size="lg")
-            rtdetr_result = gr.Image(label="검출 결과")
-            rtdetr_info = gr.Markdown()
-
-    # 이벤트 연결
-    vidraft_btn.click(
-        detect_with_vidraft,
-        [input_image, confidence_slider, iou_slider],
-        [vidraft_result, vidraft_info]
-    )
+        # ==================== 탭 2: 라벨링 도구 ====================
+        with gr.TabItem("📝 Ground Truth 라벨링"):
+            gr.Markdown("""
+            ### 선택된 모델의 검출 결과에서 올바른 박스만 선택하여 라벨링
+            이미지를 클릭하여 새우 박스를 선택/해제하세요.
+            """)
 
-    rtdetr_btn.click(
-        detect_with_rtdetr,
-        [input_image, confidence_slider],
-        [rtdetr_result, rtdetr_info]
-    )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    folder_dropdown = gr.Dropdown(
+                        choices=get_folders(),
+                        label="📁 폴더 선택",
+                        info="라벨링할 폴더를 선택하세요"
+                    )
+
+                    conf_slider_label = gr.Slider(
+                        0.01, 0.5, 0.2,
+                        step=0.05,
+                        label="신뢰도",
+                        info="검출 민감도 조정"
+                    )
+
+                    start_btn = gr.Button("▶️ 라벨링 시작", variant="primary", size="lg")
+
+                    gr.Markdown("---")
+
+                    next_btn = gr.Button("⏭️ 저장 & 다음", variant="secondary", size="lg")
+                    skip_btn = gr.Button("⏩ 건너뛰기", size="lg")
+
+                    labeling_info = gr.Markdown("폴더를 선택하고 '라벨링 시작'을 클릭하세요.")
+
+                with gr.Column(scale=2):
+                    labeling_image = gr.Image(
+                        label="🖱️ 클릭하여 박스 선택/해제",
+                        type="pil",
+                        interactive=True
+                    )
+
+                    labeling_filename = gr.Textbox(visible=False)
+                    click_info = gr.Markdown()
+
+            # 이벤트 핸들러
+            start_btn.click(
+                start_labeling,
+                [folder_dropdown, conf_slider_label, model_selector],
+                [labeling_image, labeling_info, labeling_filename]
+            )
+
+            labeling_image.select(
+                labeling_click,
+                [labeling_image, labeling_filename],
+                [labeling_image, click_info]
+            )
+
+            next_btn.click(
+                save_and_next,
+                [],
+                [labeling_image, labeling_info, labeling_filename]
+            )
+
+            skip_btn.click(
+                skip_image,
+                [],
+                [labeling_image, labeling_info, labeling_filename]
+            )
+
+            gr.Markdown("""
+            ### 🖱️ 사용 방법
+            1. **모델 선택** (최상단에서 선택)
+            2. 폴더 선택 후 "라벨링 시작"
+            3. 이미지에서 **원형 버튼 클릭** 또는 **박스 영역 클릭**으로 선택/해제
+            4. "저장 & 다음"으로 다음 이미지로 이동 (자동 저장)
+            5. "건너뛰기"로 선택 없이 다음 이미지로
+
+            **💾 저장 위치:** `ground_truth.json` (자동 백업: `backups/`)
+            """)
+
+        # ==================== 탭 3: 간단 데모 ====================
+        with gr.TabItem("🎯 간단 데모"):
+            gr.Markdown("""
+            ### 빠르고 간단한 새우 검출 데모
+            이미지를 업로드하고 바로 결과를 확인하세요.
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    input_image_demo = gr.Image(label="입력 이미지", type="pil")
+
+                    confidence_slider_demo = gr.Slider(
+                        0.01, 1.0, 0.1,
+                        step=0.01,
+                        label="신뢰도",
+                        info="RT-DETR: 0.065 | VIDraft/Shrimp: 0.3~0.5 | YOLOv8: 0.1~0.3 권장"
+                    )
+
+                    use_filter_demo = gr.Checkbox(
+                        label="🔍 필터 점수 임계값 사용",
+                        value=False,
+                        info="체크하면 필터 점수 기준으로 추가 필터링"
+                    )
+
+                    filter_slider_demo = gr.Slider(
+                        0, 100, 90,
+                        step=5,
+                        label="필터 임계값",
+                        info="RT-DETR: Universal Filter | VIDraft/Shrimp: 신뢰도 기반",
+                        visible=True
+                    )
+
+                    demo_detect_btn = gr.Button("🚀 검출", variant="primary", size="lg")
+
+                    # 예제 이미지
+                    example_images_demo = [
+                        "data/yolo_dataset/images/train/250818_01.jpg",
+                        "data/yolo_dataset/images/train/250818_03.jpg",
+                        "data/yolo_dataset/images/train/250818_04.jpg",
+                        "data/yolo_dataset/images/train/250818_05.jpg",
+                        "data/yolo_dataset/images/train/250818_10.jpg",
+                    ]
+
+                    # 파일이 존재하는 것만 필터링
+                    example_images_demo = [img for img in example_images_demo if os.path.exists(img)]
+
+                    if example_images_demo:
+                        gr.Examples(
+                            examples=[[img] for img in example_images_demo],
+                            inputs=[input_image_demo],
+                            label="📷 예제 이미지"
+                        )
+
+                with gr.Column():
+                    output_image_demo = gr.Image(label="검출 결과")
+                    output_info_demo = gr.Markdown()
+
+            demo_detect_btn.click(
+                demo_detect,
+                [input_image_demo, confidence_slider_demo, filter_slider_demo, model_selector, use_filter_demo],
+                [output_image_demo, output_info_demo]
+            )
+
+            # 필터 사용 체크박스에 따라 필터 슬라이더 활성화/비활성화
+            use_filter_demo.change(
+                lambda x: gr.update(interactive=x),
+                inputs=[use_filter_demo],
+                outputs=[filter_slider_demo]
+            )
+
+            gr.Markdown("""
+            ### 💡 빠르고 간단한 검출
+            이미지를 업로드하거나 예제 이미지를 선택하여 바로 검출 결과를 확인하세요.
+            """)
 
     gr.Markdown("""
     ---
 
-    ### 💡 팁
+    ### 🤖 모델 설명
+    - **RT-DETR**: 로컬 모델, 빠른 추론 속도, 오프라인 사용 가능
+    - **VIDraft/Shrimp**: 클라우드 모델, 인터넷 연결 필요
+    - **YOLOv8**: 로컬 커스텀 학습 모델, 빠른 추론 속도
 
-    - **수조 이미지**: VIDraft/Shrimp 모델이 훨씬 정확합니다 (새우 전용 학습)
-    - **측정용 이미지**: RT-DETR 범용 모델을 사용하세요
-    - **검출 안 됨**: 신뢰도를 낮춰보세요 (0.3~0.4)
-    - **중복 박스**: IoU 임계값을 조정하세요 (VIDraft/Shrimp 모델만)
+    ---
+
+    © 2025 VIDraft. All rights reserved.
     """)
 
 if __name__ == "__main__":
+    print("\n" + "="*60)
+    print("🦐 새우 검출 통합 시스템 v2.1 시작")
+    print("="*60)
+    print("🤖 사용 가능한 모델:")
+    print("   1. RT-DETR (로컬)")
+    print("   2. VIDraft/Shrimp (클라우드)")
+    print("   3. YOLOv8 (로컬 학습) ⭐ 기본값")
+    print(f"\n📦 YOLOv8 모델: {YOLO_MODEL_PATH}")
+    print("="*60)
+
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7860,  # Hugging Face default port
+        server_port=None,  # 자동으로 빈 포트 찾기
         share=False
     )

app_backup.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""
+바운딩 박스 검출 테스트 페이지
+VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 결과 비교
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+import os
+
+# VIDraft/Shrimp 전용 검출기
+try:
+    from inference_sdk import InferenceHTTPClient, InferenceConfiguration
+
+    vidraft_client = InferenceHTTPClient(
+        api_url="https://serverless.roboflow.com",
+        api_key="azcIL8KDJVJMYrsERzI7"
+    )
+    VIDRAFT_AVAILABLE = True
+    print("✅ VIDraft/Shrimp 모델 사용 가능")
+except Exception as e:
+    VIDRAFT_AVAILABLE = False
+    print(f"❌ VIDraft/Shrimp 모델 사용 불가: {e}")
+
+def detect_with_vidraft(image, confidence, iou_threshold):
+    """VIDraft/Shrimp 전용 모델로 검출"""
+    if not VIDRAFT_AVAILABLE:
+        return None, "❌ VIDraft/Shrimp 모델을 사용할 수 없습니다."
+
+    if image is None:
+        return None, "⚠️ 이미지를 업로드하세요."
+
+    try:
+        # 임시 파일로 저장
+        import tempfile
+        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            image.save(tmp.name, quality=95)
+            tmp_path = tmp.name
+
+        # API 호출 with configuration
+        custom_config = InferenceConfiguration(
+            confidence_threshold=confidence,
+            iou_threshold=iou_threshold
+        )
+
+        with vidraft_client.use_configuration(custom_config):
+            result = vidraft_client.infer(tmp_path, model_id="shrimp-konvey/2")
+
+        # 임시 파일 삭제
+        os.unlink(tmp_path)
+
+        # 결과 그리기
+        img = image.copy()
+        draw = ImageDraw.Draw(img)
+
+        try:
+            font = ImageFont.truetype("arial.ttf", 14)
+        except:
+            font = ImageFont.load_default()
+
+        predictions = result["predictions"]
+        detected_count = 0
+
+        for pred in predictions:
+            if pred["confidence"] < confidence:
+                continue
+
+            detected_count += 1
+
+            x = pred["x"]
+            y = pred["y"]
+            w = pred["width"]
+            h = pred["height"]
+            conf = pred["confidence"]
+
+            # 바운딩 박스 좌표
+            x1 = x - w/2
+            y1 = y - h/2
+            x2 = x + w/2
+            y2 = y + h/2
+
+            # 신뢰도에 따라 색상
+            if conf > 0.8:
+                color = "lime"
+            elif conf > 0.6:
+                color = "orange"
+            else:
+                color = "yellow"
+
+            # 박스 그리기
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+
+            # 라벨
+            label = f"#{detected_count} {conf:.0%}"
+            bbox = draw.textbbox((x1, y1 - 25), label, font=font)
+            draw.rectangle(bbox, fill=color)
+            draw.text((x1, y1 - 25), label, fill="black", font=font)
+
+        # 헤더
+        header = f"VIDraft/Shrimp: {detected_count}마리 검출"
+        header_bbox = draw.textbbox((10, 10), header, font=font)
+        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="lime", width=2)
+        draw.text((10, 10), header, fill="lime", font=font)
+
+        info = f"""
+        ### 📊 VIDraft/Shrimp 모델 검출 결과
+
+        - **검출 수**: {detected_count}마리
+        - **전체 예측**: {len(predictions)}개
+        - **신뢰도 임계값**: {confidence:.0%}
+        - **IoU 임계값**: {iou_threshold:.0%}
+        - **처리 시간**: {result['time']:.2f}초
+        """
+
+        return img, info
+
+    except Exception as e:
+        return None, f"❌ 오류 발생: {str(e)}"
+
+def detect_with_rtdetr(image, confidence):
+    """RT-DETR로 검출 (간단 버전)"""
+    if image is None:
+        return None, "⚠️ 이미지를 업로드하세요."
+
+    try:
+        from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+        import torch
+
+        # 모델 로드 (캐시 사용)
+        if not hasattr(detect_with_rtdetr, 'model'):
+            print("🔄 RT-DETR 모델 로딩 중...")
+            processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
+            model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
+            model.eval()
+            detect_with_rtdetr.processor = processor
+            detect_with_rtdetr.model = model
+            print("✅ RT-DETR 로딩 완료")
+
+        processor = detect_with_rtdetr.processor
+        model = detect_with_rtdetr.model
+
+        # 추론
+        inputs = processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        target_sizes = torch.tensor([image.size[::-1]])
+        results = processor.post_process_object_detection(
+            outputs,
+            target_sizes=target_sizes,
+            threshold=confidence
+        )[0]
+
+        # 결과 그리기
+        img = image.copy()
+        draw = ImageDraw.Draw(img)
+
+        try:
+            font = ImageFont.truetype("arial.ttf", 14)
+        except:
+            font = ImageFont.load_default()
+
+        detected_count = len(results["scores"])
+
+        for idx, (score, label, box) in enumerate(zip(results["scores"], results["labels"], results["boxes"]), 1):
+            x1, y1, x2, y2 = box.tolist()
+            conf = score.item()
+
+            # 색상
+            if conf > 0.8:
+                color = "cyan"
+            elif conf > 0.6:
+                color = "magenta"
+            else:
+                color = "yellow"
+
+            # 박스
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+
+            # 라벨
+            label_text = f"#{idx} {conf:.0%}"
+            bbox = draw.textbbox((x1, y1 - 25), label_text, font=font)
+            draw.rectangle(bbox, fill=color)
+            draw.text((x1, y1 - 25), label_text, fill="black", font=font)
+
+        # 헤더
+        header = f"RT-DETR: {detected_count}개 검출"
+        header_bbox = draw.textbbox((10, 10), header, font=font)
+        draw.rectangle([5, 5, header_bbox[2]+10, header_bbox[3]+10], fill="black", outline="cyan", width=2)
+        draw.text((10, 10), header, fill="cyan", font=font)
+
+        info = f"""
+        ### 📊 RT-DETR 범용 모델 검출 결과
+
+        - **검출 수**: {detected_count}개
+        - **신뢰도 임계값**: {confidence:.0%}
+
+        ⚠️ **참고**: RT-DETR은 범용 객체 검출 모델입니다. 새우 검출은 VIDraft/Shrimp 모델을 사용하세요.
+        """
+
+        return img, info
+
+    except Exception as e:
+        return None, f"❌ 오류 발생: {str(e)}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="🦐 바운딩 박스 검출 테스트", theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown("""
+    # 🦐 바운딩 박스 검출 비교 테스트
+
+    VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 성능을 비교합니다.
+
+    ---
+    """)
+
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(label="입력 이미지", type="pil")
+            confidence_slider = gr.Slider(
+                0.1, 0.9, 0.5,
+                label="신뢰도 임계값 (Confidence)",
+                info="낮을수록 더 많이 검출"
+            )
+            iou_slider = gr.Slider(
+                0.1, 0.9, 0.5,
+                label="IoU 임계값 (Overlap)",
+                info="겹치는 박스 제거 기준 (높을수록 더 많이 유지)"
+            )
+
+            # 예제 이미지
+            gr.Examples(
+                examples=[
+                    ["imgs/test_shrimp_tank.png", 0.1, 0.1],
+                ],
+                inputs=[input_image, confidence_slider, iou_slider],
+                label="📷 예제 이미지 (클릭하여 바로 테스트)"
+            )
+
+        with gr.Column():
+            gr.Markdown("### 📝 사용 방법")
+            gr.Markdown("""
+            1. **아래 예제 이미지를 클릭**하거나 직접 업로드
+            2. 파라미터 조정:
+               - **Confidence**: 검출 신뢰도 (낮을수록 더 많이 검출)
+               - **IoU**: 중복 박스 제거 기준 (NMS)
+            3. 버튼 클릭하여 검출
+
+            **색상 의미:**
+            - **녹색/청록**: 높은 신뢰도 (>80%)
+            - **주황/자홍**: 중간 신뢰도 (60-80%)
+            - **노란색**: 낮은 신뢰도 (<60%)
+            """)
+
+    with gr.Tabs():
+        with gr.TabItem("🤖 VIDraft/Shrimp (새우 전용)"):
+            vidraft_btn = gr.Button("🚀 VIDraft/Shrimp 모델로 검출", variant="primary", size="lg")
+            vidraft_result = gr.Image(label="검출 결과")
+            vidraft_info = gr.Markdown()
+
+        with gr.TabItem("🔍 RT-DETR (범용)"):
+            rtdetr_btn = gr.Button("🚀 RT-DETR로 검출", variant="secondary", size="lg")
+            rtdetr_result = gr.Image(label="검출 결과")
+            rtdetr_info = gr.Markdown()
+
+    # 이벤트 연결
+    vidraft_btn.click(
+        detect_with_vidraft,
+        [input_image, confidence_slider, iou_slider],
+        [vidraft_result, vidraft_info]
+    )
+
+    rtdetr_btn.click(
+        detect_with_rtdetr,
+        [input_image, confidence_slider],
+        [rtdetr_result, rtdetr_info]
+    )
+
+    gr.Markdown("""
+    ---
+
+    ### 💡 팁
+
+    - **수조 이미지**: VIDraft/Shrimp 모델이 훨씬 정확합니다 (새우 전용 학습)
+    - **측정용 이미지**: RT-DETR 범용 모델을 사용하세요
+    - **검출 안 됨**: 신뢰도를 낮춰보세요 (0.3~0.4)
+    - **중복 박스**: IoU 임계값을 조정하세요 (VIDraft/Shrimp 모델만)
+    """)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,  # Hugging Face default port
+        share=False
+    )