Upload 12 files

README.md

@@ -1,14 +1,29 @@
----
-title: Yolocar
-emoji: 💻
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Car Damage Detection System with YOLOv11
+
+A state-of-the-art vehicle damage detection and comparison system using YOLOv11, designed to analyze vehicle conditions before and after delivery.
+
+## Features
+
+- **YOLOv11 Detection**: YOLO model for accurate damage detection
+- **Smart Comparison**: IoU-based matching using Hungarian algorithm
+- **6-Position Analysis**: Comprehensive vehicle inspection from multiple angles
+- **Case Classification**: Automatic categorization of damage scenarios
+- **Visual Reports**: Generated comparison images with damage highlights
+- **REST API**: Easy integration with existing systems
+
+## Use Cases
+
+The system identifies three main scenarios:
+
+1. **Case 1 - Existing Damage**: Damages present before and after delivery → Delivery completed
+2. **Case 2 - New Damage**: New damages detected after delivery → Issue during delivery
+3. **Case 3 - No Damage**: No damages detected → Successful delivery
+
+## Quick Start
+
+### Installation
+
+1. Clone the repository
+2. Install dependencies:
+```bash
+pip install -r requirements.txt

config.yaml

@@ -0,0 +1,31 @@
+# Model Configuration
+model:
+  path: "models/best.pt"  # Sử dụng model best.pt đã train từ Colab
+  confidence: 0.1        # Confidence threshold
+  iou_threshold: 0.14      # NMS IoU threshold
+  device: "cpu"           # cuda:0 for GPU, cpu for CPU
+
+# Detection Configuration
+detection:
+  classes:
+    - "Damaged_Bonnet"
+    - "Damaged_Bumper"
+    - "Damaged_Dickey"
+    - "Damaged_Door"
+    - "Damaged_Fender"
+    - "Damaged_Light"
+    - "Damaged_Windshield"
+
+# Comparison Configuration
+comparison:
+  iou_match_threshold: 0.2      # IoU threshold for matching damages
+  position_tolerance: 50        # Pixel tolerance for position matching
+
+# Visualization
+visualization:
+  line_thickness: 2
+  font_scale: 0.5
+  colors:
+    existing_damage: [0, 255, 0]     # Green for existing damages
+    new_damage: [0, 0, 255]          # Red for new damages
+    matched_damage: [255, 255, 0]    # Yellow for matched damages

main.py

@@ -0,0 +1,283 @@
+import io
+import shutil
+
+import uvicorn
+import numpy as np
+import uuid
+from datetime import datetime
+from pathlib import Path
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from PIL import Image
+import cv2
+from src.detection import YOLOv11Detector
+from src.comparison import DamageComparator
+from src.visualization import DamageVisualizer
+
+
+app = FastAPI(
+    title="Car Damage Detection API",
+    description="YOLOv11-based car damage detection and comparison system",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize components
+detector = YOLOv11Detector()
+comparator = DamageComparator()
+visualizer = DamageVisualizer()
+
+# Create necessary directories
+Path("uploads").mkdir(exist_ok=True)
+Path("results").mkdir(exist_ok=True)
+
+# Mount static files directory
+app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Car Damage Detection API with YOLOv11",
+        "endpoints": {
+            "/docs": "API documentation",
+            "/detect": "Single image detection",
+            "/compare": "Compare before/after images (6 pairs)",
+            "/uploads/{filename}": "Access saved visualization images",
+            "/health": "Health check"
+        }
+    }
+
+
+def save_temp_file(upload_file: UploadFile) -> str:
+    """Save an uploaded file into /tmp and return the temp file path"""
+    tmp_dir = Path("/tmp")
+    tmp_dir.mkdir(exist_ok=True)
+
+    temp_path = tmp_dir / upload_file.filename
+
+    with open(temp_path, "wb") as buffer:
+        shutil.copyfileobj(upload_file.file, buffer)
+
+    return str(temp_path)
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "model": "YOLOv11"}
+
+@app.post("/detect")
+async def detect_single_image(file: UploadFile = File(...)):
+    """
+    Detect damages in a single image
+
+    Args:
+        file: Image file
+
+    Returns:
+        Detection results with bounding boxes and path to visualized image
+    """
+    try:
+        # Read and process image
+        contents = await file.read()
+        image = Image.open(io.BytesIO(contents)).convert("RGB")
+        image_np = np.array(image)
+        image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+
+        # Perform detection
+        detections = detector.detect(image_bgr)
+
+        # Create visualization
+        visualized = visualizer.draw_detections(image_bgr, detections, 'new_damage')
+
+
+        filename = f"detection_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}.jpg"
+        output_path = Path("/tmp") / filename
+        cv2.imwrite(str(output_path), visualized)
+
+        return JSONResponse({
+            "status": "success",
+            "detections": detections,
+            "statistics": {
+                "total_damages": len(detections['boxes']),
+                "damage_types": list(set(detections['classes']))
+            },
+            "visualized_image_path": f"/tmp/{filename}",
+        })
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Detection failed: {str(e)}")
+
+@app.post("/compare")
+async def compare_vehicle_damages(
+    # Before delivery images (6 positions)
+    before_1: UploadFile = File(..., description="Before - Position 1"),
+    before_2: UploadFile = File(..., description="Before - Position 2"),
+    before_3: UploadFile = File(..., description="Before - Position 3"),
+    before_4: UploadFile = File(..., description="Before - Position 4"),
+    before_5: UploadFile = File(..., description="Before - Position 5"),
+    before_6: UploadFile = File(..., description="Before - Position 6"),
+    # After delivery images (6 positions)
+    after_1: UploadFile = File(..., description="After - Position 1"),
+    after_2: UploadFile = File(..., description="After - Position 2"),
+    after_3: UploadFile = File(..., description="After - Position 3"),
+    after_4: UploadFile = File(..., description="After - Position 4"),
+    after_5: UploadFile = File(..., description="After - Position 5"),
+    after_6: UploadFile = File(..., description="After - Position 6"),
+):
+    """
+    Compare vehicle damages before and after delivery
+
+    Analyzes 6 pairs of images (before/after) from different positions
+    and determines the damage status according to 3 cases:
+    - Case 1: Existing damages (from before) -> Delivery completed
+    - Case 2: New damages detected -> Error during delivery
+    - Case 3: No damages -> Successful delivery
+
+    Returns:
+        Detailed comparison results for each position and overall status
+    """
+    try:
+        before_images = [before_1, before_2, before_3, before_4, before_5, before_6]
+        after_images = [after_1, after_2, after_3, after_4, after_5, after_6]
+
+        position_results = []
+        all_visualizations = []
+        image_pairs = []
+
+        # Overall statistics
+        total_new_damages = 0
+        total_existing_damages = 0
+        total_matched_damages = 0
+
+        # Generate unique session ID for this comparison
+        session_id = str(uuid.uuid4())[:8]
+        timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        # Process each position pair
+        for i in range(6):
+            # Read images
+            before_contents = await before_images[i].read()
+            after_contents = await after_images[i].read()
+
+            before_img = Image.open(io.BytesIO(before_contents)).convert("RGB")
+            after_img = Image.open(io.BytesIO(after_contents)).convert("RGB")
+
+            before_np = np.array(before_img)
+            after_np = np.array(after_img)
+
+            before_bgr = cv2.cvtColor(before_np, cv2.COLOR_RGB2BGR)
+            after_bgr = cv2.cvtColor(after_np, cv2.COLOR_RGB2BGR)
+
+            # Store image pairs for grid visualization
+            image_pairs.append((before_bgr, after_bgr))
+
+            # Detect damages
+            before_detections = detector.detect(before_bgr)
+            after_detections = detector.detect(after_bgr)
+
+            # Compare damages
+            comparison = comparator.analyze_damage_status(before_detections, after_detections)
+
+            # Update overall statistics
+            total_new_damages += len(comparison['new_damages'])
+            total_existing_damages += len(comparison['repaired_damages'])
+            total_matched_damages += len(comparison['matched_damages'])
+
+            # Create visualization for this position
+            vis_img = visualizer.create_comparison_visualization(
+                before_bgr, after_bgr,
+                before_detections, after_detections,
+                comparison
+            )
+
+            # Save visualization image with unique filename
+            vis_filename = f"comparison_{timestamp_str}_{session_id}_pos{i+1}.jpg"
+            vis_path = Path("/tmp") / vis_filename
+            cv2.imwrite(str(vis_path), vis_img)
+
+            vis_url = f"http://localhost:8000/uploads/{vis_filename}"
+            all_visualizations.append(vis_url)
+
+            # Store position result
+            position_results.append({
+                f"position_{i+1}": {
+                    "case": comparison['case'],
+                    "message": comparison['message'],
+                    "statistics": comparison['statistics'],
+                    "new_damages": comparison['new_damages'],
+                    "matched_damages": comparison['matched_damages'],
+                    "repaired_damages": comparison['repaired_damages'],
+                    "visualization_path": f"/tmp/{vis_filename}",
+                    "visualization_url": vis_url
+                }
+            })
+
+        # Determine overall case
+        overall_case = "CASE_3_SUCCESS"
+        overall_message = "Successful delivery - No damage detected"
+
+        if total_new_damages > 0:
+            overall_case = "CASE_2_NEW_DAMAGE"
+            overall_message = f"Error during vehicle delivery - Detection {total_new_damages} new damage"
+        elif total_matched_damages > 0 and total_new_damages == 0:
+            overall_case = "CASE_1_EXISTING"
+            overall_message = "Error from the beginning, not during the delivery process -> Delivery completed"
+
+        # Create summary grid visualization
+        grid_results = [res[f"position_{i+1}"] for i, res in enumerate(position_results)]
+        grid_img = visualizer.create_summary_grid(grid_results, image_pairs)
+
+        # Save grid summary image
+        grid_filename = f"summary_grid_{timestamp_str}_{session_id}.jpg"
+        grid_path = Path("uploads") / grid_filename
+        cv2.imwrite(str(grid_path), grid_img)
+        grid_url = f"http://localhost:8000/uploads/{grid_filename}"
+
+        # Generate timestamp for tracking
+        timestamp = datetime.now().isoformat()
+
+        return JSONResponse({
+            "status": "success",
+            "session_id": session_id,
+            "timestamp": timestamp,
+            "overall_result": {
+                "case": overall_case,
+                "message": overall_message,
+                "statistics": {
+                    "total_new_damages": total_new_damages,
+                    "total_matched_damages": total_matched_damages,
+                    "total_repaired_damages": total_existing_damages
+                }
+            },
+            "position_results": position_results,
+            "summary_visualization_path": f"/uploads/{grid_filename}",
+            "summary_visualization_url": grid_url,
+            "recommendations": {
+                "action_required": total_new_damages > 0,
+                "suggested_action": "Investigate delivery process" if total_new_damages > 0 else "Proceed with delivery completion"
+            }
+        })
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Comparison failed: {str(e)}")
+
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

requirements.txt

@@ -0,0 +1,65 @@
+# Core YOLOv11 and Ultralytics
+ultralytics>=8.3.0
+torch>=2.0.0
+torchvision>=0.15.0
+
+# FastAPI and web server
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
+websockets>=12.0
+
+# Image processing
+opencv-python>=4.8.0
+opencv-contrib-python>=4.8.0
+Pillow>=10.0.0
+numpy>=1.24.0
+
+# Video processing
+imageio>=2.31.0
+imageio-ffmpeg>=0.4.8
+
+# Data processing
+scipy>=1.11.0
+scikit-learn>=1.3.0
+pandas>=2.0.0
+
+# Configuration
+pyyaml>=6.0
+python-dotenv>=1.0.0
+
+# API documentation
+pydantic>=2.0.0
+
+# Performance optimization
+# For ONNX export
+onnx>=1.14.0
+onnxruntime>=1.15.0
+# onnxruntime-gpu>=1.15.0  # Uncomment for GPU support
+
+# Monitoring and logging
+tqdm>=4.65.0
+colorama>=0.4.6
+rich>=13.0.0
+
+# Testing (optional)
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+
+# Database (optional)
+# psycopg2-binary>=2.9.0  # PostgreSQL
+# pymongo>=4.5.0  # MongoDB
+# redis>=5.0.0  # Redis for caching
+
+# Cloud storage (optional)
+# boto3>=1.28.0  # AWS S3
+# google-cloud-storage>=2.10.0  # Google Cloud Storage
+
+# Tracking algorithms (for object tracking in videos)
+# lap>=0.4.0  # For ByteTrack
+# filterpy>=1.4.5  # For Kalman filtering
+
+# Additional utilities
+matplotlib>=3.7.0
+seaborn>=0.12.0
+plotly>=5.16.0

src/comparison.py

@@ -0,0 +1,210 @@
+import numpy as np
+from typing import List, Dict
+from scipy.optimize import linear_sum_assignment
+import yaml
+
+class DamageComparator:
+    """Compare damages between before and after images"""
+
+    def __init__(self, config_path: str = "config.yaml"):
+        """Initialize comparator with configuration"""
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)
+
+        self.iou_threshold = self.config['comparison']['iou_match_threshold']
+        self.position_tolerance = self.config['comparison']['position_tolerance']
+
+    def calculate_iou(self, box1: List[int], box2: List[int]) -> float:
+        """
+        Calculate Intersection over Union between two boxes
+
+        Args:
+            box1, box2: Bounding boxes in format [x1, y1, x2, y2]
+
+        Returns:
+            IoU value between 0 and 1
+        """
+        # Calculate intersection area
+        x1 = max(box1[0], box2[0])
+        y1 = max(box1[1], box2[1])
+        x2 = min(box1[2], box2[2])
+        y2 = min(box1[3], box2[3])
+
+        if x2 < x1 or y2 < y1:
+            return 0.0
+
+        intersection = (x2 - x1) * (y2 - y1)
+
+        # Calculate union area
+        box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+        box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+        union = box1_area + box2_area - intersection
+
+        # Calculate IoU
+        if union == 0:
+            return 0.0
+
+        return intersection / union
+
+    def match_damages(self, detections1: Dict, detections2: Dict) -> Dict:
+        """
+        Match damages between two sets of detections using Hungarian algorithm
+
+        Args:
+            detections1: First detection results (before)
+            detections2: Second detection results (after)
+
+        Returns:
+            Matching results with paired and unpaired damages
+        """
+        boxes1 = detections1['boxes']
+        boxes2 = detections2['boxes']
+
+        if len(boxes1) == 0 and len(boxes2) == 0:
+            return {
+                'matched_pairs': [],
+                'unmatched_before': [],
+                'unmatched_after': [],
+                'iou_matrix': None
+            }
+
+        if len(boxes1) == 0:
+            return {
+                'matched_pairs': [],
+                'unmatched_before': [],
+                'unmatched_after': list(range(len(boxes2))),
+                'iou_matrix': None
+            }
+
+        if len(boxes2) == 0:
+            return {
+                'matched_pairs': [],
+                'unmatched_before': list(range(len(boxes1))),
+                'unmatched_after': [],
+                'iou_matrix': None
+            }
+
+        # Calculate IoU matrix
+        iou_matrix = np.zeros((len(boxes1), len(boxes2)))
+        for i, box1 in enumerate(boxes1):
+            for j, box2 in enumerate(boxes2):
+                iou_matrix[i, j] = self.calculate_iou(box1, box2)
+
+        # Use Hungarian algorithm for optimal matching
+        # Convert to cost matrix (1 - IoU)
+        cost_matrix = 1 - iou_matrix
+        row_indices, col_indices = linear_sum_assignment(cost_matrix)
+
+        # Filter matches by IoU threshold
+        matched_pairs = []
+        matched_rows = set()
+        matched_cols = set()
+
+        for i, j in zip(row_indices, col_indices):
+            if iou_matrix[i, j] >= self.iou_threshold:
+                # Also check if damage types match
+                if detections1['classes'][i] == detections2['classes'][j]:
+                    matched_pairs.append((i, j, iou_matrix[i, j]))
+                    matched_rows.add(i)
+                    matched_cols.add(j)
+
+        # Find unmatched damages
+        unmatched_before = [i for i in range(len(boxes1)) if i not in matched_rows]
+        unmatched_after = [j for j in range(len(boxes2)) if j not in matched_cols]
+
+        return {
+            'matched_pairs': matched_pairs,
+            'unmatched_before': unmatched_before,
+            'unmatched_after': unmatched_after,
+            'iou_matrix': iou_matrix.tolist()
+        }
+
+    def analyze_damage_status(self, before_detections: Dict, after_detections: Dict) -> Dict:
+        """
+        Analyze damage status between before and after images
+
+        Returns detailed analysis with case classification
+        """
+        matching = self.match_damages(before_detections, after_detections)
+
+        # Extract damage information
+        matched_damages = []
+        for i, j, iou in matching['matched_pairs']:
+            matched_damages.append({
+                'type': before_detections['classes'][i],
+                'confidence_before': before_detections['confidences'][i],
+                'confidence_after': after_detections['confidences'][j],
+                'box_before': before_detections['boxes'][i],
+                'box_after': after_detections['boxes'][j],
+                'iou': iou
+            })
+
+        existing_damages = []
+        for i in matching['unmatched_before']:
+            existing_damages.append({
+                'type': before_detections['classes'][i],
+                'confidence': before_detections['confidences'][i],
+                'box': before_detections['boxes'][i]
+            })
+
+        new_damages = []
+        for j in matching['unmatched_after']:
+            new_damages.append({
+                'type': after_detections['classes'][j],
+                'confidence': after_detections['confidences'][j],
+                'box': after_detections['boxes'][j]
+            })
+
+        # Determine case
+        case = self._determine_case(matched_damages, existing_damages, new_damages)
+
+        return {
+            'case': case['type'],
+            'message': case['message'],
+            'matched_damages': matched_damages,
+            'repaired_damages': existing_damages,  # Damages that were there before but not after
+            'new_damages': new_damages,
+            'statistics': {
+                'total_before': len(before_detections['boxes']),
+                'total_after': len(after_detections['boxes']),
+                'matched': len(matched_damages),
+                'repaired': len(existing_damages),
+                'new': len(new_damages)
+            }
+        }
+
+    def _determine_case(self, matched: List, repaired: List, new: List) -> Dict:
+        """Determine which case the comparison falls into"""
+
+        # Case 3: Happy case - no damages at all
+        if len(matched) == 0 and len(repaired) == 0 and len(new) == 0:
+            return {
+                'type': 'CASE_3_SUCCESS',
+                'message': 'Successful delivery - No damage detected'
+            }
+
+        # Case 1: Existing damages remain (with or without repairs/new damages)
+        if len(matched) > 0 and len(new) == 0:
+            return {
+                'type': 'CASE_1_EXISTING',
+                'message': 'Error from the beginning, not during the delivery process -> Delivery completed'
+            }
+
+        # Case 2: New damages detected
+        if len(new) > 0:
+            return {
+                'type': 'CASE_2_NEW_DAMAGE',
+                'message': 'Delivery Defect - New Damage Discovered'
+            }
+
+        # Special case: All damages repaired
+        if len(repaired) > 0 and len(new) == 0 and len(matched) == 0:
+            return {
+                'type': 'CASE_REPAIRED',
+                'message': 'All damage repaired - Vehicle delivered successfully'
+            }
+
+        return {
+            'type': 'CASE_UNKNOWN',
+            'message': 'Status Undetermined'
+        }

src/detection.py

@@ -0,0 +1,204 @@
+import numpy as np
+from typing import List, Dict, Tuple
+import cv2
+from pathlib import Path
+import yaml
+
+class YOLOv11Detector:
+    """YOLOv11 detector for car damage detection"""
+
+    def __init__(self, config_path: str = "config.yaml"):
+        """Initialize YOLOv11 detector with configuration"""
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)
+
+        model_path = self.config['model']['path']
+
+        # Check which model file exists
+        if not Path(model_path).exists():
+            # Try to find available model files
+            model_dir = Path("models")
+            if (model_dir / "best.pt").exists():
+                model_path = str(model_dir / "best.pt")
+                print(f"Using best.pt model from training")
+            elif (model_dir / "last.pt").exists():
+                model_path = str(model_dir / "last.pt")
+                print(f"Using last.pt checkpoint model")
+            elif (model_dir / "best.onnx").exists():
+                model_path = str(model_dir / "best.onnx")
+                print(f"Using best.onnx model")
+            else:
+                raise FileNotFoundError(f"No model files found in models/ directory!")
+
+        self.model_path = model_path
+        self.device = self.config['model']['device']
+        self.confidence = self.config['model']['confidence']
+        self.iou_threshold = self.config['model']['iou_threshold']
+        self.classes = self.config['detection']['classes']
+
+        # Load model based on format
+        if model_path.endswith('.onnx'):
+            self._load_onnx_model()
+        else:  # .pt format
+            self._load_pytorch_model()
+
+    def _load_pytorch_model(self):
+        """Load PyTorch model using Ultralytics"""
+        from ultralytics import YOLO
+        self.model = YOLO(self.model_path)
+
+        # Set model to appropriate device
+        if self.device == 'cuda:0':
+            self.model.to('cuda')
+
+        print(f"Loaded PyTorch model: {self.model_path}")
+
+    def _load_onnx_model(self):
+        """Load ONNX model using OpenCV DNN"""
+        self.net = cv2.dnn.readNet(self.model_path)
+
+        # Set backend based on device
+        if self.device == 'cuda:0':
+            self.net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
+            self.net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
+        else:
+            self.net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
+            self.net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
+
+        print(f"Loaded ONNX model: {self.model_path}")
+
+    def detect(self, image: np.ndarray) -> Dict:
+        """
+        Perform detection on image
+
+        Args:
+            image: Input image as numpy array (BGR format)
+
+        Returns:
+            Dictionary containing detection results
+        """
+        if self.model_path.endswith('.onnx'):
+            return self._detect_onnx(image)
+        else:
+            return self._detect_pytorch(image)
+
+    def _detect_pytorch(self, image: np.ndarray) -> Dict:
+        """Detection using PyTorch model"""
+        # Run YOLO inference
+        results = self.model(
+            image,
+            conf=self.confidence,
+            iou=self.iou_threshold,
+            device=self.device,
+            verbose=False
+        )
+
+        # Parse results
+        detections = {
+            'boxes': [],
+            'confidences': [],
+            'classes': [],
+            'class_ids': []
+        }
+
+        if len(results) > 0 and results[0].boxes is not None:
+            boxes = results[0].boxes
+
+            for box in boxes:
+                # Get box coordinates (xyxy format)
+                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+
+                # Get confidence and class
+                conf = float(box.conf[0].cpu().numpy())
+                cls_id = int(box.cls[0].cpu().numpy())
+
+                # Map class ID to class name
+                if cls_id < len(self.classes):
+                    cls_name = self.classes[cls_id]
+                else:
+                    cls_name = f"class_{cls_id}"
+
+                detections['boxes'].append([int(x1), int(y1), int(x2), int(y2)])
+                detections['confidences'].append(conf)
+                detections['classes'].append(cls_name)
+                detections['class_ids'].append(cls_id)
+
+        return detections
+
+    def _detect_onnx(self, image: np.ndarray) -> Dict:
+        """Detection using ONNX model (compatible with original code)"""
+        height, width = image.shape[:2]
+
+        # Preprocess image for ONNX
+        blob = cv2.dnn.blobFromImage(
+            image, 1/255.0, (640, 640),
+            swapRB=True, crop=False
+        )
+
+        self.net.setInput(blob)
+        preds = self.net.forward()
+        preds = preds.transpose((0, 2, 1))
+
+        # Extract outputs
+        detections = self._extract_onnx_output(
+            preds=preds,
+            image_shape=(height, width),
+            input_shape=(640, 640)
+        )
+
+        return detections
+
+    def _extract_onnx_output(self, preds: np.ndarray, image_shape: Tuple[int, int],
+                            input_shape: Tuple[int, int]) -> Dict:
+        """Extract detection results from ONNX model output"""
+        class_ids, confs, boxes = [], [], []
+
+        image_height, image_width = image_shape
+        input_height, input_width = input_shape
+        x_factor = image_width / input_width
+        y_factor = image_height / input_height
+
+        rows = preds[0].shape[0]
+        for i in range(rows):
+            row = preds[0][i]
+            conf = row[4]
+
+            classes_score = row[4:]
+            _, _, _, max_idx = cv2.minMaxLoc(classes_score)
+            class_id = max_idx[1]
+
+            if classes_score[class_id] > self.confidence:
+                confs.append(float(conf))
+                label = self.classes[int(class_id)] if int(class_id) < len(self.classes) else f"class_{class_id}"
+                class_ids.append(label)
+
+                # Extract boxes
+                x, y, w, h = row[0].item(), row[1].item(), row[2].item(), row[3].item()
+                left = int((x - 0.5 * w) * x_factor)
+                top = int((y - 0.5 * h) * y_factor)
+                width = int(w * x_factor)
+                height = int(h * y_factor)
+                box = [left, top, left + width, top + height]
+                boxes.append(box)
+
+        # Apply NMS
+        if len(boxes) > 0:
+            indices = cv2.dnn.NMSBoxes(
+                [[b[0], b[1], b[2]-b[0], b[3]-b[1]] for b in boxes],
+                confs, self.confidence, self.iou_threshold
+            )
+
+            if len(indices) > 0:
+                indices = indices.flatten()
+                return {
+                    'boxes': [boxes[i] for i in indices],
+                    'confidences': [confs[i] for i in indices],
+                    'classes': [class_ids[i] for i in indices],
+                    'class_ids': list(range(len(indices)))
+                }
+
+        return {'boxes': [], 'confidences': [], 'classes': [], 'class_ids': []}
+
+    def detect_batch(self, images: List[np.ndarray]) -> List[Dict]:
+        """Detect on multiple images"""
+        return [self.detect(img) for img in images]

src/init.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

src/visualization.py

@@ -0,0 +1,183 @@
+import cv2
+import numpy as np
+from typing import List, Dict, Tuple
+import yaml
+
+class DamageVisualizer:
+    """Visualize detection and comparison results"""
+
+    def __init__(self, config_path: str = "config.yaml"):
+        """Initialize visualizer with configuration"""
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)
+
+        self.line_thickness = self.config['visualization']['line_thickness']
+        self.font_scale = self.config['visualization']['font_scale']
+        self.colors = self.config['visualization']['colors']
+
+    def draw_detections(self, image: np.ndarray, detections: Dict,
+                       color_type: str = 'new_damage') -> np.ndarray:
+        """
+        Draw bounding boxes and labels on image
+
+        Args:
+            image: Input image
+            detections: Detection results
+            color_type: Type of color to use ('new_damage', 'existing_damage', 'matched_damage')
+
+        Returns:
+            Image with drawn detections
+        """
+        img_copy = image.copy()
+        color = self.colors.get(color_type, [255, 0, 0])
+
+        for i, box in enumerate(detections['boxes']):
+            x1, y1, x2, y2 = box
+            label = f"{detections['classes'][i]} ({detections['confidences'][i]:.2f})"
+
+            # Draw rectangle
+            cv2.rectangle(img_copy, (x1, y1), (x2, y2), color, self.line_thickness)
+
+            # Draw label background
+            label_size, _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX,
+                                           self.font_scale, self.line_thickness)
+            cv2.rectangle(img_copy, (x1, y1 - label_size[1] - 5),
+                         (x1 + label_size[0], y1), color, -1)
+
+            # Draw label text
+            cv2.putText(img_copy, label, (x1, y1 - 5),
+                       cv2.FONT_HERSHEY_SIMPLEX, self.font_scale,
+                       [255, 255, 255], self.line_thickness)
+
+        return img_copy
+
+    def create_comparison_visualization(self, before_img: np.ndarray, after_img: np.ndarray,
+                                      before_detections: Dict, after_detections: Dict,
+                                      comparison_result: Dict) -> np.ndarray:
+        """
+        Create side-by-side comparison visualization
+
+        Args:
+            before_img, after_img: Input images
+            before_detections, after_detections: Detection results
+            comparison_result: Comparison analysis results
+
+        Returns:
+            Combined visualization image
+        """
+        # Draw matched damages in yellow
+        before_vis = before_img.copy()
+        after_vis = after_img.copy()
+
+        # Draw matched damages
+        for match in comparison_result['matched_damages']:
+            # Draw on before image
+            x1, y1, x2, y2 = match['box_before']
+            cv2.rectangle(before_vis, (x1, y1), (x2, y2),
+                         self.colors['matched_damage'], self.line_thickness)
+
+            # Draw on after image
+            x1, y1, x2, y2 = match['box_after']
+            cv2.rectangle(after_vis, (x1, y1), (x2, y2),
+                         self.colors['matched_damage'], self.line_thickness)
+
+        # Draw repaired damages (only on before) in green
+        for damage in comparison_result['repaired_damages']:
+            x1, y1, x2, y2 = damage['box']
+            cv2.rectangle(before_vis, (x1, y1), (x2, y2),
+                         self.colors['existing_damage'], self.line_thickness)
+            cv2.putText(before_vis, "REPAIRED", (x1, y1 - 5),
+                       cv2.FONT_HERSHEY_SIMPLEX, self.font_scale,
+                       self.colors['existing_damage'], self.line_thickness)
+
+        # Draw new damages (only on after) in red
+        for damage in comparison_result['new_damages']:
+            x1, y1, x2, y2 = damage['box']
+            cv2.rectangle(after_vis, (x1, y1), (x2, y2),
+                         self.colors['new_damage'], self.line_thickness + 1)
+            cv2.putText(after_vis, "NEW!", (x1, y1 - 5),
+                       cv2.FONT_HERSHEY_SIMPLEX, self.font_scale * 1.5,
+                       self.colors['new_damage'], self.line_thickness)
+
+        # Combine images side by side
+        h1, w1 = before_vis.shape[:2]
+        h2, w2 = after_vis.shape[:2]
+        max_height = max(h1, h2)
+
+        # Resize if needed
+        if h1 != max_height:
+            before_vis = cv2.resize(before_vis, (int(w1 * max_height / h1), max_height))
+        if h2 != max_height:
+            after_vis = cv2.resize(after_vis, (int(w2 * max_height / h2), max_height))
+
+        # Create combined image
+        combined = np.hstack([before_vis, after_vis])
+
+        # Add status text
+        status_height = 100
+        status_img = np.ones((status_height, combined.shape[1], 3), dtype=np.uint8) * 255
+
+        # Add case message
+        case_color = (0, 128, 0) if 'SUCCESS' in comparison_result['case'] else (0, 0, 255)
+        cv2.putText(status_img, comparison_result['message'], (20, 40),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, case_color, 2)
+
+        # Add statistics
+        stats_text = f"Before: {comparison_result['statistics']['total_before']} | " \
+                    f"After: {comparison_result['statistics']['total_after']} | " \
+                    f"Matched: {comparison_result['statistics']['matched']} | " \
+                    f"New: {comparison_result['statistics']['new']}"
+        cv2.putText(status_img, stats_text, (20, 70),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 1)
+
+        # Combine with status
+        final_image = np.vstack([status_img, combined])
+
+        return final_image
+
+    def create_summary_grid(self, comparison_results: List[Dict],
+                           image_pairs: List[Tuple[np.ndarray, np.ndarray]]) -> np.ndarray:
+        """
+        Create a grid visualization of all 6 position comparisons
+
+        Args:
+            comparison_results: List of comparison results for each position
+            image_pairs: List of (before, after) image pairs
+
+        Returns:
+            Grid visualization of all positions
+        """
+        grid_images = []
+
+        for i, (result, (before_img, after_img)) in enumerate(zip(comparison_results, image_pairs)):
+            # Create mini comparison for each position
+            target_size = (300, 200)  # Smaller size for grid
+
+            before_small = cv2.resize(before_img, target_size)
+            after_small = cv2.resize(after_img, target_size)
+
+            # Add position label
+            position_label = f"Position {i+1}"
+            cv2.putText(before_small, position_label, (10, 20),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+            cv2.putText(after_small, position_label, (10, 20),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+
+            # Add case indicator
+            case_color = (0, 255, 0) if 'SUCCESS' in result['case'] else (0, 0, 255)
+            if 'NEW_DAMAGE' in result['case']:
+                case_color = (0, 0, 255)
+
+            cv2.rectangle(after_small, (0, 0), (target_size[0], 30), case_color, -1)
+            cv2.putText(after_small, result['case'][:10], (10, 20),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)
+
+            pair_img = np.hstack([before_small, after_small])
+            grid_images.append(pair_img)
+
+        # Create 2x3 grid
+        row1 = np.hstack(grid_images[:3])
+        row2 = np.hstack(grid_images[3:])
+        grid = np.vstack([row1, row2])
+
+        return grid