800x600灰度图像批量处理技术问询：最大值图生成与像素归一化

Hey there! Let's build on your existing code using Pillow (for image I/O) and NumPy (for efficient matrix operations) — these tools will eliminate the need for slow nested loops and make your task straightforward.

Step 1: Install Required Libraries #

First, make sure you have the necessary packages installed:

pip install pillow numpy

Step 2: Load Selected Images & Compute the Max Pixel Image #

Here's how to read your 50 random images into a NumPy array and calculate the per-pixel maximum across all selected images:

from random import seed, sample
from PIL import Image
import numpy as np

# Your existing code to select 50 random images
seed(1)
sequence = list(range(1000))
subset = sample(sequence, 50)
print("Chosen 50 random images: ", subset)

# Initialize list to store image data as NumPy arrays
image_arrays = []

# Load each selected image (update the path pattern to match your files!)
for img_idx in subset:
    # Replace with your actual image file path (e.g., "images/img_{img_idx}.png")
    img_path = f"path/to/your/images/image_{img_idx}.png"
    # Open image in grayscale mode ('L' converts to 8-bit grayscale)
    img = Image.open(img_path).convert('L')
    # Convert to NumPy array (shape: (600, 800) since images are 800x600 width/height)
    img_array = np.array(img)
    image_arrays.append(img_array)

# Stack all 50 images into a 3D array (shape: 50 images × 600 rows × 800 columns)
stacked_images = np.stack(image_arrays, axis=0)

# Compute per-pixel maximum across all 50 images
max_image = np.max(stacked_images, axis=0)

# Add a tiny epsilon to avoid division by zero (in case all 50 images have 0 in a pixel)
epsilon = 1e-8
max_image = max_image + epsilon

Step 3: Normalize All 1000 Images #

Now loop through every image, normalize it using the max pixel values, and save the result:

# Process all 1000 images
for img_idx in range(1000):
    # Load original image
    img_path = f"path/to/your/images/image_{img_idx}.png"
    img = Image.open(img_path).convert('L')
    img_array = np.array(img)
    
    # Apply normalization: (pixel_value / max_pixel) * 255
    normalized_array = (img_array / max_image) * 255
    
    # Convert back to 8-bit integer (required for valid image output)
    normalized_array = normalized_array.astype(np.uint8)
    
    # Save the normalized image (update output path as needed)
    normalized_img = Image.fromarray(normalized_array)
    normalized_img.save(f"path/to/normalized/output/normalized_img_{img_idx}.png")

Key Notes to Keep in Mind: #

• File Paths: Replace the placeholder paths (path/to/your/images/) with your actual directory structure, and adjust the filename pattern to match how your images are named.
• Efficiency: NumPy's vectorized operations are way faster than nested loops — this will save you hours of processing time with 1000 images.
• Division by Zero: The epsilon value ensures you never divide by zero, which could happen if all 50 selected images have a pixel value of 0 at a specific position.
• Alternative with OpenCV: If you prefer using OpenCV instead of Pillow, swap out the image loading/saving steps with cv2.imread(img_path, cv2.IMREAD_GRAYSCALE) and cv2.imwrite(...) — the NumPy operations stay identical.

Content of the question is sourced from Stack Exchange, asked by Tommy