import os import json 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. Also generates pairs within the same camera if only one camera is present. :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 other cameras for target_camera, target_images in camera_images.items(): # Skip self-pairing at the same index (would create identical pairs) if base_camera == target_camera and current_index == current_index: # But still generate pairs for same camera at different timestamps # if there's only one camera if len(camera_images) == 1: # 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 and base_images[current_index + i] is not None: image_pairs.append(( f"{base_camera}/{base_images[current_index]}", f"{base_camera}/{base_images[current_index + i]}" )) # Backward window if current_index - i >= 0 and base_images[current_index - i] is not None: image_pairs.append(( f"{base_camera}/{base_images[current_index]}", f"{base_camera}/{base_images[current_index - i]}" )) continue # Skip if target image is None if target_images[current_index] is None: continue # Add current image pair (from different cameras) 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 get_video_duration(video_path): result = subprocess.run([ "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "json", video_path ], stdout=subprocess.PIPE) duration = float(json.loads(result.stdout)["format"]["duration"]) return duration 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) duration = get_video_duration(video_file) skip_start = config[scene_name].get('skip_start_seconds', 0) skip_end = config[scene_name].get('skip_end_seconds', 0) duration_to_keep = duration - skip_start - skip_end # Construct the ffmpeg command # ffmpeg_command = [ # "ffmpeg", # "-hwaccel", "auto", # "-ss", f"{skip_start_seconds}", # 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" # ] # Build ffmpeg command ffmpeg_command = [ "ffmpeg", "-hwaccel", "auto", "-ss", f"{skip_start}", "-i", video_file, "-t", f"{duration_to_keep}", "-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 generate_sequential_pairs(folder_path, output_file_pairs_sequential, scene_name, window_size=20): # Get images from all cameras camera_images = get_list_images(folder_path) print(camera_images) # Generate exhaustive list of pairs of images print(f"Generating image pairs for scene: {scene_name}") images_pairs_sequential = generate_multi_camera_pairs(camera_images, window_size) # Save pairs to file save_pairs_to_file(images_pairs_sequential, output_file_pairs_sequential, scene) 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}") if(os.path.exists(f"{out_dir}/{scene_name}")): print(f"Images already generated for scene: {scene_name}") else: 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) print(f"Generating sequential image pairs for scene: {scene_name}") generate_sequential_pairs(new_folder_path, output_file_pairs_sequential, \ scene_name, config[scene_name].get('window_size', 20)) # 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_seconds': 5, 'skip_end_seconds': 20, '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, 'window_size': 10, }, "campus_entrance": { 'skip_start_seconds': 0, 'cam1_start': 0, 'cam1_end': 100, 'cam2_start': 0, 'cam2_end': 100, }, "campus_entrance_2": { 'skip_start_seconds': 3, 'skip_end_seconds': 0, }, "campus_knowledge_center": { 'skip_start_seconds': 0, 'skip_end_seconds': 0, }, "campus_nlp": { 'skip_start_seconds': 0, 'skip_end_seconds': 0, }, "garden_path": { 'skip_start_seconds': 5, 'skip_end_seconds': 0, }, "hydro_NLP_connection":{ 'skip_start_seconds': 6, 'skip_end_seconds': 7, 'cam1_start': 1150, 'cam1_end': 1170, 'cam2_start': 158, 'cam2_end': 171, }, "knowledge_center_front": { 'skip_start_seconds': 8, 'skip_end_seconds': 0, }, "library": { 'skip_start_seconds': 4, 'skip_end_seconds': 0, }, "mid_library": { 'skip_start_seconds': 3, 'skip_end_seconds': 0, 'cam1_start': 700, 'cam1_end': 720, 'cam2_start': 118, 'cam2_end': 140, }, "NLP_boulevard": { 'skip_start_seconds': 6, 'skip_end_seconds': 0, '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!") # find . -type f -name '._*.MP4' -delete