adding prepare data

prepare_data.py

@@ -0,0 +1,441 @@
+import os
+import itertools
+import subprocess
+
+def list_images_in_folder_multi(folder_path, scene_name, output_file=None):
+    """
+    Recursively list all image files in a specified folder and its subdirectories.
+    :param folder_path: Path to the root folder containing images
+    :param scene_name: Name of the current scene
+    :param output_file: Optional path to save the list of images (if None, prints to console)
+    :return: List of image filenames with full relative paths
+    """
+    # List of common image file extensions
+    image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp']
+    
+    # List to store image paths
+    image_files = []
+    
+    # Walk through all directories and subdirectories
+    for root, dirs, files in os.walk(folder_path):
+        # Find image files in current directory
+        current_images = [
+            os.path.relpath(os.path.join(root, file), folder_path)
+            for file in files
+            if os.path.splitext(file)[1].lower() in image_extensions
+        ]
+        
+        # Add current directory's images to the list
+        image_files.extend(current_images)
+    
+    # Sort the image files
+    image_files.sort()
+    
+    # If output file is specified, write to file
+    if output_file:
+        with open(output_file, 'w') as f:
+            for image in image_files:
+                f.write(f"{scene_name}/{image}\n")
+        print(f"Image list saved to {output_file}")
+    
+    # Print some basic information
+    print(f"Total images found: {len(image_files)}")
+    return image_files
+
+
+def get_list_images(base_path):
+    """
+    Retrieve images from all camera subdirectories.
+    :param base_path: Base directory containing camera subdirectories
+    :return: Dictionary of camera names to sorted image lists
+    """
+    camera_images = {}
+    # Find all camera subdirectories
+    for camera_dir in os.listdir(base_path):
+        camera_path = os.path.join(base_path, camera_dir)
+        
+        # Check if it's a directory and starts with 'cam'
+        if os.path.isdir(camera_path) and camera_dir.startswith('cam'):
+            # Get jpg files for this camera
+            image_files = [f for f in os.listdir(camera_path) if f.endswith('.jpg')]
+            camera_images[camera_dir] = sorted(image_files)
+    
+    return camera_images
+
+def generate_image_pairs(camera_images):
+    """
+    Generate image pairs within and across cameras, avoiding pairing an image with itself.
+    :param camera_images: Dictionary of camera names to image lists
+    :return: List of image pair tuples with camera names
+    """
+    image_pairs = []
+    camera_names = list(camera_images.keys())
+    
+    # Generate pairs within each camera
+    for camera, images in camera_images.items():
+        # Pairs within the same camera using combinations
+        camera_pairs = list(itertools.combinations(images, 2))
+        camera_formatted_pairs = [(f"{camera}/{pair[0]}", f"{camera}/{pair[1]}") for pair in camera_pairs]
+        image_pairs.extend(camera_formatted_pairs)
+    
+    # Generate pairs across different cameras
+    for i in range(len(camera_names)):
+        for j in range(i+1, len(camera_names)):
+            cam1, cam2 = camera_names[i], camera_names[j]
+            for img1 in camera_images[cam1]:
+                for img2 in camera_images[cam2]:
+                    image_pairs.append((f"{cam1}/{img1}", f"{cam2}/{img2}"))
+    
+    return image_pairs
+
+def save_pairs_to_file(pairs, output_file, scene_name):
+    """
+    Save image pairs to a text file.
+    :param pairs: List of image pair tuples
+    :param output_file: Path to the output text file
+    :param scene_name: Name of the current scene
+    """
+    with open(output_file, 'w') as f:
+        for pair in pairs:
+            f.write(f"{scene_name}/{pair[0]} {scene_name}/{pair[1]}\n")
+
+# ------------------------------------------------
+# Helper functions for processing individual scenes
+# CROSS PAIRS EXHAUSTIVE
+# ------------------------------------------------
+
+def get_image_range(path, start, end):
+    """
+    Get list of images within a specific range.
+    
+    :param path: Directory path
+    :param start: Start of image range
+    :param end: End of image range
+    :return: Sorted list of images in the specified range
+    """
+    files = []
+    for file in os.listdir(path):
+        if file.endswith('.jpg'):
+            # Extract number from filename
+            try:
+                num = int(''.join(filter(str.isdigit, file)))
+                if start <= num <= end:
+                    files.append(file)
+            except ValueError:
+                continue
+    return sorted(files)
+
+def generate_cross_camera_pairs(images_list1, images_list2):
+    """
+    Generate image pairs between two specific ranges of images.
+    
+    :param images_list1: List of images from first camera range
+    :param images_list2: List of images from second camera range
+    :return: List of image pair tuples
+    """
+    image_pairs = []
+    for img1 in images_list1:
+        for img2 in images_list2:
+            image_pairs.append((img1, img2))
+    
+    return image_pairs
+
+# ------------------------------------------------
+# Helper functions for processing individual scenes
+# PAIRS SEQUENTIALLY
+# ------------------------------------------------
+
+def generate_multi_camera_pairs(camera_images, window_size=20):
+    """
+    Generate image pairs across multiple cameras sequentially.
+    :param camera_images: Dictionary of camera names to image lists
+    :param window_size: Number of images to match before and after each image
+    :return: List of image pair tuples with camera names
+    """
+    # Ensure all cameras have the same number of images
+    max_images = max(len(images) for images in camera_images.values())
+    
+    # Pad shorter camera lists with None to match the longest list
+    for camera, images in camera_images.items():
+        if len(images) < max_images:
+            camera_images[camera] = images + [None] * (max_images - len(images))
+    
+    image_pairs = []
+    
+    # Iterate through image indices
+    for current_index in range(max_images):
+        # Generate pairs for each camera with other cameras
+        for base_camera, base_images in camera_images.items():
+            # Skip if base image is None
+            if base_images[current_index] is None:
+                continue
+            
+            # Generate pairs with images from other cameras in the same time step
+            for target_camera, target_images in camera_images.items():
+                if base_camera == target_camera:
+                    continue
+                
+                # Skip if target image is None
+                if target_images[current_index] is None:
+                    continue
+                
+                # Add current image pair
+                image_pairs.append((f"{base_camera}/{base_images[current_index]}", 
+                                    f"{target_camera}/{target_images[current_index]}"))
+                
+                # Generate pairs within window size for forward and backward directions
+                for i in range(1, window_size + 1):
+                    # Forward window
+                    if current_index + i < max_images:
+                        if base_images[current_index + i] is not None and target_images[current_index + i] is not None:
+                            image_pairs.append((
+                                f"{base_camera}/{base_images[current_index]}", 
+                                f"{target_camera}/{target_images[current_index + i]}"
+                            ))
+                        
+                    # Backward window
+                    if current_index - i >= 0:
+                        if base_images[current_index - i] is not None and target_images[current_index - i] is not None:
+                            image_pairs.append((
+                                f"{base_camera}/{base_images[current_index]}", 
+                                f"{target_camera}/{target_images[current_index - i]}"
+                            ))
+    
+    return image_pairs
+
+
+# Function to count image files in the directory
+def count_images(output_directory):
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff'}
+    return len([
+        f for f in os.listdir(output_directory) 
+        if os.path.isfile(os.path.join(output_directory, f)) and os.path.splitext(f)[1].lower() in image_extensions
+    ])
+
+
+def generate_images(out_dir, scene_name, config):
+
+    # Define the root folder for videos
+    root_video_dir = f"./videos/{scene_name}"
+    
+    camera_correspondances = {
+        "00": "a",
+        "01": "b",
+        "02": "c",
+        "03": "d",
+        "04": "e",
+        "05": "f",
+        "core01": "core",
+    }
+    
+    prev_max_id = 0
+    
+    # Iterate through each folder in the root video directory
+    for folder_name in sorted(os.listdir(root_video_dir)):
+        folder_path = os.path.join(root_video_dir, folder_name)    
+        print(f"Processing folder: {folder_name}")
+    
+        # Check if it's a directory
+        if os.path.isdir(folder_path):
+            # Search for a video file in the folder
+            video_file = None
+            for file_name in os.listdir(folder_path):
+                if file_name.lower().endswith(('.mp4', '.mov', '.avi', '.mkv')):  # Add extensions as needed
+                    video_file = os.path.join(folder_path, file_name)
+                    break
+            
+            if video_file is None:
+                print(f"No video file found in {folder_name}. Skipping...")
+                continue
+    
+            # Create output images directory if it doesn't exist
+            output_images_dir = f"{out_dir}/{scene_name}/cam{folder_name}"
+            os.makedirs(output_images_dir, exist_ok=True)
+            
+            skip_n_frames = config[scene_name]['skip_start_frames']
+    
+            # Construct the ffmpeg command
+            ffmpeg_command = [
+                "ffmpeg",
+                "-hwaccel", "auto",
+                "-ss", f"{skip_n_frames/2}",  # Skip n frames at 2fps (n/2 seconds)
+                "-i", video_file,
+                "-vf", "fps=2,scale=iw:ih",
+                "-q:v", "2",
+                "-start_number", f"{prev_max_id}",
+                f"{output_images_dir}/%06d_{camera_correspondances[folder_name]}.jpg"
+            ]
+    
+            print(f"Running ffmpeg command for folder: {folder_name}")
+            # Run the command
+            try:
+                subprocess.run(ffmpeg_command, 
+                    stdout=subprocess.DEVNULL,  # Suppress stdout
+                    stderr=subprocess.DEVNULL,  # Suppress stderr
+                    check=True
+                    )
+                print(f"Completed processing for folder: {folder_name}")
+    
+            except subprocess.CalledProcessError as e:
+                print(f"Error processing folder {folder_name}: {e}")
+    
+            total_images = count_images(output_images_dir)
+            print(f"Total images extracted: {total_images}")
+            prev_max_id += total_images + 1
+            print(f"Next start number: {prev_max_id}")
+
+def generate_exhaustive_pairs(folder_path, output_file_pairs_exhaustive, scene_name):
+    # Get images from all cameras
+    camera_images = get_list_images(folder_path)
+    
+    # Generate exhaustive list of pairs of images
+    print(f"Generating image pairs for scene: {scene_name}")
+    image_pairs = generate_image_pairs(camera_images)
+    
+    # Save pairs to file
+    save_pairs_to_file(image_pairs, output_file_pairs_exhaustive, scene_name)
+    print(f"Processing completed for scene: {scene_name}")
+
+def process_scene(scene_name, config, out_dir="./images"):
+    """
+    Process a single scene including video extraction and image pair generation
+    :param scene_name: Name of the scene to process
+    :param config: Configuration dictionary containing scene-specific settings
+    """
+    print(f"\n{'='*50}\nProcessing scene: {scene_name}\n{'='*50}")
+    
+    print(f"Generating images for scene: {scene_name}")
+    generate_images(out_dir, scene_name, config)
+    
+    # Generate output files
+    new_folder_path = f"{out_dir}/{scene_name}"
+    output_file_list = f"{out_dir}/{scene_name}/image_list.txt"
+    output_file_pairs_exhaustive = f"{out_dir}/{scene_name}/image_pairs_exhaustive.txt"
+    output_file_pairs_sequential = f"{out_dir}/{scene_name}/image_pairs_sequential.txt"
+        
+    # Write the image list
+    print(f"Generating image list for scene: {scene_name}")
+    list_images_in_folder_multi(new_folder_path, scene_name, output_file_list)
+
+    print(f"Generating exhaustive image pairs for scene: {scene_name}")
+    generate_exhaustive_pairs(new_folder_path, output_file_pairs_exhaustive, scene_name)
+    
+    # Get images from all cameras
+    camera_images = get_list_images(new_folder_path)
+    
+    # # Generate exhaustive list of pairs of images
+    # print(f"Generating image pairs for scene: {scene_name}")
+    # image_pairs = generate_image_pairs(camera_images)
+    
+    # # Save pairs to file
+    # save_pairs_to_file(image_pairs, output_file_pairs_exhaustive, scene_name)
+    # print(f"Processing completed for scene: {scene_name}")
+
+    if(config[scene_name].get('generate_correspondances', False)):
+        src_scene = config.get('src_scene', "campus_core")
+        src_cam = config.get('src_cam', "core01")
+        target_scene = config.get('target_scene', "mid_library")
+
+        # generate cross-camera pairs
+        cam1_path = f"{out_dir}/{src_scene}/{src_cam}"
+        cam2_path = f"{out_dir}/{target_scene}/cam01"
+        output_file = f"{out_dir}/{target_scene}/cross_camera_pairs.txt"
+
+        # Get images in specified ranges
+        cam1_start = config[scene_name]['cam1_start']
+        cam1_end = config[scene_name]['cam1_end']
+        cam2_start = config[scene_name]['cam2_start']
+        cam2_end = config[scene_name]['cam2_end']
+
+        cam1_images = get_image_range(cam1_path, cam1_start, cam1_end)
+        cam2_images = get_image_range(cam2_path, cam2_start, cam2_end)
+
+        # Generate cross-camera image pairs
+        image_pairs = generate_cross_camera_pairs(cam1_images, cam2_images)
+
+        # Save pairs to file
+        save_pairs_to_file(image_pairs, output_file, cam1_prefix=f'{src_scene}/{src_cam}/', cam2_prefix=f'{target_scene}/cam01/')
+
+        # Print statistics
+        print(f"Images from Camera 1 (range {cam1_start}-{cam1_end}): {len(cam1_images)}")
+        print(f"Images from Camera 2 (range {cam2_start}-{cam2_end}): {len(cam2_images)}")
+        print(f"Total cross-camera pairs generated: {len(image_pairs)}")
+        print(f"Pairs saved to: {output_file}")
+
+# Scene configurations
+config = {
+    "campus_core": {
+        'skip_start_frames': 0,
+        'src_scene': "campus_core",
+        'src_cam': "core01",
+        'target_scene': "mid_library",
+        'cam1_start': 0,
+        'cam1_end': 100,
+        'cam2_start': 0,
+        'cam2_end': 100,
+        'generate_correspondances': False,
+    },
+    "campus_entrance": {
+        'skip_start_frames': 0,
+        'cam1_start': 0,
+        'cam1_end': 100,
+        'cam2_start': 0,
+        'cam2_end': 100,
+    },
+    "campus_entrance_2": {
+        'skip_start_frames': 0,
+    },
+    "campus_knowledge_center": {
+        'skip_start_frames': 0,
+    },
+    "campus_nlpr": {
+        'skip_start_frames': 0,
+    },
+    "garden_path": {
+        'skip_start_frames': 0,
+    },
+    "hydro_NLP_connection":{
+        'skip_start_frames': 0,
+        'cam1_start': 1150,
+        'cam1_end': 1170,
+        'cam2_start': 158,
+        'cam2_end': 171,
+    },
+    "knowledge_center_front": {
+        'skip_start_frames': 0,
+    },
+    "library": {
+        'skip_start_frames': 4,
+    },
+    "mid_library": {
+        'skip_start_frames': 20,
+        'cam1_start': 700,
+        'cam1_end': 720,
+        'cam2_start': 118,
+        'cam2_end': 140,
+    },
+    "NLP_boulevard": {
+        'skip_start_frames': 8,
+        'cam1_start': 220,
+        'cam1_end': 240,
+        'cam2_start': 164,
+        'cam2_end': 174,
+    },
+}
+
+# List of scenes to process
+# Process all the scenes
+# scenes_to_process = config.keys()
+
+# or Process a subset of scenes
+# scenes_to_process = ["library", "mid_library", "NLP_boulevard"]
+scenes_to_process = ["campus_core"]
+
+# Process each scene
+for scene in scenes_to_process:
+    if scene in config:
+        process_scene(scene, config)
+    else:
+        print(f"Warning: Scene '{scene}' not found in configuration. Skipping.")
+
+print("All scenes processed successfully!")