create_video_resized.py

#!/usr/bin/env python3
"""
Create Video with Resized Images
Resizes the processed images to a manageable size and creates a video.
"""

import os
import sys
import subprocess
from pathlib import Path
from PIL import Image

def resize_images_for_video(input_dir="output", resized_dir="resized", target_width=1920):
    """Resize images to a manageable size for video creation"""
    print(f"Resizing images to {target_width}px width for video...")
    
    input_path = Path(input_dir)
    resized_path = Path(resized_dir)
    resized_path.mkdir(exist_ok=True)
    
    # Get all bitmap files
    image_files = sorted(list(input_path.glob("*.bmp")))
    
    if not image_files:
        print(f"No images found in {input_dir}")
        return False
    
    print(f"Found {len(image_files)} images to resize...")
    
    for i, image_file in enumerate(image_files):
        try:
            if i % 50 == 0:
                print(f"Resizing image {i+1}/{len(image_files)}...")
            
            # Open and resize image
            with Image.open(image_file) as img:
                # Calculate new height maintaining aspect ratio
                aspect_ratio = img.height / img.width
                new_height = int(target_width * aspect_ratio)
                
                # Resize image
                resized_img = img.resize((target_width, new_height), Image.Resampling.LANCZOS)
                
                # Save resized image
                output_filename = image_file.name
                output_path = resized_path / output_filename
                resized_img.save(output_path, 'BMP')
                
        except Exception as e:
            print(f"Error resizing {image_file.name}: {e}")
            return False
    
    print(f"✓ Resized {len(image_files)} images to {target_width}x{new_height}")
    return True

def create_video_from_resized(resized_dir="resized", video_dir="video", fps=60):
    """Create video from resized images"""
    print(f"Creating {fps}fps video from resized images...")
    
    resized_path = Path(resized_dir)
    video_path = Path(video_dir)
    video_path.mkdir(exist_ok=True)
    
    # Get resized images
    image_files = sorted(list(resized_path.glob("*.bmp")))
    
    if not image_files:
        print(f"No resized images found in {resized_dir}")
        return False
    
    print(f"Found {len(image_files)} resized images...")
    
    # Create video filename
    base_name = image_files[0].stem.split('_video_echo_')[0]
    video_filename = f"{base_name}_echo_progression_{fps}fps_resized.mp4"
    video_file = video_path / video_filename
    
    # Build FFmpeg command
    input_pattern = str(resized_path / f"{base_name}_video_echo_%04d.bmp")
    
    cmd = [
        "ffmpeg",
        "-y",
        "-framerate", str(fps),
        "-i", input_pattern,
        "-c:v", "libx264",
        "-preset", "fast",
        "-crf", "23",
        "-pix_fmt", "yuv420p",
        str(video_file)
    ]
    
    print(f"Creating video: {video_filename}")
    print(f"Command: {' '.join(cmd)}")
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        print(f"✓ Video created successfully: {video_filename}")
        
        # Get video info
        info_cmd = ["ffprobe", "-v", "quiet", "-print_format", "json", 
                   "-show_format", "-show_streams", str(video_file)]
        info_result = subprocess.run(info_cmd, capture_output=True, text=True, check=True)
        
        import json
        info = json.loads(info_result.stdout)
        duration = float(info['format']['duration'])
        print(f"✓ Video duration: {duration:.2f} seconds")
        print(f"✓ Frame count: {len(image_files)} frames")
        print(f"✓ Video saved to: {video_file}")
        
        return True
        
    except subprocess.CalledProcessError as e:
        print(f"✗ Error creating video: {e.stderr}")
        return False

def main():
    """Main function"""
    
    # Default parameters
    target_width = 1920  # 1080p width
    fps = 60
    
    # Allow command line arguments
    if len(sys.argv) > 1:
        try:
            target_width = int(sys.argv[1])
            if target_width < 480 or target_width > 3840:
                print("Target width should be between 480 and 3840")
                return
        except ValueError:
            print("Please provide a valid number for target width")
            return
    
    if len(sys.argv) > 2:
        try:
            fps = int(sys.argv[2])
            if fps < 1 or fps > 120:
                print("FPS should be between 1 and 120")
                return
        except ValueError:
            print("Please provide a valid number for FPS")
            return
    
    print("Starting video creation with resized images...")
    print("=" * 60)
    print(f"Target width: {target_width}px")
    print(f"FPS: {fps}")
    print("=" * 60)
    
    # Step 1: Resize images
    if not resize_images_for_video(target_width=target_width):
        print("Failed to resize images")
        return
    
    print()
    
    # Step 2: Create video
    if not create_video_from_resized(fps=fps):
        print("Failed to create video")
        return
    
    print()
    print("=" * 60)
    print("Video creation completed successfully!")
    print("=" * 60)

if __name__ == "__main__":
    main()