**Real-world analogy:** Face recognition from a drone is like a security guard with a photo album. They see a face, compare it to their memory, and determine if the person is authorized. The challenge is doing this accurately from a moving platform at varying distances.

## Face Detection

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

@dataclass
class FaceDetection:
    """Single face detection."""
    bbox: Tuple[int, int, int, int]  # x1, y1, x2, y2
    confidence: float
    landmarks: np.ndarray  # 5 facial landmarks
    embedding: np.ndarray = None

class FaceDetector:
    """Face detection optimized for drone imagery."""

    def __init__(self, confidence_threshold=0.7, nms_threshold=0.4):
        self.confidence_threshold = confidence_threshold
        self.nms_threshold = nms_threshold

        # Simplified anchor boxes for face detection
        self.anchors = self._generate_anchors()

    def _generate_anchors(self):
        """Generate anchor boxes for face detection."""
        anchors = []
        scales = [16, 32, 64, 128]
        ratios = [1.0, 0.75, 1.33]

        for scale in scales:
            for ratio in ratios:
                w = scale * np.sqrt(ratio)
                h = scale / np.sqrt(ratio)
                anchors.append((w, h))

        return anchors

    def detect_faces(self, image):
        """Detect faces in image."""
        h, w = image.shape[:2]

        # Simulate face detection (in production, use RetinaFace or MTCNN)
        detections = []
        num_faces = np.random.randint(0, 5)

        for _ in range(num_faces):
            # Random face position
            x1 = np.random.randint(0, w - 100)
            y1 = np.random.randint(0, h - 100)
            face_w = np.random.randint(40, min(150, w - x1))
            face_h = int(face_w * 1.2)  # Faces are typically taller than wide

            confidence = np.random.uniform(0.6, 0.99)

            if confidence > self.confidence_threshold:
                # Generate 5 landmarks (eyes, nose, mouth corners)
                landmarks = np.array([
                    [x1 + face_w * 0.3, y1 + face_h * 0.35],   # Left eye
                    [x1 + face_w * 0.7, y1 + face_h * 0.35],   # Right eye
                    [x1 + face_w * 0.5, y1 + face_h * 0.55],   # Nose
                    [x1 + face_w * 0.3, y1 + face_h * 0.7],    # Left mouth
                    [x1 + face_w * 0.7, y1 + face_h * 0.7],    # Right mouth
                ])

                detections.append(FaceDetection(
                    bbox=(x1, y1, x1 + face_w, y1 + face_h),
                    confidence=confidence,
                    landmarks=landmarks
                ))

        # Apply NMS
        return self._non_max_suppression(detections)

    def _non_max_suppression(self, detections):
        """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:
                iou = self._compute_iou(current.bbox, det.bbox)
                if iou < self.nms_threshold:
                    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 align_face(self, image, detection, target_size=(112, 112)):
        """Align face using landmarks."""
        # Get eye positions
        left_eye = detection.landmarks[0]
        right_eye = detection.landmarks[1]

        # Compute rotation angle
        dx = right_eye[0] - left_eye[0]
        dy = right_eye[1] - left_eye[1]
        angle = np.degrees(np.arctan2(dy, dx))

        # Compute center between eyes
        eye_center = ((left_eye[0] + right_eye[0]) / 2,
                      (left_eye[1] + right_eye[1]) / 2)

        # Simple alignment (in production, use affine transformation)
        aligned = np.random.randint(0, 255, (*target_size, 3), dtype=np.uint8)

        return aligned, angle

# Example: Face detection
np.random.seed(42)
detector = FaceDetector(confidence_threshold=0.7)

print("Face Detection for Drone Security")
print("=" * 50)

# Simulate drone frame
frame = np.random.randint(0, 255, (720, 1280, 3), dtype=np.uint8)

# Detect faces
detections = detector.detect_faces(frame)
print(f"\nDetected {len(detections)} face(s):")

for i, det in enumerate(detections):
    print(f"\n  Face {i+1}:")
    print(f"    BBox: {det.bbox}")
    print(f"    Confidence: {det.confidence:.1%}")
    print(f"    Landmarks: 5 points detected")

    # Align face
    aligned, angle = detector.align_face(frame, det)
    print(f"    Alignment angle: {angle:.1f}°")