When dealing with interpolation, the issue of confidence level was not taken into consideration.

text2pose.py

@@ -230,9 +230,10 @@ class SignLanguageQA:
                 frame_data = self.apply_y_offset(frame_data, y_offset)
 
             if draw_style == 'openpose':
+                filtered_frame = self.filter_pose_for_openpose(frame_data)
                 # Use OpenPose style (simpler, no processing needed)
                 vis_img = draw_pose_openpose(
-                    pose=frame_data,
+                    pose=filtered_frame,
                     height=height,
                     width=width,
                     include_face=True,
@@ -435,6 +436,66 @@ class SignLanguageQA:
 
         return offset_data
 
+    def filter_pose_for_openpose(self, frame_data, conf_threshold=0.2):
+        """Filter low-confidence joints for OpenPose rendering to avoid ghost limbs"""
+        filtered = copy.deepcopy(frame_data)
+
+        # Bodies
+        bodies = filtered.get('bodies', None)
+        body_scores = filtered.get('body_scores', None)
+        if bodies is not None and body_scores is not None:
+            scores = np.array(body_scores).reshape(-1)
+            mask = (scores < conf_threshold) | (scores <= 0)
+            if mask.shape[0] < bodies.shape[0]:
+                mask = np.pad(mask, (0, bodies.shape[0] - mask.shape[0]), constant_values=False)
+            elif mask.shape[0] > bodies.shape[0]:
+                mask = mask[:bodies.shape[0]]
+            bodies = bodies.copy()
+            bodies[mask, :] = 0
+            filtered['bodies'] = bodies
+
+        # Hands
+        hands = filtered.get('hands', None)
+        hand_scores = filtered.get('hands_scores', None)
+        if hands is not None and hand_scores is not None:
+            scores = np.array(hand_scores)
+            hands = hands.copy()
+            if hands.ndim == 3 and scores.ndim == 3:
+                for h in range(hands.shape[0]):
+                    mask = (scores[h] < conf_threshold) | (scores[h] <= 0)
+                    hands[h][mask, :] = 0
+            elif hands.ndim == 3 and scores.ndim == 2:
+                for h in range(hands.shape[0]):
+                    mask = (scores[h] < conf_threshold) | (scores[h] <= 0)
+                    hands[h][mask, :] = 0
+            elif hands.ndim == 2 and scores.ndim == 2:
+                mask = (scores < conf_threshold) | (scores <= 0)
+                hands[mask, :] = 0
+            elif hands.ndim == 2 and scores.ndim == 1:
+                mask = (scores < conf_threshold) | (scores <= 0)
+                hands[mask, :] = 0
+            filtered['hands'] = hands
+
+        # Faces
+        faces = filtered.get('faces', None)
+        face_scores = filtered.get('faces_scores', None)
+        if faces is not None and face_scores is not None:
+            scores = np.array(face_scores)
+            faces = faces.copy()
+            if faces.ndim == 3 and scores.ndim == 3:
+                for f in range(faces.shape[0]):
+                    mask = (scores[f] < conf_threshold) | (scores[f] <= 0)
+                    faces[f][mask, :] = 0
+            elif faces.ndim == 2 and scores.ndim == 2:
+                mask = (scores < conf_threshold) | (scores <= 0)
+                faces[mask, :] = 0
+            elif faces.ndim == 2 and scores.ndim == 1:
+                mask = (scores < conf_threshold) | (scores <= 0)
+                faces[mask, :] = 0
+            filtered['faces'] = faces
+
+        return filtered
+
     def normalize_pose_data(self, npz_data, reference_point='neck', scale_by='shoulders',
                              target_shoulder_width=0.35, target_shoulder_y=0.45):
         """

utils/npz_interpolation.py

@@ -138,6 +138,56 @@ def interpolate_pose_npz(npz1_data, npz2_data, num_frames=10, method='catmull-ro
     # 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 = {}
@@ -205,6 +255,16 @@ def interpolate_pose_npz(npz1_data, npz2_data, num_frames=10, method='catmull-ro
                             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
@@ -251,4 +311,4 @@ def smooth_trajectory(keypoints_sequence, window_size=5):
         avg_kp = np.mean(window_kps, axis=0)
         smoothed.append(avg_kp)
     
-    return smoothed
+    return smoothed