小白的进阶
小白的进阶

立体视觉标定和校正

1.读取左右相机图片序列

双目相机的图片序列放在Demon的路径下，左右相机的图像的名字分别存放在两个txt文件中，程序分别通过这两个txt文件读取对应的图片序列。主注意：我们假设已经将摄像机排列好了，其图像扫描线是粗略物理对齐，从而使得每台摄像机本质上都具有相同的视场。

2.提取图片角点，并分别标定左右相机内参矩阵和畸变向量

调用cvFindChessboardCorners找出图像中的角点，然后调用cvFindCornerSubPix计算亚像素精度角点位置，将全部找出来的角点位置压入一个矩阵序列中，以及初始化角点在世界坐标系的对应位置序列，本程序的世界坐标系长度单位取标定板放个边长。然后用cvCalibrateCamera2分别标定做右相机的内参矩阵和畸变系数向量。将该过程封装成一个函数，具体过程请参考程序注释：

[cpp]  view plain  copy
  1. /*单个相机标定函数： 
  2. 输入参数： 
  3. const char* imageList      IN保存图片名的txt文件 
  4. CvMat* object_points       OUT世界坐标系点的矩阵 
  5. CvMat* image_points        OUT图像坐标系矩阵 
  6. CvMat* intrinsic_matrix    OUT返回的内参数矩阵 
  7. CvMat* distortion_coeffs   OUT返回的畸变向量 
  8. int n_boards               IN图片的数量 
  9. int board_w                IN每张图片x方向角点数量 
  10. int board_h                IN每张图片y方向角点数量 
  11. CvSize* imgSize            OUT每张图片的像素尺寸 
  12. */  
  13. static void SingleCalib(const char* imageList, CvMat* object_points, CvMat* image_points, CvMat* intrinsic_matrix, CvMat* distortion_coeffs,  
  14.     int n_boards, int board_w, int board_h, CvSize* imgSize)  
  15. {  
  16.     //定义文件类  
  17.     FILE* f;  
  18.     fopen_s(&f, imageList, "rt");  
  19.   
  20.     int board_n = board_w*board_h;//每张图片中角点总数量  
  21.     CvSize board_sz = cvSize(board_w, board_h);//角点尺寸矩阵  
  22.   
  23.     CvPoint2D32f* corners = new CvPoint2D32f[board_w*board_h];//定义用于存放每张图片角点数量的一维点数组  
  24.     CvMat* point_counts = cvCreateMat(n_boards, 1, CV_32SC1);//向量，每个元素代表每张图片角点的数量  
  25.     int successes = 0;//找到全部角点的图片数量  
  26.     int step = 0;//用于记录每张图片角点的起始位置  
  27.   
  28.     //文件读取不成功:  
  29.     if (!f)  
  30.     {  
  31.         fprintf(stderr, "can not open file %s\n", imageList);//要读写, 得知道从哪里读, 往哪里写吧?stderr -- 标准错误输出设备  
  32.         return;  
  33.     }  
  34.     //利用i循环读取文件中的字符，然后用于读取图片  
  35.     for (int i = 0;; i++)  
  36.     {  
  37.         //读取图片  
  38.         char buf[1024];//存放读取的字符数组  
  39.         int count = 0, result = 0;//count找的的角点数量，result找角点结果标志，全部角点找到非零，否者为0；  
  40.   
  41.         if (!fgets(buf, sizeof(buf)-3, f))//提取文件的字符存放到buf  
  42.             break;  
  43.         size_t len = strlen(buf);//len为字符数组的长度  
  44.         while (len > 0 && isspace(buf[len - 1]))//int isspace(int c)检查参数c是否为空格字符，也就是判断是否为空格(' ')、定位字符(' \t ')、CR(' \r ')、换行(' \n ')  
  45.             buf[--len] = '\0';                  //、垂直定位字符(' \v ')或翻页(' \f ')的情况。，既在非空白字符的后面以为添加‘\0’  
  46.         if (buf[0] == '#')//开头为'#',结束此次循环  
  47.             continue;  
  48.         IplImage* img = cvLoadImage(buf, 0);//读取图片  
  49.         if (!img)  
  50.             break;  
  51.         //获取图片尺寸  
  52.         *imgSize = cvGetSize(img);  
  53.         //提取角点  
  54.         result = cvFindChessboardCorners(img, cvSize(board_w, board_h), corners, &count, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE);  
  55.   
  56.         if (result)  
  57.         {  
  58.             //Calibration will suffer without subpixel interpolation  
  59.             //函数 cvFindCornerSubPix 通过迭代来发现具有亚象素精度的角点位置  
  60.             cvFindCornerSubPix(img, corners, count, cvSize(11, 11), cvSize(-1, -1), cvTermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));  
  61.             /*TermCriteria迭代算法的终止准则: 
  62.             typedef struct CvTermCriteria0d 
  63.             { 
  64.             int    type;  CV_TERMCRIT_ITER 和CV_TERMCRIT_EPS二值之一，或者二者的组合 
  65.             int    max_iter; 最大迭代次数 
  66.             double epsilon; 结果的精确性 
  67.             } 
  68.             一般表示迭代终止的条件，如果为CV_TERMCRIT_ITER，则用最大迭代次数作为终止条件，如果为CV_TERMCRIT_EPS 则用精度作为迭代条件， 
  69.             如果为CV_TERMCRIT_ITER+CV_TERMCRIT_EPS则用最大迭代次数或者精度作为迭代条件，看哪个条件先满足。*/  
  70.   
  71.             //开始保存角点的其实位置  
  72.             step = successes*board_n;  
  73.             //将角点从数组corners压入矩阵image_points；以及给对应的object_points赋值  
  74.             for (int i = step, j = 0; j < board_n; ++i, ++j)  
  75.             {  
  76.                 CV_MAT_ELEM(*image_points, float, i, 0) = corners[j].x;  
  77.                 CV_MAT_ELEM(*image_points, float, i, 1) = corners[j].y;  
  78.                 CV_MAT_ELEM(*object_points, float, i, 0) = (j / board_w);  
  79.                 CV_MAT_ELEM(*object_points, float, i, 1) = (j % board_w);  
  80.                 CV_MAT_ELEM(*object_points, float, i, 2) = 0.0f;  
  81.             }  
  82.             //给对应图片的point_counts赋值  
  83.             CV_MAT_ELEM(*point_counts, int, successes, 0) = board_n;  
  84.             successes++;  
  85.         }  
  86.         //释放该角点图像  
  87.         cvReleaseImage(&img);  
  88.     }  
  89.     //关闭文件  
  90.     fclose(f);  
  91.   
  92.     //初始化相机内参矩阵  
  93.     CV_MAT_ELEM(*intrinsic_matrix, float, 0, 0) = 1.0f;  
  94.     CV_MAT_ELEM(*intrinsic_matrix, float, 1, 1) = 1.0f;  
  95.     //标定相机的内参矩阵和畸变系数向量  
  96.     cvCalibrateCamera2(object_points, image_points, point_counts, *imgSize, intrinsic_matrix, distortion_coeffs, NULL, NULL, 0);  
  97.   
  98. }  

3.立体标定，计算两摄像机相对旋转矩阵 R,平移向量 T, 本征矩阵E, 基础矩阵F

第2步获得了在世界坐标系和图片坐标系下角点位置序列，以及两个相机的内参矩阵和畸变系数向量，然后调用cvStereoCalibrate计算摄像机相对旋转矩阵 R,平移向量 T, 本征矩阵E, 基础矩阵F,，并同时调整第2步计算的做右相机内参矩阵和畸变系数向量。但是处于个人习惯还是喜欢将该过程封装到一个函数里:

[cpp]  view plain  copy
  1. static void StereoCalib(CvMat* _left_object_points, CvMat* _left_image_points, CvMat* _right_image_points, CvMat* left_intrinsic, CvMat* right_intrinsic,  
  2.     CvMat* left_distortion, CvMat* right_distortion, CvMat* _R, CvMat* _T, CvMat* _E, CvMat* _F, int _n_boards, int _board_w, int _board_h, CvSize _imgSize)  
  3. {  
  4.     int board_n = _board_w*_board_h;//每张图片中角点总数量  
  5.   
  6.     //初始化Number_perImg  
  7.     CvMat* Number_perImg = cvCreateMat(1, _n_boards, CV_32SC1);  
  8.     int* pInt;  
  9.     pInt = (int*)(Number_perImg->data.ptr);  
  10.     for (int i = 0; i < _n_boards; ++i)  
  11.     {  
  12.         *pInt = board_n;  
  13.         pInt++;  
  14.     }  
  15.     //Show(用于调试)  
  16.     /*for (int i = 0; i < _n_boards; i++) 
  17.     { 
  18.     cout << CV_MAT_ELEM(*Number_perImg, int, 0, i) << endl; 
  19.     }*/  
  20.   
  21.       
  22.     //立体标定.计算 _R, _T, _E, _F,，并同时调整Number_perImg, left_intrinsic, D_left,right_intrinsic, D_right  
  23.     cvStereoCalibrate(_left_object_points, _left_image_points, _right_image_points, Number_perImg, left_intrinsic, left_distortion,  
  24.         right_intrinsic, right_distortion, _imgSize, _R, _T, _E, _F,  
  25.         cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 100, 1e-5), CV_CALIB_FIX_ASPECT_RATIO + CV_CALIB_ZERO_TANGENT_DIST + CV_CALIB_SAME_FOCAL_LENGTH);  
  26. }  
[cpp]  view plain  copy
  1.   

计算得到如下的结果（到目前为止还是很顺利的嘛！）：


4.上述标定结果和Matlab的标定结果对比差别不大。下面通过另一种方法检查标定结果的误差，通过检查图像上的点与另一幅图像的极线的距离远近来评价标定精度。首先，通过cvUndistortPoints()对原始点进行去畸变处理，然后使用cvComputeCorrespondEplilines()来计算极线，然后计算这些点和极线的距离（理想情况下，距离为0），累计这些距离的绝对误差，然后求其平均值。具体过程我也把它封装成一个函数：

[cpp]  view plain  copy
  1. /*计算标定误差函数 
  2. CvMat* left_image_points     IN左相机图像坐标系点的矩阵 
  3. CvMat* right_image_points    IN右相机图像坐标系点的矩阵 
  4. CvMat* left_intrinsic        INandOUT左相机的内参矩阵，经立体标定调整后输出 
  5. CvMat* right_intrinsic       INandOUT右相机的内参矩阵，经立体标定调整后输出 
  6. CvMat* left_distortion       INandOUT左相机的畸变向量，经立体标定调整后输出 
  7. CvMat* right_distortion      INandOUT右相机的畸变向量，经立体标定调整后输出 
  8. CvMat* _F                    OUT基础矩阵 
  9. int n_boards                 IN图片的数量 
  10. int board_w                  IN每张图片x方向角点数量 
  11. int board_h                  IN每张图片y方向角点数量 
  12. */  
  13. double Calib_Quality_Check(CvMat* _left_image_points, CvMat* _right_image_points, CvMat* left_intrinsic, CvMat* right_intrinsic,  
  14.     CvMat* left_distortion, CvMat* right_distortion, CvMat* _F, int _n_boards, int _board_w, int _board_h)  
  15. {  
  16.     int board_n = _board_w*_board_h;//每张图片中角点总数量  
  17.       
  18.     //定义极线  
  19.     CvMat* Lines1 = cvCreateMat(1, _n_boards*board_n, CV_32FC3);  
  20.     CvMat* Lines2 = cvCreateMat(1, _n_boards*board_n, CV_32FC3);  
  21.     //校正点的畸变  
  22.     "font-family: Arial, Helvetica, sans-serif;">cvUndistortPoints"font-family: Arial, Helvetica, sans-serif;">(_left_image_points, _left_image_points, left_intrinsic, D_left, 0, left_intrinsic);//代码运行到这里出现中断  
  23.     "font-family: Arial, Helvetica, sans-serif;">cvUndistortPoints"font-family: Arial, Helvetica, sans-serif;">(_right_image_points, _right_image_points, right_intrinsic, D_right, 0, right_intrinsic);  
  24.     //计算极线  
  25.     cvComputeCorrespondEpilines(_left_image_points, 1, _F, Lines1);  
  26.     cvComputeCorrespondEpilines(_right_image_points, 2, _F, Lines2);  
  27.     //计算左相机图像点和极线的距离  
  28.     float a, b, c;//极线系数ax+by+c=0  
  29.     double err, avgErr = 0;//误差变量  
  30.     float* p_temp = (float*)cvPtr2D(_left_image_points, 0, 0);//用于临时计算的点  
  31.     float* l_temp = (float*)cvPtr2D(Lines2, 0, 0,0);//用于临时计算的极线  
  32.     for (int i = 0; i < _n_boards*board_n; i++)  
  33.     {  
  34.         //提取点坐标  
  35.         x = *p_temp;  
  36.         y = *(p_temp + 1);  
  37.         p_temp += 2;  
  38.         //提取极线系数  
  39.         a = *l_temp;  
  40.         b = *(l_temp + 1);  
  41.         c = *(l_temp + 2);  
  42.         l_temp += 3;  
  43.         //计算点到直线的距离  
  44.         err = fabs(a*x + b*y + c) / sqrt(a*a + b*b);  
  45.         //累加误差  
  46.         avgErr += err;  
  47.     }  
  48.     //计算右相机图像点和极线的距离  
  49.     p_temp = (float*)cvPtr2D(_right_image_points, 0, 0);//用于临时计算的点  
  50.     l_temp = (float*)cvPtr2D(Lines1, 0, 0);//用于临时计算的极线  
  51.     for (int i = 0; i < _n_boards*board_n; i++)  
  52.     {  
  53.         //提取点坐标  
  54.         x = *p_temp;  
  55.         y = *(p_temp + 1);  
  56.         p_temp += 2;  
  57.         //提取极线系数  
  58.         a = *l_temp;  
  59.         b = *(l_temp + 1);  
  60.         c = *(l_temp + 2);  
  61.         l_temp += 3;  
  62.         //计算点到直线的距离  
  63.         err = fabs(a*x + b*y + c) / sqrt(a*a + b*b);  
  64.         //累加误差  
  65.         avgErr += err;  
  66.     }  
  67.     //求误差的平均值  
  68.     avgErr /= (_n_boards*board_n);  
  69.     return avgErr;  
  70. }  
这时候代码运行到 cvUndistortPoints()    出现中断，查看源码sources中对应的函数可以发现函数
[cpp]  view plain  copy
  1. void  
  2. cvUndisto(const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatrix,  
  3. const CvMat* _distCoeffs,  
  4. const CvMat* _R, const CvMat* _P)  
中有这么一句话：

[cpp]  view plain  copy
  1. CV_ASSERT(CV_IS_MAT(_src) && CV_IS_MAT(_dst) &&  
  2.         (_src->rows == 1 || _src->cols == 1) &&  
  3.         (_dst->rows == 1 || _dst->cols == 1) &&  
  4.         CV_ARE_SIZES_EQ(_src, _dst) &&  
  5.         (CV_MAT_TYPE(_src->type) == CV_32FC2 || CV_MAT_TYPE(_src->type) == CV_64FC2) &&  
  6.         (CV_MAT_TYPE(_dst->type) == CV_32FC2 || CV_MAT_TYPE(_dst->type) == CV_64FC2));  
既输入参数变量 CvMat* _src, CvMat* _dst  必须符合以上的条件，具体代表什么自己查找相关宏的定义，这里不一一列出，我们输入的参数是

[cpp]  view plain  copy
  1. CvMat* left_image_points = cvCreateMat(n_boards*board_n, 2, CV_32FC1);//左相机图片坐标中的角点  
  2. CvMat* right_image_points = cvCreateMat(n_boards*board_n, 2, CV_32FC1);//右相机图片坐标中的角点  
所以因为最后两句的判断而出错。
[cpp]  view plain  copy
  1. (CV_MAT_TYPE(_src->type) == CV_32FC2 || CV_MAT_TYPE(_src->type) == CV_64FC2) &&(CV_MAT_TYPE(_dst->type) == CV_32FC2 || CV_MAT_TYPE(_dst->type) == CV_64FC2))  
所以需要先对参数进行调整，修改计算误差函数为：

[cpp]  view plain  copy
  1. /*计算标定误差函数 
  2. CvMat* left_image_points     IN左相机图像坐标系点的矩阵 
  3. CvMat* right_image_points    IN右相机图像坐标系点的矩阵 
  4. CvMat* left_intrinsic        INandOUT左相机的内参矩阵，经立体标定调整后输出 
  5. CvMat* right_intrinsic       INandOUT右相机的内参矩阵，经立体标定调整后输出 
  6. CvMat* left_distortion       INandOUT左相机的畸变向量，经立体标定调整后输出 
  7. CvMat* right_distortion      INandOUT右相机的畸变向量，经立体标定调整后输出 
  8. CvMat* _F                    OUT基础矩阵 
  9. int n_boards                 IN图片的数量 
  10. int board_w                  IN每张图片x方向角点数量 
  11. int board_h                  IN每张图片y方向角点数量 
  12. */  
  13. double Calib_Quality_Check(CvMat* _left_image_points, CvMat* _right_image_points, CvMat* left_intrinsic, CvMat* right_intrinsic,  
  14.     CvMat* left_distortion, CvMat* right_distortion, CvMat* _F, int _n_boards, int _board_w, int _board_h)  
  15. {  
  16.     int board_n = _board_w*_board_h;//每张图片中角点总数量  
  17.     //整理LeftPoints。因为_left_image_points数据类型是_n_boards*board_n*3*CV_32FC1，left数据类型是1*_n_boards*board_n*CV_32FC2，对参数进行转换  
  18.     CvMat* left = cvCreateMat(1, _n_boards*board_n, CV_32FC2);  
  19.     float *p = (float*)cvPtr2D(left, 0, 0);  
  20.     float x, y;  
  21.     for (int i = 0; i < _n_boards*board_n; ++i)  
  22.     {  
  23.         x = CV_MAT_ELEM(*_left_image_points, float, i, 0);  
  24.         y = CV_MAT_ELEM(*_left_image_points, float, i, 1);  
  25.         *p = x;  
  26.         p++;  
  27.         *p = y;  
  28.         p++;  
  29.     }  
  30.     //整理LeftPoints。因为_left_image_points数据类型是_n_boards*board_n*3*CV_32FC1，left数据类型是1*_n_boards*board_n*CV_32FC2，对参数进行转换  
  31.     CvMat* right = cvCreateMat(1, _n_boards*board_n, CV_32FC2);  
  32.     p = (float*)cvPtr2D(right, 0, 0);  
  33.     for (int i = 0; i < _n_boards*board_n; ++i)  
  34.     {  
  35.         x = CV_MAT_ELEM(*_right_image_points, float, i, 0);  
  36.         y = CV_MAT_ELEM(*_right_image_points, float, i, 1);  
  37.         *p = x;  
  38.         p++;  
  39.         *p = y;  
  40.         p++;  
  41.     }  
  42.     //调整畸变向量。因为left_distortion数据类型是5*1的向量，D_left数据类型是1*5向量，对参数进行转换  
  43.     CvMat* D_left = cvCreateMat(1, 5, CV_32FC1);  
  44.     for (int i = 0; i < 5; ++i)  
  45.     {  
  46.         CV_MAT_ELEM(*D_left, float, 0, i) = CV_MAT_ELEM(*left_distortion, float, i, 0);  
  47.     }  
  48.     //调整畸变向量。因为right_distortion数据类型是5*1的向量，D_right数据类型是1*5向量，对参数进行转换  
  49.     CvMat* D_right = cvCreateMat(1, 5, CV_32FC1);  
  50.     for (int i = 0; i < 5; ++i)  
  51.     {  
  52.         CV_MAT_ELEM(*D_right, float, 0, i) = CV_MAT_ELEM(*right_distortion, float, i, 0);  
  53.     }  
  54.     //定义极线  
  55.     CvMat* Lines1 = cvCreateMat(1, _n_boards*board_n, CV_32FC3);  
  56.     CvMat* Lines2 = cvCreateMat(1, _n_boards*board_n, CV_32FC3);  
  57.     //校正点的畸变  
  58.     cvUndistortPoints(_left_image_points, _left_image_points, left_intrinsic, D_left, 0, left_intrinsic);  
  59.     cvUndistortPoints(_right_image_points, _right_image_points, right_intrinsic, D_right, 0, right_intrinsic);  
  60.     //计算极线  
  61.     cvComputeCorrespondEpilines(_left_image_points, 1, _F, Lines1);  
  62.     cvComputeCorrespondEpilines(_right_image_points, 2, _F, Lines2);  
  63.     //计算左相机图像点和极线的距离  
  64.     float a, b, c;//极线系数ax+by+c=0  
  65.     double err, avgErr = 0;//误差变量  
  66.     float* p_temp = (float*)cvPtr2D(_left_image_points, 0, 0);//用于临时计算的点  
  67.     float* l_temp = (float*)cvPtr2D(Lines2, 0, 0,0);//用于临时计算的极线  
  68.     for (int i = 0; i < _n_boards*board_n; i++)  
  69.     {  
  70.         //提取点坐标  
  71.         x = *p_temp;  
  72.         y = *(p_temp + 1);  
  73.         p_temp += 2;  
  74.         //提取极线系数  
  75.         a = *l_temp;  
  76.         b = *(l_temp + 1);  
  77.         c = *(l_temp + 2);  
  78.         l_temp += 3;  
  79.         //计算点到直线的距离  
  80.         err = fabs(a*x + b*y + c) / sqrt(a*a + b*b);  
  81.         //累加误差  
  82.         avgErr += err;  
  83.     }  
  84.     //计算右相机图像点和极线的距离  
  85.     p_temp = (float*)cvPtr2D(_right_image_points, 0, 0);//用于临时计算的点  
  86.     l_temp = (float*)cvPtr2D(Lines1, 0, 0);//用于临时计算的极线  
  87.     for (int i = 0; i < _n_boards*board_n; i++)  
  88.     {  
  89.         //提取点坐标  
  90.         x = *p_temp;  
  91.         y = *(p_temp + 1);  
  92.         p_temp += 2;  
  93.         //提取极线系数  
  94.         a = *l_temp;  
  95.         b = *(l_temp + 1);  
  96.         c = *(l_temp + 2);  
  97.         l_temp += 3;  
  98.         //计算点到直线的距离  
  99.         err = fabs(a*x + b*y + c) / sqrt(a*a + b*b);  
  100.         //累加误差  
  101.         avgErr += err;  
  102.     }  
  103.     //求误差的平均值  
  104.     avgErr /= (_n_boards*board_n);  
  105.     return avgErr;  
  106. }  
修改函数之后计算得到如下的结果（单位为像素）：

4.计算相机校正的左右相机的校正矩阵，使相机两平面完全行对准

当相机两平面完全行对准时，计算立体视差是最简单的，为了使相机两平面完全行对准，OpenCV提供了非标定和标定的方法来计算相机校正的左右相机的校正矩阵。接下来，选择非标定（Hartley)方法cvStereoRectifyUncalibrated()或者标定(Bouguet)方法cvStereoRectify()来计算相机变换。

如果选择非标定方法，在使用

[cpp]  view plain  copy
  1. cvInitUndistortRectifyMap( const CvMat* camera_matrix,const CvMat* dist_coeffs,const CvMat *R, const CvMat* new_camera_matrix,CvArr* mapx, CvArr* mapy );  
计算校正映射mapx和mapy之前，需要先预处理一下单应矩阵：令camera_matrix等于前面cvCalibrateCamera2或cvStereoCalibrate计算的相机内参数矩阵，然后利用相机内参矩阵camera_matrix和单应矩阵H计算左右相机对应的旋转矩阵：Rl=inv(camera_matrix_l)Hl(camera_matrix_l)和Rr=inv(camera_matrix_r)Hr(camera_matrix_r)，其中inv表示求矩阵的逆。

而选择标定方法则可以直接从cvStereoRectify()读出cvInitUndistortRectifyMap()的输入参数。

我还是把这个过程封装成一个函数的形式：

[cpp]  view plain  copy
  1. /*立体校正的映射矩阵mapx和mapy函数 
  2. CvMat* left_image_points     IN左相机图像坐标系点的矩阵 
  3. CvMat* right_image_points    IN右相机图像坐标系点的矩阵 
  4. CvMat* left_intrinsic        INandOUT左相机的内参矩阵，经立体标定调整后输出 
  5. CvMat* right_intrinsic       INandOUT右相机的内参矩阵，经立体标定调整后输出 
  6. CvMat* left_distortion       INandOUT左相机的畸变向量，经立体标定调整后输出 
  7. CvMat* right_distortion      INandOUT右相机的畸变向量，经立体标定调整后输出 
  8. CvMat* R                     OUT相机相对旋转矩阵 
  9. CvMat* T                     OUT相机相对平移矩阵 
  10. CvMat* F                     OUT基础矩阵 
  11. CvSize* imgSize              IN每张图片的像素尺寸 
  12. int n_boards                 IN图片的数量 
  13. int board_w                  IN每张图片x方向角点数量 
  14. int board_h                  IN每张图片y方向角点数量 
  15. bool useUncalibrated         IN是否采用非标定算法Hartly计算立体校正的映射矩阵mapx和mapy 
  16. CvMat* mxl                   OUT左相机立体校正的映射矩阵mapx 
  17. CvMat* myl                   OUT左相机立体校正的映射矩阵mapy 
  18. CvMat* mxr                   OUT右相机立体校正的映射矩阵mapx 
  19. CvMat* myr                   OUT右相机立体校正的映射矩阵mapy 
  20. */  
  21. /*mapx和mapy是函数返回的查找映射表，。对目标图像上的每一个像素来说，映射表说明应该从什么位置插值源像素； 
  22. 并且映射表可以直接被Remap()嵌入使用。函数cvInitUndistortRectifyMap（）被左右摄像机分别调用，这样可以获得它们的各自不同的重映射参数mapx和mapy， 
  23. 每次我们有新的左右立体图像需要校正时可以使用左右映射表*/  
  24. static void ComputeRectification(CvMat* imagePoints_left, CvMat* imagePoints_right, CvMat* _left_intrinsic, CvMat* _right_intrinsic, CvMat* _left_distortion, CvMat* _right_distortion,  
  25.     CvMat* R, CvMat* T, CvMat* F, CvSize imageSize, int _n_boards, int _board_w, int _board_h, CvMat* mxl, CvMat* myl, CvMat* mxr, CvMat* myr)  
  26. {  
  27.       
  28.     //定义和初始化左右相机的行对准旋转矩阵  
  29.     CvMat* Rl = cvCreateMat(3, 3, CV_64FC1);  
  30.     cvZero(Rl);  
  31.     CvMat* Rr = cvCreateMat(3, 3, CV_64FC1);  
  32.     cvZero(Rr);  
  33.     //计算相机共面和行对准的校正项  
  34.     if (useUncalibrated == false)//useUncalibrated == 0，使用Bouguet方法计算校正项  
  35.     {  
  36.         //定义和初始化做右相机投影矩阵，该矩阵可以计算校正后的相机内参数矩阵  
  37.         CvMat* Pl = cvCreateMat(3, 4, CV_64FC1);  
  38.         cvZero(Pl);  
  39.         CvMat* Pr = cvCreateMat(3, 4, CV_64FC1);  
  40.         cvZero(Pr);  
  41.         //计算相机校正项，计算得到 Rl, Rr, Pl, Pr  
  42.         cvStereoRectify("font-family: Arial, Helvetica, sans-serif;">_left_intrinsic"font-family: Arial, Helvetica, sans-serif;">, "font-family: Arial, Helvetica, sans-serif;">_right_intrinsic"font-family: Arial, Helvetica, sans-serif;">, "font-family: Arial, Helvetica, sans-serif;">_left_distortion"font-family: Arial, Helvetica, sans-serif;">, "font-family: Arial, Helvetica, sans-serif;">_right_distortion"font-family: Arial, Helvetica, sans-serif;">, imageSize,"font-family: Arial, Helvetica, sans-serif;">R, T, Rl, Rr, Pl, Pr, 0, 0, );//运行到此处出现中断  
  43.        //Show（用于调试）  
  44.         /*cout << endl << "Pr:" << endl; 
  45.         for (int i = 0; i < 3; i++) 
  46.         { 
  47.             const double *p = (const double*)(Pr->data.ptr + i*Pr->step); 
  48.                 cout << *p << "    " << *(p + 1) << "       " << *(p + 2)<<"        "<<*(p+3) << endl; 
  49.         }*/  
  50.         /*通过比较转换矩阵P位置[0][3]和位置[1][3]的大小 判断相机是水平布置还是垂直布置。 
  51.         因为这两个位置的元素分别表示右相机坐标系原点移动到左相机坐标系原点的x和y方向移动距离。*/  
  52.         isVerticalStereo = fabs(CV_MAT_ELEM(*Pr, double, 1, 3)) > fabs(CV_MAT_ELEM(*Pr, double, 0, 3));  
  53.         //Precompute maps for cvRemap()  
  54.         //下面通过函数cvInitUndistortRectifyMap()计算立体校正的映射矩阵mx和my  
  55.         cvInitUndistortRectifyMap(_left_intrinsic, D_left, Rl, Pl, mxl, myl);  
  56.         cvInitUndistortRectifyMap(_right_intrinsic, D_right, Rr, Pr, mxr, myr);  
  57.     }  
  58.     else//useUncalibrated！ = 0，使用Hartley方法计算校正项  
  59.     {  
  60.         int board_n = _board_w*_board_h;//每张图片中角点总数量  
  61.         CvMat* Hl = cvCreateMat(3, 3, CV_64F);//Hartley方法计算得到的校正项  
  62.         CvMat* Hr = cvCreateMat(3, 3, CV_64F);//Hartley方法计算得到的校正项  
  63.         CvMat *invM = cvCreateMat(3, 3, CV_64F);//用于临时存放相机内参数的逆  
  64.         //整理imagePoints_left和imagePoints_right  
  65.         float x, y;//用于传值的临时变量  
  66.         float* p;//用于传值的临时变量  
  67.         //LeftPoints  
  68.         CvMat* left = cvCreateMat(1, _n_boards*board_n, CV_32FC2);  
  69.         p = (float*)cvPtr2D(left, 0, 0);  
  70.         for (int i = 0; i < _n_boards*board_n; ++i)  
  71.         {  
  72.             x = CV_MAT_ELEM(*imagePoints_left, float, i, 0);  
  73.             y = CV_MAT_ELEM(*imagePoints_left, float, i, 1);  
  74.             *p = x;  
  75.             p++;  
  76.             *p = y;  
  77.             p++;  
  78.         }  
  79.         //Show  
  80.         /*p = (float*)cvPtr2D(left, 0, 0); 
  81.         for (int i = 0; i < n_boards*board_n; i++) 
  82.         { 
  83.         cout << *p << "    " << *(p + 1) << endl; 
  84.         p += 2; 
  85.         }*/  
  86.         //RightPoints  
  87.         CvMat* right = cvCreateMat(1, _n_boards*board_n, CV_32FC2);  
  88.         p = (float*)cvPtr2D(right, 0, 0);  
  89.         for (int i = 0; i < _n_boards*board_n; ++i)  
  90.         {  
  91.             x = CV_MAT_ELEM(*imagePoints_right, float, i, 0);  
  92.             y = CV_MAT_ELEM(*imagePoints_right, float, i, 1);  
  93.             *p = x;  
  94.             p++;  
  95.             *p = y;  
  96.             p++;  
  97.         }  
  98.         //Show  
  99.         /*p = (float*)cvPtr2D(right, 0, 0); 
  100.         for (int i = 0; i < n_boards*board_n; i++) 
  101.         { 
  102.         cout << *p << "    " << *(p + 1) << endl; 
  103.         p += 2; 
  104.         }*/  
  105.         //通过两个相机的图像点计算基础矩阵F  
  106.         cvFindFundamentalMat(left, right, F);  
  107.         //使用非标定算法Hartley立体校正，获得做右相机的校正单应性矩阵H1,H2  
  108.         cvStereoRectifyUncalibrated(left, right, F, imageSize, Hl, Hr, 3);  
  109.         /*使用cvStereoRectifyUncalibrated()的结果H1,H2来校正立体摄像机，必须先预处理一下单应性矩阵Hl和我Hr， 
  110.         如果没有先前标定中获得Mrect，令Mrect=M,分别计算左右校正旋转矩阵Rl=inv(Mrect_l)Hl(Ml)和Rr=inv(Mrect_r)Hr(Mr)， 
  111.         最后还需要分别计算左右相机的畸变系数向量*/  
  112.         //Show（用于调试）  
  113.         /*cout << endl << "M1:"; 
  114.         for (int i = 0; i < 3; i++) 
  115.         { 
  116.             cout << endl; 
  117.             for (int j = 0; j < 3; j++) 
  118.             { 
  119.                 cout << CV_MAT_ELEM(*_left_intrinsic, float, i, j) << "     "; 
  120.             } 
  121.         }*/  
  122.         //预处理Rl=inv(Mrect_l)Hl(Ml)  
  123.         cvInvert(M_left, invM);  
  124.         cvMatMul(Hl, M_left, Rl);  
  125.         cvMatMul(invM, Rl, Rl);  
  126.         //预处理Rr=inv(Mrect_r)Hr(Mr)  
  127.         cvInvert(M_right, invM);//_iM为_M1的逆矩阵  
  128.         cvMatMul(Hr, M_right, Rr);//_R1=_H1*_M1  
  129.         cvMatMul(invM, Rr, Rr);//_R2=_iM*_R1  
  130.         //Precompute map for cvRemap()，用预处理后的_R1和_R2，以及前面计算的相机参数代入cvInitUndistortRectifyMap计算mapx和mapy  
  131.         cvInitUndistortRectifyMap(M_left, D_left, Rl, M_left, mxl, myl);  
  132.         cvInitUndistortRectifyMap(M_right, D_right, Rr, M_right, mxr, myr);  
  133.   
  134.     }  
  135. }  
当useUncalibrated == false时，函数运行到cvStereoRectify会出现程序中断，再次查看OpenCV中对应该函数的源代码，可以发现里面定义的矩阵变量都是CV_64F，而且接下来进行了罗德里格斯变换：

[cpp]  view plain  copy
  1. cvRodrigues2( const CvMat* src, CvMat* dst, CvMat* jacobian )  
查看了一下该函数的源代码发现里面的一句话会引起中断：

[cpp]  view plain  copy
  1. if (!CV_ARE_DEPTHS_EQ(src, dst))  
  2.         CV_Error(CV_StsUnmatchedFormats, "All the matrices must have the same data type");  
所以我接下来索性把函数 cvStereoRectify（） 的所有参数变量都转换成CV_64FC1，以及将cvStereoRectifyUncalibrated（）的参数变量也全部改为CV_64FC1,则都可以顺利运行，修改后的自定义函数为：

[cpp]  view plain  copy
  1. /*立体校正的映射矩阵mapx和mapy函数 
  2. CvMat* left_image_points     IN左相机图像坐标系点的矩阵 
  3. CvMat* right_image_points    IN右相机图像坐标系点的矩阵 
  4. CvMat* left_intrinsic        INandOUT左相机的内参矩阵，经立体标定调整后输出 
  5. CvMat* right_intrinsic       INandOUT右相机的内参矩阵，经立体标定调整后输出 
  6. CvMat* left_distortion       INandOUT左相机的畸变向量，经立体标定调整后输出 
  7. CvMat* right_distortion      INandOUT右相机的畸变向量，经立体标定调整后输出 
  8. CvMat* R                     OUT相机相对旋转矩阵 
  9. CvMat* T                     OUT相机相对平移矩阵 
  10. CvMat* F                     OUT基础矩阵 
  11. CvSize* imgSize              IN每张图片的像素尺寸 
  12. int n_boards                 IN图片的数量 
  13. int board_w                  IN每张图片x方向角点数量 
  14. int board_h                  IN每张图片y方向角点数量 
  15. bool useUncalibrated         IN是否采用非标定算法Hartly计算立体校正的映射矩阵mapx和mapy 
  16. CvMat* mxl                   OUT左相机立体校正的映射矩阵mapx 
  17. CvMat* myl                   OUT左相机立体校正的映射矩阵mapy 
  18. CvMat* mxr                   OUT右相机立体校正的映射矩阵mapx 
  19. CvMat* myr                   OUT右相机立体校正的映射矩阵mapy 
  20. */  
  21. /*mapx和mapy是函数返回的查找映射表，。对目标图像上的每一个像素来说，映射表说明应该从什么位置插值源像素； 
  22. 并且映射表可以直接被Remap()嵌入使用。函数cvInitUndistortRectifyMap（）被左右摄像机分别调用，这样可以获得它们的各自不同的重映射参数mapx和mapy， 
  23. 每次我们有新的左右立体图像需要校正时可以使用左右映射表*/  
  24. static void ComputeRectification(CvMat* imagePoints_left, CvMat* imagePoints_right, CvMat* _left_intrinsic, CvMat* _right_intrinsic, CvMat* _left_distortion, CvMat* _right_distortion,  
  25.     CvMat* R, CvMat* T, CvMat* F, CvSize imageSize, int _n_boards, int _board_w, int _board_h, CvMat* mxl, CvMat* myl, CvMat* mxr, CvMat* myr)  
  26. {  
  27.     /*将参数变量重新整理成CV_64F类型的，我也不知道为什么，cvStereoRectify如果传入CV_32FC1的参数会中断，改为CV_64FC1则成功*/  
  28.     //整理左相机内参矩阵。因为_left_intrinsic数据类型为CV_32FC1，M_left为CV_64FC1  
  29.     CvMat* M_left = cvCreateMat(3, 3, CV_64FC1);  
  30.     for (int i = 0; i < 3; i++)  
  31.     for (int j = 0; j < 3; j++)  
  32.         CV_MAT_ELEM(*M_left, double, i, j) = CV_MAT_ELEM(*_left_intrinsic, float, i, j);  
  33.     //整理右相机内参矩阵。因为_left_intrinsic数据类型为CV_32FC1，M_left为CV_64FC1  
  34.     CvMat* M_right = cvCreateMat(3, 3, CV_64FC1);  
  35.     for (int i = 0; i < 3; i++)  
  36.     for (int j = 0; j < 3; j++)  
  37.         CV_MAT_ELEM(*M_right, double, i, j) = CV_MAT_ELEM(*_right_intrinsic, float, i, j);  
  38.     //调整畸变向量。因为left_distortion数据类型是5*1的向量，D_left数据类型是1*5向量，同时转换为CV_64FC1。  
  39.     CvMat* D_left = cvCreateMat(1, 5, CV_64FC1);  
  40.     for (int i = 0; i < 5; ++i)  
  41.     {  
  42.         CV_MAT_ELEM(*D_left, double, 0, i) = CV_MAT_ELEM(*_left_distortion, float, i, 0);  
  43.     }  
  44.     //调整畸变向量。因为right_distortion数据类型是5*1的向量，D_right数据类型是1*5向量，同时转换为CV_64FC1。  
  45.     CvMat* D_right = cvCreateMat(1, 5, CV_64FC1);  
  46.     for (int i = 0; i < 5; ++i)  
  47.     {  
  48.         CV_MAT_ELEM(*D_right, double, 0, i) = CV_MAT_ELEM(*_right_distortion, float, i, 0);  
  49.     }  
  50.     //转换旋转矩阵。CV_32FC1转换为CV_64FC1  
  51.     CvMat* RR = cvCreateMat(3, 3, CV_64FC1);  
  52.     for (int i = 0; i < 3; i++)  
  53.     for (int j = 0; j < 3; j++)  
  54.         CV_MAT_ELEM(*RR, double, i, j) = CV_MAT_ELEM(*R, float, i, j);  
  55.     //定义平移向量。CV_32FC1转换为CV_64FC1  
  56.     CvMat* TT = cvCreateMat(3, 1, CV_64FC1);  
  57.     for (int i = 0; i < 3; ++i)  
  58.     {  
  59.         CV_MAT_ELEM(*TT, double, i, 0) = CV_MAT_ELEM(*T, float, i, 0);  
  60.     }  
  61.     //定义和初始化左右相机的行对准旋转矩阵  
  62.     CvMat* Rl = cvCreateMat(3, 3, CV_64FC1);  
  63.     cvZero(Rl);  
  64.     CvMat* Rr = cvCreateMat(3, 3, CV_64FC1);  
  65.     cvZero(Rr);  
  66.     //计算相机共面和行对准的校正项  
  67.     if (useUncalibrated == false)//useUncalibrated == 0，使用Bouguet方法计算校正项  
  68.     {  
  69.         //定义和初始化做右相机投影矩阵，该矩阵可以计算校正后的相机内参数矩阵  
  70.         CvMat* Pl = cvCreateMat(3, 4, CV_64FC1);  
  71.         cvZero(Pl);  
  72.         CvMat* Pr = cvCreateMat(3, 4, CV_64FC1);  
  73.         cvZero(Pr);  
  74.         //计算相机校正项，计算得到 Rl, Rr, Pl, Pr  
  75.         cvStereoRectify(M_left, M_right, D_left, D_right, imageSize,  
  76.             RR, TT, Rl, Rr, Pl, Pr, 0, 0, -1.0, cvSize(0, 0), (CvRect*)0, (CvRect*)0);  
  77.         //Show（用于调试）  
  78.         /*cout << endl << "Pr:" << endl; 
  79.         for (int i = 0; i < 3; i++) 
  80.         { 
  81.             const double *p = (const double*)(Pr->data.ptr + i*Pr->step); 
  82.                 cout << *p << "    " << *(p + 1) << "       " << *(p + 2)<<"        "<<*(p+3) << endl; 
  83.         }*/  
  84.         /*通过比较转换矩阵P位置[0][3]和位置[1][3]的大小 判断相机是水平布置还是垂直布置。 
  85.         因为这两个位置的元素分别表示右相机坐标系原点移动到左相机坐标系原点的x和y方向移动距离。*/  
  86.         isVerticalStereo = fabs(CV_MAT_ELEM(*Pr, double, 1, 3)) > fabs(CV_MAT_ELEM(*Pr, double, 0, 3));  
  87.         //Precompute maps for cvRemap()  
  88.         //下面通过函数cvInitUndistortRectifyMap()计算立体校正的映射矩阵mx和my  
  89.         cvInitUndistortRectifyMap(_left_intrinsic, D_left, Rl, Pl, mxl, myl);  
  90.         cvInitUndistortRectifyMap(_right_intrinsic, D_right, Rr, Pr, mxr, myr);  
  91.     }  
  92.     else//useUncalibrated！ = 0，使用Hartley方法计算校正项  
  93.     {  
  94.         int board_n = _board_w*_board_h;//每张图片中角点总数量  
  95.         CvMat* Hl = cvCreateMat(3, 3, CV_64FC1);//Hartley方法计算得到的校正项  
  96.         CvMat* Hr = cvCreateMat(3, 3, CV_64FC1);//Hartley方法计算得到的校正项  
  97.         CvMat *invM = cvCreateMat(3, 3, CV_64FC1);//用于临时存放相机内参数的逆  
  98.         //整理imagePoints_left和imagePoints_right  
  99.         float x, y;//用于传值的临时变量  
  100.         double* p;//用于传值的临时变量  
  101.         //LeftPoints  
  102.         CvMat* left = cvCreateMat(1, _n_boards*board_n, CV_64FC2);  
  103.         p = (double*)cvPtr2D(left, 0, 0);  
  104.         for (int i = 0; i < _n_boards*board_n; ++i)  
  105.         {  
  106.             x = CV_MAT_ELEM(*imagePoints_left, float, i, 0);  
  107.             y = CV_MAT_ELEM(*imagePoints_left, float, i, 1);  
  108.             *p = x;  
  109.             p++;  
  110.             *p = y;  
  111.             p++;  
  112.         }  
  113.         //Show  
  114.         /*p = (float*)cvPtr2D(left, 0, 0); 
  115.         for (int i = 0; i < n_boards*board_n; i++) 
  116.         { 
  117.         cout << *p << "    " << *(p + 1) << endl; 
  118.         p += 2; 
  119.         }*/  
  120.         //RightPoints  
  121.         CvMat* right = cvCreateMat(1, _n_boards*board_n, CV_64FC2);  
  122.         p = (double*)cvPtr2D(right, 0, 0);  
  123.         for (int i = 0; i < _n_boards*board_n; ++i)  
  124.         {  
  125.             x = CV_MAT_ELEM(*imagePoints_right, float, i, 0);  
  126.             y = CV_MAT_ELEM(*imagePoints_right, float, i, 1);  
  127.             *p = x;  
  128.             p++;  
  129.             *p = y;  
  130.             p++;  
  131.         }  
  132.         //Show  
  133.         /*p = (float*)cvPtr2D(right, 0, 0); 
  134.         for (int i = 0; i < n_boards*board_n; i++) 
  135.         { 
  136.         cout << *p << "    " << *(p + 1) << endl; 
  137.         p += 2; 
  138.         }*/  
  139.         //通过两个相机的图像点计算基础矩阵F  
  140.         cvFindFundamentalMat(left, right, F);  
  141.         //使用非标定算法Hartley立体校正，获得做右相机的校正单应性矩阵H1,H2  
  142.         cvStereoRectifyUncalibrated(left, right, F, imageSize, Hl, Hr, 3);  
  143.         /*使用cvStereoRectifyUncalibrated()的结果H1,H2来校正立体摄像机，必须先预处理一下单应性矩阵Hl和我Hr， 
  144.         如果没有先前标定中获得Mrect，令Mrect=M,分别计算左右校正旋转矩阵Rl=inv(Mrect_l)Hl(Ml)和Rr=inv(Mrect_r)Hr(Mr)， 
  145.         最后还需要分别计算左右相机的畸变系数向量*/  
  146.         //Show（用于调试）  
  147.         /*cout << endl << "M1:"; 
  148.         for (int i = 0; i < 3; i++) 
  149.         { 
  150.             cout << endl; 
  151.             for (int j = 0; j < 3; j++) 
  152.             { 
  153.                 cout << CV_MAT_ELEM(*_left_intrinsic, float, i, j) << "     "; 
  154.             } 
  155.         }*/  
  156.         //预处理Rl=inv(Mrect_l)Hl(Ml)  
  157.         cvInvert(M_left, invM);  
  158.         cvMatMul(Hl, M_left, Rl);  
  159.         cvMatMul(invM, Rl, Rl);  
  160.         //预处理Rr=inv(Mrect_r)Hr(Mr)  
  161.         cvInvert(M_right, invM);//_iM为_M1的逆矩阵  
  162.         cvMatMul(Hr, M_right, Rr);//_R1=_H1*_M1  
  163.         cvMatMul(invM, Rr, Rr);//_R2=_iM*_R1  
  164.         //Precompute map for cvRemap()，用预处理后的_R1和_R2，以及前面计算的相机参数代入cvInitUndistortRectifyMap计算mapx和mapy  
  165.         cvInitUndistortRectifyMap(M_left, D_left, Rl, M_left, mxl, myl);  
  166.         cvInitUndistortRectifyMap(M_right, D_right, Rr, M_right, mxr, myr);  
  167.   
  168.     }  
  169. }  


5.校正图片和计算视差映射矩阵

这一步没碰上什么异常，直接上自定义函数代码。

[cpp]  view plain  copy
  1. /*校正图片和计算视察映射的函数 
  2. const char* imageList_left       IN保存左相机图片名的txt文件 
  3. const char* imageList_right      IN保存右相机图片名的txt文件 
  4. CvSize* imgSize                  IN每张图片的像素尺寸 
  5. CvMat* mxl                       IN左相机立体校正的映射矩阵mapx 
  6. CvMat* myl                       IN左相机立体校正的映射矩阵mapy 
  7. CvMat* mxr                       IN右相机立体校正的映射矩阵mapx 
  8. CvMat* myr                       IN右相机立体校正的映射矩阵mapy 
  9. */  
  10. static void Rectify_and_ComputeDisparity(const char* imageList_left, const char* imageList_right, CvSize imSize, CvMat* mxl, CvMat* myl, CvMat* mxr, CvMat* myr)  
  11. {  
  12.     FILE *f_left, *f_right;//定义两个文件操作对象  
  13.     fopen_s(&f_left, imageList_left, "rt");//打开左相机图像的图像名文件  
  14.     fopen_s(&f_right, imageList_right, "rt");//打开右相机图像的图像名文件  
  15.     IplImage *img_left, *img_right;//定义两个图像对象  
  16.     //定义两个矩阵用于存放校正后的图像  
  17.     CvMat* img1r = cvCreateMat(imSize.height, imSize.width, CV_8U);  
  18.     CvMat* img2r = cvCreateMat(imSize.height, imSize.width, CV_8U);  
  19.   
  20.     CvMat* disp = cvCreateMat(imSize.height, imSize.width, CV_16S);//视察映射  
  21.     CvMat* vdisp = cvCreateMat(imSize.height, imSize.width, CV_8U);//归一化后的视差映射  
  22.     /*创建和初始化一个结构体CvStereoBMState用于cvFindStereoCorrespondenceBM()的匹配过程的参数。因为如果每次调用cvFindStereoCorrespondenceBM() 
  23.     都离散分配内部离散缓存会影响程序的运行速度。*/  
  24.     CvStereoBMState *BMState = cvCreateStereoBMState();  
  25.     assert(BMState != 0);//如果创建失败则终止程序  
  26.     BMState->preFilterSize = 41;//预过滤窗口的尺寸，使图像亮度归一化并加强纹理  
  27.     BMState->preFilterCap = 31;//预过滤的阈值  
  28.     BMState->SADWindowSize = 41;//"绝对误差累计"小窗口(SAD)的尺寸  
  29.     BMState->minDisparity = -64;//匹配搜索起始点位置  
  30.     BMState->numberOfDisparities = 128;//匹配搜索 的视差范围  
  31.     BMState->textureThreshold = 10;//后过滤阈值，响应小于该值的匹配不予考虑  
  32.     BMState->uniquenessRatio = 15;//后过滤比例阈值，uniquenessRatio>(match_val-min_match)/min_match的地方过滤掉匹配值  
  33.   
  34.     cvNamedWindow("disparity");//创建一个窗口用于显示视差映射  
  35.     cvNamedWindow("rectified", 1);//创建窗口，用于显示校正后的图像  
  36.     CvMat* pair;//定义一个矩阵用于存放校正后的两张图片  
  37.     CvMat part;//定义一个矩阵用于存放校正后的一张图片  
  38.     if (!isVerticalStereo)//相机水平布置则创建尺寸为（imageSize.height, imageSize.width * 2）的图片用于显示左右相机立体校正后的图片  
  39.         pair = cvCreateMat(imSize.height, imSize.width * 2, CV_8UC3);  
  40.     else//相机竖直布置则创建尺寸为（imageSize.height * 2, imageSize.width）的图片用于显示上下相机立体校正后的图片  
  41.         pair = cvCreateMat(imSize.height * 2, imSize.width, CV_8UC3);  
  42.   
  43.     //循环读取左右相机的图像  
  44.     for (int i = 0;; i++)  
  45.     {  
  46.         //读取图片  
  47.         char buf_left[1024], buf_right[1024];//存放读取的字符数组  
  48.         if ((!fgets(buf_left, sizeof(buf_left)-3, f_left)) || (!fgets(buf_right, sizeof(buf_right)-3, f_right)))//提取文件的字符存放到buf  
  49.             break;  
  50.         size_t len = strlen(buf_left);//len为字符数组的长度  
  51.         while (len > 0 && isspace(buf_left[len - 1]))//int isspace(int c)检查参数c是否为空格字符，也就是判断是否为空格(' ')、定位字符(' \t ')、CR(' \r ')、换行(' \n ')  
  52.             buf_left[--len] = '\0';                 //、垂直定位字符(' \v ')或翻页(' \f ')的情况。，既在非空白字符的后面以为添加‘\0’  
  53.         len = strlen(buf_right);//len为字符数组的长度  
  54.         while (len > 0 && isspace(buf_right[len - 1]))//int isspace(int c)检查参数c是否为空格字符，也就是判断是否为空格(' ')、定位字符(' \t ')、CR(' \r ')、换行(' \n ')  
  55.             buf_right[--len] = '\0';                    //、垂直定位字符(' \v ')或翻页(' \f ')的情况。，既在非空白字符的后面以为添加‘\0’  
  56.         if ((buf_left[0] == '#') || (buf_right[0] == '#'))//开头为'#',结束此次循环  
  57.             continue;  
  58.         img_left = cvLoadImage(buf_left, 0);//读取图片  
  59.         img_right = cvLoadImage(buf_right, 0);//读取图片  
  60.         if ((!img_left) || (!img_right))  
  61.             break;  
  62.         //使用用前面计算的mx和my立体校正图片，两个相机的图片处于同一个相机平面且行对准  
  63.         cvRemap(img_left, img1r, mxl, myl);  
  64.         cvRemap(img_right, img2r, mxr, myr);  
  65.         /*接下来用立体校准后的图片计算双目视觉模型的视察映射。分为相机水平布置和垂直布置两种情况， 
  66.         对于摄像机垂直布置的情形，如果没有自己添加图像转置的代码，函数cvFindStereoCorrespondenceBM() 
  67.         只能计算非标定校正的视察，对于摄像机水平对齐的情形，函数cvFindStereoCorrespondenceBM()可以计算 
  68.         标定和非标定的校正立体像对的视差。*/  
  69.         if (!isVerticalStereo || useUncalibrated != 0)  
  70.         {  
  71.             cvFindStereoCorrespondenceBM(img1r, img2r, disp, BMState);//计算视差映射  
  72.             cvNormalize(disp, vdisp, 0, 256, CV_MINMAX);//归一化视差映射  
  73.             //显示视差映射  
  74.             cvShowImage("disparity", vdisp);  
  75.         }  
  76.         //下面显示立体校正后的两个相机对应的图片  
  77.         if (!isVerticalStereo)//水平布置相机的情形  
  78.         {  
  79.             //pair的左侧复制左相机立体校正后的照片  
  80.             cvGetCols(pair, &part, 0, imSize.width);/*CvMat* cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col ); 
  81.                                                        返回数组的一定跨度内的列 
  82.                                                        arr-输入数组 
  83.                                                        submat-指向结果子数组头指针. 
  84.                                                        start_col-跨度的开始列（包括该列）索引下标，该下标以0为基准。 
  85.                                                        end_col-跨度的结束列（不包括该列）索引下标，该下标以0为基准。*/  
  86.             cvCvtColor(img1r, &part, CV_GRAY2BGR);//GRAY->RGB  
  87.             //pair右侧复制右相机立体校正后的照片  
  88.             cvGetCols(pair, &part, imSize.width, imSize.width * 2);  
  89.             cvCvtColor(img2r, &part, CV_GRAY2BGR);//GRAY->RGB  
  90.             //在一定距离间隔处绘制水平直线  
  91.             for (int j = 0; j < imSize.height; j += 16)  
  92.                 cvLine(pair, cvPoint(0, j), cvPoint(imSize.width * 2, j), CV_RGB(0, 255, 0));  
  93.         }  
  94.         else//竖直布置相机的情况  
  95.         {  
  96.             //pair的上侧复制上相机立体校正后的照片  
  97.             cvGetRows(pair, &part, 0, imSize.height);  
  98.             cvCvtColor(img1r, &part, CV_GRAY2BGR);//GRAY->RGB  
  99.             //pair的下侧复制下相机立体校正后的照片  
  100.             cvGetRows(pair, &part, imSize.height, imSize.height * 2);  
  101.             cvCvtColor(img2r, &part, CV_GRAY2BGR);//GRAY->RGB  
  102.             //在一定距离间隔处绘制竖直的直线  
  103.             for (int j = 0; j < imSize.width; j += 16)  
  104.                 cvLine(pair, cvPoint(j, 0), cvPoint(j, imSize.height * 2), CV_RGB(0, 255, 0));  
  105.         }  
  106.         //显示pair  
  107.         cvShowImage("rectified", pair);  
  108.         //等待用户输入。。。  
  109.         if (cvWaitKey() == 27)  
  110.             break;  
  111.     }  
  112. }  
输出了校正后的左右相机的图像以及视差映射矩阵，如图所示：


校正的图片


视察映射图

6.程序入口：main()函数

[cpp]  view plain  copy
  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.     int n_boards = 13;//标定板图片数量  
  4.     int board_w = 8;//x方向角点数目  
  5.     int board_h = 6;//y方向角点数目  
  6.     int board_n = board_w*board_h;//n_boards张图片中角点总数量  
  7.   
  8.     //标定左相机  
  9.     const char* left_imageList = "left_ImgName.txt";  
  10.     CvMat* left_object_points = cvCreateMat(n_boards*board_n, 3, CV_32FC1);//左相机对应的世界坐标中的角点  
  11.     CvMat* left_image_points = cvCreateMat(n_boards*board_n, 2, CV_32FC1);//左相机图片坐标中的角点  
  12.     CvMat* left_intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1);//左相机内参数矩阵  
  13.     CvMat* left_distortion_coeffs = cvCreateMat(5, 1, CV_32FC1);//左相机畸变系数向量  
  14.     CvSize* left_imgSize = new CvSize;//图片尺寸  
  15.     //标定左相机内参数和畸变向量  
  16.     SingleCalib(left_imageList, left_object_points, left_image_points, left_intrinsic_matrix, left_distortion_coeffs,  
  17.         n_boards, board_w, board_h, left_imgSize);  
  18.     //Show(用于调试)  
  19.     /*int cout_step = left_intrinsic_matrix->step / sizeof(float); 
  20.     float* data = left_intrinsic_matrix->data.fl; 
  21.     for (int i = 0; i < 3; i++) 
  22.     { 
  23.     cout << "\n"; 
  24.     for (int j = 0; j < 3; j++) 
  25.     { 
  26.     cout << (data + i*cout_step)[j] << "      "; 
  27.     } 
  28.     }*/  
  29.   
  30.     //标定右相机  
  31.     const char* right_imageList = "right_ImgName.txt";  
  32.     CvMat* right_object_points = cvCreateMat(n_boards*board_n, 3, CV_32FC1);//右相机对应的世界坐标中的角点  
  33.     CvMat* right_image_points = cvCreateMat(n_boards*board_n, 2, CV_32FC1);//右相机图片坐标中的角点  
  34.     CvMat* right_intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1);//右相机内参数矩阵  
  35.     CvMat* right_distortion_coeffs = cvCreateMat(5, 1, CV_32FC1);//右相机畸变系数向量  
  36.     CvSize* right_imgSize = new CvSize;//图片尺寸  
  37.     //标定右相机内参数和畸变向量  
  38.     SingleCalib(right_imageList, right_object_points, right_image_points, right_intrinsic_matrix, right_distortion_coeffs,  
  39.         n_boards, board_w, board_h, right_imgSize);  
  40.     //输出标定的内参数矩阵  
  41.     /*cout_step = right_intrinsic_matrix->step / sizeof(float); 
  42.     data = right_intrinsic_matrix->data.fl; 
  43.     for (int i = 0; i < 3; i++) 
  44.     { 
  45.     cout << "\n"; 
  46.     for (int j = 0; j < 3; j++) 
  47.     { 
  48.     cout << (data + i*cout_step)[j] << "      "; 
  49.     } 
  50.     }*/  
  51.     //图片尺寸（取左右相机的都一样）  
  52.     CvSize imgSize;  
  53.     imgSize = *right_imgSize;  
  54.     CvMat* R = cvCreateMat(3, 3, CV_32FC1);//旋转矩阵  
  55.     CvMat* T = cvCreateMat(3, 1, CV_32FC1);//平移矩阵  
  56.     CvMat* E = cvCreateMat(3, 3, CV_32FC1);//本征矩阵  
  57.     CvMat* F = cvCreateMat(3, 3, CV_32FC1);//基础矩阵  
  58.     /*立体标定，得到R, T, E, F，同时可以校正right_image_points, left_intrinsic_matrix, right_intrinsic_matrix, 
  59.     left_distortion_coeffs*/  
  60.     StereoCalib(left_object_points, left_image_points, right_image_points, left_intrinsic_matrix, right_intrinsic_matrix,  
  61.         left_distortion_coeffs, right_distortion_coeffs, R, T, E, F, n_boards, board_w, board_h, imgSize);  
  62.   
  63.     //输出立体标定结果  
  64.     cout << endl << "M1:";  
  65.     for (int i = 0; i < 3; i++)  
  66.     {  
  67.         cout << endl;  
  68.         for (int j = 0; j < 3; j++)  
  69.         {  
  70.             cout << CV_MAT_ELEM(*left_intrinsic_matrix, float, i, j) << "     ";  
  71.         }  
  72.     }  
  73.     cout << endl << "D1:";  
  74.     for (int i = 0; i < 5; i++)  
  75.     {  
  76.         cout << endl;  
  77.         cout << CV_MAT_ELEM(*left_distortion_coeffs, float, i, 0) << "     ";  
  78.     }  
  79.     cout << endl << "M2:";  
  80.     for (int i = 0; i < 3; i++)  
  81.     {  
  82.         cout << endl;  
  83.         for (int j = 0; j < 3; j++)  
  84.         {  
  85.             cout << CV_MAT_ELEM(*right_intrinsic_matrix, float, i, j) << "     ";  
  86.         }  
  87.     }  
  88.     cout << endl << "D2:";  
  89.     for (int i = 0; i < 5; i++)  
  90.     {  
  91.         cout << endl;  
  92.         cout << CV_MAT_ELEM(*right_distortion_coeffs, float, i, 0) << "     ";  
  93.     }  
  94.     cout << endl << "R:";  
  95.     for (int i = 0; i < 3; i++)  
  96.     {  
  97.         cout << endl;  
  98.         for (int j = 0; j < 3; j++)  
  99.         {  
  100.             cout << CV_MAT_ELEM(*R, float, i, j) << "     ";  
  101.         }  
  102.     }  
  103.     cout << endl << "T:";  
  104.     for (int i = 0; i < 3; i++)  
  105.     {  
  106.         cout << endl;  
  107.         cout << CV_MAT_ELEM(*T, float, i, 0) << "     ";  
  108.     }  
  109.     cout << endl << "E:";  
  110.     for (int i = 0; i < 3; i++)  
  111.     {  
  112.         cout << endl;  
  113.         for (int j = 0; j < 3; j++)  
  114.         {  
  115.             cout << CV_MAT_ELEM(*E, float, i, j) << "     ";  
  116.         }  
  117.     }  
  118.     cout << endl << "F:";  
  119.     for (int i = 0; i < 3; i++)  
  120.     {  
  121.         cout << endl;  
  122.         for (int j = 0; j < 3; j++)  
  123.         {  
  124.             cout << CV_MAT_ELEM(*F, float, i, j) << "     ";  
  125.         }  
  126.     }  
  127.   
  128.     //计算标定结果的误差  
  129.     double Error = 0;  
  130.     Error = Calib_Quality_Check(left_image_points, right_image_points, left_intrinsic_matrix, right_intrinsic_matrix,  
  131.         left_distortion_coeffs, right_distortion_coeffs, F, n_boards, board_w, board_h);  
  132.     //输出标定误差  
  133.     cout << endl << "Error:" << Error << endl;  
  134.   
  135.     //保存标定结果  
  136.     CvFileStorage* fs = cvOpenFileStorage("Result.xml", 0, CV_STORAGE_WRITE);  
  137.     cvWrite(fs, "left_intrinsic_matrix", left_intrinsic_matrix, cvAttrList(0, 0));  
  138.     cvWrite(fs, "left_distortion", right_distortion_coeffs, cvAttrList(0, 0));  
  139.     cvWrite(fs, "right_intrinsic_matrix", right_intrinsic_matrix, cvAttrList(0, 0));  
  140.     cvWrite(fs, "right_distortion", right_distortion_coeffs, cvAttrList(0, 0));  
  141.     cvWrite(fs, "R", R, cvAttrList(0, 0));  
  142.     cvWrite(fs, "T", T, cvAttrList(0, 0));  
  143.     cvWrite(fs, "E", E, cvAttrList(0, 0));  
  144.     cvWrite(fs, "F", F, cvAttrList(0, 0));  
  145.     cvWriteReal(fs, "Error", Error);  
  146.     cvReleaseFileStorage(&fs);  
  147.   
  148.     //计算立体校正的映射矩阵mapx和mapy  
  149.     CvMat* mxl = cvCreateMat(imgSize.height, imgSize.width, CV_32F);  
  150.     CvMat* myl = cvCreateMat(imgSize.height, imgSize.width, CV_32F);  
  151.     CvMat* mxr = cvCreateMat(imgSize.height, imgSize.width, CV_32F);  
  152.     CvMat* myr = cvCreateMat(imgSize.height, imgSize.width, CV_32F);  
  153.     ComputeRectification(left_image_points, right_image_points, left_intrinsic_matrix, right_intrinsic_matrix, left_distortion_coeffs, right_distortion_coeffs,  
  154.         R, T, F, imgSize, n_boards, board_w, board_h, mxl, myl, mxr, myr);  
  155.   
  156.     //校正图片和计算视察映射并显示  
  157.     Rectify_and_ComputeDisparity(left_imageList, right_imageList, imgSize, mxl, myl, mxr, myr);  
  158.   
  159.   
  160.     return 0;  
  161. }  

你可能感兴趣的:(立体视觉,OpenCV,学习)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 阶段总结反思 轻争
    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • 展现思维导图魅力，不断挖掘人生宝藏 思维导图讲师Mandy
    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
  • 2019-3-23晨间日记 红红火火小耳朵
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 教育 用心灵温暖心灵
    @陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首 张三叨
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
  • 学习“论语”-第59天 春峰轩
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Java 并发包之线程池和原子计数 lijingyao8206 Java计数ThreadPool并发包java线程池
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。     这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
  • java编程思想 抽象类和接口 百合不是茶 java抽象类接口
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持   1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错)   抽象方法 : 在方法中仅有声明而没有方法体    package com.wj.Interface;
  • [房地产与大数据]房地产数据挖掘系统 comsci 数据挖掘
           随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间...        所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产     &nb
  • 数组队列总结 沐刃青蛟 数组队列
          数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。      以下是数组队列的功能实现代码：   import List.Student; public class
  • Oracle存储过程无法编译的解决方法 IT独行者 oracle存储过程　
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。   1.     查看无效对象 XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
  • 重装系统之后oracle恢复 文强chu oracle
    前几天正在使用电脑，没有暂停oracle的各种服务。 突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 直接把我的c盘给格式化了 并且清理了注册表，再装系统。 然后的结果就是我的oracl
  • python学习二（ 一些基础语法） 小桔子 pthon基础语法
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 1.ptyhon的源文件以UTF-8编码格式 2. /   除 结果浮点型 //  除 结果整形 %   除 取余数 *   乘 **  乘方 eg 5**2 结果是5的2次方25 _&
  • svn 常用命令 aichenglong SVN版本回退
    1 svn回退版本   1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 两者的区别:   revert this version:表示回退到当前版本(该版本后的版本全部作废)   revert chanages from this versio
  • 某小公司面试归来 alafqq 面试
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 老拿这些对付毕业生的东东来吓唬我。。 面试官很刁难，问了几个问题，记录下； 1，包的范围。。。public,private,protect. --悲剧了 2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 4，stru
  • 动态数组的存储速度比较 集合框架 百合不是茶 集合框架
    集合框架： 自定义数据结构(增删改查等) package 数组; /** * 创建动态数组 * @author 百合 * */ public class ArrayDemo{ //定义一个数组来存放数据 String[] src = new String[0]; /** * 增加元素加入容器 * @param s要加入容器
  • 用JS实现一个JS对象，对象里有两个属性一个方法 bijian1013 js对象
    <html> <head> </head> <body> 用js代码实现一个js对象，对象里有两个属性，一个方法 </body> <script> var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){
  • 探索JUnit4扩展：使用Rule bijian1013 java单元测试JUnitRule
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 1. Rule       &n
  • [Gson一]非泛型POJO对象的反序列化 bit1129 POJO
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 1. POJO对象不包含任何泛型的字段 2. POJO对象包含泛型字段，例如泛型集合或者泛型类 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO    
  • 【Kakfa五】Kafka Producer和Consumer基本使用 bit1129 kafka
    0.Kafka服务器的配置 一个Broker， 一个Topic Topic中只有一个Partition（）   1. Producer： package kafka.examples.producers; import kafka.producer.KeyedMessage; import kafka.javaapi.producer.Producer; impor
  • lsyncd实时同步搭建指南——取代rsync+inotify ronin47
    1. 几大实时同步工具比较 1.1 inotify + rsync 最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果 bylijinnan java
    public class IsBinTreePostTraverse{ static boolean isBSTPostOrder(int[] a){ if(a==null){ return false; } /*1.只有一个结点时，肯定是查找树 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是 6 {6,5}对应的BST是
  • MySQL的sum函数返回的类型 bylijinnan javaspringsqlmysqljdbc
    今天项目切换数据库时，出错 访问数据库的代码大概是这样： String sql = "select sum(number) as sumNumberOfOneDay from tableName"; List<Map> rows = getJdbcTemplate().queryForList(sql); for (Map row : rows
  • java设计模式之单例模式 chicony java设计模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的结构 　　单例模式的特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 　　饿汉式单例类   publ
  • javascript取当月最后一天 ctrain JavaScript
    <!--javascript取当月最后一天--> <script language=javascript> var current = new Date(); var year = current.getYear(); var month = current.getMonth(); showMonthLastDay(year, mont
  • linux tune2fs命令详解 daizj linuxtune2fs查看系统文件块信息
    一.简介： tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 二.用法： Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
  • 做有中国特色的程序员 dcj3sjt126com 程序员
      从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
  • Android：TextView属性大全 dcj3sjt126com textview
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
  • tomcat虚拟目录安装及其配置 eksliang tomcat配置说明tomca部署web应用tomcat虚拟目录安装
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 1.-------------------------------------------tomcat  目录结构 config：存放tomcat的配置文件 temp  ：存放tomcat跑起来后存放临时文件用的 work   ： 当第一次访问应用中的jsp
  • 浅谈：APP有哪些常被黑客利用的安全漏洞 gg163 APP
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 1. 应用反编译漏洞：APK 包非常容易被反编译成可读
  • C#根据网址生成静态页面 hvt Web.netC#asp.nethovertree
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法：   bool CreateHtmlFile(string url, string path) { //http://keleyi.com/a/bjae/3d10wfax.htm stri
  • SVG 教程 （一） 天梯梦 svg
    SVG 简介 SVG 是使用 XML 来描述二维图形和绘图程序的语言。 学习之前应具备的基础知识： 继续学习之前，你应该对以下内容有基本的了解： HTML XML 基础 如果希望首先学习这些内容，请在本站的首页选择相应的教程。 什么是SVG？ SVG 指可伸缩矢量图形 (Scalable Vector Graphics) SVG 用来定义用于网络的基于矢量
  • 一个简单的java栈 luyulong java数据结构栈
    public class MyStack { private long[] arr; private int top; public MyStack() { arr = new long[10]; top = -1; } public MyStack(int maxsize) { arr = new long[maxsize]; top
  • 基础数据结构和算法八：Binary search sunwinner AlgorithmBinary search
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 刘星宇 c面试
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 1.gets()函数 问：请找出下面代码里的问题： #include<stdio.h> int main(void) {     char buff[10];     memset(buff,0,sizeof(buff));
  • ITeye 7月技术图书有奖试读获奖名单公布 ITeye管理员 活动ITeye试读
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 7月试读活动回顾： http://webmaster.iteye.com/blog/2092746 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《Java性能优化权威指南》
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他