刚学Python，从零实现最近邻插值函数的技术疑问

Hey there! Since you're new to Python and tackling your first nearest-neighbor interpolation task, let's break down where your current code might be going off track and fix the core coordinate mapping logic.

First, Let's Recap the Core Idea of Nearest-Neighbor Interpolation #

The key is to map each pixel in the scaled image back to its closest corresponding pixel in the original image, not the other way around. For example:

• If you're scaling a 10x10 image down to 5x5 (scale=0.5), each pixel in the 5x5 image maps to a position in the 10x10 image calculated by dividing the scaled pixel's coordinates by the scale factor.
• We then round that position to the nearest integer to get the original image's pixel value.

Issues in Your Current Code #

1. Coordinate Direction is Reversed: You're generating scaled coordinates first and pulling pixels from the original image, but we need to iterate over the scaled image's pixels and compute their original image counterparts.
2. Incorrect Coordinate Range: Your linspace uses 0.0 to width/height, but original image coordinates go from 0 to width-1/height-1 (since Python uses 0-indexing). This would cause you to access out-of-bounds pixels.
3. Unnecessary Padding: The padding you added complicates coordinate mapping without adding value for basic nearest-neighbor interpolation (we can handle boundaries with clipping instead).
4. Inefficient Pixel Storage: Storing pixels in a list and reconstructing the image adds unnecessary steps and room for error.

Fixed Implementation (Loop Version for Clarity) #

This version uses straightforward loops to make the logic easy to follow:

import numpy as np

def interpolation_nn(image, scale):
    # Preserve the original image data type
    dtype = image.dtype
    height, width = image.shape
    
    # Calculate the size of the scaled image
    scaled_height = int(round(height * scale))
    scaled_width = int(round(width * scale))
    
    # Initialize an empty array for the scaled image
    scaled_image = np.zeros((scaled_height, scaled_width), dtype=dtype)
    
    # Iterate over every pixel in the scaled image
    for i in range(scaled_height):
        for j in range(scaled_width):
            # Reverse the scaling: map scaled coordinates back to original image
            original_y = i / scale
            original_x = j / scale
            
            # Round to get the nearest neighbor pixel in the original image
            nearest_y = round(original_y)
            nearest_x = round(original_x)
            
            # Ensure we don't go out of bounds (clip to valid image indices)
            nearest_y = np.clip(nearest_y, 0, height - 1)
            nearest_x = np.clip(nearest_x, 0, width - 1)
            
            # Assign the original pixel value to the scaled image
            scaled_image[i, j] = image[nearest_y, nearest_x]
    
    return scaled_image

Optimized Version (Numpy Vectorization) #

For better performance (especially with large images), we can use numpy's vectorized operations instead of loops. This does the same logic but in bulk:

import numpy as np

def interpolation_nn(image, scale):
    dtype = image.dtype
    height, width = image.shape
    
    scaled_height = int(round(height * scale))
    scaled_width = int(round(width * scale))
    
    # Generate a grid of coordinates for the scaled image
    scaled_y, scaled_x = np.meshgrid(np.arange(scaled_height), np.arange(scaled_width), indexing='ij')
    
    # Map scaled coordinates back to original image and find nearest neighbors
    original_y = scaled_y / scale
    original_x = scaled_x / scale
    nearest_y = np.round(original_y).astype(int)
    nearest_x = np.round(original_x).astype(int)
    
    # Clip coordinates to stay within the original image's bounds
    nearest_y = np.clip(nearest_y, 0, height - 1)
    nearest_x = np.clip(nearest_x, 0, width - 1)
    
    # Extract pixel values from the original image using the nearest neighbor indices
    scaled_image = image[nearest_y, nearest_x].astype(dtype)
    
    return scaled_image

Key Improvements Explained #

• Direct Coordinate Mapping: We start with the scaled image's pixels and calculate their original image positions, which aligns with how interpolation works.
• Boundary Safety: np.clip ensures we never try to access pixels outside the original image's dimensions, preventing index errors.
• Simplified Logic: Removed unnecessary padding and pixel list storage to make the code easier to read and debug.

Since you're just starting out, the loop version is perfect for understanding each step, while the vectorized version is a great way to learn how numpy can speed up operations once you're comfortable with the basics.

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