utils/npz_interpolation.py

#!/usr/bin/env python3
"""
NPZ-level interpolation for smooth pose transitions
Implements various interpolation methods for creating natural transitions between poses
"""

import numpy as np
from scipy import interpolate
from scipy.spatial.transform import Slerp, Rotation
import cv2


def ease_in_out_cubic(t):
    """Cubic easing function for smooth acceleration and deceleration"""
    if t < 0.5:
        return 4 * t * t * t
    else:
        p = 2 * t - 2
        return 1 + p * p * p / 2


def ease_in_out_sine(t):
    """Sine easing function for very smooth transitions"""
    return -(np.cos(np.pi * t) - 1) / 2


def interpolate_keypoints(kp1, kp2, num_frames, easing_func=ease_in_out_cubic):
    """
    Interpolate between two sets of keypoints using easing functions
    
    Args:
        kp1: Starting keypoints (N, 2) or (N, 3)
        kp2: Ending keypoints (N, 2) or (N, 3)
        num_frames: Number of interpolated frames
        easing_func: Easing function to use
    
    Returns:
        List of interpolated keypoints
    """
    interpolated = []
    
    for i in range(num_frames):
        t = i / (num_frames - 1) if num_frames > 1 else 0
        t_eased = easing_func(t)
        
        # Linear interpolation with easing
        interp_kp = kp1 * (1 - t_eased) + kp2 * t_eased
        interpolated.append(interp_kp)
    
    return interpolated


def catmull_rom_spline(p0, p1, p2, p3, num_points, tension=0.5):
    """
    Catmull-Rom spline interpolation for smooth curves through control points
    
    Args:
        p0, p1, p2, p3: Control points (start from p1 to p2, p0 and p3 for curvature)
        num_points: Number of points to generate
        tension: Tension parameter (0.5 is standard Catmull-Rom)
    
    Returns:
        Array of interpolated points
    """
    points = []
    
    for i in range(num_points):
        t = i / (num_points - 1)
        t2 = t * t
        t3 = t2 * t
        
        # Catmull-Rom basis functions
        v0 = -tension * t + 2 * tension * t2 - tension * t3
        v1 = 1 + (tension - 3) * t2 + (2 - tension) * t3
        v2 = tension * t + (3 - 2 * tension) * t2 + (tension - 2) * t3
        v3 = -tension * t2 + tension * t3
        
        point = v0 * p0 + v1 * p1 + v2 * p2 + v3 * p3
        points.append(point)
    
    return np.array(points)



BODY_TREE = [
    (1, 2), (2, 3), (3, 4),
    (1, 5), (5, 6), (6, 7),
    (1, 8), (8, 9), (9, 10),
    (1, 11), (11, 12), (12, 13),
    (1, 0), (0, 14), (14, 16), (0, 15), (15, 17),
]


def _valid_xy(points):
    return points is not None and points.shape[-1] >= 2


def _point_valid(point):
    return point is not None and len(point) >= 2 and point[0] > 0 and point[1] > 0


def _canonicalize_body(body, body_a, body_b, blend=0.9):
    if body is None or body.shape[0] < 18:
        return body
    rec = body.copy()
    rec[1, :2] = body[1, :2]
    for parent, child in BODY_TREE:
        if parent >= len(body) or child >= len(body):
            continue
        if not (_point_valid(body[parent]) and _point_valid(body[child])):
            continue
        lengths = []
        for ref in (body_a, body_b):
            if ref is not None and parent < len(ref) and child < len(ref):
                if _point_valid(ref[parent]) and _point_valid(ref[child]):
                    length = np.linalg.norm(ref[child, :2] - ref[parent, :2])
                    if 0.002 < length < 0.8:
                        lengths.append(length)
        if not lengths:
            continue
        target_len = float(np.median(lengths))
        direction = body[child, :2] - body[parent, :2]
        current_len = np.linalg.norm(direction)
        if current_len <= 1e-6:
            continue
        rec[child, :2] = rec[parent, :2] + direction / current_len * target_len
    out = body.copy()
    out[:, :2] = body[:, :2] * (1.0 - blend) + rec[:, :2] * blend
    out[:, 0] = np.clip(out[:, 0], 0.0, 1.0)
    out[:, 1] = np.clip(out[:, 1], 0.0, 1.0)
    return out


def _attach_hands_to_body(hands_a, hands_b, body_a, body_b, body_t, alpha):
    if hands_a is None and hands_b is None:
        return None
    if hands_a is None:
        hands_a = hands_b
        body_a = body_b
    if hands_b is None:
        hands_b = hands_a
        body_b = body_a
    if hands_a is None or hands_b is None or hands_a.shape != hands_b.shape:
        return hands_a if alpha < 0.5 else hands_b

    out_a = np.array(hands_a, copy=True)
    out_b = np.array(hands_b, copy=True)
    wrist_ids = [4, 7]

    def attach(src_hands, src_body):
        attached = np.array(src_hands, copy=True)
        if src_body is None or body_t is None or len(src_body) <= 7 or len(body_t) <= 7:
            return attached
        if src_hands.ndim == 3:
            for hand_idx in range(src_hands.shape[0]):
                root = src_hands[hand_idx, 0]
                if not _point_valid(root):
                    continue
                choices = []
                for wid in wrist_ids:
                    if _point_valid(src_body[wid]) and _point_valid(body_t[wid]):
                        choices.append((np.linalg.norm(root[:2] - src_body[wid, :2]), wid))
                if not choices:
                    continue
                wid = min(choices, key=lambda item: item[0])[1]
                delta = body_t[wid, :2] - src_body[wid, :2]
                valid = (attached[hand_idx, :, 0] > 0) & (attached[hand_idx, :, 1] > 0)
                attached[hand_idx, valid, :2] += delta
        elif src_hands.ndim == 2 and len(src_hands) > 0:
            root = src_hands[0]
            choices = []
            for wid in wrist_ids:
                if _point_valid(root) and _point_valid(src_body[wid]) and _point_valid(body_t[wid]):
                    choices.append((np.linalg.norm(root[:2] - src_body[wid, :2]), wid))
            if choices:
                wid = min(choices, key=lambda item: item[0])[1]
                delta = body_t[wid, :2] - src_body[wid, :2]
                valid = (attached[:, 0] > 0) & (attached[:, 1] > 0)
                attached[valid, :2] += delta
        attached[..., 0] = np.clip(attached[..., 0], 0.0, 1.0)
        attached[..., 1] = np.clip(attached[..., 1], 0.0, 1.0)
        return attached

    a = attach(out_a, body_a)
    b = attach(out_b, body_b)
    out = a * (1.0 - alpha) + b * alpha
    return out


def _attach_faces_to_body(face_a, face_b, body_a, body_b, body_t, alpha):
    if face_a is None and face_b is None:
        return None
    if face_a is None:
        face_a = face_b
        body_a = body_b
    if face_b is None:
        face_b = face_a
        body_b = body_a
    if face_a is None or face_b is None or face_a.shape != face_b.shape:
        return face_a if alpha < 0.5 else face_b

    def attach(src_face, src_body):
        attached = np.array(src_face, copy=True)
        if src_body is None or body_t is None or len(src_body) <= 1 or len(body_t) <= 1:
            return attached
        if not (_point_valid(src_body[1]) and _point_valid(body_t[1])):
            return attached
        delta = body_t[1, :2] - src_body[1, :2]
        valid = (attached[..., 0] > 0) & (attached[..., 1] > 0)
        attached[..., :2][valid] += delta
        attached[..., 0] = np.clip(attached[..., 0], 0.0, 1.0)
        attached[..., 1] = np.clip(attached[..., 1], 0.0, 1.0)
        return attached

    a = attach(face_a, body_a)
    b = attach(face_b, body_b)
    return a * (1.0 - alpha) + b * alpha

def interpolate_pose_npz(npz1_data, npz2_data, num_frames=10, method='catmull-rom', frame1_num=None, frame2_num=None):
    """
    Interpolate between two pose NPZ data structures
    
    Args:
        npz1_data: Dictionary containing pose data from first NPZ
        npz2_data: Dictionary containing pose data from second NPZ
        num_frames: Number of transition frames to generate
        method: Interpolation method ('linear', 'cubic', 'catmull-rom')
        frame1_num: Specific frame number to use from npz1 (default: last frame)
        frame2_num: Specific frame number to use from npz2 (default: first frame)
    
    Returns:
        List of interpolated pose data dictionaries
    """
    interpolated_frames = []
    
    # Extract keypoints from the specified frames
    # Assume format: frame_XXXXXXXX_bodies, frame_XXXXXXXX_hands, etc.
    
    # Get the frame from npz1
    if frame1_num is None:
        frame_keys1 = sorted([k for k in npz1_data.keys() if k.endswith('_bodies')])
        if not frame_keys1:
            return []
        last_frame_key1 = frame_keys1[-1]
        frame_num1 = last_frame_key1.split('_')[1]
    else:
        frame_num1 = f"{frame1_num:08d}"
    
    # Get the frame from npz2
    if frame2_num is None:
        frame_keys2 = sorted([k for k in npz2_data.keys() if k.endswith('_bodies')])
        if not frame_keys2:
            return []
        first_frame_key2 = frame_keys2[0]
        frame_num2 = first_frame_key2.split('_')[1]
    else:
        frame_num2 = f"{frame2_num:08d}"
    
    # For catmull-rom, we need frames before and after for control points
    # Get frame keys if not already obtained
    if frame1_num is not None or frame2_num is not None:
        frame_keys1 = sorted([k for k in npz1_data.keys() if k.endswith('_bodies')])
        frame_keys2 = sorted([k for k in npz2_data.keys() if k.endswith('_bodies')])
    
    # Find previous frame for npz1
    prev_frame_num1 = max(1, int(frame_num1) - 1)
    prev_frame_key1 = f"frame_{prev_frame_num1:08d}"
    
    # Find next frame for npz2  
    next_frame_num2 = min(int(frame_num2) + 1, len(frame_keys2))
    next_frame_key2 = f"frame_{next_frame_num2:08d}"
    
    # Extract all components
    components = ['bodies', 'body_scores', 'hands', 'hands_scores', 'faces', 'faces_scores']
    
    conf_threshold = 0.3
    score_component_map = {
        'bodies': 'body_scores',
        'hands': 'hands_scores',
        'faces': 'faces_scores'
    }
    validity_masks = {}

    def compute_valid_mask(component_name):
        score_component = score_component_map.get(component_name)
        if not score_component:
            return None
        score_key1 = f"frame_{frame_num1}_{score_component}"
        score_key2 = f"frame_{frame_num2}_{score_component}"
        if score_key1 not in npz1_data or score_key2 not in npz2_data:
            return None
        score1 = np.array(npz1_data[score_key1])
        score2 = np.array(npz2_data[score_key2])
        if score1.shape != score2.shape:
            return None
        return (score1 >= conf_threshold) & (score2 >= conf_threshold)

    def apply_mask_to_data(data, mask, invalid_value=0.0, treat_scores=False):
        if mask is None:
            return data

        data = np.array(data, copy=True)
        valid_mask = np.array(mask, dtype=bool)

        if treat_scores:
            try:
                valid_mask = np.broadcast_to(valid_mask, data.shape)
            except ValueError:
                valid_mask = np.squeeze(valid_mask)
                valid_mask = np.broadcast_to(valid_mask, data.shape)
            data = np.where(valid_mask, data, invalid_value)
            return data

        # Coordinates: ensure mask matches all dims except the last coordinate axis
        target_mask_shape = data.shape[:-1]
        try:
            valid_mask = np.broadcast_to(valid_mask, target_mask_shape)
        except ValueError:
            valid_mask = np.squeeze(valid_mask)
            valid_mask = np.broadcast_to(valid_mask, target_mask_shape)

        valid_mask = np.expand_dims(valid_mask, axis=-1)
        data = np.where(valid_mask, data, invalid_value)
        return data

    for i in range(num_frames):
        t = i / (num_frames - 1) if num_frames > 1 else 0
        interpolated_data = {}
        
        for component in components:
            key1 = f"frame_{frame_num1}_{component}"
            key2 = f"frame_{frame_num2}_{component}"
            
            if key1 in npz1_data and key2 in npz2_data:
                data1 = npz1_data[key1]
                data2 = npz2_data[key2]
                
                if method == 'body-anchor':
                    t_eased = ease_in_out_sine(t)
                    if component == 'bodies':
                        prev_key = f"{prev_frame_key1}_{component}"
                        next_key = f"{next_frame_key2}_{component}"
                        p0 = npz1_data.get(prev_key, data1)
                        p1 = data1
                        p2 = data2
                        p3 = npz2_data.get(next_key, data2)
                        interpolated = catmull_rom_spline(p0, p1, p2, p3, num_frames)[i]
                        interpolated = _canonicalize_body(interpolated, data1, data2, blend=0.9)
                    elif component == 'hands':
                        body1 = npz1_data.get(f"frame_{frame_num1}_bodies")
                        body2 = npz2_data.get(f"frame_{frame_num2}_bodies")
                        body_key = f"frame_{i+1:08d}_bodies"
                        body_t = interpolated_data.get(body_key)
                        interpolated = _attach_hands_to_body(data1, data2, body1, body2, body_t, t_eased)
                    elif component == 'faces':
                        body1 = npz1_data.get(f"frame_{frame_num1}_bodies")
                        body2 = npz2_data.get(f"frame_{frame_num2}_bodies")
                        body_key = f"frame_{i+1:08d}_bodies"
                        body_t = interpolated_data.get(body_key)
                        interpolated = _attach_faces_to_body(data1, data2, body1, body2, body_t, t_eased)
                    elif component.endswith('_scores'):
                        interpolated = data1 * (1 - t_eased) + data2 * t_eased
                    else:
                        interpolated = data1 * (1 - t_eased) + data2 * t_eased

                elif method == 'linear':
                    # Simple linear interpolation with easing
                    t_eased = ease_in_out_cubic(t)
                    interpolated = data1 * (1 - t_eased) + data2 * t_eased
                    
                elif method == 'cubic':
                    # Use scipy's cubic interpolation
                    if data1.ndim == 3:  # Multiple people
                        interpolated = np.zeros_like(data1)
                        for person_idx in range(data1.shape[0]):
                            for joint_idx in range(data1.shape[1]):
                                for coord_idx in range(data1.shape[2]):
                                    y = [data1[person_idx, joint_idx, coord_idx], 
                                         data2[person_idx, joint_idx, coord_idx]]
                                    f = interpolate.interp1d([0, 1], y, kind='cubic')
                                    interpolated[person_idx, joint_idx, coord_idx] = f(t)
                    else:
                        t_eased = ease_in_out_cubic(t)
                        interpolated = data1 * (1 - t_eased) + data2 * t_eased
                        
                elif method == 'catmull-rom':
                    # Use Catmull-Rom spline for smoother transitions
                    if component.endswith('_scores'):
                        # For scores, use simple easing
                        t_eased = ease_in_out_sine(t)
                        interpolated = data1 * (1 - t_eased) + data2 * t_eased
                    else:
                        # For keypoints, use spline interpolation
                        # Get control points
                        prev_key = f"{prev_frame_key1}_{component}"
                        next_key = f"{next_frame_key2}_{component}"
                        
                        p0 = npz1_data.get(prev_key, data1)
                        p1 = data1
                        p2 = data2
                        p3 = npz2_data.get(next_key, data2)
                        
                        if data1.ndim == 3:  # Multiple people
                            interpolated = np.zeros_like(data1)
                            for person_idx in range(data1.shape[0]):
                                for joint_idx in range(data1.shape[1]):
                                    # Interpolate each joint
                                    points = catmull_rom_spline(
                                        p0[person_idx, joint_idx],
                                        p1[person_idx, joint_idx],
                                        p2[person_idx, joint_idx],
                                        p3[person_idx, joint_idx],
                                        num_points=num_frames
                                    )
                                    interpolated[person_idx, joint_idx] = points[i]
                        else:
                            # Single dimension data
                            t_eased = ease_in_out_sine(t)
                            interpolated = data1 * (1 - t_eased) + data2 * t_eased
                
                # Apply confidence-aware masking so we don't invent joints with low confidence
                if component in score_component_map:
                    if component not in validity_masks:
                        validity_masks[component] = compute_valid_mask(component)
                    interpolated = apply_mask_to_data(interpolated, validity_masks.get(component), invalid_value=0.0)
                elif component.endswith('_scores'):
                    base_component = component.replace('_scores', '')
                    mask = validity_masks.get(base_component)
                    interpolated = apply_mask_to_data(interpolated, mask, invalid_value=-1.0, treat_scores=True)

                # Create frame key for interpolated frame
                frame_key = f"frame_{i+1:08d}_{component}"
                interpolated_data[frame_key] = interpolated
        
        interpolated_frames.append(interpolated_data)
    
    return interpolated_frames


def apply_motion_blur(frame, prev_frame, blur_strength=0.3):
    """Apply motion blur between frames for smoother visual transitions"""
    if prev_frame is None:
        return frame
    
    # Weighted average with previous frame
    blurred = cv2.addWeighted(prev_frame, blur_strength, frame, 1 - blur_strength, 0)
    return blurred


def smooth_trajectory(keypoints_sequence, window_size=5):
    """
    Apply trajectory smoothing to a sequence of keypoints
    Uses a moving average filter to smooth the motion
    
    Args:
        keypoints_sequence: List of keypoint arrays
        window_size: Size of the smoothing window
    
    Returns:
        Smoothed keypoints sequence
    """
    if len(keypoints_sequence) <= window_size:
        return keypoints_sequence
    
    smoothed = []
    half_window = window_size // 2
    
    for i in range(len(keypoints_sequence)):
        start_idx = max(0, i - half_window)
        end_idx = min(len(keypoints_sequence), i + half_window + 1)
        
        # Average keypoints in the window
        window_kps = keypoints_sequence[start_idx:end_idx]
        avg_kp = np.mean(window_kps, axis=0)
        smoothed.append(avg_kp)
    
    return smoothed