开始记录计算机视觉学习之旅
开始记录计算机视觉学习之旅

双目视觉下空间坐标计算/双目测距

摄像机矩阵由内参矩阵和外参矩阵组成，对摄像机矩阵进行QR分解可以得到内参矩阵和外参矩阵。

内参包括焦距、主点、倾斜系数、畸变系数

双目视觉下空间坐标计算/双目测距_第1张图片（1）

其中，fx，fy为焦距，一般情况下，二者相等，x0、y0为主点坐标（相对于成像平面），s为坐标轴倾斜参数，理想情况下为0
 
外参包括旋转矩阵R3×3、平移向量T3×1，它们共同描述了如何把点从世界坐标系转换到摄像机坐标系，旋 转矩阵描述了世界坐标系的坐标轴相对于摄像机坐标轴的方向，平移向量描述了在摄像机 坐标系下空间原点的位置。
 
标定双目后，首先要根据其畸变系数来校正原图，可以参考
http://blog.csdn.net/qq_15947787/article/details/51471535

 

[cpp] view plain copy
  1. Mat jiaozheng( Mat image )  
  2. {  
  3.     Size image_size = image.size();  
  4.     float intrinsic[3][3] = {589.2526583947847,0,321.8607532099886,0,585.7784771038199,251.0338528599469,0,0,1};  
  5.     float distortion[1][5] = {-0.5284205687061442, 0.3373615384253201, -0.002133029981628697, 0.001511983002864886, -0.1598661778309496};  
  6.     Mat intrinsic_matrix = Mat(3,3,CV_32FC1,intrinsic);  
  7.     Mat distortion_coeffs = Mat(1,5,CV_32FC1,distortion);  
  8.     Mat R = Mat::eye(3,3,CV_32F);         
  9.     Mat mapx = Mat(image_size,CV_32FC1);  
  10.     Mat mapy = Mat(image_size,CV_32FC1);      
  11.     initUndistortRectifyMap(intrinsic_matrix,distortion_coeffs,R,intrinsic_matrix,image_size,CV_32FC1,mapx,mapy);  
  12.     Mat t = image.clone();  
  13.     cv::remap( image, t, mapx, mapy, INTER_LINEAR);  
  14.     return t;  
  15. }  

校正完成后就可以进行坐标计算了，分两种

（1）世界坐标系——>像面坐标系

首先将世界坐标系——>摄像机坐标系

已知某点在世界坐标系中的坐标为(Xw, Yw, Zw)，由旋转和平移矩阵可得摄像机坐标系和世界坐标系的关系为

双目视觉下空间坐标计算/双目测距_第2张图片（2）
然后将摄像机坐标系——>像面坐标系

双目视觉下空间坐标计算/双目测距_第3张图片（3）

其中[u v 1]T为点在图像坐标系中的坐标，[Xc Yc  Zc  1]T为点在摄像机坐标系中的坐标，K为摄像机内参数矩阵。

这样最终可以得到：

双目视觉下空间坐标计算/双目测距_第4张图片（4）

（2）像面坐标系——>世界坐标系

光轴会聚模型：

双目视觉下空间坐标计算/双目测距_第5张图片

对于两相机分别有：

双目视觉下空间坐标计算/双目测距_第6张图片（5）          双目视觉下空间坐标计算/双目测距_第7张图片（6）

公式56，左边Z应分别为Zc1，Zc2

其中，

双目视觉下空间坐标计算/双目测距_第8张图片（7）

这样可以把（5）（6）写成

双目视觉下空间坐标计算/双目测距_第9张图片（8）  

公式8左边Z应为Zc1

双目视觉下空间坐标计算/双目测距_第10张图片（9）

公式9左边Z应为Zc2

将（8）（9）整理可以得到

双目视觉下空间坐标计算/双目测距_第11张图片（10）

以上公式参考评论6楼 wisemanjack 

采用最小二乘法求解X,Y,Z，在opencv中可以用solve(A,B,XYZ,DECOMP_SVD)求解

 

代码如下：

[cpp] view plain copy
  1. //opencv2.4.9 vs2012  
  2. #include   
  3. #include   
  4. #include   
  5.   
  6. using namespace std;  
  7. using namespace cv;  
  8.   
  9. Point2f xyz2uv(Point3f worldPoint,float intrinsic[3][3],float translation[1][3],float rotation[3][3]);  
  10. Point3f uv2xyz(Point2f uvLeft,Point2f uvRight);  
  11.   
  12. //图片对数量  
  13. int PicNum = 14;  
  14.   
  15. //左相机内参数矩阵  
  16. float leftIntrinsic[3][3] = {4037.82450,             0,     947.65449,  
  17.                                       0,    3969.79038,     455.48718,  
  18.                                       0,             0,             1};  
  19. //左相机畸变系数  
  20. float leftDistortion[1][5] = {0.18962, -4.05566, -0.00510, 0.02895, 0};  
  21. //左相机旋转矩阵  
  22. float leftRotation[3][3] = {0.912333,       -0.211508,       0.350590,   
  23.                             0.023249,       -0.828105,      -0.560091,   
  24.                             0.408789,        0.519140,      -0.750590};  
  25. //左相机平移向量  
  26. float leftTranslation[1][3] = {-127.199992, 28.190639, 1471.356768};  
  27.   
  28. //右相机内参数矩阵  
  29. float rightIntrinsic[3][3] = {3765.83307,            0,     339.31958,  
  30.                                         0,  3808.08469,     660.05543,  
  31.                                         0,           0,             1};  
  32. //右相机畸变系数  
  33. float rightDistortion[1][5] = {-0.24195, 5.97763, -0.02057, -0.01429, 0};  
  34. //右相机旋转矩阵  
  35. float rightRotation[3][3] = {-0.134947,      0.989568,      -0.050442,   
  36.                               0.752355,      0.069205,      -0.655113,   
  37.                              -0.644788,     -0.126356,      -0.753845};  
  38. //右相机平移向量  
  39. float rightTranslation[1][3] = {50.877397, -99.796492, 1507.312197};  
  40.   
  41.   
  42. int main()  
  43. {  
  44.     //已知空间坐标求成像坐标  
  45.     Point3f point(700,220,530);  
  46.     cout<<"左相机中坐标："<
  47.     cout<
  48.     cout<<"右相机中坐标："<
  49.     cout<
  50.   
  51.     //已知左右相机成像坐标求空间坐标  
  52.     Point2f l = xyz2uv(point,leftIntrinsic,leftTranslation,leftRotation);  
  53.     Point2f r = xyz2uv(point,rightIntrinsic,rightTranslation,rightRotation);  
  54.     Point3f worldPoint;  
  55.     worldPoint = uv2xyz(l,r);  
  56.     cout<<"空间坐标为:"<
  57.   
  58.     system("pause");  
  59.   
  60.     return 0;  
  61. }  
  62.   
  63.   
  64. //************************************  
  65. // Description: 根据左右相机中成像坐标求解空间坐标  
  66. // Method:    uv2xyz  
  67. // FullName:  uv2xyz  
  68. // Access:    public   
  69. // Parameter: Point2f uvLeft  
  70. // Parameter: Point2f uvRight  
  71. // Returns:   cv::Point3f  
  72. // Author:    小白  
  73. // Date:      2017/01/10  
  74. // History:  
  75. //************************************  
  76. Point3f uv2xyz(Point2f uvLeft,Point2f uvRight)  
  77. {  
  78.     //  [u1]      |X|                     [u2]      |X|  
  79.     //Z*|v1| = Ml*|Y|                   Z*|v2| = Mr*|Y|  
  80.     //  [ 1]      |Z|                     [ 1]      |Z|  
  81.     //            |1|                               |1|  
  82.     Mat mLeftRotation = Mat(3,3,CV_32F,leftRotation);  
  83.     Mat mLeftTranslation = Mat(3,1,CV_32F,leftTranslation);  
  84.     Mat mLeftRT = Mat(3,4,CV_32F);//左相机M矩阵  
  85.     hconcat(mLeftRotation,mLeftTranslation,mLeftRT);  
  86.     Mat mLeftIntrinsic = Mat(3,3,CV_32F,leftIntrinsic);  
  87.     Mat mLeftM = mLeftIntrinsic * mLeftRT;  
  88.     //cout<<"左相机M矩阵 = "<  
  89.   
  90.     Mat mRightRotation = Mat(3,3,CV_32F,rightRotation);  
  91.     Mat mRightTranslation = Mat(3,1,CV_32F,rightTranslation);  
  92.     Mat mRightRT = Mat(3,4,CV_32F);//右相机M矩阵  
  93.     hconcat(mRightRotation,mRightTranslation,mRightRT);  
  94.     Mat mRightIntrinsic = Mat(3,3,CV_32F,rightIntrinsic);  
  95.     Mat mRightM = mRightIntrinsic * mRightRT;  
  96.     //cout<<"右相机M矩阵 = "<  
  97.   
  98.     //最小二乘法A矩阵  
  99.     Mat A = Mat(4,3,CV_32F);  
  100.     A.at<float>(0,0) = uvLeft.x * mLeftM.at<float>(2,0) - mLeftM.at<float>(0,0);  
  101.     A.at<float>(0,1) = uvLeft.x * mLeftM.at<float>(2,1) - mLeftM.at<float>(0,1);  
  102.     A.at<float>(0,2) = uvLeft.x * mLeftM.at<float>(2,2) - mLeftM.at<float>(0,2);  
  103.   
  104.     A.at<float>(1,0) = uvLeft.y * mLeftM.at<float>(2,0) - mLeftM.at<float>(1,0);  
  105.     A.at<float>(1,1) = uvLeft.y * mLeftM.at<float>(2,1) - mLeftM.at<float>(1,1);  
  106.     A.at<float>(1,2) = uvLeft.y * mLeftM.at<float>(2,2) - mLeftM.at<float>(1,2);  
  107.   
  108.     A.at<float>(2,0) = uvRight.x * mRightM.at<float>(2,0) - mRightM.at<float>(0,0);  
  109.     A.at<float>(2,1) = uvRight.x * mRightM.at<float>(2,1) - mRightM.at<float>(0,1);  
  110.     A.at<float>(2,2) = uvRight.x * mRightM.at<float>(2,2) - mRightM.at<float>(0,2);  
  111.   
  112.     A.at<float>(3,0) = uvRight.y * mRightM.at<float>(2,0) - mRightM.at<float>(1,0);  
  113.     A.at<float>(3,1) = uvRight.y * mRightM.at<float>(2,1) - mRightM.at<float>(1,1);  
  114.     A.at<float>(3,2) = uvRight.y * mRightM.at<float>(2,2) - mRightM.at<float>(1,2);  
  115.   
  116.     //最小二乘法B矩阵  
  117.     Mat B = Mat(4,1,CV_32F);  
  118.     B.at<float>(0,0) = mLeftM.at<float>(0,3) - uvLeft.x * mLeftM.at<float>(2,3);  
  119.     B.at<float>(1,0) = mLeftM.at<float>(1,3) - uvLeft.y * mLeftM.at<float>(2,3);  
  120.     B.at<float>(2,0) = mRightM.at<float>(0,3) - uvRight.x * mRightM.at<float>(2,3);  
  121.     B.at<float>(3,0) = mRightM.at<float>(1,3) - uvRight.y * mRightM.at<float>(2,3);  
  122.   
  123.     Mat XYZ = Mat(3,1,CV_32F);  
  124.     //采用SVD最小二乘法求解XYZ  
  125.     solve(A,B,XYZ,DECOMP_SVD);  
  126.   
  127.     //cout<<"空间坐标为 = "<  
  128.   
  129.     //世界坐标系中坐标  
  130.     Point3f world;  
  131.     world.x = XYZ.at<float>(0,0);  
  132.     world.y = XYZ.at<float>(1,0);  
  133.     world.z = XYZ.at<float>(2,0);  
  134.   
  135.     return world;  
  136. }  
  137.   
  138. //************************************  
  139. // Description: 将世界坐标系中的点投影到左右相机成像坐标系中  
  140. // Method:    xyz2uv  
  141. // FullName:  xyz2uv  
  142. // Access:    public   
  143. // Parameter: Point3f worldPoint  
  144. // Parameter: float intrinsic[3][3]  
  145. // Parameter: float translation[1][3]  
  146. // Parameter: float rotation[3][3]  
  147. // Returns:   cv::Point2f  
  148. // Author:    小白  
  149. // Date:      2017/01/10  
  150. // History:  
  151. //************************************  
  152. Point2f xyz2uv(Point3f worldPoint,float intrinsic[3][3],float translation[1][3],float rotation[3][3])  
  153. {  
  154.     //    [fx s x0]                         [Xc]        [Xw]        [u]   1     [Xc]  
  155.     //K = |0 fy y0|       TEMP = [R T]      |Yc| = TEMP*|Yw|        | | = —*K *|Yc|  
  156.     //    [ 0 0 1 ]                         [Zc]        |Zw|        [v]   Zc    [Zc]  
  157.     //                                                  [1 ]  
  158.     Point3f c;  
  159.     c.x = rotation[0][0]*worldPoint.x + rotation[0][1]*worldPoint.y + rotation[0][2]*worldPoint.z + translation[0][0]*1;  
  160.     c.y = rotation[1][0]*worldPoint.x + rotation[1][1]*worldPoint.y + rotation[1][2]*worldPoint.z + translation[0][1]*1;  
  161.     c.z = rotation[2][0]*worldPoint.x + rotation[2][1]*worldPoint.y + rotation[2][2]*worldPoint.z + translation[0][2]*1;  
  162.   
  163.     Point2f uv;  
  164.     uv.x = (intrinsic[0][0]*c.x + intrinsic[0][1]*c.y + intrinsic[0][2]*c.z)/c.z;  
  165.     uv.y = (intrinsic[1][0]*c.x + intrinsic[1][1]*c.y + intrinsic[1][2]*c.z)/c.z;  
  166.   
  167.     return uv;  
  168. }  


2017/5/26补充 

matlab或者opencv标定完都是在左相机上建立世界坐标系，于是上面代码对应的改为：

[cpp] view plain copy
  1. //左相机旋转矩阵    
  2. float leftRotation[3][3] = {1,0,0,  0,1,0,  0,0,1 };  
  3. //左相机平移向量    
  4. float leftTranslation[1][3] = {0,0,0};  

畸变矩阵(默认获得5个即便参数k1,k2,p1,p2,k3）

 

 ——————————————————————————————————————————————————————————————

 像面坐标系——>世界坐标系还有一种模型是光轴平行模型

双目立体视觉三位测量是基于视差原理：

（11）

双目视觉下空间坐标计算/双目测距_第12张图片

双目视觉下空间坐标计算/双目测距_第13张图片

双目视觉下空间坐标计算/双目测距_第14张图片（12）

这里，除cx‘外的所有参数都来自于左图像，cx’是主点在右图像上的x坐标。如果主光线在无穷远处相交，那么cx=cx‘，并且右下角的项为0，给定一个二维齐次点和其关联的视差d，我们可以将此点投影到三维中：

双目视觉下空间坐标计算/双目测距_第15张图片（13）

三维坐标就是（X / W , Y / W , Z / W）

 

光轴平行模型要得到视差图，http://blog.csdn.net/wangchao7281/article/details/52506691?locationNum=7

可以参考opencv的例子，例子的使用方法可以参考http://blog.csdn.net/t247555529/article/details/48046859

得到视差图后可以调用cvReprojectImageTo3D输出的三维坐标

看到很多人输出三维坐标时z出现10000，那个其实是输出方式不对，应该是下面这样

[cpp] view plain copy
  1. Point p;  
  2. p.x =294,p.y=189;  
  3. cout<"in world coordinate: " << xyz.at(p)*16 <

为什么要乘以16呢？

因为在OpenCV2.0中，BM函数得出的结果是以16位符号数的形式的存储的，出于精度需要，所有的视差在输出时都扩大了16倍(2^4)。其具体代码表示如下：

[cpp] view plain copy
  1. dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*128/d : 0) + 15) >> 4);  

 

可以看到，原始视差在左移8位(256)并且加上一个修正值之后又右移了4位，最终的结果就是左移4位

因此，在实际求距离时，cvReprojectTo3D出来的X/W,Y/W,Z/W都要乘以16 (也就是W除以16)，才能得到正确的三维坐标信息

下面是在opencv3.0下实现的该方法的测距（转载）

[cpp] view plain copy
  1. /******************************/  
  2. /*        立体匹配和测距        */  
  3. /******************************/  
  4.   
  5. #include     
  6. #include     
  7.   
  8. using namespace std;  
  9. using namespace cv;  
  10.   
  11. const int imageWidth = 640;                             //摄像头的分辨率    
  12. const int imageHeight = 480;  
  13. Size imageSize = Size(imageWidth, imageHeight);  
  14.   
  15. Mat rgbImageL, grayImageL;  
  16. Mat rgbImageR, grayImageR;  
  17. Mat rectifyImageL, rectifyImageR;  
  18.   
  19. Rect validROIL;//图像校正之后，会对图像进行裁剪，这里的validROI就是指裁剪之后的区域    
  20. Rect validROIR;  
  21.   
  22. Mat mapLx, mapLy, mapRx, mapRy;     //映射表    
  23. Mat Rl, Rr, Pl, Pr, Q;              //校正旋转矩阵R，投影矩阵P 重投影矩阵Q  
  24. Mat xyz;              //三维坐标  
  25.   
  26. Point origin;         //鼠标按下的起始点  
  27. Rect selection;      //定义矩形选框  
  28. bool selectObject = false;    //是否选择对象  
  29.   
  30. int blockSize = 0, uniquenessRatio =0, numDisparities=0;  
  31. Ptr bm = StereoBM::create(16, 9);  
  32.   
  33. /* 
  34. 事先标定好的相机的参数 
  35. fx 0 cx 
  36. 0 fy cy 
  37. 0 0  1 
  38. */  
  39. Mat cameraMatrixL = (Mat_<double>(3, 3) << 836.771593170594,0,319.970748854743,  
  40.     0,839.416501863912,228.788913693256,  
  41.     0, 0, 1);  
  42. Mat distCoeffL = (Mat_<double>(5, 1) << 0, 0, 0, 0, 0);  
  43.   
  44. Mat cameraMatrixR = (Mat_<double>(3, 3) << 838.101721655709,0,319.647150557935,  
  45.     0,840.636812165056,250.655818405938,  
  46.     0, 0, 1);  
  47. Mat distCoeffR = (Mat_<double>(5, 1) << 0, 0, 0, 0, 0);  
  48.   
  49. Mat T = (Mat_<double>(3, 1) << -39.7389449993974,0.0740619639178984,0.411914303245886);//T平移向量  
  50. Mat rec = (Mat_<double>(3, 1) << -0.00306, -0.03207, 0.00206);//rec旋转向量  
  51. Mat R = (Mat_<double>(3, 3) << 0.999957725513956,-0.00103511880221423,0.00913650447492805,  
  52.          0.00114462826834523,0.999927476064641,-0.0119888463633882,  
  53.          -0.00912343197938050,0.0119987974423658,0.999886389470751);//R 旋转矩阵  
  54.   
  55.   
  56. /*****立体匹配*****/  
  57. void stereo_match(int,void*)  
  58. {  
  59.     bm->setBlockSize(2*blockSize+5);     //SAD窗口大小，5~21之间为宜  
  60.     bm->setROI1(validROIL);  
  61.     bm->setROI2(validROIR);  
  62.     bm->setPreFilterCap(31);  
  63.     bm->setMinDisparity(0);  //最小视差，默认值为0, 可以是负值，int型  
  64.     bm->setNumDisparities(numDisparities*16+16);//视差窗口，即最大视差值与最小视差值之差,窗口大小必须是16的整数倍，int型  
  65.     bm->setTextureThreshold(10);   
  66.     bm->setUniquenessRatio(uniquenessRatio);//uniquenessRatio主要可以防止误匹配  
  67.     bm->setSpeckleWindowSize(100);  
  68.     bm->setSpeckleRange(32);  
  69.     bm->setDisp12MaxDiff(-1);  
  70.     Mat disp, disp8;  
  71.     bm->compute(rectifyImageL, rectifyImageR, disp);//输入图像必须为灰度图  
  72.     disp.convertTo(disp8, CV_8U, 255 / ((numDisparities * 16 + 16)*16.));//计算出的视差是CV_16S格式  
  73.     reprojectImageTo3D(disp, xyz, Q, true); //在实际求距离时，ReprojectTo3D出来的X / W, Y / W, Z / W都要乘以16(也就是W除以16)，才能得到正确的三维坐标信息。  
  74.     xyz = xyz * 16;  
  75.     imshow("disparity", disp8);  
  76. }  
  77.   
  78. /*****描述：鼠标操作回调*****/  
  79. static void onMouse(int event, int x, int y, int, void*)  
  80. {  
  81.     if (selectObject)  
  82.     {  
  83.         selection.x = MIN(x, origin.x);  
  84.         selection.y = MIN(y, origin.y);  
  85.         selection.width = std::abs(x - origin.x);  
  86.         selection.height = std::abs(y - origin.y);  
  87.     }  
  88.   
  89.     switch (event)  
  90.     {  
  91.     case EVENT_LBUTTONDOWN:   //鼠标左按钮按下的事件  
  92.         origin = Point(x, y);  
  93.         selection = Rect(x, y, 0, 0);  
  94.         selectObject = true;  
  95.         cout << origin <<"in world coordinate is: " << xyz.at(origin) << endl;  
  96.         break;  
  97.     case EVENT_LBUTTONUP:    //鼠标左按钮释放的事件  
  98.         selectObject = false;  
  99.         if (selection.width > 0 && selection.height > 0)  
  100.         break;  
  101.     }  
  102. }  
  103.   
  104.   
  105. /*****主函数*****/  
  106. int main()  
  107. {  
  108.     /* 
  109.     立体校正 
  110.     */  
  111.     //Rodrigues(rec, R); //Rodrigues变换  
  112.     stereoRectify(cameraMatrixL, distCoeffL, cameraMatrixR, distCoeffR, imageSize, R, T, Rl, Rr, Pl, Pr, Q, CALIB_ZERO_DISPARITY,  
  113.         0, imageSize, &validROIL, &validROIR);  
  114.     initUndistortRectifyMap(cameraMatrixL, distCoeffL, Rl, Pr, imageSize, CV_32FC1, mapLx, mapLy);  
  115.     initUndistortRectifyMap(cameraMatrixR, distCoeffR, Rr, Pr, imageSize, CV_32FC1, mapRx, mapRy);  
  116.   
  117.     /* 
  118.     读取图片 
  119.     */  
  120.     rgbImageL = imread("左2.jpg", CV_LOAD_IMAGE_COLOR);  
  121.     cvtColor(rgbImageL, grayImageL, CV_BGR2GRAY);  
  122.     rgbImageR = imread("右2.jpg", CV_LOAD_IMAGE_COLOR);  
  123.     cvtColor(rgbImageR, grayImageR, CV_BGR2GRAY);  
  124.   
  125.     imshow("ImageL Before Rectify", grayImageL);  
  126.     imshow("ImageR Before Rectify", grayImageR);  
  127.   
  128.     /* 
  129.     经过remap之后，左右相机的图像已经共面并且行对准了 
  130.     */  
  131.     remap(grayImageL, rectifyImageL, mapLx, mapLy, INTER_LINEAR);  
  132.     remap(grayImageR, rectifyImageR, mapRx, mapRy, INTER_LINEAR);  
  133.   
  134.     /* 
  135.     把校正结果显示出来 
  136.     */  
  137.     Mat rgbRectifyImageL, rgbRectifyImageR;  
  138.     cvtColor(rectifyImageL, rgbRectifyImageL, CV_GRAY2BGR);  //伪彩色图  
  139.     cvtColor(rectifyImageR, rgbRectifyImageR, CV_GRAY2BGR);  
  140.   
  141.     //单独显示  
  142.     //rectangle(rgbRectifyImageL, validROIL, Scalar(0, 0, 255), 3, 8);  
  143.     //rectangle(rgbRectifyImageR, validROIR, Scalar(0, 0, 255), 3, 8);  
  144.     imshow("ImageL After Rectify", rgbRectifyImageL);  
  145.     imshow("ImageR After Rectify", rgbRectifyImageR);  
  146.   
  147.     //显示在同一张图上  
  148.     Mat canvas;  
  149.     double sf;  
  150.     int w, h;  
  151.     sf = 600. / MAX(imageSize.width, imageSize.height);  
  152.     w = cvRound(imageSize.width * sf);  
  153.     h = cvRound(imageSize.height * sf);  
  154.     canvas.create(h, w * 2, CV_8UC3);   //注意通道  
  155.   
  156.     //左图像画到画布上  
  157.     Mat canvasPart = canvas(Rect(w * 0, 0, w, h));                                //得到画布的一部分    
  158.     resize(rgbRectifyImageL, canvasPart, canvasPart.size(), 0, 0, INTER_AREA);     //把图像缩放到跟canvasPart一样大小    
  159.     Rect vroiL(cvRound(validROIL.x*sf), cvRound(validROIL.y*sf),                //获得被截取的区域      
  160.         cvRound(validROIL.width*sf), cvRound(validROIL.height*sf));  
  161.     //rectangle(canvasPart, vroiL, Scalar(0, 0, 255), 3, 8);                      //画上一个矩形    
  162.     cout << "Painted ImageL" << endl;  
  163.   
  164.     //右图像画到画布上  
  165.     canvasPart = canvas(Rect(w, 0, w, h));                                      //获得画布的另一部分    
  166.     resize(rgbRectifyImageR, canvasPart, canvasPart.size(), 0, 0, INTER_LINEAR);  
  167.     Rect vroiR(cvRound(validROIR.x * sf), cvRound(validROIR.y*sf),  
  168.         cvRound(validROIR.width * sf), cvRound(validROIR.height * sf));  
  169.     //rectangle(canvasPart, vroiR, Scalar(0, 0, 255), 3, 8);  
  170.     cout << "Painted ImageR" << endl;  
  171.   
  172.     //画上对应的线条  
  173.     for (int i = 0; i < canvas.rows; i += 16)  
  174.         line(canvas, Point(0, i), Point(canvas.cols, i), Scalar(0, 255, 0), 1, 8);  
  175.     imshow("rectified", canvas);  
  176.   
  177.     /* 
  178.     立体匹配 
  179.     */  
  180.     namedWindow("disparity", CV_WINDOW_AUTOSIZE);  
  181.     // 创建SAD窗口 Trackbar  
  182.     createTrackbar("BlockSize:\n", "disparity",&blockSize, 8, stereo_match);  
  183.     // 创建视差唯一性百分比窗口 Trackbar  
  184.     createTrackbar("UniquenessRatio:\n", "disparity", &uniquenessRatio, 50, stereo_match);  
  185.     // 创建视差窗口 Trackbar  
  186.     createTrackbar("NumDisparities:\n", "disparity", &numDisparities, 16, stereo_match);  
  187.     //鼠标响应函数setMouseCallback(窗口名称, 鼠标回调函数, 传给回调函数的参数，一般取0)  
  188.     setMouseCallback("disparity", onMouse, 0);  
  189.     stereo_match(0,0);  
  190.   
  191.     waitKey(0);  
  192.     return 0;  
  193. }  


 

————————————————————————————————————————

最后是完整的大作业代码，感觉自己写的并不是很好，敷衍了事~~

运行该程序，会对素材文件夹中图像进行处理，生成三个文件夹，分别是“大球圆心”、“畸变校正”、“亮度对比度”以及一个csv文件，文件名为“三维坐标.csv”，里面记录了计算得到的左右相机中球的像面坐标和解算出的空间坐标。该程序默认对所有计算出的圆心坐标进行了重新赋值，如需修改圆心坐标，需在工程中的initPos()修改赋值语句，如需程序自动计算，在主函数中注释该指令即可，但是自动计算的圆心并不准确。

 

[cpp] view plain copy
  1. //opencv2.4.9 vs2012  
  2. #include   
  3. #include   
  4. #include   
  5.   
  6. using namespace std;  
  7. using namespace cv;  
  8.   
  9. //图片对数量  
  10. #define  PicNum  14  
  11.   
  12. //左相机内参数矩阵  
  13. float leftIntrinsic[3][3] = {4037.82450,             0,     947.65449,  
  14.                                       0,    3969.79038,     455.48718,  
  15.                                       0,             0,             1};  
  16. //左相机畸变系数  
  17. float leftDistortion[1][5] = {0.18962, -4.05566, -0.00510, 0.02895, 0};  
  18. //左相机旋转矩阵  
  19. float leftRotation[3][3] = {0.912333,       -0.211508,       0.350590,   
  20.                             0.023249,       -0.828105,      -0.560091,   
  21.                             0.408789,        0.519140,      -0.750590};  
  22. //左相机平移向量  
  23. float leftTranslation[1][3] = {-127.199992, 28.190639, 1471.356768};  
  24.   
  25. //右相机内参数矩阵  
  26. float rightIntrinsic[3][3] = {3765.83307,            0,     339.31958,  
  27.                                         0,  3808.08469,     660.05543,  
  28.                                         0,           0,             1};  
  29. //右相机畸变系数  
  30. float rightDistortion[1][5] = {-0.24195, 5.97763, -0.02057, -0.01429, 0};  
  31. //右相机旋转矩阵  
  32. float rightRotation[3][3] = {-0.134947,      0.989568,      -0.050442,   
  33.                               0.752355,      0.069205,      -0.655113,   
  34.                              -0.644788,     -0.126356,      -0.753845};  
  35. //右相机平移向量  
  36. float rightTranslation[1][3] = {50.877397, -99.796492, 1507.312197};  
  37.   
  38. //球坐标数组  
  39. //大球  
  40. float rightDaqiu[PicNum][2] = {0};  
  41. float leftDaqiu[PicNum][2] = {0};  
  42. float worldDaqiu[PicNum][3] = {0};  
  43. //小球  
  44. float rightXiaoqiu[PicNum][2] = {0};  
  45. float leftXiaoqiu[PicNum][2] = {0};  
  46. float worldXiaoqiu[PicNum][3] = {0};  
  47. //花球  
  48. float rightHuaqiu[PicNum][2] = {0};  
  49. float leftHuaqiu[PicNum][2] = {0};  
  50. float worldHuaqiu[PicNum][3] = {0};  
  51.   
  52. void ContrastAndBright(double alpha, double beta);//调节亮度/对比度  
  53. void CorrectionProcess();//对素材校正畸变  
  54. void initPos();//手动赋值球的图像坐标  
  55. void Daqiu();//计算大球图像坐标  
  56. Mat PictureCorrection( Mat image ,float intrinsic[3][3],float distortion[1][5]);//单张图像畸变校正  
  57. Point2f xyz2uv(Point3f worldPoint,float intrinsic[3][3],float translation[1][3],float rotation[3][3]);//从世界坐标转为图像坐标  
  58. Point3f uv2xyz(Point2f uvLeft,Point2f uvRight);//从图像坐标转为世界坐标  
  59.   
  60. int main()  
  61. {  
  62.     CorrectionProcess();//对素材校正畸变  
  63.     ContrastAndBright(2.5,50);//调节亮度/对比度  
  64.       
  65.     Daqiu();//自动计算大球坐标  
  66.       
  67.     initPos();//手动修正,如需验证数据，可以在该函数中修改  
  68.   
  69.     //求取大球的空间坐标  
  70.     cout<<"求解大球的世界坐标："<
  71.     for (int i=0; i
  72.     {  
  73.         Point2f l,r;  
  74.         Point3f worldPoint;  
  75.   
  76.         l.x = leftDaqiu[i][0];  
  77.         l.y = leftDaqiu[i][1];  
  78.         r.x = rightDaqiu[i][0];  
  79.         r.y = rightDaqiu[i][1];  
  80.   
  81.         worldPoint = uv2xyz(l,r);  
  82.         cout<< worldPoint <
  83.         worldDaqiu[i][0] = worldPoint.x;  
  84.         worldDaqiu[i][1] = worldPoint.y;  
  85.         worldDaqiu[i][2] = worldPoint.z;  
  86.     }  
  87.   
  88.     cout<<"求解小球的世界坐标："<
  89.     for (int i=0; i
  90.     {  
  91.         Point2f l,r;  
  92.         Point3f worldPoint;  
  93.   
  94.         l.x = leftXiaoqiu[i][0];  
  95.         l.y = leftXiaoqiu[i][1];  
  96.         r.x = rightXiaoqiu[i][0];  
  97.         r.y = rightXiaoqiu[i][1];  
  98.   
  99.         worldPoint = uv2xyz(l,r);  
  100.         cout<< worldPoint <
  101.         worldXiaoqiu[i][0] = worldPoint.x;  
  102.         worldXiaoqiu[i][1] = worldPoint.y;  
  103.         worldXiaoqiu[i][2] = worldPoint.z;  
  104.     }  
  105.   
  106.     cout<<"求解花球的世界坐标："<
  107.     for (int i=0; i
  108.     {  
  109.         Point2f l,r;  
  110.         Point3f worldPoint;  
  111.   
  112.         l.x = leftHuaqiu[i][0];  
  113.         l.y = leftHuaqiu[i][1];  
  114.         r.x = rightHuaqiu[i][0];  
  115.         r.y = rightHuaqiu[i][1];  
  116.   
  117.         worldPoint = uv2xyz(l,r);  
  118.         cout<< worldPoint <
  119.         worldHuaqiu[i][0] = worldPoint.x;  
  120.         worldHuaqiu[i][1] = worldPoint.y;  
  121.         worldHuaqiu[i][2] = worldPoint.z;  
  122.     }  
  123.   
  124.     //csv文件写入部分  
  125.     ofstream oFile;  //定义文件输出流     
  126.   
  127.     oFile.open("三维坐标.csv", ios::out | ios::trunc);    //打开要输出的文件     这样就很容易的输出一个需要的excel 文件    
  128.     //写入大球数据  
  129.     oFile << "大球坐标" << endl;  
  130.     oFile << "左相机坐标,,,右相机坐标,,,世界坐标" << endl;  
  131.     oFile << "x,y,,x,y,,x,y,z" << endl;  
  132.     for (int i=0; i
  133.     {  
  134.         oFile << leftDaqiu[i][0] <<","<< leftDaqiu[i][1] << ",," << rightDaqiu[i][0] <<","<< rightDaqiu[i][1]   
  135.               << ",," << worldDaqiu[i][0] <<","<<  worldDaqiu[i][1] <<","<<  worldDaqiu[i][2] << endl;  
  136.     }  
  137.   
  138.     //写入小球数据  
  139.     oFile << "小球坐标" << endl;  
  140.     oFile << "左相机坐标,,,右相机坐标,,,世界坐标" << endl;  
  141.     oFile << "x,y,,x,y,,x,y,z" << endl;  
  142.     for (int i=0; i
  143.     {  
  144.         oFile << leftXiaoqiu[i][0] <<","<< leftXiaoqiu[i][1] << ",," << rightXiaoqiu[i][0] <<","<< rightXiaoqiu[i][1]   
  145.         << ",," << worldXiaoqiu[i][0] <<","<<  worldXiaoqiu[i][1] <<","<<  worldXiaoqiu[i][2] << endl;  
  146.     }  
  147.       
  148.   
  149.     //写入花球数据  
  150.     oFile << "花球坐标" << endl;  
  151.     oFile << "左相机坐标,,,右相机坐标,,,世界坐标" << endl;  
  152.     oFile << "x,y,,x,y,,x,y,z" << endl;  
  153.     for (int i=0; i
  154.     {  
  155.         oFile << leftHuaqiu[i][0] <<","<< leftHuaqiu[i][1] << ",," << rightHuaqiu[i][0] <<","<< rightHuaqiu[i][1]   
  156.         << ",," << worldHuaqiu[i][0] <<","<<  worldHuaqiu[i][1] <<","<<  worldHuaqiu[i][2] << endl;  
  157.     }  
  158.   
  159.     //关闭文件  
  160.     oFile.close();    
  161.       
  162.   
  163.     //test  
  164.     ////已知空间坐标求成像坐标  
  165.     //Point3f point(700,220,530);  
  166.     //cout<<"左相机中坐标："<  
  167.     //cout<  
  168.     //cout<<"右相机中坐标："<  
  169.     //cout<  
  170.   
  171.     //已知左右相机成像坐标求空间坐标  
  172.     //Point2f l = xyz2uv(point,leftIntrinsic,leftTranslation,leftRotation);  
  173.     //Point2f r = xyz2uv(point,rightIntrinsic,rightTranslation,rightRotation);  
  174.     //Point3f worldPoint;  
  175.     //worldPoint = uv2xyz(l,r);  
  176.     //cout<<"空间坐标为:"<  
  177.   
  178.   
  179.     /* 
  180.     //csv文件读取部分 
  181.  
  182.     string value;//临时字符串 
  183.     ifstream iFile("三维坐标.csv");//打开要读入的文件 
  184.     //循环行读取 
  185.     while (iFile.good()) 
  186.     { 
  187.         getline(iFile,value); 
  188.         //getline(iFile,value,','); //.csv文件用","作为分隔符 
  189.         cout< 
  190.     } 
  191.     */  
  192.       
  193.     system("pause");  
  194.   
  195.     return 0;  
  196. }  
  197.   
  198. //************************************  
  199. // Description: 修正圆心坐标  
  200. // Method:    initPos  
  201. // FullName:  initPos  
  202. // Access:    public   
  203. // Returns:   void  
  204. // Author:    bhy  
  205. // Date:      2016/12/25  
  206. // History:  
  207. //************************************  
  208. void initPos()  
  209. {  
  210.     //手动修正  
  211.     leftDaqiu[0][0] = 1175;  leftDaqiu[0][1] = 7;     rightDaqiu[0][0] = 256;  rightDaqiu[0][1] = 1;  
  212.     leftDaqiu[1][0] = 823;   leftDaqiu[1][1] = 603;   rightDaqiu[1][0] = 289;  rightDaqiu[1][1] = 431;  
  213.     leftDaqiu[2][0] = 963;   leftDaqiu[2][1] = 360;   rightDaqiu[2][0] = 283;  rightDaqiu[2][1] = 169;  
  214.     leftDaqiu[3][0] = 1065;  leftDaqiu[3][1] = 180;   rightDaqiu[3][0] = 294;  rightDaqiu[3][1] = 1;  
  215.     leftDaqiu[4][0] = 1039;  leftDaqiu[4][1] = 217;   rightDaqiu[4][0] = 314;  rightDaqiu[4][1] = 68;  
  216.     leftDaqiu[5][0] = 896;   leftDaqiu[5][1] = 448;   rightDaqiu[5][0] = 378;  rightDaqiu[5][1] = 402;  
  217.     leftDaqiu[6][0] = 933;   leftDaqiu[6][1] = 376;   rightDaqiu[6][0] = 398;  rightDaqiu[6][1] = 347;  
  218.     leftDaqiu[7][0] = 868;   leftDaqiu[7][1] = 463;   rightDaqiu[7][0] = 423;  rightDaqiu[7][1] = 418;  
  219.     leftDaqiu[8][0] = 878;   leftDaqiu[8][1] = 417;   rightDaqiu[8][0] = 458;  rightDaqiu[8][1] = 466;  
  220.     leftDaqiu[9][0] = 860;   leftDaqiu[9][1] = 423;   rightDaqiu[9][0] = 481;  rightDaqiu[9][1] = 490;  
  221.     leftDaqiu[10][0] = 840;  leftDaqiu[10][1] = 442;  rightDaqiu[10][0] = 499; rightDaqiu[10][1] = 500;  
  222.     leftDaqiu[11][0] = 822;  leftDaqiu[11][1] = 414;  rightDaqiu[11][0] = 523; rightDaqiu[11][1] = 511;  
  223.     leftDaqiu[12][0] = 805;  leftDaqiu[12][1] = 406;  rightDaqiu[12][0] = 538; rightDaqiu[12][1] = 516;  
  224.     leftDaqiu[13][0] = 802;  leftDaqiu[13][1] = 402;  rightDaqiu[13][0] = 549; rightDaqiu[13][1] = 514;  
  225.   
  226.     leftXiaoqiu[0][0] = 1250;   leftXiaoqiu[0][1] = 120;   rightXiaoqiu[0][0] = 308;  rightXiaoqiu[0][1] = 313;  
  227.     leftXiaoqiu[1][0] = 1034;   leftXiaoqiu[1][1] = 481;   rightXiaoqiu[1][0] = 314;  rightXiaoqiu[1][1] = 482;  
  228.     leftXiaoqiu[2][0] = 1207;   leftXiaoqiu[2][1] = 228;   rightXiaoqiu[2][0] = 284;  rightXiaoqiu[2][1] = 186;  
  229.     leftXiaoqiu[3][0] = 1343;   leftXiaoqiu[3][1] = 55;    rightXiaoqiu[3][0] = 252;  rightXiaoqiu[3][1] = -20;  
  230.     leftXiaoqiu[4][0] = 1326;   leftXiaoqiu[4][1] = 102;   rightXiaoqiu[4][0] = 242;  rightXiaoqiu[4][1] = 23;  
  231.     leftXiaoqiu[5][0] = 1021;   leftXiaoqiu[5][1] = 625;   rightXiaoqiu[5][0] = 269;  rightXiaoqiu[5][1] = 632;  
  232.     leftXiaoqiu[6][0] = 1123;   leftXiaoqiu[6][1] = 489;   rightXiaoqiu[6][0] = 241;  rightXiaoqiu[6][1] = 458;  
  233.     leftXiaoqiu[7][0] = 1147;   leftXiaoqiu[7][1] = 475;   rightXiaoqiu[7][0] = 224;  rightXiaoqiu[7][1] = 404;  
  234.     leftXiaoqiu[8][0] = 1078;   leftXiaoqiu[8][1] = 595;   rightXiaoqiu[8][0] = 223;  rightXiaoqiu[8][1] = 558;  
  235.     leftXiaoqiu[9][0] = 1062;   leftXiaoqiu[9][1] = 635;   rightXiaoqiu[9][0] = 216;  rightXiaoqiu[9][1] = 598;  
  236.     leftXiaoqiu[10][0] = 1080;  leftXiaoqiu[10][1] = 619;  rightXiaoqiu[10][0] = 201; rightXiaoqiu[10][1] = 576;  
  237.     leftXiaoqiu[11][0] = 1054;  leftXiaoqiu[11][1] = 690;  rightXiaoqiu[11][0] = 189; rightXiaoqiu[11][1] = 633;  
  238.     leftXiaoqiu[12][0] = 1046;  leftXiaoqiu[12][1] = 724;  rightXiaoqiu[12][0] = 179; rightXiaoqiu[12][1] = 655;  
  239.     leftXiaoqiu[13][0] = 1046;  leftXiaoqiu[13][1] = 726;  rightXiaoqiu[13][0] = 172; rightXiaoqiu[13][1] = 656;  
  240.       
  241.     leftHuaqiu[0][0] = 1075;  leftHuaqiu[0][1] = 111;   rightHuaqiu[0][0] = 120;  rightHuaqiu[0][1] = -30;//出视场  
  242.     leftHuaqiu[1][0] = 708;   leftHuaqiu[1][1] = 810;   rightHuaqiu[1][0] = 142;  rightHuaqiu[1][1] = 382;  
  243.     leftHuaqiu[2][0] = 876;   leftHuaqiu[2][1] = 518;   rightHuaqiu[2][0] = 131;  rightHuaqiu[2][1] = 83;  
  244.     leftHuaqiu[3][0] = 1021;  leftHuaqiu[3][1] = 253;   rightHuaqiu[3][0] = 180;   rightHuaqiu[3][1] = -60;//出视场  
  245.     leftHuaqiu[4][0] = 1019;  leftHuaqiu[4][1] = 248;   rightHuaqiu[4][0] = 183;   rightHuaqiu[4][1] = -30;//出视场  
  246.     leftHuaqiu[5][0] = 764;   leftHuaqiu[5][1] = 654;   rightHuaqiu[5][0] = 278;  rightHuaqiu[5][1] = 437;  
  247.     leftHuaqiu[6][0] = 844;   leftHuaqiu[6][1] = 486;   rightHuaqiu[6][0] = 286;  rightHuaqiu[6][1] = 261;  
  248.     leftHuaqiu[7][0] = 852;   leftHuaqiu[7][1] = 425;   rightHuaqiu[7][0] = 305;  rightHuaqiu[7][1] = 206;  
  249.     leftHuaqiu[8][0] = 780;   leftHuaqiu[8][1] = 523;   rightHuaqiu[8][0] = 347;  rightHuaqiu[8][1] = 359;  
  250.     leftHuaqiu[9][0] = 757;   leftHuaqiu[9][1] = 530;   rightHuaqiu[9][0] = 363;  rightHuaqiu[9][1] = 382;  
  251.     leftHuaqiu[10][0] = 765;  leftHuaqiu[10][1] = 505;  rightHuaqiu[10][0] = 368; rightHuaqiu[10][1] = 345;  
  252.     leftHuaqiu[11][0] = 702;  leftHuaqiu[11][1] = 554;  rightHuaqiu[11][0] = 382; rightHuaqiu[11][1] = 398;  
  253.     leftHuaqiu[12][0] = 666;  leftHuaqiu[12][1] = 573;  rightHuaqiu[12][0] = 386; rightHuaqiu[12][1] = 408;  
  254.     leftHuaqiu[13][0] = 656;  leftHuaqiu[13][1] = 581;  rightHuaqiu[13][0] = 384; rightHuaqiu[13][1] = 398;  
  255. }  
  256.   
  257. //************************************  
  258. // 2016/12/2  by 小白  
  259. // Method:    uv2xyz  
  260. // FullName:  uv2xyz  
  261. // Access:    public   
  262. // Returns:   cv::Point3f       世界坐标  
  263. // Qualifier: 根据左右相机中成像坐标求解空间坐标  
  264. // Parameter: Point2f uvLeft        左相机中成像坐标  
  265. // Parameter: Point2f uvRight       右相机中成像坐标  
  266. //************************************  
  267. Point3f uv2xyz(Point2f uvLeft,Point2f uvRight)  
  268. {  
  269.     //  [u1]      |X|                     [u2]      |X|  
  270.     //Z*|v1| = Ml*|Y|                   Z*|v2| = Mr*|Y|  
  271.     //  [ 1]      |Z|                     [ 1]      |Z|  
  272.     //            |1|                               |1|  
  273.     Mat mLeftRotation = Mat(3,3,CV_32F,leftRotation);  
  274.     Mat mLeftTranslation = Mat(3,1,CV_32F,leftTranslation);  
  275.     Mat mLeftRT = Mat(3,4,CV_32F);//左相机M矩阵  
  276.     hconcat(mLeftRotation,mLeftTranslation,mLeftRT);  
  277.     Mat mLeftIntrinsic = Mat(3,3,CV_32F,leftIntrinsic);  
  278.     Mat mLeftM = mLeftIntrinsic * mLeftRT;  
  279.     //cout<<"左相机M矩阵 = "<  
  280.   
  281.     Mat mRightRotation = Mat(3,3,CV_32F,rightRotation);  
  282.     Mat mRightTranslation = Mat(3,1,CV_32F,rightTranslation);  
  283.     Mat mRightRT = Mat(3,4,CV_32F);//右相机M矩阵  
  284.     hconcat(mRightRotation,mRightTranslation,mRightRT);  
  285.     Mat mRightIntrinsic = Mat(3,3,CV_32F,rightIntrinsic);  
  286.     Mat mRightM = mRightIntrinsic * mRightRT;  
  287.     //cout<<"右相机M矩阵 = "<  
  288.   
  289.     //最小二乘法A矩阵  
  290.     Mat A = Mat(4,3,CV_32F);  
  291.     A.at<float>(0,0) = uvLeft.x * mLeftM.at<float>(2,0) - mLeftM.at<float>(0,0);  
  292.     A.at<float>(0,1) = uvLeft.x * mLeftM.at<float>(2,1) - mLeftM.at<float>(0,1);  
  293.     A.at<float>(0,2) = uvLeft.x * mLeftM.at<float>(2,2) - mLeftM.at<float>(0,2);  
  294.   
  295.     A.at<float>(1,0) = uvLeft.y * mLeftM.at<float>(2,0) - mLeftM.at<float>(1,0);  
  296.     A.at<float>(1,1) = uvLeft.y * mLeftM.at<float>(2,1) - mLeftM.at<float>(1,1);  
  297.     A.at<float>(1,2) = uvLeft.y * mLeftM.at<float>(2,2) - mLeftM.at<float>(1,2);  
  298.   
  299.     A.at<float>(2,0) = uvRight.x * mRightM.at<float>(2,0) - mRightM.at<float>(0,0);  
  300.     A.at<float>(2,1) = uvRight.x * mRightM.at<float>(2,1) - mRightM.at<float>(0,1);  
  301.     A.at<float>(2,2) = uvRight.x * mRightM.at<float>(2,2) - mRightM.at<float>(0,2);  
  302.   
  303.     A.at<float>(3,0) = uvRight.y * mRightM.at<float>(2,0) - mRightM.at<float>(1,0);  
  304.     A.at<float>(3,1) = uvRight.y * mRightM.at<float>(2,1) - mRightM.at<float>(1,1);  
  305.     A.at<float>(3,2) = uvRight.y * mRightM.at<float>(2,2) - mRightM.at<float>(1,2);  
  306.   
  307.     //最小二乘法B矩阵  
  308.     Mat B = Mat(4,1,CV_32F);  
  309.     B.at<float>(0,0) = mLeftM.at<float>(0,3) - uvLeft.x * mLeftM.at<float>(2,3);  
  310.     B.at<float>(1,0) = mLeftM.at<float>(1,3) - uvLeft.y * mLeftM.at<float>(2,3);  
  311.     B.at<float>(2,0) = mRightM.at<float>(0,3) - uvRight.x * mRightM.at<float>(2,3);  
  312.     B.at<float>(3,0) = mRightM.at<float>(1,3) - uvRight.y * mRightM.at<float>(2,3);  
  313.   
  314.     Mat XYZ = Mat(3,1,CV_32F);  
  315.     //采用SVD最小二乘法求解XYZ  
  316.     solve(A,B,XYZ,DECOMP_SVD);  
  317.   
  318.     //cout<<"空间坐标为 = "<  
  319.   
  320.     //世界坐标系中坐标  
  321.     Point3f world;  
  322.     world.x = XYZ.at<float>(0,0);  
  323.     world.y = XYZ.at<float>(1,0);  
  324.     world.z = XYZ.at<float>(2,0);  
  325.   
  326.     return world;  
  327. }  
  328.   
  329. //************************************  
  330. // Description: 将空间坐标转换为像面坐标，用于检验  
  331. // Method:    xyz2uv  
  332. // FullName:  xyz2uv  
  333. // Access:    public   
  334. // Parameter: Point3f worldPoint  
  335. // Parameter: float intrinsic[3][3]  
  336. // Parameter: float translation[1][3]  
  337. // Parameter: float rotation[3][3]  
  338. // Returns:   cv::Point2f  
  339. // Author:    bhy  
  340. // Date:      2016/12/28  
  341. // History:  
  342. //************************************  
  343. Point2f xyz2uv(Point3f worldPoint,float intrinsic[3][3],float translation[1][3],float rotation[3][3])  
  344. {  
  345.     //    [fx s x0]                         [Xc]        [Xw]        [u]   1     [Xc]  
  346.     //K = |0 fy y0|       TEMP = [R T]      |Yc| = TEMP*|Yw|        | | = —*K *|Yc|  
  347.     //    [ 0 0 1 ]                         [Zc]        |Zw|        [v]   Zc    [Zc]  
  348.     //                                                  [1 ]  
  349.     Point3f c;  
  350.     c.x = rotation[0][0]*worldPoint.x + rotation[0][1]*worldPoint.y + rotation[0][2]*worldPoint.z + translation[0][0]*1;  
  351.     c.y = rotation[1][0]*worldPoint.x + rotation[1][1]*worldPoint.y + rotation[1][2]*worldPoint.z + translation[0][1]*1;  
  352.     c.z = rotation[2][0]*worldPoint.x + rotation[2][1]*worldPoint.y + rotation[2][2]*worldPoint.z + translation[0][2]*1;  
  353.   
  354.     Point2f uv;  
  355.     uv.x = (intrinsic[0][0]*c.x + intrinsic[0][1]*c.y + intrinsic[0][2]*c.z)/c.z + 0.5;//加0.5去整 == 四舍五入  
  356.     uv.y = (intrinsic[1][0]*c.x + intrinsic[1][1]*c.y + intrinsic[1][2]*c.z)/c.z + 0.5;//加0.5去整 == 四舍五入  
  357.   
  358.     return uv;  
  359. }  
  360.   
  361.   
  362. //************************************  
  363. // Description: 对畸变校正文件夹下的图片批量进行亮度/对比度调节  
  364. // Method:    ContrastAndBright  
  365. // FullName:  ContrastAndBright  
  366. // Access:    public   
  367. // Parameter: double alpha  
  368. // Parameter: double beta  
  369. // Returns:   void  
  370. // Author:    bhy  
  371. // Date:      2016/12/28  
  372. // History:  
  373. //************************************  
  374. void ContrastAndBright(double alpha, double beta)  
  375. {  
  376.     //double alpha =3;    
  377.     //double beta = 40;   
  378.     cout<<"**********************************************"<
  379.     cout<<"                 亮度/对比度调节              "<
  380.     cout<<"**********************************************"<
  381.   
  382.     cout<<"当前 alpha = "<
  383.     cout<<"当前 beta = "<
  384.   
  385.     Mat src,dst;   
  386.   
  387.     system("md 亮度对比度\\rightky1");  
  388.   
  389.     //右相机调节  
  390.     //如果校正图像目录不存在，则创建该目录  
  391.   
  392.     for (int ii=1; ii<=PicNum; ii++)  
  393.     {  
  394.         cout<<"右：第"<"张图片"<
  395.   
  396.         char* filename = new char[100];  
  397.         sprintf(filename,"畸变校正/rightky1/r%d.bmp",ii);  
  398.         src = imread(filename);//顺次读入图片  
  399.         delete []filename;//释放字符串  
  400.           
  401.         dst = Mat::zeros(src.size(),src.type());//清空目标矩阵  
  402.         //根据alpha,beta重新计算灰度值  
  403.         for (int i = 0;i
  404.             for(int j= 0;j
  405.                 for(int k = 0;k<3;++k)    
  406.                     dst.at(i,j)[k] = saturate_cast(src.at(i,j)[k]*alpha+beta);    
  407.   
  408.         char* output = new char[100];  
  409.         sprintf(output,"亮度对比度/rightky1/r%d.bmp",ii);  
  410.         imwrite(output,dst); //顺次保存校正图  
  411.         delete []output;//释放字符串  
  412.     }  
  413.   
  414.     //左相机调节  
  415.     //如果校正图像目录不存在，则创建该目录  
  416.     system("md 亮度对比度\\leftky1");  
  417.   
  418.     for (int ii=1; ii<=PicNum; ii++)  
  419.     {  
  420.         cout<<"左：第"<"张图片"<
  421.   
  422.         char* filename = new char[100];  
  423.         sprintf(filename,"畸变校正/leftky1/l%d.bmp",ii);  
  424.         src = imread(filename);//顺次读入图片  
  425.         delete []filename;//释放字符串  
  426.   
  427.         dst = Mat::zeros(src.size(),src.type());//清空目标矩阵  
  428.         //根据alpha,beta重新计算灰度值  
  429.         for (int i = 0;i
  430.             for(int j= 0;j
  431.                 for(int k = 0;k<3;++k)    
  432.                     dst.at(i,j)[k] = saturate_cast(src.at(i,j)[k]*alpha+beta);    
  433.   
  434.         char* output = new char[100];  
  435.         sprintf(output,"亮度对比度/leftky1/l%d.bmp",ii);  
  436.         imwrite(output,dst); //顺次保存校正图  
  437.         delete []output;//释放字符串  
  438.     }  
  439.   
  440.     cout<<"**********************************************"<
  441.     cout<<"             亮度/对比度调节结束              "<
  442.     cout<<"**********************************************"<
  443. }  
  444.   
  445. //************************************  
  446. // Description: 对素材文件夹中的图片批量进行畸变校正  
  447. // Method:    CorrectionProcess  
  448. // FullName:  CorrectionProcess  
  449. // Access:    public   
  450. // Returns:   void  
  451. // Author:    bhy  
  452. // Date:      2016/12/28  
  453. // History:  
  454. //************************************  
  455. void CorrectionProcess()  
  456. {  
  457.     cout<<"**********************************************"<
  458.     cout<<"                    畸变校正                  "<
  459.     cout<<"**********************************************"<
  460.   
  461.     Mat image;  
  462.   
  463.     //使用畸变系数与内参校正右相机原图  
  464.     //如果校正图像目录不存在，则创建该目录  
  465.     system("md 畸变校正\\rightky1");  
  466.   
  467.     for (int i=1; i<=PicNum; i++)  
  468.     {  
  469.         cout<<"右：校正第"<"张图片"<
  470.   
  471.         char* filename = new char[100];  
  472.         sprintf(filename,"素材/rightky1/r%d.bmp",i);  
  473.         image = imread(filename,IMREAD_GRAYSCALE);//顺次读入图片  
  474.         delete []filename;//释放字符串  
  475.   
  476.         char* output = new char[100];  
  477.         sprintf(output,"畸变校正/rightky1/r%d.bmp",i);  
  478.         imwrite(output,PictureCorrection(image,rightIntrinsic,rightDistortion)); //顺次保存校正图  
  479.         delete []output;//释放字符串  
  480.     }  
  481.   
  482.     //使用畸变系数与内参校正左相机原图  
  483.     //如果校正图像目录不存在，则创建该目录  
  484.     system("md 畸变校正\\leftky1");  
  485.   
  486.     for (int i=1; i<=PicNum; i++)  
  487.     {  
  488.         cout<<"左：校正第"<"张图片"<
  489.   
  490.         char* filename = new char[100];  
  491.         sprintf(filename,"素材/leftky1/l%d.bmp",i);  
  492.         image = imread(filename,IMREAD_GRAYSCALE);//顺次读入图片  
  493.         delete []filename;//释放字符串  
  494.   
  495.         char* output = new char[100];  
  496.         sprintf(output,"畸变校正/leftky1/l%d.bmp",i);  
  497.         imwrite(output,PictureCorrection(image,leftIntrinsic,leftDistortion)); //顺次保存校正图  
  498.         delete []output;//释放字符串  
  499.     }  
  500.     cout<<"**********************************************"<
  501.     cout<<"                  畸变校正结束                "<
  502.     cout<<"**********************************************"<
  503. }  
  504.   
  505. //************************************  
  506. // Method:    PictureCorrection  
  507. // FullName:  PictureCorrection  
  508. // Access:    public   
  509. // Returns:   cv::Mat   校正图  
  510. // Qualifier: 根据畸变系数与内参校正一张图片  
  511. // Parameter: Mat image  
  512. // Parameter: float intrinsic[3][3]     内参  
  513. // Parameter: float distortion[1][5]    畸变矩阵  
  514. //************************************  
  515. Mat PictureCorrection( Mat image ,float intrinsic[3][3],float distortion[1][5])  
  516. {  
  517.     Size image_size = image.size();  
  518.   
  519.     Mat intrinsic_matrix = Mat(3,3,CV_32FC1,intrinsic);  
  520.     Mat distortion_coeffs = Mat(1,5,CV_32FC1,distortion);  
  521.     Mat R = Mat::eye(3,3,CV_32F);         
  522.     Mat mapx = Mat(image_size,CV_32FC1);  
  523.     Mat mapy = Mat(image_size,CV_32FC1);      
  524.     initUndistortRectifyMap(intrinsic_matrix,distortion_coeffs,R,intrinsic_matrix,image_size,CV_32FC1,mapx,mapy);  
  525.     Mat t = image.clone();  
  526.     cv::remap( image, t, mapx, mapy, INTER_LINEAR);  
  527.     return t;  
  528. }  
  529.   
  530.   
  531. //************************************  
  532. // Description: 采用hough变换求取大球圆心  
  533. // Method:    Daqiu  
  534. // FullName:  Daqiu  
  535. // Access:    public   
  536. // Returns:   void  
  537. // Author:    bhy  
  538. // Date:      2016/12/28  
  539. // History:  
  540. //************************************  
  541. void Daqiu()  
  542. {  
  543.     cout<<"**********************************************"<
  544.     cout<<"                  计算大球圆心                "<
  545.     cout<<"**********************************************"<
  546.   
  547.     Mat img;  
  548.     //右相机 ContrastAndBright(2.5,50);  
  549.     system("md 大球圆心\\rightky1");  
  550.   
  551.     cout<<"右图："<
  552.   
  553.     for (int i=1; i<=PicNum; i++)  
  554.     {  
  555.         stringstream strStm;  
  556.         string strFileName;  
  557.         strStm << i;  
  558.         strStm >> strFileName;  
  559.         strFileName = "亮度对比度/rightky1/r" + strFileName + ".bmp";  
  560.         img = imread(strFileName,IMREAD_GRAYSCALE);  
  561.   
  562.         GaussianBlur(img,img,Size(5,5),0);  
  563.   
  564.         vector circles;  
  565.         HoughCircles( img, circles, CV_HOUGH_GRADIENT, 3 ,70, 70, 30, 95 ,100);//hough圆变换  
  566.         Point2f center(0,0);  
  567.         float radius;  
  568.         for (int j = 0; j < circles.size(); j++)  
  569.         {  
  570.             if (circles[j][0] > center.x && circles[j][0] < img.cols/2)  
  571.             {  
  572.                 center.x = circles[j][0];  
  573.                 center.y = circles[j][1];  
  574.                 radius = circles[j][2];//半径   
  575.             }  
  576.         }  
  577.   
  578.         rightDaqiu[i-1][0] = center.x;  
  579.         rightDaqiu[i-1][1] = center.y;  
  580.   
  581.         CvScalar color = CV_RGB(0,0,0);  
  582.         circle( img, (Point)center, radius, color, 3, 8, 0);//绘制圆  
  583.         circle( img, (Point)center, 3, color, 3, 8, 0);//绘制圆心  
  584.         cout<<"圆心:"<//为了保证精度，以原值输出  
  585.   
  586.         char* output = new char[100];  
  587.         sprintf(output,"大球圆心/rightky1/r%d.bmp",i);  
  588.         imwrite(output,img); //顺次保存校正图  
  589.         delete []output;//释放字符串  
  590.     }  
  591.   
  592.     system("md 大球圆心\\leftky1");  
  593.   
  594.     cout<<"左图："<
  595.   
  596.     for (int i=1; i<=PicNum; i++)  
  597.     {  
  598.         stringstream strStm;  
  599.         string strFileName;  
  600.         strStm << i;  
  601.         strStm >> strFileName;  
  602.         strFileName = "亮度对比度/leftky1/l" + strFileName + ".bmp";  
  603.         img = imread(strFileName,IMREAD_GRAYSCALE);  
  604.   
  605.         GaussianBlur(img,img,Size(5,5),0);  
  606.   
  607.         vector circles;  
  608.         HoughCircles( img, circles, CV_HOUGH_GRADIENT, 3 ,70, 30, 50, 100 ,110);//hough圆变换  
  609.         Point2f center(0,1024);  
  610.         float radius;  
  611.         for (int j = 0; j < circles.size(); j++)  
  612.         {  
  613.             if (circles[j][1]
  614.             {  
  615.                 center.x = circles[j][0];  
  616.                 center.y = circles[j][1];  
  617.                 radius = circles[j][2];//半径  
  618.             }  
  619.         }  
  620.         leftDaqiu[i-1][0] = center.x;  
  621.         leftDaqiu[i-1][1] = center.y;  
  622.   
  623.         CvScalar color = CV_RGB(0,0,0);  
  624.         circle( img, center, radius, color, 3, 8, 0);//绘制圆  
  625.         circle( img, center, 3, color, 3, 8, 0);//绘制圆心  
  626.         cout<<"圆心:"<//为了保证精度，以原值输出  
  627.   
  628.         char* output = new char[100];  
  629.         sprintf(output,"大球圆心/leftky1/l%d.bmp",i);  
  630.         imwrite(output,img); //顺次保存校正图  
  631.         delete []output;//释放字符串  
  632.     }  
  633.   
  634.     cout<<"**********************************************"<
  635.     cout<<"                  圆心计算结束                "<
  636.     cout<<"**********************************************"<
  637. }  


 

运行该程序，会提取生成的“三维坐标.csv”中的空间坐标数据，并绘制运动轨迹需要注意的是，在“三维坐标.csv”文件中直接修改圆心坐标没有用，需要在工程中的initPos()修改。

[cpp] view plain copy
  1. clc;clear;  
  2. M = csvread('三维坐标.csv',3,6,[3,6,16,8]);  
  3. x = M(:,1);  
  4. y = M(:,2);  
  5. z = M(:,3);  
  6. plot3(x,y,z,'r');  
  7. %legend('大球');  
  8. hold on  
  9.   
  10. M = csvread('三维坐标.csv',20,6,[20,6,33,8]);  
  11. x = M(:,1);  
  12. y = M(:,2);  
  13. z = M(:,3);  
  14. plot3(x,y,z,'g');  
  15. %legend('小球');  
  16. hold on  
  17.   
  18. M = csvread('三维坐标.csv',37,6,[37,6,50,8]);  
  19. x = M(:,1);  
  20. y = M(:,2);  
  21. z = M(:,3);  
  22. plot3(x,y,z,'b');  
  23. %legend('花球');  
  24. hold on  
  25.   
  26. legend('大球','小球','花球');  
  27. title('小球运动轨迹');  
  28. xlabel('x');  
  29. ylabel('y');  
  30. zlabel('z');  
  31. grid on  
  32. axis square  


最后绘制的轨迹图

双目视觉下空间坐标计算/双目测距_第16张图片

 

 补一张世界坐标系的图

双目视觉下空间坐标计算/双目测距_第17张图片

你可能感兴趣的:(opencv)

  • 利用 OpenCV 库进行实时目标物体检测 欣然～ opencv人工智能计算机视觉
    一、代码概述此代码利用OpenCV库实现了基于特征匹配的实时物体检测系统。通过摄像头捕获实时视频帧，将其与预先加载的参考图像进行特征匹配，从而识别出视频帧中是否存在与参考图像匹配的物体。二、环境依赖OpenCV：用于图像处理、特征提取和匹配等操作。NumPy：用于数值计算，OpenCV依赖于NumPy进行数组操作。可以使用以下命令安装所需库：bashpipinstallopencv-pythonn
  • OpenCV | 图像读取与显示 ToBeCertain OpenCVopencv人工智能计算机视觉
    OpenCV对图像进行处理时，常用API如下：API描述cv.imread根据给定的磁盘路径加载对应的图像，默认使用BGR方式加载cv.imshow展示图像cv.imwrite将图像保存到磁盘中cv.waitKey暂停一段时间，接受键盘输出后，继续执行程序cv.destroyAllWindows释放所有资源目录一.OpenCV基本操作函数1.cv.imread()图像读取2.cv.imshow()
  • opencv图像视频的加载和显示 NDNPOMDFLR opencvpython
    opencv图像视频的加载和显示基于上篇文章，在开始之前需要在上级目录里打开jupyternotebook首先需要进入scrips目录里进行激活，然后如果在该目录下输入jupyternotebook的话，不太好所以需要进入上级目录创建和显示窗口需要牢记的命令namedWindow()创建命令窗口imshow()显示窗口destroyAllwindows()摧毁窗口resizeWindow()改变窗
  • cv2.imshow报错 残影飞雪 Pythonpython
    pipinstallopencv-contrib-pythoncv2.error:OpenCV(4.1.0)C:\projects\opencv-python\opencv\modules\highgui\src\window.cpp:627:error:(-2:Unspecifiederror)Thefunctionisnotimplemented.RebuildthelibrarywithWi
  • 解决OpenCV读取目标图像，cv2.imshow出现闪退的问题 写python的鑫哥 OpenCV入门与进阶opencv人工智能计算机视觉python图像显示闪退
    前言本文是该专栏的第17篇，后面将持续分享OpenCV计算机视觉的干货知识，记得关注。最近有粉丝朋友询问到OpenCV读取目标图像出现的一个问题，在基于python语言“使用OpenCV读取目标图像的时候，利用cv2.imshow函数出现闪退”的情况。而本文，笔者将详细介绍针对上述问题，给出一个详细的应对思路以及解决方法。废话不多说，具体的细节部分以及详细的解决方案，跟着笔者直接往下看正文详细内容
  • windows python opencv imshow图片报错解决 热爱生活热爱你 python3opencv人工智能计算机视觉
    importcv2#检查版本print(cv2.__version__)#加载一张图片（确保你有一个名为'test.jpg'的文件在当前目录）image=cv2.imread('C:\\test1.jpg')#显示图片cv2.imshow('image',image)cv2.waitKey(0)cv2.destroyAllWindows()cv2意思是opencvc++o(*￣︶￣*)o建议使用A
  • OpenCV 深度学习模块 cv2.dnn 与其他深度学习框架的优缺点对比及适用场景 白.夜 深度学习opencv
    OpenCV提供了一个深度学习模块cv2.dnn，让开发者能够在计算机视觉项目中轻松加载和推理深度学习模型。相比于TensorFlow、PyTorch等其他深度学习框架，cv2.dnn有其独特的优点与缺点，适用于不同的应用场景。在这篇文章中，我们将详细分析cv2.dnn的优缺点，并讨论它的适用场景。一、cv2.dnn的优点1.简单易用cv2.dnn提供了一个相对简单且易于使用的接口，适合已经在使用
  • 深度学习中的 blob 格式：与普通 image 的区别及转换原因 白.夜 深度学习人工智能
    在深度学习模型推理过程中，我们经常会用到cv2.dnn.blobFromImage函数将普通图像转换为blob格式。那么，blob格式到底是什么？它和普通image有什么区别？为什么在模型推理中需要这种转换？本文将用通俗的语言为你解答这些问题。1.什么是blob格式？blob是OpenCV中用于深度学习模型输入的一种特殊数据格式，全称为BinaryLargeObject。它本质上是一个多维数组（通
  • python opencv轮廓检测_python opencv中的不规则形状检测和测量 weixin_39584529 pythonopencv轮廓检测
    正如我在评论中提到的那样,对于这个问题,分水岭似乎是一个很好的方法.但是当你回答时,定义标记的前景和背景是困难的部分！我的想法是使用形态梯度沿着冰晶获得良好的边缘并从那里开始工作;形态梯度似乎很有效.importnumpyasnpimportcv2img=cv2.imread('image.png')blur=cv2.GaussianBlur(img,(7,7),2)h,w=img.shape[:
  • OpenCV学习(二十一) ：计算图像连通分量:connectedComponents(),connectedComponentsWithStats() Leon_Chen0 OpenCV
    OpenCV学习(二十一)：计算图像连通分量:connectedComponents(),connectedComponentsWithStats()1、connectedComponents()函数ConnectedComponents即连通体算法用id标注图中每个连通体，将连通体中序号最小的顶点的id作为连通体的id。如果在图G中，任意2个顶点之间都存在路径，那么称G为连通图，否则称该图为非连
  • OpenCV图像基础 天行者@ opencv人工智能计算机视觉
    OpenCV其实就是一堆C和C++语言的源代码文件,这些源代码文件中实现了许多常用的计算机视觉算法。OpenCV的全称是OpenSourceComputerVisionLibrary,是一个开放源代码的计算机视觉库OpenCV最初由英特尔公司发起并开发,以BSD许可证授权发行,可以在商业和研究领域中免费使用,现在美国WillowGarage为OpenCV提供主要的支持OpenCV可用于开发实时的图
  • android 基于OpenCV4.8微笑检测自动拍照 mmsx android作业源码分享androidopencv
    一，前言1、基于OpenCV4.8微笑检测自动拍照存储2、左侧有一个预览小框，有人脸时候会有红色框框。3、当真人入境时候，微笑。相机预览捕捉到了人的微笑，自动拍照保存。opencv库的编译就不说了。这篇有介绍：androidopencv导入进行编译_编译androidopencv-CSDN博客二、加载人脸特征和微笑特征文件faceCascade=loadCascade(R.raw.haarcasc
  • 67-OpenCVSharp 创建实现Halcon的tile_images_offset算子（用于图像拼接，对每张图像设置偏移量） 搬码驿站 #opencv计算机视觉人工智能算法图像处理
    以下是基于OpenCvSharp实现的Halcontile_images_offset算子的高性能函数。该函数不仅支持图像拼接，还允许对每张图像设置偏移量（offset），以灵活布局图像。代码中包含了详细注释和性能优化策略。为了优化运行时间和性能，我们可以从以下几个方面对代码进行改进：并行处理：利用多核CPU的能力，通过Parallel.For或其他并行技术加速图像复制操作。减少边界检查开销：在确
  • 【视频】V4L2、ffmpeg、OpenCV中对YUV的定义 郭老二 视频音视频ffmpegopencv
    1、常见的YUV格式1.1YUV420每像素16位IMC1：YYYYYYYYVV--UU–IMC3：YYYYYYYYUU--VV–每像素12位I420:YYYYYYYYUUVV=>YUV420PYV12:YYYYYYYYVVUU=>YUV420PNV12:YYYYYYYYUVUV=>YUV420SP（最受欢迎格式）NV21:YYYYYYYYVUVU=>YUV420SPIMC2：YYYYYYYYYY
  • 20250310：OpenCV mat对象与base64互转 微风❤水墨 AI模型部署Mat转base64
    代码：https://github.com/ReneNyffenegger/cpp-base64指南：https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp/实操：
  • opencv python 光流法 weixin_34241036 人工智能python
    OpticalFlow光流法光流是由对象或相机的移动引起的两个连续帧之间的图像对象的明显运动的模式.它是2D矢量场，其中每个矢量是位移矢量，表示从第一帧到第二帧的点的移动.上图表示的是一个球在连续的5帧图像中的运动,箭头显示其位移矢量.光流法原理的基础：目标像素强度在连续帧之间不变相邻像素具有相似的运动第一帧的像素I(x,y,t),在dt时间之后的下一帧中移动距离(dx，dy),因为这些像素是相同
  • OpenCV-Python 光流 LeonDL168 Opencv-Pythonopencvpython人工智能
    40.1光流由于目标对象或者摄像机的移动造成的图像对象在连续两帧图像中的移动被称为光流。它是一个2D向量场，可以用来显示一个点从第一帧图像到第二帧图像之间的移动。如下图所示（ImageCourtesy:WikipediaarticleonOpticalFlow）：OpticalFlow上图显示了一个点在连续的五帧图像间的移动。箭头表示光流场向量。光流在很多领域中都很有用：•由运动重建结构•视频压缩
  • 【全流程】配置 Jetson Nano 摄像头使用 GStreamer 传输 RTSP 流到本地（整合版） 咚叶大人 visualstudiotcp/ip硬件架构实时音视频计算机视觉
    文末附录内容：【本地编译OpenCV支持GStreamer（Windows方案）】写在前面：为什么选择GStreamer？在JetsonNano这样的微机平台中，我们选择视频流传输工具时应该综合考虑硬件兼容性、延迟、资源占用和开发效率这几个方面。以下是GStreamer与其他常见几种工具做对比：工具/框架优势局限性适用场景GStreamer✅深度整合NVIDIA硬件编码（NVENC/NVDEC）✅
  • Python----计算机视觉处理（opencv：像素，RGB颜色，图像的存储，opencv安装，代码展示） 蹦蹦跳跳真可爱589 Pythonopencv图像处理计算机视觉pythonopencv人工智能
    一、计算机眼中的图像像素像素是图像的基本单元，每个像素存储着图像的颜色、亮度和其他特征。一系列像素组合到一起就形成了完整的图像，在计算机中，图像以像素的形式存在并采用二进制格式进行存储。根据图像的颜色不同，每个像素可以用不同的二进制数表示。日常生活中常见的图像是RGB三原色图。RGB图上的每个点都是由红（R）、绿（G）、蓝（B）三个颜色按照一定比例混合而成的，几乎所有颜色都可以通过这三种颜色按照不
  • 九点标定 opencv 方式实现 手眼标定 孙春泉 opencv计算机视觉微信小程序
    opencv获取中心点位置代码：MatSrcMat(nImgWidth,nImgHeight,CV_8UC3);UCharToMat(pSrcImg,nImgHeight,nImgWidth,24,SrcMat);MatgrayMat;cvtColor(SrcMat,grayMat,COLOR_BGR2GRAY);MatbinMat=cv::Mat::zeros(SrcMat.size(),CV_
  • 【Python+OpenCV实战】手把手教你打造自定义视频播放器 m0_54877156 计算机视觉pythonopencv
    随着计算机视觉技术的发展，Python作为其主要开发语言，搭配强大的OpenCV库，为我们提供了无比丰富的功能和可能性。今天，我们将一起踏入这个奇妙的世界，通过Python和cv2来实现一款自定义的视频播放器，让你在理解基础原理的同时，也能亲手打造出属于自己的酷炫工具。首先我们需要确保安装了必要的库pipinstallopencv-python安装完毕之后我们就可以正式开始了。1.导入OpenCV
  • 用OpenCV写个视频播放器可还行？（Python版） 程序员Linc 计算机视觉opencv音视频python
    引言提到OpenCV，大家首先想到的可能是图像处理、目标检测，但你是否想过——用OpenCV实现一个带进度条、倍速播放、暂停功能的视频播放器？本文将通过一个实战项目，带你深入掌握OpenCV的视频处理能力，并解锁以下功能：基础播放/暂停动态倍速调节（0.5x~4x）交互式进度条实时时间戳显示文末提供完整代码，可直接运行！一、环境准备安装OpenCVpipinstallopencv-python#P
  • 常用图像增强算法原理及 OpenCV C++ 实现 埃菲尔铁塔_CV算法 opencv计算机视觉人工智能c++算法机器学习
    一、引言图像增强是数字图像处理中的一个重要分支，其目的是改善图像的视觉效果，突出图像中的重要信息，或者将图像转换为更适合人或机器分析处理的形式。在实际应用中，图像增强技术广泛应用于医学影像、遥感图像、安防监控等领域。本文将详细介绍常用的图像增强算法原理，并给出基于OpenCVC++库的实现代码。二、图像增强算法分类图像增强算法可以分为空间域增强和频域增强两大类。空间域增强是直接对图像的像素值进行操
  • opencv借助ffmpeg读取sdp文件进行rtp拉流 20231019 诗筱涵 rtsp用简单代码实现功能OpenCVrtp
    20231019ffmpeg装起来很快编译命令g++rtp_ffmpeg_test.cpp-ooutput$(pkg-config--libsopencv4)代码如下#include#include#include#includeusingnamespacestd;usingnamespacecv;intmain(intargc,char**argv){cout>frame;if(frame.em
  • 【OpenCV C++】存图，如何以时间命名，“年月日-时分秒“产生唯一的文件名呢？“年月日-时分秒-毫秒“ 自动检查存储目录，若不存在自动创建存图 R-G-B OpenCVC++C/C++opencvc++人工智能
    文章目录1生成文件名（格式:"年月日-时分秒"格式）2生成文件名（格式:"年月日-时分秒-毫秒"）3多模式存图函数4综合调用实例5注意：默认参数只能在头文件中定义，不能在实现中重复默认参数mode==1→“年月日-时分”→YYYYMMDD-HHMM的文件名；例如：20250310-1647mode==2→"年月日-时分秒-毫秒"→YYYYMMDD-HHMMSS-MMM（适用采集存储帧率搞得图片，增
  • SOPHON SDK解码视频流的常见调试方法 算能开发者社区 SOPHONSDK常见问题linux人工智能
    SOPHONSDK解码视频流的常见调试方法1.rtsp连接测试2.判断rtsp是否正常工作3.确认解码器是否能正常工作：（url为文件名或者rtsp连接地址）4.确认解码器和vpp的OpenCV接口是否正常工作5.解码不正确或者无法解码的最终调试手段1.rtsp连接测试ffmpeg-rtsp_transporttcp-iurl-frawvideo-y/dev/null或者ffmpeg-rtsp_t
  • 人脸识别，dlib优化，Dlib/OpenCV交叉编译 yiyayiya557 linux嵌入式
    参考文章：GitRepo镜像使用帮助https://mirrors.tuna.tsinghua.edu.cn/help/git-repo/交叉编译Dlib+OpenCV交叉编译移植到ARM64-v8平台（编译不通过，不可用）https://blog.csdn.net/kaychangeek/article/details/80365320Qt移植到ARM64-v8平台(NXPi.MX8M)笔记（未
  • 智能遥感新质生产力：ChatGPT、Python和OpenCV强强联合；空天地遥感数据分析的全流程；地面数据、无人机数据、卫星数据、多源数据等处理 小艳加油 DeepSeekChatGPT遥感遥感新质生产力ChatGPTOpenCV遥感数据处理
    通过系统化的模块设计和丰富的实战案例，深入理解和掌握遥感数据的处理与计算。不仅涵盖了从零基础入门Python编程、OpenCV视觉处理的基础知识，还将借助ChatGPT智能支持，引导您掌握遥感影像识别和分析的进阶技术。更为重要的是，通过15个经过精心设计的真实案例，深度参与地质监测、城市规划、农业分析、生态评估等不同场景下的遥感应用实践。层层递进、结构严谨，帮助您系统性掌握从数据预处理、图像增强、
  • opencv cuda例程 OpenCV和Cuda结合编程 weixin_44602056 opencvC++
    本文转载自：https://www.fuwuqizhijia.com/linux/201704/70863.html此网页，仅保存下来供随时查看一、利用OpenCV中提供的GPU模块目前，OpenCV中已提供了许多GPU函数，直接使用OpenCV提供的GPU模块，可以完成大部分图像处理的加速操作。该方法的优点是使用简单，利用GpuMat管理CPU与GPU之间的数据传输，而且不需要关注内核函数调用参
  • OpenCV连续数字识别—可运行验证 正冬升 OpenCVopencv人工智能计算机视觉
    前言文章开始，瞎说一点其他的东西，真的是很离谱，找了至少两三个小时，就一个简单的需求：1、利用OpenCV在Windows进行抓图2、利用OpenCV进行连续数字的检测。3、使用C++，Qt3、将检测的结果显示出来就这么简单的需求，结果网上找了各种版本硬是找不到,要是代码可能没啥问题，但是运行不了，你这运行不了，我怎么知道你到底能不能用，我代码调半天能用了，结果你跟我说最后效果不好，为啥呢？因为图
  • JAVA基础 灵静志远 位运算加载Date字符串池覆盖
    一、类的初始化顺序 1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器 同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。 二、String 1 String a = "abc"; JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
  • keepalived实现redis主从高可用 bylijinnan redis
    方案说明 两台机器（称为A和B），以统一的VIP对外提供服务 1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
  • java文件操作大全 0624chenhong java
    最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 一.获得控制台用户输入的信息    &nbs
  • android学习任务 不懂事的小屁孩 工作
    任务 完成情况 搞清楚带箭头的pupupwindows和不带的使用 已完成 熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成 熟练使用android的线程handler,并敲示例代码 进行中 了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar 研究一下android的动画效果，写一个实例 已完成 复习fragem
  • zoom.js 换个号韩国红果果 oom
    它的基于bootstrap 的 https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序 <link rel="stylesheet" href="style/zoom.css"> <script src=&q
  • 详解Oracle云操作系统Solaris 11.2 蓝儿唯美 Solaris
    当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。 
  • spring学习——springmvc（一） a-john springMVC
    Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。   1，跟踪Spring MVC的请求 请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
  • hdu4342 History repeat itself-------多校联合五 aijuans 数论
    水题就不多说什么了。 #include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--)
  • EJB和javabean的区别 asia007 beanejb
    EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了   1.EJB用于服务端应用开发, 而JavaBeans
  • Struts的action和Result总结 百合不是茶 strutsAction配置Result配置
        一:Action的配置详解:      下面是一个Struts中一个空的Struts.xml的配置文件     <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC &quo
  • 如何带好自已的团队 bijian1013 项目管理团队管理团队
    在网上看到博客" 怎么才能让团队成员好好干活"的评论，觉得写的比较好。 原文如下： 我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 1.诚信         对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
  • Java代码混淆工具 sunjing ProGuard
    Open Source Obfuscators ProGuard http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
  • 【Redis三】基于Redis sentinel的自动failover主从复制 bit1129 redis
    在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。   什么是Sentine
  • 使用代理实现Hibernate Dao层自动事务 白糖_ DAOspringAOP框架Hibernate
    都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 public void save(Object obj){ Session session = this.getSession(); Transaction tran = session.beginTransaction(); try
  • maven3实战读书笔记 braveCS maven3
    Maven简介 是什么？ Is a software project management and comprehension tool.项目管理工具 是基于POM概念(工程对象模型) [设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] [与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区]     功能：
  • 编程之美-子数组的最大乘积 bylijinnan 编程之美
    public class MaxProduct { /** * 编程之美 子数组的最大乘积 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。 * 但按题目的意思，是要求得这个子数组，而不
  • 读书笔记-2 chengxuyuancsdn 读书笔记
    1、反射 2、oracle年-月-日 时-分-秒 3、oracle创建有参、无参函数 4、oracle行转列 5、Struts2拦截器 6、Filter过滤器(web.xml) 1、反射 (1)检查类的结构 在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。 2、oracle年月日时分秒 s
  • [求学与房地产]慎重选择IT培训学校 comsci it
          关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题       培训学校的教学楼和宿舍的环境和稳定性问题       我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... &nb
  • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 daizj oraclermanfilespersetPARALLELISM
    RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转 PARALLELISM --- 我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： RMAN > configure device type disk parallelism 3 ; 表示启动三个通道，可以加快备份恢复的速度。
  • 简单排序:冒泡排序 dieslrae 冒泡排序
    public void bubbleSort(int[] array){ for(int i=1;i<array.length;i++){ for(int k=0;k<array.length-i;k++){ if(array[k] > array[k+1]){
  • 初二上学期难记单词三 dcj3sjt126com sciet
    concert 音乐会 tonight 今晚 famous 有名的；著名的 song 歌曲 thousand 千 accident 事故；灾难 careless 粗心的，大意的 break 折断；断裂；破碎 heart 心（脏） happen  偶尔发生，碰巧 tourist 旅游者；观光者 science （自然）科学 marry 结婚 subject 题目；
  • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码 dcj3sjt126com redis
    wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-stable make   前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。 异常一： make[2]: cc: Command not found 异常原因：没有安装g
  • 并发容器 shuizhaosi888 并发容器
       通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。    并发容器ConcurrentHashMap       替代同步基于散列的Map，通过Lock控制。   &nb
  • Spring Security（12）——Remember-Me功能 234390216 Spring SecurityRemember Me记住我
    Remember-Me功能   目录   1.1     概述 1.2     基于简单加密token的方法 1.3     基于持久化token的方法 1.4     Remember-Me相关接口和实现
  • 位运算 焦志广 位运算
    一、位运算符Ｃ语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 例如：9&am
  • nodejs 数据库连接 mongodb mysql liguangsong mongodbmysqlnode数据库连接
    1.mysql 连接    package.json中dependencies加入     "mysql":"~2.7.0"    执行 npm install      在config 下创建文件 database.js    
  • java动态编译 olive6615 javaHotSpotjvm动态编译
        在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。     HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
  • Storm0.9.5的集群部署配置优化 roadrunners 优化storm.yaml
    nimbus结点配置（storm.yaml）信息： # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional inf
  • 101个MySQL 的调节和优化的提示 tomcat_oracle mysql
    　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。 　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。 　　3. 使用电池供电的RAM（注：RAM即随机存储器）。 　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
  • zoj 3829 Known Notation(贪心) 阿尔萨斯 ZOJ
    题目链接：zoj 3829 Known Notation 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。 解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他