128x128灰度图像4x4非重叠块分割、像素坐标存储及均值计算求助

Absolutely, loops are the perfect solution here—manually defining 16,384 pixel variables would be tedious and error-prone! Let’s walk through how to implement this efficiently using Python (the standard tool for image processing tasks like this).

Step 1: Load and Prepare Your Image #

First, we’ll load your 128x128 grayscale image and convert it into a numpy array (this makes pixel and block operations much easier):

from PIL import Image
import numpy as np

# Load your image (replace "your_image.png" with your actual file path)
img = Image.open("your_image.png").convert("L")  # "L" converts to grayscale
img_array = np.array(img)  # Converts image to a 128x128 numpy array

Step 2: Generate Pixel Variables with Coordinates #

You can dynamically create variables like pixel1=(x,y), pixel2=(x,y), etc., using a nested loop. However, dynamic global variables can clutter your namespace, so I’ll show both the variable approach and a cleaner dictionary alternative:

Option 1: Dynamic Pixel Variables #

pixel_count = 0
# Iterate over each pixel's y and x coordinates
for y in range(img_array.shape[0]):
    for x in range(img_array.shape[1]):
        pixel_count += 1
        # Create a global variable like pixel1, pixel2, ..., pixel16384
        globals()[f"pixel{pixel_count}"] = (x, y)
        # Optional: Store pixel value too, e.g., (x, y, img_array[y][x])

Option 2: Dictionary (Recommended) #

This keeps your pixels organized and easy to access without polluting the global scope:

pixels_dict = {}
pixel_count = 0
for y in range(img_array.shape[0]):
    for x in range(img_array.shape[1]):
        pixel_count += 1
        pixels_dict[f"pixel{pixel_count}"] = (x, y)

# Access pixels like this: pixels_dict["pixel1"] returns (0, 0)

Step 3: Calculate 4x4 Block Means #

Your 128x128 image splits into 32x32 = 1024 non-overlapping 4x4 blocks. Again, we can use numpy for fast calculations, or a manual loop for clarity.

Option 1: Numpy (Fast & Efficient) #

Numpy’s reshape and mean functions handle block operations in seconds:

block_size = 4
# Reshape the image array into a grid of 4x4 blocks
blocks = img_array.reshape(
    img_array.shape[0] // block_size, block_size,
    img_array.shape[1] // block_size, block_size
)
# Compute mean for each block (averages across the 4x4 pixel dimensions)
block_means = blocks.mean(axis=(1, 3))

# Optional: Create variables like Average_of_block1, Average_of_block2, etc.
mean_count = 0
for i in range(block_means.shape[0]):
    for j in range(block_means.shape[1]):
        mean_count += 1
        globals()[f"Average_of_block{mean_count}"] = block_means[i][j]

# Recommended: Store means in a dictionary
block_means_dict = {}
mean_count = 0
for i in range(block_means.shape[0]):
    for j in range(block_means.shape[1]):
        mean_count += 1
        block_means_dict[f"Average_of_block{mean_count}"] = block_means[i][j]

Option 2: Manual Loop (For Understanding) #

If you want to see exactly how each block is processed:

block_size = 4
num_blocks_y = img_array.shape[0] // block_size
num_blocks_x = img_array.shape[1] // block_size

block_means_dict = {}
mean_count = 0

for i in range(num_blocks_y):
    for j in range(num_blocks_x):
        mean_count += 1
        # Extract the 4x4 block from the image array
        block = img_array[
            i*block_size : (i+1)*block_size,
            j*block_size : (j+1)*block_size
        ]
        # Calculate the mean of the block
        block_mean = block.mean()
        # Store in dictionary
        block_means_dict[f"Average_of_block{mean_count}"] = block_mean

Key Recommendations #

• Avoid dynamic global variables: Dictionaries or lists are far easier to debug and manage, especially when working with thousands of items.
• Use numpy for performance: Numpy’s vectorized operations are exponentially faster than pure Python loops for large images.
• Link pixels to blocks (optional): If you need to track which block each pixel belongs to, modify the pixel storage to include the block ID:

  pixels_dict[f"pixel{pixel_count}"] = (x, y, mean_count)  # mean_count is the block number for this pixel
  

内容的提问来源于stack exchange，提问作者Hero31