Achieve the interpolation effect at the npz level

README.md

@@ -31,7 +31,7 @@ The entire project is divided into two parts: `text_or_gloss2pose` and `pose2vid
 ## tutorial01 prepare pose dict
 
 1. cd StableSigner
-2. run `python pipeline/pipeline01_merge_frame_level_npz_from_video_dir.py tools-new-2025/output/test_dataset_results` 
+2. run `python utils/pipeline01_merge_frame_level_npz_from_video_dir.py tools-new-2025/output/test_dataset_results` 
 3. Place the corresponding "gloss-videoID" mapping in the pose dict
 
 ## tutorial02 get pose video from text input
@@ -39,7 +39,7 @@ The entire project is divided into two parts: `text_or_gloss2pose` and `pose2vid
 ```python
 
 # Default
-python text2pose.py --gloss "good afternoon" --smoothing fade --smoothing-frames 5 --width 512 --height 768 --fps 30
+python text2pose.py --gloss "good morning afternoon" --npz-interpolation 20 --width 512 --height 768 --fps 30
 
 # Single gloss
 python text2pose.py --gloss "hello"

env/requirements01_dwpose.txt

@@ -2,4 +2,5 @@ easy_dwpose==1.0.1
 ffmpeg
 torch
 torchvision
-einops
+einops
+scipy

env/requirements02_controlnext.txt

@@ -5,6 +5,7 @@ opencv-python
 omegaconf
 onnxruntime
 pillow
+scipy
 matplotlib
 numpy
 transformers

generated_pose_video/GOOD_MORNING_AFTERNOON_25073_36863_01435_20250803_231751.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:761d087c399b83e83d0246c6eb84d5cefe7290a01ceb59f1bbab2a29e7a4bf26
+size 1688288

text2pose.py

@@ -19,6 +19,7 @@ from datetime import datetime
 
 from easy_dwpose import DWposeDetector
 from easy_dwpose.draw.controlnext import draw_pose, process_pose_data
+from utils.npz_interpolation import interpolate_pose_npz, ease_in_out_cubic
 
 # Fixed configuration
 JSON_FILE = "pose_dict/WLASL_train.json"  # JSON mapping file
@@ -129,13 +130,14 @@ class SignLanguageQA:
             return None
 
     def generate_video_from_glosses(self, gloss_list, output_path, fps=30, width=480, height=480,
-                                    smoothing_frames=5, smoothing_method='none'):
+                                    smoothing_frames=5, smoothing_method='none', npz_interpolation_frames=0):
         """Generate video from gloss list"""
         # Create output directory
         output_path.parent.mkdir(parents=True, exist_ok=True)
         
         # Collect all frames from all glosses
         all_pose_frames = []
+        all_npz_data = []  # Store NPZ data for interpolation
         video_info = []
         
         for gloss in gloss_list:
@@ -154,6 +156,9 @@ class SignLanguageQA:
                     total_frames = self.get_total_frames(npz_data)
                     print(f"   📹 {video_id}: {total_frames} frames")
                     
+                    # Store NPZ data for potential interpolation
+                    all_npz_data.append(npz_data)
+                    
                     # Extract all frames for this video
                     gloss_frames = []
                     for frame_num in range(1, total_frames + 1):
@@ -168,7 +173,8 @@ class SignLanguageQA:
                         video_info.append({
                             'gloss': gloss,
                             'video_id': video_id,
-                            'frame_count': len(gloss_frames)
+                            'frame_count': len(gloss_frames),
+                            'npz_data': npz_data
                         })
                         print(f"   ✅ Generated {len(gloss_frames)} pose frames")
                         break  # Use only first valid video per gloss
@@ -177,6 +183,53 @@ class SignLanguageQA:
             print("❌ No frames generated")
             return False
         
+        # Apply NPZ interpolation if requested
+        if npz_interpolation_frames > 0 and len(all_pose_frames) > 1:
+            print(f"🔄 Applying NPZ interpolation with {npz_interpolation_frames} frames...")
+            interpolated_pose_frames = []
+            
+            for i in range(len(all_pose_frames)):
+                # Add original frames
+                interpolated_pose_frames.extend(all_pose_frames[i])
+                
+                # Add interpolated frames between glosses
+                if i < len(all_pose_frames) - 1:
+                    # Get NPZ data for interpolation
+                    npz1 = video_info[i]['npz_data']
+                    npz2 = video_info[i + 1]['npz_data']
+                    
+                    # Interpolate between the two NPZ files
+                    interpolated_npz_frames = interpolate_pose_npz(
+                        npz1, npz2, 
+                        num_frames=npz_interpolation_frames,
+                        method='catmull-rom'
+                    )
+                    
+                    # Convert interpolated NPZ frames to visual frames
+                    for interp_data in interpolated_npz_frames:
+                        # Extract frame data from interpolated NPZ
+                        frame_keys = [k for k in interp_data.keys() if k.endswith('_bodies')]
+                        if frame_keys:
+                            frame_key = frame_keys[0]
+                            frame_num = int(frame_key.split('_')[1])
+                            
+                            # Build frame data dict
+                            frame_data = {}
+                            for suffix in ['bodies', 'body_scores', 'hands', 'hands_scores', 'faces', 'faces_scores']:
+                                key = f"frame_{frame_num:08d}_{suffix}"
+                                if key in interp_data:
+                                    frame_data[suffix] = interp_data[key]
+                            
+                            # Create visual frame
+                            if frame_data:
+                                pose_frame = self.create_pose_frame(frame_data, width, height)
+                                if pose_frame is not None:
+                                    interpolated_pose_frames.append(pose_frame)
+                    
+                    print(f"   ✅ Added {npz_interpolation_frames} interpolated frames between '{video_info[i]['gloss']}' and '{video_info[i+1]['gloss']}'")
+            
+            all_pose_frames = [interpolated_pose_frames]  # Treat as single sequence
+        
         # Apply smoothing if needed
         if smoothing_method != 'none' and len(all_pose_frames) > 1:
             final_frames = self.apply_smoothing(all_pose_frames, smoothing_frames, smoothing_method)
@@ -339,6 +392,7 @@ class SignLanguageQA:
                 # Ask for smoothing options if multiple glosses
                 smoothing_method = 'none'
                 smoothing_frames = 0
+                npz_interpolation_frames = 0
                 
                 if len(gloss_list) > 1:
                     print(f"\n🌊 Multiple glosses detected, choose smoothing method:")
@@ -346,8 +400,9 @@ class SignLanguageQA:
                     print(f"   2. fade - Fade in/out transition")
                     print(f"   3. blend - Frame blending transition")
                     print(f"   4. pause - Add pause interval")
+                    print(f"   5. npz - NPZ interpolation (smoothest transition)")
                     
-                    smooth_choice = input(f"Choose smoothing method [1-4, default 1]: ").strip()
+                    smooth_choice = input(f"Choose smoothing method [1-5, default 1]: ").strip()
                     
                     if smooth_choice == '2':
                         smoothing_method = 'fade'
@@ -358,16 +413,22 @@ class SignLanguageQA:
                     elif smooth_choice == '4':
                         smoothing_method = 'pause'
                         smoothing_frames = int(input("Pause frames [default 10]: ").strip() or "10")
+                    elif smooth_choice == '5':
+                        npz_interpolation_frames = int(input("NPZ interpolation frames [default 10]: ").strip() or "10")
+                        print(f"📊 Using Catmull-Rom spline interpolation for smooth transitions")
                 
                 # Generate output filename
                 suffix = f"_{smoothing_method}" if smoothing_method != 'none' else ""
+                if npz_interpolation_frames > 0:
+                    suffix = f"_npz{npz_interpolation_frames}"
                 output_file = Path(OUTPUT_DIR) / f"{gloss_str}_{timestamp}{suffix}.mp4"
                 
                 # Generate video
                 success = self.generate_video_from_glosses(
                     gloss_list, output_file,
                     smoothing_frames=smoothing_frames,
-                    smoothing_method=smoothing_method
+                    smoothing_method=smoothing_method,
+                    npz_interpolation_frames=npz_interpolation_frames
                 )
 
             except KeyboardInterrupt:
@@ -390,6 +451,7 @@ class SignLanguageQA:
         print("   - fade: Fade in/out transition")
         print("   - blend: Frame blending transition")
         print("   - pause: Add pause interval")
+        print("   - npz: NPZ-level interpolation (smoothest, uses Catmull-Rom splines)")
         print("=" * 50)
 
 
@@ -407,6 +469,8 @@ def main():
                         default='none', help='Smoothing method (default: none)')
     parser.add_argument('--smoothing-frames', type=int, default=5,
                         help='Smoothing frames (default: 5)')
+    parser.add_argument('--npz-interpolation', type=int, default=0,
+                        help='Number of NPZ interpolation frames between glosses (default: 0)')
 
     args = parser.parse_args()
 
@@ -437,7 +501,7 @@ def main():
 
         success = qa_system.generate_video_from_glosses(
             gloss_list, output_file, args.fps, args.width, args.height,
-            args.smoothing_frames, args.smoothing
+            args.smoothing_frames, args.smoothing, args.npz_interpolation
         )
 
         if not success:

utils/npz_interpolation.py

@@ -0,0 +1,236 @@
+#!/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)
+
+
+def interpolate_pose_npz(npz1_data, npz2_data, num_frames=10, method='catmull-rom'):
+    """
+    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')
+    
+    Returns:
+        List of interpolated pose data dictionaries
+    """
+    interpolated_frames = []
+    
+    # Extract keypoints from the last frame of first video and first frame of second
+    # Assume format: frame_XXXXXXXX_bodies, frame_XXXXXXXX_hands, etc.
+    
+    # Get the last frame from npz1
+    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]
+    
+    # Get the first frame from npz2
+    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]
+    
+    # For catmull-rom, we also need one frame before and after
+    prev_frame_key1 = frame_keys1[-2] if len(frame_keys1) > 1 else frame_keys1[-1]
+    next_frame_key2 = frame_keys2[1] if len(frame_keys2) > 1 else frame_keys2[0]
+    
+    # Extract all components
+    components = ['bodies', 'body_scores', 'hands', 'hands_scores', 'faces', 'faces_scores']
+    
+    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 == '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"frame_{prev_frame_key1.split('_')[1]}_{component}"
+                        next_key = f"frame_{next_frame_key2.split('_')[1]}_{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
+                
+                # 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