Yolo

.dockerignore.prod

@@ -0,0 +1,48 @@
+# Ignore all test files
+test_*.py
+tests/
+test_files/
+test_output/
+eda.ipynb
+*.ipynb
+
+# Temporary files
+tmp*
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+
+# Ignore smaller YOLOv8 models (we only need YOLOv8x)
+yolov8n.pt
+yolov8s.pt
+yolov8m.pt
+yolov8l.pt
+# Note: don't ignore yolov8x.pt - we need it!
+
+# Documentation files not needed for runtime
+*.md
+*.txt
+!requirements.txt
+
+# Debug scripts
+debug_*.py
+create_test_*.py
+generate_*.py
+list_*.py
+train_*.py
+
+# Git files
+.git/
+.gitattributes
+.gitignore
+
+# Environment and IDE files
+.env
+.vscode/
+.idea/
+
+# Only needed for development
+requirements-*.txt
+!requirements.txt
+Dockerfile.simple

DEPLOYMENT.md

@@ -0,0 +1,69 @@
+# Marine Pollution Detection System - Deployment Guide
+
+This guide provides instructions for deploying the Marine Pollution Detection system using YOLOv8x for optimal detection accuracy.
+
+## Deployment Preparation
+
+### Option 1: Using the Automated Script (Recommended)
+
+1. Run the deployment preparation script:
+
+   **For Windows:**
+   ```
+   prepare_deployment.bat
+   ```
+
+   **For Linux/Mac:**
+   ```
+   chmod +x prepare_deployment.sh
+   ./prepare_deployment.sh
+   ```
+
+2. Build the Docker container:
+   ```
+   docker build -t marine-pollution-api .
+   ```
+
+3. Run the container:
+   ```
+   docker run -p 7860:7860 marine-pollution-api
+   ```
+
+### Option 2: Manual Deployment
+
+1. Clean up unnecessary files:
+   - Remove all test files (`test_*.py`, `test_files/`, `test_output/`, etc.)
+   - Remove smaller YOLO models (keep only `yolov8x.pt`)
+   - Remove development utilities (`debug_*.py`, etc.)
+
+2. Use the production Dockerfile:
+   ```
+   cp Dockerfile.prod Dockerfile
+   cp .dockerignore.prod .dockerignore
+   ```
+
+3. Build and run the Docker container as described in Option 1.
+
+## Important Notes
+
+1. **YOLOv8x Model**: The system now exclusively uses YOLOv8x (the largest/most accurate model) for marine pollution detection. The model file will be downloaded automatically on the first run if it doesn't exist.
+
+2. **Image Annotation**: The output images now have more subtle scene annotations in small text to improve readability.
+
+3. **Deployment Size**: The Docker image is optimized to include only necessary files for production use.
+
+4. **First Run**: The first time the system runs, it will download the YOLOv8x model (approximately 136MB). Subsequent runs will use the downloaded model.
+
+5. **Requirements**: Make sure the deployment environment has sufficient memory and processing power to run YOLOv8x effectively.
+
+## Troubleshooting
+
+1. **Model Download Issues**: If the model download fails, check your internet connection. If you want to manually provide the YOLOv8x model, place the file in the root directory of the project.
+
+2. **Performance Optimization**: For better performance on low-resource environments, consider adding memory management optimizations or serving the model with ONNX Runtime.
+
+3. **Errors**: Check the logs for detailed error messages. Most issues are related to model loading or file paths.
+
+## Contact
+
+For any deployment issues or questions, please contact the development team.

Dockerfile.prod

@@ -0,0 +1,56 @@
+# Production Dockerfile for Marine Pollution Detection API
+# Optimized for deployment with only necessary files included
+
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Create a non-root user for security
+RUN useradd --create-home --shell /bin/bash app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy only the requirements file first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy only the necessary application files (explicitly excluding test files)
+COPY app/ /app/app/
+COPY models/ /app/models/
+COPY start-hf.sh /app/
+COPY Procfile /app/
+COPY Procfile.railway /app/
+
+# Create necessary directories with proper permissions
+RUN mkdir -p app/uploads /tmp/uploads && \
+    chown -R app:app /app /tmp/uploads && \
+    chmod -R 755 /app /tmp/uploads
+
+# Make startup script executable
+RUN chmod +x start-hf.sh && chown app:app start-hf.sh
+
+# Switch to non-root user
+USER app
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Command to run the application
+CMD ["./start-hf.sh"]

app/routers/incidents.py

@@ -49,16 +49,24 @@ async def classify_incident_report(
             incident_class, severity = classification_result
             confidence_scores = None
 
-        # Upload image to Cloudinary
+        # Upload image to Cloudinary and process with object detection
         image_path = None
+        annotated_image_path = None
+        detection_results = None
+        
         if image:
-            image_path = await store_image(image)
-            if not image_path:
+            image_result = await store_image(image)
+            if not image_result:
                 # If Cloudinary upload fails, raise an error since we're not using local fallback
                 raise HTTPException(
                     status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                     detail="Failed to upload image to cloud storage"
                 )
+            
+            # Extract the image paths and detection results
+            image_path = image_result["image_url"]
+            annotated_image_path = image_result["annotated_image_url"]
+            detection_results = image_result["detection_results"]
 
         document = {
             "name": name,
@@ -69,6 +77,8 @@ async def classify_incident_report(
             "severity": severity,
             "reporter_id": current_user["id"],
             "image_path": image_path,
+            "annotated_image_path": annotated_image_path,
+            "detection_results": detection_results,
             "created_at": datetime.utcnow(),
         }
 
@@ -129,10 +139,18 @@ async def list_incidents(current_user=Depends(get_current_user)):
 @router.post("/update-status/{incident_id}")
 async def update_status(
     incident_id: str,
-    status: str = Body(..., embed=True),
+    data: dict = Body(...),
     current_user=Depends(get_current_user),
 ):
-    """Update the status of an incident (validated, rejected, investigating)"""
+    """
+    Update the status of an incident (validated, rejected, investigating)
+    
+    Request body format:
+    {
+      "status": "validated" | "rejected" | "investigating",
+      "comment": "Optional explanation for the status change" (optional)
+    }
+    """
     if not is_database_available():
         raise HTTPException(
             status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
@@ -146,8 +164,18 @@ async def update_status(
             detail="Only validators can update incident status"
         )
     
+    # Extract status and optional comment from request body
+    if not data or "status" not in data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing required field 'status' in request body"
+        )
+    
+    incident_status = data["status"]
+    comment = data.get("comment")  # Optional field
+    
     # Validate the status value
-    if status not in ["validated", "rejected", "investigating"]:
+    if incident_status not in ["validated", "rejected", "investigating"]:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="Invalid status. Must be one of: validated, rejected, investigating"
@@ -156,12 +184,16 @@ async def update_status(
     try:
         success = await update_incident_status(
             incident_id=incident_id,
-            status=status,
-            validator_id=current_user["id"]
+            status=incident_status,
+            validator_id=current_user["id"],
+            comment=comment
         )
         
         if success:
-            return {"message": f"Incident status updated to {status}"}
+            response_message = f"Incident status updated to {incident_status}"
+            if comment:
+                response_message += " with comment"
+            return {"message": response_message}
         else:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,

app/services/fallback_detection.py

@@ -0,0 +1,371 @@
+"""
+Fallback detection module for when the main YOLO model fails due to
+torchvision or other dependency issues.
+
+This provides a simple detection mechanism without dependencies on 
+PyTorch or torchvision.
+"""
+
+import logging
+import numpy as np
+import os
+import tempfile
+from typing import Dict, List, Optional, Tuple, Union
+import uuid
+
+# Initialize logger
+logger = logging.getLogger(__name__)
+
+# Try to import OpenCV, but don't fail if not available
+try:
+    import cv2
+    HAS_CV2 = True
+except ImportError:
+    HAS_CV2 = False
+    logger.warning("OpenCV (cv2) not available in fallback_detection module")
+
+# Basic color detection thresholds
+# These are simple HSV thresholds for detecting common pollution colors
+COLOR_THRESHOLDS = {
+    "oil_spill": {
+        "lower": np.array([0, 0, 0]),
+        "upper": np.array([180, 255, 80]),
+        "label": "Potential Oil Spill",
+        "confidence": 0.6
+    },
+    "plastic_bright": {
+        "lower": np.array([0, 50, 180]),
+        "upper": np.array([30, 255, 255]),
+        "label": "Potential Plastic Debris",
+        "confidence": 0.7
+    },
+    "foam_pollution": {
+        "lower": np.array([0, 0, 200]),
+        "upper": np.array([180, 30, 255]),
+        "label": "Potential Foam/Chemical Pollution",
+        "confidence": 0.65
+    },
+    # Enhanced plastic bottle detection thresholds
+    "plastic_bottles_clear": {
+        "lower": np.array([0, 0, 140]),
+        "upper": np.array([180, 60, 255]),
+        "label": "plastic bottle",  # Updated label to match YOLO naming
+        "confidence": 0.80
+    },
+    "plastic_bottles_blue": {
+        "lower": np.array([90, 40, 100]),
+        "upper": np.array([130, 255, 255]),
+        "label": "plastic bottle",
+        "confidence": 0.75
+    },
+    "plastic_bottles_green": {
+        "lower": np.array([35, 40, 100]),
+        "upper": np.array([85, 255, 255]),
+        "label": "plastic bottle",
+        "confidence": 0.75
+    },
+    "plastic_bottles_white": {
+        "lower": np.array([0, 0, 180]),
+        "upper": np.array([180, 30, 255]),
+        "label": "plastic bottle",
+        "confidence": 0.75
+    },
+    "plastic_bottles_cap": {
+        "lower": np.array([100, 100, 100]),
+        "upper": np.array([140, 255, 255]),
+        "label": "plastic bottle cap",
+        "confidence": 0.85
+    },
+    "blue_plastic": {
+        "lower": np.array([90, 50, 50]),
+        "upper": np.array([130, 255, 255]),
+        "label": "plastic waste",  # Updated label for consistency
+        "confidence": 0.6
+    },
+    "green_plastic": {
+        "lower": np.array([35, 50, 50]),
+        "upper": np.array([85, 255, 255]),
+        "label": "plastic waste",
+        "confidence": 0.6
+    },
+    "white_plastic": {
+        "lower": np.array([0, 0, 190]),
+        "upper": np.array([180, 30, 255]),
+        "label": "plastic waste",
+        "confidence": 0.6
+    }
+}
+
+def analyze_texture_for_pollution(img):
+    """
+    Analyze image texture to detect unnatural patterns that could be debris.
+    Uses edge detection and morphological operations to find potential plastic debris.
+    Enhanced for better plastic bottle detection.
+    
+    Args:
+        img: OpenCV image in BGR format
+        
+    Returns:
+        List of bounding boxes for potential debris based on texture
+    """
+    try:
+        # Convert to grayscale
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # Apply Gaussian blur to reduce noise
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+        
+        # Apply Canny edge detection
+        edges = cv2.Canny(blurred, 50, 150)
+        
+        # Dilate edges to connect nearby edges
+        kernel = np.ones((3, 3), np.uint8)
+        dilated_edges = cv2.dilate(edges, kernel, iterations=2)
+        
+        # Find contours in the edge map
+        contours, _ = cv2.findContours(dilated_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Also do a more specific search for bottle-shaped objects
+        # Convert to HSV for color filtering
+        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+        
+        # Create a combined mask for common bottle colors
+        bottle_mask = np.zeros_like(gray)
+        
+        # Clear/translucent plastic
+        clear_mask = cv2.inRange(hsv, np.array([0, 0, 140]), np.array([180, 60, 255]))
+        bottle_mask = cv2.bitwise_or(bottle_mask, clear_mask)
+        
+        # Blue plastic
+        blue_mask = cv2.inRange(hsv, np.array([90, 40, 100]), np.array([130, 255, 255]))
+        bottle_mask = cv2.bitwise_or(bottle_mask, blue_mask)
+        
+        # Apply morphological operations to clean up the mask
+        bottle_mask = cv2.morphologyEx(bottle_mask, cv2.MORPH_CLOSE, kernel)
+        bottle_mask = cv2.morphologyEx(bottle_mask, cv2.MORPH_OPEN, kernel)
+        
+        # Find contours in the bottle mask
+        bottle_contours, _ = cv2.findContours(bottle_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Filter contours by various criteria to find unnatural patterns
+        debris_regions = []
+        
+        # Process regular edge contours
+        for contour in contours:
+            # Calculate area and perimeter
+            area = cv2.contourArea(contour)
+            perimeter = cv2.arcLength(contour, True)
+            
+            # Skip very small contours
+            if area < 100:
+                continue
+                
+            # Calculate shape metrics
+            if perimeter > 0:
+                circularity = 4 * np.pi * area / (perimeter * perimeter)
+                
+                # Unnatural objects tend to have specific circularity ranges
+                # (not too circular, not too irregular)
+                if 0.2 < circularity < 0.8:
+                    x, y, w, h = cv2.boundingRect(contour)
+                    
+                    # Calculate aspect ratio
+                    aspect_ratio = float(w) / h if h > 0 else 0
+                    
+                    # Most natural objects don't have extreme aspect ratios
+                    if 0.2 < aspect_ratio < 5:
+                        # Get ROI and check for texture uniformity
+                        roi = gray[y:y+h, x:x+w]
+                        if roi.size > 0:
+                            # Calculate standard deviation of pixel values
+                            std_dev = np.std(roi)
+                            
+                            # Man-made objects often have uniform textures
+                            if std_dev < 40:
+                                debris_regions.append({
+                                    "bbox": [x, y, x+w, y+h],
+                                    "confidence": 0.55,
+                                    "class": "Potential Debris (Texture)"
+                                })
+        
+        # Process bottle-specific contours with higher confidence
+        for contour in bottle_contours:
+            area = cv2.contourArea(contour)
+            if area < 200:  # Higher threshold for bottles
+                continue
+                
+            perimeter = cv2.arcLength(contour, True)
+            if perimeter <= 0:
+                continue
+                
+            # Get bounding rectangle
+            x, y, w, h = cv2.boundingRect(contour)
+            
+            # Calculate aspect ratio - bottles typically have aspect ratio between 0.2 and 0.7
+            aspect_ratio = float(w) / h if h > 0 else 0
+            
+            # Bottle detection criteria - bottles are usually taller than wide
+            if 0.2 < aspect_ratio < 0.7 and h > 50:
+                # This is likely to be a bottle based on shape
+                bottle_confidence = 0.70
+                
+                # Get ROI for additional checks
+                roi_hsv = hsv[y:y+h, x:x+w]
+                if roi_hsv.size > 0:
+                    # Check for uniformity in color which is common in bottles
+                    h_std = np.std(roi_hsv[:,:,0])
+                    s_std = np.std(roi_hsv[:,:,1])
+                    
+                    # Bottles often have uniform hue and saturation
+                    if h_std < 30 and s_std < 60:
+                        bottle_confidence = 0.85  # Higher confidence for uniform color
+                
+                debris_regions.append({
+                    "bbox": [x, y, x+w, y+h],
+                    "confidence": bottle_confidence,
+                    "class": "Plastic Bottle"
+                })
+        
+        return debris_regions
+    except Exception as e:
+        logger.error(f"Texture analysis failed: {str(e)}")
+        return []
+
+def fallback_detect_objects(image_path: str) -> Dict:
+    """
+    Perform a simple color-based detection when ML detection fails.
+    Uses basic computer vision techniques to detect potential pollution.
+    
+    Args:
+        image_path: Path to the image file
+    
+    Returns:
+        Dict with detections in the same format as the main detection function
+    """
+    if not HAS_CV2:
+        logger.warning("OpenCV not available for fallback detection")
+        return {"detections": [], "detection_count": 0, "annotated_image_url": None}
+    
+    try:
+        # Read the image
+        img = cv2.imread(image_path)
+        if img is None:
+            logger.error(f"Failed to read image at {image_path} in fallback detection")
+            return {"detections": [], "detection_count": 0, "annotated_image_url": None}
+        
+        # Convert to HSV for better color detection
+        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+        
+        # Make a copy for annotation
+        annotated = img.copy()
+        
+        # Initialize detections
+        detections = []
+        
+        # First check if the image contains water
+        has_water = detect_water_body(image_path)
+        logger.info(f"Water detection result: {'water detected' if has_water else 'no significant water detected'}")
+        
+        # Run texture-based detection for potential debris
+        texture_detections = analyze_texture_for_pollution(img)
+        detections.extend(texture_detections)
+        logger.info(f"Texture analysis found {len(texture_detections)} potential debris objects")
+        
+        # Detect potential pollution based on color profiles
+        for pollution_type, thresholds in COLOR_THRESHOLDS.items():
+            # Create mask using HSV thresholds
+            mask = cv2.inRange(hsv, thresholds["lower"], thresholds["upper"])
+            
+            # Apply some morphological operations to clean up the mask
+            kernel = np.ones((5, 5), np.uint8)
+            mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+            mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+            
+            # Find contours
+            contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            # Filter out small contours, but with a smaller threshold for plastic debris
+            if "plastic" in pollution_type:
+                # More sensitive threshold for plastic items (0.5% of image)
+                min_area = img.shape[0] * img.shape[1] * 0.005
+            else:
+                # Standard threshold for other pollution (1% of image)
+                min_area = img.shape[0] * img.shape[1] * 0.01
+                
+            filtered_contours = [cnt for cnt in contours if cv2.contourArea(cnt) > min_area]
+            
+            # Process filtered contours
+            for contour in filtered_contours:
+                # Get bounding box
+                x, y, w, h = cv2.boundingRect(contour)
+                
+                # Add to detections
+                detections.append({
+                    "class": thresholds["label"],
+                    "confidence": thresholds["confidence"],
+                    "bbox": [x, y, x + w, y + h]
+                })
+                
+                # Draw on the annotated image
+                cv2.rectangle(annotated, (x, y), (x + w, y + h), (0, 255, 0), 2)
+                
+                # Add label
+                label = f"{thresholds['label']}: {thresholds['confidence']:.2f}"
+                cv2.putText(annotated, label, (x, y - 10), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        
+        # Save the annotated image
+        annotated_image_path = f"{image_path}_fallback_annotated.jpg"
+        cv2.imwrite(annotated_image_path, annotated)
+        
+        # Return the results - would normally upload image in real implementation
+        return {
+            "detections": detections,
+            "detection_count": len(detections),
+            "annotated_image_path": annotated_image_path,
+            "method": "fallback_color_detection"
+        }
+        
+    except Exception as e:
+        logger.error(f"Fallback detection failed: {str(e)}")
+        return {"detections": [], "detection_count": 0, "annotated_image_url": None}
+        
+def detect_water_body(image_path: str) -> bool:
+    """
+    Simple detection to check if an image contains a large water body.
+    This helps validate if the image is related to marine environment.
+    
+    Args:
+        image_path: Path to the image file
+    
+    Returns:
+        True if a significant water body is detected
+    """
+    if not HAS_CV2:
+        return True  # Assume yes if we can't check
+    
+    try:
+        # Read image
+        img = cv2.imread(image_path)
+        if img is None:
+            return False
+            
+        # Convert to HSV
+        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+        
+        # Water detection thresholds (blue/green tones)
+        lower_water = np.array([90, 50, 50])  # Blue/green hues
+        upper_water = np.array([150, 255, 255])
+        
+        # Create mask
+        mask = cv2.inRange(hsv, lower_water, upper_water)
+        
+        # Calculate percentage of water-like pixels
+        water_percentage = np.sum(mask > 0) / (mask.shape[0] * mask.shape[1])
+        
+        # Return True if water covers at least 30% of image
+        return water_percentage > 0.3
+        
+    except Exception as e:
+        logger.error(f"Water detection failed: {str(e)}")
+        return True  # Assume yes if detection fails

app/services/incidents.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict, Any, List, Union
 from uuid import uuid4
 import logging
 import cloudinary
@@ -7,8 +7,11 @@ import cloudinary.uploader
 import tempfile
 import os
 from datetime import datetime
+import asyncio
+
 from ..database import get_collection
 from ..config import get_settings
+from .image_processing import detect_objects_in_image
 
 logger = logging.getLogger(__name__)
 INCIDENTS_COLLECTION = "incidents"
@@ -35,7 +38,12 @@ async def get_all_incidents() -> list:
     return await cursor.to_list(length=None)
 
 
-async def update_incident_status(incident_id: str, status: str, validator_id: str) -> bool:
+async def update_incident_status(
+    incident_id: str, 
+    status: str, 
+    validator_id: str, 
+    comment: Optional[str] = None
+) -> bool:
     """
     Update the status of an incident
     
@@ -43,6 +51,7 @@ async def update_incident_status(incident_id: str, status: str, validator_id: st
         incident_id: The ID of the incident to update
         status: The new status (validated, rejected, investigating)
         validator_id: The ID of the validator who updated the status
+        comment: Optional comment from the validator explaining the decision
     
     Returns:
         True if the update was successful, False otherwise
@@ -54,14 +63,21 @@ async def update_incident_status(incident_id: str, status: str, validator_id: st
         from bson import ObjectId
         object_id = ObjectId(incident_id)
         
+        # Prepare the update with status and validator information
+        update_data = {
+            "status": status,
+            "validated_by": validator_id,
+            "validated_at": datetime.utcnow(),
+        }
+        
+        # Add comment if provided
+        if comment:
+            update_data["validator_comment"] = comment
+        
         # Update the incident with the new status and validator information
         result = await collection.update_one(
             {"_id": object_id},
-            {"$set": {
-                "status": status,
-                "validated_by": validator_id,
-                "validated_at": datetime.utcnow()
-            }}
+            {"$set": update_data}
         )
         
         return result.modified_count > 0
@@ -70,10 +86,15 @@ async def update_incident_status(incident_id: str, status: str, validator_id: st
         return False
 
 
-async def store_image(upload_file) -> Optional[str]:
+async def store_image(upload_file) -> Dict[str, Any]:
     """
-    Store an uploaded image using Cloudinary only.
-    No local fallback - if Cloudinary upload fails, the function will return None.
+    Store an uploaded image using Cloudinary and process it with object detection.
+    Returns a dictionary with:
+    - image_url: The URL of the original uploaded image
+    - annotated_image_url: The URL of the image with object detection boxes (if available)
+    - detection_results: Object detection results (if available)
+    
+    If upload fails, returns None
     """
     if upload_file is None:
         return None
@@ -102,12 +123,49 @@ async def store_image(upload_file) -> Optional[str]:
             resource_type="auto"
         )
         
-        # Return the Cloudinary URL
+        # Get the Cloudinary URL
         cloudinary_url = upload_result["secure_url"]
         logger.info(f"Cloudinary upload successful. URL: {cloudinary_url}")
         
+        # Initialize the result dictionary
+        result = {
+            "image_url": cloudinary_url,
+            "annotated_image_url": None,
+            "detection_results": None
+        }
+        
+        # Run object detection on the uploaded image
+        try:
+            logger.info("Running object detection on uploaded image")
+            detection_result = await detect_objects_in_image(cloudinary_url)
+            
+            if detection_result:
+                result["detection_results"] = detection_result["detections"]
+                result["annotated_image_url"] = detection_result["annotated_image_url"]
+                
+                if detection_result["detection_count"] > 0:
+                    logger.info(f"Object detection successful. Found {detection_result['detection_count']} objects.")
+                    # Log the detected classes
+                    classes = [f"{d['class']} ({int(d['confidence']*100)}%)" for d in detection_result["detections"]]
+                    logger.info(f"Detected objects: {', '.join(classes)}")
+                else:
+                    logger.info("Object detection completed but no relevant objects found in image")
+            else:
+                logger.warning("Object detection failed or returned None")
+                
+                # Since detection failed, we'll use the original image as the annotated one
+                # This ensures the frontend still works properly
+                result["annotated_image_url"] = cloudinary_url
+                result["detection_results"] = []
+                
+        except Exception as e:
+            logger.error(f"Error in object detection: {e}", exc_info=True)
+            # Provide fallback values to ensure frontend functionality
+            result["annotated_image_url"] = cloudinary_url  # Use original as fallback
+            result["detection_results"] = []  # Empty detection results
+        
         await upload_file.close()
-        return cloudinary_url
+        return result
     
     except Exception as e:
         logger.error(f"Failed to upload image to Cloudinary: {e}", exc_info=True)

prepare_deployment.bat

@@ -0,0 +1,48 @@
+@echo off
+REM Deployment script for Marine Pollution Detection API
+REM This script cleans up unnecessary files and prepares for deployment
+
+echo Starting deployment preparation...
+
+REM 1. Remove all test files
+echo Removing test files...
+for /r %%i in (test_*.py) do del "%%i"
+if exist test_files\ rd /s /q test_files
+if exist test_output\ rd /s /q test_output
+if exist tests\ rd /s /q tests
+
+REM 2. Remove unnecessary Python files
+echo Removing unnecessary Python files...
+if exist debug_cloudinary.py del debug_cloudinary.py
+if exist create_test_user.py del create_test_user.py
+if exist generate_test_incidents.py del generate_test_incidents.py
+if exist list_incidents.py del list_incidents.py
+if exist train_models.py del train_models.py
+
+REM 3. Remove smaller YOLOv8 models (we only need YOLOv8x)
+echo Removing smaller YOLO models...
+if exist yolov8n.pt del yolov8n.pt
+if exist yolov8s.pt del yolov8s.pt
+if exist yolov8m.pt del yolov8m.pt
+if exist yolov8l.pt del yolov8l.pt
+REM Note: Keep yolov8x.pt as it's required
+
+REM 4. Use production Dockerfile and .dockerignore
+echo Setting up production Docker files...
+copy Dockerfile.prod Dockerfile /Y
+copy .dockerignore.prod .dockerignore /Y
+
+REM 5. Clean up Python cache files
+echo Cleaning up Python cache files...
+for /d /r %%i in (__pycache__) do rd /s /q "%%i"
+for /r %%i in (*.pyc *.pyo *.pyd) do del "%%i"
+for /d /r %%i in (.pytest_cache) do rd /s /q "%%i"
+
+REM 6. Keep only necessary requirements
+echo Setting up production requirements...
+copy requirements.txt requirements.bak /Y
+REM Use specific requirements file for deployment
+copy requirements-docker.txt requirements.txt /Y
+
+echo Deployment preparation completed successfully!
+echo Use 'docker build -t marine-pollution-api .' to build the production container

prepare_deployment.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# Deployment script for Marine Pollution Detection API
+# This script cleans up unnecessary files and prepares for deployment
+
+echo "Starting deployment preparation..."
+
+# 1. Remove all test files
+echo "Removing test files..."
+find . -name "test_*.py" -type f -delete
+rm -rf test_files/ test_output/ tests/
+
+# 2. Remove unnecessary Python files
+echo "Removing unnecessary Python files..."
+rm -f debug_cloudinary.py create_test_user.py generate_test_incidents.py list_incidents.py train_models.py
+
+# 3. Remove smaller YOLOv8 models (we only need YOLOv8x)
+echo "Removing smaller YOLO models..."
+rm -f yolov8n.pt yolov8s.pt yolov8m.pt yolov8l.pt
+# Note: Keep yolov8x.pt as it's required
+
+# 4. Use production Dockerfile and .dockerignore
+echo "Setting up production Docker files..."
+cp Dockerfile.prod Dockerfile
+cp .dockerignore.prod .dockerignore
+
+# 5. Clean up Python cache files
+echo "Cleaning up Python cache files..."
+find . -name "__pycache__" -type d -exec rm -rf {} +
+find . -name "*.pyc" -type f -delete
+find . -name "*.pyo" -type f -delete
+find . -name "*.pyd" -type f -delete
+find . -name ".pytest_cache" -type d -exec rm -rf {} +
+
+# 6. Keep only necessary requirements
+echo "Setting up production requirements..."
+cp requirements.txt requirements.bak
+# Use specific requirements file for deployment
+cp requirements-docker.txt requirements.txt
+
+echo "Deployment preparation completed successfully!"
+echo "Use 'docker build -t marine-pollution-api .' to build the production container"

requirements-version-fix.txt

@@ -0,0 +1,8 @@
+# Successfully tested on 2025-10-16 09:05:50
+torch==2.0.1+cpu
+torchvision==0.15.2+cpu
+ultralytics
+opencv-python
+cloudinary
+numpy
+requests

requirements.txt

@@ -8,7 +8,11 @@ python-jose==3.3.0
 python-multipart==0.0.9
 pydantic[email]==2.9.2
 pydantic-settings==2.6.1
-python-dotenv==1.0.1
+python-dotenv==1.0.1torch==2.0.1+cpu
+torchvision==0.15.2+cpu
+ultralytics
+opencv-python
+requests
 cloudinary
 
 # Testing dependencies (optional for production)

test_beach_plastic_detection.py

@@ -0,0 +1,177 @@
+import os
+import sys
+import logging
+import cv2
+import numpy as np
+from pathlib import Path
+import urllib.request
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Add the app directory to the path so we can import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from app.services.image_processing import (
+    detect_beach_scene, detect_water_scene, detect_plastic_bottles, 
+    detect_plastic_bottles_in_beach, check_for_plastic_bottle
+)
+
+# Sample beach plastic images (public domain or creative commons)
+SAMPLE_IMAGES = [
+    # Beach with plastic bottles
+    "https://cdn.pixabay.com/photo/2019/07/30/11/13/plastic-waste-4372436_1280.jpg",
+    # Beach with plastic bottles
+    "https://live.staticflickr.com/4499/37193114384_25b662f3b3_b.jpg",
+    # Plastic bottle on beach
+    "https://cdn.pixabay.com/photo/2019/06/15/16/28/plastic-4275696_1280.jpg"
+]
+
+def download_sample_images():
+    """Download sample images for testing"""
+    output_dir = Path("test_files/beach_plastic")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    downloaded_files = []
+    
+    for i, url in enumerate(SAMPLE_IMAGES):
+        try:
+            output_path = output_dir / f"beach_plastic_{i+1}.jpg"
+            
+            # Skip if already downloaded
+            if output_path.exists():
+                logger.info(f"File already exists: {output_path}")
+                downloaded_files.append(str(output_path))
+                continue
+                
+            # Download the image
+            logger.info(f"Downloading: {url}")
+            urllib.request.urlretrieve(url, output_path)
+            downloaded_files.append(str(output_path))
+            logger.info(f"Downloaded to: {output_path}")
+        except Exception as e:
+            logger.error(f"Error downloading {url}: {e}")
+    
+    return downloaded_files
+
+def test_on_image(image_path):
+    """Test all detection functions on a single image"""
+    logger.info(f"Testing detection on: {image_path}")
+    
+    # Read the image
+    img = cv2.imread(image_path)
+    if img is None:
+        logger.error(f"Could not read image: {image_path}")
+        return False
+    
+    # Get image dimensions
+    height, width = img.shape[:2]
+    logger.info(f"Image dimensions: {width}x{height}")
+    
+    # Create a copy for drawing results
+    img_result = img.copy()
+    
+    # Convert to HSV for color-based detection
+    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    
+    # Detect scene type
+    is_beach = detect_beach_scene(img, hsv)
+    is_water = detect_water_scene(img, hsv)
+    
+    scene_type = "unknown"
+    if is_beach and is_water:
+        scene_type = "coastal"
+    elif is_beach:
+        scene_type = "beach"
+    elif is_water:
+        scene_type = "water"
+    
+    logger.info(f"Scene type: {scene_type}")
+    
+    # Add scene type text to image
+    cv2.putText(img_result, f"Scene: {scene_type}", (10, 30), 
+                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 2)
+    
+    # Detect plastic bottles with both methods for comparison
+    
+    # Standard detection
+    standard_bottles = detect_plastic_bottles(img, hsv)
+    logger.info(f"Standard detection found {len(standard_bottles)} bottles")
+    
+    # Beach-specific detection
+    beach_bottles = detect_plastic_bottles_in_beach(img, hsv)
+    logger.info(f"Beach-specific detection found {len(beach_bottles)} bottles")
+    
+    # Use the appropriate detection based on scene type
+    if is_beach:
+        bottle_detections = beach_bottles
+        logger.info("Using beach-specific bottle detection")
+    else:
+        bottle_detections = standard_bottles
+        logger.info("Using standard bottle detection")
+    
+    # Draw standard detection in green
+    for det in standard_bottles:
+        x1, y1, x2, y2 = det["bbox"]
+        conf = det["confidence"]
+        
+        # Draw green rectangle for standard detection
+        cv2.rectangle(img_result, (x1, y1), (x2, y2), (0, 255, 0), 1)
+        cv2.putText(img_result, f"Std: {conf:.2f}", (x1, y1-10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+    
+    # Draw beach-specific detection in red (thicker line)
+    for det in beach_bottles:
+        x1, y1, x2, y2 = det["bbox"]
+        conf = det["confidence"]
+        
+        # Draw red rectangle for beach-specific detection
+        cv2.rectangle(img_result, (x1, y1), (x2, y2), (0, 0, 255), 2)
+        cv2.putText(img_result, f"Beach: {conf:.2f}", (x1, y1-25),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+    
+    # Save the result
+    output_dir = Path("test_output/beach_plastic")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    base_name = os.path.basename(image_path)
+    output_path = output_dir / f"result_{base_name}"
+    
+    cv2.imwrite(str(output_path), img_result)
+    logger.info(f"Result saved to: {output_path}")
+    
+    return {
+        "scene_type": scene_type,
+        "standard_bottles": len(standard_bottles),
+        "beach_bottles": len(beach_bottles),
+        "output_path": str(output_path)
+    }
+
+def main():
+    """Main function to test beach plastic bottle detection"""
+    # Download sample images
+    image_paths = download_sample_images()
+    
+    if not image_paths:
+        logger.error("No images to test")
+        return
+    
+    results = {}
+    
+    # Process each image
+    for img_path in image_paths:
+        results[os.path.basename(img_path)] = test_on_image(img_path)
+    
+    # Print summary
+    logger.info("\n\n--- Beach Plastic Detection Results Summary ---")
+    for img_file, result in results.items():
+        if result:
+            logger.info(f"{img_file}:")
+            logger.info(f"  Scene type: {result['scene_type']}")
+            logger.info(f"  Standard detection: {result['standard_bottles']} bottles")
+            logger.info(f"  Beach-specific detection: {result['beach_bottles']} bottles")
+            logger.info(f"  Output: {result['output_path']}")
+            logger.info("---")
+
+if __name__ == "__main__":
+    main()

test_end_to_end_flow.py

@@ -0,0 +1,473 @@
+#!/usr/bin/env python
+"""
+End-to-end test script for Marine Pollution Detection system.
+Simulates the entire flow from citizen incident reporting to cleanup.
+
+This script mimics:
+1. Creating a test user
+2. Authenticating and getting access token
+3. Uploading test images
+4. Submitting incident reports
+5. Processing images with YOLO detection
+6. Saving annotated images locally
+7. Querying the database for results
+8. Cleanup of test data from MongoDB and Cloudinary
+"""
+
+import asyncio
+import os
+import sys
+import json
+import time
+import logging
+import requests
+import uuid
+from datetime import datetime
+from pathlib import Path
+import shutil
+from pymongo import MongoClient
+import cloudinary
+import cloudinary.uploader
+import cloudinary.api
+from pprint import pprint
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger("end_to_end_test")
+
+# Configuration
+BASE_URL = "http://localhost:8000"  # FastAPI backend URL
+TEST_IMAGE_DIR = Path("test_files")  # Directory with test images
+OUTPUT_DIR = Path("test_output")  # Directory to save annotated images
+MONGODB_URI = "mongodb://localhost:27017"  # MongoDB connection URI
+DB_NAME = "marine_pollution"  # MongoDB database name
+
+# Test user credentials
+TEST_USER = {
+    "email": f"test_user_{uuid.uuid4().hex[:8]}@example.com",
+    "password": "Test@password123",
+    "name": "Test User"
+}
+
+# Test incident data template
+TEST_INCIDENT = {
+    "title": "Test Marine Pollution Incident",
+    "description": "This is a test incident created by the end-to-end test script",
+    "location": {
+        "latitude": 19.0760,  # Mumbai coast coordinates
+        "longitude": 72.8777
+    },
+    "severity": "medium",
+    "pollution_type": "plastic",
+    "date_observed": datetime.now().isoformat(),
+    "reported_by": None  # Will be filled in after user creation
+}
+
+class EndToEndTest:
+    """Class to manage the end-to-end testing flow"""
+    
+    def __init__(self):
+        """Initialize the test environment"""
+        self.access_token = None
+        self.user_id = None
+        self.test_incidents = []
+        self.uploaded_images = []
+        self.annotated_images = []
+        self.mongo_client = None
+        self.db = None
+        
+        # Create output directory if it doesn't exist
+        OUTPUT_DIR.mkdir(exist_ok=True)
+        
+        # Initialize Cloudinary (will use env vars or settings from app config)
+        try:
+            # Try to import app settings
+            sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            from app.config import get_settings
+            settings = get_settings()
+            
+            # Configure Cloudinary
+            cloudinary.config(
+                cloud_name=settings.cloudinary_cloud_name,
+                api_key=settings.cloudinary_api_key,
+                api_secret=settings.cloudinary_api_secret,
+                secure=True
+            )
+            logger.info("Configured Cloudinary from app settings")
+        except Exception as e:
+            logger.warning(f"Could not load app settings: {e}")
+            logger.warning("Make sure Cloudinary env variables are set")
+    
+    def connect_to_mongodb(self):
+        """Connect to MongoDB database"""
+        try:
+            self.mongo_client = MongoClient(MONGODB_URI)
+            self.db = self.mongo_client[DB_NAME]
+            logger.info(f"Connected to MongoDB: {MONGODB_URI}, database: {DB_NAME}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to MongoDB: {e}")
+            return False
+    
+    async def register_test_user(self):
+        """Register a test user and return the user_id"""
+        try:
+            response = requests.post(
+                f"{BASE_URL}/auth/register",
+                json=TEST_USER
+            )
+            response.raise_for_status()
+            user_data = response.json()
+            self.user_id = user_data.get("id")
+            logger.info(f"Created test user with ID: {self.user_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to register test user: {e}")
+            # Check if user already exists (409 Conflict)
+            if getattr(e, "response", None) and getattr(e.response, "status_code", None) == 409:
+                logger.info("User already exists, trying to authenticate instead")
+                return await self.authenticate()
+            return False
+    
+    async def authenticate(self):
+        """Authenticate the test user and get access token"""
+        try:
+            response = requests.post(
+                f"{BASE_URL}/auth/token",
+                data={
+                    "username": TEST_USER["email"],
+                    "password": TEST_USER["password"]
+                },
+                headers={"Content-Type": "application/x-www-form-urlencoded"}
+            )
+            response.raise_for_status()
+            token_data = response.json()
+            self.access_token = token_data.get("access_token")
+            
+            # Get user ID if we don't have it yet
+            if not self.user_id:
+                me_response = requests.get(
+                    f"{BASE_URL}/auth/me",
+                    headers={"Authorization": f"Bearer {self.access_token}"}
+                )
+                me_response.raise_for_status()
+                me_data = me_response.json()
+                self.user_id = me_data.get("id")
+            
+            logger.info(f"Authenticated as user ID: {self.user_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to authenticate: {e}")
+            return False
+    
+    async def upload_test_images(self):
+        """Upload test images to the system"""
+        try:
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+            
+            # Find all images in the test directory
+            image_files = list(TEST_IMAGE_DIR.glob("*.jpg")) + list(TEST_IMAGE_DIR.glob("*.png"))
+            
+            if not image_files:
+                logger.warning(f"No test images found in {TEST_IMAGE_DIR}")
+                
+                # Create a demo image if no test images are found
+                from PIL import Image
+                import numpy as np
+                
+                # Create a simple synthetic image with a blue background and a black blob
+                img = np.zeros((300, 500, 3), dtype=np.uint8)
+                img[:, :] = [200, 150, 100]  # Brownish water
+                img[100:200, 200:300] = [0, 0, 0]  # Black "oil spill"
+                
+                # Save the test image
+                TEST_IMAGE_DIR.mkdir(exist_ok=True)
+                demo_image_path = TEST_IMAGE_DIR / "demo_oil_spill.jpg"
+                Image.fromarray(img).save(demo_image_path)
+                image_files = [demo_image_path]
+                logger.info(f"Created demo test image: {demo_image_path}")
+            
+            for image_path in image_files:
+                # Upload the image
+                with open(image_path, "rb") as f:
+                    files = {"file": (image_path.name, f, "image/jpeg")}
+                    response = requests.post(
+                        f"{BASE_URL}/incidents/upload-image",
+                        files=files,
+                        headers=headers
+                    )
+                    response.raise_for_status()
+                    image_data = response.json()
+                    image_url = image_data.get("image_url")
+                    self.uploaded_images.append({
+                        "url": image_url,
+                        "original_path": str(image_path),
+                        "filename": image_path.name
+                    })
+                    logger.info(f"Uploaded image: {image_path.name} -> {image_url}")
+            
+            logger.info(f"Uploaded {len(self.uploaded_images)} test images")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to upload test images: {e}")
+            return False
+    
+    async def create_test_incidents(self):
+        """Create test incidents using the uploaded images"""
+        try:
+            headers = {
+                "Authorization": f"Bearer {self.access_token}",
+                "Content-Type": "application/json"
+            }
+            
+            for i, image_data in enumerate(self.uploaded_images):
+                # Create an incident for each uploaded image
+                incident_data = TEST_INCIDENT.copy()
+                incident_data["title"] = f"Test Incident {i+1}: {image_data['filename']}"
+                incident_data["image_url"] = image_data["url"]
+                incident_data["reported_by"] = self.user_id
+                
+                # Submit the incident
+                response = requests.post(
+                    f"{BASE_URL}/incidents/",
+                    json=incident_data,
+                    headers=headers
+                )
+                response.raise_for_status()
+                created_incident = response.json()
+                self.test_incidents.append(created_incident)
+                logger.info(f"Created test incident: {created_incident.get('id')} with image {image_data['filename']}")
+            
+            logger.info(f"Created {len(self.test_incidents)} test incidents")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to create test incidents: {e}")
+            return False
+    
+    async def wait_for_detection_processing(self, timeout=60):
+        """
+        Wait for the object detection to be processed
+        This polls the API to check if annotated images are available
+        """
+        try:
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+            start_time = time.time()
+            processed_count = 0
+            
+            logger.info(f"Waiting for detection processing (timeout: {timeout}s)...")
+            
+            while processed_count < len(self.test_incidents) and time.time() - start_time < timeout:
+                processed_count = 0
+                
+                for incident in self.test_incidents:
+                    incident_id = incident.get("id")
+                    response = requests.get(
+                        f"{BASE_URL}/incidents/{incident_id}",
+                        headers=headers
+                    )
+                    response.raise_for_status()
+                    incident_data = response.json()
+                    
+                    # Check if detection has been processed
+                    if incident_data.get("detection_results"):
+                        if incident_data["detection_results"].get("annotated_image_url"):
+                            processed_count += 1
+                
+                if processed_count < len(self.test_incidents):
+                    logger.info(f"Processed {processed_count}/{len(self.test_incidents)} incidents, waiting...")
+                    await asyncio.sleep(2)
+            
+            if processed_count < len(self.test_incidents):
+                logger.warning(f"Not all incidents were processed within the timeout")
+                logger.warning(f"Processed {processed_count}/{len(self.test_incidents)} incidents")
+            else:
+                logger.info(f"All {len(self.test_incidents)} incidents processed successfully")
+            
+            return processed_count > 0
+        except Exception as e:
+            logger.error(f"Error while waiting for detection processing: {e}")
+            return False
+    
+    async def download_annotated_images(self):
+        """Download annotated images from the incidents"""
+        try:
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+            
+            for incident in self.test_incidents:
+                incident_id = incident.get("id")
+                response = requests.get(
+                    f"{BASE_URL}/incidents/{incident_id}",
+                    headers=headers
+                )
+                response.raise_for_status()
+                incident_data = response.json()
+                
+                # Check if detection results and annotated image exist
+                if (incident_data.get("detection_results") and 
+                    incident_data["detection_results"].get("annotated_image_url")):
+                    
+                    # Download the annotated image
+                    annotated_url = incident_data["detection_results"]["annotated_image_url"]
+                    img_response = requests.get(annotated_url, stream=True)
+                    
+                    if img_response.status_code == 200:
+                        # Save the image locally
+                        local_filename = f"incident_{incident_id}_annotated.jpg"
+                        local_path = OUTPUT_DIR / local_filename
+                        
+                        with open(local_path, "wb") as f:
+                            for chunk in img_response.iter_content(chunk_size=8192):
+                                f.write(chunk)
+                        
+                        self.annotated_images.append({
+                            "incident_id": incident_id,
+                            "url": annotated_url,
+                            "local_path": str(local_path),
+                            "detection_count": incident_data["detection_results"].get("detection_count", 0)
+                        })
+                        
+                        logger.info(f"Downloaded annotated image for incident {incident_id}")
+                        logger.info(f"Found {incident_data['detection_results'].get('detection_count', 0)} objects")
+            
+            logger.info(f"Downloaded {len(self.annotated_images)} annotated images")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to download annotated images: {e}")
+            return False
+    
+    async def print_mongodb_records(self):
+        """Print relevant MongoDB records for verification"""
+        if not self.db:
+            if not self.connect_to_mongodb():
+                return False
+        
+        try:
+            # Print incident records
+            logger.info("--- MongoDB Incident Records ---")
+            incidents = list(self.db.incidents.find({"reported_by": self.user_id}))
+            for incident in incidents:
+                logger.info(f"Incident: {incident['_id']} - {incident['title']}")
+                if "detection_results" in incident and incident["detection_results"]:
+                    logger.info(f"  Detection count: {incident['detection_results'].get('detection_count', 0)}")
+                    if "detections" in incident["detection_results"]:
+                        for det in incident["detection_results"]["detections"]:
+                            logger.info(f"  - {det.get('class')}: {det.get('confidence')}")
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error accessing MongoDB: {e}")
+            return False
+    
+    async def cleanup_test_data(self, keep_local=True):
+        """Clean up all test data from MongoDB and Cloudinary"""
+        try:
+            if not self.db:
+                if not self.connect_to_mongodb():
+                    return False
+            
+            # Delete incidents from MongoDB
+            if self.user_id:
+                result = self.db.incidents.delete_many({"reported_by": self.user_id})
+                logger.info(f"Deleted {result.deleted_count} incidents from MongoDB")
+            
+            # Delete images from Cloudinary
+            for image_data in self.uploaded_images + self.annotated_images:
+                url = image_data.get("url", "")
+                if "cloudinary" in url:
+                    try:
+                        # Extract public ID from URL
+                        # URL format: https://res.cloudinary.com/{cloud_name}/image/upload/{transformations}/{public_id}.{format}
+                        parts = url.split("/")
+                        public_id_with_ext = parts[-1]
+                        public_id = public_id_with_ext.split(".")[0]
+                        
+                        # Delete from Cloudinary
+                        result = cloudinary.uploader.destroy(public_id)
+                        logger.info(f"Deleted image from Cloudinary: {public_id}, result: {result}")
+                    except Exception as e:
+                        logger.warning(f"Could not delete Cloudinary image {url}: {e}")
+            
+            # Optionally delete local files
+            if not keep_local:
+                # Clean up the output directory
+                for file_path in OUTPUT_DIR.glob("*"):
+                    if file_path.is_file():
+                        file_path.unlink()
+                
+                # Clean up demo test images if we created them
+                demo_image = TEST_IMAGE_DIR / "demo_oil_spill.jpg"
+                if demo_image.exists():
+                    demo_image.unlink()
+            
+            logger.info("Test data cleanup completed")
+            return True
+        except Exception as e:
+            logger.error(f"Error during cleanup: {e}")
+            return False
+    
+    async def run_test(self):
+        """Run the complete end-to-end test flow"""
+        logger.info("=== Starting End-to-End Test Flow ===")
+        
+        # Step 1: Register test user (or authenticate if exists)
+        if not await self.register_test_user():
+            if not await self.authenticate():
+                logger.error("Failed to register or authenticate test user")
+                return False
+        
+        # Step 2: Upload test images
+        if not await self.upload_test_images():
+            logger.error("Failed to upload test images")
+            return False
+        
+        # Step 3: Create test incidents
+        if not await self.create_test_incidents():
+            logger.error("Failed to create test incidents")
+            return False
+        
+        # Step 4: Wait for detection processing
+        if not await self.wait_for_detection_processing():
+            logger.warning("Detection processing may not be complete")
+            # Continue anyway as some may be processed
+        
+        # Step 5: Download annotated images
+        if not await self.download_annotated_images():
+            logger.error("Failed to download annotated images")
+            return False
+        
+        # Step 6: Print MongoDB records
+        await self.print_mongodb_records()
+        
+        logger.info("=== End-to-End Test Flow Completed Successfully ===")
+        logger.info(f"Test user ID: {self.user_id}")
+        logger.info(f"Created {len(self.test_incidents)} test incidents")
+        logger.info(f"Processed {len(self.annotated_images)} annotated images")
+        logger.info(f"Annotated images saved to: {OUTPUT_DIR}")
+        
+        return True
+
+async def main():
+    """Main entry point for the script"""
+    test = EndToEndTest()
+    success = await test.run_test()
+    
+    # Ask if the user wants to clean up test data
+    cleanup = input("Do you want to clean up test data? (y/n): ").lower().strip() == "y"
+    if cleanup:
+        await test.cleanup_test_data()
+        logger.info("Test data cleaned up")
+    else:
+        logger.info("Test data preserved for inspection")
+    
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    try:
+        sys.exit(asyncio.run(main()))
+    except KeyboardInterrupt:
+        print("\nTest interrupted by user")
+        sys.exit(130)

test_enhanced_detection.py

@@ -0,0 +1,149 @@
+import os
+import sys
+import logging
+import cv2
+import numpy as np
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Add the app directory to the path so we can import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from app.services.image_processing import (
+    detect_beach_scene, detect_water_scene, detect_plastic_bottles, 
+    detect_plastic_bottles_in_beach, detect_ships, check_for_plastic_bottle,
+    check_for_ship, check_for_plastic_waste
+)
+
+def test_on_image(image_path):
+    """Test all detection functions on a single image"""
+    logger.info(f"Testing detection on: {image_path}")
+    
+    # Read the image
+    img = cv2.imread(image_path)
+    if img is None:
+        logger.error(f"Could not read image: {image_path}")
+        return False
+    
+    # Get image dimensions
+    height, width = img.shape[:2]
+    logger.info(f"Image dimensions: {width}x{height}")
+    
+    # Create a copy for drawing results
+    img_result = img.copy()
+    
+    # Convert to HSV for color-based detection
+    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+    
+    # Detect scene type
+    is_beach = detect_beach_scene(img, hsv)
+    is_water = detect_water_scene(img, hsv)
+    
+    scene_type = "unknown"
+    if is_beach and is_water:
+        scene_type = "coastal"
+    elif is_beach:
+        scene_type = "beach"
+    elif is_water:
+        scene_type = "water"
+    
+    logger.info(f"Scene type: {scene_type}")
+    
+    # Add scene type text to image
+    cv2.putText(img_result, f"Scene: {scene_type}", (10, 30), 
+                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 2)
+    
+    # Detect plastic bottles
+    if is_beach:
+        logger.info("Using beach-specific bottle detection")
+        bottle_detections = detect_plastic_bottles_in_beach(img, hsv)
+    else:
+        logger.info("Using standard bottle detection")
+        bottle_detections = detect_plastic_bottles(img, hsv)
+    
+    logger.info(f"Detected {len(bottle_detections)} potential plastic bottles")
+    
+    # Draw bottle detections
+    for det in bottle_detections:
+        x1, y1, x2, y2 = det["bbox"]
+        conf = det["confidence"]
+        
+        # Draw red rectangle for bottles
+        cv2.rectangle(img_result, (x1, y1), (x2, y2), (0, 0, 255), 2)
+        cv2.putText(img_result, f"Bottle: {conf:.2f}", (x1, y1-10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+    
+    # Detect ships if in water scene
+    ship_detections = []
+    if is_water:
+        logger.info("Detecting ships in water scene")
+        ship_detections = detect_ships(img, hsv)
+        
+        logger.info(f"Detected {len(ship_detections)} potential ships")
+        
+        # Draw ship detections
+        for det in ship_detections:
+            x1, y1, x2, y2 = det["bbox"]
+            conf = det["confidence"]
+            
+            # Draw blue rectangle for ships
+            cv2.rectangle(img_result, (x1, y1), (x2, y2), (255, 0, 0), 2)
+            cv2.putText(img_result, f"Ship: {conf:.2f}", (x1, y1-10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
+    
+    # Save the result
+    output_dir = Path("test_output/enhanced_detection")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    base_name = os.path.basename(image_path)
+    output_path = output_dir / f"result_{base_name}"
+    
+    cv2.imwrite(str(output_path), img_result)
+    logger.info(f"Result saved to: {output_path}")
+    
+    return {
+        "scene_type": scene_type,
+        "bottle_detections": len(bottle_detections),
+        "ship_detections": len(ship_detections),
+        "output_path": str(output_path)
+    }
+
+def main():
+    """Main function to test enhanced detection on sample images"""
+    # Test directory
+    test_dir = "test_files"
+    
+    # Check if test directory exists
+    if not os.path.isdir(test_dir):
+        logger.error(f"Test directory not found: {test_dir}")
+        return
+    
+    # Get all image files in the test directory
+    image_files = [f for f in os.listdir(test_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
+    
+    if not image_files:
+        logger.error(f"No image files found in {test_dir}")
+        return
+    
+    results = {}
+    
+    # Process each image
+    for img_file in image_files:
+        img_path = os.path.join(test_dir, img_file)
+        results[img_file] = test_on_image(img_path)
+    
+    # Print summary
+    logger.info("\n\n--- Detection Results Summary ---")
+    for img_file, result in results.items():
+        if result:
+            logger.info(f"{img_file}:")
+            logger.info(f"  Scene type: {result['scene_type']}")
+            logger.info(f"  Plastic bottles: {result['bottle_detections']}")
+            logger.info(f"  Ships: {result['ship_detections']}")
+            logger.info(f"  Output: {result['output_path']}")
+            logger.info("---")
+
+if __name__ == "__main__":
+    main()