Update to VIDraft/Shrimp detection comparison app

- Replace main app with simplified bbox detection test
- Remove Roboflow branding, use VIDraft/Shrimp naming
- Add IoU threshold control for VIDraft/Shrimp model
- Update README with usage instructions
- Simplify requirements.txt for deployment
- Backup original full system app as app_full_system.py

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

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

.gitignore

@@ -72,20 +72,28 @@ checkpoints/
 huggingface/
 transformers_cache/
 
-# Dataset files
-*.jpg
-*.jpeg
-*.png
-*.gif
-*.bmp
-*.tiff
-*.webp
-data/
+# Dataset files (대용량 데이터셋만 제외, 샘플은 포함)
 dataset/
 datasets/
 images/
 annotations/
 
+# 이미지 파일 (특정 폴더만 제외)
+# data/ 폴더는 .gitkeep으로 관리
+data/**/*.jpg
+data/**/*.jpeg
+data/**/*.png
+data/**/*.gif
+data/**/*.bmp
+
+# 하지만 샘플/테스트 이미지는 포함 (예외)
+!data/samples/
+!data/test/
+!test_*.jpg
+!test_*.png
+!sample_*.jpg
+!sample_*.png
+
 # Excel and data files
 *.xlsx
 *.xls

README.md

@@ -1,12 +1,74 @@
 ---
-title: Shrimp
-emoji: 👁
+title: VIDraft Shrimp Detection
+emoji: 🦐
 colorFrom: blue
-colorTo: red
+colorTo: green
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🦐 VIDraft/Shrimp - 새우 검출 비교 시스템
+
+VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 새우 검출 성능을 비교하는 Gradio 앱입니다.
+
+## 🎯 주요 기능
+
+### 1. VIDraft/Shrimp 전용 모델
+- 새우 수조 환경에 특화된 검출 모델
+- 높은 정확도와 신뢰도
+- **조정 가능한 파라미터:**
+  - Confidence Threshold: 검출 신뢰도 임계값
+  - IoU Threshold: 중복 박스 제거 기준 (NMS)
+
+### 2. RT-DETR 범용 모델
+- COCO 데이터셋 학습 범용 객체 검출 모델
+- 다양한 객체 검출 가능
+- 측정용 이미지에 적합
+
+## 🚀 사용 방법
+
+1. **이미지 업로드**
+   - 새우 수조 사진 또는 측정용 사진 업로드
+
+2. **파라미터 조정**
+   - **Confidence**: 낮을수록 더 많은 객체 검출 (권장: 0.5)
+   - **IoU**: 높을수록 겹치는 박스를 더 많이 유지 (권장: 0.5)
+
+3. **모델 선택 및 검출**
+   - **VIDraft/Shrimp 탭**: 수조 이미지에 최적
+   - **RT-DETR 탭**: 측정용 이미지에 적합
+
+## 📊 결과 해석
+
+### 바운딩 박스 색상
+- 🟢 **녹색/청록**: 높은 신뢰도 (>80%)
+- 🟠 **주황/자홍**: 중간 신뢰도 (60-80%)
+- 🟡 **노란색**: 낮은 신뢰도 (<60%)
+
+### 검출 정보
+- 검출된 새우 개수
+- 전체 예측 개수
+- 각 검출의 신뢰도
+- 처리 시간
+
+## 💡 팁
+
+| 상황 | 권장 모델 | Confidence | IoU |
+|------|-----------|------------|-----|
+| 수조 이미지 | VIDraft/Shrimp | 0.5 | 0.5 |
+| 밀집 수조 | VIDraft/Shrimp | 0.4 | 0.3 |
+| 측정용 매트 | RT-DETR | 0.5 | - |
+| 검출 안 됨 | 둘 다 시도 | 0.3-0.4 | 0.5 |
+
+## 🛠️ 기술 스택
+
+- **Frontend**: Gradio
+- **VIDraft/Shrimp Model**: Custom-trained detection model
+- **RT-DETR**: PekingU/rtdetr_r50vd_coco_o365
+- **Inference**: Roboflow Inference SDK, Transformers
+
+---
+
+**Developed by VIDraft Team**

app.py

@@ -1,1087 +1,290 @@
+# -*- coding: utf-8 -*-
 """
-🦐 흰다리새우 분석 시스템 - RT-DETR CPU 최적화 버전
-실제 객체 검출 + 체장/체중 자동 추정
+바운딩 박스 검출 테스트 페이지
+VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 결과 비교
 """
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
 
 import gradio as gr
-import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
 from PIL import Image, ImageDraw, ImageFont
-from datetime import datetime
-import torch
-from transformers import (
-    RTDetrForObjectDetection,
-    RTDetrImageProcessor,
-    AutoImageProcessor,
-    AutoModelForDepthEstimation
-)
 import os
-import warnings
-warnings.filterwarnings('ignore')
 
-# =====================
-# 실측 데이터 (260개 샘플)
-# =====================
-REAL_DATA = [
-    {"length": 7.5, "weight": 2.0}, {"length": 7.7, "weight": 2.1},
-    {"length": 8.3, "weight": 2.7}, {"length": 8.4, "weight": 2.9},
-    {"length": 8.6, "weight": 3.1}, {"length": 8.7, "weight": 3.0},
-    {"length": 8.9, "weight": 3.2}, {"length": 9.1, "weight": 3.4},
-    {"length": 9.4, "weight": 4.0}, {"length": 9.7, "weight": 4.7},
-    {"length": 9.9, "weight": 4.7}, {"length": 10.0, "weight": 4.6},
-    {"length": 10.2, "weight": 5.5}, {"length": 10.3, "weight": 5.8},
-    {"length": 10.4, "weight": 5.5}, {"length": 10.7, "weight": 6.1},
-    {"length": 10.9, "weight": 6.0}, {"length": 11.0, "weight": 6.2},
-    {"length": 11.3, "weight": 5.8}, {"length": 11.4, "weight": 6.5},
-    {"length": 11.6, "weight": 7.5}, {"length": 11.7, "weight": 8.1},
-    {"length": 11.9, "weight": 9.4}, {"length": 12.0, "weight": 8.8},
-    {"length": 12.3, "weight": 10.2}, {"length": 12.5, "weight": 10.9},
-    {"length": 12.7, "weight": 10.1}, {"length": 12.9, "weight": 10.7},
-    {"length": 13.0, "weight": 10.7}, {"length": 13.1, "weight": 11.3},
-]
-
-# =====================
-# 회귀 모델
-# =====================
-class RegressionModel:
-    def __init__(self):
-        self.a = 0.003454
-        self.b = 3.1298
-        self.r2 = 0.929
-        self.mape = 6.4
-
-    def estimate_weight(self, length_cm):
-        """체장으로 체중 추정: W = a × L^b"""
-        return self.a * (length_cm ** self.b)
-
-    def calculate_error(self, true_weight, pred_weight):
-        """오차율 계산"""
-        if true_weight == 0:
-            return 0
-        return abs(true_weight - pred_weight) / true_weight * 100
-
-# =====================
-# 깊이 추정기
-# =====================
-class DepthEstimator:
-    def __init__(self, model_name="depth-anything/Depth-Anything-V2-Small-hf"):
-        """Depth-Anything V2 모델 초기화"""
-        print(f"🔄 Loading Depth Estimation model: {model_name}")
-
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-
-        try:
-            self.processor = AutoImageProcessor.from_pretrained(model_name)
-            self.model = AutoModelForDepthEstimation.from_pretrained(model_name)
-            self.model.to(self.device)
-            self.model.eval()
-            print("✅ Depth model loaded successfully!")
-            self.enabled = True
-        except Exception as e:
-            print(f"⚠️ Depth model loading failed: {e}")
-            print("📝 Running without depth correction")
-            self.enabled = False
-
-    @torch.no_grad()
-    def estimate_depth(self, image):
-        """이미지에서 깊이 맵 추정"""
-        if not self.enabled or image is None:
-            return None
-
-        # 이미지 전처리
-        inputs = self.processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-
-        # 깊이 추정
-        outputs = self.model(**inputs)
-        predicted_depth = outputs.predicted_depth
-
-        # 원본 이미지 크기로 리샘플링
-        depth_map = torch.nn.functional.interpolate(
-            predicted_depth.unsqueeze(1),
-            size=image.size[::-1],  # (height, width)
-            mode="bicubic",
-            align_corners=False,
-        ).squeeze().cpu().numpy()
-
-        # 정규화 (0~1 범위)
-        depth_min = depth_map.min()
-        depth_max = depth_map.max()
-        depth_normalized = (depth_map - depth_min) / (depth_max - depth_min + 1e-8)
+# VIDraft/Shrimp 전용 검출기
+try:
+    from inference_sdk import InferenceHTTPClient, InferenceConfiguration
 
-        return depth_normalized
+    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 get_depth_at_bbox(self, depth_map, bbox):
-        """bbox 중심점의 깊이 값 추출"""
-        if depth_map is None:
-            return 1.0  # 기본값
+def detect_with_vidraft(image, confidence, iou_threshold):
+    """VIDraft/Shrimp 전용 모��로 검출"""
+    if not VIDRAFT_AVAILABLE:
+        return None, "❌ VIDraft/Shrimp 모델을 사용할 수 없습니다."
 
-        x1, y1, x2, y2 = bbox
-        center_x = int((x1 + x2) / 2)
-        center_y = int((y1 + y2) / 2)
+    if image is None:
+        return None, "⚠️ 이미지를 업로드하세요."
 
-        # 범위 체크
-        h, w = depth_map.shape
-        center_x = min(max(0, center_x), w - 1)
-        center_y = min(max(0, center_y), h - 1)
+    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
+        )
 
-        return depth_map[center_y, center_x]
+        with vidraft_client.use_configuration(custom_config):
+            result = vidraft_client.infer(tmp_path, model_id="shrimp-konvey/2")
 
-    def visualize_depth(self, depth_map):
-        """깊이 맵 시각화"""
-        if depth_map is None:
-            return None
+        # 임시 파일 삭제
+        os.unlink(tmp_path)
 
-        # 깊이 맵을 컬러맵으로 변환
-        import matplotlib.cm as cm
-        colormap = cm.get_cmap('viridis')
-        depth_colored = (colormap(depth_map)[:, :, :3] * 255).astype(np.uint8)
+        # 결과 그리기
+        img = image.copy()
+        draw = ImageDraw.Draw(img)
 
-        return Image.fromarray(depth_colored)
+        try:
+            font = ImageFont.truetype("arial.ttf", 14)
+        except:
+            font = ImageFont.load_default()
 
-# =====================
-# RT-DETR 검출기
-# =====================
-class RTDetrDetector:
-    def __init__(self, model_name="PekingU/rtdetr_r50vd_coco_o365"):
-        """RT-DETR 모델 초기화"""
-        print(f"🔄 Loading RT-DETR model: {model_name}")
+        predictions = result["predictions"]
+        detected_count = 0
 
-        # CPU 최적화 설정
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"📱 Using device: {self.device}")
+        for pred in predictions:
+            if pred["confidence"] < confidence:
+                continue
 
-        try:
-            # 모델 및 프로세서 로딩
-            self.processor = RTDetrImageProcessor.from_pretrained(model_name)
-            self.model = RTDetrForObjectDetection.from_pretrained(model_name)
-            self.model.to(self.device)
-            self.model.eval()  # 평가 모드
+            detected_count += 1
 
-            print("✅ Model loaded successfully!")
-        except Exception as e:
-            print(f"❌ Model loading failed: {e}")
-            raise
+            x = pred["x"]
+            y = pred["y"]
+            w = pred["width"]
+            h = pred["height"]
+            conf = pred["confidence"]
 
-        self.regression_model = RegressionModel()
+            # 바운딩 박스 좌표
+            x1 = x - w/2
+            y1 = y - h/2
+            x2 = x + w/2
+            y2 = y + h/2
 
-        # 깊이 추정기 초기화
-        try:
-            self.depth_estimator = DepthEstimator()
-        except Exception as e:
-            print(f"⚠️ Depth estimator initialization failed: {e}")
-            self.depth_estimator = None
+            # 신뢰도에 따라 색상
+            if conf > 0.8:
+                color = "lime"
+            elif conf > 0.6:
+                color = "orange"
+            else:
+                color = "yellow"
 
-        # 참조 스케일: 픽셀 크기를 실제 cm로 변환
-        # 예: 100픽셀 = 10cm (이미지에 따라 조정 필요)
-        self.pixel_to_cm_ratio = 0.1  # 기본값
+            # 박스 그리기
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
 
-        # 깊이 보정 활성화 플래그
-        self.depth_correction_enabled = True
+            # 라벨
+            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)
 
-        # 마지막 깊이 맵 캐싱 (UI 표시용)
-        self.last_depth_map = None
+        # 헤더
+        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)
 
-    def set_scale(self, pixel_length, actual_cm):
-        """스케일 설정 (보정용)"""
-        self.pixel_to_cm_ratio = actual_cm / pixel_length
-        print(f"📏 Scale updated: {pixel_length}px = {actual_cm}cm")
+        info = f"""
+        ### 📊 VIDraft/Shrimp ���델 검출 결과
 
-    @torch.no_grad()  # CPU 최적화: gradient 계산 비활성화
-    def detect(self, image, confidence_threshold=0.5):
-        """객체 검출 수행"""
+        - **검출 수**: {detected_count}마리
+        - **전체 예측**: {len(predictions)}개
+        - **신뢰도 임계값**: {confidence:.0%}
+        - **IoU 임계값**: {iou_threshold:.0%}
+        - **처리 시간**: {result['time']:.2f}초
+        """
 
-        if image is None:
-            return []
+        return img, info
 
-        # 깊이 맵 생성 (원근 보정용)
-        depth_map = None
-        if self.depth_correction_enabled and self.depth_estimator and self.depth_estimator.enabled:
-            print("🔍 Estimating depth map for perspective correction...")
-            depth_map = self.depth_estimator.estimate_depth(image)
-            self.last_depth_map = depth_map
+    except Exception as e:
+        return None, f"❌ 오류 발생: {str(e)}"
 
-            # 참조 깊이 (이미지 중심의 평균 깊이)
-            h, w = depth_map.shape
-            center_region = depth_map[h//4:3*h//4, w//4:3*w//4]
-            self.reference_depth = np.median(center_region)
-            print(f"📏 Reference depth: {self.reference_depth:.3f}")
+def detect_with_rtdetr(image, confidence):
+    """RT-DETR로 검출 (간단 버전)"""
+    if image is None:
+        return None, "⚠️ 이미지를 업로드하세요."
 
-        # 이미지 전처리
-        inputs = self.processor(images=image, return_tensors="pt")
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
+    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
 
         # 추론
-        outputs = self.model(**inputs)
+        inputs = processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = model(**inputs)
 
-        # 결과 후처리
-        target_sizes = torch.tensor([image.size[::-1]])  # (height, width)
-        results = self.processor.post_process_object_detection(
+        target_sizes = torch.tensor([image.size[::-1]])
+        results = processor.post_process_object_detection(
             outputs,
             target_sizes=target_sizes,
-            threshold=confidence_threshold
+            threshold=confidence
         )[0]
 
-        # 검출 결과 파싱
-        detections = []
-
-        for idx, (score, label, box) in enumerate(zip(
-            results["scores"],
-            results["labels"],
-            results["boxes"]
-        )):
-            # COCO 클래스 필터링 (필요시)
-            # 새우 전용 모델이 아니므로 모든 객체 검출
-            # label 1 = "person", 16 = "bird", 17 = "cat" 등
-            # 일단 모든 객체를 검출하되, 향후 fine-tuning 시 새우만 검출
-
-            x1, y1, x2, y2 = box.tolist()
-            bbox_width = x2 - x1
-            bbox_height = y2 - y1
-
-            # 깊이 기반 스케일 보정
-            depth_corrected_ratio = self.pixel_to_cm_ratio
-
-            if depth_map is not None:
-                # bbox 중심점의 깊이 값 추출
-                object_depth = self.depth_estimator.get_depth_at_bbox(depth_map, [x1, y1, x2, y2])
-
-                # 깊이 비율 계산 (참조 깊이 대비)
-                # 깊이 값이 클수록 먼 거리 → 실제 크기가 더 큼
-                # Depth-Anything에서: 작은 값 = 가까움, 큰 값 = 멀음
-                depth_ratio = object_depth / (self.reference_depth + 1e-8)
-
-                # 스케일 보정 (원근 효과 보정)
-                # 먼 물체(큰 depth)는 픽셀이 작아 보이므로 보정 계수를 크게
-                depth_corrected_ratio = self.pixel_to_cm_ratio * depth_ratio
-
-                print(f"  Object #{idx+1}: depth={object_depth:.3f}, ratio={depth_ratio:.3f}, corrected_scale={depth_corrected_ratio:.4f}")
-
-            # 체장 추정: bbox의 긴 변을 체장으로 간주
-            length_pixels = max(bbox_width, bbox_height)
-            length_cm = length_pixels * depth_corrected_ratio
-
-            # 체중 추정
-            pred_weight = self.regression_model.estimate_weight(length_cm)
-
-            detections.append({
-                "id": idx + 1,
-                "bbox": [x1, y1, x2, y2],
-                "length": round(length_cm, 1),
-                "pred_weight": round(pred_weight, 2),
-                "confidence": round(score.item(), 2),
-                "label": label.item()
-            })
-
-        return detections
-
-    def visualize(self, image, detections):
-        """검출 결과 시각화"""
-        if image is None:
-            return None
-
+        # 결과 그리기
         img = image.copy()
         draw = ImageDraw.Draw(img)
 
-        # 폰트 설정 (기본 폰트 사용)
         try:
-            font = ImageFont.truetype("arial.ttf", 12)
+            font = ImageFont.truetype("arial.ttf", 14)
         except:
             font = ImageFont.load_default()
 
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
+        detected_count = len(results["scores"])
 
-            # 고정 색상 (녹색)
-            color = "lime"
+        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 = f"#{det['id']} {det['length']}cm {det['pred_weight']}g ({det['confidence']:.0%})"
-
-            # 배경 박스
-            bbox = draw.textbbox((x1, y1 - 20), label, font=font)
+            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 - 20), label, fill="white", font=font)
-
-        return img
-
-    def visualize_with_groundtruth(self, image, detection, true_length, true_weight, sample_id):
-        """검출 결과와 실측값을 함께 시각화"""
-        if image is None:
-            return None
-
-        img = image.copy()
-        draw = ImageDraw.Draw(img)
-
-        # 폰트 설정
-        try:
-            font_large = ImageFont.truetype("arial.ttf", 16)
-            font_small = ImageFont.truetype("arial.ttf", 12)
-        except:
-            font_large = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-
-        # Bounding box 그리기
-        x1, y1, x2, y2 = detection["bbox"]
-
-        # 오차율로 색상 결정
-        error_weight = abs(detection["pred_weight"] - true_weight) / true_weight * 100
-        if error_weight < 10:
-            color = "lime"  # 녹색: 우수
-        elif error_weight < 25:
-            color = "orange"  # 주황: 양호
-        else:
-            color = "red"  # 빨강: 개선 필요
-
-        # 박스 그리기
-        draw.rectangle([x1, y1, x2, y2], outline=color, width=4)
-
-        # 예측값 라벨 (bbox 위)
-        pred_label = f"예측: {detection['length']:.1f}cm / {detection['pred_weight']:.1f}g"
-        bbox_pred = draw.textbbox((x1, y1 - 40), pred_label, font=font_small)
-        draw.rectangle(bbox_pred, fill=color)
-        draw.text((x1, y1 - 40), pred_label, fill="white", font=font_small)
-
-        # 실측값 라벨 (bbox 위, 예측값 아래)
-        true_label = f"실제: {true_length:.1f}cm / {true_weight:.1f}g"
-        bbox_true = draw.textbbox((x1, y1 - 20), true_label, font=font_small)
-        draw.rectangle(bbox_true, fill="blue")
-        draw.text((x1, y1 - 20), true_label, fill="white", font=font_small)
-
-        # 이미지 상단에 샘플 ID와 오차율 표시
-        header = f"샘플 #{sample_id} | 체장 오차: {abs(detection['length']-true_length)/true_length*100:.1f}% | 체중 오차: {error_weight:.1f}%"
-        header_bbox = draw.textbbox((10, 10), header, font=font_large)
-        draw.rectangle([5, 5, header_bbox[2]+5, header_bbox[3]+5], fill="black", outline=color, width=3)
-        draw.text((10, 10), header, fill=color, font=font_large)
-
-        return img
-
-# =====================
-# 전역 인스턴스 (모델 캐싱)
-# =====================
-
-# RT-DETR 검출기 초기화
-print("🚀 Initializing RT-DETR detector...")
-try:
-    detector = RTDetrDetector()
-    MODEL_LOADED = True
-except Exception as e:
-    print(f"⚠️ Failed to load model: {e}")
-    print("📝 Running in simulation mode")
-    MODEL_LOADED = False
-    detector = None
-
-regression_model = RegressionModel()
-
-# =====================
-# Gradio 인터페이스 함수
-# =====================
-
-def process_image(image, confidence, pixel_scale, cm_scale, enable_depth):
-    """이미지 처리 및 분석"""
-
-    if not MODEL_LOADED:
-        return None, None, "❌ 모델 로딩 실패. requirements.txt를 확인하세요.", pd.DataFrame()
-
-    if image is None:
-        return None, None, "⚠️ 이미지를 업로드하세요.", pd.DataFrame()
-
-    # 깊이 보정 활성화/비활성화
-    detector.depth_correction_enabled = enable_depth
-
-    # 스케일 업데이트
-    if pixel_scale > 0 and cm_scale > 0:
-        detector.set_scale(pixel_scale, cm_scale)
-
-    # 검출 수행
-    detections = detector.detect(image, confidence)
-
-    if not detections:
-        return image, None, "⚠️ 검출된 객체가 없습니다. 신뢰도를 낮춰보세요.", pd.DataFrame()
-
-    # 시각화
-    result_image = detector.visualize(image, detections)
-
-    # 깊이 맵 시각화
-    depth_vis = None
-    if enable_depth and detector.depth_estimator and detector.last_depth_map is not None:
-        depth_vis = detector.depth_estimator.visualize_depth(detector.last_depth_map)
-
-    # 통계 계산
-    avg_length = np.mean([d["length"] for d in detections])
-    avg_weight = np.mean([d["pred_weight"] for d in detections])
-    total_biomass = sum([d["pred_weight"] for d in detections])
-
-    # 통계 텍스트
-    depth_status = "✅ 활성화" if enable_depth else "⚠️ 비활성화"
-    stats_text = f"""
-    ### 📊 검출 결과
-
-    - **검출 개체 수**: {len(detections)}마리
-    - **평균 체장**: {avg_length:.1f}cm
-    - **평균 예측 체중**: {avg_weight:.1f}g
-    - **총 바이오매스**: {total_biomass:.1f}g
-    - **깊이 보정**: {depth_status}
-
-    💡 **팁**: 정확도 검증은 "정확도 검증" 탭에서 실제 데이터와 비교할 수 있습니다.
-    """
-
-    # 결과 테이블
-    df_data = []
-    for d in detections:
-        df_data.append({
-            "ID": f"#{d['id']}",
-            "체장(cm)": d["length"],
-            "예측 체중(g)": d["pred_weight"],
-            "신뢰도": f"{d['confidence']:.0%}"
-        })
-
-    df = pd.DataFrame(df_data)
-
-    return result_image, depth_vis, stats_text, df
-
-def evaluate_model():
-    """모델 성능 평가"""
-
-    # 실측 데이터로 평가
-    predictions = []
-    actuals = []
-
-    for sample in REAL_DATA:
-        pred = regression_model.estimate_weight(sample["length"])
-        predictions.append(pred)
-        actuals.append(sample["weight"])
-
-    # 메트릭 계산
-    errors = [abs(p - a) / a * 100 for p, a in zip(predictions, actuals)]
-    mape = np.mean(errors)
-    mae = np.mean([abs(p - a) for p, a in zip(predictions, actuals)])
-    rmse = np.sqrt(np.mean([(p - a) ** 2 for p, a in zip(predictions, actuals)]))
-
-    # R² 계산
-    mean_actual = np.mean(actuals)
-    ss_tot = sum([(a - mean_actual) ** 2 for a in actuals])
-    ss_res = sum([(a - p) ** 2 for a, p in zip(actuals, predictions)])
-    r2 = 1 - (ss_res / ss_tot)
-
-    eval_text = f"""
-    ### 🎯 회귀 모델 성능 평가
-
-    **데이터셋**: {len(REAL_DATA)}개 실측 샘플
-
-    **성능 지표**:
-    - R² Score: **{r2:.4f}** (92.9% 설명력)
-    - MAPE: **{mape:.1f}%** (목표 25% 이내 ✅)
-    - MAE: **{mae:.2f}g**
-    - RMSE: **{rmse:.2f}g**
-
-    **모델 식**: W = {regression_model.a:.6f} × L^{regression_model.b:.4f}
-
-    **결론**: ✅ 상용화 가능 수준의 정확도
-    """
-
-    # 차트 생성
-    fig = go.Figure()
-
-    # 실측 데이터
-    fig.add_trace(go.Scatter(
-        x=[d["length"] for d in REAL_DATA],
-        y=[d["weight"] for d in REAL_DATA],
-        mode='markers',
-        name='실측 데이터',
-        marker=dict(color='blue', size=10, opacity=0.6)
-    ))
-
-    # 회귀선
-    x_line = np.linspace(7, 14, 100)
-    y_line = [regression_model.estimate_weight(x) for x in x_line]
-
-    fig.add_trace(go.Scatter(
-        x=x_line,
-        y=y_line,
-        mode='lines',
-        name=f'회귀 모델 (R²={r2:.3f})',
-        line=dict(color='red', width=3)
-    ))
-
-    # 예측값
-    fig.add_trace(go.Scatter(
-        x=[d["length"] for d in REAL_DATA],
-        y=predictions,
-        mode='markers',
-        name='예측값',
-        marker=dict(color='red', size=8, opacity=0.4, symbol='x')
-    ))
-
-    fig.update_layout(
-        title="흰다리새우 체장-체중 회귀 분석",
-        xaxis_title="체장 (cm)",
-        yaxis_title="체중 (g)",
-        template="plotly_white",
-        height=500,
-        hovermode='closest'
-    )
-
-    return eval_text, fig
-
-def export_data():
-    """데이터 내보내기"""
-    df = pd.DataFrame(REAL_DATA)
-    csv_path = f"shrimp_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-    df.to_csv(csv_path, index=False)
-
-    return csv_path
+            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)
 
-def load_excel_data(excel_path, date_serial=45945):
-    """
-    엑셀 파일에서 특정 날짜의 데이터 읽기
-    date_serial: 45945 = 2025-10-15 (251015)
-    """
-    try:
-        # Sheet1 읽기 (헤더 없이)
-        df = pd.read_excel(excel_path, sheet_name='Sheet1', header=None)
-
-        # Row 4: 날짜 행, Row 5: 헤더 행
-        date_row = df.iloc[4]
-        header_row = df.iloc[5]
+        info = f"""
+        ### 📊 RT-DETR 범용 모델 검출 결과
 
-        # 해당 날짜 컬럼 찾기
-        for col_idx in range(len(date_row)):
-            if date_row[col_idx] == date_serial:
-                # 데이터 추출
-                data_dict = {}
-                for row_idx in range(6, len(df)):  # 데이터는 row 6부터
-                    no = df.iloc[row_idx, 1]  # No. 컬럼
-                    length = df.iloc[row_idx, col_idx]
-                    weight = df.iloc[row_idx, col_idx + 1] if col_idx + 1 < len(df.columns) else None
+        - **검출 수**: {detected_count}개
+        - **신뢰도 임계값**: {confidence:.0%}
 
-                    if pd.notna(no) and pd.notna(length):
-                        data_dict[int(no)] = {
-                            'length': float(length),
-                            'weight': float(weight) if pd.notna(weight) else None
-                        }
+        ⚠️ **참고**: RT-DETR은 범용 객체 검출 모델입니다. 새우 검출은 VIDraft/Shrimp 모델을 사용하세요.
+        """
 
-                print(f"✅ Loaded {len(data_dict)} samples from Excel for date {date_serial}")
-                return data_dict
-
-        print(f"⚠️ Date {date_serial} not found in Excel")
-        return None
+        return img, info
 
     except Exception as e:
-        print(f"❌ Excel loading error: {e}")
-        return None
-
-def process_test_dataset(data_folder, pixel_scale, cm_scale, enable_depth):
-    """테스트 데이터셋 배치 처리"""
-
-    if not MODEL_LOADED:
-        return "❌ 모델 로딩 실패", pd.DataFrame(), None, []
-
-    if not os.path.exists(data_folder):
-        return f"❌ 폴더를 찾을 수 없습니다: {data_folder}", pd.DataFrame(), None, []
-
-    # 엑셀 데이터 로드
-    excel_path = os.path.join(os.path.dirname(data_folder), '흰다리새우 실측 데이터(진행).xlsx')
-    excel_data = load_excel_data(excel_path, date_serial=45945)  # 251015
-
-    if not excel_data:
-        return "❌ 엑셀 데이터를 로드할 수 없습니다", pd.DataFrame(), None, []
-
-    # 이미지 찾기
-    image_list = []
-    for i in range(1, 20):  # 최대 20개까지 확인
-        shrimp_img = os.path.join(data_folder, f"251015_{i:02d}.jpg")
-
-        if os.path.exists(shrimp_img) and i in excel_data:
-            image_list.append((shrimp_img, i))
-
-    if not image_list:
-        return "❌ 이미지를 찾을 수 없습니다", pd.DataFrame(), None, []
-
-    print(f"\n📊 Processing {len(image_list)} images...")
-
-    # 스케일 설정
-    if pixel_scale > 0 and cm_scale > 0:
-        detector.set_scale(pixel_scale, cm_scale)
-
-    # 깊이 보정 설정
-    detector.depth_correction_enabled = enable_depth
-
-    results = []
-    visualized_images = []  # 시각화된 이미지 저장
-
-    # 결과 저장 폴더 생성
-    results_folder = os.path.join(data_folder, "results")
-    os.makedirs(results_folder, exist_ok=True)
-
-    for shrimp_path, idx in image_list:
-        print(f"\n🔍 Processing image #{idx}...")
-
-        # 1. 새우 이미지 검출
-        shrimp_img = Image.open(shrimp_path)
-        detections = detector.detect(shrimp_img, confidence_threshold=0.3)
-
-        if not detections:
-            print(f"  ⚠️ No shrimp detected in image #{idx}")
-            continue
-
-        # 새우 선택: 중앙 위치 + 크기 + 형태 기반 스코어링
-        img_width, img_height = shrimp_img.size
-        img_area = img_width * img_height
-        img_center_x = img_width / 2
-        img_center_y = img_height / 2
-
-        valid_detections = []
-        for det in detections:
-            x1, y1, x2, y2 = det["bbox"]
-            width = x2 - x1
-            height = y2 - y1
-            area = width * height
-
-            # 객체 중심점
-            obj_center_x = (x1 + x2) / 2
-            obj_center_y = (y1 + y2) / 2
-
-            # 1. 중앙 거리 점수 (0~1, 중앙에 가까울수록 높음)
-            max_dist = ((img_width/2)**2 + (img_height/2)**2)**0.5
-            dist_from_center = ((obj_center_x - img_center_x)**2 + (obj_center_y - img_center_y)**2)**0.5
-            center_score = 1 - (dist_from_center / max_dist)
-
-            # 2. 크기 점수 (적절한 크기: 이미지의 5~25%)
-            size_ratio = area / img_area
-            if 0.05 < size_ratio < 0.25:
-                size_score = 1.0
-            elif 0.01 < size_ratio < 0.4:
-                size_score = 0.5
-            else:
-                size_score = 0.0
-
-            # 3. 형태 점수 (길쭉한 형태)
-            longer_side = max(width, height)
-            shorter_side = min(width, height)
-            elongation = longer_side / (shorter_side + 1e-8)
-            if elongation > 2.5:
-                shape_score = 1.0
-            elif elongation > 1.5:
-                shape_score = 0.7
-            else:
-                shape_score = 0.3
-
-            # 4. 신뢰도 점수
-            confidence_score = det["confidence"]
-
-            # 최종 점수 (가중 평균)
-            final_score = (
-                center_score * 0.4 +    # 중앙 위치 가장 중요
-                size_score * 0.2 +      # 크기
-                shape_score * 0.2 +     # 형태
-                confidence_score * 0.2  # 신뢰도
-            )
-
-            det["final_score"] = final_score
-            det["center_score"] = center_score
-            det["size_score"] = size_score
-            det["shape_score"] = shape_score
-
-            # 최소 점수 임계값
-            if final_score > 0.3:
-                valid_detections.append(det)
-
-        if not valid_detections:
-            print(f"  ⚠️ No valid shrimp detected (filtered out {len(detections)} detections)")
-            continue
-
-        # 최종 점수가 가장 높은 객체 선택
-        largest_det = max(valid_detections, key=lambda d: d["final_score"])
-        pred_length = largest_det["length"]
-        pred_weight = largest_det["pred_weight"]
-
-        print(f"  ✓ Selected detection:")
-        print(f"    - Final score: {largest_det['final_score']:.3f}")
-        print(f"    - Center: {largest_det['center_score']:.2f}, Size: {largest_det['size_score']:.2f}, Shape: {largest_det['shape_score']:.2f}, Conf: {largest_det['confidence']:.2f}")
-        print(f"    - Bbox area: {(largest_det['bbox'][2]-largest_det['bbox'][0])*(largest_det['bbox'][3]-largest_det['bbox'][1]):.0f}px")
-
-        # 2. 엑셀에서 실제 데이터 가져오기
-        true_data = excel_data[idx]
-        true_length = true_data['length']
-        true_weight = true_data['weight']
-
-        if true_weight is None:
-            print(f"  ⚠️ No weight data in Excel for #{idx}")
-            continue
-
-        # 3. 오차 계산
-        error_weight = abs(pred_weight - true_weight) / true_weight * 100
-        error_length = abs(pred_length - true_length) / true_length * 100
-
-        # 4. 이미지 시각화 (예측 + 실제 값 표시)
-        vis_img = detector.visualize_with_groundtruth(
-            shrimp_img, largest_det, true_length, true_weight, idx
-        )
-
-        # 이미지 파일로 저장 (확장자 포함)
-        output_filename = f"sample_{idx:02d}_result.jpg"
-        output_path = os.path.join(results_folder, output_filename)
-        vis_img.save(output_path, quality=95)
-
-        visualized_images.append(output_path)
-        print(f"  💾 Saved visualization: {output_path}")
-
-        results.append({
-            "ID": f"#{idx}",
-            "실제 체장(cm)": round(true_length, 1),
-            "예측 체장(cm)": round(pred_length, 1),
-            "체장 오차(%)": round(error_length, 1),
-            "실제 체중(g)": round(true_weight, 2),
-            "예측 체중(g)": round(pred_weight, 2),
-            "체중 오차(%)": round(error_weight, 1),
-            "오차(g)": round(abs(pred_weight - true_weight), 2)
-        })
-
-        print(f"  ✅ Length: {pred_length:.1f}cm (true: {true_length:.1f}cm, error: {error_length:.1f}%)")
-        print(f"     Weight: {pred_weight:.2f}g (true: {true_weight:.2f}g, error: {error_weight:.1f}%)")
-
-    if not results:
-        return "❌ 처리된 샘플이 없습니다", pd.DataFrame(), None, []
-
-    # 결과 DataFrame
-    df = pd.DataFrame(results)
-
-    # 통계 계산
-    avg_error_length = df["체장 오차(%)"].mean()
-    avg_error_weight = df["체중 오차(%)"].mean()
-    avg_error_g = df["오차(g)"].mean()
-    min_error_weight = df["체중 오차(%)"].min()
-    max_error_weight = df["체중 오차(%)"].max()
-
-    # 차트 생성
-    fig = go.Figure()
-
-    # 예측 vs 실제 산점도
-    fig.add_trace(go.Scatter(
-        x=df["실제 체중(g)"],
-        y=df["예측 체중(g)"],
-        mode='markers+text',
-        text=df["ID"],
-        textposition="top center",
-        marker=dict(size=12, color=df["체중 오차(%)"], colorscale='RdYlGn_r',
-                   showscale=True, colorbar=dict(title="체중 오차(%)")),
-        name='예측 vs 실제'
-    ))
-
-    # 완벽한 예측 선 (y=x)
-    min_val = min(df["실제 체중(g)"].min(), df["예측 체중(g)"].min())
-    max_val = max(df["실제 체중(g)"].max(), df["예측 체중(g)"].max())
-    fig.add_trace(go.Scatter(
-        x=[min_val, max_val],
-        y=[min_val, max_val],
-        mode='lines',
-        line=dict(dash='dash', color='red', width=2),
-        name='완벽한 예측 (y=x)'
-    ))
-
-    fig.update_layout(
-        title=f"예측 정확도 검증 ({len(results)}개 샘플)",
-        xaxis_title="실제 체중 (g)",
-        yaxis_title="예측 체중 (g)",
-        template="plotly_white",
-        height=500,
-        hovermode='closest'
-    )
-
-    # 통계 텍스트
-    stats_text = f"""
-    ### 📊 배치 테스트 결과
-
-    - **처리 샘플 수**: {len(results)}개
-    - **체장 평균 오차**: {avg_error_length:.1f}%
-    - **체중 평균 오차(MAPE)**: {avg_error_weight:.1f}%
-    - **체중 절대 오차**: {avg_error_g:.2f}g
-    - **체중 오차 범위**: {min_error_weight:.1f}% ~ {max_error_weight:.1f}%
-    - **깊이 보정**: {'✅ 활성화' if enable_depth else '⚠️ 비활성화'}
-
-    🎯 **평가**: {'✅ 우수 (MAPE < 25%)' if avg_error_weight < 25 else '⚠️ 개선 필요 (MAPE ≥ 25%)'}
+        return None, f"❌ 오류 발생: {str(e)}"
 
-    💡 **참고**: 실제 체장과 체중 데이터는 엑셀 파일에서 로드되었습니다.
-
-    📸 **이미지 결과**: 아래 갤러리에서 각 샘플의 예측/실제 값을 확인할 수 있습니다.
-
-    💾 **저장 위치**: `{results_folder}` 폴더에 {len(visualized_images)}개 이미지 저장됨
-    """
-
-    return stats_text, df, fig, visualized_images
-
-# =====================
-# Gradio UI
-# =====================
-
-with gr.Blocks(title="🦐 RT-DETR 새우 분석", theme=gr.themes.Soft()) as demo:
+# Gradio 인터페이스
+with gr.Blocks(title="🦐 바운딩 박스 검출 테스트", theme=gr.themes.Soft()) as demo:
 
     gr.Markdown("""
-    # 🦐 흰다리새우 AI 분석 시스템 (RT-DETR)
+    # 🦐 바운딩 박스 검출 비교 테스트
 
-    ### 실시간 객체 검출 + 체장/체중 자동 추정
-    **모델**: RT-DETR (PekingU/rtdetr_r50vd_coco_o365) | **회귀**: W = 0.0035 × L^3.13
-    **정확도**: R² = 0.929, MAPE = 6.4% | **디바이스**: """ + ("🚀 GPU" if torch.cuda.is_available() else "💻 CPU") + """
+    VIDraft/Shrimp 전용 모델과 RT-DETR 범용 모델의 검출 성능을 비교합니다.
 
     ---
     """)
 
-    with gr.Tabs():
-        # 검출 탭
-        with gr.TabItem("🔍 객체 검출"):
-            with gr.Row():
-                with gr.Column():
-                    input_img = gr.Image(
-                        label="입력 이미지",
-                        type="pil"
-                    )
-
-                    conf_slider = gr.Slider(
-                        0.1, 0.9, 0.5,
-                        label="검출 신뢰도 임계값",
-                        info="낮을수록 더 많은 객체 검출"
-                    )
-
-                    with gr.Row():
-                        pixel_scale = gr.Number(
-                            value=92,
-                            label="픽셀 크기 (px)",
-                            info="참조 객체의 픽셀 크기"
-                        )
-                        cm_scale = gr.Number(
-                            value=1,
-                            label="실제 크기 (cm)",
-                            info="참조 객체의 실제 크기"
-                        )
-
-                    depth_checkbox = gr.Checkbox(
-                        value=False,
-                        label="🔍 깊이 기반 원근 보정 활성화",
-                        info="Depth-Anything V2로 자동 원근 왜곡 보정"
-                    )
-
-                    detect_btn = gr.Button(
-                        "🚀 검출 실행",
-                        variant="primary",
-                        size="lg"
-                    )
-
-                with gr.Column():
-                    output_img = gr.Image(
-                        label="검출 결과"
-                    )
-                    depth_img = gr.Image(
-                        label="깊이 맵 (파란색=가까움, 노란색=멀음)"
-                    )
-                    stats = gr.Markdown()
-
-            results_df = gr.Dataframe(
-                label="검출 상세 정보",
-                wrap=True
-            )
-
-        # 평가 탭
-        with gr.TabItem("📊 성능 평가"):
-            gr.Markdown("""
-            ### 회귀 모델 성능 평가
-
-            실측 데이터를 기반으로 체장-체중 회귀 모델의 정확도를 평가합니다.
-            """)
-
-            eval_btn = gr.Button(
-                "📈 평가 실행",
-                variant="primary"
+    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="낮을수록 더 많이 검출"
             )
-            eval_text = gr.Markdown()
-            eval_plot = gr.Plot()
-
-        # 데이터 탭
-        with gr.TabItem("📋 실측 데이터"):
-            gr.Markdown(f"""
-            ### 데이터 요약
-
-            - **샘플 수**: {len(REAL_DATA)}개
-            - **체장 범위**: 7.5 - 13.1 cm
-            - **체중 범위**: 2.0 - 11.3 g
-            - **데이터 출처**: 실측 데이터
-            """)
-
-            data_df = gr.Dataframe(
-                value=pd.DataFrame(REAL_DATA),
-                label="실측 데이터",
-                wrap=True
+            iou_slider = gr.Slider(
+                0.1, 0.9, 0.5,
+                label="IoU 임계값 (Overlap)",
+                info="겹치는 박스 제거 기준 (높을수록 더 많이 유지)"
             )
 
-            export_btn = gr.Button("💾 CSV 다운로드")
-            file_output = gr.File(label="다운로드")
-
-        # 정확도 검증 탭
-        with gr.TabItem("🎯 정확도 검증"):
+        with gr.Column():
+            gr.Markdown("### 📝 사용 방법")
             gr.Markdown("""
-            ### 실제 이미지 데이터로 정확도 검증
-
-            테스트 데이터셋을 배치 처리하여 예측 정확도를 측정합니다.
+            1. 이미지 업로드
+            2. 파라미터 조정:
+               - **Confidence**: 검출 신뢰도 (낮을수록 더 많이 검출)
+               - **IoU**: 중복 박스 제거 기준 (NMS)
+            3. 버튼 클릭하여 검출
+
+            **색상 의미:**
+            - **녹색/청록**: 높은 신뢰도 (>80%)
+            - **주황/자홍**: 중간 신뢰도 (60-80%)
+            - **노란색**: 낮은 신뢰도 (<60%)
             """)
 
-            with gr.Row():
-                with gr.Column():
-                    test_folder = gr.Textbox(
-                        value="d:/Project/VIDraft/Shrimp/data/251015",
-                        label="테스트 데이터 폴더",
-                        info="251015_XX.jpg 형식의 이미지가 있는 폴더"
-                    )
-
-                    with gr.Row():
-                        test_pixel_scale = gr.Number(
-                            value=92,
-                            label="픽셀 크기 (px)",
-                            info="참조 자의 픽셀 크기"
-                        )
-                        test_cm_scale = gr.Number(
-                            value=1,
-                            label="실제 크기 (cm)",
-                            info="참조 자의 실제 크기"
-                        )
-
-                    test_depth_checkbox = gr.Checkbox(
-                        value=False,
-                        label="🔍 깊이 기반 원근 보정 활성화",
-                        info="Depth-Anything V2로 자동 원근 왜곡 보정"
-                    )
-
-                    test_btn = gr.Button(
-                        "🚀 배치 테스트 실행",
-                        variant="primary",
-                        size="lg"
-                    )
-
-                with gr.Column():
-                    test_stats = gr.Markdown()
-
-            test_plot = gr.Plot(label="예측 vs 실제 비교")
-            test_results_df = gr.Dataframe(
-                label="상세 결과",
-                wrap=True
-            )
-
-            gr.Markdown("### 📸 시각화 결과 (예측 vs 실제)")
-            test_gallery = gr.Gallery(
-                label="검출 결과 이미지",
-                show_label=True,
-                columns=3,
-                rows=2,
-                height="auto",
-                object_fit="contain"
-            )
-
-        # 정보 탭
-        with gr.TabItem("ℹ️ 사용 방법"):
-            gr.Markdown("""
-            ## 📖 사용 가이드
-
-            ### 1️⃣ 객체 검출
-            1. 새우 이미지를 업로드하세요
-            2. 신뢰도 임계값을 조정하세요 (기본값: 0.5)
-            3. **깊이 보정 활성화** (권장): 원근 왜곡 자동 보정
-            4. 스케일 보정: 실제 크기를 알고 있다면 픽셀-cm 비율을 설정하세요
-            5. "검출 실행" 버튼을 클릭하세요
-
-            ### 2️⃣ 깊이 기반 원근 보정 (NEW! 🔥)
-            - **Depth-Anything V2** 모델로 이미지의 깊이 맵 자동 생성
-            - 각 새우의 상대적 거리를 계산하여 스케일 자동 보정
-            - **원근 왜곡 효과를 자동으로 제거**하여 정확도 향상
-            - 깊이 맵 시각화: 파란색=가까움, 노란색=멀음
-            - 추가 장비나 마커 없이 단일 이미지만으로 작동
-
-            ### 3️⃣ 스케일 보정
-            - 이미지에서 알고 있는 객체의 픽셀 크기와 실제 크기를 입력하세요
-            - 예: 자가 보인다면, 자의 픽셀 길이와 실제 길이(cm)를 입력
-            - 깊이 보정과 함께 사용하면 더욱 정확한 측정 가능
-
-            ### 4️⃣ 결과 해석
-            - **초록색 박스**: 오차 < 10%
-            - **주황색 박스**: 오차 10-20%
-            - **빨간색 박스**: 오차 > 20%
-
-            ### 5️⃣ 성능 평가
-            - "성능 평가" 탭에서 회귀 모델의 정확도를 확인하세요
-            - R², MAPE, MAE, RMSE 지표 제공
-
-            ### 6️⃣ 정확도 검증 (NEW! 🔥)
-            - "정확도 검증" 탭에서 실제 이미지 데이터로 정확도 측정
-            - 테스트 데이터 폴더를 지정하고 배치 처리
-            - OCR로 전자저울 LCD에서 실제 무게 자동 읽기
-            - 예측 vs 실제 비교 차트 및 통계 제공
-
-            ### 7️⃣ 데이터 내보내기
-            - "���측 데이터" 탭에서 CSV 파일로 다운로드 가능
-
-            ---
-
-            ## ⚙️ 시스템 정보
-
-            - **검출 모델**: RT-DETR (Real-Time DEtection TRansformer)
-            - **깊이 추정 모델**: Depth-Anything V2 Small (Monocular Depth Estimation)
-            - **회귀 모델**: Power Law (W = a × L^b)
-            - **디바이스**: """ + ("GPU (CUDA)" if torch.cuda.is_available() else "CPU") + """
-            - **최적화**: CPU 모드, torch.no_grad(), FP32
-            - **원근 보정**: 깊이 맵 기반 자동 스케일 조정
-
-            ## 🔧 문제 해결
-
-            **검출이 안 될 때**:
-            - 신뢰도 임계값을 낮춰보세요 (0.3 이하)
-            - 이미지 품질을 확인하세요 (해상도, 밝기)
-
-            **정확도가 낮을 때**:
-            - 스케일 보정을 정확히 입력하세요
-            - 새우 전용 fine-tuning 모델이 필요할 수 있습니다
+    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()
 
-            **속도가 느릴 때**:
-            - GPU 가속을 사용하세요 (HF Space: GPU T4)
-            - 이미지 크기를 줄이세요 (800x600 권장)
-            """)
+        with gr.TabItem("🔍 RT-DETR (범용)"):
+            rtdetr_btn = gr.Button("🚀 RT-DETR로 검출", variant="secondary", size="lg")
+            rtdetr_result = gr.Image(label="검출 결과")
+            rtdetr_info = gr.Markdown()
 
     # 이벤트 연결
-    detect_btn.click(
-        process_image,
-        [input_img, conf_slider, pixel_scale, cm_scale, depth_checkbox],
-        [output_img, depth_img, stats, results_df]
+    vidraft_btn.click(
+        detect_with_vidraft,
+        [input_image, confidence_slider, iou_slider],
+        [vidraft_result, vidraft_info]
     )
 
-    eval_btn.click(
-        evaluate_model,
-        [],
-        [eval_text, eval_plot]
+    rtdetr_btn.click(
+        detect_with_rtdetr,
+        [input_image, confidence_slider],
+        [rtdetr_result, rtdetr_info]
     )
 
-    export_btn.click(
-        export_data,
-        [],
-        file_output
-    )
+    gr.Markdown("""
+    ---
 
-    test_btn.click(
-        process_test_dataset,
-        [test_folder, test_pixel_scale, test_cm_scale, test_depth_checkbox],
-        [test_stats, test_results_df, test_plot, test_gallery]
-    )
+    ### 💡 팁
+
+    - **수조 이미지**: VIDraft/Shrimp 모델이 훨씬 정확합니다 (새우 전용 학습)
+    - **측정용 이미지**: RT-DETR 범용 모델을 사용하세요
+    - **검출 안 됨**: 신뢰도를 낮춰보세요 (0.3~0.4)
+    - **중복 박스**: IoU 임계값을 조정하세요 (VIDraft/Shrimp 모델만)
+    """)
 
-# 실행
 if __name__ == "__main__":
-    demo.queue(max_size=10)  # CPU 최적화: 큐 크기 제한
     demo.launch(
-        share=False,
         server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
+        server_port=7860,  # Hugging Face default port
+        share=False
     )

requirements.txt

@@ -4,19 +4,10 @@ gradio>=4.16.0
 # Deep Learning
 torch>=2.0.0
 torchvision>=0.15.0
-transformers>=4.41.0  # Required for Depth-Anything-V2
+transformers>=4.41.0
 
 # Image Processing
 pillow>=10.0.0
-opencv-python-headless>=4.9.0
 
-# Data Science
-numpy>=1.24.0
-pandas>=2.0.0
-
-# Visualization
-plotly>=5.17.0
-matplotlib>=3.7.0  # For depth map visualization
-
-# Excel reading
-openpyxl>=3.1.0
+# Inference
+inference-sdk>=0.9.0