parameters added

app.py

@@ -7,7 +7,10 @@ visual annotations and structured data output.
 """
 
 import logging
+import os
 import sys
+import tempfile
+from datetime import datetime
 from typing import Tuple, Optional
 
 import cv2
@@ -70,50 +73,55 @@ def preprocess_image(image: Image.Image) -> np.ndarray:
         raise
 
 
-def detect_objects(image: Image.Image) -> Tuple[Image.Image, pd.DataFrame]:
+def detect_objects(image: Image.Image, conf_threshold: float = 0.25) -> Tuple[Image.Image, pd.DataFrame, str]:
     """
     Main object detection function that processes images through YOLOv8.
 
     Args:
         image (Image.Image): PIL Image object to process
+        conf_threshold (float): Confidence threshold for filtering detections (0.0 to 1.0)
 
     Returns:
-        Tuple[Image.Image, pd.DataFrame]: Annotated image and detection results table
+        Tuple[Image.Image, pd.DataFrame, str]: Annotated image, detection results table, and CSV file path
     """
     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
+        return image, empty_df, None
 
     try:
         # Preprocess the image
-        logger.info("Starting object detection...")
+        logger.info("Starting object detection with confidence threshold: %.2f", conf_threshold)
         processed_image = preprocess_image(image)
 
-        # Run YOLOv8 inference
-        results = model(processed_image)
+        # Run YOLOv8 inference with confidence threshold
+        results = model(processed_image, conf=conf_threshold)
 
         # Parse detection results
-        annotated_image, detection_data = parse_detection_results(results[0], image)
+        annotated_image, detection_data = parse_detection_results(results[0], image, conf_threshold)
 
-        logger.info("Object detection completed successfully")
-        return annotated_image, detection_data
+        # Create CSV file for download
+        csv_file_path = create_csv_download(detection_data, conf_threshold)
+
+        logger.info("Object detection completed successfully with %d detections", len(detection_data))
+        return annotated_image, detection_data, csv_file_path
 
     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
+        return image, empty_df, None
 
 
-def parse_detection_results(results, original_image: Image.Image) -> Tuple[Image.Image, pd.DataFrame]:
+def parse_detection_results(results, original_image: Image.Image, conf_threshold: float = 0.25) -> 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
+        conf_threshold (float): Confidence threshold used for filtering
         
     Returns:
         Tuple[Image.Image, pd.DataFrame]: Annotated image and structured detection data
@@ -132,7 +140,7 @@ def parse_detection_results(results, original_image: Image.Image) -> Tuple[Image
             classes = results.boxes.cls.cpu().numpy()
             confidences = results.boxes.conf.cpu().numpy()
             
-            # Process each detection
+            # Process each detection (already filtered by YOLOv8 based on conf_threshold)
             for i in range(len(boxes)):
                 class_id = int(classes[i])
                 class_name = class_names[class_id]
@@ -151,9 +159,9 @@ def parse_detection_results(results, original_image: Image.Image) -> Tuple[Image
                 
                 detection_list.append(detection_record)
                 
-            logger.info("Parsed %d detections", len(detection_list))
+            logger.info("Parsed %d detections above confidence threshold %.2f", len(detection_list), conf_threshold)
         else:
-            logger.info("No objects detected in the image")
+            logger.info("No objects detected above confidence threshold %.2f", conf_threshold)
         
         # Create DataFrame from detection list with proper columns
         if detection_list:
@@ -183,7 +191,7 @@ def generate_annotated_image(results, original_image: Image.Image) -> Image.Imag
         original_image (Image.Image): Original PIL image
         
     Returns:
-        Image.Image: Annotated PIL image with bounding boxes and labels
+        Image.Image: Annotated PIL image with bounding boxes and labels in RGB format
     """
     try:
         # Use YOLOv8's built-in plot method to generate annotations
@@ -196,11 +204,16 @@ def generate_annotated_image(results, original_image: Image.Image) -> Image.Imag
             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)
+        # IMPORTANT: YOLOv8's plot() method returns BGR format, but Gradio expects RGB
+        # Convert BGR to RGB to fix color display issue
+        if len(annotated_array.shape) == 3 and annotated_array.shape[2] == 3:
+            annotated_rgb = cv2.cvtColor(annotated_array, cv2.COLOR_BGR2RGB)
+        else:
+            # Fallback if image format is unexpected
+            annotated_rgb = annotated_array
         
         # Convert NumPy array back to PIL Image
-        annotated_image = Image.fromarray(annotated_rgb)
+        annotated_image = Image.fromarray(annotated_rgb.astype(np.uint8))
         
         # Ensure the annotated image maintains aspect ratio
         # The YOLOv8 plot method should preserve the original dimensions
@@ -214,9 +227,55 @@ def generate_annotated_image(results, original_image: Image.Image) -> Image.Imag
         return original_image
 
 
+def create_csv_download(detection_data: pd.DataFrame, conf_threshold: float = 0.25) -> str:
+    """
+    Create a CSV file from detection results for download.
+    
+    Args:
+        detection_data (pd.DataFrame): Detection results dataframe
+        conf_threshold (float): Confidence threshold used for filtering
+        
+    Returns:
+        str: Path to the created CSV file
+    """
+    try:
+        # Create a temporary CSV file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        csv_filename = f"detection_results_{timestamp}.csv"
+        
+        # Use a temporary directory
+        temp_dir = tempfile.gettempdir()
+        csv_path = os.path.join(temp_dir, csv_filename)
+        
+        # Save DataFrame to CSV with additional metadata
+        if not detection_data.empty:
+            # Add metadata to the CSV
+            with open(csv_path, 'w', newline='', encoding='utf-8') as f:
+                f.write(f"# YOLOv8 Object Detection Results\n")
+                f.write(f"# Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                f.write(f"# Confidence threshold: {conf_threshold:.2f} ({conf_threshold*100:.0f}%)\n")
+                f.write(f"# Total detections: {len(detection_data)}\n")
+                f.write("# Columns: class, confidence, x1, y1, x2, y2\n")
+                f.write("# Coordinates are in pixels (x1,y1 = top-left, x2,y2 = bottom-right)\n")
+                f.write("#\n")
+            
+            # Append the actual data
+            detection_data.to_csv(csv_path, mode='a', index=False)
+        else:
+            # Create empty CSV with headers
+            detection_data.to_csv(csv_path, index=False)
+        
+        logger.info("CSV file created successfully: %s", csv_path)
+        return csv_path
+        
+    except Exception as e:
+        logger.error("Error creating CSV file: %s", str(e))
+        return None
+
+
 def create_gradio_interface():
     """
-    Create Gradio Interface with image upload input and dual output.
+    Create Gradio Interface with image upload, confidence slider, and triple output.
     
     Returns:
         gr.Interface: Configured Gradio interface
@@ -224,16 +283,26 @@ def create_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
-        ),
+        inputs=[
+            gr.Image(
+                type="pil",
+                label="Upload Image for Object Detection",
+                sources=["upload", "clipboard"],
+                height=400
+            ),
+            gr.Slider(
+                minimum=0.01,
+                maximum=1.0,
+                value=0.25,
+                step=0.01,
+                label="Confidence Threshold",
+                info="Only show detections above this confidence level (0.01 = 1%, 1.0 = 100%)"
+            )
+        ],
         outputs=[
             gr.Image(
                 type="pil",
-                label="Annotated Image with Detections",
+                label="Annotated Image with Detections (RGB Fixed)",
                 height=400,
                 show_label=True
             ),
@@ -244,9 +313,13 @@ def create_gradio_interface():
                 col_count=(6, "fixed"),
                 row_count=(10, "dynamic"),
                 interactive=False
+            ),
+            gr.File(
+                label="Download Results as CSV",
+                visible=True
             )
         ],
-        title="🎯 YOLOv8 Object Detection",
+        title="🎯 YOLOv8 Object Detection with Confidence Control",
         description="""
         **Upload an image to detect objects using YOLOv8!**
         
@@ -254,14 +327,29 @@ def create_gradio_interface():
         You'll get both a visual representation with bounding boxes and a detailed data table.
         
         **Supported formats:** JPG, PNG, JPEG
+        
+        **Features:** 
+        - ✅ Fixed RGB color display issue
+        - 🎚️ Adjustable confidence threshold slider
+        - 📥 Download detection results as CSV
+        - 📊 Real-time filtering based on confidence scores
         """,
         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
+        2. **Adjust** the confidence threshold slider to filter detections (default: 0.25 = 25%)
+        3. **View** the annotated image with bounding boxes and labels (RGB colors fixed)
+        4. **Analyze** the detection data in the table with confidence scores and coordinates
+        5. **Download** the results as a CSV file for further analysis
+        
+        **Confidence Threshold Guide:**
+        - **0.01-0.20**: Very permissive - shows many detections, including uncertain ones
+        - **0.25-0.50**: Balanced - good mix of accuracy and detection count (recommended)
+        - **0.50-0.80**: Conservative - only high-confidence detections
+        - **0.80-1.00**: Very strict - only extremely confident detections
         
         The confidence scores are rounded to 3 decimal places, and coordinates to 1 decimal place for clarity.
+        The CSV file includes all detection data with timestamps for easy tracking.
         """,
         theme=gr.themes.Soft(),
         css="""
@@ -271,12 +359,15 @@ def create_gradio_interface():
         .output-image {
             height: 400px !important;
         }
+        .slider-container {
+            margin: 10px 0;
+        }
         """,
         examples=[
             # Add example images if available
         ],
         cache_examples=False,
-        allow_flagging="never"
+        flagging_mode="never"
     )
     
     return demo