Upload 5 files

camera_utils.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+class Camera(object):
+    def __init__(self, c2w):
+        c2w_mat = np.array(c2w).reshape(4, 4)
+        self.c2w_mat = c2w_mat
+        self.w2c_mat = np.linalg.inv(c2w_mat)
+
+def parse_matrix(matrix_str):
+    """Parse camera matrix string from JSON format"""
+    rows = matrix_str.strip().split('] [')
+    matrix = []
+    for row in rows:
+        row = row.replace('[', '').replace(']', '')
+        matrix.append(list(map(float, row.split())))
+    return np.array(matrix)
+
+def get_relative_pose(cam_params):
+    """Calculate relative camera poses"""
+    abs_w2cs = [cam_param.w2c_mat for cam_param in cam_params]
+    abs_c2ws = [cam_param.c2w_mat for cam_param in cam_params]
+
+    cam_to_origin = 0
+    target_cam_c2w = np.array([
+        [1, 0, 0, 0],
+        [0, 1, 0, -cam_to_origin],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1]
+    ])
+    abs2rel = target_cam_c2w @ abs_w2cs[0]
+    ret_poses = [target_cam_c2w, ] + [abs2rel @ abs_c2w for abs_c2w in abs_c2ws[1:]]
+    ret_poses = np.array(ret_poses, dtype=np.float32)
+    return ret_poses

config.py

@@ -0,0 +1,16 @@
+# Camera transformation types
+CAMERA_TRANSFORMATIONS = {
+    "1": "Pan Right",
+    "2": "Pan Left", 
+    "3": "Tilt Up",
+    "4": "Tilt Down",
+    "5": "Zoom In",
+    "6": "Zoom Out",
+    "7": "Translate Up (with rotation)",
+    "8": "Translate Down (with rotation)",
+    "9": "Arc Left (with rotation)",
+    "10": "Arc Right (with rotation)"
+}
+
+# Define test data directory
+TEST_DATA_DIR = "example_test_data"

model_loader.py

@@ -0,0 +1,330 @@
+import os
+import torch
+import torch.nn as nn
+import logging
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+from diffsynth import ModelManager, WanVideoReCamMasterPipeline
+
+logger = logging.getLogger(__name__)
+
+# Get model storage path from environment variable or use default
+MODELS_ROOT_DIR = os.environ.get("RECAMMASTER_MODELS_DIR", "/data/models")
+logger.info(f"Using models root directory: {MODELS_ROOT_DIR}")
+
+# Define model repositories and files
+WAN21_REPO_ID = "Wan-AI/Wan2.1-T2V-1.3B"
+WAN21_LOCAL_DIR = f"{MODELS_ROOT_DIR}/Wan-AI/Wan2.1-T2V-1.3B"
+WAN21_FILES = [
+    "diffusion_pytorch_model.safetensors",
+    "models_t5_umt5-xxl-enc-bf16.pth",
+    "Wan2.1_VAE.pth"
+]
+
+# Define tokenizer files to download
+UMT5_XXL_TOKENIZER_FILES = [
+    "google/umt5-xxl/special_tokens_map.json",
+    "google/umt5-xxl/spiece.model",
+    "google/umt5-xxl/tokenizer.json",
+    "google/umt5-xxl/tokenizer_config.json"
+]
+
+RECAMMASTER_REPO_ID = "KwaiVGI/ReCamMaster-Wan2.1"
+RECAMMASTER_CHECKPOINT_FILE = "step20000.ckpt"
+RECAMMASTER_LOCAL_DIR = f"{MODELS_ROOT_DIR}/ReCamMaster/checkpoints"
+
+class ModelLoader:
+    def __init__(self):
+        self.model_manager = None
+        self.pipe = None
+        self.is_loaded = False
+    
+    def download_umt5_xxl_tokenizer(self, progress_callback=None):
+        """Download UMT5-XXL tokenizer files from HuggingFace"""
+        
+        total_files = len(UMT5_XXL_TOKENIZER_FILES)
+        downloaded_paths = []
+        
+        for i, file_path in enumerate(UMT5_XXL_TOKENIZER_FILES):
+            local_dir = f"{WAN21_LOCAL_DIR}/{os.path.dirname(file_path)}"
+            filename = os.path.basename(file_path)
+            full_local_path = f"{WAN21_LOCAL_DIR}/{file_path}"
+            
+            # Update progress
+            if progress_callback:
+                progress_callback(i/total_files, desc=f"Checking tokenizer file {i+1}/{total_files}: {filename}")
+            
+            # Check if already exists
+            if os.path.exists(full_local_path):
+                logger.info(f"✓ Tokenizer file {filename} already exists at {full_local_path}")
+                downloaded_paths.append(full_local_path)
+                continue
+            
+            # Create directory if it doesn't exist
+            os.makedirs(local_dir, exist_ok=True)
+            
+            # Download the file
+            logger.info(f"Downloading tokenizer file {filename} from {WAN21_REPO_ID}/{file_path}...")
+            
+            if progress_callback:
+                progress_callback(i/total_files, desc=f"Downloading tokenizer file {i+1}/{total_files}: {filename}")
+            
+            try:
+                # Download using huggingface_hub
+                downloaded_path = hf_hub_download(
+                    repo_id=WAN21_REPO_ID,
+                    filename=file_path,
+                    local_dir=WAN21_LOCAL_DIR,
+                    local_dir_use_symlinks=False
+                )
+                logger.info(f"✓ Successfully downloaded tokenizer file {filename} to {downloaded_path}!")
+                downloaded_paths.append(downloaded_path)
+            except Exception as e:
+                logger.error(f"✗ Error downloading tokenizer file {filename}: {e}")
+                raise
+        
+        if progress_callback:
+            progress_callback(1.0, desc=f"All tokenizer files downloaded successfully!")
+        
+        return downloaded_paths
+
+    def download_wan21_models(self, progress_callback=None):
+        """Download Wan2.1 model files from HuggingFace"""
+        
+        total_files = len(WAN21_FILES)
+        downloaded_paths = []
+        
+        # Create directory if it doesn't exist
+        Path(WAN21_LOCAL_DIR).mkdir(parents=True, exist_ok=True)
+        
+        for i, filename in enumerate(WAN21_FILES):
+            local_path = Path(WAN21_LOCAL_DIR) / filename
+            
+            # Update progress
+            if progress_callback:
+                progress_callback(i/total_files, desc=f"Checking Wan2.1 file {i+1}/{total_files}: {filename}")
+            
+            # Check if already exists
+            if local_path.exists():
+                logger.info(f"✓ {filename} already exists at {local_path}")
+                downloaded_paths.append(str(local_path))
+                continue
+            
+            # Download the file
+            logger.info(f"Downloading {filename} from {WAN21_REPO_ID}...")
+            
+            if progress_callback:
+                progress_callback(i/total_files, desc=f"Downloading Wan2.1 file {i+1}/{total_files}: {filename}")
+            
+            try:
+                # Download using huggingface_hub
+                downloaded_path = hf_hub_download(
+                    repo_id=WAN21_REPO_ID,
+                    filename=filename,
+                    local_dir=WAN21_LOCAL_DIR,
+                    local_dir_use_symlinks=False
+                )
+                logger.info(f"✓ Successfully downloaded {filename} to {downloaded_path}!")
+                downloaded_paths.append(downloaded_path)
+            except Exception as e:
+                logger.error(f"✗ Error downloading {filename}: {e}")
+                raise
+        
+        if progress_callback:
+            progress_callback(1.0, desc=f"All Wan2.1 models downloaded successfully!")
+        
+        return downloaded_paths
+
+    def download_recammaster_checkpoint(self, progress_callback=None):
+        """Download ReCamMaster checkpoint from HuggingFace using huggingface_hub"""
+        checkpoint_path = Path(RECAMMASTER_LOCAL_DIR) / RECAMMASTER_CHECKPOINT_FILE
+
+        # Check if already exists
+        if checkpoint_path.exists():
+            logger.info(f"✓ ReCamMaster checkpoint already exists at {checkpoint_path}")
+            return checkpoint_path
+
+        # Create directory if it doesn't exist
+        Path(RECAMMASTER_LOCAL_DIR).mkdir(parents=True, exist_ok=True)
+
+        # Download the checkpoint
+        logger.info("Downloading ReCamMaster checkpoint from HuggingFace...")
+        logger.info(f"Repository: {RECAMMASTER_REPO_ID}")
+        logger.info(f"File: {RECAMMASTER_CHECKPOINT_FILE}")
+        logger.info(f"Destination: {checkpoint_path}")
+        
+        if progress_callback:
+            progress_callback(0.0, desc=f"Downloading ReCamMaster checkpoint...")
+
+        try:
+            # Download using huggingface_hub
+            downloaded_path = hf_hub_download(
+                repo_id=RECAMMASTER_REPO_ID,
+                filename=RECAMMASTER_CHECKPOINT_FILE,
+                local_dir=RECAMMASTER_LOCAL_DIR,
+                local_dir_use_symlinks=False
+            )
+            logger.info(f"✓ Successfully downloaded ReCamMaster checkpoint to {downloaded_path}!")
+            
+            if progress_callback:
+                progress_callback(1.0, desc=f"ReCamMaster checkpoint downloaded successfully!")
+                
+            return downloaded_path
+        except Exception as e:
+            logger.error(f"✗ Error downloading checkpoint: {e}")
+            raise
+
+    def create_symlink_for_tokenizer(self):
+        """Create symlink for google/umt5-xxl to handle potential path issues"""
+        try:
+            google_dir = f"{MODELS_ROOT_DIR}/google"
+            if not os.path.exists(google_dir):
+                os.makedirs(google_dir, exist_ok=True)
+            
+            umt5_xxl_symlink = f"{google_dir}/umt5-xxl"
+            umt5_xxl_source = f"{WAN21_LOCAL_DIR}/google/umt5-xxl"
+            
+            # Create a symlink if it doesn't exist
+            if not os.path.exists(umt5_xxl_symlink) and os.path.exists(umt5_xxl_source):
+                if os.name == 'nt':  # Windows
+                    import ctypes
+                    kdll = ctypes.windll.LoadLibrary("kernel32.dll")
+                    kdll.CreateSymbolicLinkA(umt5_xxl_symlink.encode(), umt5_xxl_source.encode(), 1)
+                else:  # Unix/Linux
+                    os.symlink(umt5_xxl_source, umt5_xxl_symlink)
+                logger.info(f"Created symlink from {umt5_xxl_source} to {umt5_xxl_symlink}")
+        except Exception as e:
+            logger.warning(f"Could not create symlink for google/umt5-xxl: {str(e)}")
+            # This is a warning, not an error, as we'll try to proceed anyway
+
+    def load_models(self, progress_callback=None):
+        """Load the ReCamMaster models"""
+        
+        if self.is_loaded:
+            return "Models already loaded!"
+        
+        try:
+            logger.info("Starting model loading...")
+            
+            # Import test data creator
+            from test_data import create_test_data_structure
+            
+            # First create the test data structure
+            if progress_callback:
+                progress_callback(0.05, desc="Setting up test data structure...")
+            
+            try:
+                create_test_data_structure(progress_callback)
+            except Exception as e:
+                error_msg = f"Error creating test data structure: {str(e)}"
+                logger.error(error_msg)
+                return error_msg
+            
+            # Second, ensure the checkpoint is downloaded
+            if progress_callback:
+                progress_callback(0.1, desc="Checking for ReCamMaster checkpoint...")
+            
+            try:
+                ckpt_path = self.download_recammaster_checkpoint(progress_callback)
+                logger.info(f"Using checkpoint at {ckpt_path}")
+            except Exception as e:
+                error_msg = f"Error downloading ReCamMaster checkpoint: {str(e)}"
+                logger.error(error_msg)
+                return error_msg
+            
+            # Third, download Wan2.1 models if needed
+            if progress_callback:
+                progress_callback(0.2, desc="Checking for Wan2.1 models...")
+            
+            try:
+                wan21_paths = self.download_wan21_models(progress_callback)
+                logger.info(f"Using Wan2.1 models: {wan21_paths}")
+            except Exception as e:
+                error_msg = f"Error downloading Wan2.1 models: {str(e)}"
+                logger.error(error_msg)
+                return error_msg
+            
+            # Fourth, download UMT5-XXL tokenizer files
+            if progress_callback:
+                progress_callback(0.3, desc="Checking for UMT5-XXL tokenizer files...")
+            
+            try:
+                tokenizer_paths = self.download_umt5_xxl_tokenizer(progress_callback)
+                logger.info(f"Using UMT5-XXL tokenizer files: {tokenizer_paths}")
+            except Exception as e:
+                error_msg = f"Error downloading UMT5-XXL tokenizer files: {str(e)}"
+                logger.error(error_msg)
+                return error_msg
+            
+            # Now, load the models
+            if progress_callback:
+                progress_callback(0.4, desc="Loading model manager...")
+            
+            # Create symlink for tokenizer
+            self.create_symlink_for_tokenizer()
+            
+            # Load Wan2.1 pre-trained models
+            self.model_manager = ModelManager(torch_dtype=torch.bfloat16, device="cpu")
+            
+            if progress_callback:
+                progress_callback(0.5, desc="Loading Wan2.1 models...")
+            
+            # Build full paths for the model files
+            model_files = [f"{WAN21_LOCAL_DIR}/{filename}" for filename in WAN21_FILES]
+            
+            for model_file in model_files:
+                logger.info(f"Loading model from: {model_file}")
+                if not os.path.exists(model_file):
+                    error_msg = f"Error: Model file not found: {model_file}"
+                    logger.error(error_msg)
+                    return error_msg
+            
+            # Set environment variable for transformers to find the tokenizer
+            os.environ["TRANSFORMERS_CACHE"] = MODELS_ROOT_DIR
+            os.environ["TOKENIZERS_PARALLELISM"] = "false"  # Disable tokenizers parallelism warning
+            
+            self.model_manager.load_models(model_files)
+            
+            if progress_callback:
+                progress_callback(0.7, desc="Creating pipeline...")
+            
+            self.pipe = WanVideoReCamMasterPipeline.from_model_manager(self.model_manager, device="cuda")
+            
+            if progress_callback:
+                progress_callback(0.8, desc="Initializing ReCamMaster modules...")
+            
+            # Initialize additional modules introduced in ReCamMaster
+            dim = self.pipe.dit.blocks[0].self_attn.q.weight.shape[0]
+            for block in self.pipe.dit.blocks:
+                block.cam_encoder = nn.Linear(12, dim)
+                block.projector = nn.Linear(dim, dim)
+                block.cam_encoder.weight.data.zero_()
+                block.cam_encoder.bias.data.zero_()
+                block.projector.weight = nn.Parameter(torch.eye(dim))
+                block.projector.bias = nn.Parameter(torch.zeros(dim))
+            
+            if progress_callback:
+                progress_callback(0.9, desc="Loading ReCamMaster checkpoint...")
+            
+            # Load ReCamMaster checkpoint
+            if not os.path.exists(ckpt_path):
+                error_msg = f"Error: ReCamMaster checkpoint not found at {ckpt_path} even after download attempt."
+                logger.error(error_msg)
+                return error_msg
+            
+            state_dict = torch.load(ckpt_path, map_location="cpu")
+            self.pipe.dit.load_state_dict(state_dict, strict=True)
+            self.pipe.to("cuda")
+            self.pipe.to(dtype=torch.bfloat16)
+            
+            self.is_loaded = True
+            
+            if progress_callback:
+                progress_callback(1.0, desc="Models loaded successfully!")
+            
+            logger.info("Models loaded successfully!")
+            return "Models loaded successfully!"
+        
+        except Exception as e:
+            logger.error(f"Error loading models: {str(e)}")
+            return f"Error loading models: {str(e)}"

test_data.py

@@ -0,0 +1,128 @@
+import json
+import numpy as np
+import logging
+from pathlib import Path
+from config import TEST_DATA_DIR
+
+logger = logging.getLogger(__name__)
+
+def create_test_data_structure(progress_callback=None):
+    """Create sample camera extrinsics data for testing"""
+    
+    if progress_callback:
+        progress_callback(0.0, desc="Creating test data structure...")
+    
+    # Create directories
+    data_dir = Path(f"{TEST_DATA_DIR}/cameras")
+    videos_dir = Path(f"{TEST_DATA_DIR}/videos")
+    data_dir.mkdir(parents=True, exist_ok=True)
+    videos_dir.mkdir(parents=True, exist_ok=True)
+    
+    camera_file = data_dir / "camera_extrinsics.json"
+    
+    # Skip if file already exists
+    if camera_file.exists():
+        logger.info(f"✓ Camera extrinsics already exist at {camera_file}")
+        
+        if progress_callback:
+            progress_callback(1.0, desc="Test data structure already exists")
+            
+        return
+    
+    if progress_callback:
+        progress_callback(0.3, desc="Generating camera extrinsics data...")
+    
+    # Generate sample camera data
+    camera_data = {}
+    
+    # Create 81 frames with 10 camera trajectories each
+    for frame_idx in range(81):
+        frame_key = f"frame{frame_idx}"
+        camera_data[frame_key] = {}
+        
+        for cam_idx in range(1, 11):  # Camera types 1-10
+            # Create a sample camera matrix (this is just an example - replace with actual logic if needed)
+            # In reality, these would be calculated based on specific camera movement patterns
+            
+            # Create a base identity matrix
+            base_matrix = np.eye(4)
+            
+            # Add some variation based on frame and camera type
+            # This is a simplistic example - real camera movements would be more complex
+            if cam_idx == 1:  # Pan Right
+                base_matrix[0, 3] = 0.01 * frame_idx  # Move right over time
+            elif cam_idx == 2:  # Pan Left
+                base_matrix[0, 3] = -0.01 * frame_idx  # Move left over time
+            elif cam_idx == 3:  # Tilt Up
+                # Rotate around X-axis
+                angle = 0.005 * frame_idx
+                base_matrix[1, 1] = np.cos(angle)
+                base_matrix[1, 2] = -np.sin(angle)
+                base_matrix[2, 1] = np.sin(angle)
+                base_matrix[2, 2] = np.cos(angle)
+            elif cam_idx == 4:  # Tilt Down
+                # Rotate around X-axis (opposite direction)
+                angle = -0.005 * frame_idx
+                base_matrix[1, 1] = np.cos(angle)
+                base_matrix[1, 2] = -np.sin(angle)
+                base_matrix[2, 1] = np.sin(angle)
+                base_matrix[2, 2] = np.cos(angle)
+            elif cam_idx == 5:  # Zoom In
+                base_matrix[2, 3] = -0.01 * frame_idx  # Move forward over time
+            elif cam_idx == 6:  # Zoom Out
+                base_matrix[2, 3] = 0.01 * frame_idx  # Move backward over time
+            elif cam_idx == 7:  # Translate Up (with rotation)
+                base_matrix[1, 3] = 0.01 * frame_idx  # Move up over time
+                angle = 0.003 * frame_idx
+                base_matrix[0, 0] = np.cos(angle)
+                base_matrix[0, 2] = np.sin(angle)
+                base_matrix[2, 0] = -np.sin(angle)
+                base_matrix[2, 2] = np.cos(angle)
+            elif cam_idx == 8:  # Translate Down (with rotation)
+                base_matrix[1, 3] = -0.01 * frame_idx  # Move down over time
+                angle = -0.003 * frame_idx
+                base_matrix[0, 0] = np.cos(angle)
+                base_matrix[0, 2] = np.sin(angle)
+                base_matrix[2, 0] = -np.sin(angle)
+                base_matrix[2, 2] = np.cos(angle)
+            elif cam_idx == 9:  # Arc Left (with rotation)
+                angle = 0.005 * frame_idx
+                radius = 2.0
+                base_matrix[0, 3] = -radius * np.sin(angle)
+                base_matrix[2, 3] = -radius * np.cos(angle) + radius
+                # Rotate to look at center
+                look_angle = angle + np.pi
+                base_matrix[0, 0] = np.cos(look_angle)
+                base_matrix[0, 2] = np.sin(look_angle)
+                base_matrix[2, 0] = -np.sin(look_angle)
+                base_matrix[2, 2] = np.cos(look_angle)
+            elif cam_idx == 10:  # Arc Right (with rotation)
+                angle = -0.005 * frame_idx
+                radius = 2.0
+                base_matrix[0, 3] = -radius * np.sin(angle)
+                base_matrix[2, 3] = -radius * np.cos(angle) + radius
+                # Rotate to look at center
+                look_angle = angle + np.pi
+                base_matrix[0, 0] = np.cos(look_angle)
+                base_matrix[0, 2] = np.sin(look_angle)
+                base_matrix[2, 0] = -np.sin(look_angle)
+                base_matrix[2, 2] = np.cos(look_angle)
+            
+            # Format the matrix as a string (as expected by the app)
+            matrix_str = ' '.join([' '.join([str(base_matrix[i, j]) for j in range(4)]) for i in range(4)])
+            matrix_str = '[ ' + matrix_str.replace(' ', ' ] [ ', 3) + ' ]'
+            
+            camera_data[frame_key][f"cam{cam_idx:02d}"] = matrix_str
+    
+    if progress_callback:
+        progress_callback(0.7, desc="Saving camera extrinsics data...")
+    
+    # Save camera extrinsics to JSON file
+    with open(camera_file, 'w') as f:
+        json.dump(camera_data, f, indent=2)
+    
+    logger.info(f"Created sample camera extrinsics at {camera_file}")
+    logger.info(f"Created directory for example videos at {videos_dir}")
+    
+    if progress_callback:
+        progress_callback(1.0, desc="Test data structure created successfully!")

video_processor.py

@@ -0,0 +1,118 @@
+import torch
+import numpy as np
+import json
+import imageio
+from PIL import Image
+from torchvision.transforms import v2
+from einops import rearrange
+import torchvision
+import logging
+from config import TEST_DATA_DIR
+from camera_utils import Camera, parse_matrix, get_relative_pose
+
+logger = logging.getLogger(__name__)
+
+class VideoProcessor:
+    def __init__(self, pipe):
+        self.pipe = pipe
+        self.height = 480
+        self.width = 832
+        
+        # Create frame processor
+        self.frame_process = v2.Compose([
+            v2.CenterCrop(size=(self.height, self.width)),
+            v2.Resize(size=(self.height, self.width), antialias=True),
+            v2.ToTensor(),
+            v2.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+        ])
+    
+    def crop_and_resize(self, image):
+        """Crop and resize image to match target dimensions"""
+        width_img, height_img = image.size
+        scale = max(self.width / width_img, self.height / height_img)
+        image = torchvision.transforms.functional.resize(
+            image,
+            (round(height_img*scale), round(width_img*scale)),
+            interpolation=torchvision.transforms.InterpolationMode.BILINEAR
+        )
+        return image
+    
+    def load_video_frames(self, video_path):
+        """Load and process video frames"""
+        reader = imageio.get_reader(video_path)
+        frames = []
+        
+        for i in range(81):  # ReCamMaster needs exactly 81 frames
+            try:
+                frame = reader.get_data(i)
+                frame = Image.fromarray(frame)
+                frame = self.crop_and_resize(frame)
+                frame = self.frame_process(frame)
+                frames.append(frame)
+            except:
+                # If we run out of frames, repeat the last one
+                if frames:
+                    frames.append(frames[-1])
+                else:
+                    raise ValueError("Video is too short!")
+        
+        reader.close()
+        
+        frames = torch.stack(frames, dim=0)
+        frames = rearrange(frames, "T C H W -> C T H W")
+        video_tensor = frames.unsqueeze(0)  # Add batch dimension
+        
+        return video_tensor
+    
+    def load_camera_trajectory(self, cam_type):
+        """Load camera trajectory for the selected type"""
+        tgt_camera_path = f"./{TEST_DATA_DIR}/cameras/camera_extrinsics.json"
+        with open(tgt_camera_path, 'r') as file:
+            cam_data = json.load(file)
+        
+        # Get camera trajectory for selected type
+        cam_idx = list(range(81))[::4]  # Sample every 4 frames
+        traj = [parse_matrix(cam_data[f"frame{idx}"][f"cam{int(cam_type):02d}"]) for idx in cam_idx]
+        traj = np.stack(traj).transpose(0, 2, 1)
+        
+        c2ws = []
+        for c2w in traj:
+            c2w = c2w[:, [1, 2, 0, 3]]
+            c2w[:3, 1] *= -1.
+            c2w[:3, 3] /= 100
+            c2ws.append(c2w)
+        
+        tgt_cam_params = [Camera(cam_param) for cam_param in c2ws]
+        relative_poses = []
+        for i in range(len(tgt_cam_params)):
+            relative_pose = get_relative_pose([tgt_cam_params[0], tgt_cam_params[i]])
+            relative_poses.append(torch.as_tensor(relative_pose)[:,:3,:][1])
+        
+        pose_embedding = torch.stack(relative_poses, dim=0)  # 21x3x4
+        pose_embedding = rearrange(pose_embedding, 'b c d -> b (c d)')
+        camera_tensor = pose_embedding.to(torch.bfloat16).unsqueeze(0)  # Add batch dimension
+        
+        return camera_tensor
+    
+    def process_video(self, video_path, text_prompt, cam_type):
+        """Process video through ReCamMaster model"""
+        
+        # Load video frames
+        video_tensor = self.load_video_frames(video_path)
+        
+        # Load camera trajectory
+        camera_tensor = self.load_camera_trajectory(cam_type)
+        
+        # Generate video with ReCamMaster
+        video = self.pipe(
+            prompt=[text_prompt],
+            negative_prompt=["worst quality, low quality, blurry, jittery, distorted"],
+            source_video=video_tensor,
+            target_camera=camera_tensor,
+            cfg_scale=5.0,
+            num_inference_steps=50,
+            seed=0,
+            tiled=True
+        )
+        
+        return video