Update detection_api.py

detection_api.py

@@ -1,10 +1,9 @@
 from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks, Form
-from fastapi.responses import  FileResponse
+from fastapi.responses import FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 from typing import List, Optional, Dict, Any, Union
 import cv2
-from gunicorn.app.base import BaseApplication
 import numpy as np
 from datetime import datetime
 import aiofiles
@@ -14,7 +13,10 @@ import uuid
 import traceback
 from concurrent.futures import ThreadPoolExecutor
 import logging
-import uvicorn
+import hashlib
+import time
+from functools import lru_cache
+
 from main import ContentModerator
 
 # Setup logging
@@ -42,19 +44,8 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-class StandaloneApplication(BaseApplication):
-    def __init__(self, app, options=None):
-        self.application = app
-        self.options = options or {}
-        super().__init__()
-
-    def load_config(self):
-        for key, value in self.options.items():
-            self.cfg.set(key, value)
 
-    def load(self):
-        return self.application
-# Configuration
+# Configuration optimized for CPU
 class Config:
     UPLOAD_DIR = Path("uploads")
     RESULTS_DIR = Path("results")
@@ -63,10 +54,16 @@ class Config:
     MAX_VIDEO_SIZE = 500 * 1024 * 1024  # 500MB for videos
     ALLOWED_IMAGE_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.webp'}
     ALLOWED_VIDEO_EXTENSIONS = {'.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv'}
-    VIDEO_FRAME_SKIP = 5  # Process every 5th frame for performance
+
+    # CPU-optimized settings
+    VIDEO_FRAME_SKIP = 10  # Process every 10th frame by default
+    VIDEO_MAX_FRAMES = 100  # Maximum frames to process
+    VIDEO_TARGET_WIDTH = 416  # Downscale to this width
+    VIDEO_EARLY_STOP_THRESHOLD = 10  # Stop after N threats
+
     CLEANUP_AFTER_HOURS = 24
-    ENABLE_ANNOTATED_OUTPUT = True
-    MAX_WORKERS = 4
+    ENABLE_ANNOTATED_OUTPUT = False  # Disable to save CPU
+    MAX_WORKERS = 2  # Reduced for CPU
 
 
 config = Config()
@@ -77,47 +74,126 @@ for directory in [config.UPLOAD_DIR, config.RESULTS_DIR, config.PROCESSED_DIR]:
     (directory / "images").mkdir(exist_ok=True)
     (directory / "videos").mkdir(exist_ok=True)
 
-# Global moderator instance (initialized on startup)
+# Global moderator instance
 moderator: Optional[ContentModerator] = None
 
 # Thread pool for background processing
 executor = ThreadPoolExecutor(max_workers=config.MAX_WORKERS)
 
 
+# Video Optimizer Class
+class VideoOptimizer:
+    """Optimized video processing for CPU environments"""
+
+    def __init__(self):
+        self.frame_cache = {}
+        self.cache_size = 20
+
+    def get_optimal_settings(self, duration: float, total_frames: int) -> Dict:
+        """Calculate optimal settings based on video duration"""
+
+        if duration <= 5:
+            return {
+                'frame_skip': 3,
+                'target_width': 416,
+                'max_frames': 50
+            }
+        elif duration <= 15:
+            return {
+                'frame_skip': 8,
+                'target_width': 416,
+                'max_frames': 75
+            }
+        elif duration <= 30:
+            return {
+                'frame_skip': 12,
+                'target_width': 320,
+                'max_frames': 100
+            }
+        else:
+            return {
+                'frame_skip': 20,
+                'target_width': 320,
+                'max_frames': 150
+            }
+
+    def preprocess_frame(self, frame: np.ndarray, target_width: int = 416) -> np.ndarray:
+        """Downscale frame for faster processing"""
+        height, width = frame.shape[:2]
+
+        if width > target_width:
+            scale = target_width / width
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+            frame = cv2.resize(frame, (new_width, new_height),
+                               interpolation=cv2.INTER_LINEAR)
+
+        return frame
+
+    def get_frame_hash(self, frame: np.ndarray) -> str:
+        """Generate hash for frame"""
+        small = cv2.resize(frame, (8, 8))
+        return hashlib.md5(small.tobytes()).hexdigest()
+
+    def should_skip_frame(self, frame: np.ndarray) -> bool:
+        """Check if frame is similar to cached frames"""
+        frame_hash = self.get_frame_hash(frame)
+
+        if frame_hash in self.frame_cache:
+            return True
+
+        # Maintain cache size
+        if len(self.frame_cache) >= self.cache_size:
+            # Remove oldest entry
+            oldest = min(self.frame_cache, key=self.frame_cache.get)
+            del self.frame_cache[oldest]
+
+        self.frame_cache[frame_hash] = time.time()
+        return False
+
+    def clear_cache(self):
+        """Clear frame cache"""
+        self.frame_cache.clear()
+
+
+# Initialize video optimizer
+video_optimizer = VideoOptimizer()
+
+
 # ============== Response Models ==============
 
 class BoundingBox(BaseModel):
-    x1: int = Field(..., description="Top-left x coordinate")
-    y1: int = Field(..., description="Top-left y coordinate")
-    x2: int = Field(..., description="Bottom-right x coordinate")
-    y2: int = Field(..., description="Bottom-right y coordinate")
+    x1: int
+    y1: int
+    x2: int
+    y2: int
 
 
 class WeaponDetection(BaseModel):
-    type: str = Field(..., description="Detection type (weapon)")
-    class_name: str = Field(..., description="Weapon class (knife/dao/gun)")
-    weapon_type: str = Field(..., description="Weapon category (blade/firearm)")
-    confidence: float = Field(..., ge=0, le=1, description="Detection confidence")
+    type: str
+    class_name: str
+    weapon_type: str
+    confidence: float
     bbox: BoundingBox
-    threat_level: str = Field(..., description="Threat level (low/medium/high/critical)")
-    detection_method: str = Field(..., description="Detection method used")
+    threat_level: str
+    detection_method: str
 
 
 class NSFWDetection(BaseModel):
-    type: str = Field(..., description="Detection type (nsfw)")
-    class_name: str = Field(..., description="NSFW class")
-    confidence: float = Field(..., ge=0, le=1, description="Detection confidence")
+    type: str
+    class_name: str
+    confidence: float
     bbox: BoundingBox
-    method: str = Field(..., description="Detection method (classification/skin_detection/pose_analysis)")
-    skin_ratio: Optional[float] = Field(None, description="Skin exposure ratio if applicable")
+    method: str
+    skin_ratio: Optional[float] = None
 
 
 class FightDetection(BaseModel):
-    type: str = Field(default="fight", description="Detection type")
-    confidence: float = Field(..., ge=0, le=1, description="Detection confidence")
+    type: str
+    confidence: float
     bbox: BoundingBox
-    persons_involved: int = Field(..., description="Number of persons detected in fight")
-    threat_level: str = Field(..., description="Threat level")
+    persons_involved: int
+    threat_level: str
 
 
 class ImageDetectionResponse(BaseModel):
@@ -129,7 +205,6 @@ class ImageDetectionResponse(BaseModel):
     summary: Dict[str, Any]
     risk_level: str
     action_required: bool
-    annotated_image_url: Optional[str] = None
     processing_time_ms: float
 
 
@@ -143,16 +218,73 @@ class VideoDetectionResponse(BaseModel):
     summary: Dict[str, Any]
     risk_level: str
     action_required: bool
-    processed_video_url: Optional[str] = None
     processing_time_ms: float
+    optimization_used: Dict[str, Any]
 
 
-class ErrorResponse(BaseModel):
-    success: bool = False
-    error: str
-    error_code: str
-    timestamp: str
-    request_id: Optional[str] = None
+# ============== Startup/Shutdown Events ==============
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize Content Moderator on startup"""
+    global moderator
+    try:
+        logger.info("Initializing Content Moderator for CPU...")
+
+        # Create CPU-optimized config
+        cpu_config = {
+            'weapon_detection': {
+                'enabled': True,
+                'confidence_threshold': 0.5,
+                'knife_confidence': 0.5,
+                'fight_confidence': 0.45,
+                'model_size': 'yolo11n',
+                'use_enhancement': False,  # Disable for CPU
+                'multi_pass': False,  # Disable for CPU
+                'boost_knife_detection': True,
+                'fight_detection': True,
+                'fight_analysis': False  # Disable complex analysis
+            },
+            'nsfw_detection': {
+                'enabled': True,
+                'confidence_threshold': 0.7,
+                'skin_detection': False,  # Disable for CPU
+                'pose_analysis': False,
+                'region_analysis': False
+            },
+            'performance': {
+                'image_size': 320,  # Small size for CPU
+                'batch_size': 1,
+                'half_precision': False,
+                'use_flash_attention': False,
+                'cpu_optimization': True
+            },
+            'output': {
+                'save_detections': True,
+                'draw_boxes': False,  # Disable to save CPU
+                'log_results': True
+            }
+        }
+
+        moderator = ContentModerator(config=cpu_config)
+
+        status = moderator.get_model_status()
+        logger.info(f"Model Status: {status}")
+        logger.info("✅ Content Moderator initialized successfully for CPU")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize Content Moderator: {e}")
+        moderator = None
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    global moderator
+    if moderator:
+        logger.info("Shutting down Content Moderator...")
+        moderator = None
+    video_optimizer.clear_cache()
 
 
 # ============== Utility Functions ==============
@@ -184,49 +316,14 @@ async def save_upload_file(upload_file: UploadFile, destination: Path) -> Path:
         raise
 
 
-def detect_fight_in_frame(image: np.ndarray, persons: List[Dict]) -> Optional[FightDetection]:
-    """
-    Detect potential fight based on person proximity and poses
-    This is a simplified implementation - you may want to enhance this
-    """
-    if len(persons) < 2:
-        return None
-
-    # Check for overlapping or very close person bounding boxes
-    for i in range(len(persons)):
-        for j in range(i + 1, len(persons)):
-            bbox1 = persons[i]['bbox']
-            bbox2 = persons[j]['bbox']
-
-            # Calculate center points
-            center1_x = (bbox1[0] + bbox1[2]) / 2
-            center1_y = (bbox1[1] + bbox1[3]) / 2
-            center2_x = (bbox2[0] + bbox2[2]) / 2
-            center2_y = (bbox2[1] + bbox2[3]) / 2
-
-            # Calculate distance between centers
-            distance = np.sqrt((center1_x - center2_x) ** 2 + (center1_y - center2_y) ** 2)
-
-            # Calculate average person width
-            avg_width = ((bbox1[2] - bbox1[0]) + (bbox2[2] - bbox2[0])) / 2
-
-            # If persons are very close (distance less than average width)
-            if distance < avg_width * 1.5:
-                # Create combined bounding box
-                min_x = min(bbox1[0], bbox2[0])
-                min_y = min(bbox1[1], bbox2[1])
-                max_x = max(bbox1[2], bbox2[2])
-                max_y = max(bbox1[3], bbox2[3])
-
-                return FightDetection(
-                    type="fight",
-                    confidence=0.7,  # Simplified confidence
-                    bbox=BoundingBox(x1=min_x, y1=min_y, x2=max_x, y2=max_y),
-                    persons_involved=2,
-                    threat_level="high"
-                )
-
-    return None
+def safe_dict(obj):
+    """Convert object to dict safely"""
+    if hasattr(obj, 'dict'):
+        return obj.dict()
+    elif isinstance(obj, dict):
+        return obj
+    else:
+        return str(obj)
 
 
 def process_detections(raw_detections: List[Dict]) -> Dict[str, List]:
@@ -268,215 +365,140 @@ def process_detections(raw_detections: List[Dict]) -> Dict[str, List]:
                 skin_ratio=det.get('skin_ratio')
             ))
         elif det['type'] == 'fight':
-            processed['fights'].append(det)
+            processed['fights'].append(FightDetection(
+                type="fight",
+                confidence=det['confidence'],
+                bbox=BoundingBox(
+                    x1=det['bbox'][0],
+                    y1=det['bbox'][1],
+                    x2=det['bbox'][2],
+                    y2=det['bbox'][3]
+                ),
+                persons_involved=det.get('people_involved', 2),
+                threat_level=det.get('threat_level', 'high')
+            ))
 
     return processed
 
 
 # ============== API Endpoints ==============
 
-@app.on_event("startup")
-async def startup_event():
-    """Initialize moderator on startup"""
-    global moderator
-    try:
-        logger.info("Initializing Content Moderator...")
-
-        # Custom configuration for API
-        custom_config = {
-            'weapon_detection': {
-                'enabled': True,
-                'confidence_threshold': 0.5,
-                'knife_confidence': 0.25,
-                'model_size': 'yolo11n',
-                'classes': ['knife', 'dao', 'gun', 'rifle', 'pistol', 'weapon', 'fight'],
-                'use_enhancement': True,
-                'multi_pass': True,
-                'boost_knife_detection': True
-            },
-            'nsfw_detection': {
-                'enabled': True,
-                'confidence_threshold': 0.7,
-                'skin_detection': True,
-                'pose_analysis': False,  # Disabled for performance
-                'region_analysis': True
-            },
-            'performance': {
-                'image_size': 640,
-                'batch_size': 1,
-                'half_precision': True,
-                'use_flash_attention': False,
-                'cpu_optimization': False
-            },
-            'output': {
-                'save_detections': True,
-                'draw_boxes': True,
-                'log_results': True
-            }
-        }
-
-        moderator = ContentModerator(config=custom_config)
-        logger.info("✅ Content Moderator initialized successfully")
-
-        # Log model status
-        status = moderator.get_model_status()
-        logger.info(f"Model Status: {json.dumps(status, indent=2)}")
-
-    except Exception as e:
-        logger.error(f"Failed to initialize Content Moderator: {e}")
-        logger.error(traceback.format_exc())
-
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Cleanup on shutdown"""
-    executor.shutdown(wait=True)
-    logger.info("API shutdown complete")
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Weapon & NSFW Detection API",
+        "version": "2.0.0",
+        "status": "running" if moderator else "initializing",
+        "cpu_optimized": True,
+        "docs": "/docs"
+    }
 
 
-@app.get("/", response_model=Dict[str, Any])
-async def root():
-    """API root endpoint with status information"""
-    if moderator:
-        status = moderator.get_model_status()
-        return {
-            "service": "Weapon & NSFW Detection API",
-            "version": "2.0.0",
-            "status": "operational",
-            "models": status,
-            "endpoints": {
-                "image_detection": "/detect_n_k_f_g/images",
-                "video_detection": "/detect_n_k_f_g/videos",
-                "documentation": "/docs"
-            }
-        }
-    else:
+@app.get("/status")
+async def get_status():
+    """Check system status"""
+    if moderator is None:
         return {
-            "service": "Weapon & NSFW Detection API",
-            "version": "2.0.0",
-            "status": "initializing",
-            "message": "Models are being loaded..."
+            "status": "error",
+            "message": "Content Moderator not initialized"
         }
 
+    return {
+        "status": "ok",
+        "model_status": moderator.get_model_status(),
+        "memory_usage": moderator.get_memory_usage(),
+        "cache_size": len(video_optimizer.frame_cache),
+        "cpu_optimized": True
+    }
+
 
 @app.post("/detect_n_k_f_g/images", response_model=ImageDetectionResponse)
 async def detect_image(
-        file: UploadFile = File(..., description="Image file to analyze"),
-        enable_fight_detection: bool = Form(True, description="Enable fight detection"),
-        return_annotated: bool = Form(True, description="Return annotated image")
+        file: UploadFile = File(...),
+        return_annotated: bool = Form(False)
 ):
     """
-    Detect weapons (knife/dao/gun), fights, and NSFW content in images
-
-    Supports: JPG, JPEG, PNG, BMP, GIF, WEBP
-    Max size: 50MB
+    Detect weapons, fights, and NSFW content in images
+    Optimized for CPU processing
     """
+    if moderator is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Content Moderator not initialized"
+        )
+
     request_id = generate_request_id()
     start_time = datetime.now()
 
     try:
-        # Validate file extension
+        # Validate file
         if not validate_file_extension(file.filename, config.ALLOWED_IMAGE_EXTENSIONS):
             raise HTTPException(
                 status_code=400,
-                detail=f"Invalid file type. Allowed: {', '.join(config.ALLOWED_IMAGE_EXTENSIONS)}"
+                detail=f"Invalid file type"
             )
 
-        # Check file size
+        # Read file
         file_content = await file.read()
         file_size = len(file_content)
 
         if not validate_file_size(file_size, config.MAX_IMAGE_SIZE):
             raise HTTPException(
                 status_code=400,
-                detail=f"File too large. Maximum size: {config.MAX_IMAGE_SIZE / (1024 * 1024):.1f}MB"
+                detail=f"File too large. Max: {config.MAX_IMAGE_SIZE / (1024 * 1024):.1f}MB"
             )
 
-        # Save uploaded file
+        # Save file
         upload_path = config.UPLOAD_DIR / "images" / f"{request_id}_{file.filename}"
         async with aiofiles.open(upload_path, 'wb') as f:
             await f.write(file_content)
 
-        # Read image with OpenCV
+        # Decode image
         nparr = np.frombuffer(file_content, np.uint8)
         image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
 
         if image is None:
-            raise HTTPException(status_code=400, detail="Invalid or corrupted image file")
+            raise HTTPException(status_code=400, detail="Invalid image file")
 
         # Get image info
-        height, width, channels = image.shape
+        height, width = image.shape[:2]
         image_info = {
             "filename": file.filename,
             "width": width,
             "height": height,
-            "channels": channels,
-            "size_bytes": file_size,
             "size_mb": round(file_size / (1024 * 1024), 2)
         }
 
-        # Process image with ContentModerator
-        logger.info(f"Processing image {request_id}")
+        # Downscale for CPU if too large
+        if width > 640:
+            scale = 640 / width
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+            image = cv2.resize(image, (new_width, new_height))
+            logger.info(f"Downscaled image from {width}x{height} to {new_width}x{new_height}")
+
+        # Process image
         result = moderator.process_image(image)
 
         if not result:
-            raise HTTPException(status_code=500, detail="Detection processing failed")
-
-        # Detect persons for potential fight detection
-        persons = moderator.detect_persons(image)
-
-        # Check for fights if enabled
-        fight_detection = None
-        if enable_fight_detection and len(persons) >= 2:
-            fight_detection = detect_fight_in_frame(image, persons)
+            raise HTTPException(status_code=500, detail="Processing failed")
 
         # Process detections
         processed = process_detections(result['detections'])
 
-        # Add fight detection if found
-        if fight_detection:
-            processed['fights'].append(fight_detection)
-
-        # Save annotated image if requested
-        annotated_url = None
-        if return_annotated and config.ENABLE_ANNOTATED_OUTPUT:
-            if 'annotated_image' in result:
-                annotated_path = config.PROCESSED_DIR / "images" / f"{request_id}_annotated.jpg"
-                cv2.imwrite(str(annotated_path), result['annotated_image'])
-                annotated_url = f"/results/images/{request_id}_annotated.jpg"
-            else:
-                # Draw annotations manually if not provided
-                annotated_image = moderator.draw_detections(image.copy(), result['detections'])
-                annotated_path = config.PROCESSED_DIR / "images" / f"{request_id}_annotated.jpg"
-                cv2.imwrite(str(annotated_path), annotated_image)
-                annotated_url = f"/results/images/{request_id}_annotated.jpg"
-
         # Calculate summary
-        total_weapons = len(processed['weapons'])
-        total_nsfw = len(processed['nsfw'])
-        total_fights = len(processed['fights'])
-
-        knife_count = sum(
-            1 for w in processed['weapons'] if 'knife' in w.class_name.lower() or 'dao' in w.class_name.lower())
-        gun_count = sum(1 for w in processed['weapons'] if
-                        'gun' in w.class_name.lower() or 'pistol' in w.class_name.lower() or 'rifle' in w.class_name.lower())
-
         summary = {
-            "total_detections": total_weapons + total_nsfw + total_fights,
-            "weapons": {
-                "total": total_weapons,
-                "knives": knife_count,
-                "guns": gun_count
-            },
-            "nsfw": total_nsfw,
-            "fights": total_fights,
-            "persons_detected": len(persons)
+            "total_detections": len(result['detections']),
+            "weapons": len(processed['weapons']),
+            "nsfw": len(processed['nsfw']),
+            "fights": len(processed['fights'])
         }
 
-        # Determine overall risk level
-        if total_weapons > 0 or total_fights > 0:
-            risk_level = "critical" if gun_count > 0 else "high"
-        elif total_nsfw > 0:
+        # Determine risk level
+        if len(processed['weapons']) > 0 or len(processed['fights']) > 0:
+            risk_level = "high"
+        elif len(processed['nsfw']) > 0:
             risk_level = "medium"
         else:
             risk_level = "safe"
@@ -493,62 +515,62 @@ async def detect_image(
             summary=summary,
             risk_level=risk_level,
             action_required=(summary["total_detections"] > 0),
-            annotated_image_url=annotated_url,
             processing_time_ms=processing_time
         )
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error processing image {request_id}: {e}")
+        logger.error(f"Error processing image: {e}")
         logger.error(traceback.format_exc())
-        raise HTTPException(
-            status_code=500,
-            detail=f"Internal server error: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @app.post("/detect_n_k_f_g/videos", response_model=VideoDetectionResponse)
 async def detect_video(
-        file: UploadFile = File(..., description="Video file to analyze"),
-        frame_skip: int = Form(5, ge=1, le=30, description="Process every Nth frame"),
-        max_frames: int = Form(1000, ge=10, le=5000, description="Maximum frames to process"),
-        enable_fight_detection: bool = Form(True, description="Enable fight detection")
+        file: UploadFile = File(...),
+        quick_mode: bool = Form(True, description="Enable CPU optimizations"),
+        adaptive_settings: bool = Form(True, description="Auto-adjust settings"),
+        custom_frame_skip: Optional[int] = Form(None, ge=1, le=50)
 ):
     """
-    Detect weapons (knife/dao/gun), fights, and NSFW content in videos
-    Supports: MP4, AVI, MOV, MKV, WEBM, FLV, WMV
-    Max size: 500MB
-    Note: Videos are automatically deleted after processing to save disk space
+    Detect weapons, fights, and NSFW content in videos
+    CPU-optimized with smart frame skipping
     """
+    if moderator is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Content Moderator not initialized"
+        )
+
     request_id = generate_request_id()
     start_time = datetime.now()
-    upload_path = None
 
     try:
-        # Validate file extension
+        # Validate file
         if not validate_file_extension(file.filename, config.ALLOWED_VIDEO_EXTENSIONS):
             raise HTTPException(
                 status_code=400,
-                detail=f"Invalid file type. Allowed: {', '.join(config.ALLOWED_VIDEO_EXTENSIONS)}"
+                detail="Invalid video format"
             )
 
-        # Save uploaded video
+        # Save video
         upload_path = config.UPLOAD_DIR / "videos" / f"{request_id}_{file.filename}"
         await save_upload_file(file, upload_path)
 
-        # Get file size
+        # Check file size
         file_size = upload_path.stat().st_size
         if not validate_file_size(file_size, config.MAX_VIDEO_SIZE):
+            upload_path.unlink()
             raise HTTPException(
                 status_code=400,
-                detail=f"File too large. Maximum size: {config.MAX_VIDEO_SIZE / (1024 * 1024):.1f}MB"
+                detail=f"File too large. Max: {config.MAX_VIDEO_SIZE / (1024 * 1024):.1f}MB"
             )
 
         # Open video
         cap = cv2.VideoCapture(str(upload_path))
         if not cap.isOpened():
-            raise HTTPException(status_code=400, detail="Invalid or corrupted video file")
+            raise HTTPException(status_code=400, detail="Cannot open video file")
 
         # Get video info
         fps = cap.get(cv2.CAP_PROP_FPS)
@@ -564,22 +586,43 @@ async def detect_video(
             "fps": fps,
             "total_frames": total_frames,
             "duration_seconds": round(duration, 2),
-            "size_bytes": file_size,
             "size_mb": round(file_size / (1024 * 1024), 2)
         }
 
-        # Process video frames
-        logger.info(f"Processing video {request_id}: {total_frames} frames, skip={frame_skip}")
+        # Get optimal settings
+        if adaptive_settings:
+            settings = video_optimizer.get_optimal_settings(duration, total_frames)
+            frame_skip = custom_frame_skip or settings['frame_skip']
+            target_width = settings['target_width']
+            max_frames = settings['max_frames']
+        else:
+            frame_skip = custom_frame_skip or config.VIDEO_FRAME_SKIP
+            target_width = config.VIDEO_TARGET_WIDTH
+            max_frames = config.VIDEO_MAX_FRAMES
+
+        logger.info(f"Video settings: skip={frame_skip}, width={target_width}, max={max_frames}")
+
+        # Clear cache for new video
+        video_optimizer.clear_cache()
 
+        # Processing variables
         frame_detections = []
         frame_count = 0
         processed_count = 0
+        threat_count = 0
+        critical_threat = False
 
         # Aggregated statistics
         all_weapons = []
         all_nsfw = []
         all_fights = []
 
+        # Temporary optimize settings for video processing
+        if quick_mode:
+            original_size = moderator.config['performance']['image_size']
+            moderator.config['performance']['image_size'] = target_width
+
+        # Process video
         while True:
             ret, frame = cap.read()
             if not ret:
@@ -587,88 +630,97 @@ async def detect_video(
 
             frame_count += 1
 
-            # Skip frames according to frame_skip parameter
+            # Skip frames
             if frame_count % frame_skip != 0:
                 continue
 
-            # Limit maximum frames processed
+            # Check max frames limit
             if processed_count >= max_frames:
                 logger.info(f"Reached max frames limit: {max_frames}")
                 break
 
+            # Preprocess frame
+            frame = video_optimizer.preprocess_frame(frame, target_width)
+
+            # Skip similar frames
+            if video_optimizer.should_skip_frame(frame):
+                continue
+
             processed_count += 1
 
             # Process frame
             result = moderator.process_image(frame)
 
             if result and result['detections']:
-                # Get persons for fight detection
-                persons = moderator.detect_persons(frame)
-
-                # Check for fights
-                fight_detection = None
-                if enable_fight_detection and len(persons) >= 2:
-                    fight_detection = detect_fight_in_frame(frame, persons)
-
                 # Process detections
                 processed = process_detections(result['detections'])
 
-                if fight_detection:
-                    processed['fights'].append(fight_detection)
+                # Track threats
+                current_threats = len(result['detections'])
+                threat_count += current_threats
+
+                # Check for critical threats
+                for det in result['detections']:
+                    if det.get('threat_level') == 'critical':
+                        critical_threat = True
 
-                # Store frame detection info
-                if len(processed['weapons']) > 0 or len(processed['nsfw']) > 0 or len(processed['fights']) > 0:
+                # Store frame detection info (simplified)
+                if current_threats > 0:
                     frame_info = {
                         "frame_number": frame_count,
-                        "timestamp_seconds": frame_count / fps if fps > 0 else 0,
+                        "timestamp_seconds": round(frame_count / fps, 2),
                         "detections": {
-                            "weapons": [w.dict() for w in processed['weapons']],
-                            "nsfw": [n.dict() for n in processed['nsfw']],
-                            "fights": [f.dict() for f in processed['fights']]
-                        }
+                            "weapons": len(processed['weapons']),
+                            "nsfw": len(processed['nsfw']),
+                            "fights": len(processed['fights'])
+                        },
+                        "threat_level": "critical" if critical_threat else "high"
                     }
                     frame_detections.append(frame_info)
 
-                    # Aggregate statistics
+                    # Aggregate
                     all_weapons.extend(processed['weapons'])
                     all_nsfw.extend(processed['nsfw'])
                     all_fights.extend(processed['fights'])
 
-            # Log progress every 100 frames
-            if processed_count % 100 == 0:
-                logger.info(f"Processed {processed_count} frames...")
+                # Early stopping
+                if critical_threat and threat_count >= config.VIDEO_EARLY_STOP_THRESHOLD:
+                    logger.info(f"Critical threats detected ({threat_count}), early stopping")
+                    break
 
-        # Release resources
+            # Progress log
+            if processed_count % 20 == 0:
+                elapsed = (datetime.now() - start_time).total_seconds()
+                frames_per_sec = processed_count / elapsed if elapsed > 0 else 0
+                logger.info(f"Processed {processed_count} frames in {elapsed:.1f}s ({frames_per_sec:.1f} fps)")
+
+        # Restore original settings
+        if quick_mode:
+            moderator.config['performance']['image_size'] = original_size
+
+        # Release video
         cap.release()
 
-        # Calculate summary
-        knife_count = sum(1 for w in all_weapons if 'knife' in w.class_name.lower() or 'dao' in w.class_name.lower())
-        gun_count = sum(1 for w in all_weapons if 'gun' in w.class_name.lower() or 'pistol' in w.class_name.lower())
+        # Clean up uploaded file
+        try:
+            upload_path.unlink()
+        except:
+            pass
 
+        # Calculate summary
         summary = {
             "total_frames_analyzed": processed_count,
             "frames_with_detections": len(frame_detections),
-            "total_detections": len(all_weapons) + len(all_nsfw) + len(all_fights),
-            "weapons": {
-                "total": len(all_weapons),
-                "knives": knife_count,
-                "guns": gun_count,
-                "unique_frames": len(set(f["frame_number"] for f in frame_detections if f["detections"]["weapons"]))
-            },
-            "nsfw": {
-                "total": len(all_nsfw),
-                "unique_frames": len(set(f["frame_number"] for f in frame_detections if f["detections"]["nsfw"]))
-            },
-            "fights": {
-                "total": len(all_fights),
-                "unique_frames": len(set(f["frame_number"] for f in frame_detections if f["detections"]["fights"]))
-            }
+            "total_detections": threat_count,
+            "weapons": len(all_weapons),
+            "nsfw": len(all_nsfw),
+            "fights": len(all_fights)
         }
 
-        # Determine overall risk level
-        if gun_count > 0 or len(all_fights) > 5:
+        # Determine risk level
+        if critical_threat or len(all_weapons) > 5:
             risk_level = "critical"
-        elif knife_count > 0 or len(all_fights) > 0:
+        elif len(all_weapons) > 0 or len(all_fights) > 0:
             risk_level = "high"
         elif len(all_nsfw) > 0:
             risk_level = "medium"
@@ -678,71 +730,58 @@ async def detect_video(
         # Calculate processing time
         processing_time = (datetime.now() - start_time).total_seconds() * 1000
 
+        # Optimization info
+        optimization_used = {
+            "frame_skip": frame_skip,
+            "resolution": target_width,
+            "max_frames": max_frames,
+            "frames_cached": len(video_optimizer.frame_cache),
+            "early_stopped": critical_threat and threat_count >= config.VIDEO_EARLY_STOP_THRESHOLD
+        }
+
         return VideoDetectionResponse(
             success=True,
             request_id=request_id,
             timestamp=datetime.now().isoformat(),
             video_info=video_info,
             total_frames_processed=processed_count,
-            frame_detections=frame_detections,
+            frame_detections=frame_detections[:50],  # Limit to 50 detections
             summary=summary,
             risk_level=risk_level,
             action_required=(summary["total_detections"] > 0),
-            processed_video_url=None,  # Always None since we don't save processed videos
-            processing_time_ms=processing_time
+            processing_time_ms=processing_time,
+            optimization_used=optimization_used
         )
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error processing video {request_id}: {e}")
+        logger.error(f"Error processing video: {e}")
         logger.error(traceback.format_exc())
-        raise HTTPException(
-            status_code=500,
-            detail=f"Internal server error: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=str(e))
     finally:
-        # Always cleanup uploaded video file after processing
-        if upload_path and upload_path.exists():
-            try:
-                upload_path.unlink()
-                logger.info(f"Cleaned up uploaded video: {upload_path}")
-            except Exception as cleanup_error:
-                logger.warning(f"Failed to cleanup uploaded video {upload_path}: {cleanup_error}")
+        # Clear cache after video processing
+        video_optimizer.clear_cache()
 
 
 @app.delete("/cleanup")
 async def cleanup_old_files(hours: int = 24):
-    """Clean up old files from upload and results directories (excluding videos from uploads as they are auto-deleted)"""
+    """Clean up old files"""
     try:
         from datetime import timedelta
         cutoff_time = datetime.now() - timedelta(hours=hours)
 
         deleted_count = 0
-        
-        # Clean up images from all directories
         for directory in [config.UPLOAD_DIR, config.RESULTS_DIR, config.PROCESSED_DIR]:
-            images_path = directory / "images"
-            if images_path.exists():
-                for file in images_path.iterdir():
-                    if file.is_file():
-                        file_time = datetime.fromtimestamp(file.stat().st_mtime)
-                        if file_time < cutoff_time:
-                            file.unlink()
-                            deleted_count += 1
-
-        # Clean up any remaining uploaded videos (should be rare since they're auto-deleted)
-        upload_videos_path = config.UPLOAD_DIR / "videos"
-        if upload_videos_path.exists():
-            for file in upload_videos_path.iterdir():
-                if file.is_file():
-                    file_time = datetime.fromtimestamp(file.stat().st_mtime)
-                    if file_time < cutoff_time:
-                        file.unlink()
-                        deleted_count += 1
-                        logger.info(f"Cleaned up old uploaded video: {file}")
-
-        # Note: No need to clean processed videos since we don't save them anymore
+            for subdir in ["images", "videos"]:
+                path = directory / subdir
+                if path.exists():
+                    for file in path.iterdir():
+                        if file.is_file():
+                            file_time = datetime.fromtimestamp(file.stat().st_mtime)
+                            if file_time < cutoff_time:
+                                file.unlink()
+                                deleted_count += 1
 
         return {
             "success": True,
@@ -751,10 +790,8 @@ async def cleanup_old_files(hours: int = 24):
         }
     except Exception as e:
         logger.error(f"Cleanup error: {e}")
-        return {
-            "success": False,
-            "error": str(e)
-        }
+        return {"success": False, "error": str(e)}
+
 
 if __name__ == "__main__":
     import os