Upload 6 files

app.py

@@ -0,0 +1,598 @@
+import os
+import numpy as np
+import torch
+import cv2
+import matplotlib.pyplot as plt
+import gradio as gr
+import io
+from PIL import Image, ImageDraw, ImageFont
+import spaces
+from typing import Dict, List, Any, Optional, Tuple
+from ultralytics import YOLO
+
+from detection_model import DetectionModel
+from color_mapper import ColorMapper
+from visualization_helper import VisualizationHelper
+from evaluation_metrics import EvaluationMetrics
+from style import Style
+
+
+color_mapper = ColorMapper()
+model_instances = {}
+
+@spaces.GPU
+def process_image(image, model_instance, confidence_threshold, filter_classes=None):
+    """
+    Process an image for object detection
+    
+    Args:
+        image: Input image (numpy array or PIL Image)
+        model_instance: DetectionModel instance to use
+        confidence_threshold: Confidence threshold for detection
+        filter_classes: Optional list of classes to filter results
+        
+    Returns:
+        Tuple of (result_image, result_text, stats_data)
+    """
+    # initialize key variables
+    result = None
+    stats = {}
+    temp_path = None
+    
+    try:
+        # update confidence threshold
+        model_instance.confidence = confidence_threshold
+        
+        # processing input image
+        if isinstance(image, np.ndarray):
+            # Convert BGR to RGB if needed
+            if image.shape[2] == 3:
+                image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            else:
+                image_rgb = image
+            pil_image = Image.fromarray(image_rgb)
+        elif image is None:
+            return None, "No image provided. Please upload an image.", {}
+        else:
+            pil_image = image
+        
+        # store temp files
+        import uuid
+        import tempfile
+        
+        temp_dir = tempfile.gettempdir()  # use system temp directory
+        temp_filename = f"temp_{uuid.uuid4().hex}.jpg"
+        temp_path = os.path.join(temp_dir, temp_filename)
+        pil_image.save(temp_path)
+        
+        # object detection
+        result = model_instance.detect(temp_path)
+        
+        if result is None:
+            return None, "Detection failed. Please try again with a different image.", {}
+        
+        # calculate stats
+        stats = EvaluationMetrics.calculate_basic_stats(result)
+            
+        # add space calculation
+        spatial_metrics = EvaluationMetrics.calculate_distance_metrics(result)
+        stats["spatial_metrics"] = spatial_metrics
+        
+        if filter_classes and len(filter_classes) > 0:
+            # get classes, boxes, confidence
+            classes = result.boxes.cls.cpu().numpy().astype(int)
+            confs = result.boxes.conf.cpu().numpy()
+            boxes = result.boxes.xyxy.cpu().numpy()
+            
+            mask = np.zeros_like(classes, dtype=bool)
+            for cls_id in filter_classes:
+                mask = np.logical_or(mask, classes == cls_id)
+    
+            filtered_stats = {
+                "total_objects": int(np.sum(mask)),
+                "class_statistics": {},
+                "average_confidence": float(np.mean(confs[mask])) if np.any(mask) else 0,
+                "spatial_metrics": stats["spatial_metrics"]  
+            }
+            
+            # update stats 
+            names = result.names
+            for cls, conf in zip(classes[mask], confs[mask]):
+                cls_name = names[int(cls)]
+                if cls_name not in filtered_stats["class_statistics"]:
+                    filtered_stats["class_statistics"][cls_name] = {
+                        "count": 0,
+                        "average_confidence": 0
+                    }
+                
+                filtered_stats["class_statistics"][cls_name]["count"] += 1
+                filtered_stats["class_statistics"][cls_name]["average_confidence"] = conf
+            
+            stats = filtered_stats
+        
+        viz_data = EvaluationMetrics.generate_visualization_data(
+            result, 
+            color_mapper.get_all_colors()
+        )
+        
+        result_image = VisualizationHelper.visualize_detection(
+            temp_path, result, color_mapper=color_mapper, figsize=(12, 12), return_pil=True
+        )
+        
+        result_text = EvaluationMetrics.format_detection_summary(viz_data)
+        
+        return result_image, result_text, stats
+        
+    except Exception as e:
+        error_message = f"Error Occurs: {str(e)}"
+        import traceback
+        traceback.print_exc()  
+        print(error_message)
+        return None, error_message, {}
+    
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            try:
+                os.remove(temp_path)
+            except Exception as e:
+                print(f"Cannot delete temp files {temp_path}: {str(e)}")
+
+def format_result_text(stats):
+    """
+    Format detection statistics into readable text with improved spacing
+    
+    Args:
+        stats: Dictionary containing detection statistics
+        
+    Returns:
+        Formatted text summary
+    """
+    if not stats or "total_objects" not in stats:
+        return "No objects detected."
+        
+    # 減少不必要的空行
+    lines = [
+        f"Detected {stats['total_objects']} objects.",  
+        f"Average confidence: {stats.get('average_confidence', 0):.2f}",
+        "Objects by class:"
+    ]
+    
+    if "class_statistics" in stats and stats["class_statistics"]:
+        # 按計數排序類別
+        sorted_classes = sorted(
+            stats["class_statistics"].items(),
+            key=lambda x: x[1]["count"],
+            reverse=True
+        )
+        
+        for cls_name, cls_stats in sorted_classes:
+            count = cls_stats["count"]
+            conf = cls_stats.get("average_confidence", 0)
+            
+            item_text = "item" if count == 1 else "items"
+            lines.append(f"• {cls_name}: {count} {item_text} (avg conf: {conf:.2f})")
+    else:
+        lines.append("No class information available.")
+    
+    # 添加空間信息
+    if "spatial_metrics" in stats and "spatial_distribution" in stats["spatial_metrics"]:
+        lines.append("Object Distribution:")
+        
+        dist = stats["spatial_metrics"]["spatial_distribution"]
+        x_mean = dist.get("x_mean", 0)
+        y_mean = dist.get("y_mean", 0)
+        
+        # 描述物體的大致位置
+        if x_mean < 0.33:
+            h_pos = "on the left side"
+        elif x_mean < 0.67:
+            h_pos = "in the center"
+        else:
+            h_pos = "on the right side"
+        
+        if y_mean < 0.33:
+            v_pos = "in the upper part"
+        elif y_mean < 0.67:
+            v_pos = "in the middle"
+        else:
+            v_pos = "in the lower part"
+            
+        lines.append(f"• Most objects appear {h_pos} {v_pos} of the image")
+    
+    return "\n".join(lines)
+
+def format_json_for_display(stats):
+    """
+    Format statistics JSON for better display
+    
+    Args:
+        stats: Raw statistics dictionary
+        
+    Returns:
+        Formatted statistics structure for display
+    """
+    # Create a cleaner copy of the stats for display
+    display_stats = {}
+    
+    # Add summary section
+    display_stats["summary"] = {
+        "total_objects": stats.get("total_objects", 0),
+        "average_confidence": round(stats.get("average_confidence", 0), 3)
+    }
+    
+    # Add class statistics in a more organized way
+    if "class_statistics" in stats and stats["class_statistics"]:
+        # Sort classes by count (descending)
+        sorted_classes = sorted(
+            stats["class_statistics"].items(),
+            key=lambda x: x[1].get("count", 0),
+            reverse=True
+        )
+        
+        class_stats = {}
+        for cls_name, cls_data in sorted_classes:
+            class_stats[cls_name] = {
+                "count": cls_data.get("count", 0),
+                "average_confidence": round(cls_data.get("average_confidence", 0), 3)
+            }
+            
+        display_stats["detected_objects"] = class_stats
+    
+    # Simplify spatial metrics
+    if "spatial_metrics" in stats:
+        spatial = stats["spatial_metrics"]
+        
+        # Simplify spatial distribution
+        if "spatial_distribution" in spatial:
+            dist = spatial["spatial_distribution"]
+            display_stats["spatial"] = {
+                "distribution": {
+                    "x_mean": round(dist.get("x_mean", 0), 3),
+                    "y_mean": round(dist.get("y_mean", 0), 3),
+                    "x_std": round(dist.get("x_std", 0), 3),
+                    "y_std": round(dist.get("y_std", 0), 3)
+                }
+            }
+            
+        # Add simplified size information
+        if "size_distribution" in spatial:
+            size = spatial["size_distribution"]
+            display_stats["spatial"]["size"] = {
+                "mean_area": round(size.get("mean_area", 0), 3),
+                "min_area": round(size.get("min_area", 0), 3),
+                "max_area": round(size.get("max_area", 0), 3)
+            }
+    
+    return display_stats
+
+def get_all_classes():
+    """
+    Get all available COCO classes from the currently active model or fallback to standard COCO classes
+    
+    Returns:
+        List of tuples (class_id, class_name)
+    """
+    global model_instances
+    
+    # Try to get class names from any loaded model
+    for model_name, model_instance in model_instances.items():
+        if model_instance and model_instance.is_model_loaded:
+            try:
+                class_names = model_instance.class_names
+                return [(idx, name) for idx, name in class_names.items()]
+            except Exception:
+                pass
+    
+    # Fallback to standard COCO classes
+    return [
+        (0, 'person'), (1, 'bicycle'), (2, 'car'), (3, 'motorcycle'), (4, 'airplane'),
+        (5, 'bus'), (6, 'train'), (7, 'truck'), (8, 'boat'), (9, 'traffic light'),
+        (10, 'fire hydrant'), (11, 'stop sign'), (12, 'parking meter'), (13, 'bench'), 
+        (14, 'bird'), (15, 'cat'), (16, 'dog'), (17, 'horse'), (18, 'sheep'), (19, 'cow'),
+        (20, 'elephant'), (21, 'bear'), (22, 'zebra'), (23, 'giraffe'), (24, 'backpack'),
+        (25, 'umbrella'), (26, 'handbag'), (27, 'tie'), (28, 'suitcase'), (29, 'frisbee'),
+        (30, 'skis'), (31, 'snowboard'), (32, 'sports ball'), (33, 'kite'), (34, 'baseball bat'),
+        (35, 'baseball glove'), (36, 'skateboard'), (37, 'surfboard'), (38, 'tennis racket'), 
+        (39, 'bottle'), (40, 'wine glass'), (41, 'cup'), (42, 'fork'), (43, 'knife'),
+        (44, 'spoon'), (45, 'bowl'), (46, 'banana'), (47, 'apple'), (48, 'sandwich'), 
+        (49, 'orange'), (50, 'broccoli'), (51, 'carrot'), (52, 'hot dog'), (53, 'pizza'),
+        (54, 'donut'), (55, 'cake'), (56, 'chair'), (57, 'couch'), (58, 'potted plant'), 
+        (59, 'bed'), (60, 'dining table'), (61, 'toilet'), (62, 'tv'), (63, 'laptop'),
+        (64, 'mouse'), (65, 'remote'), (66, 'keyboard'), (67, 'cell phone'), (68, 'microwave'), 
+        (69, 'oven'), (70, 'toaster'), (71, 'sink'), (72, 'refrigerator'), (73, 'book'),
+        (74, 'clock'), (75, 'vase'), (76, 'scissors'), (77, 'teddy bear'), (78, 'hair drier'), 
+        (79, 'toothbrush')
+    ]
+
+def create_interface():
+    """創建 Gradio 界面，包含美化的視覺效果"""
+    css = Style.get_css()
+
+    # 獲取可用模型信息
+    available_models = DetectionModel.get_available_models()
+    model_choices = [model["model_file"] for model in available_models]
+    model_labels = [f"{model['name']} - {model['inference_speed']}" for model in available_models]
+    
+    # 可用類別過濾選項
+    available_classes = get_all_classes()
+    class_choices = [f"{id}: {name}" for id, name in available_classes]
+    
+    # 創建 Gradio Blocks 界面
+    with gr.Blocks(css=css, theme=gr.themes.Soft(primary_hue="teal", secondary_hue="blue")) as demo:
+        # 頁面頂部標題
+        with gr.Group(elem_classes="app-header"):
+            gr.HTML("""
+                <div style="text-align: center; width: 100%;">
+                    <h1 class="app-title">VisionScout</h1>
+                    <h2 class="app-subtitle">Detect and identify objects in your images</h2>
+                    <div class="app-divider"></div>
+                </div>
+            """)
+
+        current_model = gr.State("yolov8m.pt")  # use medium size model as defualt
+        
+        # 主要內容區 - 輸入和輸出面板
+        with gr.Row(equal_height=True):
+            # 左側 - 輸入控制區(可上傳圖片)
+            with gr.Column(scale=4, elem_classes="input-panel"):
+                with gr.Group():
+                    gr.HTML('<div class="section-heading">Upload Image</div>')
+                    image_input = gr.Image(type="pil", label="Upload an image", elem_classes="upload-box")
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        with gr.Row():
+                            model_dropdown = gr.Dropdown(
+                                choices=model_choices,
+                                value="yolov8m.pt",  
+                                label="Select Model",
+                                info="Choose different models based on your needs for speed vs. accuracy"
+                            )
+                        
+                        # display model info
+                        model_info = gr.Markdown(DetectionModel.get_model_description("yolov8m.pt"))
+
+                        confidence = gr.Slider(
+                            minimum=0.1, 
+                            maximum=0.9, 
+                            value=0.25, 
+                            step=0.05, 
+                            label="Confidence Threshold",
+                            info="Higher values show fewer but more confident detections"
+                        )
+                        
+                        with gr.Accordion("Filter Classes", open=False):
+                            # 常見物件類別快速選擇按鈕
+                            gr.HTML('<div class="section-heading" style="font-size: 1rem;">Common Categories</div>')
+                            with gr.Row():
+                                people_btn = gr.Button("People", size="sm")
+                                vehicles_btn = gr.Button("Vehicles", size="sm")
+                                animals_btn = gr.Button("Animals", size="sm")
+                                objects_btn = gr.Button("Common Objects", size="sm")
+                            
+                            # 類別選擇下拉框
+                            class_filter = gr.Dropdown(
+                                choices=class_choices,
+                                multiselect=True,
+                                label="Select Classes to Display",
+                                info="Leave empty to show all detected objects"
+                            )
+                    
+                    # detect buttom
+                    detect_btn = gr.Button("Detect Objects", variant="primary", elem_classes="detect-btn")
+                
+                # 使用說明區
+                with gr.Group(elem_classes="how-to-use"):
+                    gr.HTML('<div class="section-heading">How to Use</div>')
+                    gr.Markdown("""
+                    1. Upload an image or use the camera
+                    2. Adjust confidence threshold if needed
+                    3. Optionally filter to specific object classes
+                    4. Click "Detect Objects" button
+                    
+                    The model will identify objects in your image and display them with bounding boxes.
+                    
+                    **Note:** Detection quality depends on image clarity and object visibility. The model can detect up to 80 different types of common objects.
+                    """)
+            
+            # 右側 - 結果顯示區
+            with gr.Column(scale=6, elem_classes="output-panel"):
+                with gr.Tabs(elem_classes="tabs"):
+                    with gr.Tab("Detection Result"):
+                        result_image = gr.Image(type="pil", label="Detection Result")
+                        
+                        # 文本框的格式
+                        with gr.Group(elem_classes="result-details-box"):
+                            gr.HTML('<div class="section-heading">Detection Details</div>')
+                            # 文本框設置，讓顯示會更寬
+                            result_text = gr.Textbox(
+                                label=None,
+                                lines=12,
+                                max_lines=15,
+                                elem_classes="wide-result-text",
+                                elem_id="detection-details",
+                                container=False,  
+                                scale=2,          
+                                min_width=600     
+                            )
+                    
+                    with gr.Tab("Statistics"):
+                        with gr.Row():
+                            with gr.Column(scale=3, elem_classes="plot-column"):
+                                gr.HTML('<div class="section-heading">Object Distribution</div>')
+                                plot_output = gr.Plot(
+                                    label=None,  
+                                    elem_classes="large-plot-container"
+                                )
+                            
+                            # 右側放 JSON 數據比較清晰
+                            with gr.Column(scale=2, elem_classes="stats-column"):
+                                gr.HTML('<div class="section-heading">Detection Statistics</div>')
+                                stats_json = gr.JSON(
+                                    label=None,  # remove label
+                                    elem_classes="enhanced-json-display"
+                                )
+        
+        detect_btn.click(
+            fn=lambda img, model, conf, classes: process_and_plot(img, model, conf, classes),
+            inputs=[image_input, current_model, confidence, class_filter],
+            outputs=[result_image, result_text, stats_json, plot_output]
+        )
+
+        # model option
+        model_dropdown.change(
+            fn=lambda model: (model, DetectionModel.get_model_description(model)),
+            inputs=[model_dropdown],
+            outputs=[current_model, model_info]
+        )
+        
+        # each classes link
+        people_classes = [0]  # 人
+        vehicles_classes = [1, 2, 3, 4, 5, 6, 7, 8]  # 各種車輛
+        animals_classes = list(range(14, 24))  # COCO 中的動物
+        common_objects = [41, 42, 43, 44, 45, 67, 73, 74, 76]  # 常見家居物品
+        
+        # Linked the quik buttom
+        people_btn.click(
+            lambda: [f"{id}: {name}" for id, name in available_classes if id in people_classes],
+            outputs=class_filter
+        )
+        
+        vehicles_btn.click(
+            lambda: [f"{id}: {name}" for id, name in available_classes if id in vehicles_classes],
+            outputs=class_filter
+        )
+        
+        animals_btn.click(
+            lambda: [f"{id}: {name}" for id, name in available_classes if id in animals_classes],
+            outputs=class_filter
+        )
+        
+        objects_btn.click(
+            lambda: [f"{id}: {name}" for id, name in available_classes if id in common_objects],
+            outputs=class_filter
+        )
+        
+        example_images = [
+            "room_01.jpg",
+            "street_01.jpg",
+            "street_02.jpg",
+            "street_03.jpg"
+        ]
+        
+        # add example images
+        gr.Examples(
+            examples=example_images,
+            inputs=image_input,
+            outputs=None,  
+            fn=None,  
+            cache_examples=False,  
+        )
+        
+        # 頁腳部分
+        gr.HTML("""
+            <div class="footer">
+                <p>Powered by YOLOv8 and Ultralytics • Created with Gradio</p>
+                <p>Model can detect 80 different classes of objects</p>
+            </div>
+        """)
+    
+    return demo
+
+@spaces.GPU
+def process_and_plot(image, model_name, confidence_threshold, filter_classes=None):
+    """
+    Process image and create plots for statistics with enhanced visualization
+    
+    Args:
+        image: Input image
+        model_name: Name of the model to use
+        confidence_threshold: Confidence threshold for detection
+        filter_classes: Optional list of classes to filter results
+        
+    Returns:
+        Tuple of (result_image, result_text, formatted_stats, plot_figure)
+    """
+    global model_instances
+    
+    if model_name not in model_instances:
+        print(f"Creating new model instance for {model_name}")
+        model_instances[model_name] = DetectionModel(model_name=model_name, confidence=confidence_threshold, iou=0.45)
+    else:
+        print(f"Using existing model instance for {model_name}")
+        model_instances[model_name].confidence = confidence_threshold
+    
+    class_ids = None
+    if filter_classes:
+        class_ids = []
+        for class_str in filter_classes:
+            try:
+                # Extract ID from format "id: name"
+                class_id = int(class_str.split(":")[0].strip())
+                class_ids.append(class_id)
+            except:
+                continue
+    
+    # Execute detection
+    result_image, result_text, stats = process_image(
+        image, 
+        model_instances[model_name], 
+        confidence_threshold, 
+        class_ids
+    )
+    
+    # Format the statistics for better display
+    formatted_stats = format_json_for_display(stats)
+    
+    if not stats or "class_statistics" not in stats or not stats["class_statistics"]:
+        # Create the table
+        fig, ax = plt.subplots(figsize=(8, 6))
+        ax.text(0.5, 0.5, "No detection data available", 
+                ha='center', va='center', fontsize=14, fontfamily='Arial')
+        ax.set_xlim(0, 1)
+        ax.set_ylim(0, 1)
+        ax.axis('off')
+        plot_figure = fig
+    else:
+        # prepare visualization data
+        viz_data = {
+            "total_objects": stats.get("total_objects", 0),
+            "average_confidence": stats.get("average_confidence", 0),
+            "class_data": []
+        }
+        
+        # get the color map
+        color_mapper_instance = ColorMapper()
+        
+        # class data
+        available_classes = dict(get_all_classes())
+        for cls_name, cls_stats in stats.get("class_statistics", {}).items():
+            # search class ID
+            class_id = -1
+            for id, name in available_classes.items():
+                if name == cls_name:
+                    class_id = id
+                    break
+            
+            cls_data = {
+                "name": cls_name,
+                "class_id": class_id,
+                "count": cls_stats.get("count", 0),
+                "average_confidence": cls_stats.get("average_confidence", 0),
+                "color": color_mapper_instance.get_color(class_id if class_id >= 0 else cls_name)
+            }
+            
+            viz_data["class_data"].append(cls_data)
+        
+        # descending order
+        viz_data["class_data"].sort(key=lambda x: x["count"], reverse=True)
+        
+        plot_figure = EvaluationMetrics.create_enhanced_stats_plot(viz_data)
+    
+    return result_image, result_text, formatted_stats, plot_figure
+
+
+if __name__ == "__main__":
+    import time
+    
+    demo = create_interface()
+    demo.launch()

color_mapper.py

@@ -0,0 +1,270 @@
+import numpy as np
+from typing import Dict, List, Tuple, Union, Any
+
+class ColorMapper:
+    """
+    A class for consistent color mapping of object detection classes
+    Provides color schemes for visualization in both RGB and hex formats
+    """
+    
+    # Class categories for better organization
+    CATEGORIES = {
+        "person": [0],
+        "vehicles": [1, 2, 3, 4, 5, 6, 7, 8],
+        "traffic": [9, 10, 11, 12],
+        "animals": [14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
+        "outdoor": [13, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33],
+        "sports": [34, 35, 36, 37, 38],
+        "kitchen": [39, 40, 41, 42, 43, 44, 45],
+        "food": [46, 47, 48, 49, 50, 51, 52, 53, 54, 55],
+        "furniture": [56, 57, 58, 59, 60, 61],
+        "electronics": [62, 63, 64, 65, 66, 67, 68, 69, 70],
+        "household": [71, 72, 73, 74, 75, 76, 77, 78, 79]
+    }
+    
+    # Base colors for each category (in HSV for easier variation)
+    CATEGORY_COLORS = {
+        "person": (0, 0.8, 0.9),       # Red
+        "vehicles": (210, 0.8, 0.9),   # Blue
+        "traffic": (45, 0.8, 0.9),     # Orange
+        "animals": (120, 0.7, 0.8),    # Green
+        "outdoor": (180, 0.7, 0.9),    # Cyan
+        "sports": (270, 0.7, 0.8),     # Purple
+        "kitchen": (30, 0.7, 0.9),     # Light Orange
+        "food": (330, 0.7, 0.85),      # Pink
+        "furniture": (150, 0.5, 0.85), # Light Green
+        "electronics": (240, 0.6, 0.9), # Light Blue
+        "household": (60, 0.6, 0.9)    # Yellow
+    }
+    
+    def __init__(self):
+        """Initialize the ColorMapper with COCO class mappings"""
+        self.class_names = self._get_coco_classes()
+        self.color_map = self._generate_color_map()
+    
+    def _get_coco_classes(self) -> Dict[int, str]:
+        """Get the standard COCO class names with their IDs"""
+        return {
+            0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 4: 'airplane',
+            5: 'bus', 6: 'train', 7: 'truck', 8: 'boat', 9: 'traffic light',
+            10: 'fire hydrant', 11: 'stop sign', 12: 'parking meter', 13: 'bench', 
+            14: 'bird', 15: 'cat', 16: 'dog', 17: 'horse', 18: 'sheep', 19: 'cow',
+            20: 'elephant', 21: 'bear', 22: 'zebra', 23: 'giraffe', 24: 'backpack',
+            25: 'umbrella', 26: 'handbag', 27: 'tie', 28: 'suitcase', 29: 'frisbee',
+            30: 'skis', 31: 'snowboard', 32: 'sports ball', 33: 'kite', 34: 'baseball bat',
+            35: 'baseball glove', 36: 'skateboard', 37: 'surfboard', 38: 'tennis racket', 
+            39: 'bottle', 40: 'wine glass', 41: 'cup', 42: 'fork', 43: 'knife',
+            44: 'spoon', 45: 'bowl', 46: 'banana', 47: 'apple', 48: 'sandwich', 
+            49: 'orange', 50: 'broccoli', 51: 'carrot', 52: 'hot dog', 53: 'pizza',
+            54: 'donut', 55: 'cake', 56: 'chair', 57: 'couch', 58: 'potted plant', 
+            59: 'bed', 60: 'dining table', 61: 'toilet', 62: 'tv', 63: 'laptop',
+            64: 'mouse', 65: 'remote', 66: 'keyboard', 67: 'cell phone', 68: 'microwave', 
+            69: 'oven', 70: 'toaster', 71: 'sink', 72: 'refrigerator', 73: 'book',
+            74: 'clock', 75: 'vase', 76: 'scissors', 77: 'teddy bear', 78: 'hair drier', 
+            79: 'toothbrush'
+        }
+    
+    def _hsv_to_rgb(self, h: float, s: float, v: float) -> Tuple[int, int, int]:
+        """
+        Convert HSV color to RGB
+        
+        Args:
+            h: Hue (0-360)
+            s: Saturation (0-1)
+            v: Value (0-1)
+            
+        Returns:
+            Tuple of (R, G, B) values (0-255)
+        """
+        h = h / 60
+        i = int(h)
+        f = h - i
+        p = v * (1 - s)
+        q = v * (1 - s * f)
+        t = v * (1 - s * (1 - f))
+        
+        if i == 0:
+            r, g, b = v, t, p
+        elif i == 1:
+            r, g, b = q, v, p
+        elif i == 2:
+            r, g, b = p, v, t
+        elif i == 3:
+            r, g, b = p, q, v
+        elif i == 4:
+            r, g, b = t, p, v
+        else:
+            r, g, b = v, p, q
+        
+        return (int(r * 255), int(g * 255), int(b * 255))
+    
+    def _rgb_to_hex(self, rgb: Tuple[int, int, int]) -> str:
+        """
+        Convert RGB color to hex color code
+        
+        Args:
+            rgb: Tuple of (R, G, B) values (0-255)
+            
+        Returns:
+            Hex color code (e.g. '#FF0000')
+        """
+        return f'#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}'
+    
+    def _find_category(self, class_id: int) -> str:
+        """
+        Find the category for a given class ID
+        
+        Args:
+            class_id: Class ID (0-79)
+            
+        Returns:
+            Category name
+        """
+        for category, ids in self.CATEGORIES.items():
+            if class_id in ids:
+                return category
+        return "other"  # Fallback
+    
+    def _generate_color_map(self) -> Dict:
+        """
+        Generate a color map for all 80 COCO classes
+        
+        Returns:
+            Dictionary mapping class IDs and names to color values
+        """
+        color_map = {
+            'by_id': {},      # Map class ID to RGB and hex
+            'by_name': {},    # Map class name to RGB and hex
+            'categories': {}  # Map category to base color
+        }
+        
+        # Generate colors for categories
+        for category, hsv in self.CATEGORY_COLORS.items():
+            rgb = self._hsv_to_rgb(hsv[0], hsv[1], hsv[2])
+            hex_color = self._rgb_to_hex(rgb)
+            color_map['categories'][category] = {
+                'rgb': rgb,
+                'hex': hex_color
+            }
+        
+        # Generate variations for each class within a category
+        for class_id, class_name in self.class_names.items():
+            category = self._find_category(class_id)
+            base_hsv = self.CATEGORY_COLORS.get(category, (0, 0, 0.8))  # Default gray
+            
+            # Slightly vary the hue and saturation within the category
+            ids_in_category = self.CATEGORIES.get(category, [])
+            if ids_in_category:
+                position = ids_in_category.index(class_id) if class_id in ids_in_category else 0
+                variation = position / max(1, len(ids_in_category) - 1)  # 0 to 1
+                
+                # Vary hue slightly (±15°) and saturation
+                h_offset = 30 * variation - 15  # -15 to +15
+                s_offset = 0.2 * variation  # 0 to 0.2
+                
+                h = (base_hsv[0] + h_offset) % 360
+                s = min(1.0, base_hsv[1] + s_offset)
+                v = base_hsv[2]
+            else:
+                h, s, v = base_hsv
+            
+            rgb = self._hsv_to_rgb(h, s, v)
+            hex_color = self._rgb_to_hex(rgb)
+            
+            # Store in both mappings
+            color_map['by_id'][class_id] = {
+                'rgb': rgb,
+                'hex': hex_color,
+                'category': category
+            }
+            
+            color_map['by_name'][class_name] = {
+                'rgb': rgb,
+                'hex': hex_color,
+                'category': category
+            }
+        
+        return color_map
+    
+    def get_color(self, class_identifier: Union[int, str], format: str = 'hex') -> Any:
+        """
+        Get color for a specific class
+        
+        Args:
+            class_identifier: Class ID (int) or name (str)
+            format: Color format ('hex', 'rgb', or 'bgr')
+            
+        Returns:
+            Color in requested format
+        """
+        # Determine if identifier is an ID or name
+        if isinstance(class_identifier, int):
+            color_info = self.color_map['by_id'].get(class_identifier)
+        else:
+            color_info = self.color_map['by_name'].get(class_identifier)
+        
+        if not color_info:
+            # Fallback color if not found
+            return '#CCCCCC' if format == 'hex' else (204, 204, 204)
+        
+        if format == 'hex':
+            return color_info['hex']
+        elif format == 'rgb':
+            return color_info['rgb']
+        elif format == 'bgr':
+            # Convert RGB to BGR for OpenCV
+            r, g, b = color_info['rgb']
+            return (b, g, r)
+        else:
+            return color_info['rgb']
+    
+    def get_all_colors(self, format: str = 'hex') -> Dict:
+        """
+        Get all colors in the specified format
+        
+        Args:
+            format: Color format ('hex', 'rgb', or 'bgr')
+            
+        Returns:
+            Dictionary mapping class names to colors
+        """
+        result = {}
+        for class_id, class_name in self.class_names.items():
+            result[class_name] = self.get_color(class_id, format)
+        return result
+    
+    def get_category_colors(self, format: str = 'hex') -> Dict:
+        """
+        Get base colors for each category
+        
+        Args:
+            format: Color format ('hex', 'rgb', or 'bgr')
+            
+        Returns:
+            Dictionary mapping categories to colors
+        """
+        result = {}
+        for category, color_info in self.color_map['categories'].items():
+            if format == 'hex':
+                result[category] = color_info['hex']
+            elif format == 'bgr':
+                r, g, b = color_info['rgb']
+                result[category] = (b, g, r)
+            else:
+                result[category] = color_info['rgb']
+        return result
+    
+    def get_category_for_class(self, class_identifier: Union[int, str]) -> str:
+        """
+        Get the category for a specific class
+        
+        Args:
+            class_identifier: Class ID (int) or name (str)
+            
+        Returns:
+            Category name
+        """
+        if isinstance(class_identifier, int):
+            return self.color_map['by_id'].get(class_identifier, {}).get('category', 'other')
+        else:
+            return self.color_map['by_name'].get(class_identifier, {}).get('category', 'other')

detection_model.py

@@ -0,0 +1,164 @@
+from ultralytics import YOLO
+from typing import Any, List, Dict, Optional
+import torch
+import numpy as np
+import os
+
+class DetectionModel:
+    """Core detection model class for object detection using YOLOv8"""
+    
+    # Model information dictionary
+    MODEL_INFO = {
+        "yolov8n.pt": {
+            "name": "YOLOv8n (Nano)",
+            "description": "Fastest model with smallest size (3.2M parameters). Best for speed-critical applications.",
+            "size_mb": 6,
+            "inference_speed": "Very Fast"
+        },
+        "yolov8m.pt": {
+            "name": "YOLOv8m (Medium)",
+            "description": "Balanced model with good accuracy-speed tradeoff (25.9M parameters). Recommended for general use.",
+            "size_mb": 25,
+            "inference_speed": "Medium"
+        },
+        "yolov8x.pt": {
+            "name": "YOLOv8x (XLarge)",
+            "description": "Most accurate but slower model (68.2M parameters). Best for accuracy-critical applications.",
+            "size_mb": 68,
+            "inference_speed": "Slower"
+        }
+    }
+    
+    def __init__(self, model_name: str = 'yolov8m.pt', confidence: float = 0.25, iou: float = 0.45):
+        """
+        Initialize the detection model
+        
+        Args:
+            model_name: Model name or path, default is yolov8m.pt
+            confidence: Confidence threshold, default is 0.25
+            iou: IoU threshold for non-maximum suppression, default is 0.45
+        """
+        self.model_name = model_name
+        self.confidence = confidence
+        self.iou = iou
+        self.model = None
+        self.class_names = {}
+        self.is_model_loaded = False
+        
+        # Load model on initialization
+        self._load_model()
+        
+    def _load_model(self):
+        """Load the YOLO model"""
+        try:
+            print(f"Loading model: {self.model_name}")
+            self.model = YOLO(self.model_name)
+            self.class_names = self.model.names
+            self.is_model_loaded = True
+            print(f"Successfully loaded model: {self.model_name}")
+            print(f"Number of classes the model can recognize: {len(self.class_names)}")
+        except Exception as e:
+            print(f"Error occurred when loading the model: {e}")
+            self.is_model_loaded = False
+    
+    def change_model(self, new_model_name: str) -> bool:
+        """
+        Change the currently loaded model
+        
+        Args:
+            new_model_name: Name of the new model to load
+            
+        Returns:
+            bool: True if model changed successfully, False otherwise
+        """
+        if self.model_name == new_model_name and self.is_model_loaded:
+            print(f"Model {new_model_name} is already loaded")
+            return True
+            
+        print(f"Changing model from {self.model_name} to {new_model_name}")
+        
+        # Unload current model to free memory
+        if self.model is not None:
+            del self.model
+            self.model = None
+            
+            # Clean GPU memory if available
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                
+        # Update model name and load new model
+        self.model_name = new_model_name
+        self._load_model()
+        
+        return self.is_model_loaded
+            
+    def reload_model(self):
+        """Reload the model (useful for changing model or after error)"""
+        if self.model is not None:
+            del self.model
+            self.model = None
+            
+            # Clean GPU memory if available
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                
+        self._load_model()
+            
+    def detect(self, image_input: Any) -> Optional[Any]:
+        """
+        Perform object detection on a single image
+        
+        Args:
+            image_input: Image path (str), PIL Image, or numpy array
+            
+        Returns:
+            Detection result object or None if error occurred
+        """
+        if self.model is None or not self.is_model_loaded:
+            print("Model not found or not loaded. Attempting to reload...")
+            self._load_model()
+            if self.model is None or not self.is_model_loaded:
+                print("Failed to load model. Cannot perform detection.")
+                return None
+                
+        try:
+            results = self.model(image_input, conf=self.confidence, iou=self.iou)
+            return results[0]
+        except Exception as e:
+            print(f"Error occurred during detection: {e}")
+            return None
+    
+    def get_class_names(self, class_id: int) -> str:
+        """Get class name for a given class ID"""
+        return self.class_names.get(class_id, "Unknown Class")
+    
+    def get_supported_classes(self) -> Dict[int, str]:
+        """Get all supported classes as a dictionary of {id: class_name}"""
+        return self.class_names
+        
+    @classmethod
+    def get_available_models(cls) -> List[Dict]:
+        """
+        Get list of available models with their information
+        
+        Returns:
+            List of dictionaries containing model information
+        """
+        models = []
+        for model_file, info in cls.MODEL_INFO.items():
+            models.append({
+                "model_file": model_file,
+                "name": info["name"],
+                "description": info["description"],
+                "size_mb": info["size_mb"],
+                "inference_speed": info["inference_speed"]
+            })
+        return models
+        
+    @classmethod
+    def get_model_description(cls, model_name: str) -> str:
+        """Get description for a specific model"""
+        if model_name in cls.MODEL_INFO:
+            info = cls.MODEL_INFO[model_name]
+            return f"{info['name']}: {info['description']} (Size: ~{info['size_mb']}MB, Speed: {info['inference_speed']})"
+        return "Model information not available"

evaluation_metrics.py

@@ -0,0 +1,360 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from typing import Dict, List, Any, Optional, Tuple
+
+class EvaluationMetrics:
+    """Class for computing detection metrics, generating statistics and visualization data"""
+    
+    @staticmethod
+    def calculate_basic_stats(result: Any) -> Dict:
+        """
+        Calculate basic statistics for a single detection result
+        
+        Args:
+            result: Detection result object
+            
+        Returns:
+            Dictionary with basic statistics
+        """
+        if result is None:
+            return {"error": "No detection result provided"}
+            
+        # Get classes and confidences
+        classes = result.boxes.cls.cpu().numpy().astype(int)
+        confidences = result.boxes.conf.cpu().numpy()
+        names = result.names
+        
+        # Count by class
+        class_counts = {}
+        for cls, conf in zip(classes, confidences):
+            cls_name = names[int(cls)]
+            if cls_name not in class_counts:
+                class_counts[cls_name] = {"count": 0, "total_confidence": 0, "confidences": []}
+                
+            class_counts[cls_name]["count"] += 1
+            class_counts[cls_name]["total_confidence"] += float(conf)
+            class_counts[cls_name]["confidences"].append(float(conf))
+        
+        # Calculate average confidence
+        for cls_name, stats in class_counts.items():
+            if stats["count"] > 0:
+                stats["average_confidence"] = stats["total_confidence"] / stats["count"]
+                stats["confidence_std"] = float(np.std(stats["confidences"])) if len(stats["confidences"]) > 1 else 0
+                stats.pop("total_confidence")  # Remove intermediate calculation
+        
+        # Prepare summary
+        stats = {
+            "total_objects": len(classes),
+            "class_statistics": class_counts,
+            "average_confidence": float(np.mean(confidences)) if len(confidences) > 0 else 0
+        }
+        
+        return stats
+    
+    @staticmethod
+    def generate_visualization_data(result: Any, class_colors: Dict = None) -> Dict:
+        """
+        Generate structured data suitable for visualization
+        
+        Args:
+            result: Detection result object
+            class_colors: Dictionary mapping class names to color codes (optional)
+            
+        Returns:
+            Dictionary with visualization-ready data
+        """
+        if result is None:
+            return {"error": "No detection result provided"}
+            
+        # Get basic stats first
+        stats = EvaluationMetrics.calculate_basic_stats(result)
+        
+        # Create visualization-specific data structure
+        viz_data = {
+            "total_objects": stats["total_objects"],
+            "average_confidence": stats["average_confidence"],
+            "class_data": []
+        }
+        
+        # Sort classes by count (descending)
+        sorted_classes = sorted(
+            stats["class_statistics"].items(),
+            key=lambda x: x[1]["count"],
+            reverse=True
+        )
+        
+        # Create class-specific visualization data
+        for cls_name, cls_stats in sorted_classes:
+            class_id = -1
+            # Find the class ID based on the name
+            for idx, name in result.names.items():
+                if name == cls_name:
+                    class_id = idx
+                    break
+                    
+            cls_data = {
+                "name": cls_name,
+                "class_id": class_id,
+                "count": cls_stats["count"],
+                "average_confidence": cls_stats.get("average_confidence", 0),
+                "confidence_std": cls_stats.get("confidence_std", 0),
+                "color": class_colors.get(cls_name, "#CCCCCC") if class_colors else "#CCCCCC"
+            }
+            
+            viz_data["class_data"].append(cls_data)
+        
+        return viz_data
+    
+    @staticmethod
+    def create_stats_plot(viz_data: Dict, figsize: Tuple[int, int] = (10, 7), max_classes: int = 30) -> plt.Figure:
+        """
+        Create a horizontal bar chart showing detection statistics
+        
+        Args:
+            viz_data: Visualization data generated by generate_visualization_data
+            figsize: Figure size (width, height) in inches
+            max_classes: Maximum number of classes to display
+            
+        Returns:
+            Matplotlib figure object
+        """
+        # Use the enhanced version
+        return EvaluationMetrics.create_enhanced_stats_plot(viz_data, figsize, max_classes)
+
+    @staticmethod
+    def create_enhanced_stats_plot(viz_data: Dict, figsize: Tuple[int, int] = (10, 7), max_classes: int = 30) -> plt.Figure:
+        """
+        Create an enhanced horizontal bar chart with larger fonts and better styling
+        
+        Args:
+            viz_data: Visualization data dictionary
+            figsize: Figure size (width, height) in inches
+            max_classes: Maximum number of classes to display
+            
+        Returns:
+            Matplotlib figure with enhanced styling
+        """
+        if "error" in viz_data:
+            # Create empty plot if error
+            fig, ax = plt.subplots(figsize=figsize)
+            ax.text(0.5, 0.5, viz_data["error"], 
+                    ha='center', va='center', fontsize=14, fontfamily='Arial')
+            ax.set_xlim(0, 1)
+            ax.set_ylim(0, 1)
+            ax.axis('off')
+            return fig
+            
+        if "class_data" not in viz_data or not viz_data["class_data"]:
+            # Create empty plot if no data
+            fig, ax = plt.subplots(figsize=figsize)
+            ax.text(0.5, 0.5, "No detection data available", 
+                    ha='center', va='center', fontsize=14, fontfamily='Arial')
+            ax.set_xlim(0, 1)
+            ax.set_ylim(0, 1)
+            ax.axis('off')
+            return fig
+        
+        # Limit to max_classes
+        class_data = viz_data["class_data"][:max_classes]
+        
+        # Extract data for plotting
+        class_names = [item["name"] for item in class_data]
+        counts = [item["count"] for item in class_data]
+        colors = [item["color"] for item in class_data]
+        
+        # Create figure and horizontal bar chart with improved styling
+        plt.rcParams['font.family'] = 'Arial'
+        fig, ax = plt.subplots(figsize=figsize)
+        
+        # Set background color to white
+        fig.patch.set_facecolor('white')
+        ax.set_facecolor('white')
+        
+        y_pos = np.arange(len(class_names))
+        
+        # Create horizontal bars with class-specific colors
+        bars = ax.barh(y_pos, counts, color=colors, alpha=0.8, height=0.6)
+        
+        # Add count values at end of each bar with larger font
+        for i, bar in enumerate(bars):
+            width = bar.get_width()
+            conf = class_data[i]["average_confidence"]
+            ax.text(width + 0.3, bar.get_y() + bar.get_height()/2, 
+                    f"{width:.0f} (conf: {conf:.2f})", 
+                    va='center', fontsize=12, fontfamily='Arial')
+        
+        # Customize axis and labels with larger fonts
+        ax.set_yticks(y_pos)
+        ax.set_yticklabels(class_names, fontsize=14, fontfamily='Arial')
+        ax.invert_yaxis()  # Labels read top-to-bottom
+        ax.set_xlabel('Count', fontsize=14, fontfamily='Arial')
+        ax.set_title(f'Objects Detected: {viz_data["total_objects"]} Total', 
+                    fontsize=16, fontfamily='Arial', fontweight='bold')
+        
+        # Add grid for better readability
+        ax.set_axisbelow(True)
+        ax.grid(axis='x', linestyle='--', alpha=0.7, color='#E5E7EB')
+        
+        # Increase tick label font size
+        ax.tick_params(axis='both', which='major', labelsize=12)
+        
+        # Add detection summary as a text box with improved styling
+        summary_text = (
+            f"Total Objects: {viz_data['total_objects']}\n"
+            f"Average Confidence: {viz_data['average_confidence']:.2f}\n"
+            f"Unique Classes: {len(viz_data['class_data'])}"
+        )
+        plt.figtext(0.02, 0.02, summary_text, fontsize=12, fontfamily='Arial',
+                bbox=dict(facecolor='white', alpha=0.9, boxstyle='round,pad=0.5', 
+                            edgecolor='#E5E7EB'))
+        
+        plt.tight_layout()
+        return fig
+    
+    @staticmethod
+    def format_detection_summary(viz_data: Dict) -> str:
+        """
+        Format detection results as a readable text summary with improved spacing
+        
+        Args:
+            viz_data: Visualization data generated by generate_visualization_data
+            
+        Returns:
+            Formatted text with proper spacing
+        """
+        if "error" in viz_data:
+            return viz_data["error"]
+                
+        if "total_objects" not in viz_data:
+            return "No detection data available."
+                
+        # 獲取基本統計信息
+        total_objects = viz_data["total_objects"]
+        avg_confidence = viz_data["average_confidence"]
+        
+        # 創建標題，使用更多空白行增加可讀性
+        lines = [
+            f"Detected {total_objects} objects.", 
+            f"Average confidence: {avg_confidence:.2f}",
+            "\n",  # 添加額外的空行
+            "Objects by class:",
+        ]
+        
+        # 添加類別詳情，每個類別使用更多空間
+        if "class_data" in viz_data and viz_data["class_data"]:
+            for item in viz_data["class_data"]:
+                count = item['count']
+                # 使用正確的單複數形式
+                item_text = "item" if count == 1 else "items"
+                
+                # 每個項目前添加空行，並使用縮進格式化
+                lines.append("\n")  # 每個項目前添加空白行
+                lines.append(f"• {item['name']}: {count} {item_text}")  
+                lines.append(f"    Confidence: {item['average_confidence']:.2f}")
+        else:
+            lines.append("\nNo class information available.")
+        
+        return "\n".join(lines)
+    
+    @staticmethod
+    def calculate_distance_metrics(result: Any) -> Dict:
+        """
+        Calculate distance-related metrics for detected objects
+        
+        Args:
+            result: Detection result object
+            
+        Returns:
+            Dictionary with distance metrics
+        """
+        if result is None:
+            return {"error": "No detection result provided"}
+            
+        boxes = result.boxes.xyxy.cpu().numpy()
+        classes = result.boxes.cls.cpu().numpy().astype(int)
+        names = result.names
+        
+        # Initialize metrics
+        metrics = {
+            "proximity": {},  # Classes that appear close to each other
+            "spatial_distribution": {},  # Distribution across the image
+            "size_distribution": {}  # Size distribution of objects
+        }
+        
+        # Calculate image dimensions (assuming normalized coordinates or extract from result)
+        img_width, img_height = 1, 1
+        if hasattr(result, "orig_shape"):
+            img_height, img_width = result.orig_shape[:2]
+        
+        # Calculate bounding box areas and centers
+        areas = []
+        centers = []
+        class_names = []
+        
+        for box, cls in zip(boxes, classes):
+            x1, y1, x2, y2 = box
+            width, height = x2 - x1, y2 - y1
+            area = width * height
+            center_x, center_y = (x1 + x2) / 2, (y1 + y2) / 2
+            
+            areas.append(area)
+            centers.append((center_x, center_y))
+            class_names.append(names[int(cls)])
+        
+        # Calculate spatial distribution
+        if centers:
+            x_coords = [c[0] for c in centers]
+            y_coords = [c[1] for c in centers]
+            
+            metrics["spatial_distribution"] = {
+                "x_mean": float(np.mean(x_coords)) / img_width,
+                "y_mean": float(np.mean(y_coords)) / img_height,
+                "x_std": float(np.std(x_coords)) / img_width,
+                "y_std": float(np.std(y_coords)) / img_height
+            }
+        
+        # Calculate size distribution
+        if areas:
+            metrics["size_distribution"] = {
+                "mean_area": float(np.mean(areas)) / (img_width * img_height),
+                "std_area": float(np.std(areas)) / (img_width * img_height),
+                "min_area": float(np.min(areas)) / (img_width * img_height),
+                "max_area": float(np.max(areas)) / (img_width * img_height)
+            }
+        
+        # Calculate proximity between different classes
+        class_centers = {}
+        for cls_name, center in zip(class_names, centers):
+            if cls_name not in class_centers:
+                class_centers[cls_name] = []
+            class_centers[cls_name].append(center)
+        
+        # Find classes that appear close to each other
+        proximity_pairs = []
+        for i, cls1 in enumerate(class_centers.keys()):
+            for j, cls2 in enumerate(class_centers.keys()):
+                if i >= j:  # Avoid duplicate pairs and self-comparison
+                    continue
+                    
+                # Calculate minimum distance between any two objects of these classes
+                min_distance = float('inf')
+                for center1 in class_centers[cls1]:
+                    for center2 in class_centers[cls2]:
+                        dist = np.sqrt((center1[0] - center2[0])**2 + (center1[1] - center2[1])**2)
+                        min_distance = min(min_distance, dist)
+                
+                # Normalize by image diagonal
+                img_diagonal = np.sqrt(img_width**2 + img_height**2)
+                norm_distance = min_distance / img_diagonal
+                
+                proximity_pairs.append({
+                    "class1": cls1,
+                    "class2": cls2,
+                    "distance": float(norm_distance)
+                })
+        
+        # Sort by distance and keep the closest pairs
+        proximity_pairs.sort(key=lambda x: x["distance"])
+        metrics["proximity"] = proximity_pairs[:5]  # Keep top 5 closest pairs
+        
+        return metrics

style.py

@@ -0,0 +1,282 @@
+class Style:
+    @staticmethod
+    def get_css():
+        """Return the application's CSS styles with improved aesthetics"""
+        css = """
+        /* Base styles and typography */
+        body {
+            font-family: Arial, sans-serif;
+            background: linear-gradient(135deg, #f0f9ff, #e1f5fe);
+            margin: 0;
+            padding: 0;
+            display: flex;
+            justify-content: center;
+            min-height: 100vh;
+        }
+        
+        /* Typography improvements */
+        h1, h2, h3, h4, h5, h6, p, span, div, label, button {
+            font-family: Arial, sans-serif;
+        }
+        
+        /* Container styling */
+        .gradio-container {
+            max-width: 1200px !important;
+            margin: 0 auto;
+            padding: 1rem;
+            width: 100%;
+        }
+        
+        /* Header area styling with gradient background */
+        .app-header {
+            text-align: center;
+            margin-bottom: 2rem;
+            background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+            padding: 1.5rem;
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
+            width: 100%;
+        }
+        
+        .app-title {
+            color: #2D3748;
+            font-size: 2.5rem;
+            margin-bottom: 0.5rem;
+            background: linear-gradient(90deg, #38b2ac, #4299e1);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            font-weight: bold;
+        }
+        
+        .app-subtitle {
+            color: #4A5568;
+            font-size: 1.2rem;
+            font-weight: normal;
+            margin-top: 0.25rem;
+        }
+        
+        .app-divider {
+            width: 80px;
+            height: 3px;
+            background: linear-gradient(90deg, #38b2ac, #4299e1);
+            margin: 1rem auto;
+        }
+        
+        /* Panel styling - gradient background */
+        .input-panel, .output-panel {
+            background: white;
+            border-radius: 10px;
+            padding: 1.5rem;
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+            margin: 0 auto 1rem auto;
+        }
+        
+        /* Section heading styling with gradient background */
+        .section-heading {
+            font-size: 1.25rem;
+            font-weight: 600;
+            color: #2D3748;
+            margin-bottom: 1rem;
+            margin-top: 0.5rem;
+            text-align: center;
+            padding: 0.8rem;
+            background: linear-gradient(to right, #e6f3fc, #f0f9ff);
+            border-radius: 8px;
+        }
+        
+        /* How-to-use section with gradient background */
+        .how-to-use {
+            background: linear-gradient(135deg, #f8fafc, #e8f4fd);
+            border-radius: 10px;
+            padding: 1.5rem;
+            margin-top: 1rem;
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+            color: #2d3748;
+        }
+        
+        /* Detection button styling */
+        .detect-btn {
+            background: linear-gradient(90deg, #38b2ac, #4299e1) !important;
+            color: white !important;
+            border: none !important;
+            border-radius: 8px !important;
+            transition: transform 0.3s, box-shadow 0.3s !important;
+            font-weight: bold !important;
+            letter-spacing: 0.5px !important;
+            padding: 0.75rem 1.5rem !important;
+            width: 100%;
+            margin: 1rem auto !important;
+            font-family: Arial, sans-serif !important;
+        }
+        
+        .detect-btn:hover {
+            transform: translateY(-2px) !important;
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2) !important;
+        }
+        
+        .detect-btn:active {
+            transform: translateY(1px) !important;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2) !important;
+        }
+        
+        /* JSON display improvements */
+        .json-display pre {
+            background: #f8fafc;
+            border-radius: 6px;
+            padding: 1rem;
+            font-family: 'Consolas', 'Monaco', monospace;
+            white-space: pre-wrap;
+            max-height: 500px;
+            overflow-y: auto;
+            box-shadow: inset 0 0 4px rgba(0, 0, 0, 0.1);
+        }
+        
+        .json-key {
+            color: #e53e3e;
+        }
+        
+        .json-value {
+            color: #2b6cb0;
+        }
+        
+        .json-string {
+            color: #38a169;
+        }
+        
+        /* Chart/plot styling improvements */
+        .plot-container {
+            background: white;
+            border-radius: 8px;
+            padding: 0.5rem;
+            box-shadow: 0 2px 6px rgba(0, 0, 0, 0.05);
+        }
+        
+        /* Larger font for plots */
+        .plot-container text {
+            font-family: Arial, sans-serif !important;
+            font-size: 14px !important;
+        }
+        
+        /* Title styling for charts */
+        .plot-title {
+            font-family: Arial, sans-serif !important;
+            font-size: 16px !important;
+            font-weight: bold !important;
+        }
+        
+        /* Tab styling with subtle gradient */
+        .tabs {
+            width: 100%;
+            display: flex;
+            justify-content: center;
+        }
+        
+        .tabs > div:first-child {
+            background: linear-gradient(to right, #f8fafc, #e8f4fd) !important;
+            border-radius: 8px 8px 0 0;
+        }
+        
+        /* Footer styling with gradient background */
+        .footer {
+            text-align: center;
+            margin-top: 2rem;
+            font-size: 0.9rem;
+            color: #4A5568;
+            padding: 1rem;
+            background: linear-gradient(135deg, #f8f9fa, #e1effe);
+            border-radius: 10px;
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+            width: 100%;
+        }
+        
+        /* Ensure centering works for all elements */
+        .container, .gr-container, .gr-row, .gr-col {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            width: 100%;
+        }
+        
+        /* 結果文本框的改進樣式 */
+        #detection-details, .wide-result-text {
+            width: 100% !important;
+            max-width: 100% !important;
+            box-sizing: border-box !important;
+        }
+        
+        .wide-result-text textarea {
+            width: 100% !important;
+            min-width: 600px !important;
+            font-family: 'Arial', sans-serif !important;
+            font-size: 14px !important;
+            line-height: 1.5 !important;  /* 減少行間距 */
+            padding: 16px !important;
+            white-space: pre-wrap !important;
+            background-color: #f8f9fa !important;
+            border-radius: 8px !important;
+            min-height: 300px !important;
+            resize: none !important;
+            overflow-y: auto !important;
+            border: 1px solid #e2e8f0 !important;
+            display: block !important;
+        }
+        
+        /* 結果詳情面板樣式 - 加入漸層背景 */
+        .result-details-box {
+            width: 100% !important;
+            margin-top: 1.5rem;
+            background: linear-gradient(135deg, #f8fafc, #e8f4fd);
+            border-radius: 10px;
+            padding: 1rem;
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+        }
+        
+        /* 確保結果詳情面板內的元素寬度可以適應面板 */
+        .result-details-box > * {
+            width: 100% !important;
+            max-width: 100% !important;
+        }
+        
+        /* 確保文本區域不會被限制寬度 */
+        .result-details-box .gr-text-input {
+            width: 100% !important;
+            max-width: none !important;
+        }
+        
+        /* 輸出面板內容的布局調整 */
+        .output-panel {
+            display: flex;
+            flex-direction: column;
+            width: 100%;
+            padding: 0 !important;
+        }
+        
+        /* 確保結果面板內的元素寬度可以適應面板 */
+        .output-panel > * {
+            width: 100%;
+        }
+        
+        /* 改善統計面板列佈局 */
+        .plot-column, .stats-column {
+            display: flex;
+            flex-direction: column;
+            padding: 1rem;
+        }
+        
+        /* Responsive adjustments */
+        @media (max-width: 768px) {
+            .app-title {
+                font-size: 2rem;
+            }
+            
+            .app-subtitle {
+                font-size: 1rem;
+            }
+            
+            .gradio-container {
+                padding: 0.5rem;
+            }
+        }
+        """
+        return css

visualization_helper.py

@@ -0,0 +1,147 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from typing import Any, List, Dict, Tuple, Optional
+import io
+from PIL import Image
+
+class VisualizationHelper:
+    """Helper class for visualizing detection results"""
+    
+    @staticmethod
+    def visualize_detection(image: Any, result: Any, color_mapper: Optional[Any] = None,
+                            figsize: Tuple[int, int] = (12, 12),
+                            return_pil: bool = False) -> Optional[Image.Image]:
+        """
+        Visualize detection results on a single image
+        
+        Args:
+            image: Image path or numpy array
+            result: Detection result object
+            color_mapper: ColorMapper instance for consistent colors
+            figsize: Figure size
+            return_pil: If True, returns a PIL Image object
+            
+        Returns:
+            PIL Image if return_pil is True, otherwise displays the plot
+        """
+        if result is None:
+            print('No data for visualization')
+            return None
+            
+        # Read image if path is provided
+        if isinstance(image, str):
+            img = cv2.imread(image)
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        else:
+            img = image
+            if len(img.shape) == 3 and img.shape[2] == 3:
+                # Check if BGR format (OpenCV) and convert to RGB if needed
+                if isinstance(img, np.ndarray):
+                    # Assuming BGR format from OpenCV
+                    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        
+        # Create figure
+        fig, ax = plt.subplots(figsize=figsize)
+        ax.imshow(img)
+        
+        # Get bounding boxes, classes and confidences
+        boxes = result.boxes.xyxy.cpu().numpy()
+        classes = result.boxes.cls.cpu().numpy()
+        confs = result.boxes.conf.cpu().numpy()
+        
+        # Get class names
+        names = result.names
+        
+        # Create a default color mapper if none is provided
+        if color_mapper is None:
+            # For backward compatibility, fallback to a simple color function
+            from matplotlib import colormaps
+            cmap = colormaps['tab10']
+            def get_color(class_id):
+                return cmap(class_id % 10)
+        else:
+            # Use the provided color mapper
+            def get_color(class_id):
+                hex_color = color_mapper.get_color(class_id)
+                # Convert hex to RGB float values for matplotlib
+                hex_color = hex_color.lstrip('#')
+                return tuple(int(hex_color[i:i+2], 16) / 255 for i in (0, 2, 4)) + (1.0,)
+        
+        # Draw detection results
+        for box, cls, conf in zip(boxes, classes, confs):
+            x1, y1, x2, y2 = box
+            cls_id = int(cls)
+            cls_name = names[cls_id]
+            
+            # Get color for this class
+            box_color = get_color(cls_id)
+            
+            # Add text label with colored background
+            ax.text(x1, y1 - 5, f'{cls_name}: {conf:.2f}',
+                    color='white', fontsize=10,
+                    bbox=dict(facecolor=box_color[:3], alpha=0.7))
+            
+            # Add bounding box
+            ax.add_patch(plt.Rectangle((x1, y1), x2-x1, y2-y1, 
+                                    fill=False, edgecolor=box_color[:3], linewidth=2))
+        
+        ax.axis('off')
+        # ax.set_title('Detection Result')
+        plt.tight_layout()
+        
+        if return_pil:
+            # Convert plot to PIL Image
+            buf = io.BytesIO()
+            fig.savefig(buf, format='png', bbox_inches='tight', pad_inches=0)
+            buf.seek(0)
+            pil_img = Image.open(buf)
+            plt.close(fig)
+            return pil_img
+        else:
+            plt.show()
+            return None
+    
+    @staticmethod
+    def create_summary(result: Any) -> Dict:
+        """
+        Create a summary of detection results
+        
+        Args:
+            result: Detection result object
+            
+        Returns:
+            Dictionary with detection summary statistics
+        """
+        if result is None:
+            return {"error": "No detection result provided"}
+            
+        # Get classes and confidences
+        classes = result.boxes.cls.cpu().numpy().astype(int)
+        confidences = result.boxes.conf.cpu().numpy()
+        names = result.names
+        
+        # Count detections by class
+        class_counts = {}
+        for cls, conf in zip(classes, confidences):
+            cls_name = names[int(cls)]
+            if cls_name not in class_counts:
+                class_counts[cls_name] = {"count": 0, "confidences": []}
+                
+            class_counts[cls_name]["count"] += 1
+            class_counts[cls_name]["confidences"].append(float(conf))
+            
+        # Calculate average confidence for each class
+        for cls_name, stats in class_counts.items():
+            if stats["confidences"]:
+                stats["average_confidence"] = float(np.mean(stats["confidences"]))
+                stats.pop("confidences")  # Remove detailed confidences list to keep summary concise
+        
+        # Prepare summary
+        summary = {
+            "total_objects": len(classes),
+            "class_counts": class_counts,
+            "unique_classes": len(class_counts)
+        }
+        
+        return summary