手动实现28*28 Numpy数组图像45度顺时针旋转遇问题求解

Let's break down exactly what's wrong with your current code, then walk through fixes tailored to your two stated goals—either implementing a standard 45-degree clockwise image rotation (great for linear algebra practice) or building that custom transformation you described for the 2x2 identity matrix.

What's Wrong With Your Current Code? #

Your approach doesn't align with any kind of 45-degree transformation, and here's why:

• Incorrect core logic: Right now, you're just summing each pixel with its horizontal mirror in the same row (image[i,j] + image[i, W-j-1]). For the 2x2 identity matrix, this would spit out a matrix of all 1s—nothing like your target [[1,-1],[-1,1]].
• No coordinate transformation: Any affine transformation (like rotation) relies on mapping pixel coordinates from the original image to the new one using linear algebra. Your code doesn't touch this foundational step.
• Missing sign handling: Your target matrix includes negative values, but your code only sums non-negative elements (assuming your image data is typical pixel values, which are 0-255). It can never produce negatives.

Fix Option 1: Standard 45-Degree Clockwise Image Rotation #

If you want to rotate your 28x28 image the way image editors do, you'll need to use the rotation matrix and handle coordinate translation (since rotating shifts pixels into negative indices, which we need to fix to keep the image intact). Here's a numpy implementation:

import numpy as np

def rotate_45_clockwise(image):
    H, W = image.shape
    theta = np.radians(-45)  # Negative angle for clockwise rotation
    cos_theta, sin_theta = np.cos(theta), np.sin(theta)
    
    # Rotation matrix adjusted for image coordinates (y-axis points downward)
    rotation_matrix = np.array([[cos_theta, sin_theta],
                                [-sin_theta, cos_theta]])
    
    # Calculate bounds of the rotated image by transforming all four corners
    corners = np.array([[0, 0], [W-1, 0], [0, H-1], [W-1, H-1]])
    rotated_corners = corners @ rotation_matrix.T
    
    # Compute new image dimensions and offset to shift all coordinates to positive indices
    min_x, min_y = rotated_corners.min(axis=0)
    max_x, max_y = rotated_corners.max(axis=0)
    new_W = int(np.ceil(max_x - min_x)) + 1
    new_H = int(np.ceil(max_y - min_y)) + 1
    offset = np.array([-min_x, -min_y])
    
    # Initialize output image
    rotated_image = np.zeros((new_H, new_W), dtype=image.dtype)
    
    # Map each pixel in the rotated image back to the original image
    for y_new in range(new_H):
        for x_new in range(new_W):
            # Reverse the rotation to find original coordinates
            x_orig, y_orig = (np.array([x_new, y_new]) - offset) @ np.linalg.inv(rotation_matrix)
            
            # Use nearest-neighbor interpolation if coordinates are within bounds
            if 0 <= x_orig < W and 0 <= y_orig < H:
                x_orig_int = int(np.round(x_orig))
                y_orig_int = int(np.round(y_orig))
                rotated_image[y_new, x_new] = image[y_orig_int, x_orig_int]
    
    return rotated_image

Fix Option 2: Custom Transformation for the 2x2 Identity Matrix #

If your goal is specifically to turn the identity matrix [[1,0],[0,1]] into [[1,-1],[-1,1]], we first formalize the mathematical rule for this custom transformation. Looking at the target matrix:

• Diagonal elements match the original identity's diagonal
• Off-diagonal elements are the negative of the opposite diagonal element

Here's a numpy implementation that generalizes this to square matrices (like your 28x28 image):

import numpy as np

def custom_45_transform(image):
    H, W = image.shape
    assert H == W, "This custom transformation requires a square input matrix"
    res = np.zeros_like(image, dtype=np.float32)  # Use float to support negative values
    
    for i in range(H):
        for j in range(W):
            if i == j:
                res[i,j] = image[i,i]
            else:
                res[i,j] = -image[j,j]
    
    return res

Testing this with the identity matrix gives exactly your target:

I = np.array([[1,0],[0,1]])
print(custom_45_transform(I))
# Output: [[ 1. -1.]
#          [-1.  1.]]

Key Takeaways for Linear Algebra Practice #

• For geometric transformations like rotation, always start with the rotation matrix and coordinate mapping. Don't forget to adjust for image-specific coordinate systems (where the y-axis points downward).
• When defining custom transformations, first write down the mathematical rule for element mapping before coding—this avoids guessing logic that doesn't align with your goal.

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