如何用Python ndimage generic_filter实现2D图像热像素去除的条件逻辑

Got it, let's work through this hot pixel removal function together. The key issue you're hitting is figuring out how to calculate the neighborhood mean/std without including the current pixel (which is what your placeholder origin was meant to handle). Here's a straightforward, numpy-based solution that addresses exactly that:

Step-by-Step Solution #

First, let's clarify the core logic:

• For each pixel, grab its surrounding neighborhood (we'll use a 3x3 kernel by default, but it's adjustable)
• Exclude the current pixel from that neighborhood to avoid skewing the mean/std with the hot pixel itself
• Check if the current pixel deviates more than 3σ from the neighborhood mean
• If yes, replace it with the neighborhood mean

Complete Working Code #

import numpy as np

def remove_hot_pixels(image, kernel_size=3, sigma_threshold=3):
    # Get image dimensions
    h, w = image.shape
    # Calculate half the kernel size (only works with odd kernel sizes)
    half_kernel = kernel_size // 2
    # Create a copy of the original image to modify (so we don't overwrite input)
    cleaned_image = image.copy()
    
    # Loop through pixels, skipping edges to avoid out-of-bounds errors
    for i in range(half_kernel, h - half_kernel):
        for j in range(half_kernel, w - half_kernel):
            # Extract the full neighborhood around the current pixel
            neighborhood = image[i-half_kernel:i+half_kernel+1, j-half_kernel:j+half_kernel+1]
            
            # Flatten the neighborhood and remove the current pixel (the center element)
            flat_neighborhood = neighborhood.flatten()
            # The center index of a flattened kernel is (kernel_size * half_kernel) + half_kernel
            neighborhood_no_current = np.delete(flat_neighborhood, kernel_size * half_kernel + half_kernel)
            
            # Calculate mean and standard deviation of the cleaned neighborhood
            neighbor_mean = np.mean(neighborhood_no_current)
            neighbor_std = np.std(neighborhood_no_current)
            
            # Check if current pixel is a hot pixel
            current_pixel = image[i, j]
            if abs(current_pixel - neighbor_mean) > sigma_threshold * neighbor_std:
                # Replace hot pixel with neighborhood mean
                cleaned_image[i, j] = neighbor_mean
    
    return cleaned_image

Key Fixes & Explanations #

• No more origin placeholder: Instead of passing the current pixel value, we directly remove it from the neighborhood array using np.delete. For a 3x3 kernel, the center element is at index 4 (since 3*1 +1 =4), which works for any odd-sized kernel.
• Edge handling: We skip the outermost pixels (equal to half the kernel size) to avoid trying to grab a neighborhood that goes outside the image bounds. If you need to process edges too, you can add padding to the image first (e.g., np.pad(image, half_kernel, mode='reflect')) and adjust the loop to cover all pixels.
• Non-destructive modification: We work on a copy of the input image so we don't alter the original data.

Test It Out #

Here's a quick example to see it in action:

# Test image with a clear hot pixel (the 100 in the center)
test_img = np.array([
    [10, 12, 11, 13],
    [12, 100, 11, 12],
    [11, 13, 12, 14],
    [12, 11, 13, 12]
])

# Run the function
fixed_img = remove_hot_pixels(test_img)

print("Original Image:")
print(test_img)
print("\nCleaned Image:")
print(fixed_img)

You'll see the 100 gets replaced with the mean of its surrounding pixels (11.875), which is exactly what we want.

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