cv2.resize()无法适配(y,x)矩阵的问题及HD相机校准后坐标网格跨宽高比缩放方案咨询

Hey there, let's break down your issues and fix this coordinate grid generation step by step.

1. Did you misuse cv2.resize()? #

Yes, you did—but it's an easy mistake to make! Here's why:
Your undist_grid contains raw camera coordinates (y,x) for each pixel in the 1280x720 corrected view. When you run cv2.resize(undist_grid, (320,240)), you're treating these coordinate values like image pixel data and scaling them numerically. That's not what you want—you need to map each target pixel (in 640x480) back to its corresponding position in the original undistorted 1280x720 view, not shrink the coordinate values themselves.

2. Is there a better way to generate (y,x) coordinates from the undistorted camera view? #

Absolutely! Instead of starting with the 1280x720 grid, start from your target 640x480 grid and map each target pixel back to the original undistorted camera coordinates (then reverse the undistortion to get raw camera positions for Flash). This approach is more intuitive and avoids scaling errors.

The key insight is: Flash needs to know, for every pixel in its 640x480 output, which pixel to sample from the raw 1280x720 camera feed. So we need to:

• Create a grid for the 640x480 target size
• Map each target pixel to its corresponding position in the undistorted 1280x720 view (handling non-uniform scaling)
• Apply the inverse undistortion to get the raw camera coordinates (since cv2.undistort() goes from distorted → undistorted; we need undistorted → distorted for raw positions)

3. How to correctly implement 1280x720 → 640x480 scaling in the naive approach? #

Non-uniform scaling means we calculate separate scaling factors for x and y axes:

• X-axis: 1280 → 640 → scaling factor = 1280 / 640 = 2 (target x maps to undistorted x = target_x * 2)
• Y-axis: 720 → 480 → scaling factor = 720 / 480 = 1.5 (target y maps to undistorted y = target_y * 1.5)

Your naive approach was using integer division and skipping pixels, which caused sampling errors. Instead, we need to compute exact floating-point positions (then we can round or interpolate if needed, though for coordinate mapping, exact values are better).

Here's a revised approach that fixes all these issues:

import numpy as np
import cv2

def generate_target_grid(target_rows, target_cols):
    """Generate grid of (y,x) coordinates for the target 640x480 size"""
    yy, xx = np.meshgrid(np.arange(target_rows, dtype=np.float32), 
                         np.arange(target_cols, dtype=np.float32),
                         indexing='ij')
    return np.dstack([yy, xx])

camera_size = (1280, 720)  # (width, height)
target_size = (640, 480)   # (width, height)

# Step 1: Generate target 640x480 grid
target_grid = generate_target_grid(target_size[1], target_size[0])

# Step 2: Map target grid to undistorted 1280x720 coordinates (non-uniform scaling)
# Scaling factors: x = target_x * (camera_width / target_width), y = target_y * (camera_height / target_height)
scale_x = camera_size[0] / target_size[0]
scale_y = camera_size[1] / target_size[1]
undistorted_coords = target_grid.copy()
undistorted_coords[..., 1] *= scale_x  # x coordinate scaling
undistorted_coords[..., 0] *= scale_y  # y coordinate scaling

# Step 3: Apply inverse undistortion to get raw camera coordinates
# cv2.undistortPoints takes (x,y) points, so we need to reshape first
points = undistorted_coords.reshape(-1, 1, 2)  # shape (N,1,2) where N=640*480
raw_camera_points = cv2.undistortPoints(points, camera_matrix, dist_coeffs, None, camera_matrix)

# Step 4: Reshape back to 640x480 grid (y,x) format
raw_grid = raw_camera_points.reshape(target_size[1], target_size[0], 2)
# Convert to uint16 since your original code uses this dtype
raw_grid = raw_grid.astype(np.uint16)

# Step 5: Apply perspective transform if needed (match your original code)
transformed_grid = cv2.warpPerspective(raw_grid, transformed_matrix, target_size)

# Step 6: Write to binary file
with open(path_to_binary_file, "wb") as binary_file:
    num_bytes_written = binary_file.write(transformed_grid)
    print(transformed_grid.shape)
    print(f"Wrote {num_bytes_written} bytes.")

Key Improvements: #

• We start from the target size, ensuring every 640x480 pixel has a corresponding raw camera coordinate
• Non-uniform scaling is calculated precisely using floating-point factors, no pixel skipping
• Uses cv2.undistortPoints (the correct function for point-based undistortion) instead of cv2.undistort (which is for images)
• Maintains proper coordinate order (y,x) as required by your FlashPlayer integration

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