OPENCV 旋转图像算法-汇总

 

 void ImgRotate(cv::Mat imgIn, float theta, cv::Mat& imgOut)
 {
     int oldWidth = imgIn.cols;
     int oldHeight = imgIn.rows;

     // 源图四个角的坐标（以图像中心为坐标系原点）
     float fSrcX1, fSrcY1, fSrcX2, fSrcY2, fSrcX3, fSrcY3, fSrcX4, fSrcY4;
     fSrcX1 = (float)(-(oldWidth - ) / );
     fSrcY1 = (float)((oldHeight - ) / );
     fSrcX2 = (float)((oldWidth - ) / );
     fSrcY2 = (float)((oldHeight - ) / );
     fSrcX3 = (float)(-(oldWidth - ) / );
     fSrcY3 = (float)(-(oldHeight - ) / );
     fSrcX4 = (float)((oldWidth - ) / );
     fSrcY4 = (float)(-(oldHeight - ) / );

     // 旋转后四个角的坐标（以图像中心为坐标系原点）
     float fDstX1, fDstY1, fDstX2, fDstY2, fDstX3, fDstY3, fDstX4, fDstY4;
     fDstX1 = cos(theta) * fSrcX1 + sin(theta) * fSrcY1;
     fDstY1 = -sin(theta) * fSrcX1 + cos(theta) * fSrcY1;
     fDstX2 = cos(theta) * fSrcX2 + sin(theta) * fSrcY2;
     fDstY2 = -sin(theta) * fSrcX2 + cos(theta) * fSrcY2;
     fDstX3 = cos(theta) * fSrcX3 + sin(theta) * fSrcY3;
     fDstY3 = -sin(theta) * fSrcX3 + cos(theta) * fSrcY3;
     fDstX4 = cos(theta) * fSrcX4 + sin(theta) * fSrcY4;
     fDstY4 = -sin(theta) * fSrcX4 + cos(theta) * fSrcY4;

     int newWidth = (max(fabs(fDstX4 - fDstX1), fabs(fDstX3 - fDstX2)) + 0.5);
     int newHeight = (max(fabs(fDstY4 - fDstY1), fabs(fDstY3 - fDstY2)) + 0.5);

     imgOut.create(newHeight, newWidth, imgIn.type());

     float dx = -0.5*newWidth*cos(theta) - 0.5*newHeight*sin(theta) + 0.5*oldWidth;
     float dy = 0.5*newWidth*sin(theta) - 0.5*newHeight*cos(theta) + 0.5*oldHeight;

     int x, y;
     for (int i = ; i < newHeight; i++)
     {
         for (int j = ; j < newWidth; j++)
         {
             x = float(j)*cos(theta) + float(i)*sin(theta) + dx;
             y = float(-j)*sin(theta) + float(i)*cos(theta) + dy;

             if ((x < ) || (x >= oldWidth) || (y < ) || (y >= oldHeight))
             {
                 if (imgIn.channels() == )
                 {
                     imgOut.at<cv::Vec3b>(i, j) = cv::Vec3b(, , );
                 }
                 else if (imgIn.channels() == )
                 {
                     imgOut.at<uchar>(i, j) = ;
                 }
             }
             else
             {
                 if (imgIn.channels() == )
                 {
                     imgOut.at<cv::Vec3b>(i, j) = imgIn.at<cv::Vec3b>(y, x);
                 }
                 else if (imgIn.channels() == )
                 {
                     imgOut.at<uchar>(i, j) = imgIn.at<uchar>(y, x);
                 }
             }
         }
     }
 }

 void getAfterRotateRoi(cv::Mat& imgIn, int cols, int rows, Mat& imgOut)
 {

     imgOut.create(cols, rows, imgIn.type());
     Point center(imgIn.cols / , imgIn.rows / );

     imgOut = imgIn(Rect(imgIn.cols /  - cols / , imgIn.rows /  - rows / , cols,rows));

 }

 Mat ImageRotate2NewSize(Mat& src, const CvPoint &_center, double angle, double scale)
 {
     double angle2 = angle * CV_PI / ;
     int width = src.cols;
     int height = src.rows;

     double alpha = cos(angle2) * scale;
     double beta = sin(angle2) * scale;

     int new_width = (int)(width * fabs(alpha) + height * fabs(beta));
     int new_height = (int)(width * fabs(beta) + height * fabs(alpha));

     CvPoint2D32f center;
     center.x = float(width / );
     center.y = float(height / );
     //计算二维旋转的仿射变换矩阵
     Mat M = getRotationMatrix2D(center, angle, scale);

     // 给计算得到的旋转矩阵添加平移
     M.at<double>(, ) += (int)((new_width - width) / );
     M.at<double>(, ) += (int)((new_height - height) / );

     // rotate
     Mat dst;
     warpAffine(src, dst, M, cvSize(new_width, new_height), CV_INTER_LINEAR);
     return dst;
 }

参考：http://www.tuicool.com/articles/RZz2Eb