Update main.py

main.py

@@ -1,11 +1,11 @@
 import io
-from typing import List
+from typing import List, Dict
 import uvicorn
 import numpy as np
 import uuid
 from datetime import datetime
 from fastapi import FastAPI, UploadFile, File, HTTPException, Form
-from fastapi.responses import JSONResponse, FileResponse
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from PIL import Image
@@ -15,11 +15,14 @@ from src.detection import YOLOv11Detector
 from src.comparison import DamageComparator
 from src.visualization import DamageVisualizer
 from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import torch
+import gc
 
 app = FastAPI(
     title="Car Damage Detection API",
-    description="YOLOv11-based car damage detection and comparison system with PyTorch and ONNX support (Optimized for ONNX Runtime v1.19 + opset 21)",
-    version="1.2.0"
+    description="YOLOv11-based car damage detection with DINOv2 ReID (Memory Optimized)",
+    version="1.3.0"
 )
 
 # Add CORS middleware
@@ -31,10 +34,10 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Initialize components
+# GLOBAL COMPONENTS - Load once at startup
 detector = None
-comparator = DamageComparator()
-visualizer = DamageVisualizer()
+comparator = None
+visualizer = None
 
 # Model paths mapping - PT and ONNX versions
 MODEL_PATHS = {
@@ -81,7 +84,6 @@ PT_TO_ONNX_MAPPING = {
     6: 11   # Medium v3 -> ONNX
 }
 
-
 def get_optimal_model_index(select_models: int, prefer_onnx: bool = True) -> int:
     """
     Enhanced model selection with performance optimization info
@@ -116,14 +118,10 @@ def get_optimal_model_index(select_models: int, prefer_onnx: bool = True) -> int
     # No suitable file found
     raise FileNotFoundError(f"Requested PT model index {select_models} not found at {MODEL_PATHS.get(select_models)}")
 
-
 def load_detector(select_models: int = 2, prefer_onnx: bool = True):
     """
-   
-    Args:
-        select_models: Model selection
-        
-        prefer_onnx: Whether to prefer ONNX format for fallback
+    Load detector with optimized ONNX Runtime v1.19 support
+    IMPORTANT: This loads GLOBAL instances that are shared across threads
     """
     global detector, comparator, visualizer
 
@@ -144,7 +142,20 @@ def load_detector(select_models: int = 2, prefer_onnx: bool = True):
     with open(temp_config, 'w') as f:
         yaml.dump(config, f, default_flow_style=False)
 
-    # Reload all components with new config
+    # Clear previous models from memory before loading new ones
+    if detector is not None:
+        del detector
+    if comparator is not None:
+        del comparator
+    if visualizer is not None:
+        del visualizer
+
+    # Force garbage collection
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    # Load all components with new config
     detector = YOLOv11Detector(config_path=temp_config)
     comparator = DamageComparator(config_path=temp_config)
     visualizer = DamageVisualizer(config_path=temp_config)
@@ -152,8 +163,8 @@ def load_detector(select_models: int = 2, prefer_onnx: bool = True):
     # Log model info with optimization status
     model_type = "ONNX" if MODEL_PATHS[actual_model_index].endswith('.onnx') else "PyTorch"
     model_labels = [
-        "Small v1", "Small v2","Small v3", "Medium v1", "Medium v2", "Medium v3",
-        "Small v1 ONNX", "Small v2 ONNX","Small v3 ONNX", "Medium v1 ONNX", "Medium v2 ONNX", "Medium v3 ONNX"
+        "Small v1", "Small v2", "Small v3", "Medium v1", "Medium v2", "Medium v3",
+        "Small v1 ONNX", "Small v2 ONNX", "Small v3 ONNX", "Medium v1 ONNX", "Medium v2 ONNX", "Medium v3 ONNX"
     ]
 
     if 0 <= select_models < len(model_labels):
@@ -161,23 +172,15 @@ def load_detector(select_models: int = 2, prefer_onnx: bool = True):
     else:
         raise ValueError(f"select_models={select_models} must be 0-11")
 
-    # Enhanced logging for optimization status
     optimization_status = "🚀 MAXIMUM OPTIMIZATIONS" if model_type == "ONNX" else "📦 Standard PyTorch"
     print(f"Loaded {model_size} model in {model_type} format - {optimization_status}")
-
-    # Show performance info for ONNX models
-    if model_type == "ONNX" and hasattr(detector, 'get_performance_info'):
-        perf_info = detector.get_performance_info()
-        if 'providers' in perf_info:
-            print(f"Provider: {perf_info['providers'][0]}")
-        if 'optimization_level' in perf_info:
-            print(f"Graph optimizations: {perf_info['optimization_level']}")
+    print(f"✅ DINOv2 ReID enabled for damage comparison")
 
     return detector
 
 
 # Initialize default detector with medium model (preferring ONNX for performance)
-print("🚀 Initializing API with optimized ONNX Runtime support...")
+print("🚀 Initializing API with optimized ONNX Runtime and DINOv2 ReID support...")
 detector = load_detector(2, prefer_onnx=True)
 comparator = DamageComparator(config_path=CONFIG_PATHS[2])
 visualizer = DamageVisualizer(config_path=CONFIG_PATHS[2])
@@ -196,16 +199,18 @@ app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
 async def root():
     """Root endpoint with enhanced model info"""
     return {
-        "message": "Car Damage Detection API with YOLOv11 (ONNX Runtime v1.19 optimized)",
-        "version": "1.2.0",
+        "message": "Car Damage Detection API with YOLOv11 + DINOv2 ReID (Memory Optimized)",
+        "version": "1.3.0",
         "optimizations": {
             "onnx_runtime": "v1.19+ with opset 21 support",
+            "reid_model": "DINOv2 (Meta) - Superior visual feature extraction",
+            "memory_management": "Global model loading with ThreadPoolExecutor",
             "performance_features": [
                 "Graph optimizations (ALL level)",
-                "Dynamic thread pool with load balancing",
-                "Memory arena optimizations",
-                "CPU spinning for low latency",
-                "OpenMP with ACTIVE wait policy"
+                "DINOv2 ReID for cross-view damage matching",
+                "Memory-efficient threading",
+                "torch.no_grad() context for inference",
+                "Automatic CUDA cache clearing"
             ]
         },
         "model_options": {
@@ -223,7 +228,7 @@ async def root():
         "endpoints": {
             "/docs": "API documentation",
             "/detect": "Single/Multi image detection",
-            "/compare": "Compare before/after images (6 pairs)",
+            "/compare": "Compare before/after images (6 pairs) with DINOv2 ReID",
             "/uploads/{filename}": "Access saved visualization images",
             "/health": "Health check",
             "/model-info": "Get current model information",
@@ -238,7 +243,9 @@ async def health_check():
     health_info = {
         "status": "healthy",
         "model": "YOLOv11",
-        "backend": "ONNX/PyTorch"
+        "reid": "DINOv2",
+        "backend": "ONNX/PyTorch",
+        "memory_optimization": "ThreadPoolExecutor with global models"
     }
 
     if detector and hasattr(detector, 'get_performance_info'):
@@ -251,6 +258,31 @@ async def health_check():
     return health_info
 
 
+@app.get("/model-info")
+async def get_model_info():
+    """Get comprehensive information about currently loaded model"""
+    if detector is None:
+        return {"error": "No model loaded"}
+
+    model_path = detector.model_path
+    model_type = "ONNX" if model_path.endswith('.onnx') else "PyTorch"
+
+    info = {
+        "model_path": model_path,
+        "model_type": model_type,
+        "confidence_threshold": detector.confidence,
+        "iou_threshold": detector.iou_threshold,
+        "classes": detector.classes,
+        "reid_model": "DINOv2",
+        "optimization_status": "Optimized" if model_type == "ONNX" else "Standard"
+    }
+
+    if hasattr(detector, 'get_performance_info'):
+        perf_info = detector.get_performance_info()
+        info.update(perf_info)
+
+    return info
+
 
 @app.post("/detect")
 async def detect_single_image(
@@ -259,23 +291,14 @@ async def detect_single_image(
         select_models: int = Form(2),
         prefer_onnx: bool = Form(True)
 ):
-    """
-    Multi-view detection with ONNX Runtime optimizations
-    Args:
-        file: Single image (backward compatibility)
-        files: Multiple images for multi-view detection
-        select_models: Model selection
-            - 0-4: PyTorch models (standard performance)
-            - 5-8: ONNX models (maximum optimizations)
-        prefer_onnx: Whether to prefer ONNX format (default: True for better performance)
-    """
+    """Multi-view detection with ONNX Runtime optimizations and DINOv2 ReID"""
     try:
         # Validate select_models
         if select_models not in list(range(0, 12)):
             raise HTTPException(status_code=400,
-                                detail="select_models must be 0-10 (0-5=PyTorch, 6-11=ONNX optimized)")
+                                detail="select_models must be 0-8 (0-4=PyTorch, 5-8=ONNX optimized)")
 
-        # Load appropriate detector
+        # Load appropriate detector (if different from current)
         current_detector = load_detector(select_models, prefer_onnx)
 
         # Case 1: Single image (backward compatibility)
@@ -296,7 +319,6 @@ async def detect_single_image(
             output_path = UPLOADS_DIR / filename
             cv2.imwrite(str(output_path), visualized)
 
-            # Enhanced response with optimization info
             model_type = "ONNX" if current_detector.model_path.endswith('.onnx') else "PyTorch"
             optimization_status = "🚀 OPTIMIZED" if model_type == "ONNX" else "📦 Standard"
 
@@ -311,52 +333,39 @@ async def detect_single_image(
                 },
                 "visualized_image_path": f"uploads/{filename}",
                 "visualized_image_url": f"http://localhost:8000/uploads/{filename}",
-                "filename": filename,
-                "performance_note": "Using ONNX optimizations" if model_type == "ONNX" else "Consider using ONNX models (6-11) for better performance"
+                "filename": filename
             })
 
-        # Case 2: Multiple images - MULTI-VIEW DETECTION with ReID
-        elif files is not None and len(files) > 0:
-            print(f"\nMulti-view detection with {len(files)} images")
-
-            images_list = []
+        # Case 2: Multiple images with DINOv2 deduplication
+        elif files is not None:
             detections_list = []
+            images = []
 
-            # Process all images
-            for idx, img_file in enumerate(files):
-                contents = await img_file.read()
+            for idx, f in enumerate(files):
+                contents = await f.read()
                 image = Image.open(io.BytesIO(contents)).convert("RGB")
                 image_np = np.array(image)
                 image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
-
-                images_list.append(image_bgr)
+                images.append(image_bgr)
                 detections = current_detector.detect(image_bgr)
                 detections_list.append(detections)
 
-                print(f"   View {idx + 1}: {len(detections['boxes'])} detections")
-
-            # DEDUPLICATION using ReID
-            print("\nPerforming cross-view deduplication...")
-            unique_damages = comparator.deduplicate_detections_across_views(
-                detections_list, images_list
-            )
+            # Deduplicate across views using DINOv2
+            unique_damages = comparator.deduplicate_detections_across_views(detections_list, images)
 
             # Create combined visualization
-            combined_height = max(img.shape[0] for img in images_list)
-            combined_width = sum(img.shape[1] for img in images_list)
-            combined_img = np.ones((combined_height, combined_width, 3), dtype=np.uint8) * 255
-
+            heights = [img.shape[0] for img in images]
+            widths = [img.shape[1] for img in images]
+            max_height = max(heights)
+            total_width = sum(widths)
+            combined_img = np.zeros((max_height, total_width, 3), dtype=np.uint8)
             x_offset = 0
-            for img_idx, (image, detections) in enumerate(zip(images_list, detections_list)):
-                # Resize if needed
-                h, w = image.shape[:2]
-                if h != combined_height:
-                    scale = combined_height / h
-                    new_w = int(w * scale)
-                    image = cv2.resize(image, (new_w, combined_height))
-                    w = new_w
 
-                # Draw on combined image
+            for img_idx, image in enumerate(images):
+                h, w = image.shape[:2]
+                if h != max_height:
+                    image = cv2.resize(image, (w, max_height))
+                detections = detections_list[img_idx]
                 combined_img[:, x_offset:x_offset + w] = image
 
                 # Draw detections with unique IDs
@@ -395,16 +404,17 @@ async def detect_single_image(
             output_path = UPLOADS_DIR / filename
             cv2.imwrite(str(output_path), combined_img)
 
-            # Return results with optimization info
+            # Return results
             total_detections = sum(len(d['boxes']) for d in detections_list)
             model_type = "ONNX" if current_detector.model_path.endswith('.onnx') else "PyTorch"
             optimization_status = "🚀 OPTIMIZED" if model_type == "ONNX" else "📦 Standard"
 
             return JSONResponse({
                 "status": "success",
-                "mode": "multi_view_with_reid",
+                "mode": "multi_view_with_dinov2_reid",
                 "model_type": model_type,
                 "optimization_status": optimization_status,
+                "reid_model": "DINOv2",
                 "total_detections_all_views": total_detections,
                 "unique_damages_count": len(unique_damages),
                 "unique_damages": {
@@ -420,8 +430,7 @@ async def detect_single_image(
                 "visualized_image_path": f"uploads/{filename}",
                 "visualized_image_url": f"http://localhost:8000/uploads/{filename}",
                 "message": f"Detected {total_detections} damages across {len(files)} views, "
-                           f"identified {len(unique_damages)} unique damages using ReID",
-                "performance_note": "Using ONNX optimizations" if model_type == "ONNX" else "Consider using ONNX models (5-8) for better performance"
+                           f"identified {len(unique_damages)} unique damages using DINOv2 ReID"
             })
 
         else:
@@ -431,6 +440,84 @@ async def detect_single_image(
         raise HTTPException(status_code=500, detail=f"Detection failed: {str(e)}")
 
 
+def process_single_position_threaded(
+        i: int,
+        before_contents: bytes,
+        after_contents: bytes,
+        timestamp_str: str,
+        session_id: str
+) -> Dict:
+    """
+    Process single position comparison using GLOBAL models (thread-safe)
+    No model loading here - uses global instances
+    """
+    # Use GLOBAL instances - no loading
+    global detector, comparator, visualizer
+
+    # Preprocess images
+    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)
+
+    # Detect using global detector
+    before_detections = detector.detect(before_bgr)
+    after_detections = detector.detect(after_bgr)
+
+    # Compare using global comparator with DINOv2 ReID
+    comparison = comparator.analyze_damage_status(
+        before_detections, after_detections,
+        before_bgr, after_bgr
+    )
+
+    # Visualize using global visualizer
+    vis_img = visualizer.create_comparison_visualization(
+        before_bgr, after_bgr,
+        before_detections, after_detections,
+        comparison
+    )
+
+    vis_filename = f"comparison_{timestamp_str}_{session_id}_pos{i + 1}.jpg"
+    vis_path = UPLOADS_DIR / vis_filename
+    cv2.imwrite(str(vis_path), vis_img)
+    vis_url = f"http://localhost:8000/uploads/{vis_filename}"
+
+    # Clear any GPU memory if used
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    # Return result
+    return {
+        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'],
+            "using_reid": comparison['statistics'].get('using_reid', True),
+            "reid_model": comparison['statistics'].get('reid_model', 'DINOv2'),
+            "visualization_path": f"uploads/{vis_filename}",
+            "visualization_url": vis_url,
+            "filename": vis_filename
+        },
+        "before_detections": {
+            "boxes": [np.array(box).tolist() for box in before_detections['boxes']],
+            "confidences": [float(c) for c in before_detections['confidences']],
+            "classes": before_detections['classes']
+        },
+        "after_detections": {
+            "boxes": [np.array(box).tolist() for box in after_detections['boxes']],
+            "confidences": [float(c) for c in after_detections['confidences']],
+            "classes": after_detections['classes']
+        },
+        "_before_bgr": before_bgr,  # chỉ dùng nội bộ
+        "_after_bgr": after_bgr  # chỉ dùng nội bộ
+    }
+
+
 @app.post("/compare")
 async def compare_vehicle_damages(
         # Before delivery images (6 positions)
@@ -452,34 +539,24 @@ async def compare_vehicle_damages(
         prefer_onnx: bool = Form(True)
 ):
     """
-    Enhanced comparison with ONNX Runtime optimizations and ReID
-    Args:
-        before_1-6: Before delivery images from 6 positions
-        after_1-6: After delivery images from 6 positions
-        select_models: Model selection (0-4=PyTorch, 5-8=ONNX optimized)
-        prefer_onnx: Whether to prefer ONNX format (default: True)
+    Enhanced comparison with DINOv2 ReID and Memory Optimization
+    Uses ThreadPoolExecutor with global models to avoid OOM
     """
     try:
         # Validate select_models
         if select_models not in list(range(0, 12)):
             raise HTTPException(status_code=400,
-                                detail="select_models must be 0-11 (0-5=PyTorch, 6-11=ONNX optimized)")
+                                detail="select_models must be 0-10 (0-5=PyTorch, 6-11=ONNX optimized)")
 
-        # Load appropriate detector
+        # Load appropriate detector if different from current
         current_detector = load_detector(select_models, prefer_onnx)
 
         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 = []
-
-        # Collect all before/after images and detections
-        all_before_images = []
-        all_after_images = []
-        all_before_detections = []
-        all_after_detections = []
+        # Read contents first
+        before_contents_list = [await img.read() for img in before_images]
+        after_contents_list = [await img.read() for img in after_images]
 
         # Overall statistics
         total_new_damages = 0
@@ -489,89 +566,72 @@ async def compare_vehicle_damages(
         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):
-            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 for multi-view analysis
-            all_before_images.append(before_bgr)
-            all_after_images.append(after_bgr)
-
-            image_pairs.append((before_bgr, after_bgr))
-
-            # Detect damages
-            before_detections = current_detector.detect(before_bgr)
-            after_detections = current_detector.detect(after_bgr)
-
-            all_before_detections.append(before_detections)
-            all_after_detections.append(after_detections)
-
-            # Enhanced comparison with ReID
-            comparison = comparator.analyze_damage_status(
-                before_detections, after_detections,
-                before_bgr, after_bgr
-            )
-
-            # Update statistics
-            total_new_damages += len(comparison['new_damages'])
-            total_existing_damages += len(comparison['repaired_damages'])
-            total_matched_damages += len(comparison['matched_damages'])
+        position_results = []
+        all_visualizations = []
+        image_pairs = []
+        all_before_images = []
+        all_after_images = []
+        all_before_detections = []
+        all_after_detections = []
 
-            # Create visualization
-            vis_img = visualizer.create_comparison_visualization(
-                before_bgr, after_bgr,
-                before_detections, after_detections,
-                comparison
-            )
-
-            vis_filename = f"comparison_{timestamp_str}_{session_id}_pos{i + 1}.jpg"
-            vis_path = UPLOADS_DIR / 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 with ReID info
-            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'],
-                    "using_reid": comparison['statistics'].get('using_reid', True),
-                    "visualization_path": f"uploads/{vis_filename}",
-                    "visualization_url": vis_url,
-                    "filename": vis_filename
-                }
-            })
+        # Use ThreadPoolExecutor to share memory (avoid OOM)
+        print(f"🔄 Processing {len(before_images)} image pairs using ThreadPoolExecutor...")
+
+        with ThreadPoolExecutor(max_workers=3) as executor:  # Limit workers to avoid memory issues
+            futures = [
+                executor.submit(
+                    process_single_position_threaded,
+                    i,
+                    before_contents_list[i],
+                    after_contents_list[i],
+                    timestamp_str,
+                    session_id
+                )
+                for i in range(6)
+            ]
 
-        # Deduplicate BEFORE damages across all 6 views
+            for future in as_completed(futures):
+                result = future.result()
+                pos_key = list(result.keys())[0]  # e.g., 'position_1'
+                position_results.append(result)
+                all_visualizations.append(result[pos_key]["visualization_url"])
+
+                # Collect for deduplication
+                image_pairs.append((result["_before_bgr"], result["_after_bgr"]))
+                all_before_images.append(result["_before_bgr"])
+                all_after_images.append(result["_after_bgr"])
+                result.pop("_before_bgr", None)
+                result.pop("_after_bgr", None)
+
+                all_before_detections.append(result["before_detections"])
+                all_after_detections.append(result["after_detections"])
+
+                # Update statistics
+                comparison = result[pos_key]
+                total_new_damages += len(comparison["new_damages"])
+                total_existing_damages += len(comparison["repaired_damages"])
+                total_matched_damages += len(comparison["matched_damages"])
+
+        # Sort position_results by position number
+        position_results.sort(key=lambda x: int(list(x.keys())[0].split('_')[1]))
+
+        # Deduplicate BEFORE damages across all 6 views using DINOv2
+        print("🔍 Deduplicating damages across views using DINOv2...")
         unique_before = comparator.deduplicate_detections_across_views(
             all_before_detections, all_before_images
         )
 
-        # Deduplicate AFTER damages across all 6 views
+        # Deduplicate AFTER damages across all 6 views using DINOv2
         unique_after = comparator.deduplicate_detections_across_views(
             all_after_detections, all_after_images
         )
 
-        print(f"Before: {sum(len(d['boxes']) for d in all_before_detections)} detections → {len(unique_before)} unique")
-        print(f"After: {sum(len(d['boxes']) for d in all_after_detections)} detections → {len(unique_after)} unique")
+        print(
+            f"✅ Before: {sum(len(d['boxes']) for d in all_before_detections)} detections → {len(unique_before)} unique")
+        print(f"✅ After: {sum(len(d['boxes']) for d in all_after_detections)} detections → {len(unique_after)} unique")
 
         # Determine overall case with deduplication
-        actual_new_damages = len(unique_after) - len(unique_before)
+        actual_new_damages = max(0, len(unique_after) - len(unique_before))
 
         overall_case = "CASE_3_SUCCESS"
         overall_message = "Successful delivery - No damage detected"
@@ -584,7 +644,7 @@ async def compare_vehicle_damages(
             overall_message = "Existing damages from beginning → Delivery completed"
 
         # Create summary grid
-        grid_results = [res[f"position_{i + 1}"] for i, res in enumerate(position_results)]
+        grid_results = [res[list(res.keys())[0]] for res in position_results]
         grid_img = visualizer.create_summary_grid(grid_results, image_pairs)
 
         grid_filename = f"summary_grid_{timestamp_str}_{session_id}.jpg"
@@ -595,7 +655,12 @@ async def compare_vehicle_damages(
 
         timestamp = datetime.now().isoformat()
 
-        # Enhanced response with optimization info
+        # Clean up memory
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        # Enhanced response
         model_type = "ONNX" if current_detector.model_path.endswith('.onnx') else "PyTorch"
         optimization_status = "🚀 OPTIMIZED" if model_type == "ONNX" else "📦 Standard"
 
@@ -606,6 +671,8 @@ async def compare_vehicle_damages(
             "model_type": model_type,
             "optimization_status": optimization_status,
             "reid_enabled": True,
+            "reid_model": "DINOv2",
+            "memory_optimization": "ThreadPoolExecutor with global models",
             "overall_result": {
                 "case": overall_case,
                 "message": overall_message,
@@ -615,10 +682,11 @@ async def compare_vehicle_damages(
                     "total_repaired_damages": int(total_existing_damages),
                     "unique_damages_before": int(len(unique_before)),
                     "unique_damages_after": int(len(unique_after)),
-                    "actual_new_unique_damages": int(max(0, len(unique_after) - len(unique_before)))
+                    "actual_new_unique_damages": int(actual_new_damages)
                 }
             },
             "deduplication_info": {
+                "model": "DINOv2",
                 "before_total_detections": int(sum(len(d['boxes']) for d in all_before_detections)),
                 "before_unique_damages": int(len(unique_before)),
                 "after_total_detections": int(sum(len(d['boxes']) for d in all_after_detections)),
@@ -635,14 +703,17 @@ async def compare_vehicle_damages(
                 "suggested_action": "Investigate delivery process" if actual_new_damages > 0
                 else "Proceed with delivery completion"
             },
-            "performance_note": "Using ONNX optimizations" if model_type == "ONNX" else "Consider using ONNX models (5-8) for better performance"
+            "performance_note": f"Using {model_type} + DINOv2 ReID with memory optimization"
         })
 
     except Exception as e:
+        # Clean up on error
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
         raise HTTPException(status_code=500, detail=f"Comparison failed: {str(e)}")
 
 
-
 if __name__ == "__main__":
     import os
     uvicorn.run(
@@ -651,4 +722,4 @@ if __name__ == "__main__":
         port=int(os.environ.get("PORT", 7860)),  
         reload=False,  
         log_level="info"
-    )
+    )