**Real-world analogy:** Pose estimation from a drone is like watching people from a second-story window. You can see their overall posture and movement, but fine details like facial expressions are harder to distinguish. The challenge is reconstructing 3D body poses from these overhead 2D views.

## Keypoint Detection

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

@dataclass
class Keypoint:
    """Single body keypoint."""
    x: float
    y: float
    confidence: float
    keypoint_id: int

@dataclass
class Pose:
    """Complete human pose."""
    keypoints: List[Keypoint]
    bbox: Tuple[int, int, int, int]
    person_id: Optional[int] = None
    action: Optional[str] = None

class AerialPoseEstimator:
    """Pose estimation optimized for drone (aerial) views."""

    # COCO keypoint connections for skeleton
    SKELETON = [
        (0, 1), (0, 2), (1, 3), (2, 4),  # Head
        (5, 6),  # Shoulders
        (5, 7), (7, 9),  # Left arm
        (6, 8), (8, 10),  # Right arm
        (5, 11), (6, 12),  # Torso
        (11, 12),  # Hips
        (11, 13), (13, 15),  # Left leg
        (12, 14), (14, 16),  # Right leg
    ]

    def __init__(self, input_size=(256, 256), num_keypoints=17):
        self.input_size = input_size
        self.num_keypoints = num_keypoints

        # Simulated heatmap model weights
        self.heatmap_weights = np.random.randn(
            num_keypoints, 64, input_size[0]//4, input_size[1]//4
        ) * 0.01

    def generate_heatmaps(self, person_region):
        """Generate keypoint heatmaps for a detected person."""
        h, w = person_region.shape[:2]
        heatmap_h, heatmap_w = h // 4, w // 4

        heatmaps = np.zeros((self.num_keypoints, heatmap_h, heatmap_w))

        # Simulate keypoint positions (top-down view adjustments)
        keypoint_positions = [
            (heatmap_h//2, heatmap_w//2),      # Nose (center of head)
            (heatmap_h//2-2, heatmap_w//2-2),   # Left eye
            (heatmap_h//2-2, heatmap_w//2+2),   # Right eye
            (heatmap_h//2-1, heatmap_w//2-4),   # Left ear
            (heatmap_h//2-1, heatmap_w//2+4),   # Right ear
            (heatmap_h//3, heatmap_w//3),        # Left shoulder
            (heatmap_h//3, 2*heatmap_w//3),     # Right shoulder
            (heatmap_h//2, heatmap_w//4),        # Left elbow
            (heatmap_h//2, 3*heatmap_w//4),     # Right elbow
            (2*heatmap_h//3, heatmap_w//5),     # Left wrist
            (2*heatmap_h//3, 4*heatmap_w//5),   # Right wrist
            (2*heatmap_h//3, heatmap_w//3),     # Left hip
            (2*heatmap_h//3, 2*heatmap_w//3),   # Right hip
            (5*heatmap_h//6, heatmap_w//4),     # Left knee
            (5*heatmap_h//6, 3*heatmap_w//4),   # Right knee
            (heatmap_h-1, heatmap_w//5),        # Left ankle
            (heatmap_h-1, 4*heatmap_w//5),      # Right ankle
        ]

        for kp_id, (ky, kx) in enumerate(keypoint_positions):
            if ky < heatmap_h and kx < heatmap_w:
                # Generate Gaussian heatmap
                y, x = np.ogrid[:heatmap_h, :heatmap_w]
                sigma = 2
                heatmap = np.exp(-((x - kx)**2 + (y - ky)**2) / (2 * sigma**2))
                heatmaps[kp_id] = heatmap

        return heatmaps

    def decode_heatmaps(self, heatmaps, threshold=0.3):
        """Decode heatmaps to keypoint coordinates."""
        keypoints = []

        for kp_id in range(self.num_keypoints):
            heatmap = heatmaps[kp_id]

            # Find maximum response
            max_idx = np.unravel_index(np.argmax(heatmap), heatmap.shape)
            max_val = heatmap[max_idx]

            if max_val > threshold:
                keypoints.append(Keypoint(
                    x=float(max_idx[1]),
                    y=float(max_idx[0]),
                    confidence=float(max_val),
                    keypoint_id=kp_id
                ))
            else:
                keypoints.append(Keypoint(
                    x=0.0, y=0.0,
                    confidence=0.0,
                    keypoint_id=kp_id
                ))

        return keypoints

    def adjust_for_aerial_view(self, keypoints, altitude=50):
        """Adjust keypoints for top-down aerial perspective."""
        # Aerial view transformations
        scale_factor = 100 / altitude  # Higher altitude = smaller scale

        adjusted = []
        for kp in keypoints:
            # Scale coordinates
            new_x = kp.x * scale_factor
            new_y = kp.y * scale_factor

            # Adjust for top-down view (foreshortening)
            # Vertical body parts appear compressed
            if kp.keypoint_id in [13, 14, 15, 16]:  # Knees and ankles
                new_y = kp.y * 0.6  # Compress leg appearance

            adjusted.append(Keypoint(
                x=new_x,
                y=new_y,
                confidence=kp.confidence,
                keypoint_id=kp.keypoint_id
            ))

        return adjusted

    def estimate_pose(self, person_image, altitude=50):
        """Complete pose estimation pipeline."""
        # Generate heatmaps
        heatmaps = self.generate_heatmaps(person_image)

        # Decode to keypoints
        keypoints = self.decode_heatmaps(heatmaps)

        # Adjust for aerial view
        keypoints = self.adjust_for_aerial_view(keypoints, altitude)

        return keypoints

    def compute_skeleton(self, keypoints, image_shape):
        """Compute skeleton lines from keypoints."""
        skeleton = []
        h, w = image_shape[:2]

        for start_idx, end_idx in self.SKELETON:
            kp_start = keypoints[start_idx]
            kp_end = keypoints[end_idx]

            if kp_start.confidence > 0.3 and kp_end.confidence > 0.3:
                skeleton.append({
                    'start': (int(kp_start.x), int(kp_start.y)),
                    'end': (int(kp_end.x), int(kp_end.y)),
                    'confidence': (kp_start.confidence + kp_end.confidence) / 2
                })

        return skeleton

# Example: Aerial pose estimation
np.random.seed(42)
estimator = AerialPoseEstimator()

print("Aerial Pose Estimation")
print("=" * 50)

# Simulate person region from drone
person_region = np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8)

# Estimate pose
keypoints = estimator.estimate_pose(person_region, altitude=30)

print("Detected Keypoints (top-down adjusted):")
kp_names = ['Nose', 'L-Eye', 'R-Eye', 'L-Ear', 'R-Ear',
            'L-Shoulder', 'R-Shoulder', 'L-Elbow', 'R-Elbow',
            'L-Wrist', 'R-Wrist', 'L-Hip', 'R-Hip',
            'L-Knee', 'R-Knee', 'L-Ankle', 'R-Ankle']

for i, (kp, name) in enumerate(zip(keypoints, kp_names)):
    if kp.confidence > 0.3:
        print(f"  {name}: ({kp.x:.1f}, {kp.y:.1f}) conf={kp.confidence:.2f}")

# Compute skeleton
skeleton = estimator.compute_skeleton(keypoints, (64, 64))
print(f"\nSkeleton segments: {len(skeleton)}")