random data

extract_frames.py

@@ -95,7 +95,7 @@ def main():
     expanded_dir.mkdir(exist_ok=True)
     
     # Find all WebP files
-    webp_files = list(shots_dir.glob('sample-035-*.webp'))
+    webp_files = list(shots_dir.glob('sample-193-*.webp'))
     
     if not webp_files:
         print(f"No WebP files found in {shots_dir}")

random_frame_extractor.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Script to randomly extract k frames from WebP files in data/shots/ and save them as PNG files.
+
+Usage:
+    python random_frame_extractor.py <k> <output_dir>
+    
+Where:
+    k: Number of frames to extract
+    output_dir: Directory to save the extracted frames
+
+Input:  data/shots/sample-XXX-Y.webp (randomly selected)
+Output: <output_dir>/sample-XXX-Y-fZ.png (where Z is the frame number, e.g., f20 for frame 20)
+"""
+
+import os
+import sys
+import random
+from pathlib import Path
+from PIL import Image
+import re
+import argparse
+
+
+def get_frame_count(webp_path):
+    """
+    Get the total number of frames in a WebP file.
+    
+    Args:
+        webp_path (Path): Path to the WebP file
+        
+    Returns:
+        int: Number of frames in the file
+    """
+    try:
+        with Image.open(webp_path) as img:
+            frame_count = 0
+            try:
+                while True:
+                    img.seek(frame_count)
+                    frame_count += 1
+            except EOFError:
+                pass
+            return max(1, frame_count)  # At least 1 frame for static images
+    except Exception as e:
+        print(f"Error reading {webp_path}: {e}")
+        return 0
+
+
+def extract_random_frames(webp_path, output_dir, num_frames_to_extract):
+    """
+    Extract random frames from a WebP file and save them as PNG files.
+    
+    Args:
+        webp_path (Path): Path to the input WebP file
+        output_dir (Path): Directory to save the extracted frames
+        num_frames_to_extract (int): Number of frames to extract from this file
+        
+    Returns:
+        list: List of extracted frame filenames
+    """
+    try:
+        # Parse filename to get sample and shot numbers
+        filename = webp_path.stem  # e.g., "sample-123-2"
+        match = re.match(r'sample-(\d+)-(\d+)', filename)
+        if not match:
+            print(f"Warning: Filename {filename} doesn't match expected pattern")
+            return []
+        
+        sample_num = match.group(1)
+        shot_num = match.group(2)
+        
+        # Get total frame count
+        total_frames = get_frame_count(webp_path)
+        if total_frames == 0:
+            return []
+        
+        # Determine how many frames to extract (don't exceed available frames)
+        frames_to_extract = min(num_frames_to_extract, total_frames)
+        
+        # Select random frame indices
+        if total_frames == 1:
+            selected_frames = [0]
+        else:
+            selected_frames = sorted(random.sample(range(total_frames), frames_to_extract))
+        
+        extracted_files = []
+        
+        with Image.open(webp_path) as img:
+            for frame_idx in selected_frames:
+                try:
+                    # Seek to the specific frame
+                    img.seek(frame_idx)
+                    
+                    # Convert to RGB if necessary
+                    frame = img.convert('RGB')
+                    
+                    # Create output filename: sample-XXX-Y-fZ.png
+                    output_filename = f"sample-{sample_num}-{shot_num}-f{frame_idx}.png"
+                    output_path = output_dir / output_filename
+                    
+                    # Save the frame as PNG
+                    frame.save(output_path)
+                    extracted_files.append(output_filename)
+                    print(f"Extracted frame {frame_idx} from {webp_path.name}: {output_filename}")
+                    
+                except Exception as e:
+                    print(f"Error extracting frame {frame_idx} from {webp_path}: {e}")
+        
+        return extracted_files
+        
+    except Exception as e:
+        print(f"Error processing {webp_path}: {e}")
+        return []
+
+
+def main():
+    """Main function to randomly extract k frames from WebP files"""
+    
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Randomly extract k frames from WebP files')
+    parser.add_argument('k', type=int, help='Number of frames to extract')
+    parser.add_argument('output_dir', type=str, help='Output directory for extracted frames')
+    parser.add_argument('--frames-per-file', type=int, default=3, 
+                       help='Maximum frames to extract per WebP file (default: 3)')
+    parser.add_argument('--seed', type=int, help='Random seed for reproducible results')
+    
+    args = parser.parse_args()
+    
+    if args.k <= 0:
+        print("Error: k must be a positive integer")
+        sys.exit(1)
+    
+    # Set random seed if provided
+    if args.seed is not None:
+        random.seed(args.seed)
+        print(f"Using random seed: {args.seed}")
+    
+    # Set up paths
+    script_dir = Path(__file__).parent
+    shots_dir = script_dir / "data" / "shots"
+    output_dir = Path(args.output_dir)
+    
+    # Check if shots directory exists
+    if not shots_dir.exists():
+        print(f"Error: Shots directory not found: {shots_dir}")
+        sys.exit(1)
+    
+    # Create output directory if it doesn't exist
+    output_dir.mkdir(parents=True, exist_ok=True)
+    print(f"Output directory: {output_dir}")
+    
+    # Find all WebP files
+    webp_files = list(shots_dir.glob('sample-*.webp'))
+    
+    if not webp_files:
+        print(f"No WebP files found in {shots_dir}")
+        sys.exit(1)
+    
+    print(f"Found {len(webp_files)} WebP files available")
+    
+    # Calculate how many files we need to process
+    frames_per_file = args.frames_per_file
+    files_needed = (args.k + frames_per_file - 1) // frames_per_file  # Ceiling division
+    files_needed = min(files_needed, len(webp_files))
+    
+    # Randomly select WebP files
+    selected_files = random.sample(webp_files, files_needed)
+    print(f"Randomly selected {len(selected_files)} WebP files")
+    
+    total_extracted = 0
+    extracted_files = []
+    
+    # Process each selected WebP file
+    for i, webp_file in enumerate(selected_files):
+        remaining_frames = args.k - total_extracted
+        if remaining_frames <= 0:
+            break
+        
+        # Calculate how many frames to extract from this file
+        frames_from_this_file = min(frames_per_file, remaining_frames)
+        
+        print(f"\nProcessing ({i+1}/{len(selected_files)}): {webp_file.name}")
+        print(f"Extracting up to {frames_from_this_file} frames...")
+        
+        files = extract_random_frames(webp_file, output_dir, frames_from_this_file)
+        extracted_files.extend(files)
+        total_extracted += len(files)
+    
+    print(f"\n=== Summary ===")
+    print(f"Target frames: {args.k}")
+    print(f"Frames extracted: {total_extracted}")
+    print(f"Files processed: {len(selected_files)}")
+    print(f"Output directory: {output_dir}")
+    
+    if total_extracted < args.k:
+        print(f"Warning: Only extracted {total_extracted} frames out of {args.k} requested")
+    
+    print(f"\nExtracted files:")
+    for filename in extracted_files:
+        print(f"  {filename}")
+
+
+if __name__ == "__main__":
+    main()