镜头桶形失真校正算法

短焦镜头通常会产生桶形失真，以下是校正算法的matlab代码：

 

  1. %% 镜头桶形失真校正(短焦镜头)  
  2.   
  3. img_origin1 = imread('Still001.bmp');  
  4. img_origin = rgb2gray(img_origin1);  
  5.   
  6. k1 = -0.00000037;   % 形变参数，根据实际情况调整  
  7. k2 = -0.00000037;  
  8.   
  9. img_size = size( img_origin );  
  10. img_undist = zeros( img_size );  
  11. img_undist = uint8( img_undist );  
  12.   
  13.   
  14. for l1 = 1:img_size(1)  % 垂直方向  
  15.       
  16.     y = l1 - img_size(1)/2;  
  17.       
  18.     for l2 = 1:img_size(2)  % 水平方向  
  19.           
  20.         x = l2 - img_size(2)/2;  
  21.           
  22.         x1 = round( x * ( 1 + k1 * x * x + k2 * y * y ) );  
  23.         y1 = round( y * ( 1 + k1 * x * x + k2 * y * y ) );  
  24.         y1 = y1 + img_size(1)/2;  
  25.         x1 = x1 + img_size(2)/2;  
  26.           
  27.         img_undist(l1,l2) = img_origin(y1, x1);  
  28.           
  29.     end  
  30. end  
  31.   
  32.   
  33. figure(1);  
  34. subplot(121); imshow(img_origin);  
  35. subplot(122); imshow(img_undist);  
  36.   
  37. imwrite(img_origin,'1.bmp');  
  38. imwrite(img_undist,'2.bmp');  

在实时视频处理中，如果对每帧图像都要重复进行坐标转换运算，就是个很大的浪费，我们可以在初始化过程中先将坐标对应关系建立一个二维查找表，之后每帧处理只需要查表，C++代码如下（用到了OpenCV）：

 

  1. // 镜头校正查找表  
  2. CvPoint CorrInd[480][640];  
  3.   
  4. // 镜头径向畸变校正初始化  
  5. void LensCorrectInit( double k1 = -0.00000035, double k2 = -0.00000035 );  
  6.   
  7.   
  8. // 镜头径向畸变校正初始化  
  9. void LensCorrectInit( double k1, double k2 )  
  10. {  
  11.     int imgWidth = camera.GetWidth();   // 获得摄像头图像尺寸  
  12.     int imgHeight = camera.GetHeight();  
  13.   
  14.     int imgWd2 = imgWidth>>1;  
  15.     int imgHd2 = imgHeight>>1;  
  16.   
  17.     int it;  
  18.     int jt;  
  19.     int it2;  
  20.     int jt2;  
  21.   
  22.     for( int i=0; i
  23.     {  
  24.         it = ( i + 1 ) - imgHd2; // (i+1) 是其真正的图像坐标  
  25.         for( int j=0; j
  26.         {  
  27.             double temp;  
  28.   
  29.             jt = ( j + 1 ) - imgWd2; // (j+1) 是其真正的图像坐标  
  30.             temp = 1 + k1*it*it + k2*jt*jt;  
  31.             it2 = (int)(temp * it);  
  32.             jt2 = (int)(temp * jt);  
  33.   
  34.             it2 = it2 + imgHd2 + 1;  
  35.             jt2 = jt2 + imgWd2 + 1;  
  36.   
  37.             CorrInd[i][j].x = jt2;  
  38.             CorrInd[i][j].y = it2;  
  39.         }  
  40.     }  
  41. }  
  42.   
  43.   
  44.   
  45.   
  46. // 镜头径向畸变校正  
  47. void LensCorrect( IplImage* src, IplImage* dst )  
  48. {  
  49.     int imgWidth = dst->width;  
  50.     int imgHeight = dst->height;  
  51.   
  52.     int it2;  
  53.     int jt2;  
  54.   
  55.     for( int i=0; i
  56.     {  
  57.         uchar *pdstdata = (uchar*)(dst->imageData) + i*dst->widthStep;  
  58.   
  59.         for( int j=0; j
  60.         {  
  61.             it2 = CorrInd[i][j].y;  
  62.             jt2 = CorrInd[i][j].x;  
  63.   
  64.             uchar * psrcdata = cvPtr2D( src, it2, jt2 );  
  65.   
  66.             *(pdstdata++) = *(psrcdata++);  
  67.             *(pdstdata++) = *(psrcdata++);  
  68.             *(pdstdata++) = *(psrcdata++);  
  69.         }  
  70.     }  
  71. }  
版权声明：本文为shangyaowei原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。