|
|
| """
|
| Sign Language Gloss Q&A System
|
| User inputs gloss, system generates corresponding pose video
|
| """
|
|
|
| import torch
|
| from PIL import Image
|
| import numpy as np
|
| import json
|
| import os
|
| import sys
|
| import argparse
|
| from pathlib import Path
|
| import cv2
|
| from tqdm import tqdm
|
| import re
|
|
|
| from easy_dwpose import DWposeDetector
|
| from easy_dwpose.draw.controlnext import draw_pose, process_pose_data
|
|
|
|
|
| DATABASE_PATH = "output/merge/merged_database.npz"
|
| MAPPING_FILE = "output/gloss_mapping.json"
|
| OUTPUT_DIR = "output/video"
|
|
|
|
|
| class SignLanguageQA:
|
| def __init__(self):
|
| self.data = None
|
| self.metadata = None
|
| self.gloss_mapping = None
|
| self.load_database()
|
| self.load_mapping()
|
|
|
| def load_database(self):
|
| """Load database"""
|
| try:
|
| if not Path(DATABASE_PATH).exists():
|
| print(f"❌ Database file does not exist: {DATABASE_PATH}")
|
| print(" Please ensure merge_all_to_database.py has been run to generate database file")
|
| sys.exit(1)
|
|
|
| print(f"📚 Loading database: {DATABASE_PATH}")
|
| self.data = np.load(DATABASE_PATH, allow_pickle=True)
|
| self.metadata = self.data['_metadata'].item()
|
|
|
| print(f"✅ Database loaded successfully!")
|
| print(f" 📊 Total frames: {self.metadata['total_frames']}")
|
| print(f" 🎬 Video count: {self.metadata['video_count']}")
|
|
|
| except Exception as e:
|
| print(f"❌ Database loading failed: {e}")
|
| sys.exit(1)
|
|
|
| def load_mapping(self):
|
| """Load gloss mapping file"""
|
| if Path(MAPPING_FILE).exists():
|
| try:
|
| with open(MAPPING_FILE, 'r', encoding='utf-8') as f:
|
| self.gloss_mapping = json.load(f)
|
| print(f"✅ Mapping file loaded successfully: {MAPPING_FILE}")
|
| print(f" 📝 Contains {len(self.gloss_mapping)} gloss mappings")
|
| except Exception as e:
|
| print(f"⚠️ Mapping file loading failed: {e}")
|
| self.gloss_mapping = None
|
| else:
|
| print(f"ℹ️ Mapping file does not exist: {MAPPING_FILE}")
|
| print(" Will use intelligent matching mode")
|
| self.gloss_mapping = None
|
|
|
| def find_gloss_videos(self, gloss):
|
| """Find corresponding video_ids based on a single gloss"""
|
| if self.gloss_mapping and gloss.upper() in self.gloss_mapping:
|
|
|
| video_ids = self.gloss_mapping[gloss.upper()]
|
| if not isinstance(video_ids, list):
|
| video_ids = [video_ids]
|
| return video_ids
|
| else:
|
|
|
| gloss_upper = gloss.upper()
|
| matched_videos = []
|
|
|
| for video_id in self.metadata['video_index'].keys():
|
|
|
| if (gloss_upper == video_id.upper() or
|
| gloss_upper in video_id.upper() or
|
| video_id.upper().endswith(f"_{gloss_upper}") or
|
| video_id.upper().startswith(f"{gloss_upper}_") or
|
| f"_{gloss_upper}_" in video_id.upper()):
|
| matched_videos.append(video_id)
|
|
|
| return matched_videos
|
|
|
| def get_frames_for_glosses(self, gloss_list, one_video_per_gloss=True):
|
| """Get all frames corresponding to gloss list
|
|
|
| Args:
|
| gloss_list: gloss list
|
| one_video_per_gloss: whether to select only one video per gloss
|
| """
|
| all_frame_groups = []
|
| video_info = []
|
|
|
| for gloss in gloss_list:
|
| matched_videos = self.find_gloss_videos(gloss)
|
|
|
| if matched_videos:
|
| print(f"🎯 '{gloss}' -> Found {len(matched_videos)} videos")
|
|
|
|
|
| videos_to_use = []
|
| if one_video_per_gloss:
|
|
|
| for video_id in matched_videos:
|
| if video_id in self.metadata['video_index']:
|
| videos_to_use = [video_id]
|
| if len(matched_videos) > 1:
|
| print(f" 💡 Selecting first valid video: {video_id}, skipping other {len(matched_videos) - 1}")
|
| break
|
|
|
| if not videos_to_use:
|
| print(f" ❌ No valid videos found (all video_ids not in database)")
|
| continue
|
| else:
|
| videos_to_use = matched_videos
|
|
|
| gloss_frames = []
|
| for video_id in videos_to_use:
|
| if video_id in self.metadata['video_index']:
|
| start_frame = self.metadata['video_index'][video_id]['start_frame']
|
| end_frame = self.metadata['video_index'][video_id]['end_frame']
|
| frames = list(range(start_frame, end_frame + 1))
|
| gloss_frames.extend(frames)
|
| video_info.append({
|
| 'gloss': gloss,
|
| 'video_id': video_id,
|
| 'start_frame': start_frame,
|
| 'end_frame': end_frame,
|
| 'frame_count': len(frames)
|
| })
|
| print(f" 📹 {video_id}: {len(frames)} frames ({start_frame}-{end_frame})")
|
| else:
|
| print(f" ⚠️ {video_id}: Not found in database")
|
|
|
| if gloss_frames:
|
| all_frame_groups.append(gloss_frames)
|
| else:
|
| print(f"❌ '{gloss}' -> No matching videos found")
|
| self.suggest_similar_glosses(gloss)
|
|
|
|
|
| all_frames = []
|
| for frame_group in all_frame_groups:
|
| all_frames.extend(frame_group)
|
|
|
| return all_frames, video_info
|
|
|
| def suggest_similar_glosses(self, gloss):
|
| """Provide similar suggestions for unfound gloss"""
|
| gloss_upper = gloss.upper()
|
| similar_videos = []
|
|
|
|
|
| for video_id in self.metadata['video_index'].keys():
|
| score = 0
|
| for char in gloss_upper:
|
| if char in video_id.upper():
|
| score += 1
|
|
|
| if score >= len(gloss_upper) * 0.5:
|
| similar_videos.append(video_id)
|
|
|
| if similar_videos:
|
| print(f" 💡 Similar video_ids: {similar_videos[:5]}")
|
|
|
|
|
| if self.gloss_mapping:
|
| available_glosses = list(self.gloss_mapping.keys())
|
| similar_glosses = [g for g in available_glosses if
|
| any(char in g for char in gloss_upper)]
|
| if similar_glosses:
|
| print(f" 💡 Similar glosses: {similar_glosses[:5]}")
|
|
|
| def create_pose_frame(self, frame_data, width=480, height=480):
|
| """Create single frame pose image"""
|
| try:
|
| 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
|
| )
|
|
|
| return vis_img.transpose(1, 2, 0)
|
|
|
| except Exception as e:
|
| print(f"⚠️ Failed to create pose frame: {e}")
|
| return None
|
|
|
| def generate_video(self, frame_indices, output_path, video_info, fps=30, width=480, height=480,
|
| smoothing_frames=5, smoothing_method='none'):
|
| """Generate pose video
|
|
|
| Args:
|
| frame_indices: frame index list
|
| output_path: output path
|
| video_info: video info list
|
| fps: frame rate
|
| width: width
|
| height: height
|
| smoothing_frames: number of smoothing transition frames
|
| smoothing_method: smoothing method ('fade', 'blend', 'pause', 'none')
|
| """
|
| if not frame_indices:
|
| return False
|
|
|
|
|
| output_path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
|
| 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
|
|
|
| original_keys = self.metadata['original_keys']
|
| successful_frames = 0
|
|
|
| print(f"🎬 Generating video (smoothing method: {smoothing_method})...")
|
|
|
|
|
| all_pose_frame_groups = []
|
|
|
| print("🔄 Rendering pose frames...")
|
| current_frame_idx = 0
|
|
|
| for info in video_info:
|
| gloss_frames = []
|
| frame_count = info['frame_count']
|
|
|
| for _ in range(frame_count):
|
| if current_frame_idx < len(frame_indices):
|
| frame_idx = frame_indices[current_frame_idx]
|
| frame_key = f"frame_{frame_idx:08d}"
|
| frame_data = {}
|
|
|
| for key in original_keys:
|
| combined_key = f"{frame_key}_{key}"
|
| if combined_key in self.data:
|
| frame_data[key] = self.data[combined_key]
|
|
|
| if frame_data:
|
| pose_frame = self.create_pose_frame(frame_data, width, height)
|
| if pose_frame is not None:
|
| gloss_frames.append(pose_frame)
|
|
|
| current_frame_idx += 1
|
|
|
| if gloss_frames:
|
| all_pose_frame_groups.append(gloss_frames)
|
| print(f" ✅ {info['gloss']}: {len(gloss_frames)} frames")
|
|
|
| if not all_pose_frame_groups:
|
| print("❌ No frames generated successfully")
|
| video_writer.release()
|
| return False
|
|
|
|
|
| if smoothing_method != 'none' and len(all_pose_frame_groups) > 1:
|
| final_frames = self.apply_group_smoothing(all_pose_frame_groups, smoothing_frames, smoothing_method)
|
| else:
|
|
|
| final_frames = []
|
| for group in all_pose_frame_groups:
|
| final_frames.extend(group)
|
|
|
|
|
| print("💾 Writing video file...")
|
| 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)
|
| successful_frames += 1
|
|
|
| video_writer.release()
|
|
|
| if successful_frames > 0:
|
| print(f"✅ Video generated successfully!")
|
| print(f" 📁 File: {output_path}")
|
| print(f" 📊 {successful_frames} frames, {fps}fps, {width}x{height}")
|
| if output_path.exists():
|
| print(f" 💾 Size: {output_path.stat().st_size / 1024 / 1024:.2f} MB")
|
| return True
|
| else:
|
| print(f"❌ Video generation failed")
|
| return False
|
|
|
| def apply_group_smoothing(self, frame_groups, smoothing_frames, method):
|
| """Apply smoothing transition effects to gloss groups"""
|
| if len(frame_groups) <= 1 or smoothing_frames <= 0:
|
| final_frames = []
|
| for group in frame_groups:
|
| final_frames.extend(group)
|
| return final_frames
|
|
|
| print(f"🌊 Applying {method} smoothing transition ({smoothing_frames} frames)...")
|
|
|
| if method == 'fade':
|
| return self.apply_group_fade_smoothing(frame_groups, smoothing_frames)
|
| elif method == 'blend':
|
| return self.apply_group_blend_smoothing(frame_groups, smoothing_frames)
|
| elif method == 'pause':
|
| return self.apply_group_pause_smoothing(frame_groups, smoothing_frames)
|
| else:
|
| final_frames = []
|
| for group in frame_groups:
|
| final_frames.extend(group)
|
| return final_frames
|
|
|
| def apply_group_fade_smoothing(self, frame_groups, fade_frames):
|
| """Apply fade in/out smoothing to gloss groups"""
|
| smoothed_frames = []
|
|
|
| for i, group in enumerate(frame_groups):
|
| if i == 0:
|
|
|
| for f in range(fade_frames):
|
| alpha = f / fade_frames
|
| black_frame = np.zeros_like(group[0])
|
| faded_frame = (black_frame * (1 - alpha) + group[0] * alpha).astype(np.uint8)
|
| smoothed_frames.append(faded_frame)
|
|
|
|
|
| smoothed_frames.extend(group)
|
|
|
| if i < len(frame_groups) - 1:
|
|
|
| next_group = frame_groups[i + 1]
|
| current_last = group[-1]
|
| next_first = next_group[0]
|
|
|
| for f in range(fade_frames):
|
| alpha = f / fade_frames
|
| blended_frame = (current_last * (1 - alpha) + next_first * alpha).astype(np.uint8)
|
| smoothed_frames.append(blended_frame)
|
|
|
| return smoothed_frames
|
|
|
| def apply_group_blend_smoothing(self, frame_groups, blend_frames):
|
| """Apply blend smoothing to gloss groups"""
|
| smoothed_frames = []
|
|
|
| for i, group in enumerate(frame_groups):
|
| smoothed_frames.extend(group)
|
|
|
| if i < len(frame_groups) - 1:
|
| next_group = frame_groups[i + 1]
|
| current_last = group[-1]
|
| next_first = next_group[0]
|
|
|
|
|
| for f in range(1, blend_frames + 1):
|
| alpha = f / (blend_frames + 1)
|
| blended_frame = (current_last * (1 - alpha) + next_first * alpha).astype(np.uint8)
|
| smoothed_frames.append(blended_frame)
|
|
|
| return smoothed_frames
|
|
|
| def apply_group_pause_smoothing(self, frame_groups, pause_frames):
|
| """Apply pause smoothing to gloss groups"""
|
| smoothed_frames = []
|
|
|
| for i, group in enumerate(frame_groups):
|
| smoothed_frames.extend(group)
|
|
|
|
|
| if i < len(frame_groups) - 1:
|
| last_frame = group[-1]
|
| for _ in range(pause_frames):
|
| smoothed_frames.append(last_frame.copy())
|
|
|
| return smoothed_frames
|
|
|
| def show_available_glosses(self, limit=20):
|
| """Show available glosses or video_ids"""
|
| if self.gloss_mapping:
|
| glosses = list(self.gloss_mapping.keys())
|
| print(f"\n📋 Available Glosses ({len(glosses)}):")
|
| for i, gloss in enumerate(glosses[:limit]):
|
| videos = self.gloss_mapping[gloss]
|
| if isinstance(videos, list):
|
| print(f" {gloss} -> {len(videos)} videos")
|
| else:
|
| print(f" {gloss} -> {videos}")
|
| if len(glosses) > limit:
|
| print(f" ... and {len(glosses) - limit} more")
|
| else:
|
| video_ids = list(self.metadata['video_index'].keys())
|
| print(f"\n📋 Available Video IDs ({len(video_ids)}):")
|
| for i, vid in enumerate(video_ids[:limit]):
|
| frame_count = (self.metadata['video_index'][vid]['end_frame'] -
|
| self.metadata['video_index'][vid]['start_frame'] + 1)
|
| print(f" {vid} ({frame_count} frames)")
|
| if len(video_ids) > limit:
|
| print(f" ... and {len(video_ids) - limit} more")
|
|
|
| def run_qa_system(self):
|
| """Run QA system"""
|
| print("\n" + "=" * 60)
|
| print("🤖 Sign Language Gloss Q&A System")
|
| print("=" * 60)
|
| print("💬 Enter gloss to convert, separate multiple words with spaces")
|
| print("📋 Enter 'list' to view available glosses/videos")
|
| print("🔧 Enter 'help' to view help")
|
| print("👋 Enter 'quit' to exit system")
|
| print("=" * 60)
|
|
|
| while True:
|
| try:
|
| user_input = input("\n🤖 Please enter gloss: ").strip()
|
|
|
| if not user_input:
|
| continue
|
| elif user_input.lower() == 'quit':
|
| print("👋 Thank you for using!")
|
| break
|
| elif user_input.lower() == 'list':
|
| self.show_available_glosses()
|
| continue
|
| elif user_input.lower() == 'help':
|
| self.show_help()
|
| continue
|
|
|
|
|
| gloss_list = user_input.upper().split()
|
| print(f"\n🎯 Query: {' + '.join(gloss_list)}")
|
|
|
|
|
| frame_indices, video_info = self.get_frames_for_glosses(gloss_list, one_video_per_gloss=True)
|
|
|
| if not frame_indices:
|
| print("❌ No matching video frames found")
|
| continue
|
|
|
| print(f"\n📊 Total found {len(frame_indices)} frames from {len(video_info)} videos")
|
|
|
|
|
| smoothing_method = 'none'
|
| smoothing_frames = 0
|
|
|
| if len(video_info) > 1:
|
| print(f"\n🌊 Multiple video segments detected, choose smoothing transition method:")
|
| print(f" 1. none - No smoothing (direct concatenation)")
|
| print(f" 2. fade - Fade in/out transition")
|
| print(f" 3. blend - Frame blending transition")
|
| print(f" 4. pause - Add pause interval")
|
|
|
| smooth_choice = input(f"Choose smoothing method [1-4, default 1]: ").strip()
|
|
|
| if smooth_choice == '2':
|
| smoothing_method = 'fade'
|
| smoothing_frames = int(input("Fade in/out frames [default 5]: ").strip() or "5")
|
| elif smooth_choice == '3':
|
| smoothing_method = 'blend'
|
| smoothing_frames = int(input("Blend frames [default 3]: ").strip() or "3")
|
| elif smooth_choice == '4':
|
| smoothing_method = 'pause'
|
| smoothing_frames = int(input("Pause frames [default 10]: ").strip() or "10")
|
|
|
|
|
| gloss_str = "_".join(gloss_list)
|
| timestamp = __import__('datetime').datetime.now().strftime("%Y%m%d_%H%M%S")
|
| suffix = f"_{smoothing_method}" if smoothing_method != 'none' else ""
|
| output_file = Path(OUTPUT_DIR) / f"{gloss_str}_{timestamp}{suffix}.mp4"
|
|
|
|
|
| confirm = input(f"\n❓ Generate video to {output_file}? [y/n]: ").strip().lower()
|
|
|
| if confirm in ['y', 'yes', '']:
|
| success = self.generate_video(
|
| frame_indices, output_file, video_info,
|
| smoothing_frames=smoothing_frames,
|
| smoothing_method=smoothing_method
|
| )
|
|
|
| if success:
|
| print(f"\n🎉 Video generated: {output_file}")
|
|
|
|
|
| print(f"\n📈 Video details:")
|
| for info in video_info:
|
| print(f" {info['gloss']}: {info['video_id']} ({info['frame_count']} frames)")
|
| else:
|
| print("⏭️ Skipping video generation")
|
|
|
| except KeyboardInterrupt:
|
| print("\n\n👋 System exited")
|
| break
|
| except Exception as e:
|
| print(f"❌ Error occurred: {e}")
|
|
|
| def show_help(self):
|
| """Show help information"""
|
| print("\n" + "=" * 50)
|
| print("📖 Help Information")
|
| print("=" * 50)
|
| print("🔹 Enter single gloss: HELLO")
|
| print("🔹 Enter multiple glosses: HELLO WORLD GOODBYE")
|
| print("🔹 View available content: list")
|
| print("🔹 System will automatically match corresponding sign language videos")
|
| print(f"🔹 Generated videos are saved in {OUTPUT_DIR}/ directory")
|
| print("🔹 Supported mapping file format (gloss_mapping.json):")
|
| print(' {"HELLO": ["video1", "video2"], "WORLD": "video3"}')
|
| print("🔹 Smoothing transition options:")
|
| print(" - fade: Fade in/out transition")
|
| print(" - blend: Frame blending transition")
|
| print(" - pause: Add pause interval")
|
| print("=" * 50)
|
|
|
|
|
| def main():
|
| parser = argparse.ArgumentParser(description='Sign Language Gloss Q&A System')
|
| parser.add_argument('--gloss', '-g',
|
| help='Directly input gloss to generate video, separated by spaces')
|
| parser.add_argument('--fps', type=int, default=30,
|
| help='Video frame rate (default: 30)')
|
| parser.add_argument('--width', type=int, default=480,
|
| help='Video width (default: 480)')
|
| parser.add_argument('--height', type=int, default=480,
|
| help='Video height (default: 480)')
|
| parser.add_argument('--smoothing', choices=['none', 'fade', 'blend', 'pause'],
|
| default='none', help='Smoothing transition method (default: none)')
|
| parser.add_argument('--smoothing-frames', type=int, default=5,
|
| help='Smoothing transition frames (default: 5)')
|
|
|
| args = parser.parse_args()
|
|
|
|
|
| qa_system = SignLanguageQA()
|
|
|
|
|
| if args.gloss:
|
| gloss_list = args.gloss.upper().split()
|
| print(f"🎯 Processing gloss: {' + '.join(gloss_list)}")
|
|
|
| frame_indices, video_info = qa_system.get_frames_for_glosses(gloss_list, one_video_per_gloss=True)
|
|
|
| if frame_indices:
|
| gloss_str = "_".join(gloss_list)
|
| timestamp = __import__('datetime').datetime.now().strftime("%Y%m%d_%H%M%S")
|
| suffix = f"_{args.smoothing}" if args.smoothing != 'none' else ""
|
| output_file = Path(OUTPUT_DIR) / f"{gloss_str}_{timestamp}{suffix}.mp4"
|
|
|
| print(f"📊 Found {len(frame_indices)} frames from {len(video_info)} videos")
|
| if args.smoothing != 'none':
|
| print(f"🌊 Using {args.smoothing} smoothing transition ({args.smoothing_frames} frames)")
|
|
|
| success = qa_system.generate_video(
|
| frame_indices, output_file, video_info, args.fps, args.width, args.height,
|
| args.smoothing_frames, args.smoothing
|
| )
|
|
|
| if success:
|
| print(f"🎉 Video generated: {output_file}")
|
| print(f"\n📈 Video details:")
|
| for info in video_info:
|
| print(f" {info['gloss']}: {info['video_id']} ({info['frame_count']} 帧)")
|
| else:
|
| print("❌ No matching videos found")
|
| else:
|
|
|
| qa_system.run_qa_system()
|
|
|
|
|
| if __name__ == "__main__":
|
| main() |
