first try

.kiro/specs/yolov8-gradio-app/design.md

@@ -0,0 +1,176 @@
+# Design Document
+
+## Overview
+
+The YOLOv8 Gradio Object Detection application is a web-based tool that provides real-time object detection capabilities through an intuitive user interface. The system leverages the Ultralytics YOLOv8 model for state-of-the-art object detection and Gradio for creating an interactive web interface. The application follows a simple pipeline: image upload → detection processing → dual output (annotated image + structured data table).
+
+## Architecture
+
+The application follows a single-file architecture with clear separation of concerns:
+
+```
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│   Gradio UI     │───▶│  Detection Core  │───▶│   Output Layer  │
+│                 │    │                  │    │                 │
+│ - Image Upload  │    │ - YOLOv8 Model   │    │ - Annotated Img │
+│ - File Handling │    │ - Preprocessing  │    │ - Data Table    │
+│ - Display       │    │ - Postprocessing │    │ - Error Display │
+└─────────────────┘    └──────────────────┘    └─────────────────┘
+```
+
+### Key Design Decisions
+
+1. **Single-file Architecture**: Keeps the application simple and self-contained for easy deployment
+2. **Pretrained Model**: Uses YOLOv8n for balance between speed and accuracy
+3. **Dual Output**: Provides both visual and structured data outputs to serve different user needs
+4. **PIL/NumPy Integration**: Ensures compatibility between Gradio, OpenCV, and YOLOv8 image formats
+
+## Components and Interfaces
+
+### 1. Model Management Component
+
+**Purpose**: Handle YOLOv8 model loading and initialization
+
+```python
+# Interface
+model = YOLO("yolov8n.pt")  # Global model instance
+```
+
+**Responsibilities**:
+- Load pretrained YOLOv8 model on application startup
+- Handle model loading errors and fallbacks
+- Provide access to model class names mapping
+
+### 2. Image Processing Component
+
+**Purpose**: Handle image format conversions and preprocessing
+
+```python
+# Interface
+def preprocess_image(image: Image.Image) -> np.ndarray
+def postprocess_results(results, original_image) -> tuple
+```
+
+**Responsibilities**:
+- Convert PIL Image to NumPy array for YOLOv8 processing
+- Handle image format validation
+- Maintain image aspect ratios during processing
+
+### 3. Detection Engine Component
+
+**Purpose**: Core object detection logic
+
+```python
+# Interface
+def detect_objects(image: Image.Image) -> tuple[Image.Image, pd.DataFrame]
+```
+
+**Responsibilities**:
+- Execute YOLOv8 inference on input images
+- Parse detection results (boxes, classes, confidence scores)
+- Generate annotated output images
+- Create structured data output
+
+### 4. Gradio Interface Component
+
+**Purpose**: Web UI creation and event handling
+
+```python
+# Interface
+demo = gr.Interface(
+    fn=detect_objects,
+    inputs=gr.Image(type="pil", label="Upload Image"),
+    outputs=[gr.Image(type="pil"), gr.Dataframe()]
+)
+```
+
+**Responsibilities**:
+- Create responsive web interface
+- Handle file uploads and validation
+- Display results in appropriate formats
+- Manage user interactions
+
+## Data Models
+
+### Detection Result Model
+
+```python
+{
+    "class": str,           # Object class name (e.g., "person", "car")
+    "confidence": float,    # Confidence score (0.0-1.0, rounded to 3 decimals)
+    "x1": float,           # Top-left x coordinate (rounded to 1 decimal)
+    "y1": float,           # Top-left y coordinate (rounded to 1 decimal)
+    "x2": float,           # Bottom-right x coordinate (rounded to 1 decimal)
+    "y2": float            # Bottom-right y coordinate (rounded to 1 decimal)
+}
+```
+
+### Image Processing Pipeline
+
+```
+Input: PIL Image → NumPy Array → YOLOv8 Processing → Results Object → 
+Output: Annotated PIL Image + Pandas DataFrame
+```
+
+## Error Handling
+
+### Model Loading Errors
+- **Issue**: YOLOv8 model file not found or corrupted
+- **Handling**: Display clear error message, suggest model download
+- **Fallback**: Graceful degradation with error display in UI
+
+### Image Processing Errors
+- **Issue**: Invalid image format or corrupted file
+- **Handling**: Validate file type before processing
+- **Fallback**: Display user-friendly error message
+
+### Detection Processing Errors
+- **Issue**: YOLOv8 inference failures
+- **Handling**: Catch exceptions during model inference
+- **Fallback**: Return empty results with error notification
+
+### Memory Management
+- **Issue**: Large image files causing memory issues
+- **Handling**: Implement image size validation and resizing if needed
+- **Fallback**: Display memory limitation warnings
+
+## Testing Strategy
+
+### Unit Testing
+- **Model Loading**: Test YOLOv8 model initialization and error handling
+- **Image Processing**: Test format conversions and preprocessing functions
+- **Detection Logic**: Test detection result parsing and data structure creation
+- **Data Formatting**: Test confidence score and coordinate rounding
+
+### Integration Testing
+- **End-to-End Pipeline**: Test complete image upload → detection → output flow
+- **UI Components**: Test Gradio interface functionality and responsiveness
+- **Error Scenarios**: Test various error conditions and fallback behaviors
+
+### Performance Testing
+- **Inference Speed**: Measure detection processing time for various image sizes
+- **Memory Usage**: Monitor memory consumption during processing
+- **Concurrent Users**: Test application behavior with multiple simultaneous users
+
+### User Acceptance Testing
+- **Image Format Support**: Test with various image formats (JPG, PNG, JPEG)
+- **Detection Accuracy**: Validate detection results against known test images
+- **UI Usability**: Test interface responsiveness and user experience
+- **Output Quality**: Verify annotated images and data table accuracy
+
+## Deployment Considerations
+
+### Dependencies
+- **Core**: gradio, ultralytics, opencv-python, pillow, numpy, pandas
+- **Model**: Automatic YOLOv8n.pt download on first run
+- **Python Version**: 3.8+ recommended for compatibility
+
+### Performance Optimization
+- **Model Caching**: Keep model loaded in memory to avoid reload overhead
+- **Image Resizing**: Implement intelligent resizing for very large images
+- **Batch Processing**: Consider batch processing for multiple images (future enhancement)
+
+### Security
+- **File Upload Validation**: Strict image format validation
+- **File Size Limits**: Implement reasonable file size restrictions
+- **Input Sanitization**: Validate all user inputs before processing

.kiro/specs/yolov8-gradio-app/requirements.md

@@ -0,0 +1,77 @@
+# Requirements Document
+
+## Introduction
+
+This feature implements a web-based object detection application using YOLOv8 and Gradio. The application allows users to upload images and receive real-time object detection results with visual annotations and structured data output. The system leverages a pretrained YOLOv8 model to identify and classify objects in uploaded images, providing both visual feedback through bounding boxes and detailed detection information in a tabular format.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a user, I want to upload an image to the web application, so that I can get object detection results for analysis.
+
+#### Acceptance Criteria
+
+1. WHEN a user accesses the web application THEN the system SHALL display an image upload interface
+2. WHEN a user selects an image file THEN the system SHALL accept common image formats (JPG, PNG, JPEG)
+3. WHEN an image is uploaded THEN the system SHALL process the image and display it in the interface
+4. IF the uploaded file is not a valid image format THEN the system SHALL display an appropriate error message
+
+### Requirement 2
+
+**User Story:** As a user, I want the system to detect objects in my uploaded image, so that I can identify what objects are present.
+
+#### Acceptance Criteria
+
+1. WHEN an image is uploaded THEN the system SHALL run YOLOv8 object detection on the image
+2. WHEN objects are detected THEN the system SHALL identify object classes using the pretrained model
+3. WHEN detection is complete THEN the system SHALL calculate confidence scores for each detection
+4. WHEN detection is complete THEN the system SHALL determine bounding box coordinates for each object
+5. IF no objects are detected THEN the system SHALL return an empty results set
+
+### Requirement 3
+
+**User Story:** As a user, I want to see visual annotations on my image, so that I can easily identify where objects were detected.
+
+#### Acceptance Criteria
+
+1. WHEN objects are detected THEN the system SHALL draw bounding boxes around detected objects
+2. WHEN bounding boxes are drawn THEN the system SHALL include class labels on each box
+3. WHEN bounding boxes are drawn THEN the system SHALL include confidence scores on each box
+4. WHEN annotations are complete THEN the system SHALL display the annotated image to the user
+5. WHEN displaying results THEN the system SHALL maintain the original image aspect ratio
+
+### Requirement 4
+
+**User Story:** As a user, I want to see detection results in a structured table format, so that I can analyze the data programmatically.
+
+#### Acceptance Criteria
+
+1. WHEN objects are detected THEN the system SHALL generate a structured data table
+2. WHEN creating the table THEN the system SHALL include object class names
+3. WHEN creating the table THEN the system SHALL include confidence scores rounded to 3 decimal places
+4. WHEN creating the table THEN the system SHALL include bounding box coordinates (x1, y1, x2, y2) rounded to 1 decimal place
+5. WHEN displaying the table THEN the system SHALL present data in a user-friendly tabular format
+
+### Requirement 5
+
+**User Story:** As a developer, I want the application to use a pretrained YOLOv8 model, so that I don't need to train a custom model.
+
+#### Acceptance Criteria
+
+1. WHEN the application starts THEN the system SHALL load a pretrained YOLOv8 model (yolov8n.pt)
+2. WHEN loading the model THEN the system SHALL handle model loading errors gracefully
+3. WHEN using the model THEN the system SHALL utilize the built-in class name mappings
+4. IF the model file is missing THEN the system SHALL download it automatically or display an appropriate error
+
+### Requirement 6
+
+**User Story:** As a user, I want the web interface to be intuitive and responsive, so that I can easily use the application.
+
+#### Acceptance Criteria
+
+1. WHEN the application launches THEN the system SHALL display a clear title and description
+2. WHEN the interface loads THEN the system SHALL provide clear labels for input and output sections
+3. WHEN processing an image THEN the system SHALL provide visual feedback during processing
+4. WHEN results are ready THEN the system SHALL display both the annotated image and data table simultaneously
+5. WHEN the application is accessed THEN the system SHALL be responsive across different screen sizes

.kiro/specs/yolov8-gradio-app/tasks.md

@@ -0,0 +1,36 @@
+# Implementation Plan
+
+- [x] 1. Set up project structure and implement YOLOv8 model loading
+
+  - Create project directory structure with app.py and requirements.txt
+  - Install dependencies (gradio, ultralytics, opencv-python, pillow, numpy, pandas)
+  - Implement YOLOv8 model initialization with error handling and validation
+  - Create basic image preprocessing utilities for PIL to NumPy conversion
+  - _Requirements: 5.1, 5.2, 5.3, 1.2, 1.4, 2.1_
+
+- [x] 2. Implement core object detection and result processing
+
+
+  - Write the main detect_objects function that processes images through YOLOv8
+  - Implement detection result parsing to extract classes, confidence scores, and bounding boxes
+  - Create structured data formatting with proper rounding (confidence to 3 decimals, coordinates to 1 decimal)
+  - Add comprehensive error handling for detection failures and edge cases
+  - _Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 4.1, 4.2, 4.3, 4.4_
+-
+
+- [ ] 3. Create image annotation and Gradio interface
+
+
+
+  - Implement annotated image generation using YOLOv8's plot() method with bounding boxes and labels
+  - Create Gradio Interface with image upload input and dual output (annotated image + data table)
+  - Add appropriate UI labels, descriptions, and user-friendly formatting
+  - Ensure proper aspect ratio maintenance and responsive display
+  - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5, 1.1, 1.3, 4.5, 6.1, 6.2, 6.4_
+
+- [ ] 4. Integrate components and finalize application
+  - Wire together all components into complete app.py with proper error handling
+  - Implement application launcher with demo.launch() and configuration options
+  - Add comprehensive validation for file uploads and user inputs
+  - Create end-to-end testing and deployment documentation
+  - _Requirements: 6.1, 6.2, 6.3, 6.4, 6.5, 1.4, 5.4_

app.py

@@ -0,0 +1,310 @@
+"""
+YOLOv8 Gradio Object Detection Application
+
+This application provides a web-based interface for object detection using YOLOv8.
+Users can upload images and receive real-time object detection results with
+visual annotations and structured data output.
+"""
+
+import logging
+import sys
+from typing import Tuple, Optional
+
+import cv2
+import gradio as gr
+import numpy as np
+import pandas as pd
+from PIL import Image
+from ultralytics import YOLO
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global model instance
+model: Optional[YOLO] = None
+
+
+def initialize_model() -> bool:
+    """
+    Initialize YOLOv8 model with error handling and validation.
+
+    Returns:
+        bool: True if model loaded successfully, False otherwise
+    """
+    global model
+    try:
+        logger.info("Loading YOLOv8 model...")
+        model = YOLO("yolov8n.pt")
+        logger.info("YOLOv8 model loaded successfully")
+        return True
+    except Exception as e:
+        logger.error("Failed to load YOLOv8 model: %s", str(e))
+        model = None
+        return False
+
+
+def preprocess_image(image: Image.Image) -> np.ndarray:
+    """
+    Convert PIL Image to NumPy array for YOLOv8 processing.
+
+    Args:
+        image (Image.Image): PIL Image object
+
+    Returns:
+        np.ndarray: NumPy array in RGB format
+    """
+    try:
+        # Convert PIL Image to RGB if not already
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+
+        # Convert to NumPy array
+        image_array = np.array(image)
+
+        logger.info("Image preprocessed: shape %s", image_array.shape)
+        return image_array
+
+    except Exception as e:
+        logger.error("Error preprocessing image: %s", str(e))
+        raise
+
+
+def detect_objects(image: Image.Image) -> Tuple[Image.Image, pd.DataFrame]:
+    """
+    Main object detection function that processes images through YOLOv8.
+
+    Args:
+        image (Image.Image): PIL Image object to process
+
+    Returns:
+        Tuple[Image.Image, pd.DataFrame]: Annotated image and detection results table
+    """
+    if model is None:
+        logger.error("YOLOv8 model not loaded")
+        # Return original image and empty dataframe
+        empty_df = pd.DataFrame(columns=['class', 'confidence', 'x1', 'y1', 'x2', 'y2'])
+        return image, empty_df
+
+    try:
+        # Preprocess the image
+        logger.info("Starting object detection...")
+        processed_image = preprocess_image(image)
+
+        # Run YOLOv8 inference
+        results = model(processed_image)
+
+        # Parse detection results
+        annotated_image, detection_data = parse_detection_results(results[0], image)
+
+        logger.info("Object detection completed successfully")
+        return annotated_image, detection_data
+
+    except Exception as e:
+        logger.error("Error during object detection: %s", str(e))
+        # Return original image and empty dataframe on error
+        empty_df = pd.DataFrame(columns=['class', 'confidence', 'x1', 'y1', 'x2', 'y2'])
+        return image, empty_df
+
+
+def parse_detection_results(results, original_image: Image.Image) -> Tuple[Image.Image, pd.DataFrame]:
+    """
+    Parse YOLOv8 detection results to extract classes, confidence scores, and bounding boxes.
+    
+    Args:
+        results: YOLOv8 detection results object
+        original_image (Image.Image): Original PIL image for annotation
+        
+    Returns:
+        Tuple[Image.Image, pd.DataFrame]: Annotated image and structured detection data
+    """
+    try:
+        # Extract detection data
+        detection_list = []
+        
+        # Check if any detections were found
+        if results.boxes is not None and len(results.boxes) > 0:
+            # Get class names from the model
+            class_names = results.names
+            
+            # Extract boxes, classes, and confidence scores
+            boxes = results.boxes.xyxy.cpu().numpy()  # x1, y1, x2, y2 format
+            classes = results.boxes.cls.cpu().numpy()
+            confidences = results.boxes.conf.cpu().numpy()
+            
+            # Process each detection
+            for i in range(len(boxes)):
+                class_id = int(classes[i])
+                class_name = class_names[class_id]
+                confidence = float(confidences[i])
+                x1, y1, x2, y2 = boxes[i]
+                
+                # Create detection record with proper rounding
+                detection_record = {
+                    'class': class_name,
+                    'confidence': round(confidence, 3),  # Round to 3 decimal places
+                    'x1': round(float(x1), 1),          # Round to 1 decimal place
+                    'y1': round(float(y1), 1),
+                    'x2': round(float(x2), 1),
+                    'y2': round(float(y2), 1)
+                }
+                
+                detection_list.append(detection_record)
+                
+            logger.info("Parsed %d detections", len(detection_list))
+        else:
+            logger.info("No objects detected in the image")
+        
+        # Create DataFrame from detection list with proper columns
+        if detection_list:
+            detection_df = pd.DataFrame(detection_list)
+        else:
+            # Create empty DataFrame with correct columns
+            detection_df = pd.DataFrame(columns=['class', 'confidence', 'x1', 'y1', 'x2', 'y2'])
+        
+        # Generate annotated image using YOLOv8's built-in plotting
+        annotated_image = generate_annotated_image(results, original_image)
+        
+        return annotated_image, detection_df
+        
+    except Exception as e:
+        logger.error("Error parsing detection results: %s", str(e))
+        # Return original image and empty dataframe on error
+        empty_df = pd.DataFrame(columns=['class', 'confidence', 'x1', 'y1', 'x2', 'y2'])
+        return original_image, empty_df
+
+
+def generate_annotated_image(results, original_image: Image.Image) -> Image.Image:
+    """
+    Generate annotated image with bounding boxes and labels using YOLOv8's plot method.
+    
+    Args:
+        results: YOLOv8 detection results object
+        original_image (Image.Image): Original PIL image
+        
+    Returns:
+        Image.Image: Annotated PIL image with bounding boxes and labels
+    """
+    try:
+        # Use YOLOv8's built-in plot method to generate annotations
+        # This automatically adds bounding boxes, class labels, and confidence scores
+        annotated_array = results.plot(
+            conf=True,  # Show confidence scores
+            labels=True,  # Show class labels
+            boxes=True,  # Show bounding boxes
+            line_width=2,  # Line width for bounding boxes
+            font_size=12  # Font size for labels
+        )
+        
+        # Convert BGR to RGB (YOLOv8 plot returns BGR format)
+        annotated_rgb = cv2.cvtColor(annotated_array, cv2.COLOR_BGR2RGB)
+        
+        # Convert NumPy array back to PIL Image
+        annotated_image = Image.fromarray(annotated_rgb)
+        
+        # Ensure the annotated image maintains aspect ratio
+        # The YOLOv8 plot method should preserve the original dimensions
+        logger.info("Generated annotated image successfully with dimensions: %s", 
+                   annotated_image.size)
+        return annotated_image
+        
+    except Exception as e:
+        logger.error("Error generating annotated image: %s", str(e))
+        # Return original image on error to maintain aspect ratio
+        return original_image
+
+
+def create_gradio_interface():
+    """
+    Create Gradio Interface with image upload input and dual output.
+    
+    Returns:
+        gr.Interface: Configured Gradio interface
+    """
+    # Create the Gradio interface
+    demo = gr.Interface(
+        fn=detect_objects,
+        inputs=gr.Image(
+            type="pil",
+            label="Upload Image for Object Detection",
+            sources=["upload", "clipboard"],
+            height=400
+        ),
+        outputs=[
+            gr.Image(
+                type="pil",
+                label="Annotated Image with Detections",
+                height=400,
+                show_label=True
+            ),
+            gr.Dataframe(
+                label="Detection Results",
+                headers=["Class", "Confidence", "X1", "Y1", "X2", "Y2"],
+                datatype=["str", "number", "number", "number", "number", "number"],
+                col_count=(6, "fixed"),
+                row_count=(10, "dynamic"),
+                interactive=False
+            )
+        ],
+        title="🎯 YOLOv8 Object Detection",
+        description="""
+        **Upload an image to detect objects using YOLOv8!**
+        
+        This application uses a pretrained YOLOv8 model to identify and locate objects in your images.
+        You'll get both a visual representation with bounding boxes and a detailed data table.
+        
+        **Supported formats:** JPG, PNG, JPEG
+        """,
+        article="""
+        ### How it works:
+        1. **Upload** an image using the interface above
+        2. **View** the annotated image with bounding boxes and labels
+        3. **Analyze** the detection data in the table with confidence scores and coordinates
+        
+        The confidence scores are rounded to 3 decimal places, and coordinates to 1 decimal place for clarity.
+        """,
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        .output-image {
+            height: 400px !important;
+        }
+        """,
+        examples=[
+            # Add example images if available
+        ],
+        cache_examples=False,
+        allow_flagging="never"
+    )
+    
+    return demo
+
+
+if __name__ == "__main__":
+    # Initialize model on startup
+    if not initialize_model():
+        logger.error("Failed to initialize YOLOv8 model. Application cannot start.")
+        sys.exit(1)
+    
+    logger.info("YOLOv8 model initialized successfully")
+    
+    # Create and launch Gradio interface
+    try:
+        demo = create_gradio_interface()
+        logger.info("Gradio interface created successfully")
+        
+        # Launch the application
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=False,
+            show_error=True,
+            quiet=False
+        )
+        
+    except Exception as e:
+        logger.error("Error launching Gradio interface: %s", str(e))
+        sys.exit(1)

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+ultralytics>=8.0.0
+opencv-python>=4.8.0
+pillow>=10.0.0
+numpy>=1.24.0
+pandas>=2.0.0

test_detection.py

@@ -0,0 +1,72 @@
+"""
+Test script to verify the object detection functionality with a sample image.
+"""
+
+import sys
+from PIL import Image, ImageDraw
+import pandas as pd
+
+# Import our detection functions
+from app import initialize_model, detect_objects
+
+def create_test_image():
+    """Create a simple test image with some basic shapes."""
+    # Create a white background
+    img = Image.new('RGB', (640, 480), 'white')
+    draw = ImageDraw.Draw(img)
+    
+    # Draw some simple shapes that might be detected as objects
+    # Rectangle (might be detected as a book or similar)
+    draw.rectangle([100, 100, 300, 200], fill='blue', outline='black', width=3)
+    
+    # Circle (might be detected as a ball or similar)
+    draw.ellipse([400, 150, 500, 250], fill='red', outline='black', width=3)
+    
+    # Another rectangle
+    draw.rectangle([200, 300, 400, 400], fill='green', outline='black', width=3)
+    
+    return img
+
+def main():
+    print("Testing YOLOv8 object detection...")
+    
+    # Initialize model
+    if not initialize_model():
+        print("Failed to initialize model")
+        return
+    
+    # Create test image
+    test_img = create_test_image()
+    test_img.save("test_image.jpg")
+    print("Created test image: test_image.jpg")
+    
+    # Run detection
+    annotated_img, detection_df = detect_objects(test_img)
+    
+    # Save results
+    annotated_img.save("annotated_result.jpg")
+    print("Saved annotated result: annotated_result.jpg")
+    
+    # Print detection results
+    print(f"\nDetection Results:")
+    print(f"Number of detections: {len(detection_df)}")
+    
+    if len(detection_df) > 0:
+        print("\nDetailed results:")
+        print(detection_df.to_string(index=False))
+        
+        # Verify data formatting
+        print("\nData formatting verification:")
+        for _, row in detection_df.iterrows():
+            print(f"Class: {row['class']}")
+            print(f"Confidence: {row['confidence']} (type: {type(row['confidence'])})")
+            print(f"Coordinates: ({row['x1']}, {row['y1']}, {row['x2']}, {row['y2']})")
+            print(f"Coordinate types: {type(row['x1'])}, {type(row['y1'])}, {type(row['x2'])}, {type(row['y2'])}")
+            print("---")
+    else:
+        print("No objects detected")
+    
+    print("\nTest completed successfully!")
+
+if __name__ == "__main__":
+    main()

test_error_handling.py

@@ -0,0 +1,75 @@
+"""
+Test script to verify error handling in the object detection functionality.
+"""
+
+from PIL import Image
+import pandas as pd
+import app
+from app import detect_objects, initialize_model
+
+def test_with_none_model():
+    """Test detection when model is None."""
+    print("Testing with None model...")
+    
+    # Temporarily set model to None
+    original_model = app.model
+    app.model = None
+    
+    # Create test image
+    test_img = Image.new('RGB', (100, 100), 'white')
+    
+    # Run detection
+    annotated_img, detection_df = detect_objects(test_img)
+    
+    # Verify results
+    print(f"Returned image type: {type(annotated_img)}")
+    print(f"Returned DataFrame shape: {detection_df.shape}")
+    print(f"DataFrame columns: {list(detection_df.columns)}")
+    print(f"DataFrame empty: {detection_df.empty}")
+    
+    # Restore original model
+    app.model = original_model
+    print("Model restored\n")
+
+def test_with_corrupted_image():
+    """Test detection with edge case images."""
+    print("Testing with very small image...")
+    
+    # Create very small image
+    tiny_img = Image.new('RGB', (1, 1), 'black')
+    
+    # Run detection
+    annotated_img, detection_df = detect_objects(tiny_img)
+    
+    print(f"Small image - Detections: {len(detection_df)}")
+    expected_columns = ['class', 'confidence', 'x1', 'y1', 'x2', 'y2']
+    print(f"Small image - DataFrame columns: {list(detection_df.columns)}")
+    print(f"Small image - DataFrame columns correct: {list(detection_df.columns) == expected_columns}")
+    
+    print("Testing with large image...")
+    
+    # Create large image
+    large_img = Image.new('RGB', (2000, 2000), 'blue')
+    
+    # Run detection
+    annotated_img, detection_df = detect_objects(large_img)
+    
+    print(f"Large image - Detections: {len(detection_df)}")
+    print(f"Large image - DataFrame columns: {list(detection_df.columns)}")
+    print(f"Large image - DataFrame columns correct: {list(detection_df.columns) == expected_columns}")
+
+def main():
+    print("Testing error handling scenarios...\n")
+    
+    # Initialize model first
+    if not initialize_model():
+        print("Failed to initialize model for testing")
+        return
+    
+    test_with_none_model()
+    test_with_corrupted_image()
+    
+    print("Error handling tests completed!")
+
+if __name__ == "__main__":
+    main()

yolov8n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f59b3d833e2ff32e194b5bb8e08d211dc7c5bdf144b90d2c8412c47ccfc83b36
+size 6549796