| from __future__ import annotations |
|
|
| import numpy as np |
|
|
|
|
| def resize_or_pad_sequence(arr: np.ndarray, target_frames: int) -> np.ndarray: |
| if arr.shape[0] == target_frames: |
| return arr |
| if arr.shape[0] > target_frames: |
| idx = np.linspace(0, arr.shape[0] - 1, target_frames).round().astype(int) |
| return arr[idx] |
| pad = np.repeat(arr[-1:], target_frames - arr.shape[0], axis=0) |
| return np.concatenate([arr, pad], axis=0) |
|
|
|
|
| def normalize_pose_sequence(pose: np.ndarray, min_conf: float = 0.05) -> np.ndarray: |
| pose = pose.astype(np.float32).copy() |
| xy = pose[..., :2] |
| conf = pose[..., 2:3] if pose.shape[-1] > 2 else np.ones((*pose.shape[:2], 1), dtype=np.float32) |
| valid = conf[..., 0] > min_conf |
| out_xy = np.zeros_like(xy, dtype=np.float32) |
| for t in range(pose.shape[0]): |
| mask = valid[t] |
| if mask.sum() < 2: |
| continue |
| pts = xy[t, mask] |
| center = (pts.min(axis=0) + pts.max(axis=0)) / 2.0 |
| size = np.maximum(pts.max(axis=0) - pts.min(axis=0), 1.0) |
| scale = float(max(size[0], size[1], 1.0)) |
| out_xy[t] = (xy[t] - center) / scale |
| return np.concatenate([out_xy, conf.astype(np.float32)], axis=-1) |
|
|
|
|
| def add_keypoint_noise(pose: np.ndarray, sigma: float, rng: np.random.Generator) -> np.ndarray: |
| if sigma <= 0: |
| return pose |
| noisy = pose.copy() |
| noisy[..., :2] += rng.normal(0.0, sigma, size=noisy[..., :2].shape).astype(np.float32) |
| return noisy |
|
|
|
|
| def apply_frame_drop(pose: np.ndarray, drop_ratio: float, rng: np.random.Generator) -> np.ndarray: |
| if drop_ratio <= 0: |
| return pose |
| out = pose.copy() |
| frames = out.shape[0] |
| keep = rng.random(frames) > drop_ratio |
| keep[0] = True |
| last = out[0].copy() |
| for t in range(frames): |
| if keep[t]: |
| last = out[t].copy() |
| else: |
| out[t] = last |
| return out |
|
|
|
|
| def pose_to_feature_vector( |
| pose: np.ndarray, |
| use_confidence: bool = True, |
| use_velocity: bool = True, |
| min_conf: float = 0.05, |
| ) -> np.ndarray: |
| norm = normalize_pose_sequence(pose, min_conf=min_conf) |
| xy = norm[..., :2] |
| parts = [xy.reshape(xy.shape[0], -1)] |
| if use_confidence: |
| parts.append(norm[..., 2:3].reshape(norm.shape[0], -1)) |
| if use_velocity: |
| vel = np.zeros_like(xy, dtype=np.float32) |
| vel[1:] = xy[1:] - xy[:-1] |
| parts.append(vel.reshape(vel.shape[0], -1)) |
| return np.concatenate(parts, axis=1).astype(np.float32) |
|
|
|
|
