解决：如何在opencv中得到与matlab立体标定一样的矫正图？（python版opencv）

目的：采用一样的标定参数，matlab中和opencv中的立体矫正图像是一样的吗？不一样的话怎么让它们一样？
结论：不一样。后文为解决方案。
原因：注意matlab的标定结果在matlab中的用法和在opencv中的用法不一样，主要原因是matlab的rectifyStereoImages函数和opencv的cv2.stereoRectify函数的计算结果不一样导致的。照这个思路，把matlab的rectifyStereoImages的结果导入opencv、而不用opencv的cv2.stereoRectify就可以了。
软件版本：Matlab2024a + OpenCV4.9.0

问题的提出

在matlab的stereo camera calibrator中对棋盘格标定后，可以点击"Show Rectified"一键得到矫正图

但是把matlab的参数导入到opencv中后，怎么得到和matlab一样的结果呢？

不想看对比细节可直接看[3. 解决方案](#不想看对比细节可直接看3. 解决方案)

1. 用标定后的参数在matlab中直接显示立体矫正后的左右目图像

在matlab的stereo camera calibrator中对棋盘格标定后，有两种结果，一种直接在stereoParams中查看，另一种用函数转换成opencv的格式，这里两种都展示：

1.1 在stereoParams中直接查看

matlab 复制代码

% stereoParams.CameraParameters1.intrinsics中查看左相机
K =
	[5701.4907,0,1387.8609;
	0,5705.7330,1050.1707;
	0,0,1]
RadialDistortion = 
	[-0.0621,0.2954,2.6695]
TangentialDistortion =
	[0.0010,-0.0004]
%写成[k1, k2, p1, p2, k3]格式
distCoeffs = [-0.0621,0.2954,0.0010,-0.0004,2.6695]
% stereoParams.CameraParameters2.intrinsics中查看右相机
K =
	[5596.4954,0,1062.2055;
	0,5620.0099,1016.7026;
	0,0,1]
RadialDistortion = 
	[-0.0358,-0.0958,9.2830]
TangentialDistortion =
	[0.0001,0.0034]
%写成[k1, k2, p1, p2, k3]格式
distCoeffs = [-0.0358,-0.0958,0.0001,0.0034,9.2830]
% 以及旋转矩阵、平移矩阵（这两个是完全一样的）
stereoParams.PoseCamera2.R =
	[0.9500,-0.0045,0.3121;
	0.0035,1.0000,0.0038;
	-0.3121,-0.0025,0.9500]
stereoParams.PoseCamera2.Translation =
	[  -35.0696   -0.0101    5.1674]

1.2 在matlab中转换成opencv格式

函数：stereoParametersToOpenCV

matlab 复制代码

[intrinsicMatrix1,distortionCoefficients1,...
    intrinsicMatrix2,distortionCoefficients2,...
    rotationOfCamera2,translationOfCamera2] ...
    = stereoParametersToOpenCV(stereoParams)
% 输出
intrinsicMatrix1 =
	[5701.4907,0,1386.8609;
	0,5705.7330,1049.1707;
	0,0,1]
distortionCoefficients1 = 
	[-0.0621    0.2954    0.0010   -0.0004    2.6695]
intrinsicMatrix2 =
	[5596.4954,0,1061.2055;
	0,5620.0099,1015.7026;
	0,0,1]
distortionCoefficients2 =
	[-0.0358   -0.0958   0.0001    0.0034   9.2830]
rotationOfCamera2 =
	[0.9500   -0.0045	0.3121
    0.0035    1.0000	0.0038
   -0.3121   -0.0025	0.9500]
translationOfCamera2 =
	[  -35.0696   -0.0101    5.1674]

1.3 两种方法的差异

只有内参矩阵的主点坐标不一样，畸变参数、旋转矩阵、平移向量都是一样的~

内参矩阵的主点坐标差值为1，原因是函数stereoParametersToOpenCV中有一个内参矩阵解析函数getOCVIntrinsicMatrix，在这个函数里把主点-1了，如下：cx = intrinsics.PrincipalPoint(1) - 1;

matlab 复制代码

%在函数function [intrinsicMatrix, distortionCoefficients] = cameraIntrinsicsToOpenCV(intrinsics)中
function distortionCoefficients = getOCVDistortionCoefficients(intrinsics)    
    % Distortion Coefficients in OpenCV [k1 k2 p1 p2 k3]
    distortionCoefficients = zeros(1,5);
    if length(intrinsics.RadialDistortion) == 3
        distortionCoefficients([1,2,5]) = intrinsics.RadialDistortion;
    else
        distortionCoefficients([1,2]) = intrinsics.RadialDistortion;
    end
    distortionCoefficients([3,4])   = intrinsics.TangentialDistortion;
end

function intrinsicMatrix = getOCVIntrinsicMatrix(intrinsics)
    % Focal length.
    fx = intrinsics.FocalLength(1);
    fy = intrinsics.FocalLength(2);
    
    % Principal point.
    cx = intrinsics.PrincipalPoint(1) - 1;
    cy = intrinsics.PrincipalPoint(2) - 1;        
    
    % Construct OpenCV's intrinsic matrix.
    intrinsicMatrix = [fx   0  cx;
                        0  fy  cy;
                        0   0  1];
end

1.4 在matlab中用stereoParams映射矫正后的图像

matlab 复制代码

close all;  clc;

I1 = imread('D:\StereoRectify\Calibration\left\0001.jpg');%读取左右图片
I2 = imread('D:\StereoRectify\Calibration\right\0001.jpg');

[J1, J2] = rectifyStereoImages(I1, I2, stereoParams);

figure; subplot(2,1,1); imshow(J1);
subplot(2,1,2); imshow(J2);

这里J1，J2的图像尺寸都是4026×2128。

如果在opencv里面矫正后的图像尺寸也是这个值，说明两个方法取得一样的效果；反之，就有问题！

当然，这个验证方法过于简单粗暴，实际上把两种方法的图像做减法也能对比的~~

但是把matlab的参数导入到opencv中后，怎么得到和matlab一样的结果呢？

2. 把matlab标定的参数导入python的opencv，然后计算立体矫正后的左右目图像

这段可以不看~~怎么解释validPixROI这个参数呢？

网上有这么说的：

python 复制代码

validPixROI1：一个最多地包含有效像素的长方形。（左目图像）
validPixROI2：一个最多地包含有效像素的长方形。（右目图像）

这个参数的第一个值是有效图像最左侧非零点的横坐标；

后面三个参数我无法解释，对着图像来看上/下/左/右/横/纵坐标都不是-_-|||。

opencv官方文档也没写，我自己写一个计算图像的非零区域的代码吧！

跳到这里：这里是正文~~

2.1 代码：

python 复制代码

import camera_config
import cv2
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np

size = camera_config.size  # (8000, 3000) # 图像尺寸
left_camera_matrix = camera_config.left_camera_matrix
left_distortion = camera_config.left_distortion
right_camera_matrix = camera_config.right_camera_matrix
right_distortion = camera_config.right_distortion
R = camera_config.R
T = camera_config.T

# 进行立体更正
R1, R2, P1, P2, Q, validPixROI1, validPixROI2 = cv2.stereoRectify(left_camera_matrix, left_distortion, right_camera_matrix, right_distortion, size, R, T)
# 输出参数：
print('***** R1 *****\n',R1)    # R1：矫正旋转矩阵。将第一个相机坐标系下未矫正的点变换到第一个相机矫正坐标系下，即 R_{左矫正坐标系}{左未矫正坐标系}
print('***** P1 *****\n',P1)    # P1：3x4左相机投影矩阵。将左矫正坐标系下的点投影到左矫正坐标系图像平面坐标系。
print('***** R2 *****\n',R2)    # R2：矫正旋转矩阵。将第二个相机坐标系下未矫正的点变换到第二个相机矫正坐标系下，即 R_{右矫正坐标系}{右未矫正坐标系}
print('***** P2 *****\n',P2)    # P2：3x4右相机投影矩阵。将左矫正坐标系下的点投影到右矫正坐标系图像平面坐标系。
print('***** Q *****\n',Q)      # Q：4x4的视差到深度映射矩阵。
# 计算更正map
left_map1, left_map2 = cv2.initUndistortRectifyMap(left_camera_matrix, left_distortion, R1, P1, size, cv2.CV_16SC2)
right_map1, right_map2 = cv2.initUndistortRectifyMap(right_camera_matrix, right_distortion, R2, P2, size, cv2.CV_16SC2)
img_l = np.array(Image.open(r'Calibration/left/0001.jpg')) 
img_r = np.array(Image.open(r'Calibration/right/0001.jpg')) 
# 根据更正map对图片进行重构
img1_rectified = cv2.remap(img_l, left_map1, left_map2, cv2.INTER_LINEAR)
img2_rectified = cv2.remap(img_r, right_map1, right_map2, cv2.INTER_LINEAR)
# 转成灰度图，求非零图像区域，然后求图像区域的上/下/左/右/横/纵坐标
img1_rectified_gray = cv2.cvtColor(img1_rectified, cv2.COLOR_RGB2GRAY)
img2_rectified_gray = cv2.cvtColor(img2_rectified, cv2.COLOR_RGB2GRAY)
# python索引是左闭右开，最大值都+1
idxNonZero=cv2.findNonZero(img1_rectified_gray).squeeze(1)
l1, r1, t1, b1 = np.min(idxNonZero[:,0]), np.max(idxNonZero[:,0])+1, np.min(idxNonZero[:,1]), np.max(idxNonZero[:,1])+1
idxNonZero=cv2.findNonZero(img2_rectified_gray).squeeze(1)
l2, r2, t2, b2 = np.min(idxNonZero[:,0]), np.max(idxNonZero[:,0])+1, np.min(idxNonZero[:,1]), np.max(idxNonZero[:,1])+1

plt.figure(1)
plt.subplot(211)
plt.imshow(img1_rectified)
plt.subplot(212)
plt.imshow(img2_rectified)
plt.figure(2)
plt.subplot(211)
plt.imshow(img1_rectified[min(t1,t2):max(b1,b2), l2:r1])
plt.subplot(212)
plt.imshow(img2_rectified[min(t1,t2):max(b1,b2), l2:r1])
# 裁剪后的图像尺寸
print(f'image size: {r1-l2}x{max(b1,b2)-min(t1,t2)}')

plt.show()

结果：

python 复制代码

***** R1 *****
 [[ 0.9853897  -0.00381456  0.1702721 ]
 [ 0.00352377  0.99999177  0.00200993]
 [-0.17027837 -0.00138056  0.98539503]]
***** P1 *****
 [[5662.8715        0.         4312.4698143     0.        ]
 [   0.         5662.8715     1261.70807171    0.        ]
 [   0.            0.            1.            0.        ]]
***** R2 *****
 [[ 0.98931806  0.00028444 -0.14577278]
 [-0.00053314  0.99999847 -0.00166697]
 [ 0.14577209  0.00172688  0.98931669]]
***** P2 *****
 [[   5662.8715           0.            4312.4698143  -200738.92039502]
 [      0.            5662.8715        1261.70807171       0.        ]
 [      0.               0.               1.               0.        ]]
***** Q *****
 [[    1.             0.             0.         -4312.4698143 ]
 [    0.             1.             0.         -1261.70807171]
 [    0.             0.             0.          5662.8715    ]
 [    0.             0.             0.02821013    -0.        ]]
image size: 4075x2153

2.2 参数解释

参见opencv官方文档中函数stereoRectify()的解释

P1, P2的含义及其用法

P1 ：3x4左相机投影矩阵。将左矫正坐标系下的三维点投影到左矫正坐标系图像平面坐标系的像素点
P 1 = [ f 0 c x 1 0 0 f c y 0 0 0 1 0 ] {P1 = }\left[ {\begin{array}{cc} f&0&{{c_{x1}}}&0\\ 0&f&{{c_y}}&0\\ 0&0&1&0 \end{array}} \right] P1= f000f0cx1cy1000

P2 ：3x4右相机投影矩阵。将左矫正坐标系下的三维点投影到右矫正坐标系图像平面坐标系的像素点。 T x T_x Tx是两个相机之间的水平偏移值。我这里算了一下，实际上就是matlab标定的平移向量[ -35.0696 -0.0101 5.1674] 的长度=35.4483的负数，用P2的两个参数 T x ⋅ f {T_x} \cdot f Tx⋅f=-200738.92039502； f f f=5662.8715； -200738.92039502/5662.8715 = -35.4483 可以验证。
P 2 = [ f 0 c x 2 T x ⋅ f 0 f c y 0 0 0 1 0 ] {P2 = }\left[ {\begin{array}{cc} f&0&{{c_{x2}}}&{{T_x} \cdot f}\\ 0&f&{{c_y}}&0\\ 0&0&1&0 \end{array}} \right] P2= f000f0cx2cy1Tx⋅f00

对于三维物理空间点 ( X , Y , Z ) (X, Y, Z) (X,Y,Z)，都可用P1和P2，计算该点对应的图像像素坐标 ( x , y ) (x, y) (x,y)，（ w w w是尺度因子）
w [ x y 1 ] = P [ X Y Z 1 ] w\left[ {\begin{array}{cc} x\\ y\\ 1 \end{array}} \right] = P\left[ {\begin{array}{cc} X\\ Y\\ Z\\ 1 \end{array}} \right] w xy1 =P XYZ1

Q的含义及其用法

Q ：4x4的视差到深度映射矩阵。
Q = [ 1 0 0 − c x 1 0 1 0 − c y 0 0 0 f 0 0 − 1 T x c x 1 − c x 2 T x ] {Q = }\left[ {\begin{array}{cc} 1&0&0&{ - {c_{x1}}}\\ 0&1&0&{ - c{}y}\\ 0&0&0&f\\ 0&0&{ - \frac{1}{{{T_x}}}}&{\frac{{{c{x1}} - {c_{x2}}}}{{{T_x}}}} \end{array}} \right] Q= 10000100000−Tx1−cx1−cyfTxcx1−cx2

为什么把Q叫视差到深度映射矩阵 呢？因为采用下式，Q能够将单通道视差图转换为表示 3D 表面的 3 通道图（就是x,y,z坐标值）。对于每个像素坐标 ( x , y ) (x, y) (x,y)及其视差 d = d i s p a r i t y ( x , y ) d=disparity(x,y) d=disparity(x,y) ，都能计算三维物理空间中的一个点 ( X , Y , Z ) (X, Y, Z) (X,Y,Z)：