基于OpenCV Python的立体视觉测距：视差图应用及优化咨询

Hey there! You’ve already nailed the tricky parts of stereo vision—calibration and rectification—so let’s work through the remaining hurdles step by step.

1. What Exactly is a Disparity Matrix/Map? #

A disparity map is a 2D array where each pixel value represents the horizontal pixel difference (disparity) between the corresponding pixel in the left and right rectified images. Here’s what you need to know:

• Disparity is inversely proportional to distance: closer objects have larger disparity values, while farther objects have smaller (or zero) disparity.
• Invalid regions (like areas occluded in one camera, or pixels with no valid match) will typically have a value of 0 or a negative number (depending on the stereo matching algorithm you use).
• For OpenCV’s StereoSGBM (one of the most common algorithms), the output is a 16-bit signed integer matrix (CV_16S). To get the actual floating-point disparity values, you need to divide by 16:

  disparity = disparity.astype(np.float32) / 16.0
  

2. Calculating Object Distance from Disparity #

The core formula linking disparity to real-world distance comes from stereo geometry:

( Z = \frac{f \times B}{d} )
Where:

• ( Z ): Distance from the camera to the object (units match your baseline, e.g., mm, cm)
• ( f ): Focal length of the camera (in pixels, from your calibration results—look at the [0][0] value of the left camera’s intrinsic matrix)
• ( B ): Baseline (the physical distance between the optical centers of your left and right cameras, measured in real-world units like mm)
• ( d ): Disparity value of the target pixel (in pixels)

Step-by-Step Implementation (Python/OpenCV) #

import numpy as np
import cv2

# Load your calibration parameters (from stereo calibration)
left_intrinsics = np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1]])
baseline = 120.0  # Example: 120mm between camera centers (measure this!)

# Load and process the disparity map
disparity = cv2.imread("disparity_map.png", cv2.IMREAD_UNCHANGED)
# Convert to floating-point disparity values
disparity = disparity.astype(np.float32) / 16.0

# Calculate depth map (ignore invalid disparity values)
depth_map = np.zeros_like(disparity)
valid_mask = disparity > 0  # Skip pixels with no valid match
depth_map[valid_mask] = (left_intrinsics[0][0] * baseline) / disparity[valid_mask]

# Get distance for a specific pixel (e.g., (x=400, y=300))
target_x, target_y = 400, 300
if disparity[target_y, target_x] > 0:
    object_distance = (left_intrinsics[0][0] * baseline) / disparity[target_y, target_x]
    print(f"Distance to object at ({target_x}, {target_y}): {object_distance:.2f} mm")

Key Notes: #

• Make sure your baseline is measured accurately—even a small error here will throw off distance calculations.
• If you used stereo calibration, the baseline is the absolute value of the X-component in the translation vector between the two cameras.

3. Optimizing Your Disparity Map #

If your disparity map is noisy or lacks detail, tweak these critical parameters in OpenCV’s StereoSGBM (the most robust built-in algorithm):

• numDisparities: Must be a multiple of 16. Larger values let you detect farther objects but increase computation time and noise. Start with 32 or 64.
• blockSize: Odd integer (3, 5, 7, 9). Smaller blocks preserve detail but introduce noise; larger blocks smooth noise but lose fine details.
• P1 & P2: Smoothness penalties. P2 should be 2-4x P1. Use these defaults as a starting point:

  P1 = 8 * 3 * blockSize**2
  P2 = 32 * 3 * blockSize**2
  

  Increase P2 to reduce noise, but don’t set it too high (it can blur valid disparity edges).
• uniquenessRatio: Integer between 5-15. Higher values filter out ambiguous matches (good for reducing false positives).
• speckleWindowSize & speckleRange: Filter small noise blobs. Try speckleWindowSize=100 and speckleRange=2 to start.
• disp12MaxDiff: Set to 1 or 2 to enable left-right consistency check (filters mismatched pixels).

Example Optimized StereoSGBM Setup: #

stereo = cv2.StereoSGBM_create(
    minDisparity=0,
    numDisparities=64,
    blockSize=7,
    P1=8 * 3 * 7**2,
    P2=32 * 3 * 7**2,
    disp12MaxDiff=1,
    uniquenessRatio=10,
    speckleWindowSize=100,
    speckleRange=2,
    mode=cv2.STEREO_SGBM_MODE_SGBM_3WAY
)
# Compute disparity from rectified left/right images
disparity = stereo.compute(left_rectified, right_rectified)

Extra Tips: #

• Preprocess your input images: Apply histogram equalization or Gaussian blur to reduce noise before computing disparity.
• Convert color images to grayscale—stereo matching works better on single-channel data.
• Use post-processing: Apply morphological operations like cv2.morphologyEx() with a small kernel to clean up noise in the final disparity map.

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