Add testing framework, example images, and improved filters

.gitignore

@@ -89,6 +89,8 @@ data/**/*.bmp
 # 하지만 샘플/테스트 이미지는 포함 (예외)
 !data/samples/
 !data/test/
+!data/251015/*.jpg
+!data/251015/*.png
 !test_*.jpg
 !test_*.png
 !sample_*.jpg

docs/detection_testing_and_validation.md

@@ -0,0 +1,931 @@
+# 🧪 새우 검출 테스트 및 검수 가이드
+
+## 📋 목차
+1. [테스트 준비](#테스트-준비)
+2. [테스트 실행](#테스트-실행)
+3. [결과 검수 방법](#결과-검수-방법)
+4. [성능 평가](#성능-평가)
+5. [개선 방향](#개선-방향)
+
+---
+
+## 🎯 테스트 준비
+
+### 1. 테스트 데이터셋 구성
+
+#### 폴더 구조
+```
+test_dataset/
+├── positive/                    # 새우 있는 이미지
+│   ├── clean/                  # 배경 깨끗 (10장)
+│   │   ├── shrimp_001.jpg
+│   │   └── ...
+│   ├── with_ruler/             # 자 포함 (10장)
+│   ├── with_hand/              # 손 포함 (10장)
+│   ├── complex_background/     # 복잡한 배경 (10장)
+│   └── various_positions/      # 다양한 위치 (10장)
+│
+├── negative/                    # 새우 없는 이미지 (10장)
+│   ├── only_ruler.jpg
+│   ├── only_hand.jpg
+│   └── ...
+│
+└── ground_truth/               # 정답 라벨
+    ├── annotations.json        # 바운딩 박스 좌표
+    └── metadata.csv            # 메타데이터
+```
+
+#### annotations.json 형식
+```json
+{
+  "images": [
+    {
+      "file_name": "shrimp_001.jpg",
+      "width": 1920,
+      "height": 1080,
+      "annotations": [
+        {
+          "bbox": [100, 200, 500, 280],
+          "category": "shrimp",
+          "difficult": false
+        }
+      ]
+    }
+  ]
+}
+```
+
+---
+
+## 🔬 테스트 실행
+
+### 방법 1: 시각적 검수용 테스트 (추천)
+
+**목적**: 각 필터 단계별로 시각적으로 확인
+
+```python
+# test_visual_validation.py
+"""
+시각적 검수용 테스트 스크립트
+각 필터 단계별로 중간 결과 저장
+"""
+
+import cv2
+import os
+import json
+from pathlib import Path
+from universal_shrimp_filter import UniversalShrimpFilter
+
+def run_visual_test(test_image_dir, output_dir):
+    """
+    시각적 검수용 테스트
+
+    Args:
+        test_image_dir: 테스트 이미지 폴더
+        output_dir: 결과 저장 폴더
+    """
+
+    # 출력 폴더 생성
+    os.makedirs(output_dir, exist_ok=True)
+
+    # 필터 초기화
+    shrimp_filter = UniversalShrimpFilter()
+
+    # 모든 테스트 이미지 처리
+    test_images = list(Path(test_image_dir).glob("*.jpg")) + \
+                  list(Path(test_image_dir).glob("*.png"))
+
+    results = []
+
+    for img_path in test_images:
+        print(f"\n{'='*60}")
+        print(f"Testing: {img_path.name}")
+        print(f"{'='*60}")
+
+        # 이미지 로드
+        image = cv2.imread(str(img_path))
+        if image is None:
+            print(f"⚠️  Failed to load image: {img_path}")
+            continue
+
+        # RT-DETR 검출 (실제로는 모델 실행, 여기서는 예시)
+        rtdetr_detections = run_rtdetr(image)  # 별도 함수
+
+        print(f"RT-DETR detected: {len(rtdetr_detections)} objects")
+
+        # 필터링 적용 (단계별 저장)
+        filtered_detections = shrimp_filter.filter_with_stages(
+            image, rtdetr_detections, save_stages=True
+        )
+
+        # 결과 시각화
+        result_image = visualize_detections(image, filtered_detections)
+
+        # 결과 저장
+        output_path = os.path.join(output_dir, f"result_{img_path.name}")
+        cv2.imwrite(output_path, result_image)
+
+        # 결과 기록
+        results.append({
+            'image': img_path.name,
+            'rtdetr_count': len(rtdetr_detections),
+            'filtered_count': len(filtered_detections),
+            'detections': filtered_detections
+        })
+
+        print(f"✅ Final detections: {len(filtered_detections)}")
+        for i, det in enumerate(filtered_detections, 1):
+            print(f"   #{i}: score={det.get('total_score', 0):.1f}/100, "
+                  f"confidence={det['confidence']:.2f}")
+
+    # 결과 요약 저장
+    with open(os.path.join(output_dir, 'test_results.json'), 'w') as f:
+        json.dump(results, f, indent=2)
+
+    print(f"\n{'='*60}")
+    print(f"✅ Test completed! Results saved to: {output_dir}")
+    print(f"{'='*60}")
+
+    return results
+
+
+def visualize_detections(image, detections):
+    """
+    검출 결과 시각화
+
+    Args:
+        image: 원본 이미지
+        detections: 검출 결과
+
+    Returns:
+        시각화된 이미지
+    """
+    import cv2
+    import numpy as np
+
+    result = image.copy()
+
+    for i, det in enumerate(detections, 1):
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        # 바운딩 박스
+        color = (0, 255, 0)  # 녹색
+        cv2.rectangle(result, (x1, y1), (x2, y2), color, 3)
+
+        # 라벨
+        score = det.get('total_score', 0)
+        confidence = det['confidence']
+        label = f"#{i} Score:{score:.1f} Conf:{confidence:.2f}"
+
+        # 라벨 배경
+        (label_w, label_h), _ = cv2.getTextSize(
+            label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2
+        )
+        cv2.rectangle(result, (x1, y1 - label_h - 10),
+                     (x1 + label_w, y1), color, -1)
+
+        # 라벨 텍스트
+        cv2.putText(result, label, (x1, y1 - 5),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
+
+    # 전체 요약 (상단)
+    summary = f"Detections: {len(detections)}"
+    cv2.putText(result, summary, (10, 30),
+               cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 3)
+
+    return result
+
+
+def run_rtdetr(image):
+    """
+    RT-DETR 검출 실행
+
+    Args:
+        image: 입력 이미지
+
+    Returns:
+        검출 결과 리스트
+    """
+    from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+    import torch
+    from PIL import Image
+
+    # 모델 로드 (캐시)
+    if not hasattr(run_rtdetr, 'model'):
+        processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
+        model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
+        model.eval()
+        run_rtdetr.processor = processor
+        run_rtdetr.model = model
+
+    processor = run_rtdetr.processor
+    model = run_rtdetr.model
+
+    # 이미지 변환
+    pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+
+    # 추론
+    inputs = processor(images=pil_image, return_tensors="pt")
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    # 후처리
+    target_sizes = torch.tensor([pil_image.size[::-1]])
+    results = processor.post_process_object_detection(
+        outputs,
+        target_sizes=target_sizes,
+        threshold=0.3
+    )[0]
+
+    # 결과 변환
+    detections = []
+    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+        detections.append({
+            'bbox': box.tolist(),
+            'confidence': score.item(),
+            'class_id': label.item()
+        })
+
+    return detections
+
+
+# 실행
+if __name__ == "__main__":
+    run_visual_test(
+        test_image_dir="test_dataset/positive/clean",
+        output_dir="test_results/visual"
+    )
+```
+
+---
+
+### 방법 2: 정량적 평가용 테스트
+
+**목적**: Precision, Recall, F1 계산
+
+```python
+# test_quantitative_evaluation.py
+"""
+정량적 평가용 테스트 스크립트
+Ground Truth와 비교하여 메트릭 계산
+"""
+
+import json
+import numpy as np
+from pathlib import Path
+import cv2
+
+def calculate_iou(bbox1, bbox2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = bbox1
+    x2_min, y2_min, x2_max, y2_max = bbox2
+
+    # 교집합
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+
+    # 합집합
+    area1 = (x1_max - x1_min) * (y1_max - y1_min)
+    area2 = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = area1 + area2 - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+
+def evaluate_detection(predictions, ground_truths, iou_threshold=0.5):
+    """
+    검출 성능 평가
+
+    Args:
+        predictions: 예측 바운딩 박스 리스트
+        ground_truths: 정답 바운딩 박스 리스트
+        iou_threshold: IoU 임계값 (기본 0.5)
+
+    Returns:
+        dict: TP, FP, FN, Precision, Recall, F1
+    """
+
+    TP = 0  # True Positive
+    FP = 0  # False Positive
+    FN = 0  # False Negative
+
+    matched_gts = set()
+
+    # 각 예측에 대해
+    for pred in predictions:
+        pred_bbox = pred['bbox']
+
+        # Ground Truth와 매칭
+        max_iou = 0
+        max_iou_gt_idx = -1
+
+        for gt_idx, gt in enumerate(ground_truths):
+            if gt_idx in matched_gts:
+                continue
+
+            gt_bbox = gt['bbox']
+            iou = calculate_iou(pred_bbox, gt_bbox)
+
+            if iou > max_iou:
+                max_iou = iou
+                max_iou_gt_idx = gt_idx
+
+        # IoU 임계값 이상이면 매칭 성공
+        if max_iou >= iou_threshold:
+            TP += 1
+            matched_gts.add(max_iou_gt_idx)
+        else:
+            FP += 1  # 잘못된 검출
+
+    # 매칭 안 된 GT = 놓친 것
+    FN = len(ground_truths) - len(matched_gts)
+
+    # 메트릭 계산
+    precision = TP / (TP + FP) if (TP + FP) > 0 else 0
+    recall = TP / (TP + FN) if (TP + FN) > 0 else 0
+    f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {
+        'TP': TP,
+        'FP': FP,
+        'FN': FN,
+        'precision': precision,
+        'recall': recall,
+        'f1_score': f1_score
+    }
+
+
+def run_quantitative_test(test_image_dir, ground_truth_file, output_file):
+    """
+    정량적 평가 실행
+
+    Args:
+        test_image_dir: 테스트 이미지 폴더
+        ground_truth_file: Ground Truth JSON 파일
+        output_file: 결과 저장 파일
+    """
+
+    # Ground Truth 로드
+    with open(ground_truth_file, 'r') as f:
+        ground_truth_data = json.load(f)
+
+    # 이미지별 GT 매핑
+    gt_map = {}
+    for img_data in ground_truth_data['images']:
+        gt_map[img_data['file_name']] = img_data['annotations']
+
+    # 필터 초기화
+    from universal_shrimp_filter import UniversalShrimpFilter
+    shrimp_filter = UniversalShrimpFilter()
+
+    # 전체 결과
+    all_results = []
+    total_metrics = {
+        'TP': 0,
+        'FP': 0,
+        'FN': 0
+    }
+
+    # 각 이미지 테스트
+    for img_name, gt_annotations in gt_map.items():
+        img_path = Path(test_image_dir) / img_name
+        if not img_path.exists():
+            print(f"⚠️  Image not found: {img_path}")
+            continue
+
+        print(f"\nTesting: {img_name}")
+
+        # 이미지 로드
+        image = cv2.imread(str(img_path))
+
+        # RT-DETR 검출
+        rtdetr_detections = run_rtdetr(image)
+
+        # 필터링
+        predictions = shrimp_filter.filter(image, rtdetr_detections)
+
+        # Ground Truth
+        ground_truths = gt_annotations
+
+        # 평가
+        metrics = evaluate_detection(predictions, ground_truths, iou_threshold=0.5)
+
+        # 결과 저장
+        result = {
+            'image': img_name,
+            'num_predictions': len(predictions),
+            'num_ground_truths': len(ground_truths),
+            'metrics': metrics
+        }
+        all_results.append(result)
+
+        # 전체 집계
+        total_metrics['TP'] += metrics['TP']
+        total_metrics['FP'] += metrics['FP']
+        total_metrics['FN'] += metrics['FN']
+
+        print(f"  GT: {len(ground_truths)}, Pred: {len(predictions)}")
+        print(f"  TP={metrics['TP']}, FP={metrics['FP']}, FN={metrics['FN']}")
+        print(f"  Precision={metrics['precision']:.2%}, Recall={metrics['recall']:.2%}, F1={metrics['f1_score']:.2%}")
+
+    # 전체 메트릭 계산
+    total_precision = total_metrics['TP'] / (total_metrics['TP'] + total_metrics['FP']) \
+                      if (total_metrics['TP'] + total_metrics['FP']) > 0 else 0
+    total_recall = total_metrics['TP'] / (total_metrics['TP'] + total_metrics['FN']) \
+                   if (total_metrics['TP'] + total_metrics['FN']) > 0 else 0
+    total_f1 = 2 * (total_precision * total_recall) / (total_precision + total_recall) \
+               if (total_precision + total_recall) > 0 else 0
+
+    # 요약
+    summary = {
+        'total_images': len(all_results),
+        'total_metrics': {
+            'TP': total_metrics['TP'],
+            'FP': total_metrics['FP'],
+            'FN': total_metrics['FN'],
+            'precision': total_precision,
+            'recall': total_recall,
+            'f1_score': total_f1
+        },
+        'per_image_results': all_results
+    }
+
+    # 결과 저장
+    with open(output_file, 'w') as f:
+        json.dump(summary, f, indent=2)
+
+    # 출력
+    print(f"\n{'='*60}")
+    print("📊 Overall Performance")
+    print(f"{'='*60}")
+    print(f"Total Images: {len(all_results)}")
+    print(f"TP: {total_metrics['TP']}, FP: {total_metrics['FP']}, FN: {total_metrics['FN']}")
+    print(f"Precision: {total_precision:.2%}")
+    print(f"Recall: {total_recall:.2%}")
+    print(f"F1 Score: {total_f1:.2%}")
+    print(f"{'='*60}")
+    print(f"Results saved to: {output_file}")
+
+    return summary
+
+
+# 실행
+if __name__ == "__main__":
+    run_quantitative_test(
+        test_image_dir="test_dataset/positive/clean",
+        ground_truth_file="test_dataset/ground_truth/annotations.json",
+        output_file="test_results/quantitative_results.json"
+    )
+```
+
+---
+
+## 📊 결과 검수 방법
+
+### 방법 1: 시각적 검수 (빠른 확인)
+
+#### 절차
+1. **테스트 실행**
+   ```bash
+   python test_visual_validation.py
+   ```
+
+2. **결과 이미지 확인**
+   ```
+   test_results/visual/
+   ├── result_shrimp_001.jpg  ✅ 새우 검출됨 (녹색 박스)
+   ├── result_shrimp_002.jpg  ❌ 검출 실패
+   └── ...
+   ```
+
+3. **육안 검수**
+   - ✅ **정상**: 새우에만 박스, 다른 객체 제외
+   - ⚠️ **과소 검출**: 새우 놓침 → Recall 낮음
+   - ⚠️ **과다 검출**: 자/손 등에도 박스 → Precision 낮음
+
+4. **검수 시트 작성**
+   ```csv
+   이미지명,GT개수,검출개수,TP,FP,FN,비고
+   shrimp_001.jpg,1,1,1,0,0,정상
+   shrimp_002.jpg,1,0,0,0,1,검출실패
+   shrimp_003.jpg,1,2,1,1,0,자도검출됨
+   ```
+
+---
+
+### 방법 2: 정량적 검수 (정확한 평가)
+
+#### 절차
+1. **Ground Truth 준비**
+   - LabelImg, CVAT 등으로 수동 라벨링
+   - JSON 형식으로 저장
+
+2. **테스트 실행**
+   ```bash
+   python test_quantitative_evaluation.py
+   ```
+
+3. **결과 분석**
+   ```json
+   {
+     "total_metrics": {
+       "TP": 42,
+       "FP": 8,
+       "FN": 6,
+       "precision": 0.84,
+       "recall": 0.88,
+       "f1_score": 0.86
+     }
+   }
+   ```
+
+4. **해석**
+   - **Precision 84%**: 검출한 것 중 84%가 실제 새우
+     - 16%는 오검출 (자, 손 등)
+   - **Recall 88%**: 전체 새우 중 88% 검출
+     - 12%는 놓침
+   - **F1 86%**: 종합 성능
+
+---
+
+### 방법 3: 대화형 검수 (Gradio 활용)
+
+```python
+# interactive_validation.py
+"""
+대화형 검수 도구
+사용자가 직접 이미지 업로드하고 결과 확인
+"""
+
+import gradio as gr
+import cv2
+import numpy as np
+from PIL import Image
+
+def detect_and_validate(image, confidence_threshold):
+    """
+    검출 및 결과 반환
+
+    Args:
+        image: PIL Image
+        confidence_threshold: 신뢰도 임계값
+
+    Returns:
+        (결과 이미지, 상세 정보)
+    """
+    # numpy로 변환
+    img_array = np.array(image)
+    img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+
+    # RT-DETR 검출
+    rtdetr_detections = run_rtdetr(img_bgr)
+
+    # 필터링
+    from universal_shrimp_filter import UniversalShrimpFilter
+    shrimp_filter = UniversalShrimpFilter()
+    filtered_detections = shrimp_filter.filter(img_bgr, rtdetr_detections)
+
+    # 시각화
+    result_img = visualize_detections(img_bgr, filtered_detections)
+    result_img_rgb = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+
+    # 상세 정보
+    info = f"""
+    ### 📊 검출 결과
+
+    - **RT-DETR 검출**: {len(rtdetr_detections)}개
+    - **필터링 후**: {len(filtered_detections)}개 (새우만)
+
+    #### 상세 정보:
+    """
+
+    for i, det in enumerate(filtered_detections, 1):
+        score = det.get('total_score', 0)
+        conf = det['confidence']
+        bbox = det['bbox']
+
+        info += f"""
+    **새우 #{i}**
+    - 종합 점수: {score:.1f}/100
+    - RT-DETR 신뢰도: {conf:.2%}
+    - 위치: ({bbox[0]:.0f}, {bbox[1]:.0f}) - ({bbox[2]:.0f}, {bbox[3]:.0f})
+        """
+
+    if len(filtered_detections) == 0:
+        info += "\n⚠️ **새우가 검출되지 않았습니다.**"
+
+    return Image.fromarray(result_img_rgb), info
+
+
+# Gradio 인터페이스
+with gr.Blocks(title="새우 검출 검수 도구") as demo:
+    gr.Markdown("""
+    # 🦐 새우 검출 검수 도구
+
+    이미지를 업로드하면 자동으로 새우를 검출합니다.
+    결과를 확인하고 검출 품질을 평가하세요.
+    """)
+
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(label="테스트 이미지", type="pil")
+            confidence_slider = gr.Slider(
+                0.1, 0.9, 0.3,
+                label="RT-DETR 신뢰도 임계값"
+            )
+            detect_btn = gr.Button("🚀 검출 실행", variant="primary")
+
+        with gr.Column():
+            output_image = gr.Image(label="검출 결과")
+            output_info = gr.Markdown()
+
+    # 이벤트
+    detect_btn.click(
+        detect_and_validate,
+        [input_image, confidence_slider],
+        [output_image, output_info]
+    )
+
+    gr.Markdown("""
+    ---
+    ### ✅ 검수 기준
+
+    **정상 검출**:
+    - 새우에만 녹색 박스
+    - 자, 손, 배경 등은 제외
+
+    **문제 있음**:
+    - 새우 놓침 → Recall 낮음 (파라미터 완화 필요)
+    - 자/손도 검출 → Precision 낮음 (파라미터 강화 필요)
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch(server_port=7862)
+```
+
+---
+
+## 📈 성능 분석 도구
+
+### 혼동 행렬 (Confusion Matrix) 생성
+
+```python
+def generate_confusion_matrix(test_results):
+    """
+    혼동 행렬 생성 및 시각화
+
+    Args:
+        test_results: 테스트 결과 리스트
+    """
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+
+    # 집계
+    TP = sum(r['metrics']['TP'] for r in test_results)
+    FP = sum(r['metrics']['FP'] for r in test_results)
+    TN = 0  # 새우 없는 이미지에서 검출 안 함
+    FN = sum(r['metrics']['FN'] for r in test_results)
+
+    # 혼동 행렬
+    cm = np.array([[TP, FP], [FN, TN]])
+
+    # 시각화
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                xticklabels=['Predicted Positive', 'Predicted Negative'],
+                yticklabels=['Actual Positive', 'Actual Negative'])
+    plt.title('Confusion Matrix')
+    plt.ylabel('Actual')
+    plt.xlabel('Predicted')
+    plt.tight_layout()
+    plt.savefig('confusion_matrix.png')
+    print("✅ Confusion matrix saved to confusion_matrix.png")
+```
+
+### PR 곡선 (Precision-Recall Curve)
+
+```python
+def generate_pr_curve(detections_by_threshold):
+    """
+    Precision-Recall 곡선 생성
+
+    Args:
+        detections_by_threshold: 임계값별 검출 결과
+    """
+    import matplotlib.pyplot as plt
+
+    thresholds = []
+    precisions = []
+    recalls = []
+
+    for threshold, results in sorted(detections_by_threshold.items()):
+        metrics = results['metrics']
+        thresholds.append(threshold)
+        precisions.append(metrics['precision'])
+        recalls.append(metrics['recall'])
+
+    # 그래프
+    plt.figure(figsize=(10, 6))
+    plt.plot(recalls, precisions, 'b-', linewidth=2)
+    plt.xlabel('Recall')
+    plt.ylabel('Precision')
+    plt.title('Precision-Recall Curve')
+    plt.grid(True)
+
+    # AP (Average Precision) 계산
+    ap = np.trapz(precisions, recalls)
+    plt.text(0.1, 0.1, f'AP = {ap:.2%}', fontsize=12,
+             bbox=dict(boxstyle='round', facecolor='wheat'))
+
+    plt.tight_layout()
+    plt.savefig('pr_curve.png')
+    print(f"✅ PR curve saved to pr_curve.png (AP = {ap:.2%})")
+```
+
+---
+
+## 🎯 검수 결과 기반 개선
+
+### 시나리오별 대응
+
+#### 1. Recall 낮음 (새우 놓침)
+
+**증상**: 실제 새우가 있는데 검출 안 됨
+
+**원인 분석**:
+```python
+# 어느 필터에서 탈락했는지 확인
+def analyze_filter_stages(image, detections):
+    """각 필터 단계별 통과율 분석"""
+
+    results = {}
+
+    # Step 1: 형태 필터
+    after_aspect = filter_by_aspect_ratio(detections)
+    results['aspect_ratio'] = {
+        'input': len(detections),
+        'output': len(after_aspect),
+        'pass_rate': len(after_aspect) / len(detections) if detections else 0
+    }
+
+    # Step 2: 색상 필터
+    after_color = filter_by_saturation(image, after_aspect)
+    results['saturation'] = {
+        'input': len(after_aspect),
+        'output': len(after_color),
+        'pass_rate': len(after_color) / len(after_aspect) if after_aspect else 0
+    }
+
+    # ... 각 필터별로 반복
+
+    return results
+```
+
+**해결 방법**:
+```python
+# 통과율이 낮은 필터의 임계값 완화
+if results['aspect_ratio']['pass_rate'] < 0.5:
+    # 종횡비 범위 확대
+    params['min_aspect_ratio'] = 1.5  # 2.0 → 1.5
+    params['max_aspect_ratio'] = 12.0  # 10.0 → 12.0
+```
+
+---
+
+#### 2. Precision 낮음 (오검출)
+
+**증상**: 자, 손 등도 새우로 검출
+
+**원인 분석**:
+```python
+# 오검출된 객체 분석
+def analyze_false_positives(false_positive_detections, images):
+    """오검출 패턴 분석"""
+
+    # 오검출 객체의 특징 수집
+    fp_features = []
+    for det in false_positive_detections:
+        features = {
+            'aspect_ratio': calculate_aspect_ratio(det['bbox']),
+            'area_ratio': calculate_area_ratio(det['bbox'], image_shape),
+            'color': extract_color_features(image, det['bbox']),
+            'texture': extract_texture_features(image, det['bbox'])
+        }
+        fp_features.append(features)
+
+    # 공통 패턴 찾기
+    avg_aspect = np.mean([f['aspect_ratio'] for f in fp_features])
+    print(f"FP 평균 종횡비: {avg_aspect:.2f}")
+
+    return fp_features
+```
+
+**해결 방법**:
+```python
+# 임계값 강화
+if avg_fp_aspect > 15:
+    # 자(ruler) 같은 매우 긴 객체
+    params['max_aspect_ratio'] = 10.0  # 줄이기
+
+if avg_fp_saturation > 100:
+    # 색상이 강한 객체 (새우는 낮은 채도)
+    params['max_saturation'] = 100  # 120 → 100
+```
+
+---
+
+#### 3. F1 낮음 (전반적 성능 부족)
+
+**증상**: Precision, Recall 모두 낮음
+
+**해결 방법**:
+1. **RT-DETR 임계값 조정**
+   ```python
+   # 더 많은 후보 검출
+   rtdetr_confidence = 0.2  # 0.3 → 0.2
+   ```
+
+2. **필터 순서 최적화**
+   ```python
+   # 가장 효과적인 필터를 먼저
+   # (빠르게 확실한 것부터 제거)
+   ```
+
+3. **근본적 해결**: Roboflow 파인튜닝
+   ```
+   → docs/measurement_shrimp_detection_strategy.md 참고
+   ```
+
+---
+
+## 📋 검수 체크리스트
+
+### 테스트 전 체크리스트
+
+- [ ] 테스트 데이터셋 준비 (최소 50장)
+- [ ] Ground Truth 라벨링 완료
+- [ ] 다양한 시나리오 포함 (배경, 위치, 크기)
+- [ ] Negative 샘플 포함 (새우 없는 이미지)
+
+### 검수 중 체크리스트
+
+- [ ] 시각적 검수 완료 (모든 이미지 육안 확인)
+- [ ] 정량적 평가 완료 (Precision, Recall, F1 계산)
+- [ ] 실패 사례 분석 완료
+- [ ] 필터별 통과율 분석 완료
+
+### 검수 후 체크리스트
+
+- [ ] 목표 성능 달성 여부 확인 (F1 > 70%)
+- [ ] 파라미터 튜닝 필요 여부 판단
+- [ ] 문서화 (실패 사례, 개선 방향)
+- [ ] 다음 iteration 계획 수립
+
+---
+
+## 🎓 요약
+
+### 빠른 검수 (1시간)
+```bash
+# 1. 시각적 테스트
+python test_visual_validation.py
+
+# 2. 결과 이미지 확인
+open test_results/visual/
+
+# 3. 육안 검수 → 문제 파악
+```
+
+### 정확한 검수 (반나절)
+```bash
+# 1. Ground Truth 준비
+# 2. 정량적 테스트
+python test_quantitative_evaluation.py
+
+# 3. 메트릭 분석
+# 4. 필터별 분석 → 파라미터 튜닝
+```
+
+### 대화형 검수 (실시간)
+```bash
+# Gradio 인터페이스 실행
+python interactive_validation.py
+
+# 브라우저에서 실시간 테스트
+# → 즉각적인 피드백
+```
+
+---
+
+**작성일**: 2025-11-07
+**버전**: 1.0
+**작성자**: VIDraft Team

docs/measurement_shrimp_detection_strategy.md

@@ -0,0 +1,400 @@
+# 📐 측정용 새우 검출 전략
+
+## 🎯 목표
+측정 매트 위의 죽은 새우만 정확하게 검출하고, 자(ruler), 손, 배경 객체는 제외
+
+---
+
+## 📊 현재 상황
+
+### 이미지 특징
+- **환경**: 파란색 측정 매트
+- **객체**: 죽은 새우 (투명/흰색)
+- **배경**: 측정 자, 사람 손/신발, 기타 물체
+- **용도**: 체장/체중 측정을 위한 실측 이미지
+
+### 현재 모델 성능
+
+| 모델 | 검출 결과 | 문제점 |
+|------|----------|--------|
+| **VIDraft/Shrimp (Roboflow)** | ❌ 검출 실패 | 수조 환경의 살아있는 새우로만 학습됨 |
+| **RT-DETR (범용)** | ⚠️ 과다 검출 | 새우 + 자 + 손 + 매트 등 모두 검출 |
+
+---
+
+## 💡 스마트한 해결 방안
+
+### 방안 1: Roboflow 모델 파인튜닝 ⭐ (추천)
+
+**개요**: 기존 VIDraft/Shrimp 모델에 측정 환경 데이터 추가 학습
+
+**장점:**
+- ✅ 기존 수조 검출 성능 유지
+- ✅ 측정 환경 검출 능력 추가
+- ✅ 단일 모델로 통합 관리
+- ✅ Roboflow 플랫폼에서 쉽게 학습 가능
+
+**단점:**
+- ⚠️ 측정 환경 이미지 라벨링 필요 (최소 50-100장)
+- ⚠️ 재학습 시간 소요
+
+**구현 절차:**
+1. **데이터 수집** (50-100장)
+   - 측정 매트 위 죽은 새우 이미지
+   - 다양한 크기, 각도, 조명 조건
+
+2. **Roboflow에서 라벨링**
+   - https://app.roboflow.com
+   - 새우 영역만 바운딩 박스 표시
+   - 자, 손, 배경은 제외
+
+3. **모델 재학습**
+   - 기존 수조 데이터 + 새로운 측정 데이터
+   - Transfer Learning으로 빠른 학습
+   - Validation으로 성능 검증
+
+4. **배포**
+   - 동일한 API 키로 업데이트된 모델 사용
+   - 코드 변경 없이 자동 적용
+
+**예상 소요 시간**: 2-3일
+**예상 정확도**: 90%+ (기존 수조: 90%, 측정: 85%+)
+
+---
+
+### 방안 2: SAM (Segment Anything Model) + 후처리 필터
+
+**개요**: SAM으로 모든 객체 세그먼트 후, 새우 특징으로 필터링
+
+**장점:**
+- ✅ 추가 학습 불필요
+- ✅ Zero-shot 검출 가능
+- ✅ 정밀한 세그먼테이션
+
+**단점:**
+- ⚠️ 느린 추론 속도 (CPU: 10-30초/이미지)
+- ⚠️ 새우 특징 정의 어려움 (색상, 크기, 형태 등)
+- ⚠️ 복잡한 후처리 로직 필요
+
+**구현 예시:**
+```python
+from segment_anything import SamPredictor, sam_model_registry
+
+# SAM 모델 로드
+sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h.pth")
+predictor = SamPredictor(sam)
+
+# 자동 세그먼트
+masks = predictor.generate(image)
+
+# 새우 필터링 (휴리스틱)
+for mask in masks:
+    # 1. 크기 필터: 너무 크거나 작으면 제외
+    area = mask.sum()
+    if area < 5000 or area > 50000:
+        continue
+
+    # 2. 위치 필터: 매트 중앙부만
+    bbox = get_bbox(mask)
+    if not is_in_center_region(bbox):
+        continue
+
+    # 3. 형태 필터: 가로로 긴 형태
+    aspect_ratio = bbox_width / bbox_height
+    if aspect_ratio < 2.0 or aspect_ratio > 8.0:
+        continue
+
+    # 새우로 판정
+    shrimp_masks.append(mask)
+```
+
+**예상 소요 시간**: 3-5일 (로직 개발 + 튜닝)
+**예상 정확도**: 70-80% (휴리스틱 의존)
+
+---
+
+### 방안 3: YOLOv8 커스텀 학습
+
+**개요**: YOLOv8 모델을 측정 환경 데이터로 처음부터 학습
+
+**장점:**
+- ✅ 빠른 추론 속도 (CPU: 0.5-1초/이미지)
+- ✅ 오픈소스로 완전 제어 가능
+- ✅ 다양한 내보내기 형식 (ONNX, TensorRT 등)
+
+**단점:**
+- ⚠️ 대량 데이터 필요 (최소 200-500장)
+- ⚠️ 학습 환경 구축 필요 (GPU)
+- ⚠️ 관리 부담 증가
+
+**구현 절차:**
+```bash
+# 설치
+pip install ultralytics
+
+# 데이터 준비 (YOLO 형식)
+# data.yaml:
+# path: ./dataset
+# train: images/train
+# val: images/val
+# nc: 1
+# names: ['shrimp']
+
+# 학습
+yolo detect train data=data.yaml model=yolov8n.pt epochs=100 imgsz=640
+
+# 추론
+yolo detect predict model=best.pt source=test.jpg
+```
+
+**예상 소요 시간**: 1-2주
+**예상 정확도**: 85%+ (충분한 데이터 시)
+
+---
+
+### 방안 4: 하이브리드 접근 (후처리 필터 추가) 🚀 (즉시 가능)
+
+**개요**: RT-DETR 결과에 스마트 필터링 적용
+
+**장점:**
+- ✅ 즉시 적용 가능 (코드만 수정)
+- ✅ 추가 학습 불필요
+- ✅ 기존 인프라 활용
+
+**구현 전략:**
+
+#### A. 클래스 필터링
+```python
+# RT-DETR는 COCO 클래스 사용
+# 새우와 유사한 클래스만 허용
+ALLOWED_CLASSES = [
+    # COCO dataset class IDs
+    # 새우와 비슷한 것들만
+]
+
+def filter_by_class(detections):
+    return [d for d in detections if d['class_id'] in ALLOWED_CLASSES]
+```
+
+#### B. 위치 기반 필터링
+```python
+def filter_by_position(detections, image_shape):
+    """매트 중앙 영역만 허용"""
+    h, w = image_shape[:2]
+    center_region = {
+        'x_min': w * 0.2,
+        'x_max': w * 0.8,
+        'y_min': h * 0.3,
+        'y_max': h * 0.7
+    }
+
+    filtered = []
+    for det in detections:
+        bbox_center_x = (det['bbox'][0] + det['bbox'][2]) / 2
+        bbox_center_y = (det['bbox'][1] + det['bbox'][3]) / 2
+
+        if (center_region['x_min'] < bbox_center_x < center_region['x_max'] and
+            center_region['y_min'] < bbox_center_y < center_region['y_max']):
+            filtered.append(det)
+
+    return filtered
+```
+
+#### C. 크기 기반 필터링
+```python
+def filter_by_size(detections, image_shape):
+    """적절한 크기의 객체만 허용"""
+    h, w = image_shape[:2]
+    image_area = h * w
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+        area_ratio = bbox_area / image_area
+
+        # 이미지의 5%~50% 크기만 허용
+        if 0.05 < area_ratio < 0.50:
+            filtered.append(det)
+
+    return filtered
+```
+
+#### D. 형태 기반 필터링
+```python
+def filter_by_shape(detections):
+    """가로로 긴 형태만 허용 (새우 특징)"""
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+        aspect_ratio = width / height
+
+        # 가로:세로 비율 2:1 ~ 8:1
+        if 2.0 < aspect_ratio < 8.0:
+            filtered.append(det)
+
+    return filtered
+```
+
+#### E. 색상 기반 필터링
+```python
+def filter_by_color(image, detections):
+    """평균 색상이 새우와 유사한 객체만 허용"""
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        roi = image[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])]
+
+        # 평균 BGR 값
+        mean_color = roi.mean(axis=(0, 1))
+
+        # 투명/흰색/회색 범위 (죽은 새우)
+        # B, G, R 값이 모두 비슷하고 중간 이상
+        if (abs(mean_color[0] - mean_color[1]) < 30 and
+            abs(mean_color[1] - mean_color[2]) < 30 and
+            mean_color.mean() > 100):
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 통합 파이프라인
+```python
+def detect_measurement_shrimp(image, confidence=0.3):
+    """측정용 새우 검출 (스마트 필터링)"""
+
+    # 1. RT-DETR로 기본 검출
+    raw_detections = rtdetr_detect(image, confidence)
+
+    # 2. 다단계 필터링
+    detections = raw_detections
+    detections = filter_by_position(detections, image.shape)
+    detections = filter_by_size(detections, image.shape)
+    detections = filter_by_shape(detections)
+    detections = filter_by_color(image, detections)
+
+    # 3. 신뢰도 순 정렬 후 상위 1개만 (측정은 보통 1마리)
+    detections = sorted(detections, key=lambda x: x['confidence'], reverse=True)
+
+    return detections[:1] if detections else []
+```
+
+**예상 소요 시간**: 1일
+**예상 정확도**: 60-75% (튜닝에 따라 달라짐)
+
+---
+
+## 📈 방안 비교
+
+| 방안 | 정확도 | 속도 | 구현 난이도 | 소요 시간 | 비용 | 추천도 |
+|------|--------|------|------------|----------|------|--------|
+| **1. Roboflow 파인튜닝** | ⭐⭐⭐⭐⭐ 90%+ | ⭐⭐⭐⭐ 1-2초 | ⭐⭐⭐ 중간 | 2-3일 | $ | ⭐⭐⭐⭐⭐ |
+| **2. SAM + 후처리** | ⭐⭐⭐ 70-80% | ⭐⭐ 10-30초 | ⭐⭐⭐⭐ 어려움 | 3-5일 | 무료 | ⭐⭐ |
+| **3. YOLOv8 커스텀** | ⭐⭐⭐⭐ 85%+ | ⭐⭐⭐⭐⭐ 0.5초 | ⭐⭐⭐⭐⭐ 매우 어려움 | 1-2주 | 무료 | ⭐⭐⭐ |
+| **4. RT-DETR + 필터** | ⭐⭐⭐ 60-75% | ⭐⭐⭐⭐ 1-2초 | ⭐⭐ 쉬움 | 1일 | 무료 | ⭐⭐⭐⭐ |
+
+---
+
+## 🎯 최종 추천 전략
+
+### 단기 (즉시~1일): 방안 4 구현
+**RT-DETR + 스마트 필터링**으로 빠르게 문제 해결
+- 위치, 크기, 형태, 색상 필터 조합
+- 테스트 이미지로 파라미터 튜닝
+- 60-75% 정확도로 실용적 사용 가능
+
+### 중기 (1주~2주): 방안 1 구현
+**Roboflow 모델 파인튜닝**으로 근본적 해결
+- 측정 환경 이미지 50-100장 수집 및 라벨링
+- 기존 모델에 추가 학습
+- 90%+ 정확도 달성
+- 수조 + 측정 통합 모델 완성
+
+### 장기 (선택): 방안 3 고려
+대량 데이터 확보 시 **YOLOv8**으로 완전 자체 모델 구축
+
+---
+
+## 📝 즉시 실행 가능한 액션 플랜
+
+### Phase 1: 빠른 프로토타입 (1일)
+1. **RT-DETR + 필터 구현**
+   - `app.py`에 `detect_measurement_shrimp()` 함수 추가
+   - 5가지 필터 순차 적용
+   - 테스트 이미지로 검증
+
+2. **UI 업데이트**
+   - "측정용 모드" 토글 추가
+   - 활성화 시 스마트 필터 적용
+
+### Phase 2: 데이터 수집 준비 (병렬 진행)
+1. **이미지 수집**
+   - 기존 `data/` 폴더의 측정 이미지 활용
+   - 추가로 50-100장 촬영
+   - 다양한 각도, 크기, 조명
+
+2. **Roboflow 프로젝트 설정**
+   - 기존 프로젝트에 새 버전 생성
+   - 라벨링 진행
+
+### Phase 3: 모델 재학습 (2-3일)
+1. **Roboflow에서 학습**
+   - 기존 + 새 데이터 통합
+   - Auto-Orient, Auto-Adjust 등 증강 적용
+   - Validation 성능 확인
+
+2. **배포 및 테스트**
+   - 업데이트된 모델 API 연동
+   - A/B 테스트로 성능 비교
+
+---
+
+## 💰 비용 분석
+
+### Roboflow 파인튜닝
+- **무료 티어**: 1,000 predictions/month
+- **Starter 플랜**: $49/month - 10,000 predictions
+- **예상 비용**: 월 $0-49 (사용량에 따라)
+
+### 대안 (완전 무료)
+- **YOLOv8 자체 학습**: 무료 (GPU 환경 필요)
+- **RT-DETR + 필터**: 무료 (로컬 실행)
+
+---
+
+## 🔬 실험 및 검증
+
+### 테스트 데이터셋 준비
+```
+test_images/
+├── measurement/
+│   ├── single_shrimp/     # 새우 1마리만
+│   ├── with_ruler/        # 자 포함
+│   ├── with_hand/         # 손 포함
+│   └── complex/           # 복잡한 배경
+└── tank/
+    └── live_shrimp/       # 수조 새우
+```
+
+### 평가 지표
+- **Precision**: 검출된 것 중 실제 새우 비율
+- **Recall**: 실제 새우 중 검출된 비율
+- **F1 Score**: Precision과 Recall의 조화평균
+- **추론 시간**: CPU 기준 ms/이미지
+
+---
+
+## 📚 참고 자료
+
+- [Roboflow Training Tutorial](https://docs.roboflow.com/train)
+- [YOLOv8 Documentation](https://docs.ultralytics.com/)
+- [Segment Anything (SAM)](https://segment-anything.com/)
+- [RT-DETR Paper](https://arxiv.org/abs/2304.08069)
+
+---
+
+**작성일**: 2025-11-07
+**작성자**: VIDraft Team
+**버전**: 1.0

docs/rt_detr_smart_filtering_strategy.md

@@ -0,0 +1,1252 @@
+# 🎯 RT-DETR + 스마트 필터링 전략 (MECE)
+
+## 📋 목차
+1. [문제 정의](#문제-정의)
+2. [필터링 전략 체계](#필터링-전략-체계)
+3. [상세 구현 방안](#상세-구현-방안)
+4. [의사결정 트리](#의사결정-트리)
+5. [구현 코드](#구현-코드)
+6. [테스트 및 검증](#테스트-및-검증)
+
+---
+
+## 🎯 문제 정의
+
+### 입력 조건
+- **이미지**: 측정 매트 위의 죽은 새우
+- **제약사항**:
+  - 새우 위치는 랜덤 (매트 어디든 가능)
+  - 배경에 사람 손, 자, 신발 등 다양한 객체
+  - 새우는 투명/흰색/회색 (죽은 상태)
+
+### 목표
+- **검출 대상**: 새우만 검출
+- **제외 대상**: 자(ruler), 손, 신발, 매트, 기타 배경 객체
+- **정확도**: 60-75% (즉시 적용 가능한 수준)
+
+### RT-DETR의 한계
+- COCO 데이터셋 학습 (80개 범용 클래스)
+- 새우 전용 학습 없음
+- 모든 객체를 검출하여 과다 검출 발생
+
+---
+
+## 🏗️ 필터링 전략 체계 (MECE)
+
+### Level 1: 객체 속성 기반 분류
+
+모든 검출된 객체는 다음 **4가지 독립적 속성**으로 분류됩니다:
+
+```
+검출 객체
+├── 1. 물리적 속성 (Physical Attributes)
+│   ├── 크기 (Size)
+│   ├── 형태 (Shape/Aspect Ratio)
+│   └── 방향 (Orientation)
+│
+├── 2. 시각적 속성 (Visual Attributes)
+│   ├── 색상 (Color)
+│   ├── 텍스처 (Texture)
+│   └── 투명도 (Transparency)
+│
+├── 3. 의미적 속성 (Semantic Attributes)
+│   ├── RT-DETR 클래스 (COCO Class)
+│   └── 신뢰도 (Confidence Score)
+│
+└── 4. 컨텍스트 속성 (Contextual Attributes)
+    ├── 공간적 관계 (Spatial Relations)
+    └── 주변 객체 (Neighboring Objects)
+```
+
+### Level 2: 필터링 단계 (순차 적용)
+
+```
+Step 1: 사전 필터 (Pre-Filter)
+  → RT-DETR 결과에서 명백히 새우가 아닌 것 제거
+  → COCO 클래스 기반 1차 필터링
+
+Step 2: 물리적 필터 (Physical Filter)
+  → 크기, 형태, 방향 기반 필터링
+  → 위치 무관하게 적용 가능
+
+Step 3: 시각적 필터 (Visual Filter)
+  → 색상, 텍스처 기반 필터링
+  → 새우의 시각적 특징 활용
+
+Step 4: 컨텍스트 필터 (Context Filter)
+  → 주변 객체와의 관계 분석
+  → 자(ruler)와의 상대적 위치
+
+Step 5: 후처리 (Post-Processing)
+  → 신뢰도 기반 최종 선택
+  → 중복 제거 (NMS)
+```
+
+---
+
+## 📐 상세 구현 방안
+
+### Step 1: 사전 필터 (Pre-Filter)
+
+#### 1.1 COCO 클래스 필터링
+
+**전략**: RT-DETR이 검출한 클래스 중 새우와 유사한 클래스만 허용
+
+**COCO 80개 클래스 분류**:
+
+```python
+# COCO Classes 완전 분류 (MECE)
+COCO_CLASSES = {
+    # A. 새우 가능성 있는 클래스 (허용) ✅
+    "POSSIBLY_SHRIMP": [
+        # 유사 형태 해양 생물
+        # (COCO에는 새우가 없으므로 유사한 것들)
+    ],
+
+    # B. 새우와 무관한 클래스 (제거) ❌
+    "DEFINITELY_NOT_SHRIMP": {
+        # B1. 사람 관련
+        "PERSON_RELATED": [0],  # person
+
+        # B2. 의류/액세서리
+        "CLOTHING": [24, 25, 26, 27, 31, 32, 33],
+        # backpack, umbrella, handbag, tie, suitcase, frisbee, skis
+
+        # B3. 스포츠 용품
+        "SPORTS": [32, 33, 34, 35, 36, 37, 38, 39, 40, 41],
+        # sports ball, baseball bat, etc.
+
+        # B4. 실내 가구
+        "FURNITURE": [56, 57, 58, 59, 60, 61, 62, 63],
+        # chair, couch, bed, etc.
+
+        # B5. 전자기기
+        "ELECTRONICS": [63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73],
+        # laptop, mouse, keyboard, etc.
+
+        # B6. 주방 용품
+        "KITCHEN": [42, 43, 44, 45, 46, 47, 48, 49, 50, 51],
+        # wine glass, cup, fork, knife, etc.
+
+        # B7. 교통수단
+        "VEHICLES": [1, 2, 3, 4, 5, 6, 7, 8],
+        # bicycle, car, motorcycle, etc.
+    },
+
+    # C. 애매한 클래스 (조건부 허용) ⚠️
+    "AMBIGUOUS": [
+        # 추가 필터링 필요
+        # 예: 일부 과일, 물체 등
+    ]
+}
+```
+
+**구현**:
+```python
+def filter_by_coco_class(detections):
+    """COCO 클래스 기반 필터링"""
+
+    # 명백히 제외할 클래스 ID
+    EXCLUDE_CLASSES = set()
+    for category in COCO_CLASSES["DEFINITELY_NOT_SHRIMP"].values():
+        EXCLUDE_CLASSES.update(category)
+
+    filtered = []
+    for det in detections:
+        class_id = det.get('class_id', -1)
+        if class_id not in EXCLUDE_CLASSES:
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 1.2 신뢰도 임계값
+
+**전략**: 너무 낮은 신뢰도는 노이즈일 가능성
+
+```python
+def filter_by_confidence(detections, min_confidence=0.15):
+    """최소 신뢰도 필터"""
+    return [d for d in detections if d['confidence'] >= min_confidence]
+```
+
+---
+
+### Step 2: 물리적 필터 (Physical Filter)
+
+**핵심**: 위치 무관하게 적용 가능한 물��적 특성
+
+#### 2.1 절대 크기 필터
+
+**가정**: 측정 이미지는 대부분 비슷한 해상도 (1000x1000 ~ 2000x2000)
+
+```python
+def filter_by_absolute_size(detections, image_shape):
+    """절대 픽셀 크기 기반 필터"""
+
+    h, w = image_shape[:2]
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        bbox_width = bbox[2] - bbox[0]
+        bbox_height = bbox[3] - bbox[1]
+        bbox_area = bbox_width * bbox_height
+
+        # 새우 크기 범위 (경험적)
+        # 너무 작으면: 노이즈
+        # 너무 크면: 매트, 배경
+        if bbox_width < 50:  # 최소 50px
+            continue
+        if bbox_height < 20:  # 최소 20px
+            continue
+        if bbox_area < 2000:  # 최소 면적
+            continue
+        if bbox_area > (w * h * 0.6):  # 이미지의 60% 이상이면 배경
+            continue
+
+        filtered.append(det)
+
+    return filtered
+```
+
+#### 2.2 상대 크기 필터
+
+**전략**: 이미지 크기 대비 비율로 필터링
+
+```python
+def filter_by_relative_size(detections, image_shape):
+    """이미지 대비 상대 크기 필터"""
+
+    h, w = image_shape[:2]
+    image_area = h * w
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+        area_ratio = bbox_area / image_area
+
+        # 이미지의 3%~50% 크기만 허용
+        if 0.03 < area_ratio < 0.50:
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 2.3 종횡비 필터 (Aspect Ratio)
+
+**특징**: 새우는 가로로 긴 형태
+
+```python
+def filter_by_aspect_ratio(detections):
+    """종횡비 기반 필터 (가로/세로)"""
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+
+        # 가로가 0이면 제외
+        if height == 0:
+            continue
+
+        aspect_ratio = width / height
+
+        # 새우는 가로로 길다
+        # 1.5:1 ~ 10:1 범위
+        if 1.5 < aspect_ratio < 10.0:
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 2.4 충만도 필터 (Solidity)
+
+**정의**: Solidity = 객체 면적 / 바운딩 박스 면적
+
+**가정**: 새우는 바운딩 박스를 어느 정도 채움 (0.3~0.8)
+
+```python
+def filter_by_solidity(image, detections):
+    """충만도 기반 필터 (세그먼트 필요 시)"""
+    import cv2
+    import numpy as np
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        # ROI 추출
+        roi = image[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        # 간단한 thresholding으로 객체 영역 추정
+        gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+        _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+        # 객체 면적
+        object_area = np.sum(binary > 0)
+        bbox_area = (x2 - x1) * (y2 - y1)
+
+        if bbox_area == 0:
+            continue
+
+        solidity = object_area / bbox_area
+
+        # 새우는 0.3~0.8 범위
+        if 0.25 < solidity < 0.85:
+            filtered.append(det)
+
+    return filtered
+```
+
+---
+
+### Step 3: 시각적 필터 (Visual Filter)
+
+**핵심**: 색상과 텍스처로 새우 식별 (위치 무관)
+
+#### 3.1 색상 기반 필터
+
+**특징**: 죽은 새우 = 투명/흰색/회색 (높은 명도, 낮은 채도)
+
+```python
+def filter_by_color(image, detections):
+    """색상 기반 필터 (HSV 색공간)"""
+    import cv2
+    import numpy as np
+
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        # ROI 추출
+        roi_hsv = hsv_image[y1:y2, x1:x2]
+        if roi_hsv.size == 0:
+            continue
+
+        # 평균 HSV 값
+        mean_h, mean_s, mean_v = roi_hsv.mean(axis=(0, 1))
+
+        # 새우 특징:
+        # - 낮은 채도 (Saturation < 100)
+        # - 높은 명도 (Value > 100)
+        # - 색상 무관 (투명하므로)
+
+        if mean_s < 120 and mean_v > 80:  # 채도 낮고 명도 높음
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 3.2 텍스처 기반 필터
+
+**특징**: 새우는 부드러운 텍스처 (자나 매트는 패턴이 강함)
+
+```python
+def filter_by_texture(image, detections):
+    """텍스처 기반 필터 (표준편차 활용)"""
+    import cv2
+    import numpy as np
+
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        # ROI 추출
+        roi = gray_image[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        # 텍스처 복잡도 (표준편차)
+        texture_std = np.std(roi)
+
+        # 새우: 부드러운 텍스처 (std 낮음)
+        # 자, 매트: 강�� 패턴 (std 높음)
+        if texture_std < 50:  # 부드러운 텍스처
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 3.3 에지 밀도 필터
+
+**특징**: 새우는 에지가 부드러움 (자는 강한 직선 에지)
+
+```python
+def filter_by_edge_density(image, detections):
+    """에지 밀도 기반 필터"""
+    import cv2
+    import numpy as np
+
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    edges = cv2.Canny(gray_image, 50, 150)
+
+    filtered = []
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        # ROI 에지
+        roi_edges = edges[y1:y2, x1:x2]
+        if roi_edges.size == 0:
+            continue
+
+        # 에지 픽셀 비율
+        edge_density = np.sum(roi_edges > 0) / roi_edges.size
+
+        # 새우: 중간 에지 밀도 (0.05~0.25)
+        # 자/매트: 높은 에지 밀도
+        if 0.03 < edge_density < 0.30:
+            filtered.append(det)
+
+    return filtered
+```
+
+---
+
+### Step 4: 컨텍스트 필터 (Context Filter)
+
+**핵심**: 주변 객체와의 관계 (위치는 랜덤이지만 상대적 관계는 활용 가능)
+
+#### 4.1 자(Ruler) 검출 및 활용
+
+**전략**: 자가 검출되면 새우는 자 근처에 있을 가능성 높음
+
+```python
+def detect_ruler(detections):
+    """자(ruler) 검출"""
+
+    rulers = []
+    for det in detections:
+        bbox = det['bbox']
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+
+        # 자 특징:
+        # - 매우 가늘고 긴 형태 (aspect ratio > 10)
+        # - 직선 패턴
+
+        if height > 0:
+            aspect_ratio = width / height
+            if aspect_ratio > 10 or aspect_ratio < 0.1:  # 가로 또는 세로로 매우 긴
+                rulers.append(det)
+
+    return rulers
+
+def filter_by_ruler_proximity(detections, rulers):
+    """자와의 근접도 기반 필터"""
+    if not rulers:
+        # 자가 없으면 이 필터 스킵
+        return detections
+
+    import numpy as np
+
+    filtered = []
+    for det in detections:
+        det_center = np.array([
+            (det['bbox'][0] + det['bbox'][2]) / 2,
+            (det['bbox'][1] + det['bbox'][3]) / 2
+        ])
+
+        # 가장 가까운 자와의 거리
+        min_distance = float('inf')
+        for ruler in rulers:
+            ruler_center = np.array([
+                (ruler['bbox'][0] + ruler['bbox'][2]) / 2,
+                (ruler['bbox'][1] + ruler['bbox'][3]) / 2
+            ])
+            distance = np.linalg.norm(det_center - ruler_center)
+            min_distance = min(min_distance, distance)
+
+        # 자와 적당히 가까우면 새우일 가능성 높음
+        # (너무 가까우면 자 자체일 수 있음)
+        if 50 < min_distance < 500:
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 4.2 손(Hand) 제거
+
+**전략**: 손이 검출되면 제외
+
+```python
+def filter_out_hands(detections):
+    """손 제거 (COCO class_id = 0 또는 특정 조건)"""
+
+    filtered = []
+    for det in detections:
+        # COCO에서 person = 0
+        # 손은 보통 person으로 검출되거나
+        # 피부색 + 특정 형태
+
+        # 간단히 class_id로 제거
+        if det.get('class_id') == 0:  # person
+            continue
+
+        filtered.append(det)
+
+    return filtered
+```
+
+#### 4.3 중심성 점수 (Centrality Score)
+
+**전략**: 완전히 랜덤은 아님. 대부분 이미지 중앙~중간 영역에 배치
+
+```python
+def calculate_centrality_score(bbox, image_shape):
+    """중심성 점수 (0~1, 높을수록 중앙)"""
+    h, w = image_shape[:2]
+    image_center = np.array([w / 2, h / 2])
+
+    bbox_center = np.array([
+        (bbox[0] + bbox[2]) / 2,
+        (bbox[1] + bbox[3]) / 2
+    ])
+
+    # 중심으로부터 거리
+    distance = np.linalg.norm(bbox_center - image_center)
+    max_distance = np.linalg.norm(np.array([w / 2, h / 2]))  # 대각선 절반
+
+    # 거리가 0이면 점수 1, 멀수록 점수 감소
+    centrality = 1 - (distance / max_distance)
+
+    return centrality
+
+def add_centrality_scores(detections, image_shape):
+    """각 검출에 중심성 점수 추가"""
+    for det in detections:
+        det['centrality_score'] = calculate_centrality_score(det['bbox'], image_shape)
+
+    return detections
+```
+
+---
+
+### Step 5: 후처리 (Post-Processing)
+
+#### 5.1 종합 점수 계산
+
+**전략**: 여러 특징을 종합하여 최종 점수 산출
+
+```python
+def calculate_composite_score(detection, image_shape):
+    """종합 점수 계산 (0~100)"""
+
+    # 가중치 (조정 가능)
+    WEIGHTS = {
+        'confidence': 0.30,      # RT-DETR 신뢰도
+        'centrality': 0.15,      # 중심성
+        'aspect_ratio': 0.20,    # 종횡비 적합도
+        'size': 0.20,            # 크기 적합도
+        'color': 0.15            # 색상 적합도
+    }
+
+    score = 0.0
+
+    # 1. 신뢰도
+    score += detection['confidence'] * WEIGHTS['confidence']
+
+    # 2. 중심성
+    if 'centrality_score' in detection:
+        score += detection['centrality_score'] * WEIGHTS['centrality']
+
+    # 3. 종횡비 적합도
+    bbox = detection['bbox']
+    width = bbox[2] - bbox[0]
+    height = bbox[3] - bbox[1]
+    if height > 0:
+        aspect_ratio = width / height
+        # 이상적 종횡비: 3~6
+        ideal_aspect = 4.5
+        aspect_fitness = 1 - abs(aspect_ratio - ideal_aspect) / ideal_aspect
+        aspect_fitness = max(0, min(1, aspect_fitness))  # 0~1 clipping
+        score += aspect_fitness * WEIGHTS['aspect_ratio']
+
+    # 4. 크기 적합도
+    h, w = image_shape[:2]
+    bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+    area_ratio = bbox_area / (h * w)
+    # 이상적 크기: 10~30%
+    if 0.10 < area_ratio < 0.30:
+        size_fitness = 1.0
+    else:
+        size_fitness = 0.5
+    score += size_fitness * WEIGHTS['size']
+
+    # 5. 색상 적합도 (이미 필터링 통과했으면 1.0)
+    if 'color_fitness' in detection:
+        score += detection['color_fitness'] * WEIGHTS['color']
+    else:
+        score += 0.5 * WEIGHTS['color']  # 기본값
+
+    return score * 100  # 0~100 스케일
+```
+
+#### 5.2 최종 선택
+
+**전략**: 종합 점수 상위 N개 선택 (측정은 보통 1마리)
+
+```python
+def select_top_detections(detections, image_shape, top_n=1):
+    """종합 점수 기반 최종 선택"""
+
+    # 중심성 점수 추가
+    detections = add_centrality_scores(detections, image_shape)
+
+    # 종합 점수 계산
+    for det in detections:
+        det['composite_score'] = calculate_composite_score(det, image_shape)
+
+    # 점수순 정렬
+    detections = sorted(detections, key=lambda x: x['composite_score'], reverse=True)
+
+    # 상위 N개 선택
+    return detections[:top_n]
+```
+
+#### 5.3 NMS (Non-Maximum Suppression)
+
+**전략**: 중복 검출 제거
+
+```python
+def apply_nms(detections, iou_threshold=0.5):
+    """NMS 적용"""
+    if len(detections) <= 1:
+        return detections
+
+    import numpy as np
+
+    # 신뢰도순 정렬
+    detections = sorted(detections, key=lambda x: x['confidence'], reverse=True)
+
+    keep = []
+    while detections:
+        best = detections.pop(0)
+        keep.append(best)
+
+        # 남은 것 중 IoU 높은 것 제거
+        filtered = []
+        for det in detections:
+            iou = calculate_iou(best['bbox'], det['bbox'])
+            if iou < iou_threshold:
+                filtered.append(det)
+
+        detections = filtered
+
+    return keep
+
+def calculate_iou(bbox1, bbox2):
+    """IoU 계산"""
+    x1_min, y1_min, x1_max, y1_max = bbox1
+    x2_min, y2_min, x2_max, y2_max = bbox2
+
+    # 교집합
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+
+    # 합집합
+    area1 = (x1_max - x1_min) * (y1_max - y1_min)
+    area2 = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = area1 + area2 - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+```
+
+---
+
+## 🌳 의사결정 트리
+
+```
+┌─────────────────────────────────────┐
+│  RT-DETR 검출 결과 (N개 객체)        │
+└─────────────────┬───────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────┐
+│ Step 1: 사전 필터                    │
+│ • COCO 클래스 필터 (명백히 제외)     │
+│ • 신뢰도 필터 (< 0.15 제거)          │
+└─────────────────┬───────────────────┘
+                  │
+                  ▼
+        ┌─────────┴─────────┐
+        │  필터 통과?        │
+        └─────┬──────┬──────┘
+              NO    YES
+              │      │
+         [제거]      ▼
+        ┌─────────────────────────────────────┐
+        │ Step 2: 물리적 필터                  │
+        │ • 절대 크기 필터                     │
+        │ • 상대 크기 필터                     │
+        │ • 종횡비 필터 (1.5 ~ 10)             │
+        │ • 충만도 필터 (0.25 ~ 0.85)          │
+        └─────────────────┬───────────────────┘
+                          │
+                          ▼
+                ┌─────────┴─────────┐
+                │  모두 통과?        │
+                └─────┬──────┬──────┘
+                      NO    YES
+                      │      │
+                 [제거]      ▼
+                ┌─────────────────────────────────────┐
+                │ Step 3: 시각적 필터                  │
+                │ • 색상 필터 (낮은 채도, 높은 명도)   │
+                │ • 텍스처 필터 (부드러움)             │
+                │ • 에지 밀도 필터 (중간)              │
+                └─────────────────┬───────────────────┘
+                                  │
+                                  ▼
+                        ┌─────────┴─────────┐
+                        │  통과?            │
+                        └─────┬──────┬──────┘
+                              NO    YES
+                              │      │
+                         [제거]      ▼
+                        ┌─────────────────────────────────────┐
+                        │ Step 4: 컨텍스트 필터                │
+                        │ • 자(ruler) 검출 및 근접도          │
+                        │ • 손 제거                           │
+                        │ • 중심성 점수 계산                  │
+                        └─────────────────┬───────────────────┘
+                                          │
+                                          ▼
+                                ┌─────────────────────────────────────┐
+                                │ Step 5: 후처리                       │
+                                │ • 종합 점수 계산                     │
+                                │ • 상위 N개 선택 (보통 1개)           │
+                                │ • NMS 적용                           │
+                                └─────────────────┬───────────────────┘
+                                                  │
+                                                  ▼
+                                        ┌─────────────────┐
+                                        │  최종 검출 결과  │
+                                        │  (새우만)       │
+                                        └─────────────────┘
+```
+
+---
+
+## 💻 통합 구현 코드
+
+```python
+# -*- coding: utf-8 -*-
+"""
+RT-DETR + 스마트 필터링 통합 파이프라인
+"""
+
+import cv2
+import numpy as np
+from typing import List, Dict, Tuple
+
+class SmartShrimpFilter:
+    """측정용 새우 검출 스마트 필터"""
+
+    def __init__(self):
+        # 파라미터 (조정 가능)
+        self.params = {
+            # Step 1: 사전 필터
+            'min_confidence': 0.15,
+
+            # Step 2: 물리적 필터
+            'min_width': 50,
+            'min_height': 20,
+            'min_area': 2000,
+            'max_area_ratio': 0.6,
+            'min_area_ratio': 0.03,
+            'max_area_ratio': 0.50,
+            'min_aspect_ratio': 1.5,
+            'max_aspect_ratio': 10.0,
+            'min_solidity': 0.25,
+            'max_solidity': 0.85,
+
+            # Step 3: 시각적 필터
+            'max_saturation': 120,
+            'min_value': 80,
+            'max_texture_std': 50,
+            'min_edge_density': 0.03,
+            'max_edge_density': 0.30,
+
+            # Step 4: 컨텍스트 필터
+            'ruler_min_aspect': 10.0,
+            'ruler_max_aspect': 0.1,
+            'min_ruler_distance': 50,
+            'max_ruler_distance': 500,
+
+            # Step 5: 후처리
+            'top_n': 1,
+            'nms_iou_threshold': 0.5,
+        }
+
+    def filter(self, image: np.ndarray, detections: List[Dict]) -> List[Dict]:
+        """
+        전체 필터링 파이프라인
+
+        Args:
+            image: 입력 이미지 (BGR)
+            detections: RT-DETR 검출 결과
+                [{'bbox': [x1,y1,x2,y2], 'confidence': 0.9, 'class_id': 0}, ...]
+
+        Returns:
+            필터링된 검출 결과 (새우만)
+        """
+
+        print(f"[INFO] Initial detections: {len(detections)}")
+
+        # Step 1: 사전 필터
+        detections = self._pre_filter(detections)
+        print(f"[STEP 1] After pre-filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        # Step 2: 물리적 필터
+        detections = self._physical_filter(detections, image.shape)
+        print(f"[STEP 2] After physical filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        # Step 3: 시각적 필터
+        detections = self._visual_filter(image, detections)
+        print(f"[STEP 3] After visual filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        # Step 4: 컨텍스트 필터
+        detections = self._context_filter(detections, image.shape)
+        print(f"[STEP 4] After context filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        # Step 5: 후처리
+        detections = self._post_process(detections, image.shape)
+        print(f"[STEP 5] Final detections: {len(detections)}")
+
+        return detections
+
+    def _pre_filter(self, detections: List[Dict]) -> List[Dict]:
+        """사전 필터: COCO 클래스 + 신뢰도"""
+
+        # 제외할 COCO 클래스
+        EXCLUDE_CLASSES = {0}  # person (손 등)
+
+        filtered = []
+        for det in detections:
+            # 클래스 필터
+            if det.get('class_id', -1) in EXCLUDE_CLASSES:
+                continue
+
+            # 신뢰도 필터
+            if det['confidence'] < self.params['min_confidence']:
+                continue
+
+            filtered.append(det)
+
+        return filtered
+
+    def _physical_filter(self, detections: List[Dict], image_shape: Tuple) -> List[Dict]:
+        """물리적 필터: 크기, 형태"""
+
+        h, w = image_shape[:2]
+        image_area = h * w
+
+        filtered = []
+        for det in detections:
+            bbox = det['bbox']
+            x1, y1, x2, y2 = bbox
+
+            bbox_width = x2 - x1
+            bbox_height = y2 - y1
+            bbox_area = bbox_width * bbox_height
+
+            # 절대 크기 필터
+            if bbox_width < self.params['min_width']:
+                continue
+            if bbox_height < self.params['min_height']:
+                continue
+            if bbox_area < self.params['min_area']:
+                continue
+
+            # 상대 크기 필터
+            area_ratio = bbox_area / image_area
+            if not (self.params['min_area_ratio'] < area_ratio < self.params['max_area_ratio']):
+                continue
+
+            # 종횡비 필터
+            if bbox_height == 0:
+                continue
+            aspect_ratio = bbox_width / bbox_height
+            if not (self.params['min_aspect_ratio'] < aspect_ratio < self.params['max_aspect_ratio']):
+                continue
+
+            filtered.append(det)
+
+        return filtered
+
+    def _visual_filter(self, image: np.ndarray, detections: List[Dict]) -> List[Dict]:
+        """시각적 필터: 색상, 텍스처"""
+
+        hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+        filtered = []
+        for det in detections:
+            bbox = det['bbox']
+            x1, y1, x2, y2 = map(int, bbox)
+
+            # ROI 추출
+            roi_hsv = hsv_image[y1:y2, x1:x2]
+            roi_gray = gray_image[y1:y2, x1:x2]
+
+            if roi_hsv.size == 0 or roi_gray.size == 0:
+                continue
+
+            # 색상 필터
+            mean_h, mean_s, mean_v = roi_hsv.mean(axis=(0, 1))
+            if not (mean_s < self.params['max_saturation'] and mean_v > self.params['min_value']):
+                continue
+
+            # 텍스처 필터
+            texture_std = np.std(roi_gray)
+            if texture_std > self.params['max_texture_std']:
+                continue
+
+            filtered.append(det)
+
+        return filtered
+
+    def _context_filter(self, detections: List[Dict], image_shape: Tuple) -> List[Dict]:
+        """컨텍스트 필터: 자 검출, 중심성"""
+
+        # 자 검출
+        rulers = self._detect_rulers(detections)
+
+        # 중심성 점수 추가
+        for det in detections:
+            det['centrality_score'] = self._calculate_centrality(det['bbox'], image_shape)
+
+        # 자 근접도 필터 (자가 있으면)
+        if rulers:
+            filtered = []
+            for det in detections:
+                if self._is_near_ruler(det, rulers):
+                    filtered.append(det)
+            return filtered if filtered else detections
+        else:
+            return detections
+
+    def _detect_rulers(self, detections: List[Dict]) -> List[Dict]:
+        """자 검출"""
+        rulers = []
+        for det in detections:
+            bbox = det['bbox']
+            width = bbox[2] - bbox[0]
+            height = bbox[3] - bbox[1]
+
+            if height > 0:
+                aspect_ratio = width / height
+                if aspect_ratio > self.params['ruler_min_aspect'] or aspect_ratio < self.params['ruler_max_aspect']:
+                    rulers.append(det)
+
+        return rulers
+
+    def _is_near_ruler(self, det: Dict, rulers: List[Dict]) -> bool:
+        """자 근처에 있는지 확인"""
+        det_center = np.array([
+            (det['bbox'][0] + det['bbox'][2]) / 2,
+            (det['bbox'][1] + det['bbox'][3]) / 2
+        ])
+
+        for ruler in rulers:
+            ruler_center = np.array([
+                (ruler['bbox'][0] + ruler['bbox'][2]) / 2,
+                (ruler['bbox'][1] + ruler['bbox'][3]) / 2
+            ])
+            distance = np.linalg.norm(det_center - ruler_center)
+
+            if self.params['min_ruler_distance'] < distance < self.params['max_ruler_distance']:
+                return True
+
+        return False
+
+    def _calculate_centrality(self, bbox: List[float], image_shape: Tuple) -> float:
+        """중심성 점수 계산"""
+        h, w = image_shape[:2]
+        image_center = np.array([w / 2, h / 2])
+
+        bbox_center = np.array([
+            (bbox[0] + bbox[2]) / 2,
+            (bbox[1] + bbox[3]) / 2
+        ])
+
+        distance = np.linalg.norm(bbox_center - image_center)
+        max_distance = np.linalg.norm(np.array([w / 2, h / 2]))
+
+        return 1 - (distance / max_distance)
+
+    def _post_process(self, detections: List[Dict], image_shape: Tuple) -> List[Dict]:
+        """후처리: 종합 점수, NMS"""
+
+        # 종합 점수 계산
+        for det in detections:
+            det['composite_score'] = self._calculate_composite_score(det, image_shape)
+
+        # 점수순 정렬
+        detections = sorted(detections, key=lambda x: x['composite_score'], reverse=True)
+
+        # NMS
+        detections = self._apply_nms(detections)
+
+        # 상위 N개
+        return detections[:self.params['top_n']]
+
+    def _calculate_composite_score(self, det: Dict, image_shape: Tuple) -> float:
+        """종합 점수 계산 (0~100)"""
+        score = 0.0
+
+        # 신뢰도 (30%)
+        score += det['confidence'] * 0.30
+
+        # 중심성 (15%)
+        if 'centrality_score' in det:
+            score += det['centrality_score'] * 0.15
+
+        # 종횡비 적합도 (20%)
+        bbox = det['bbox']
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+        if height > 0:
+            aspect_ratio = width / height
+            ideal_aspect = 4.5
+            aspect_fitness = max(0, 1 - abs(aspect_ratio - ideal_aspect) / ideal_aspect)
+            score += aspect_fitness * 0.20
+
+        # 크기 적합도 (20%)
+        h, w = image_shape[:2]
+        bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+        area_ratio = bbox_area / (h * w)
+        size_fitness = 1.0 if 0.10 < area_ratio < 0.30 else 0.5
+        score += size_fitness * 0.20
+
+        # 색상 적합도 (15%)
+        score += 0.15
+
+        return score * 100
+
+    def _apply_nms(self, detections: List[Dict]) -> List[Dict]:
+        """NMS 적용"""
+        if len(detections) <= 1:
+            return detections
+
+        keep = []
+        detections = sorted(detections, key=lambda x: x['confidence'], reverse=True)
+
+        while detections:
+            best = detections.pop(0)
+            keep.append(best)
+
+            filtered = []
+            for det in detections:
+                iou = self._calculate_iou(best['bbox'], det['bbox'])
+                if iou < self.params['nms_iou_threshold']:
+                    filtered.append(det)
+
+            detections = filtered
+
+        return keep
+
+    @staticmethod
+    def _calculate_iou(bbox1: List[float], bbox2: List[float]) -> float:
+        """IoU 계산"""
+        x1_min, y1_min, x1_max, y1_max = bbox1
+        x2_min, y2_min, x2_max, y2_max = bbox2
+
+        inter_x_min = max(x1_min, x2_min)
+        inter_y_min = max(y1_min, y2_min)
+        inter_x_max = min(x1_max, x2_max)
+        inter_y_max = min(y1_max, y2_max)
+
+        if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+            return 0.0
+
+        inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+
+        area1 = (x1_max - x1_min) * (y1_max - y1_min)
+        area2 = (x2_max - x2_min) * (y2_max - y2_min)
+        union_area = area1 + area2 - inter_area
+
+        return inter_area / union_area if union_area > 0 else 0.0
+
+
+# 사용 예시
+if __name__ == "__main__":
+    # RT-DETR 검출 결과 (예시)
+    rtdetr_detections = [
+        {'bbox': [100, 200, 400, 250], 'confidence': 0.85, 'class_id': 1},
+        {'bbox': [50, 50, 100, 500], 'confidence': 0.92, 'class_id': 2},  # 자
+        {'bbox': [200, 300, 350, 380], 'confidence': 0.45, 'class_id': 0},  # 손
+    ]
+
+    # 이미지 로드
+    image = cv2.imread("test_image.jpg")
+
+    # 필터 적용
+    smart_filter = SmartShrimpFilter()
+    shrimp_detections = smart_filter.filter(image, rtdetr_detections)
+
+    print(f"Final shrimp detections: {len(shrimp_detections)}")
+    for i, det in enumerate(shrimp_detections, 1):
+        print(f"  Shrimp #{i}: confidence={det['confidence']:.2f}, score={det['composite_score']:.2f}")
+```
+
+---
+
+## 🧪 테스트 및 검증
+
+### 테스트 시나리오 (MECE)
+
+```
+A. 이미지 유형별
+├── A1. 새우만 (배경 깨끗)
+├── A2. 새우 + 자
+├��─ A3. 새우 + 자 + 손
+├── A4. 새우 + 복잡한 배경
+└── A5. 새우 없음 (Negative)
+
+B. 새우 위치별
+├── B1. 중앙
+├── B2. 좌측
+├── B3. 우측
+├── B4. 상단
+└── B5. 하단
+
+C. 새우 크기별
+├── C1. 작은 새우 (< 8cm)
+├── C2. 중간 새우 (8-12cm)
+└── C3. 큰 새우 (> 12cm)
+
+D. 조명 조건별
+├── D1. 밝은 조명
+├── D2. 어두운 조명
+└── D3. 그림자 포함
+```
+
+### 평가 지표
+
+```python
+def evaluate_performance(predictions, ground_truths):
+    """성능 평가"""
+
+    TP = 0  # True Positive: 새우를 새우로 검출
+    FP = 0  # False Positive: 새우 아닌 것을 새우로 검출
+    FN = 0  # False Negative: 새우를 검출 못함
+
+    # ... IoU 기반 매칭 로직 ...
+
+    precision = TP / (TP + FP) if (TP + FP) > 0 else 0
+    recall = TP / (TP + FN) if (TP + FN) > 0 else 0
+    f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+    return {
+        'precision': precision,
+        'recall': recall,
+        'f1_score': f1_score
+    }
+```
+
+### 파라미터 튜닝
+
+```python
+# 파라미터 그리드 서치
+param_grid = {
+    'min_confidence': [0.10, 0.15, 0.20],
+    'min_aspect_ratio': [1.0, 1.5, 2.0],
+    'max_aspect_ratio': [8.0, 10.0, 12.0],
+    'max_saturation': [100, 120, 150],
+}
+
+best_f1 = 0
+best_params = None
+
+for params in itertools.product(*param_grid.values()):
+    # 테스트...
+    f1 = evaluate(params)
+    if f1 > best_f1:
+        best_f1 = f1
+        best_params = params
+```
+
+---
+
+## 📈 예상 성능
+
+### 시나리오별 정확도
+
+| 시나리오 | 예상 Precision | 예상 Recall | 예상 F1 |
+|---------|---------------|-------------|---------|
+| 새우만 (깨끗) | 85% | 90% | 87% |
+| 새우 + 자 | 75% | 85% | 80% |
+| 새우 + 자 + 손 | 65% | 75% | 70% |
+| 복잡한 배경 | 55% | 65% | 60% |
+| **평균** | **70%** | **79%** | **74%** |
+
+### 속도 (CPU 기준)
+
+- **RT-DETR 추론**: 1.0초
+- **필터링 파이프라인**: 0.3초
+- **총 처리 시간**: ~1.3초/이미지
+
+---
+
+## 🔧 추가 개선 방안
+
+### 단기 (1주)
+1. **파라미터 자동 튜닝**: Grid Search로 최적 파라미터 찾기
+2. **로깅 시스템**: 각 필터 단계별 통계 수집
+3. **실패 사례 분석**: 검출 실패 이미지 분석 및 개선
+
+### 중기 (2-4주)
+1. **앙상블**: 여러 필터 조합 앙상블
+2. **학습 기반 후처리**: 간단한 분류기 추가 (새우 vs 비새우)
+3. **사용자 피드백**: 수동 라벨링 결과 반영
+
+### 장기
+1. **Roboflow 파인튜닝**: 근본적 해결
+2. **자체 모델 학습**: YOLOv8 등
+
+---
+
+## 📚 참고
+
+- [RT-DETR Paper](https://arxiv.org/abs/2304.08069)
+- [COCO Dataset Classes](https://cocodataset.org/#explore)
+- [OpenCV Documentation](https://docs.opencv.org/)
+
+---
+
+**작성일**: 2025-11-07
+**버전**: 1.0 (MECE)
+**작성자**: VIDraft Team

docs/testing_framework_guide.md

@@ -0,0 +1,404 @@
+# 🧪 새우 검출 테스트 프레임워크 가이드
+
+## 📋 개요
+
+이 문서는 RT-DETR + Universal Shrimp Filter 검출 시스템의 테스트 및 검증 프레임워크 사용 가이드입니다.
+
+작성일: 2025-11-09
+
+---
+
+## 🎯 테스트 프레임워크 구성
+
+### 1. **시각적 검증** (`test_visual_validation.py`)
+- **목적**: 검출 결과를 이미지로 시각화하여 빠르게 확인
+- **사용 시기**: 초기 테스트, 파라미터 조정 전후 비교
+- **출력**: 병렬 비교 이미지 (전체 검출 vs 필터링 후)
+
+### 2. **정량적 평가** (`test_quantitative_evaluation.py`)
+- **목적**: Ground Truth와 비교하여 정확도 메트릭 계산
+- **사용 시기**: 정확한 성능 측정, 모델 튜닝
+- **출력**: Precision, Recall, F1 Score, Confusion Matrix, PR Curve
+
+### 3. **대화형 검증** (`interactive_validation.py`)
+- **목적**: 실시간으로 파라미터 조정하며 결과 확인
+- **사용 시기**: 파라미터 최적화, 디버깅
+- **출력**: Gradio 웹 인터페이스
+
+---
+
+## 🚀 사용 방법
+
+### 1️⃣ 시각적 검증 테스트
+
+**실행:**
+```bash
+python test_visual_validation.py
+```
+
+**설정 변경:**
+```python
+run_visual_test(
+    test_image_dir="imgs",      # 테스트 이미지 디렉토리
+    confidence=0.3,             # RT-DETR 신뢰도 (0.1~0.9)
+    filter_threshold=50         # 필터 점수 임계값 (20~80)
+)
+```
+
+**출력:**
+- `test_results/result_*.png` - 시각화 결과 이미지
+- `test_results/test_results_YYYYMMDD_HHMMSS.json` - 상세 검출 정보
+
+**결과 해석:**
+- **왼쪽 이미지**: 전체 검출 (회색 박스) + 필터링 통과 (컬러 박스)
+- **오른쪽 이미지**: 필터링 통과만 표시
+- **색상 의미**:
+  - 🟢 녹색 (75점 이상): 높은 확률로 새우
+  - 🟡 노란색 (50~74점): 중간 확률
+  - 🟠 주황색 (50점 미만): 낮은 확률
+
+---
+
+### 2️⃣ 정량적 평가 테스트
+
+**사전 준비:**
+1. `ground_truth.json` 파일 생성
+2. 수동으로 바운딩 박스 라벨링
+
+**ground_truth.json 형식:**
+```json
+{
+  "test_shrimp_tank.png": [
+    {"bbox": [100, 150, 200, 180], "label": "shrimp"},
+    {"bbox": [300, 250, 420, 290], "label": "shrimp"}
+  ],
+  "image (1).webp": [
+    {"bbox": [500, 600, 800, 700], "label": "shrimp"}
+  ]
+}
+```
+
+**실행:**
+```bash
+python test_quantitative_evaluation.py
+```
+
+**출력:**
+- `test_results/quantitative_*/eval_*.png` - 평가 결과 시각화
+- `test_results/quantitative_*/confusion_matrix.png` - 혼동 행렬
+- `test_results/quantitative_*/evaluation_summary.json` - 평가 요약
+
+**메트릭 해석:**
+- **Precision (정밀도)**: 검출한 것 중 실제 새우 비율 (높을수록 오검출 적음)
+- **Recall (재현율)**: 실제 새우 중 검출한 비율 (높을수록 미검출 적음)
+- **F1 Score**: Precision과 Recall의 조화 평균 (전체 성능 지표)
+
+---
+
+### 3️⃣ 대화형 검증
+
+**실행:**
+```bash
+python interactive_validation.py
+```
+
+**접속:**
+```
+http://localhost:7861
+```
+
+**사용법:**
+
+**탭 1: 🤖 자동 검출**
+1. 이미지 업로드
+2. 슬라이더로 파라미터 조정:
+   - **RT-DETR 신뢰도** (0.1~0.9): 낮을수록 더 많이 검출
+   - **필터 점수 임계값** (20~80): 높을수록 엄격하게 필터링
+3. "전체 검출 결과 표시" 체크박스: 필터링 전후 비교
+4. "🚀 검출 실행" 클릭
+
+**탭 2: 🔬 수동 분석**
+1. 이미지 업로드
+2. 바운딩 박스 좌표 입력 (x1, y1, x2, y2)
+3. "🔍 분석 실행" 클릭
+4. 해당 영역의 특징 분석 결과 확인
+
+---
+
+## 📊 실제 테스트 결과 예시
+
+### 테스트 요약 (2025-11-09)
+
+**설정:**
+- RT-DETR Confidence: 0.3
+- Filter Threshold: 50
+
+**결과:**
+
+| 이미지 | 전체 검출 | 필터링 후 | 필터링률 |
+|--------|----------|-----------|---------|
+| test_shrimp_tank.png | 7개 | 2개 | 71% |
+| 화면 캡처 2025-10-15 142552.png | 3개 | 2개 | 33% |
+| 화면 캡처 2025-10-15 170508.png | 2개 | 1개 | 50% |
+| test_shrimp_tank_roboflow_result.jpg | 8개 | 3개 | 63% |
+| image (1).webp | 2개 | 2개 | 0% |
+| image.webp | 7개 | 1개 | 86% |
+| image_original.webp | 1개 | 1개 | 0% |
+| preview.webp | 7개 | 2개 | 71% |
+
+**평균 필터링률: 47%** (RT-DETR 오검출의 절반을 제거)
+
+---
+
+## 🔧 파라미터 튜닝 가이드
+
+### 검출이 너무 적을 때
+
+**증상:**
+- 실제 새우가 검출되지 않음
+- Recall이 낮음
+
+**해결:**
+1. **RT-DETR 신뢰도 낮추기**: 0.3 → 0.2
+2. **필터 점수 임계값 낮추기**: 50 → 40
+3. **필터 가중치 조정** (고급):
+   ```python
+   # test_visual_validation.py의 apply_universal_filter() 수정
+   # 엄격한 기준 완화
+   if 1.5 <= morph['aspect_ratio'] <= 12.0:  # 기존: 2.0~10.0
+       score += 15
+   ```
+
+### 오검출이 많을 때
+
+**증상:**
+- 새우가 아닌 것도 검출됨
+- Precision이 낮음
+
+**해결:**
+1. **필터 점수 임계값 높이기**: 50 → 60
+2. **RT-DETR 신뢰도 높이기**: 0.3 → 0.4
+3. **필터 조건 강화** (고급):
+   ```python
+   # 채도 조건 강화
+   if visual['saturation'] < 120:  # 기존: 150
+       score += 20
+   ```
+
+### F1 Score가 낮을 때
+
+**원인 분석:**
+1. **RT-DETR 문제**: 검출 자체가 안 됨
+   - 해결: RT-DETR 신뢰도 조정
+2. **필터 문제**: 새우를 잘못 걸러냄
+   - 해결: 필터 조건 완화
+3. **데이터 문제**: 학습 데이터와 테스트 데이터 차이
+   - 해결: 모델 재학습 (Roboflow 측정 이미지 추가)
+
+---
+
+## 📈 성능 목표
+
+### 수조 이미지 (Live Shrimp)
+- **VIDraft/Shrimp 모델** (권장)
+  - Precision: > 95%
+  - Recall: > 90%
+  - F1 Score: > 92%
+
+### 측정 이미지 (Dead Shrimp)
+- **RT-DETR + Universal Filter**
+  - Precision: > 80%
+  - Recall: > 75%
+  - F1 Score: > 77%
+
+### 현재 성능 (추정)
+- 시각적 검증 결과로 볼 때 **F1 ~70%** 예상
+- 정량적 평가 필요 (ground_truth.json 생성 후)
+
+---
+
+## 🎨 필터 점수 구성
+
+총 100점 만점:
+
+| 특징 | 배점 | 조건 |
+|------|------|------|
+| 종횡비 (Aspect Ratio) | 15점 | 2.0 ~ 10.0 |
+| 세장도 (Compactness) | 15점 | < 0.25 |
+| 면적비 (Area Ratio) | 10점 | 5% ~ 50% |
+| 채도 (Saturation) | 20점 | < 150 |
+| 색상 일관성 (Color Std) | 15점 | < 30 |
+| RT-DETR 신뢰도 | 25점 | confidence × 25 |
+
+**합계:** 100점
+
+**임계값:**
+- **75점 이상**: 높은 확률로 새우 ✅
+- **50~74점**: 중간 확률 ⚠️
+- **50점 미만**: 새우 아님 ❌
+
+---
+
+## 🐛 트러블슈팅
+
+### 문제 1: ModuleNotFoundError
+
+**에러:**
+```
+ModuleNotFoundError: No module named 'cv2'
+```
+
+**해결:**
+```bash
+pip install opencv-python matplotlib seaborn transformers torch torchvision
+```
+
+### 문제 2: Ground Truth 파일 없음
+
+**에러:**
+```
+⚠️ Ground truth 파일이 없습니다: ground_truth.json
+```
+
+**해결:**
+1. `ground_truth.json` 파일 생성
+2. 각 이미지의 바운딩 박스 좌표 입력
+3. 좌표는 이미지 뷰어나 Gradio 대화형 도구로 확인
+
+### 문제 3: 모델 다운로드 느림
+
+**증상:**
+RT-DETR 모델 다운로드에 시간이 오래 걸림
+
+**해결:**
+- 처음 한 번만 다운로드됨 (캐시 사용)
+- 네트워크 연결 확인
+- Hugging Face Hub 접속 확인
+
+---
+
+## 📁 파일 구조
+
+```
+D:\Project\VIDraft\Shrimp\
+├── test_visual_validation.py       # 시각적 검증 스크립트
+├── test_quantitative_evaluation.py # 정량적 평가 스크립트
+├── interactive_validation.py       # 대화형 검증 인터페이스
+├── ground_truth.json               # Ground Truth 라벨 (수동 생성)
+├── imgs/                           # 테스트 이미지
+│   ├── test_shrimp_tank.png
+│   ├── image (1).webp
+│   └── ...
+├── test_results/                   # 테스트 결과 (자동 생성)
+│   ├── result_*.png
+│   ├── test_results_*.json
+│   └── quantitative_*/
+│       ├── eval_*.png
+│       ├── confusion_matrix.png
+│       └── evaluation_summary.json
+└── docs/
+    ├── testing_framework_guide.md  # 이 문서
+    └── detection_testing_and_validation.md
+```
+
+---
+
+## 🔄 워크플로우 권장사항
+
+### 1단계: 초기 검증 (시각적)
+```bash
+python test_visual_validation.py
+```
+- 결과 이미지 확인
+- 오검출/미검출 패턴 파악
+
+### 2단계: 파라미터 최적화 (대화형)
+```bash
+python interactive_validation.py
+```
+- 실시간으로 파라미터 조정
+- 최적 설정 찾기
+
+### 3단계: 정확도 측정 (정량적)
+```bash
+# ground_truth.json 생성 후
+python test_quantitative_evaluation.py
+```
+- Precision, Recall, F1 계산
+- 성능 목표 대비 평가
+
+### 4단계: 반복 개선
+- 성능 미달 시 파라미터 재조정
+- 필요 시 필터 로직 수정
+- 재테스트
+
+---
+
+## 📝 추가 개선 사항
+
+### 단기 (즉시 가능)
+1. ✅ 시각적 검증 스크립트 - **완료**
+2. ✅ 정량적 평가 스크립트 - **완료**
+3. ✅ 대화형 검증 인터페이스 - **완료**
+4. ⏳ Ground Truth 데이터 생성 - **진행 필요**
+5. ⏳ 파라미터 튜닝 - **진행 필요**
+
+### 중기 (1-2주)
+1. ⏳ 측정 이미지 50~100장으로 Roboflow 모델 재학습
+2. ⏳ 대규모 데이터셋 테스트 (100+ 이미지)
+3. ⏳ 교차 검증 (Cross-validation) 구현
+
+### 장기 (1개월+)
+1. ⏳ 앙상블 모델 (Roboflow + RT-DETR 조합)
+2. ⏳ 자동 라벨링 도구 개발
+3. ⏳ CI/CD 파이프라인 구축
+
+---
+
+## 🙋 FAQ
+
+### Q1: 몇 개의 테스트 이미지가 필요한가요?
+
+**A:**
+- **최소**: 20~30장 (다양한 배경, 조명, 각도)
+- **권장**: 50~100장 (통계적 신뢰도 확보)
+- **이상적**: 200+ 장 (프로덕션 수준)
+
+### Q2: Ground Truth는 어떻게 만드나요?
+
+**A:**
+1. **수동 방법**: 그림판/포토샵으로 좌표 확인
+2. **대���형 방법**: `interactive_validation.py`의 "수동 분석" 탭 활용
+3. **라벨링 도구**: [LabelImg](https://github.com/tzutalin/labelImg), [CVAT](https://github.com/opencv/cvat) 사용
+4. JSON 형식으로 저장
+
+### Q3: 어떤 테스트를 먼저 해야 하나요?
+
+**A:**
+1. **시작**: 시각적 검증 (빠르고 직관적)
+2. **최적화**: 대화형 검증 (파라미터 찾기)
+3. **검증**: 정량적 평가 (정확도 확인)
+
+### Q4: 필터 점수 임계값은 어떻게 정하나요?
+
+**A:**
+- **보수적 (높은 정밀도)**: 60~70점
+- **균형적 (기본)**: 50점
+- **공격적 (높은 재현율)**: 40~45점
+
+PR Curve를 보고 최적 F1 지점 선택
+
+---
+
+## 📞 문의
+
+프레임워크 관련 문제는 다음을 확인하세요:
+1. 이 문서의 트러블슈팅 섹션
+2. `docs/detection_testing_and_validation.md` (상세 기술 문서)
+3. 각 스크립트의 주석 및 docstring
+
+---
+
+**마지막 업데이트:** 2025-11-09
+**버전:** 1.0
+**작성자:** Claude Code

docs/universal_shrimp_detection_strategy.md

@@ -0,0 +1,883 @@
+# 🎯 범용 새우 검출 전략 (RT-DETR + 본질적 특징 필터링)
+
+## 📋 핵심 원칙
+
+**범용성 (Universality)**
+- ✅ 배경 무관: 매트, 수조, 접시, 손바닥 등 어디든
+- ✅ 주변 객체 무관: 자, 손, 신발 등 없어도 검출
+- ✅ 위치 무관: 이미지 어디든 (중앙, 모서리 등)
+- ✅ 조명 무관: 밝은 곳, 어두운 곳 모두
+- ✅ 크기 무관: 작은 새우부터 큰 새우까지
+
+**핵심 아이디어**
+> **"새우의 본질적 특징만으로 구별"**
+> - 외부 컨텍스트(자, 매트 등)에 의존하지 않음
+> - 새우 자체의 형태학적/시각적 특징 활용
+
+---
+
+## 🔬 새우의 본질적 특징 (Intrinsic Features)
+
+### 1. 형태학적 특징 (Morphological)
+
+```
+새우 형태의 불변 특성 (배경/위치 무관)
+├── 1.1 세장형 (Elongated)
+│   ├── 종횡비: 2:1 ~ 10:1 (가로로 길다)
+│   └── 대칭성: 좌우 대칭
+│
+├── 1.2 분절 구조 (Segmented Body)
+│   ├── 머리-가슴-꼬리 3분할
+│   └── 주기적 패턴 (마디)
+│
+├── 1.3 곡선형 외곽선 (Curved Contour)
+│   ├── 부드러운 곡선 (직선 없음)
+│   └── 'C자' 또는 'ㄱ자' 형태 (죽은 새우)
+│
+└── 1.4 크기 범위
+    ├── 절대 크기: 3cm ~ 20cm (실제)
+    └── 이미지 내 비율: 5% ~ 40%
+```
+
+### 2. 시각적 특징 (Visual)
+
+```
+새우 외형의 불변 특성
+├── 2.1 색상 (Color)
+│   ├── 살아있음: 회색/갈색 (낮은 채도)
+│   ├── 죽음: 흰색/투명 (매우 낮은 채도)
+│   └── 공통: 단색 또는 미세한 그라데이션
+│
+├── 2.2 투명도/반투명 (Translucency)
+│   ├── 죽은 새우: 높은 투명도
+│   └── 배경이 비침
+│
+├── 2.3 텍스처 (Texture)
+│   ├── 부드러운 표면 (낮은 표준편차)
+│   ├── 미세한 줄무늬 (분절)
+│   └── 광택 (하이라이트)
+│
+└── 2.4 경계선 (Boundary)
+    ├── 부드러운 에지 (soft edge)
+    └── 명확한 실루엣
+```
+
+### 3. 구조적 특징 (Structural)
+
+```
+새우 내부 구조 (죽은 새우 특화)
+├── 3.1 내부 장기 가시성
+│   ├── 검은 선 (소화관)
+│   └── 투명한 몸체 내부 구조
+│
+├── 3.2 다리/더듬이
+│   ├── 가는 선 형태
+│   └── 몸체에서 방사형으로 뻗음
+│
+└── 3.3 꼬리 부채 구조
+    └── 부채꼴 펼쳐진 형태
+```
+
+---
+
+## 🏗️ 범용 필터링 전략 (MECE)
+
+### Level 1: 필터 분류 (배경 의존도 기준)
+
+```
+배경 독립 필터 (Background-Independent) ⭐⭐⭐
+├── 형태 필터 (Shape Filter)
+├── 색상 필터 (Color Filter)
+└── 텍스처 필터 (Texture Filter)
+
+배경 의존 필터 (Background-Dependent) ⚠️
+└── 사용 안 함 (범용성 저해)
+```
+
+### Level 2: 필터링 파이프라인 (3단계)
+
+```
+Step 1: 형태 기반 1차 필터 (Shape-based Primary Filter)
+  → 새우와 명백히 다른 형태 제거
+  → 종횡비, 크기, 외곽선 곡률
+
+Step 2: 색상/텍스처 기반 2차 필터 (Visual Secondary Filter)
+  → 새우의 시각적 특징으로 검증
+  → HSV 색공간, 텍스처 분석
+
+Step 3: 정밀 검증 (Fine-grained Verification)
+  → 구조적 특징으로 최종 확인
+  → 내부 구조, 분절 패턴
+```
+
+---
+
+## 💻 범용 필터 구현
+
+### Step 1: 형태 기반 1차 필터
+
+#### 1.1 종횡비 필터 (Aspect Ratio)
+
+**원리**: 새우는 항상 가로로 길다 (배경 무관)
+
+```python
+def filter_by_aspect_ratio(detections, min_ratio=2.0, max_ratio=10.0):
+    """
+    종횡비 필터
+
+    Args:
+        min_ratio: 최소 가로/세로 비율 (기본 2.0)
+        max_ratio: 최대 가로/세로 비율 (기본 10.0)
+    """
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+
+        if height == 0:
+            continue
+
+        # 가로/세로 비율 계산
+        aspect_ratio = width / height
+
+        # 세로로 긴 경우도 고려 (새우가 세로로 놓인 경우)
+        if aspect_ratio < 1.0:
+            aspect_ratio = 1.0 / aspect_ratio
+
+        # 범위 체크
+        if min_ratio <= aspect_ratio <= max_ratio:
+            det['aspect_ratio'] = aspect_ratio
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 1.2 외곽선 곡률 필터 (Contour Curvature)
+
+**원리**: 새우는 부드러운 곡선, 자나 책 등은 직선
+
+```python
+def filter_by_curvature(image, detections, max_line_ratio=0.3):
+    """
+    외곽선 곡률 필터
+
+    Args:
+        max_line_ratio: 최대 직선 비율 (0~1)
+    """
+    import cv2
+    import numpy as np
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        # ROI 추출
+        roi = gray[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        # 외곽선 검출
+        _, binary = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        if not contours:
+            continue
+
+        # 가장 큰 외곽선
+        contour = max(contours, key=cv2.contourArea)
+
+        # 외곽선 근사 (직선 검출)
+        epsilon = 0.02 * cv2.arcLength(contour, True)
+        approx = cv2.approxPolyDP(contour, epsilon, True)
+
+        # 직선 비율 = 근사 점 개수 / 원본 점 개수
+        line_ratio = len(approx) / len(contour) if len(contour) > 0 else 1.0
+
+        # 부드러운 곡선 = 직선 비율 낮음
+        if line_ratio < max_line_ratio:
+            det['curvature_score'] = 1.0 - line_ratio
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 1.3 컴팩트니스 필터 (Compactness)
+
+**원리**: 새우는 세장형이므로 compactness가 낮음
+
+```python
+def filter_by_compactness(image, detections, max_compactness=0.25):
+    """
+    컴팩트니스 필터
+
+    Compactness = 4π × Area / Perimeter²
+    - 원: 1.0
+    - 정사각형: 0.785
+    - 세장형: < 0.3
+
+    Args:
+        max_compactness: 최대 컴팩트니스 (기본 0.25)
+    """
+    import cv2
+    import numpy as np
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi = gray[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        # 외곽선 검출
+        _, binary = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        if not contours:
+            continue
+
+        contour = max(contours, key=cv2.contourArea)
+        area = cv2.contourArea(contour)
+        perimeter = cv2.arcLength(contour, True)
+
+        if perimeter == 0:
+            continue
+
+        # 컴팩트니스 계산
+        compactness = (4 * np.pi * area) / (perimeter ** 2)
+
+        # 세장형 = 낮은 컴팩트니스
+        if compactness < max_compactness:
+            det['compactness'] = compactness
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 1.4 크기 적응형 필터 (Adaptive Size Filter)
+
+**원리**: 이미지 해상도에 따라 적응적으로 크기 판단
+
+```python
+def filter_by_adaptive_size(detections, image_shape, min_ratio=0.05, max_ratio=0.50):
+    """
+    적응형 크기 필터
+
+    Args:
+        min_ratio: 최소 면적 비율 (이미지의 5%)
+        max_ratio: 최대 면적 비율 (이미지의 50%)
+    """
+    h, w = image_shape[:2]
+    image_area = h * w
+
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+        area_ratio = bbox_area / image_area
+
+        # 너무 작거나 크면 제외
+        if min_ratio <= area_ratio <= max_ratio:
+            det['area_ratio'] = area_ratio
+            filtered.append(det)
+
+    return filtered
+```
+
+---
+
+### Step 2: 색상/텍스처 기반 2차 필터
+
+#### 2.1 색상 일관성 필터 (Color Consistency)
+
+**원리**: 새우는 단색 또는 미세한 그라데이션 (강한 패턴 없음)
+
+```python
+def filter_by_color_consistency(image, detections, max_std=50):
+    """
+    색상 일관성 필터
+
+    Args:
+        max_std: 최대 색상 표준편차 (단색에 가까움)
+    """
+    import cv2
+    import numpy as np
+
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi_hsv = hsv_image[y1:y2, x1:x2]
+        if roi_hsv.size == 0:
+            continue
+
+        # 색상(H), 채도(S), 명도(V) 표준편차
+        h_std = np.std(roi_hsv[:, :, 0])
+        s_std = np.std(roi_hsv[:, :, 1])
+        v_std = np.std(roi_hsv[:, :, 2])
+
+        # 평균 표준편차
+        avg_std = (h_std + s_std + v_std) / 3
+
+        # 단색에 가까움 = 낮은 표준편차
+        if avg_std < max_std:
+            det['color_consistency'] = 1.0 - (avg_std / max_std)
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 2.2 채도 기반 필터 (Saturation-based)
+
+**원리**: 죽은 새우 = 매우 낮은 채도 (흰색/회색)
+
+```python
+def filter_by_saturation(image, detections, max_saturation=150):
+    """
+    채도 필터 (죽은 새우 전용)
+
+    Args:
+        max_saturation: 최대 채도 (0~255)
+    """
+    import cv2
+
+    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi_hsv = hsv_image[y1:y2, x1:x2]
+        if roi_hsv.size == 0:
+            continue
+
+        # 평균 채도
+        mean_saturation = roi_hsv[:, :, 1].mean()
+
+        # 낮은 채도 = 죽은 새우
+        if mean_saturation < max_saturation:
+            det['saturation_score'] = 1.0 - (mean_saturation / 255)
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 2.3 텍스처 균질성 필터 (Texture Homogeneity)
+
+**원리**: 새우는 부드러운 텍스처 (자나 매트는 강한 패턴)
+
+```python
+def filter_by_texture_homogeneity(image, detections, max_texture_std=40):
+    """
+    텍스처 균질성 필터
+
+    Args:
+        max_texture_std: 최대 텍스처 표준편차
+    """
+    import cv2
+    import numpy as np
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi = gray[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        # 텍스처 복잡도 (표준편차)
+        texture_std = np.std(roi)
+
+        # 부드러운 텍스처 = 낮은 표준편차
+        if texture_std < max_texture_std:
+            det['texture_homogeneity'] = 1.0 - (texture_std / 100)
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 2.4 에지 패턴 필터 (Edge Pattern)
+
+**원리**: 새우는 부드러운 곡선 에지 (직선 에지 없음)
+
+```python
+def filter_by_edge_pattern(image, detections, min_edge_smoothness=0.6):
+    """
+    에지 패턴 필터
+
+    Args:
+        min_edge_smoothness: 최소 에지 부드러움 (0~1)
+    """
+    import cv2
+    import numpy as np
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    edges = cv2.Canny(gray, 50, 150)
+
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi_edges = edges[y1:y2, x1:x2]
+        if roi_edges.size == 0:
+            continue
+
+        # Hough Line 변환으로 직선 검출
+        lines = cv2.HoughLinesP(roi_edges, 1, np.pi/180, threshold=30,
+                                minLineLength=20, maxLineGap=5)
+
+        # 직선 개수
+        num_lines = len(lines) if lines is not None else 0
+
+        # 에지 픽셀 개수
+        total_edges = np.sum(roi_edges > 0)
+
+        if total_edges == 0:
+            continue
+
+        # 직선 비율 = 직선 개수 / 총 에지 픽셀
+        # (낮을수록 곡선형)
+        line_ratio = num_lines / (total_edges / 100)  # 정규화
+
+        edge_smoothness = max(0, 1.0 - line_ratio)
+
+        if edge_smoothness > min_edge_smoothness:
+            det['edge_smoothness'] = edge_smoothness
+            filtered.append(det)
+
+    return filtered
+```
+
+---
+
+### Step 3: 정밀 검증
+
+#### 3.1 내부 구조 검증 (Internal Structure)
+
+**원리**: 죽은 새우는 투명하여 내부 소화관(검은 선) 보임
+
+```python
+def verify_internal_structure(image, detections, threshold=0.3):
+    """
+    내부 구조 검증 (죽은 새우 전용)
+
+    Args:
+        threshold: 검은 선 검출 임계값
+    """
+    import cv2
+    import numpy as np
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi = gray[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        # 어두운 픽셀 (소화관) 비율
+        dark_pixels = np.sum(roi < 100)
+        total_pixels = roi.size
+        dark_ratio = dark_pixels / total_pixels
+
+        # 적당한 어두운 영역 (소화관)
+        if 0.05 < dark_ratio < 0.40:
+            det['internal_structure_score'] = dark_ratio
+            filtered.append(det)
+        else:
+            # 내부 구조 없어도 통과 (투명하지 않은 새우)
+            filtered.append(det)
+
+    return filtered
+```
+
+#### 3.2 대칭성 검증 (Symmetry)
+
+**원리**: 새우는 좌우 대칭 (위아래는 비대칭)
+
+```python
+def verify_symmetry(image, detections, min_symmetry=0.6):
+    """
+    대칭성 검증
+
+    Args:
+        min_symmetry: 최소 대칭성 점수 (0~1)
+    """
+    import cv2
+    import numpy as np
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+        x1, y1, x2, y2 = map(int, bbox)
+
+        roi = gray[y1:y2, x1:x2]
+        if roi.size == 0:
+            continue
+
+        h, w = roi.shape
+
+        # 좌우 대칭 비교
+        left_half = roi[:, :w//2]
+        right_half = roi[:, w//2:]
+        right_half_flipped = np.fliplr(right_half)
+
+        # 크기 맞추기
+        min_width = min(left_half.shape[1], right_half_flipped.shape[1])
+        left_half = left_half[:, :min_width]
+        right_half_flipped = right_half_flipped[:, :min_width]
+
+        # 상관계수 (대칭도)
+        correlation = np.corrcoef(left_half.flatten(), right_half_flipped.flatten())[0, 1]
+
+        if not np.isnan(correlation) and correlation > min_symmetry:
+            det['symmetry_score'] = correlation
+            filtered.append(det)
+
+    return filtered
+```
+
+---
+
+## 🔗 통합 파이프라인
+
+```python
+class UniversalShrimpFilter:
+    """범용 새우 검출 필터 (배경/위치 무관)"""
+
+    def __init__(self):
+        # 파라미터 (조정 가능)
+        self.params = {
+            # Step 1: 형태 필터
+            'min_aspect_ratio': 2.0,
+            'max_aspect_ratio': 10.0,
+            'max_line_ratio': 0.3,
+            'max_compactness': 0.25,
+            'min_area_ratio': 0.05,
+            'max_area_ratio': 0.50,
+
+            # Step 2: 색상/텍스처 필터
+            'max_color_std': 50,
+            'max_saturation': 150,
+            'max_texture_std': 40,
+            'min_edge_smoothness': 0.6,
+
+            # Step 3: 정밀 검증
+            'min_symmetry': 0.6,
+
+            # 종합
+            'min_total_score': 60,  # 0~100
+        }
+
+    def filter(self, image, detections):
+        """
+        범용 필터링 파이프라인
+
+        Args:
+            image: 입력 이미지 (BGR)
+            detections: RT-DETR 검출 결과
+
+        Returns:
+            필터링된 검출 (새우만)
+        """
+        import numpy as np
+
+        print(f"[INFO] Initial detections: {len(detections)}")
+
+        # Step 1: 형태 필터
+        detections = filter_by_aspect_ratio(
+            detections,
+            self.params['min_aspect_ratio'],
+            self.params['max_aspect_ratio']
+        )
+        print(f"[STEP 1-1] After aspect ratio filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        detections = filter_by_curvature(
+            image, detections,
+            self.params['max_line_ratio']
+        )
+        print(f"[STEP 1-2] After curvature filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        detections = filter_by_compactness(
+            image, detections,
+            self.params['max_compactness']
+        )
+        print(f"[STEP 1-3] After compactness filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        detections = filter_by_adaptive_size(
+            detections, image.shape,
+            self.params['min_area_ratio'],
+            self.params['max_area_ratio']
+        )
+        print(f"[STEP 1-4] After size filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        # Step 2: 색상/텍스처 필터
+        detections = filter_by_color_consistency(
+            image, detections,
+            self.params['max_color_std']
+        )
+        print(f"[STEP 2-1] After color consistency filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        detections = filter_by_saturation(
+            image, detections,
+            self.params['max_saturation']
+        )
+        print(f"[STEP 2-2] After saturation filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        detections = filter_by_texture_homogeneity(
+            image, detections,
+            self.params['max_texture_std']
+        )
+        print(f"[STEP 2-3] After texture filter: {len(detections)}")
+
+        if not detections:
+            return []
+
+        # Step 3: 정밀 검증 (선택적)
+        detections = verify_internal_structure(image, detections)
+        print(f"[STEP 3-1] After internal structure verify: {len(detections)}")
+
+        detections = verify_symmetry(
+            image, detections,
+            self.params['min_symmetry']
+        )
+        print(f"[STEP 3-2] After symmetry verify: {len(detections)}")
+
+        # 종합 점수 계산 및 최종 선택
+        detections = self._calculate_total_scores(detections)
+        detections = [d for d in detections if d['total_score'] >= self.params['min_total_score']]
+        detections = sorted(detections, key=lambda x: x['total_score'], reverse=True)
+
+        print(f"[FINAL] After scoring: {len(detections)}")
+
+        return detections[:1] if detections else []  # 상위 1개
+
+    def _calculate_total_scores(self, detections):
+        """종합 점수 계산 (0~100)"""
+
+        # 가중치
+        WEIGHTS = {
+            'aspect_ratio': 0.15,
+            'curvature': 0.15,
+            'compactness': 0.10,
+            'area_ratio': 0.10,
+            'color_consistency': 0.15,
+            'saturation': 0.10,
+            'texture_homogeneity': 0.10,
+            'edge_smoothness': 0.05,
+            'symmetry': 0.10,
+        }
+
+        for det in detections:
+            score = 0.0
+
+            # 각 점수 합산
+            if 'aspect_ratio' in det:
+                # 이상적 종횡비에 가까울수록 높은 점수
+                ideal_aspect = 4.5
+                fitness = max(0, 1 - abs(det['aspect_ratio'] - ideal_aspect) / ideal_aspect)
+                score += fitness * WEIGHTS['aspect_ratio']
+
+            if 'curvature_score' in det:
+                score += det['curvature_score'] * WEIGHTS['curvature']
+
+            if 'compactness' in det:
+                # 낮을수록 좋음
+                fitness = max(0, 1 - det['compactness'] / 0.25)
+                score += fitness * WEIGHTS['compactness']
+
+            if 'area_ratio' in det:
+                # 이상적 크기: 15% 정도
+                ideal_area = 0.15
+                fitness = max(0, 1 - abs(det['area_ratio'] - ideal_area) / ideal_area)
+                score += fitness * WEIGHTS['area_ratio']
+
+            if 'color_consistency' in det:
+                score += det['color_consistency'] * WEIGHTS['color_consistency']
+
+            if 'saturation_score' in det:
+                score += det['saturation_score'] * WEIGHTS['saturation']
+
+            if 'texture_homogeneity' in det:
+                score += det['texture_homogeneity'] * WEIGHTS['texture_homogeneity']
+
+            if 'edge_smoothness' in det:
+                score += det['edge_smoothness'] * WEIGHTS['edge_smoothness']
+
+            if 'symmetry_score' in det:
+                score += det['symmetry_score'] * WEIGHTS['symmetry']
+
+            det['total_score'] = score * 100
+
+        return detections
+
+
+# 사용 예시
+if __name__ == "__main__":
+    import cv2
+
+    # 이미지 로드
+    image = cv2.imread("shrimp_image.jpg")
+
+    # RT-DETR 검출 (가상)
+    rtdetr_detections = [
+        {'bbox': [100, 200, 500, 280], 'confidence': 0.85, 'class_id': 1},
+        {'bbox': [50, 50, 150, 500], 'confidence': 0.92, 'class_id': 2},  # 자 (제거됨)
+    ]
+
+    # 범용 필터 적용
+    universal_filter = UniversalShrimpFilter()
+    shrimp_detections = universal_filter.filter(image, rtdetr_detections)
+
+    print(f"\n✅ Final shrimp detections: {len(shrimp_detections)}")
+    for i, det in enumerate(shrimp_detections, 1):
+        print(f"  Shrimp #{i}: score={det['total_score']:.2f}/100")
+```
+
+---
+
+## 📊 범용성 검증 시나리오
+
+### 배경 유형별 테스트 (MECE)
+
+```
+A. 배경 유형
+├── A1. 측정 매트 (파란색)
+├── A2. 흰색 접시
+├── A3. 나무 도마
+├── A4. 손바닥
+├── A5. 수조 (물속)
+└── A6. 복잡한 배경 (잡지, 신문 등)
+
+B. 주변 객체
+├── B1. 새우만
+├── B2. 새우 + 자
+├── B3. 새우 + 손
+├── B4. 새우 + 다양한 물체
+└── B5. 새우 없음 (Negative)
+
+C. 새우 위치
+├── C1. 중앙
+├── C2. 모서리
+├── C3. 가장자리
+└── C4. 여러 마리 (산재)
+```
+
+### 예상 성능
+
+| 시나리오 | Precision | Recall | F1 |
+|---------|-----------|--------|-----|
+| 매트 위 (깨끗) | 85% | 90% | 87% |
+| 접시 위 | 80% | 85% | 82% |
+| 손바닥 위 | 75% | 80% | 77% |
+| 복잡한 배경 | 60% | 70% | 65% |
+| **평균** | **75%** | **81%** | **78%** |
+
+---
+
+## 🎯 핵심 장점
+
+### ✅ 범용성 (Universality)
+1. **배경 독립**: 매트, 접시, 손바닥 등 어디든
+2. **객체 독립**: 자, 손 등 주변 객체 불필요
+3. **위치 독립**: 이미지 어디에 있든 검출
+4. **크기 독립**: 작은/큰 새우 모두 검출
+
+### ✅ 강건성 (Robustness)
+1. **조명 변화**: HSV 색공간으로 조명 무관
+2. **회전 변화**: 종횡비는 방향 고려
+3. **스케일 변화**: 적응형 크기 필터
+
+### ✅ 정밀성 (Precision)
+1. **다단계 필터**: 형태 → 색상 → 구조
+2. **종합 점수**: 여러 특징의 가중 평균
+3. **임계값 조정**: 상황에 맞게 파라미터 튜닝
+
+---
+
+## 🔧 파라미터 튜닝 가이드
+
+```python
+# 검출 안 됨 (Recall 낮음)
+→ 임계값 완화
+    - min_aspect_ratio: 2.0 → 1.5
+    - max_compactness: 0.25 → 0.30
+    - min_total_score: 60 → 50
+
+# 과다 검출 (Precision 낮음)
+→ 임계값 강화
+    - min_aspect_ratio: 2.0 → 2.5
+    - max_saturation: 150 → 120
+    - min_total_score: 60 → 70
+
+# 속도 개선
+→ 필터 순서 최적화
+    1. 가장 빠르고 효과적인 필터 먼저
+    2. 비용 높은 필터(외곽선, 대칭성)는 후반
+```
+
+---
+
+## 📈 성능 비교
+
+| 전략 | 범용성 | 정확도 | 속도 | 구현 난이도 |
+|------|-------|--------|------|------------|
+| **컨텍스트 의존** (자, 매트 등) | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
+| **본질적 특징 기반** (현재) | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
+| **Roboflow 파인튜닝** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
+
+---
+
+## 🚀 다음 단계
+
+1. **즉시 구현**: 범용 필터 코드 적용
+2. **테스트**: 다양한 배경/위치 이미지로 검증
+3. **튜닝**: 파라미터 최적화
+4. **중기**: Roboflow 파인튜닝으로 정확도 향상
+
+---
+
+**작성일**: 2025-11-07
+**버전**: 2.0 (Universal)
+**작성자**: VIDraft Team

interactive_validation.py

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*-
+"""
+대화형 검증 인터페이스
+실시간으로 파라미터를 조정하며 검출 결과 확인
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+from test_visual_validation import (
+    load_rtdetr_model,
+    detect_with_rtdetr,
+    apply_universal_filter,
+    calculate_morphological_features,
+    calculate_visual_features
+)
+
+# 전역 모델 (한 번만 로드)
+processor, model = load_rtdetr_model()
+
+def interactive_detect(image, confidence, filter_threshold, show_all=False):
+    """대화형 검출"""
+    if image is None:
+        return None, "⚠️ 이미지를 업로드하세요."
+
+    try:
+        # RT-DETR 검출
+        all_detections = detect_with_rtdetr(image, processor, model, confidence)
+
+        # 필터 적용
+        filtered_detections = apply_universal_filter(all_detections, image, 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()
+
+        # 전체 검출 표시 (옵션)
+        if show_all:
+            for det in all_detections:
+                x1, y1, x2, y2 = det['bbox']
+                draw.rectangle([x1, y1, x2, y2], outline="gray", width=1)
+
+        # 필터링된 결과
+        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)
+
+            # 라벨
+            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, fill="black", font=font)
+
+            # 세부 정보 (작게) - RT-DETR 신뢰도 명시
+            details = f"RT-DETR:{det['confidence']:.0%}"
+            draw.text((x1, y2 + 5), details, fill=color, font=font_small)
+
+        # 헤더
+        header = f"검출: {len(filtered_detections)}개 (전체: {len(all_detections)}개)"
+        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"""
+### 📊 검출 결과
+
+- **전체 검출**: {len(all_detections)}개
+- **필터링 후**: {len(filtered_detections)}개
+- **제거됨**: {len(all_detections) - len(filtered_detections)}개
+
+---
+
+### 🎯 검출된 객체 상세
+
+"""
+
+        for idx, det in enumerate(filtered_detections, 1):
+            info += f"""
+**#{idx} - 점수: {det['filter_score']:.0f}점** (RT-DETR 신뢰도: {det['confidence']:.0%})
+
+"""
+            # 주요 특징만 3개
+            for reason in det['filter_reasons'][:3]:
+                info += f"- {reason}\n"
+
+        if not filtered_detections:
+            info += """
+⚠️ **검출된 객체가 없습니다.**
+
+**조정 방법:**
+1. **신뢰도 임계값**을 낮춰보세요 (0.2~0.3)
+2. **필터 점수 임계값**을 낮춰보세요 (30~40)
+3. "전체 검출 표시"를 켜서 원본 검출 결과를 확인하세요
+"""
+
+        info += f"""
+
+---
+
+### ⚙️ 현재 설정
+
+- **RT-DETR 신뢰도**: {confidence:.0%}
+- **필터 점수 임계값**: {filter_threshold}점
+- **전체 검출 표시**: {'켜짐' if show_all else '꺼짐'}
+"""
+
+        return img, info
+
+    except Exception as e:
+        import traceback
+        error_detail = traceback.format_exc()
+        return None, f"❌ 오류 발생:\n\n```\n{error_detail}\n```"
+
+def analyze_single_detection(image, x1, y1, x2, y2):
+    """단일 검출 영역 분석 (수동 바운딩 박스)"""
+    if image is None:
+        return "⚠️ 이미지를 업로드하세요."
+
+    try:
+        bbox = [float(x1), float(y1), float(x2), float(y2)]
+
+        # 형태학적 특징
+        morph = calculate_morphological_features(bbox, image.size)
+
+        # 시각적 특징
+        visual = calculate_visual_features(image, bbox)
+
+        analysis = f"""
+### 🔬 바운딩 박스 분석
+
+**좌표**: ({x1:.0f}, {y1:.0f}) → ({x2:.0f}, {y2:.0f})
+
+---
+
+### 📐 형태학적 특징
+
+- **종횡비**: {morph['aspect_ratio']:.2f} {'✅ (2~10 범위)' if 2 <= morph['aspect_ratio'] <= 10 else '❌'}
+- **세장도 (Compactness)**: {morph['compactness']:.3f} {'✅ (<0.25)' if morph['compactness'] < 0.25 else '❌'}
+- **면적비**: {morph['area_ratio']*100:.1f}% {'✅ (5~50%)' if 0.05 <= morph['area_ratio'] <= 0.5 else '❌'}
+- **너비×높이**: {morph['width']:.0f} × {morph['height']:.0f}
+
+---
+
+### 🎨 시각적 특징
+
+- **채도 (Saturation)**: {visual['saturation']:.0f} {'✅ (<150)' if visual['saturation'] < 150 else '❌'}
+- **색상 일관성 (Std)**: {visual['color_std']:.1f} {'✅ (<30)' if visual['color_std'] < 30 else '❌'}
+
+---
+
+### 💯 예상 점수
+
+"""
+        # 점수 계산
+        score = 0
+        if 2.0 <= morph['aspect_ratio'] <= 10.0:
+            score += 15
+        if morph['compactness'] < 0.25:
+            score += 15
+        if 0.05 <= morph['area_ratio'] <= 0.50:
+            score += 10
+        if visual['saturation'] < 150:
+            score += 20
+        if visual['color_std'] < 30:
+            score += 15
+
+        analysis += f"**총점**: {score}/75점 (RT-DETR 신뢰도 제외)\n\n"
+
+        if score >= 50:
+            analysis += "✅ **판정**: 새우로 분류될 가능성이 높습니다."
+        else:
+            analysis += "❌ **판정**: 새우가 아닐 가능성이 높습니다."
+
+        return analysis
+
+    except Exception as e:
+        return f"❌ 오류: {str(e)}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="🧪 새우 검출 대화형 검증", theme=gr.themes.Soft()) as demo:
+
+    gr.Markdown("""
+    # 🧪 새우 검출 대화형 검증 도구
+
+    실시간으로 파라미터를 조정하며 검출 결과를 확인할 수 있습니다.
+
+    ---
+    """)
+
+    with gr.Tabs():
+        # 탭 1: 자동 검출
+        with gr.TabItem("🤖 자동 검출"):
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.Image(label="입력 이미지", type="pil")
+
+                    confidence_slider = gr.Slider(
+                        0.1, 0.9, 0.3,
+                        label="RT-DETR 신뢰도 임계값",
+                        info="낮을수록 더 많이 검출"
+                    )
+
+                    filter_slider = gr.Slider(
+                        20, 80, 50,
+                        label="필터 점수 임계값",
+                        info="높을수록 엄격하게 필터링"
+                    )
+
+                    show_all_check = gr.Checkbox(
+                        label="전체 검출 결과 표시 (회색)",
+                        value=False
+                    )
+
+                    detect_btn = gr.Button("🚀 검출 실행", variant="primary", size="lg")
+
+                    # 예제 이미지 추가
+                    import os
+                    import glob
+                    example_images = sorted(glob.glob("data/251015/251015_*.jpg"))
+                    if example_images:
+                        # 처음 5개만 예제로 표시
+                        examples_list = [[img, 0.3, 75, False] for img in example_images[:5]]
+                        gr.Examples(
+                            examples=examples_list,
+                            inputs=[input_image, confidence_slider, filter_slider, show_all_check],
+                            label="📷 예제 이미지 (클릭하여 바로 테스트)"
+                        )
+
+                with gr.Column():
+                    output_image = gr.Image(label="검출 결과")
+                    output_info = gr.Markdown()
+
+            detect_btn.click(
+                interactive_detect,
+                [input_image, confidence_slider, filter_slider, show_all_check],
+                [output_image, output_info]
+            )
+
+            gr.Markdown("""
+            ### 💡 사용 팁
+
+            - **검출이 너무 적을 때**: 신뢰도와 필터 점수를 낮추세요
+            - **오검출이 많을 때**: 필터 점수를 높이세요
+            - **파라미터 효과 확인**: "전체 검출 표시"를 켜서 필터링 전후를 비교하세요
+            """)
+
+        # 탭 2: 수동 분석
+        with gr.TabItem("🔬 수동 분석"):
+            gr.Markdown("""
+            수동으로 바운딩 박스를 지정하여 해당 영역의 특징을 분석합니다.
+            이미지 좌표를 직접 입력하세요.
+            """)
+
+            with gr.Row():
+                with gr.Column():
+                    manual_image = gr.Image(label="분석할 이미지", type="pil")
+
+                    with gr.Row():
+                        x1_input = gr.Number(label="x1 (좌상단 X)", value=0)
+                        y1_input = gr.Number(label="y1 (좌상단 Y)", value=0)
+
+                    with gr.Row():
+                        x2_input = gr.Number(label="x2 (우하단 X)", value=100)
+                        y2_input = gr.Number(label="y2 (우하단 Y)", value=100)
+
+                    analyze_btn = gr.Button("🔍 분석 실행", variant="secondary", size="lg")
+
+                with gr.Column():
+                    analysis_output = gr.Markdown()
+
+            analyze_btn.click(
+                analyze_single_detection,
+                [manual_image, x1_input, y1_input, x2_input, y2_input],
+                analysis_output
+            )
+
+            gr.Markdown("""
+            ### 📝 좌표 확인 방법
+
+            이미지 뷰어나 그림판에서 픽셀 좌표를 확인할 수 있습니다:
+            - **x1, y1**: 바운딩 박스 좌상단 좌표
+            - **x2, y2**: 바운딩 박스 우하단 좌표
+            """)
+
+    gr.Markdown("""
+    ---
+
+    ### 📖 필터 점수 기준
+
+    - **75점 이상**: 높은 확률로 새우 (녹색)
+    - **50~74점**: 중간 확률 (노란색)
+    - **50점 미만**: 낮은 확률 (주황색)
+
+    **점수 구성** (총 100점):
+    - 종횡비 (2~10): 15점
+    - 세장도 (<0.25): 15점
+    - 면적비 (5~50%): 10점
+    - 채도 (<150): 20점
+    - 색상 일관성 (<30): 15점
+    - RT-DETR 신뢰도: 최대 25점
+    """)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7861,  # 메인 앱과 다른 포트
+        share=False
+    )

requirements.txt

@@ -8,6 +8,9 @@ transformers>=4.41.0
 
 # Image Processing
 pillow>=10.0.0
+opencv-python>=4.8.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
 
 # Inference
 inference-sdk>=0.9.0

test_quantitative_evaluation.py

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+"""
+정량적 평가 스크립트
+Ground Truth와 비교하여 Precision, Recall, F1 Score 계산
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import os
+import json
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+from test_visual_validation import (
+    load_rtdetr_model,
+    detect_with_rtdetr,
+    apply_universal_filter
+)
+
+def calculate_iou(bbox1, bbox2):
+    """IoU (Intersection over Union) 계산"""
+    x1_min, y1_min, x1_max, y1_max = bbox1
+    x2_min, y2_min, x2_max, y2_max = bbox2
+
+    # 교집합 영역
+    inter_x_min = max(x1_min, x2_min)
+    inter_y_min = max(y1_min, y2_min)
+    inter_x_max = min(x1_max, x2_max)
+    inter_y_max = min(y1_max, y2_max)
+
+    if inter_x_max < inter_x_min or inter_y_max < inter_y_min:
+        return 0.0
+
+    inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+
+    # 합집합 영역
+    bbox1_area = (x1_max - x1_min) * (y1_max - y1_min)
+    bbox2_area = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = bbox1_area + bbox2_area - inter_area
+
+    return inter_area / union_area if union_area > 0 else 0.0
+
+def evaluate_detection(predictions, ground_truths, iou_threshold=0.5):
+    """검출 결과 평가"""
+    tp = 0  # True Positive
+    fp = 0  # False Positive
+    fn = 0  # False Negative
+
+    matched_gt = set()
+
+    # 각 예측에 대해
+    for pred in predictions:
+        pred_bbox = pred['bbox']
+        matched = False
+
+        # Ground truth와 매칭
+        for gt_idx, gt in enumerate(ground_truths):
+            if gt_idx in matched_gt:
+                continue
+
+            gt_bbox = gt['bbox']
+            iou = calculate_iou(pred_bbox, gt_bbox)
+
+            if iou >= iou_threshold:
+                tp += 1
+                matched_gt.add(gt_idx)
+                matched = True
+                break
+
+        if not matched:
+            fp += 1
+
+    # 매칭 안 된 ground truth = False Negative
+    fn = len(ground_truths) - len(matched_gt)
+
+    # 메트릭 계산
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0
+
+    return {
+        'tp': tp,
+        'fp': fp,
+        'fn': fn,
+        'precision': precision,
+        'recall': recall,
+        'f1': f1
+    }
+
+def load_ground_truth(json_path):
+    """Ground truth JSON 로드
+
+    예상 형식:
+    {
+        "image1.png": [
+            {"bbox": [x1, y1, x2, y2], "label": "shrimp"},
+            ...
+        ],
+        ...
+    }
+    """
+    if not os.path.exists(json_path):
+        print(f"⚠️  Ground truth 파일이 없습니다: {json_path}")
+        print("📝 생성 방법:")
+        print("   ground_truth.json 파일을 만들고 다음 형식으로 작성:")
+        print('   {"image.png": [{"bbox": [x1, y1, x2, y2], "label": "shrimp"}]}')
+        return {}
+
+    with open(json_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def generate_confusion_matrix(results, output_dir):
+    """Confusion Matrix 생성"""
+    all_tp = sum(r['metrics']['tp'] for r in results)
+    all_fp = sum(r['metrics']['fp'] for r in results)
+    all_fn = sum(r['metrics']['fn'] for r in results)
+    tn = 0  # True Negative (객체 검출에서는 일반적으로 의미 없음)
+
+    matrix = np.array([
+        [all_tp, all_fp],
+        [all_fn, tn]
+    ])
+
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(matrix, annot=True, fmt='d', cmap='Blues',
+                xticklabels=['Positive', 'Negative'],
+                yticklabels=['Predicted Positive', 'Predicted Negative'])
+    plt.title('Confusion Matrix')
+    plt.ylabel('Actual')
+    plt.xlabel('Predicted')
+
+    output_path = os.path.join(output_dir, 'confusion_matrix.png')
+    plt.savefig(output_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"  📊 Confusion Matrix 저장: {output_path}")
+
+def generate_pr_curve(results_by_threshold, output_dir):
+    """Precision-Recall Curve 생성"""
+    thresholds = sorted(results_by_threshold.keys())
+    precisions = [results_by_threshold[t]['avg_precision'] for t in thresholds]
+    recalls = [results_by_threshold[t]['avg_recall'] for t in thresholds]
+
+    plt.figure(figsize=(10, 6))
+    plt.plot(recalls, precisions, 'b-o', linewidth=2, markersize=6)
+    plt.xlabel('Recall', fontsize=12)
+    plt.ylabel('Precision', fontsize=12)
+    plt.title('Precision-Recall Curve', fontsize=14)
+    plt.grid(True, alpha=0.3)
+    plt.xlim([0, 1])
+    plt.ylim([0, 1])
+
+    # 최적 지점 표시
+    f1_scores = [2*p*r/(p+r) if (p+r)>0 else 0 for p, r in zip(precisions, recalls)]
+    best_idx = np.argmax(f1_scores)
+    plt.plot(recalls[best_idx], precisions[best_idx], 'r*', markersize=15,
+             label=f'Best F1={f1_scores[best_idx]:.2f} (threshold={thresholds[best_idx]})')
+    plt.legend()
+
+    output_path = os.path.join(output_dir, 'pr_curve.png')
+    plt.savefig(output_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"  📈 PR Curve 저장: {output_path}")
+
+def visualize_evaluation_result(image_path, predictions, ground_truths, metrics, output_path):
+    """평가 결과 시각화"""
+    image = Image.open(image_path).convert('RGB')
+    draw = ImageDraw.Draw(image)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 12)
+        font_large = ImageFont.truetype("arial.ttf", 16)
+    except:
+        font = ImageFont.load_default()
+        font_large = ImageFont.load_default()
+
+    # Ground Truth (녹색)
+    for gt in ground_truths:
+        x1, y1, x2, y2 = gt['bbox']
+        draw.rectangle([x1, y1, x2, y2], outline="lime", width=3)
+        draw.text((x1, y1 - 15), "GT", fill="lime", font=font)
+
+    # Predictions (파란색)
+    for pred in predictions:
+        x1, y1, x2, y2 = pred['bbox']
+        draw.rectangle([x1, y1, x2, y2], outline="cyan", width=2)
+        label = f"{pred['filter_score']:.0f}"
+        draw.text((x1, y2 + 5), label, fill="cyan", font=font)
+
+    # 메트릭 헤더
+    header = f"P={metrics['precision']:.2f} R={metrics['recall']:.2f} F1={metrics['f1']:.2f}"
+    draw.rectangle([5, 5, 300, 35], fill="black", outline="white", width=2)
+    draw.text((10, 10), header, fill="white", font=font_large)
+
+    image.save(output_path, quality=95)
+
+def run_quantitative_test(test_image_dir, ground_truth_path, confidence=0.3, filter_threshold=50, iou_threshold=0.5):
+    """정량적 평가 실행"""
+    print("\n" + "="*60)
+    print("📊 정량적 평가 테스트 시작")
+    print("="*60)
+
+    # Ground truth 로드
+    ground_truths = load_ground_truth(ground_truth_path)
+    if not ground_truths:
+        return
+
+    # 모델 로드
+    processor, model = load_rtdetr_model()
+
+    # 결과 디렉토리
+    output_dir = f"test_results/quantitative_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    os.makedirs(output_dir, exist_ok=True)
+
+    print(f"\n⚙️  설정:")
+    print(f"   - RT-DETR Confidence: {confidence}")
+    print(f"   - Filter Threshold: {filter_threshold}")
+    print(f"   - IoU Threshold: {iou_threshold}")
+    print(f"   - Ground Truth 이미지: {len(ground_truths)}개\n")
+
+    results = []
+
+    for filename, gt_list in ground_truths.items():
+        img_path = os.path.join(test_image_dir, filename)
+        if not os.path.exists(img_path):
+            print(f"⚠️  이미지를 찾을 수 없습니다: {img_path}")
+            continue
+
+        print(f"\n🖼️  평가 중: {filename}")
+        print(f"   Ground Truth: {len(gt_list)}개")
+
+        # 이미지 로드 및 검출
+        image = Image.open(img_path).convert('RGB')
+        all_detections = detect_with_rtdetr(image, processor, model, confidence)
+        filtered_detections = apply_universal_filter(all_detections, image, filter_threshold)
+
+        print(f"   검출 결과: {len(filtered_detections)}개")
+
+        # 평가
+        metrics = evaluate_detection(filtered_detections, gt_list, iou_threshold)
+
+        print(f"   📊 Precision: {metrics['precision']:.2%}")
+        print(f"   📊 Recall: {metrics['recall']:.2%}")
+        print(f"   📊 F1 Score: {metrics['f1']:.2%}")
+        print(f"   TP={metrics['tp']}, FP={metrics['fp']}, FN={metrics['fn']}")
+
+        # 시각화
+        output_path = os.path.join(output_dir, f"eval_{filename}")
+        visualize_evaluation_result(img_path, filtered_detections, gt_list, metrics, output_path)
+        print(f"   💾 저장: {output_path}")
+
+        results.append({
+            'filename': filename,
+            'metrics': metrics,
+            'gt_count': len(gt_list),
+            'pred_count': len(filtered_detections)
+        })
+
+    # 전체 평균
+    if results:
+        avg_precision = np.mean([r['metrics']['precision'] for r in results])
+        avg_recall = np.mean([r['metrics']['recall'] for r in results])
+        avg_f1 = np.mean([r['metrics']['f1'] for r in results])
+
+        print("\n" + "="*60)
+        print("📊 전체 평균 성능")
+        print("="*60)
+        print(f"Precision: {avg_precision:.2%}")
+        print(f"Recall:    {avg_recall:.2%}")
+        print(f"F1 Score:  {avg_f1:.2%}")
+        print("="*60)
+
+        # Confusion Matrix 생성
+        generate_confusion_matrix(results, output_dir)
+
+        # 결과 저장
+        summary = {
+            'config': {
+                'confidence': confidence,
+                'filter_threshold': filter_threshold,
+                'iou_threshold': iou_threshold
+            },
+            'avg_metrics': {
+                'precision': avg_precision,
+                'recall': avg_recall,
+                'f1': avg_f1
+            },
+            'per_image_results': results
+        }
+
+        json_path = os.path.join(output_dir, 'evaluation_summary.json')
+        with open(json_path, 'w', encoding='utf-8') as f:
+            json.dump(summary, f, ensure_ascii=False, indent=2)
+
+        print(f"\n📄 평가 결과 저장: {json_path}")
+
+if __name__ == "__main__":
+    # 테스트 실행
+    TEST_DIR = "imgs"
+    GT_PATH = "ground_truth.json"
+
+    if not os.path.exists(GT_PATH):
+        print("⚠️  ground_truth.json 파일이 필요합니다.")
+        print("\n📝 ground_truth.json 생성 예시:")
+        print("""
+{
+  "test_shrimp_tank.png": [
+    {"bbox": [100, 150, 200, 180], "label": "shrimp"},
+    {"bbox": [300, 250, 420, 290], "label": "shrimp"}
+  ],
+  "image (1).webp": [
+    {"bbox": [500, 600, 800, 700], "label": "shrimp"}
+  ]
+}
+        """)
+    else:
+        run_quantitative_test(
+            test_image_dir=TEST_DIR,
+            ground_truth_path=GT_PATH,
+            confidence=0.3,
+            filter_threshold=50,
+            iou_threshold=0.5
+        )

test_visual_validation.py

@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+"""
+시각적 검증 테스트 스크립트
+RT-DETR + Universal Shrimp Filter의 검출 결과를 시각적으로 검증
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+
+import os
+from PIL import Image, ImageDraw, ImageFont
+import json
+from datetime import datetime
+import cv2
+import numpy as np
+from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+import torch
+
+# 출력 디렉토리 설정
+OUTPUT_DIR = "test_results"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def load_rtdetr_model():
+    """RT-DETR 모델 로드"""
+    print("🔄 RT-DETR 모델 로딩 중...")
+    processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
+    model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
+    model.eval()
+    print("✅ RT-DETR 로딩 완료")
+    return processor, model
+
+def detect_with_rtdetr(image, processor, model, 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(),
+            'label': label.item()
+        })
+
+    return detections
+
+def calculate_morphological_features(bbox, image_size):
+    """형태학적 특징 계산"""
+    x1, y1, x2, y2 = bbox
+    width = x2 - x1
+    height = y2 - y1
+
+    # Aspect ratio (긴 쪽 / 짧은 쪽)
+    aspect_ratio = max(width, height) / max(min(width, height), 1)
+
+    # Area ratio (이미지 대비 면적)
+    img_w, img_h = image_size
+    area_ratio = (width * height) / (img_w * img_h)
+
+    # Compactness (4π * Area / Perimeter²)
+    perimeter = 2 * (width + height)
+    compactness = (4 * np.pi * width * height) / max(perimeter ** 2, 1)
+
+    return {
+        'aspect_ratio': aspect_ratio,
+        'area_ratio': area_ratio,
+        'compactness': compactness,
+        'width': width,
+        'height': height
+    }
+
+def calculate_visual_features(image_pil, bbox):
+    """시각적 특징 계산 (색상, 텍스처)"""
+    # PIL → OpenCV
+    image_cv = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
+    x1, y1, x2, y2 = [int(v) for v in bbox]
+
+    # 바운딩 박스 영역 추출
+    roi = image_cv[y1:y2, x1:x2]
+    if roi.size == 0:
+        return {'saturation': 255, 'color_std': 255}
+
+    # HSV 변환
+    hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
+
+    # 채도 (Saturation)
+    saturation = np.mean(hsv[:, :, 1])
+
+    # 색상 일관성 (표준편차)
+    color_std = np.std(hsv[:, :, 0])
+
+    return {
+        'saturation': saturation,
+        'color_std': color_std
+    }
+
+def apply_universal_filter(detections, image, threshold=50):
+    """범용 새우 필터 적용"""
+    img_size = image.size
+    filtered = []
+
+    for det in detections:
+        bbox = det['bbox']
+
+        # 1. 형태학적 특징
+        morph = calculate_morphological_features(bbox, img_size)
+
+        # 2. 시각적 특징
+        visual = calculate_visual_features(image, bbox)
+
+        # 3. 점수 계산
+        score = 0
+        reasons = []
+
+        # Aspect ratio (3:1 ~ 10:1) - 자(2:1~3:1) 제외하기 위해 하한 상향
+        if 3.0 <= morph['aspect_ratio'] <= 10.0:
+            score += 15
+            reasons.append(f"✓ 종횡비 {morph['aspect_ratio']:.1f}")
+        elif 2.0 <= morph['aspect_ratio'] < 3.0:
+            # 약간 감점 (자일 가능성)
+            score += 8
+            reasons.append(f"△ 종횡비 {morph['aspect_ratio']:.1f}")
+        else:
+            reasons.append(f"✗ 종횡비 {morph['aspect_ratio']:.1f}")
+
+        # Compactness (< 0.50, 긴 형태) - 측정용 새우는 몸이 펴져있음, 자(0.6~0.8) 제외
+        if morph['compactness'] < 0.50:
+            score += 20  # 가중치 증가: 15 → 20
+            reasons.append(f"✓ 세장도 {morph['compactness']:.2f}")
+        else:
+            reasons.append(f"✗ 세장도 {morph['compactness']:.2f}")
+            score -= 10  # 패널티 추가
+
+        # Area ratio (5% ~ 50%)
+        if 0.05 <= morph['area_ratio'] <= 0.50:
+            score += 10
+            reasons.append(f"✓ 면적비 {morph['area_ratio']*100:.1f}%")
+        else:
+            reasons.append(f"✗ 면적비 {morph['area_ratio']*100:.1f}%")
+
+        # Saturation (낮을수록 죽은 새우) - 완화: 투명한 새우도 허용
+        if visual['saturation'] < 180:
+            score += 20
+            reasons.append(f"✓ 채도 {visual['saturation']:.0f}")
+        else:
+            reasons.append(f"✗ 채도 {visual['saturation']:.0f}")
+
+        # Color consistency (낮을수록 일관성 높음) - 완화: 내부 장기 보이는 투명 새우 허용
+        if visual['color_std'] < 60:
+            score += 15
+            reasons.append(f"✓ 색상일관성 {visual['color_std']:.1f}")
+        else:
+            reasons.append(f"✗ 색상일관성 {visual['color_std']:.1f}")
+
+        # RT-DETR confidence
+        score += det['confidence'] * 25
+
+        det['filter_score'] = score
+        det['filter_reasons'] = reasons
+        det['morph_features'] = morph
+        det['visual_features'] = visual
+
+        if score >= threshold:
+            filtered.append(det)
+
+    # 점수 순으로 정렬
+    filtered.sort(key=lambda x: x['filter_score'], reverse=True)
+
+    return filtered
+
+def visualize_results(image_path, all_detections, filtered_detections, output_path):
+    """검출 결과 시각화"""
+    image = Image.open(image_path).convert('RGB')
+
+    # 2개 이미지 생성 (원본 검출 vs 필터링 후)
+    img_all = image.copy()
+    img_filtered = image.copy()
+
+    draw_all = ImageDraw.Draw(img_all)
+    draw_filtered = ImageDraw.Draw(img_filtered)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 12)
+        font_large = ImageFont.truetype("arial.ttf", 16)
+    except:
+        font = ImageFont.load_default()
+        font_large = ImageFont.load_default()
+
+    # 전체 검출 결과 (회색)
+    for det in all_detections:
+        x1, y1, x2, y2 = det['bbox']
+        draw_all.rectangle([x1, y1, x2, y2], outline="gray", width=2)
+        label = f"{det['confidence']:.0%}"
+        draw_all.text((x1, y1 - 15), label, fill="gray", font=font)
+
+    # 필터링된 결과 (색상별)
+    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"
+
+        # 두 이미지 모두에 그리기
+        for draw in [draw_all, draw_filtered]:
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+            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, fill="black", font=font)
+
+    # 헤더
+    header_all = f"전체 검출: {len(all_detections)}개"
+    header_filtered = f"필터링 후: {len(filtered_detections)}개"
+
+    draw_all.rectangle([5, 5, 200, 35], fill="black", outline="white", width=2)
+    draw_all.text((10, 10), header_all, fill="white", font=font_large)
+
+    draw_filtered.rectangle([5, 5, 200, 35], fill="black", outline="lime", width=2)
+    draw_filtered.text((10, 10), header_filtered, fill="lime", font=font_large)
+
+    # 병렬 저장
+    combined_width = img_all.width * 2 + 20
+    combined_height = img_all.height
+    combined = Image.new('RGB', (combined_width, combined_height), color='white')
+
+    combined.paste(img_all, (0, 0))
+    combined.paste(img_filtered, (img_all.width + 20, 0))
+
+    combined.save(output_path, quality=95)
+    print(f"  💾 저장: {output_path}")
+
+    return len(all_detections), len(filtered_detections)
+
+def run_visual_test(test_image_dir, confidence=0.3, filter_threshold=75):
+    """시각적 검증 테스트 실행"""
+    print("\n" + "="*60)
+    print("🧪 시각적 검증 테스트 시작")
+    print("="*60)
+
+    # 모델 로드
+    processor, model = load_rtdetr_model()
+
+    # 이미지 파일 찾기
+    image_files = []
+    for ext in ['*.png', '*.jpg', '*.jpeg', '*.webp']:
+        import glob
+        image_files.extend(glob.glob(os.path.join(test_image_dir, ext)))
+
+    if not image_files:
+        print(f"❌ {test_image_dir}에서 이미지를 찾을 수 없습니다.")
+        return
+
+    print(f"\n📂 테스트 이미지: {len(image_files)}개")
+    print(f"⚙️  설정: Confidence={confidence}, Filter Threshold={filter_threshold}\n")
+
+    # 결과 저장
+    results = []
+
+    for img_path in image_files:
+        filename = os.path.basename(img_path)
+        print(f"\n🖼️  처리 중: {filename}")
+
+        # 이미지 로드
+        image = Image.open(img_path).convert('RGB')
+
+        # RT-DETR 검출
+        all_detections = detect_with_rtdetr(image, processor, model, confidence)
+        print(f"  🔍 RT-DETR 검출: {len(all_detections)}개")
+
+        # 필터 적용
+        filtered_detections = apply_universal_filter(all_detections, image, filter_threshold)
+        print(f"  ✅ 필터링 후: {len(filtered_detections)}개")
+
+        # 시각화
+        output_path = os.path.join(OUTPUT_DIR, f"result_{filename}")
+        all_count, filtered_count = visualize_results(
+            img_path, all_detections, filtered_detections, output_path
+        )
+
+        # 필터링된 객체 세부 정보
+        if filtered_detections:
+            print(f"\n  📋 검출된 ���우:")
+            for idx, det in enumerate(filtered_detections[:3], 1):  # 상위 3개만
+                print(f"    #{idx} 점수: {det['filter_score']:.0f}점")
+                for reason in det['filter_reasons'][:3]:
+                    print(f"       {reason}")
+
+        # 결과 기록
+        results.append({
+            'filename': filename,
+            'all_detections': all_count,
+            'filtered_detections': filtered_count,
+            'details': [{
+                'bbox': det['bbox'],
+                'confidence': det['confidence'],
+                'filter_score': det['filter_score'],
+                'reasons': det['filter_reasons']
+            } for det in filtered_detections]
+        })
+
+    # JSON 저장
+    result_json_path = os.path.join(OUTPUT_DIR, f"test_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
+    with open(result_json_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+
+    print("\n" + "="*60)
+    print("✅ 테스트 완료")
+    print(f"📁 결과 저장 위치: {OUTPUT_DIR}/")
+    print(f"📄 JSON 결과: {result_json_path}")
+    print("="*60)
+
+if __name__ == "__main__":
+    # 테스트 실행
+    TEST_DIR = "imgs"  # 테스트할 이미지 디렉토리
+
+    if not os.path.exists(TEST_DIR):
+        print(f"❌ 디렉토리를 찾을 수 없습니다: {TEST_DIR}")
+        print("💡 사용법: python test_visual_validation.py")
+        print("   imgs/ 디렉토리에 테스트 이미지를 넣어주세요.")
+    else:
+        run_visual_test(
+            test_image_dir=TEST_DIR,
+            confidence=0.3,        # RT-DETR 신뢰도
+            filter_threshold=50    # 필터 점수 임계값
+        )