Following this instruction : 1. Strictly adhere to PEP-8 standards, ensuring code is…
- User
Following this instruction :
- Strictly adhere to PEP-8 standards, ensuring code is clean, well-structured, and follows Python's style guide for readability.
- Use appropriate modules like
typingfor type hints, ensuring code clarity, maintainability, and leveraging Python's standard libraries effectively. - Focus on time, space, robustness, scalability; write optimized, efficient code that can handle large datasets and scale seamlessly.
- Implement comprehensive error handling, catching exceptions gracefully, providing meaningful error messages, and ensuring code robustness under unexpected conditions.
- Ensure the developer agent writes advanced, maintainable Python code, balancing performance and readability while adhering to best practices.
TASK : Create a script that efficiently processes a folder containing hundreds to thousands of images, generating an N x N grid of images where N is specified as n/2. Utilize the Plotly module to create a visual representation of these images, saving the output in .png format. Ensure that each image is resized to a small dimension to optimize loading speed, aiming for a total processing and saving time of less than 2 seconds. Implement techniques for rapid image loading and manipulation to achieve this goal, including efficient file handling and reduced image resolution without compromising clarity. The final output should be a high-quality grid image that represents the selected subset of images while ensuring minimal loading time, allowing for quick display and interaction. Each processed image should maintain a consistent aspect ratio to fit seamlessly within the grid layout.
- Assistant
Certainly! Below is a Python script that efficiently processes a folder containing a large number of images to generate an N x N grid using Plotly. The script adheres to PEP-8 standards, utilizes type hints for clarity, and includes comprehensive error handling. It leverages concurrent processing to optimize performance, aiming to keep the total processing and saving time under 2 seconds for reasonable values of N (e.g., N=10).
Key Features:
- PEP-8 Compliance: The code follows Python's style guide for readability and maintainability.
- Type Hints: Utilizes the
typingmodule for clear function signatures. - Efficiency: Employs
ThreadPoolExecutorfor concurrent image loading and resizing. - Error Handling: Catches and reports errors gracefully, ensuring robustness.
- Scalability: Optimized to handle large datasets by processing only the required subset of images.
Prerequisites:
- Install the required libraries using pip:
pip install pillow plotly
Script:
import os import sys import math import time from typing import List, Tuple from concurrent.futures import ThreadPoolExecutor, as_completed from PIL import Image import plotly.graph_objects as go from plotly.subplots import make_subplots def get_image_paths(folder_path: str) -> List[str]: """ Retrieve a list of image file paths from the specified folder. Args: folder_path (str): Path to the image folder. Returns: List[str]: List of image file paths. """ supported_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.gif', '.tiff') try: files = [ os.path.join(folder_path, file) for file in os.listdir(folder_path) if file.lower().endswith(supported_extensions) ] if not files: raise ValueError("No supported image files found in the provided folder.") return files except FileNotFoundError: raise FileNotFoundError(f"The folder '{folder_path}' does not exist.") except Exception as e: raise e def select_images(image_paths: List[str], grid_size: int) -> List[str]: """ Select a subset of images to fit into the grid. Args: image_paths (List[str]): List of available image file paths. grid_size (int): Number of images per row and column. Returns: List[str]: Selected image file paths. """ required = grid_size * grid_size if len(image_paths) < required: raise ValueError( f"Not enough images to fill a {grid_size}x{grid_size} grid. " f"Required: {required}, Available: {len(image_paths)}" ) return image_paths[:required] def resize_image(image_path: str, size: Tuple[int, int]) -> Image.Image: """ Open and resize an image while maintaining aspect ratio. Args: image_path (str): Path to the image file. size (Tuple[int, int]): Desired size as (width, height). Returns: Image.Image: Resized PIL Image object. """ try: with Image.open(image_path) as img: img.thumbnail(size, Image.ANTIALIAS) return img.copy() except Exception as e: raise IOError(f"Error processing image '{image_path}': {e}") def process_images(image_paths: List[str], thumb_size: Tuple[int, int]) -> List[Image.Image]: """ Concurrently load and resize images. Args: image_paths (List[str]): List of image file paths. thumb_size (Tuple[int, int]): Desired thumbnail size. Returns: List[Image.Image]: List of resized PIL Image objects. """ resized_images = [] with ThreadPoolExecutor() as executor: future_to_path = { executor.submit(resize_image, path, thumb_size): path for path in image_paths } for future in as_completed(future_to_path): path = future_to_path[future] try: img = future.result() resized_images.append(img) except Exception as exc: print(exc, file=sys.stderr) if not resized_images: raise ValueError("No images were successfully processed.") return resized_images def create_image_grid(images: List[Image.Image], grid_size: int) -> go.Figure: """ Create a Plotly figure with a grid of images. Args: images (List[Image.Image]): List of PIL Image objects. grid_size (int): Number of images per row and column. Returns: go.Figure: Plotly figure containing the image grid. """ try: fig = make_subplots( rows=grid_size, cols=grid_size, horizontal_spacing=0.01, vertical_spacing=0.01, shared_xaxes=True, shared_yaxes=True ) for idx, img in enumerate(images): row = (idx // grid_size) + 1 col = (idx % grid_size) + 1 # Convert PIL Image to PNG bytes img_bytes = img_to_bytes(img) fig.add_layout_image( dict( source=img_bytes, xref=f"x{col}", yref=f"y{row}", x=0, y=1, sizex=1, sizey=1, sizing="stretch", layer="below" ) ) # Hide axes fig.update_xaxes(showgrid=False, zeroline=False, visible=False, row=row, col=col) fig.update_yaxes(showgrid=False, zeroline=False, visible=False, row=row, col=col) fig.update_layout( width=grid_size * 100, height=grid_size * 100, margin=dict(l=0, r=0, t=0, b=0) ) return fig except Exception as e: raise RuntimeError(f"Failed to create image grid: {e}") def img_to_bytes(img: Image.Image) -> str: """ Convert a PIL Image to a base64-encoded PNG. Args: img (Image.Image): PIL Image object. Returns: str: Base64-encoded image string. """ from io import BytesIO import base64 buffered = BytesIO() img.save(buffered, format="PNG") img_str = base64.b64encode(buffered.getvalue()).decode() return f"data:image/png;base64,{img_str}" def save_figure(fig: go.Figure, output_path: str) -> None: """ Save the Plotly figure as a PNG file. Args: fig (go.Figure): Plotly figure to save. output_path (str): Path to save the PNG file. """ try: fig.write_image(output_path, format='png') except Exception as e: raise IOError(f"Failed to save figure to '{output_path}': {e}") def generate_image_grid( folder_path: str, n: int, output_path: str, thumb_size: Tuple[int, int] = (50, 50) ) -> None: """ Generate an N x N image grid from images in a folder and save as PNG. Args: folder_path (str): Path to the folder containing images. n (int): Size parameter where grid_size = n // 2. output_path (str): Path to save the output grid image. thumb_size (Tuple[int, int], optional): Thumbnail size. Defaults to (50, 50). """ start_time = time.time() try: image_paths = get_image_paths(folder_path) grid_size = n // 2 selected_paths = select_images(image_paths, grid_size) images = process_images(selected_paths, thumb_size) fig = create_image_grid(images, grid_size) save_figure(fig, output_path) end_time = time.time() elapsed = end_time - start_time if elapsed > 2: print(f"Warning: Processing took {elapsed:.2f} seconds, which exceeds the 2-second goal.", file=sys.stderr) else: print(f"Image grid saved to '{output_path}' in {elapsed:.2f} seconds.") except Exception as e: print(f"Error: {e}", file=sys.stderr) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description="Generate an N x N image grid from a folder of images.") parser.add_argument("folder_path", type=str, help="Path to the folder containing images.") parser.add_argument("n", type=int, help="Size parameter for grid (grid_size = n // 2).") parser.add_argument("output_path", type=str, help="Path to save the output PNG image.") args = parser.parse_args() generate_image_grid(args.folder_path, args.n, args.output_path)Usage:
-
Save the script to a file, e.g.,
image_grid.py. -
Run the script from the command line:
python image_grid.py /path/to/image_folder 20 output_grid.png/path/to/image_folder: Directory containing your images.20: Thenparameter; the grid size will ben // 2, resulting in a10 x 10grid.output_grid.png: Desired output file path.
Notes:
- Thumbnail Size: The
thumb_sizeparameter controls the size of each thumbnail. Adjusting this can help optimize performance and clarity. - Processing Time: For large values of
n, especially whengrid_size = n // 2results in a large number of images, the processing time may exceed 2 seconds. Adjustnaccordingly based on your performance requirements and system capabilities. - Error Messages: The script provides meaningful error messages for common issues, such as missing folders, insufficient images, or file processing errors.
- Dependencies: Ensure that the
PillowandPlotlylibraries are installed in your Python environment.
This script provides a balance between performance and readability, adhering to best practices for maintainable and efficient Python code.