**Real-world analogy:** YOLO is like a skilled airport security officer who scans an entire frame at once. Instead of examining each passenger individually (sliding window), they instantly spot all suspicious items in the whole scene simultaneously.

## Object Detection Implementation

```python
from dataclasses import dataclass
from typing import List, Tuple

@dataclass
class Detection:
    """Represents a single object detection."""
    bbox: Tuple[int, int, int, int]  # x1, y1, x2, y2
    confidence: float
    class_id: int
    class_name: str

class DroneObjectDetector:
    """YOLO-style object detector for drone imagery."""

    def __init__(self, num_classes=80, input_size=640, num_anchors=3):
        self.num_classes = num_classes
        self.input_size = input_size
        self.num_anchors = num_anchors
        self.class_names = self._load_class_names()

    def _load_class_names(self):
        """Load COCO class names."""
        return [
            'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
            'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
            'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
            'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
            'backpack', 'umbrella', 'handbag', 'tie', 'suitcase',
            'frisbee', 'skis', 'snowboard', 'sports ball', 'kite',
            'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
            'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
            'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',
            'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut',
            'cake', 'chair', 'couch', 'potted plant', 'bed', 'dining table',
            'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard',
            'cell phone', 'microwave', 'oven', 'toaster', 'sink',
            'refrigerator', 'book', 'clock', 'vase', 'scissors',
            'teddy bear', 'hair drier', 'toothbrush'
        ]

    def simulate_yolo_output(self, image_shape):
        """Simulate YOLO network output."""
        h, w = image_shape[:2]
        grid_size = self.input_size // 32  # 20x20 grid

        # Generate mock detections
        detections = []
        num_detections = np.random.randint(3, 10)

        for _ in range(num_detections):
            # Random bounding box
            x1 = np.random.randint(0, w - 100)
            y1 = np.random.randint(0, h - 100)
            bw = np.random.randint(50, min(200, w - x1))
            bh = np.random.randint(50, min(200, h - y1))

            confidence = np.random.uniform(0.3, 0.95)
            class_id = np.random.randint(0, self.num_classes)

            detections.append(Detection(
                bbox=(x1, y1, x1 + bw, y1 + bh),
                confidence=confidence,
                class_id=class_id,
                class_name=self.class_names[class_id]
            ))

        return detections

    def non_max_suppression(self, detections: List[Detection],
                           iou_threshold=0.5) -> List[Detection]:
        """Apply Non-Maximum Suppression."""
        if not detections:
            return []

        # Sort by confidence
        sorted_dets = sorted(detections, key=lambda d: d.confidence, reverse=True)

        keep = []
        while sorted_dets:
            current = sorted_dets.pop(0)
            keep.append(current)

            remaining = []
            for det in sorted_dets:
                if det.class_id == current.class_id:
                    iou = self._compute_iou(current.bbox, det.bbox)
                    if iou < iou_threshold:
                        remaining.append(det)
                else:
                    remaining.append(det)

            sorted_dets = remaining

        return keep

    def _compute_iou(self, box1, box2):
        """Compute Intersection over Union."""
        x1 = max(box1[0], box2[0])
        y1 = max(box1[1], box2[1])
        x2 = min(box1[2], box2[2])
        y2 = min(box1[3], box2[3])

        intersection = max(0, x2 - x1) * max(0, y2 - y1)

        area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
        area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
        union = area1 + area2 - intersection

        return intersection / union if union > 0 else 0

    def scale_detections(self, detections, original_size, model_size):
        """Scale detections from model space to original image space."""
        scale_x = original_size[1] / model_size[1]
        scale_y = original_size[0] / model_size[0]

        scaled = []
        for det in detections:
            x1 = int(det.bbox[0] * scale_x)
            y1 = int(det.bbox[1] * scale_y)
            x2 = int(det.bbox[2] * scale_x)
            y2 = int(det.bbox[3] * scale_y)

            scaled.append(Detection(
                bbox=(x1, y1, x2, y2),
                confidence=det.confidence,
                class_id=det.class_id,
                class_name=det.class_name
            ))

        return scaled

# Example: Run detection
np.random.seed(42)
detector = DroneObjectDetector(num_classes=80)

# Simulate drone frame
frame_shape = (720, 1280, 3)

# Get detections
detections = detector.simulate_yolo_output(frame_shape)
print(f"Raw detections: {len(detections)}")

# Apply NMS
nms_detections = detector.non_max_suppression(detections, iou_threshold=0.5)
print(f"After NMS: {len(nms_detections)}")

# Display top detections
for det in sorted(nms_detections, key=lambda d: d.confidence, reverse=True)[:5]:
    print(f"  {det.class_name}: {det.confidence:.2%} at {det.bbox}")