Add the modified openpose and add confidence level filtering.

.gitignore

@@ -0,0 +1,7 @@
+*.mp4
+*.jpg
+*.png
+*.npy
+部分尝试
+论文工具
+论文所需

One-to-All-Animation

@@ -0,0 +1 @@
+Subproject commit fc608e58e3956f26aebf44a4387701f5d64ffd4a

easy_dwpose/draw/openpose.py

@@ -6,7 +6,16 @@ import numpy as np
 eps = 0.01
 
 
-def draw_bodypose(canvas, candidate, subset):
+def draw_bodypose(canvas, candidate, subset, score=None, conf_threshold=0.3):
+    """Draw body pose with optional confidence filtering
+
+    Args:
+        canvas: canvas to draw on
+        candidate: pose candidate
+        subset: pose subset
+        score: confidence scores (optional)
+        conf_threshold: confidence threshold for filtering (default: 0.3)
+    """
     H, W, C = canvas.shape
     candidate = np.array(candidate)
     subset = np.array(subset)
@@ -61,6 +70,13 @@ def draw_bodypose(canvas, candidate, subset):
             index = subset[n][np.array(limbSeq[i]) - 1]
             if -1 in index:
                 continue
+
+            # Add confidence filtering (like ControlNeXt)
+            if score is not None:
+                conf = score[n][np.array(limbSeq[i]) - 1]
+                if conf[0] < conf_threshold or conf[1] < conf_threshold:
+                    continue
+
             Y = candidate[index.astype(int), 0] * float(W)
             X = candidate[index.astype(int), 1] * float(H)
             mX = np.mean(X)
@@ -77,6 +93,13 @@ def draw_bodypose(canvas, candidate, subset):
             index = int(subset[n][i])
             if index == -1:
                 continue
+
+            # Add confidence filtering for keypoints
+            if score is not None:
+                conf = score[n][i]
+                if conf < conf_threshold:
+                    continue
+
             x, y = candidate[index][0:2]
             x = int(x * W)
             y = int(y * H)
@@ -85,7 +108,15 @@ def draw_bodypose(canvas, candidate, subset):
     return canvas
 
 
-def draw_handpose(canvas, all_hand_peaks):
+def draw_handpose(canvas, all_hand_peaks, all_hand_scores=None, conf_threshold=0.3):
+    """Draw hand pose with optional confidence filtering
+
+    Args:
+        canvas: canvas to draw on
+        all_hand_peaks: hand keypoints
+        all_hand_scores: confidence scores (optional)
+        conf_threshold: confidence threshold for filtering (default: 0.3)
+    """
     import matplotlib
 
     H, W, C = canvas.shape
@@ -117,11 +148,19 @@ def draw_handpose(canvas, all_hand_peaks):
     for i in range(len(all_hand_peaks)):
         peaks = all_hand_peaks[i]
         peaks = np.array(peaks)
+        scores = all_hand_scores[i] if all_hand_scores is not None else None
 
         for ie, e in enumerate(edges):
             x1, y1 = peaks[e[0]]
             x2, y2 = peaks[e[1]]
 
+            # Add confidence filtering
+            if scores is not None:
+                score1 = scores[e[0]]
+                score2 = scores[e[1]]
+                if score1 < conf_threshold or score2 < conf_threshold:
+                    continue
+
             x1 = int(x1 * W)
             y1 = int(y1 * H)
             x2 = int(x2 * W)
@@ -135,9 +174,13 @@ def draw_handpose(canvas, all_hand_peaks):
                     thickness=2,
                 )
 
-        for _, keyponit in enumerate(peaks):
+        for idx, keyponit in enumerate(peaks):
             x, y = keyponit
 
+            # Add confidence filtering for keypoints
+            if scores is not None and scores[idx] < conf_threshold:
+                continue
+
             x = int(x * W)
             y = int(y * H)
             if x > eps and y > eps:
@@ -145,11 +188,25 @@ def draw_handpose(canvas, all_hand_peaks):
     return canvas
 
 
-def draw_facepose(canvas, all_lmks):
+def draw_facepose(canvas, all_lmks, all_scores=None, conf_threshold=0.3):
+    """Draw face pose with optional confidence filtering
+
+    Args:
+        canvas: canvas to draw on
+        all_lmks: face landmarks
+        all_scores: confidence scores (optional)
+        conf_threshold: confidence threshold for filtering (default: 0.3)
+    """
     H, W, C = canvas.shape
-    for lmks in all_lmks:
+    for i, lmks in enumerate(all_lmks):
         lmks = np.array(lmks)
-        for lmk in lmks:
+        scores = all_scores[i] if all_scores is not None else None
+
+        for idx, lmk in enumerate(lmks):
+            # Add confidence filtering
+            if scores is not None and scores[idx] < conf_threshold:
+                continue
+
             x, y = lmk
             x = int(x * W)
             y = int(y * H)
@@ -158,19 +215,44 @@ def draw_facepose(canvas, all_lmks):
     return canvas
 
 
-def draw_pose(pose, height: int, width: int, include_face: bool = True, include_hands: bool = True) -> np.ndarray:
+def draw_pose(pose, height: int, width: int, include_face: bool = True, include_hands: bool = True, conf_threshold: float = 0.3) -> np.ndarray:
+    """Draw pose with confidence filtering
+
+    Args:
+        pose: pose data dictionary
+        height: canvas height
+        width: canvas width
+        include_face: whether to draw face
+        include_hands: whether to draw hands
+        conf_threshold: confidence threshold for filtering (default: 0.3)
+    """
     canvas = np.zeros(shape=(height, width, 3), dtype=np.uint8)
 
+    # Handle bodies
     candidate = pose["bodies"]
-    subset = pose["body_scores"]
-    canvas = draw_bodypose(canvas, candidate, subset)
+    # For openpose format, subset is typically derived from body_scores
+    # Create a simple subset array for single person (18 keypoints)
+    body_scores_data = pose.get("body_scores", None)
+
+    if body_scores_data is not None:
+        # Create subset: reshape scores to be compatible
+        subset = body_scores_data.reshape(1, -1) if len(body_scores_data.shape) == 1 else body_scores_data
+    else:
+        # No scores available, create dummy subset
+        subset = np.zeros((1, 18))
+
+    canvas = draw_bodypose(canvas, candidate, subset, score=subset, conf_threshold=conf_threshold)
 
     if include_face:
-        faces = pose["faces"]
-        canvas = draw_facepose(canvas, faces)
+        faces = pose.get("faces", [])
+        face_scores = pose.get("faces_scores", None)
+        if len(faces) > 0:
+            canvas = draw_facepose(canvas, faces, all_scores=face_scores, conf_threshold=conf_threshold)
 
     if include_hands:
-        hands = pose["hands"]
-        canvas = draw_handpose(canvas, hands)
+        hands = pose.get("hands", [])
+        hand_scores = pose.get("hands_scores", None)
+        if len(hands) > 0:
+            canvas = draw_handpose(canvas, hands, all_hand_scores=hand_scores, conf_threshold=conf_threshold)
 
     return canvas

generated_pose_video/GOOD_MORNING_AFTERNOON_25073_36863_01435_20250804_214708.mp4

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

generated_pose_video/HELLO_WORLD_27184_63831_20250804_215328.mp4

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2ff6dbbc50441746c7d494956bc72987878f359dd5ff96c765adb51e5631becb
-size 2183071

generated_pose_video/I_WILL_ATTEND_THIS_DINNER_PARTY_28794_63364_04007_66628_16327_41325_20250804_215724.mp4

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

generated_pose_video/NOT_FIND_YET_38868_21853_18537_20250804_220326.mp4

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:912d9a76db09fe053361692239ba9644a47f144ec7832a2e38850811b9e5b652
-size 2095895

generated_pose_video/NOT_FIND_YET_38868_21853_38944_20250804_223748.mp4

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:23b47ae5720cb5d7ba9b5e34a63e6f31f1c136d440a6a43c9113ad8a5ff5982c
-size 1340578

src/sam-2

@@ -0,0 +1 @@
+Subproject commit 0e78a118995e66bb27d78518c4bd9a3e95b4e266

text2pose.py

@@ -18,7 +18,8 @@ import re
 from datetime import datetime
 
 from easy_dwpose import DWposeDetector
-from easy_dwpose.draw.controlnext import draw_pose, process_pose_data
+from easy_dwpose.draw.controlnext import draw_pose as draw_pose_controlnext, process_pose_data
+from easy_dwpose.draw.openpose import draw_pose as draw_pose_openpose
 from utils.npz_interpolation import interpolate_pose_npz, ease_in_out_cubic
 import copy
 
@@ -83,7 +84,7 @@ class SignLanguageQA:
         npz_path = Path(NPZ_DIR) / f"{video_id}.npz"
         
         if not npz_path.exists():
-            print(f"   ⚠️  NPZ file not found: {npz_path}")
+            print(f"   ⚠️  NPZ file not found in Pose Dict: {npz_path}")
             return None
             
         try:
@@ -210,30 +211,46 @@ class SignLanguageQA:
         frame_keys = [k for k in npz_data.keys() if k.startswith('frame_') and k.endswith('_bodies')]
         return len(frame_keys)
 
-    def create_pose_frame(self, frame_data, width=480, height=480, scale_x=1.0, scale_y=1.0, hide_torso_lines=False, y_offset=0):
-        """Create single frame pose image with progressive scaling and optional y offset"""
+    def create_pose_frame(self, frame_data, width=480, height=480, scale_x=1.0, scale_y=1.0, hide_torso_lines=False, y_offset=0, draw_style='controlnext'):
+        """Create single frame pose image with progressive scaling and optional y offset
+
+        Args:
+            draw_style: 'controlnext' or 'openpose'
+        """
         try:
             # Apply progressive scaling if needed
             if scale_x != 1.0 or scale_y != 1.0:
                 frame_data = self.apply_progressive_scaling(frame_data, scale_x, scale_y)
-            
+
             # Apply y offset if provided
             if y_offset != 0:
                 frame_data = self.apply_y_offset(frame_data, y_offset)
-            
-            processed_pred = process_pose_data(frame_data, height, width)
 
-            vis_img = draw_pose(
-                pose=processed_pred,
-                H=height,
-                W=width,
-                include_body=True,
-                include_hand=True,
-                include_face=True,
-                hide_torso_lines=hide_torso_lines
-            )
+            if draw_style == 'openpose':
+                # Use OpenPose style (simpler, no processing needed)
+                vis_img = draw_pose_openpose(
+                    pose=frame_data,
+                    height=height,
+                    width=width,
+                    include_face=True,
+                    include_hands=True
+                )
+                return vis_img
+            else:
+                # Use ControlNeXt style (default, with advanced features)
+                processed_pred = process_pose_data(frame_data, height, width)
+
+                vis_img = draw_pose_controlnext(
+                    pose=processed_pred,
+                    H=height,
+                    W=width,
+                    include_body=True,
+                    include_hand=True,
+                    include_face=True,
+                    hide_torso_lines=hide_torso_lines
+                )
 
-            return vis_img.transpose(1, 2, 0)
+                return vis_img.transpose(1, 2, 0)
 
         except Exception as e:
             import traceback
@@ -470,7 +487,43 @@ class SignLanguageQA:
         except Exception as e:
             print(f"⚠️  Failed to get reference head position: {e}")
             return None
-    
+
+    def calculate_neck_centrality_score(self, npz_data):
+        """Calculate how centered the neck position is in the video
+
+        Returns a score from 0 to 1, where 1 means perfectly centered
+        Lower score means the person is more off-center
+        """
+        neck_x_positions = []
+
+        # Sample frames throughout the video
+        total_frames = self.get_total_frames(npz_data)
+        sample_frames = [0, total_frames // 4, total_frames // 2, 3 * total_frames // 4, total_frames - 1]
+
+        for frame_num in sample_frames:
+            if frame_num >= total_frames:
+                continue
+
+            frame_data = self.get_frame_data(npz_data, frame_num)
+            if frame_data and 'bodies' in frame_data:
+                bodies = frame_data['bodies']
+                # Neck is typically index 1 in body keypoints
+                if len(bodies) > 1 and bodies[1, 0] > 0:
+                    neck_x_positions.append(bodies[1, 0])
+
+        if not neck_x_positions:
+            return 0.0  # No valid neck positions found
+
+        # Calculate average neck X position
+        avg_neck_x = np.mean(neck_x_positions)
+
+        # Calculate distance from center (0.5)
+        # Score is higher when closer to center
+        distance_from_center = abs(avg_neck_x - 0.5)
+        centrality_score = 1.0 - (distance_from_center * 2)  # Scale to 0-1
+
+        return max(0.0, centrality_score)  # Ensure non-negative
+
     def get_pose_head_top(self, frame_data):
         """Get the top of head position from pose frame data"""
         # Try faces first
@@ -507,8 +560,12 @@ class SignLanguageQA:
 
     def generate_video_from_glosses(self, gloss_list, output_path, fps=30, width=480, height=480,
                                     smoothing_frames=5, smoothing_method='none', npz_interpolation_frames=0,
-                                    scale_x=1.0, scale_y=1.0, hide_torso_lines=False, ref_image_path=None):
-        """Generate video from gloss list with optional progressive scaling and head alignment"""
+                                    scale_x=1.0, scale_y=1.0, hide_torso_lines=False, ref_image_path=None, draw_style='controlnext'):
+        """Generate video from gloss list with optional progressive scaling and head alignment
+
+        Args:
+            draw_style: 'controlnext' (default) or 'openpose' - drawing style for pose visualization
+        """
         # Create output directory
         output_path.parent.mkdir(parents=True, exist_ok=True)
         
@@ -529,73 +586,93 @@ class SignLanguageQA:
             matched_videos = self.find_gloss_videos(gloss)
             
             if not matched_videos:
-                print(f"❌ '{gloss}' -> No matching videos found")
+                print(f"❌ '{gloss}' -> No matching Pose unit found")
                 continue
             
-            print(f"🎯 '{gloss}' -> Found {len(matched_videos)} videos")
-            
-            # Try each video until we find one with good quality
-            video_found = False
+            print(f"🎯 '{gloss}' -> Found {len(matched_videos)} Unit in Pose Dict")
+
+            # Evaluate all videos and select the best one based on quality and centering
+            candidate_videos = []
+
             for idx, video_id in enumerate(matched_videos):
                 npz_data = self.load_video_npz(video_id)
                 if npz_data is not None:
                     total_frames = self.get_total_frames(npz_data)
-                    print(f"   📹 {video_id}: {total_frames} frames")
-                    
+
                     # Check video quality
                     is_good_quality, quality_msg = self.check_video_quality(npz_data)
-                    
+
                     if not is_good_quality:
-                        print(f"   ❌ Video quality check failed: {quality_msg}")
-                        if idx < len(matched_videos) - 1:
-                            print(f"   🔄 Trying next video for '{gloss}'...")
                         continue
-                    
+
                     # Get valid frame range
                     start_frame, end_frame = self.get_valid_frame_range(npz_data)
                     if start_frame > end_frame:
-                        print(f"   ❌ No valid frames found in video")
                         continue
-                    
-                    print(f"   ✅ {quality_msg}")
-                    print(f"   📊 Using frames {start_frame} to {end_frame} (out of {total_frames})")
-                    
-                    # Store NPZ data for potential interpolation
-                    all_npz_data.append(npz_data)
-                    
-                    # Extract frames within valid range
-                    gloss_frames = []
-                    for frame_num in range(start_frame, end_frame + 1):
-                        frame_data = self.get_frame_data(npz_data, frame_num)
-                        if frame_data and self.check_frame_quality(frame_data):
-                            # Calculate y offset for first frame if reference provided
-                            if ref_head_top is not None and y_offset == 0 and frame_num == start_frame:
-                                # Get head top from current pose
-                                current_head_top = self.get_pose_head_top(frame_data)
-                                if current_head_top is not None:
-                                    y_offset = ref_head_top - current_head_top
-                                    print(f"📐 Calculated Y offset: {y_offset:.2f}")
-                            
-                            pose_frame = self.create_pose_frame(frame_data, width, height, scale_x, scale_y, hide_torso_lines, y_offset)
-                            if pose_frame is not None:
-                                gloss_frames.append(pose_frame)
-                    
-                    if gloss_frames:
-                        all_pose_frames.append(gloss_frames)
-                        video_info.append({
-                            'gloss': gloss,
-                            'video_id': video_id,
-                            'frame_count': len(gloss_frames),
-                            'npz_data': npz_data,
-                            'start_frame': start_frame,
-                            'end_frame': end_frame
-                        })
-                        print(f"   ✅ Generated {len(gloss_frames)} pose frames")
-                        video_found = True
-                        break  # Use only first valid video per gloss
-            
-            if not video_found:
-                print(f"   ❌ No suitable video found for '{gloss}' after checking {len(matched_videos)} candidates")
+
+                    # Calculate neck centrality score
+                    centrality_score = self.calculate_neck_centrality_score(npz_data)
+
+                    candidate_videos.append({
+                        'video_id': video_id,
+                        'npz_data': npz_data,
+                        'total_frames': total_frames,
+                        'start_frame': start_frame,
+                        'end_frame': end_frame,
+                        'quality_msg': quality_msg,
+                        'centrality_score': centrality_score
+                    })
+
+            if not candidate_videos:
+                print(f"   ❌ No good quality poses dict found for '{gloss}'")
+                continue
+
+            # Select video with best centrality score
+            best_video = max(candidate_videos, key=lambda x: x['centrality_score'])
+            video_id = best_video['video_id']
+            npz_data = best_video['npz_data']
+            total_frames = best_video['total_frames']
+            start_frame = best_video['start_frame']
+            end_frame = best_video['end_frame']
+            quality_msg = best_video['quality_msg']
+            centrality_score = best_video['centrality_score']
+
+            print(f"   📹 {video_id}: {total_frames} frames")
+            print(f"   ✅ {quality_msg}")
+            print(f"   🎯 Centrality score: {centrality_score:.2f} (selected from {len(candidate_videos)} candidates)")
+            print(f"   📊 Using frames {start_frame} to {end_frame} (out of {total_frames})")
+
+            # Store NPZ data for potential interpolation
+            all_npz_data.append(npz_data)
+
+            # Extract frames within valid range
+            gloss_frames = []
+            for frame_num in range(start_frame, end_frame + 1):
+                frame_data = self.get_frame_data(npz_data, frame_num)
+                if frame_data and self.check_frame_quality(frame_data):
+                    # Calculate y offset for first frame if reference provided
+                    if ref_head_top is not None and y_offset == 0 and frame_num == start_frame:
+                        # Get head top from current pose
+                        current_head_top = self.get_pose_head_top(frame_data)
+                        if current_head_top is not None:
+                            y_offset = ref_head_top - current_head_top
+                            print(f"📐 Calculated Y offset: {y_offset:.2f}")
+
+                    pose_frame = self.create_pose_frame(frame_data, width, height, scale_x, scale_y, hide_torso_lines, y_offset, draw_style)
+                    if pose_frame is not None:
+                        gloss_frames.append(pose_frame)
+
+            if gloss_frames:
+                all_pose_frames.append(gloss_frames)
+                video_info.append({
+                    'gloss': gloss,
+                    'video_id': video_id,
+                    'frame_count': len(gloss_frames),
+                    'npz_data': npz_data,
+                    'start_frame': start_frame,
+                    'end_frame': end_frame
+                })
+                print(f"   ✅ Generated {len(gloss_frames)} pose frames")
         
         if not all_pose_frames:
             print("❌ No frames generated")
@@ -646,7 +723,7 @@ class SignLanguageQA:
                             
                             # Create visual frame
                             if frame_data:
-                                pose_frame = self.create_pose_frame(frame_data, width, height, scale_x, scale_y, hide_torso_lines, y_offset)
+                                pose_frame = self.create_pose_frame(frame_data, width, height, scale_x, scale_y, hide_torso_lines, y_offset, draw_style)
                                 if pose_frame is not None:
                                     interpolated_pose_frames.append(pose_frame)
                     
@@ -663,22 +740,96 @@ class SignLanguageQA:
             for group in all_pose_frames:
                 final_frames.extend(group)
         
-        # Write video
+        # Write video using FFmpeg directly for better compatibility
         print("💾 Writing video file...")
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        video_writer = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
-        
-        if not video_writer.isOpened():
-            print("❌ Unable to create video file")
-            return False
         
-        for pose_frame in tqdm(final_frames, desc="Writing frames"):
-            pose_frame_bgr = cv2.cvtColor(pose_frame, cv2.COLOR_RGB2BGR)
-            video_writer.write(pose_frame_bgr)
+        # Try to use FFmpeg pipe for direct H.264 encoding
+        use_ffmpeg_pipe = True
+        try:
+            import subprocess
+            import threading
+
+            # Create FFmpeg command for pipe input
+            ffmpeg_cmd = [
+                'ffmpeg',
+                '-y',  # Overwrite output file
+                '-f', 'rawvideo',
+                '-vcodec', 'rawvideo',
+                '-s', f'{width}x{height}',
+                '-pix_fmt', 'rgb24',
+                '-r', str(fps),
+                '-i', '-',  # Read from pipe
+                '-c:v', 'libx264',
+                '-crf', '23',
+                '-pix_fmt', 'yuv420p',
+                '-movflags', '+faststart',
+                str(output_path)
+            ]
+
+            # Start FFmpeg process with proper stderr handling
+            process = subprocess.Popen(
+                ffmpeg_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                bufsize=10**8  # Large buffer to prevent blocking
+            )
+
+            # Collect stderr in background to prevent pipe blocking
+            stderr_data = []
+            def read_stderr():
+                for line in process.stderr:
+                    stderr_data.append(line)
+
+            stderr_thread = threading.Thread(target=read_stderr)
+            stderr_thread.daemon = True
+            stderr_thread.start()
+
+            # Write frames to FFmpeg
+            for pose_frame in tqdm(final_frames, desc="Writing frames"):
+                try:
+                    # FFmpeg expects RGB format
+                    process.stdin.write(pose_frame.tobytes())
+                except BrokenPipeError:
+                    # FFmpeg died, check why
+                    process.wait()
+                    stderr_output = b''.join(stderr_data).decode('utf-8', errors='replace')
+                    print(f"⚠️  FFmpeg died during write. Error output:")
+                    print(stderr_output[-500:] if len(stderr_output) > 500 else stderr_output)
+                    raise
+
+            # Close pipe and wait for FFmpeg to finish
+            process.stdin.close()
+            process.wait(timeout=30)
+
+            if process.returncode == 0:
+                print(f"✅ Video generated successfully with H.264 codec!")
+            else:
+                stderr_output = b''.join(stderr_data).decode('utf-8', errors='replace')
+                print(f"⚠️  FFmpeg failed with return code {process.returncode}")
+                print(f"   Last 500 chars of error: {stderr_output[-500:] if len(stderr_output) > 500 else stderr_output}")
+                use_ffmpeg_pipe = False
+        except Exception as e:
+            print(f"⚠️  FFmpeg pipe method failed: {e}")
+            use_ffmpeg_pipe = False
         
-        video_writer.release()
+        # Fallback to OpenCV if FFmpeg pipe fails
+        if not use_ffmpeg_pipe:
+            print("⚠️  Falling back to OpenCV writer...")
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            video_writer = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
+            
+            if not video_writer.isOpened():
+                print("❌ Unable to create video file")
+                return False
+            
+            for pose_frame in tqdm(final_frames, desc="Writing frames"):
+                pose_frame_bgr = cv2.cvtColor(pose_frame, cv2.COLOR_RGB2BGR)
+                video_writer.write(pose_frame_bgr)
+            
+            video_writer.release()
+            print(f"✅ Video generated successfully!")
         
-        print(f"✅ Video generated successfully!")
         print(f"   📁 File: {output_path}")
         print(f"   📊 {len(final_frames)} frames, {fps}fps, {width}x{height}")
         if output_path.exists():
@@ -904,6 +1055,8 @@ def main():
                         help='Hide torso lines from neck to hips (set to black). Choices: true/false (default: false)')
     parser.add_argument('--ref-image-path', type=str, default=None,
                         help='Reference image path for head alignment')
+    parser.add_argument('--draw-style', type=str, choices=['controlnext', 'openpose'], default='controlnext',
+                        help='Drawing style for pose visualization. controlnext: advanced features with confidence-based coloring. openpose: simpler classic style. (default: controlnext)')
 
     args = parser.parse_args()
 
@@ -931,15 +1084,18 @@ def main():
 
         if args.smoothing != 'none':
             print(f"🌊 Using {args.smoothing} smoothing ({args.smoothing_frames} frames)")
-        
+
         if args.scale_x != 1.0 or args.scale_y != 1.0:
             print(f"📏 Using progressive scaling: X={args.scale_x}, Y={args.scale_y}")
 
+        if args.draw_style != 'controlnext':
+            print(f"🎨 Using {args.draw_style} drawing style")
+
         success = qa_system.generate_video_from_glosses(
             gloss_list, output_file, args.fps, args.width, args.height,
             args.smoothing_frames, args.smoothing, args.npz_interpolation,
             args.scale_x, args.scale_y, args.hide_torso_lines == 'true',
-            args.ref_image_path
+            args.ref_image_path, args.draw_style
         )
 
         if not success:

train_end2end.py

@@ -0,0 +1,460 @@
+#!/usr/bin/env python3
+"""
+End-to-end training script for StableSigner (Prompt/Text -> Gloss -> Pose MoE).
+
+Highlights:
+- Fine-tunes a T5-style model (SLUL) to map prompts/text to gloss sequences.
+- Adds a learnable Pose Mixture-of-Experts head that selects a pose (NPZ/video id)
+  for the predicted gloss; candidates can come from dataset annotations or the
+  existing pose dict (via SignLanguageQA in text2pose.py).
+- Supports a simple Semantic-Aware Gloss Masking (SAGM-like) auxiliary loss.
+
+Expected dataset format (json/jsonl):
+[
+  {
+    "prompt": "The students will study in the library tomorrow.",
+    "gloss": "STUDENT LIBRARY STUDY TOMORROW",
+    "video_id": "12345",                 # ground-truth pose id
+    "candidate_video_ids": ["12345", "67890"]  # optional; will fallback to pose dict lookup
+  },
+  ...
+]
+"""
+
+import argparse
+import json
+import math
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+from transformers import (
+    AdamW,
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    get_linear_schedule_with_warmup,
+)
+
+import text2pose as text2pose_module
+from text2pose import SignLanguageQA
+
+
+# ---------------------------- Data utilities ---------------------------- #
+class PromptGlossPoseDataset(Dataset):
+    """Simple dataset wrapper for prompt->gloss with optional pose supervision."""
+
+    def __init__(
+        self,
+        examples: List[dict],
+        tokenizer: AutoTokenizer,
+        pose_vocab: Dict[str, int],
+        signqa: Optional[SignLanguageQA],
+        max_input_length: int = 256,
+        max_target_length: int = 64,
+        max_candidates: int = 8,
+    ):
+        self.examples = examples
+        self.tokenizer = tokenizer
+        self.pose_vocab = pose_vocab
+        self.signqa = signqa
+        self.max_input_length = max_input_length
+        self.max_target_length = max_target_length
+        self.max_candidates = max_candidates
+
+    def __len__(self):
+        return len(self.examples)
+
+    def _expand_candidates(self, gloss: str, provided: Optional[List[str]]) -> List[str]:
+        if provided:
+            return provided[: self.max_candidates]
+        if self.signqa is None:
+            return []
+        return self.signqa.find_gloss_videos(gloss)[: self.max_candidates]
+
+    def __getitem__(self, idx):
+        item = self.examples[idx]
+        prompt = item["prompt"]
+        gloss = item["gloss"]
+        video_id = item.get("video_id")
+
+        # Tokenize prompt and gloss
+        model_inputs = self.tokenizer(
+            prompt,
+            truncation=True,
+            max_length=self.max_input_length,
+            return_tensors=None,
+        )
+        with self.tokenizer.as_target_tokenizer():
+            labels = self.tokenizer(
+                gloss,
+                truncation=True,
+                max_length=self.max_target_length,
+                return_tensors=None,
+            )
+
+        candidates = self._expand_candidates(gloss, item.get("candidate_video_ids"))
+        candidate_ids = [self.pose_vocab.get(cid, -1) for cid in candidates]
+        # Pad/trim candidates
+        if len(candidate_ids) < self.max_candidates:
+            candidate_ids += [-1] * (self.max_candidates - len(candidate_ids))
+        else:
+            candidate_ids = candidate_ids[: self.max_candidates]
+
+        pose_label = -1
+        if video_id is not None and video_id in self.pose_vocab:
+            pose_label = self.pose_vocab[video_id]
+        elif candidates:
+            # Fall back to first candidate if ground truth is unknown
+            pose_label = self.pose_vocab.get(candidates[0], -1)
+
+        return {
+            "input_ids": torch.tensor(model_inputs["input_ids"], dtype=torch.long),
+            "attention_mask": torch.tensor(model_inputs["attention_mask"], dtype=torch.long),
+            "labels": torch.tensor(labels["input_ids"], dtype=torch.long),
+            "candidate_pose_ids": torch.tensor(candidate_ids, dtype=torch.long),
+            "pose_label": torch.tensor(pose_label, dtype=torch.long),
+        }
+
+
+def collate_fn(batch, pad_token_id: int):
+    """Pad variable-length fields and keep pose metadata."""
+    input_ids = [b["input_ids"] for b in batch]
+    attention_masks = [b["attention_mask"] for b in batch]
+    labels = [b["labels"] for b in batch]
+    candidate_pose_ids = torch.stack([b["candidate_pose_ids"] for b in batch], dim=0)
+    pose_labels = torch.stack([b["pose_label"] for b in batch], dim=0)
+
+    input_ids = torch.nn.utils.rnn.pad_sequence(
+        input_ids, batch_first=True, padding_value=pad_token_id
+    )
+    attention_masks = torch.nn.utils.rnn.pad_sequence(
+        attention_masks, batch_first=True, padding_value=0
+    )
+    labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=-100)
+
+    return {
+        "input_ids": input_ids,
+        "attention_mask": attention_masks,
+        "labels": labels,
+        "candidate_pose_ids": candidate_pose_ids,
+        "pose_label": pose_labels,
+    }
+
+
+# ---------------------------- Model ---------------------------- #
+class PoseMoEModel(nn.Module):
+    """T5-based text->gloss with a lightweight pose-selection MoE head."""
+
+    def __init__(
+        self,
+        base_model_name: str,
+        pose_vocab_size: int,
+        pose_hidden_size: Optional[int] = None,
+        pose_loss_weight: float = 1.0,
+        sagm_loss_weight: float = 0.1,
+        sagm_mask_ratio: float = 0.15,
+    ):
+        super().__init__()
+        self.text_model = AutoModelForSeq2SeqLM.from_pretrained(base_model_name)
+        hidden_size = self.text_model.config.d_model
+        pose_hidden = pose_hidden_size or hidden_size
+        self.pose_embeddings = nn.Embedding(pose_vocab_size, pose_hidden)
+        self.pose_proj = nn.Linear(hidden_size, pose_hidden)
+        self.pose_loss_weight = pose_loss_weight
+        self.sagm_loss_weight = sagm_loss_weight
+        self.sagm_mask_ratio = sagm_mask_ratio
+        self.loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+
+    def forward(
+        self,
+        input_ids,
+        attention_mask,
+        labels,
+        candidate_pose_ids,
+        pose_label,
+    ):
+        outputs = self.text_model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            labels=labels,
+            output_hidden_states=True,
+        )
+        gloss_loss = outputs.loss
+
+        encoder_hidden = outputs.encoder_last_hidden_state
+        pooled = encoder_hidden.mean(dim=1)  # simple pooling
+
+        # Pose gating
+        candidate_pose_ids = candidate_pose_ids.clone()
+        candidate_mask = candidate_pose_ids >= 0
+        candidate_pose_ids = torch.where(candidate_mask, candidate_pose_ids, torch.zeros_like(candidate_pose_ids))
+
+        pose_embed = self.pose_embeddings(candidate_pose_ids)
+        pooled_proj = self.pose_proj(pooled).unsqueeze(1)
+        pose_logits = torch.sum(pooled_proj * pose_embed, dim=-1)
+        pose_logits = pose_logits.masked_fill(~candidate_mask, -1e4)
+
+        pose_loss = torch.tensor(0.0, device=input_ids.device)
+        if pose_label is not None and pose_label.max() >= 0:
+            # Map absolute pose ids to positions within candidate list
+            label_positions = []
+            for i in range(candidate_pose_ids.size(0)):
+                target = int(pose_label[i].item())
+                if target < 0:
+                    label_positions.append(-100)
+                    continue
+                positions = (candidate_pose_ids[i] == target).nonzero(as_tuple=False)
+                label_positions.append(int(positions[0].item()) if len(positions) > 0 else -100)
+            label_positions = torch.tensor(label_positions, device=input_ids.device, dtype=torch.long)
+            if (label_positions != -100).any():
+                pose_loss = self.loss_fct(pose_logits, label_positions)
+
+        total_loss = gloss_loss + self.pose_loss_weight * pose_loss
+        sagm_loss = self.compute_sagm_loss(outputs.logits, labels)
+        total_loss = total_loss + self.sagm_loss_weight * sagm_loss
+
+        return {
+            "loss": total_loss,
+            "gloss_loss": gloss_loss.detach(),
+            "pose_loss": pose_loss.detach(),
+            "sagm_loss": sagm_loss.detach(),
+            "pose_logits": pose_logits,
+        }
+
+    def compute_sagm_loss(self, logits, labels):
+        """Mask a subset of gloss tokens to enforce semantic robustness."""
+        if labels is None:
+            return torch.tensor(0.0, device=logits.device)
+        with torch.no_grad():
+            mask = (labels != -100) & (
+                torch.rand_like(labels.float(), device=labels.device) < self.sagm_mask_ratio
+            )
+            sagm_labels = torch.where(mask, labels, torch.full_like(labels, -100))
+        loss = self.loss_fct(logits.view(-1, logits.size(-1)), sagm_labels.view(-1))
+        return loss
+
+
+# ---------------------------- Training helpers ---------------------------- #
+@dataclass
+class TrainConfig:
+    train_file: str
+    eval_file: Optional[str]
+    pose_json: str
+    pose_npz_dir: str
+    model_name: str
+    output_dir: str
+    batch_size: int
+    num_epochs: int
+    lr: float
+    warmup_ratio: float
+    weight_decay: float
+    max_input_len: int
+    max_target_len: int
+    max_candidates: int
+    pose_loss_weight: float
+    sagm_loss_weight: float
+    sagm_mask_ratio: float
+    grad_accum: int
+    save_steps: int
+    device: str
+
+
+def load_json_any(path: Path) -> List[dict]:
+    if path.suffix.lower() == ".jsonl":
+        return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
+    data = json.loads(path.read_text())
+    if isinstance(data, dict):
+        return data.get("data", [])
+    return data
+
+
+def build_pose_vocab(examples: List[dict], signqa: SignLanguageQA) -> Dict[str, int]:
+    vocab = {}
+    for ex in examples:
+        if "video_id" in ex:
+            vocab.setdefault(str(ex["video_id"]), len(vocab))
+        gloss = ex.get("gloss", "")
+        for vid in signqa.find_gloss_videos(gloss):
+            if vid not in vocab:
+                vocab[vid] = len(vocab)
+        for vid in ex.get("candidate_video_ids", []) or []:
+            if vid not in vocab:
+                vocab[vid] = len(vocab)
+    return vocab
+
+
+def evaluate(model, data_loader, device):
+    model.eval()
+    total_loss = 0.0
+    steps = 0
+    with torch.no_grad():
+        for batch in data_loader:
+            batch = {k: v.to(device) if isinstance(v, torch.Tensor) else v for k, v in batch.items()}
+            out = model(**batch)
+            total_loss += out["loss"].item()
+            steps += 1
+    model.train()
+    return total_loss / max(steps, 1)
+
+
+def train(config: TrainConfig):
+    tokenizer = AutoTokenizer.from_pretrained(config.model_name)
+    text2pose_module.JSON_FILE = config.pose_json
+    text2pose_module.NPZ_DIR = config.pose_npz_dir
+    signqa = SignLanguageQA()
+
+    train_examples = load_json_any(Path(config.train_file))
+    eval_examples = load_json_any(Path(config.eval_file)) if config.eval_file else []
+    pose_vocab = build_pose_vocab(train_examples + eval_examples, signqa)
+
+    train_ds = PromptGlossPoseDataset(
+        train_examples,
+        tokenizer,
+        pose_vocab,
+        signqa,
+        max_input_length=config.max_input_len,
+        max_target_length=config.max_target_len,
+        max_candidates=config.max_candidates,
+    )
+    eval_ds = (
+        PromptGlossPoseDataset(
+            eval_examples,
+            tokenizer,
+            pose_vocab,
+            signqa,
+            max_input_length=config.max_input_len,
+            max_target_length=config.max_target_len,
+            max_candidates=config.max_candidates,
+        )
+        if eval_examples
+        else None
+    )
+
+    model = PoseMoEModel(
+        config.model_name,
+        pose_vocab_size=len(pose_vocab),
+        pose_loss_weight=config.pose_loss_weight,
+        sagm_loss_weight=config.sagm_loss_weight,
+        sagm_mask_ratio=config.sagm_mask_ratio,
+    ).to(config.device)
+
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=config.batch_size,
+        shuffle=True,
+        collate_fn=lambda b: collate_fn(b, tokenizer.pad_token_id),
+    )
+    eval_loader = (
+        DataLoader(
+            eval_ds,
+            batch_size=config.batch_size,
+            shuffle=False,
+            collate_fn=lambda b: collate_fn(b, tokenizer.pad_token_id),
+        )
+        if eval_ds
+        else None
+    )
+
+    num_update_steps = math.ceil(len(train_loader) / config.grad_accum) * config.num_epochs
+    warmup_steps = int(config.warmup_ratio * num_update_steps)
+
+    optimizer = AdamW(model.parameters(), lr=config.lr, weight_decay=config.weight_decay)
+    scheduler = get_linear_schedule_with_warmup(
+        optimizer, num_warmup_steps=warmup_steps, num_training_steps=num_update_steps
+    )
+
+    global_step = 0
+    for epoch in range(config.num_epochs):
+        for step, batch in enumerate(train_loader):
+            batch = {k: v.to(config.device) if isinstance(v, torch.Tensor) else v for k, v in batch.items()}
+            outputs = model(**batch)
+            loss = outputs["loss"] / config.grad_accum
+            loss.backward()
+
+            if (step + 1) % config.grad_accum == 0:
+                optimizer.step()
+                scheduler.step()
+                optimizer.zero_grad()
+                global_step += 1
+
+                if global_step % 10 == 0:
+                    print(
+                        f"[Epoch {epoch+1}] step {global_step} | "
+                        f"loss {outputs['loss'].item():.4f} | "
+                        f"gloss {outputs['gloss_loss'].item():.4f} | "
+                        f"pose {outputs['pose_loss'].item():.4f} | "
+                        f"sagm {outputs['sagm_loss'].item():.4f}"
+                    )
+
+                if config.save_steps and global_step % config.save_steps == 0:
+                    save_dir = Path(config.output_dir) / f"checkpoint-{global_step}"
+                    save_dir.mkdir(parents=True, exist_ok=True)
+                    model.text_model.save_pretrained(save_dir)
+                    tokenizer.save_pretrained(save_dir)
+                    (save_dir / "pose_vocab.json").write_text(json.dumps(pose_vocab, indent=2))
+
+        if eval_loader:
+            eval_loss = evaluate(model, eval_loader, config.device)
+            print(f"[Epoch {epoch+1}] eval loss: {eval_loss:.4f}")
+
+    Path(config.output_dir).mkdir(parents=True, exist_ok=True)
+    model.text_model.save_pretrained(config.output_dir)
+    tokenizer.save_pretrained(config.output_dir)
+    (Path(config.output_dir) / "pose_vocab.json").write_text(json.dumps(pose_vocab, indent=2))
+    print(f"Training finished. Saved to {config.output_dir}")
+
+
+def parse_args() -> TrainConfig:
+    parser = argparse.ArgumentParser(description="Train StableSigner SLUL + Pose MoE")
+    parser.add_argument("--train-file", required=True, help="Path to train json/jsonl")
+    parser.add_argument("--eval-file", default=None, help="Optional eval json/jsonl")
+    parser.add_argument("--pose-json", default="pose_dict/WLASL_train.json", help="Pose mapping JSON")
+    parser.add_argument("--pose-npz-dir", default="pose_dict/WLASL_train", help="Pose NPZ directory (for future use)")
+    parser.add_argument("--model-name", default="google/flan-t5-small", help="HF model name or path")
+    parser.add_argument("--output-dir", default="outputs/slul_pose_moe", help="Where to save checkpoints")
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--num-epochs", type=int, default=3)
+    parser.add_argument("--lr", type=float, default=3e-4)
+    parser.add_argument("--warmup-ratio", type=float, default=0.03)
+    parser.add_argument("--weight-decay", type=float, default=0.01)
+    parser.add_argument("--max-input-len", type=int, default=256)
+    parser.add_argument("--max-target-len", type=int, default=64)
+    parser.add_argument("--max-candidates", type=int, default=8)
+    parser.add_argument("--pose-loss-weight", type=float, default=1.0)
+    parser.add_argument("--sagm-loss-weight", type=float, default=0.1)
+    parser.add_argument("--sagm-mask-ratio", type=float, default=0.15)
+    parser.add_argument("--grad-accum", type=int, default=1)
+    parser.add_argument("--save-steps", type=int, default=500)
+    parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    args = parser.parse_args()
+    return TrainConfig(
+        train_file=args.train_file,
+        eval_file=args.eval_file,
+        pose_json=args.pose_json,
+        pose_npz_dir=args.pose_npz_dir,
+        model_name=args.model_name,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        lr=args.lr,
+        warmup_ratio=args.warmup_ratio,
+        weight_decay=args.weight_decay,
+        max_input_len=args.max_input_len,
+        max_target_len=args.max_target_len,
+        max_candidates=args.max_candidates,
+        pose_loss_weight=args.pose_loss_weight,
+        sagm_loss_weight=args.sagm_loss_weight,
+        sagm_mask_ratio=args.sagm_mask_ratio,
+        grad_accum=args.grad_accum,
+        save_steps=args.save_steps,
+        device=args.device,
+    )
+
+
+if __name__ == "__main__":
+    cfg = parse_args()
+    train(cfg)