小白的进阶
小白的进阶

立体视觉标定和校正

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,学习)

  • 人生没有起跑线 星悦传奇
    张东辉，讲师七期坚持原创分享第700天（2019.8.3）家长问我们学哪些东西时，我对家长说，让孩子接受超前教育，并不能让他们长久地保持学习上的优势，反而会给孩子的社会性发展造成不可逆的损害。对一个人来说，暂时在成绩上的领先并不会给他带来什么巨大的改变，真正影响他、陪伴他一生的，是知识以外的东西。小学的时候我们都学习过“偃苗助长”的寓言，其实孩子和禾苗一样，他们的成长需要遵循自然发展的规律，如果对
  • 综合学习的思考 杨小芹
    “综合学习”这是一个特别不容易理解的词语。不光是我国，世界范围内应该都对这个词都有不同的理解。佐藤先生认为日本的杂志教育在对综合学习课程大多都停留在了观念层面。那么按照佐藤先生的理解，什么是“综合学习”呢？作者提到：学科学习的重要性也许今后也不会改变，但在进行学科学习的同时，也应该把处理人生征途中谁都会面临的现实课题、现代社会所要求的的现实问题的直接学习和学科学习并行起来加以组织。综合学习就是在想
  • 你活着可能已经死了-《得到》“武志红的心理学课”学习笔记28 大庆思考笔记
    人生由几百、几千乃至几万个大大小小的选择构成，等你老了，回顾一生的时候，你发现最亏待的，恰恰是你自己，那你这一生，就白活了。我们来做一个调查，很简单，然而也许很“致命”：你能不能想起五件事，你特别想做的，但却一直没有去做的，就按照自由联想的顺序，把这五件事写出来。现在，你可以做你自己的“父母”，试试带着点偏执劲，去追逐一些你特别想追逐的事物，以此来滋养你的本我。分享一段鲁米的诗给你：有一颗光的种子
  • 给孩子做敬重长辈的典范 趣口才
    孩子们是以我们作为学习典范的。假如要孩子培育起对你们真正的尊崇，他们得明白尊崇的详细含义。孩子们不只会听你讲话，也会察看你和配偶是如何看待本人父母的。在犹太教神学中，行为的重量比信条还要重。平民施穆尔的故事也精辟地表达了这个道理，他年老的父亲由于手指哆嗦，老是把汤汁洒落在桌布上。有一天晚上，老人掉落了一只精致的茶杯，摔碎在地板上。施穆尔说：“爸，从如今以后，你本人在房间吃饭，这个木碗给你用。用这个
  • 写给自己的一封信 莯希
    亲爱的希：你好！恭喜你完成了“”日更30天，接下来的日子，要继续加油，把书写变成你的习惯。现在是2021年12月，又一年即将过去，对于新的一年有什么计划呢？2022年9月，小宝就要读小学，届时你也完成对自己的承诺，在小学前，全身心陪伴着他们。他们进入新的阶段，你也一样，在此要做好充分的准备。一、坚持学习瑜伽。二、幼师资格证。三、营养师证。不管到时从事哪个行业，机会都是留给有准备的人。加油！不管怎样
  • ReactiveCocoa 学习笔记七（RACCommand） 那夜的星空分外清澈 ReactiveCocoaReactiveCocoa
    RACCommandRACCommand关键的两个方法如下，理解了他们便能理解RACCommand的作用。-(instancetype)initWithEnabled:(nullableRACSignal*)enabledSignalsignalBlock:(RACSignal*(^)(InputType_Nullableinput))signalBlock;-(RACSignal*)execut
  • C语言学习笔记：do..while循环、goto语句 女巫和她的乌鸦 C语言c语言学习
    do…while（）循环，do语句的语法：do循环语句；while（表达式）；例：intmain(){inti=1;do{printf("%d",i);i++;}while(i#include#includevoidmenu(){printf("1.play\n");printf("0.exit\n");}voidgame(){//猜数字游戏的实现:先生成随机数-->猜数字。rand函数返回了一个
  • 【DW11月-深度学习】Task03前馈神经网络 沫2021
    参考链接：https://datawhalechina.github.io/unusual-deep-learning/#/4.%E5%89%8D%E9%A6%88%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C一、神经元模型2.1神经元1943年，美国神经生理学家沃伦·麦卡洛克(WarrenMcCulloch)和数学家沃尔特·皮茨(WalterPitts)对生物神经元进行
  • 记录一次使用crontab未执行的排错过程
    目录一、过程复现1.命令有效性排查2.查看日志3.扩展测试4.问题解决二、总结一、过程复现我在学习使用crontab计划任务时，想实现每一分钟格式化输出一次当前日期和时间的效果，于是尝试：crontab-e*****date"+%F%T"#写入crontab-l*****date"+%F%T"#查看，确实写入了1.命令有效性排查然而我等了几分钟，屏幕上却没有任何输出，于是我在命令行手动执行一下这个
  • 【python学习】使用魔塔社区的模型
    前言魔塔社区有很多模型，但是怎么使用呢？刚开始学习python，简单的摸索一下一、新建项目1、创建虚拟环境condacreate-npaddlepython=3.102、激活虚拟环境condaactivatepaddle3、新建项目PyCharn新建一个项目，选择已创建的虚拟环境paddle项目新增models目录二、下载模型打开PyCharm的Terminal，命令行前面有一个(paddle)，
  • C语言学习（4）-- 循环语句（for、while、do...while）、goto 贪睡脑子 C语言学习c语言学习算法
    第一章while循环和do...while循环第一节while语句while(整型表达式){...}，如果整型表达式为真，即可进入循环体。举例说明：其中需要注意的是1.break和continue都只有在循环体中才可以使用。2.break是结束循环，continue是不执行后面语句，重新进入循环，继续循环。//该现象会进入死循环，因为到了i==5时，下面语句不执行，i始终为5——所以输出1234i
  • 高效能人士的学习法，期待对你有所帮助 廖斋笔谈
    学习美国物理学费曼(RichardDFeynman)在大学教授物理学时，他总是能够深入浅出地将复杂的专业理论讲得通俗易懂，无论多么抽象、晦涩的概念，都能用非常生活化的例子表达出来，非常风趣幽默。后来，越来越多的人便采用他的这种方法学习，最终形成了人们众所周知的「费曼学习法」。具体步骤「费曼学习法」可以用四个关键词来概括：概念(Concept)、以教代学(Teach)、评价(Review)、简化(S
  • 2019-11-13晨间日记 ZYHJ
    今天是什么日子起床：清晨6::00就寝：夜晚：22:30天气：风和日丽心情：愉快纪念日：任务清单昨日完成的任务，最重要的三件事：改进：习惯养成：生活规律周目标·完成进度学习·信息·阅读早读英语健康·饮食·锻炼晚餐散步人际·家人·朋友陪伴家人工作·思考继续努力最美好的三件事1.每天都有小进步2.3.思考·创意·未来保持原有节奏，继续努力
  • 2020-03-31 眸若含秋水丶
    今天学习冒泡排序，通过双重for循环来实现数组有序排列。定义变量名要求：1数字字母下划线组成。2不能以关键字命名（int，printf，if，else等）。3不能以数字开头。作业1#includeintmain(){inti;intb;inta[8]={1,2,3,4,5,6,7,8};for(i=1;iintmain(){floata[10]={1,2,3,4,5,6,7,8,9,10};int
  • 主流编程语言全景图：从Python到Rust的深度解析 万能小贤哥 pythonrust开发语言
    2024年编程语言生态报告显示，全球开发者使用的语言数量已达260+，但真正主导行业的不到20种。本文带你穿透技术迷雾，掌握8大核心语言的本质差异。一、选择编程语言的黄金标准图表代码二、八大主流语言对比解析1.Python-通用胶水语言特性：动态类型+缩进语法丰富的库生态（20万+包）GIL全局锁限制并发适用场景：python#机器学习示例（TensorFlow）importtensorflowa
  • 边缘智能革命：嵌入式机器学习如何让万物“思考” 万能小贤哥 机器学习人工智能
    当智能手表精准识别你的健身动作，工业传感器预测设备故障于毫秒之间，农业传感器自动调节灌溉水量——这些并非科幻场景，而是嵌入式机器学习（EmbeddedMachineLearning,或TinyML）正在悄然重塑的现实。这场发生在设备边缘的智能革命，正将AI从云端的数据中心拉近到我们指尖的每一台设备中。一、嵌入式机器学习：定义与核心价值嵌入式机器学习是指在资源极端受限的微控制器（MCU）、微处理器（
  • 感恩日记2021/02/28总1591 喜羊羊_43e1
    感恩爱人早起煮饺子。感恩营养美味的早餐对我身体的滋养。随喜爱人种下健康、时间、满愿、和谐的种子。感恩和爱人一起看望婆婆。感恩婆婆在弟弟弟媳的精心照顾下状态良好，看到婆婆早上吃了一碗多的米粥非常开心。感恩金钱宝宝支持我们夫妇支付弟媳照顾婆婆的费用。1月份、2月份是由小侄女照顾的，小侄女作为一个大学生，作为家族里的第三代，能够尽心尽力照顾奶奶两个月，实属难得。小侄女是我们这些长辈学习的榜样。多少的语言
  • 青春里重要的你！ 靖然呐
    图片发自App青春里能够遇见你真好！每个人的青春只有一回，我应该珍惜我们仅有的青春时光，可能这份珍惜是在学习上，但更多的应该是青春里的那个他（她）因为她（他）而努力奋斗。喜欢又不敢开口，只能默默的在背后跟随，直至青春结束，步入职场，默默守护！鼓起勇气去告白吧，不要在以后的某个时刻，而后悔此生没有选择对她（他）说，直到她（他）从你的身边永远走远。
  • 远方文学二级要开课了 洮南远方文学
    图片发自App近几日有家长不断咨询二级课程。二级课程开始正式学习小说和戏剧。像《红楼梦》、《巴黎圣母院》这些长篇小说是世界文学精粹！二级与一级不同，背诵比较少，主要是理解小说人物和情节。我们希望能够基于语文这个平台，让孩子从情感上从人性上得到更健康的影响，同时，我们真正的让孩子能够运用语言文字提升作品理解能力。人生路漫漫，好多东西是需要用投入时间和精力才能完成的！图片发自App
  • 良心高效的记单词软件 d6863d4a4904
    墨墨背单词（名字千万别弄错了！）这款帮助大家学习英语单词的软件，相信很多学习党小伙伴们或者身边的同学都会有使用过的，尤其是在加深单词记忆方面，根据同学们每天对所学单词的熟练或者模糊程度，结合了艾宾浩斯的遗忘曲线，根据时间长短来不断复现，坚持使用的话效果很不错噢！以下内容均为本人（一名不知名的考研党）亲测。大家要是想加强英语词汇量一定要试试啊！强推背单词软件！！首先是app签到页面，这个页面只有你每
  • 2021-06-04 不吼不叫如何调动孩子的主动性 天下谁人不读书
    爸爸妈妈都有过这样的经验，叫孩子吃饭，三请四请都不动；让他去洗澡，东摸摸西看看，就是不去洗；要他去读书学习，更是这翻翻那弄弄，导致父母不得不靠吼叫的高压手段才会起点作用。父母和孩子的目标有着巨大的差距，当他不饿，不想洗澡，不愿读书写字的时候，内心是抗拒的，因为他只会想那是父母要他去做，而不是自己想去做的事。日常对孩子教育，就像推一个木偶，推一下动一下，每天的生活就是父母一直在重复吼叫、催促、唠叨教
  • 红场 小霞老师mn
    曼宁妈妈，晚上好。⊙∀⊙！这节课主要学习了红场，介绍了俄罗斯的首都莫斯科的中心广场红场及一些著名的建筑，如克里姆林宫等，用线描去表现装饰。这幅画还没有结束，曼宁说很喜欢俄罗斯的天空，下节课还会抽半小时，带着她把颜色上了。曼宁的学习状态很好，整节课都很认真，速度也很快。下次要注意一下画面的整洁性，线条再干净一点点就完美了。继续加油(^ω^)
  • 讚（232-0857）｜智能方法练习王羲之的《圣教序》（硬笔）｜每日精进 开心练字
    所谓取法乎上，学习行书自然要学习书圣王羲之，而学书圣行书的最佳入门途径是学习和练习《圣教序》，毛笔如此，硬笔亦如此。几种常见形态比较image《圣教序》的特色言字旁极度夸张的拉开上下距离为全字增加了一丝“动感”。开心指数欣赏指数：★★★★☆易写指数：★★★☆☆实用指数：★★☆☆☆行笔路线（笔顺）image行笔路线如图：行楷的结构特征image形体（整体视野）左右视角——左低右高：整体呈斜的“行”书
  • 2020-12-30 c5d317597ea8
    20201230智慧父母课堂李艳坚持分享第4天今天我们学习了《古人谈读书》这篇文章，古人就告诉我们了读书的方法及读书的三到，即心到、眼到、口到。难怪一些学生读书爱加字，缺字主要是没有用心，今后要告诉他们读书的时候一定要用心。在今后的学习中三到都要用到，这样才能提高成绩。
  • 2019-03-12 黄侠_美兮妈
    【美兮修能】20190312识字营009期D110（学习力践行记录D499）早上读了《民国老课本》第121课，看了《森林里的小房子》，读了一本牛津树《Thejourey》。图片发自App下午从幼儿园回来的路上背了《望庐山瀑布》《瀑布》。晚饭后上外教课，玩得很开心。图片发自App然后和小伙伴一起做实验，熔岩大爆发、颜色变变变和彩虹糖水。图片发自App然后他们一起玩颜色。又拼了小猪佩奇的拼图。图片发自
  • 我的90天PPT修行历程 舞动_Echo
    大家好，我是PPT营销力50期超越梦想最666组的黄玉丽看到我的名字你们应该能感受到我本是软妹子But，你们知道吗~提前嘚瑟一下我居然打卡了一次线下演讲秀的总统筹这其中的飞跃让我忍不住回过头看看自己究竟做了什么起源自工作以来，一直在修炼自己负责公司对外分享的PPT一次成功的商业分享不仅需要演讲者本身的能力更需要ppt视觉传达力的冲击在PPT学习道路上一直孤军奋战自学过程中水平持续保持稳定因此一直在
  • 微服务网站开发学习路线与RuoYi-Cloud实战指南 你喜欢喝可乐吗？ ruoyi-cloudmicroservicesjavaweb微服务学习运维
    微服务网站开发学习路线与RuoYi-Cloud实战指南微服务架构已成为现代网站开发的主流选择，它通过将大型应用拆分为小型自治服务，实现了系统的高内聚、低耦合、独立部署和扩展。掌握微服务开发技能需要系统性学习，从基础概念到技术栈再到实战应用。本文将为您提供从零开始学习微服务的完整路线图，并结合RuoYi-Cloud开源框架进行详细举例，帮助您快速上手微服务网站开发。一、微服务基础概念与架构特点微服务
  • 我明明是老师，“病毒”把我变成了主播。 顾若_
    我明明是老师，“病毒”把我变成了主播。或许这是资历较深的老师们第一次成为“主播”；或许这是刚刚步入教师职位的年轻教师第一次网上授课；或许都有所不习惯，甚至家长也可能不适应学生在家中学习。早有很多的app都有线上教学，如小猿搜题、作业帮、线上名师讲课E网通等等。这次的疫情，使得全国中小学、高中、乃至大学生都是在网上开展教学工作，还有一些企业也将在网上进行办公~~对于学生网上学习、教师网上办公、授课、
  • 学习中 田慧婷
    坚持打卡记录第98天今天期中考试成绩全部出来，孩子们考的不太理想，不过高分的还是可以的，全校前200名占了6个，好了太多！两级分化太严重！
  • 初见：冬天开的猫印象 繁星月影
    跟随着八月的雨的足迹，邂逅了一只优秀博学的猫。于辛丑年甲午月壬辰日晚，与友冬天开的猫初见，缘于友八月的雨文理解是一门艺术中的评论。由于这段对话，我也很好奇啊，于是我也去见识见识这脑洞大开想象力丰富的人儿，悄悄的关注一下，向优秀的友学习，打算悄悄的去膜拜友的文。猫姐姐，在这看不出年龄距离，看大家都这样称呼，感觉比较亲切。之前猫的签名“你好，我这有些故事”，正好我也是喜欢看故事的人，喜欢听故事。后来签
  • 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其他