opencv实现图像旋转

1.旋转后图像变大，但是原图像部分保持不变

法1：

 #include "cv.h"
 #include "highgui.h"

 int main()
 {
     double degree = 30; // rotate 30 degree
     double angle = degree  * CV_PI / 180.; // angle in radian
     double a = sin(angle), b = cos(angle); // sine and cosine of angle

     // Load source image as you wish
     IplImage *imgSrc = cvLoadImage("l:\\test\\5.jpg");
     int w_src = imgSrc->width;
     int h_src = imgSrc->height;
     cvNamedWindow ("src", 1);
     cvShowImage ("src", imgSrc);
     // Make w_dst and h_dst to fit the output image
     int w_dst = int(h_src * fabs(a) + w_src * fabs(b));
     int h_dst = int(w_src * fabs(a) + h_src * fabs(b));

     // map matrix for WarpAffine, stored in statck array
     double map[6];
     CvMat map_matrix = cvMat(2, 3, CV_64FC1, map);

     // Rotation center needed for cv2DRotationMatrix
     CvPoint2D32f pt = cvPoint2D32f(w_src / 2, h_src / 2);
     cv2DRotationMatrix(pt, degree, 1.0, &map_matrix);

     // Adjust rotation center to dst's center,
     // otherwise you will get only part of the result
     map[2] += (w_dst - w_src) / 2;
     map[5] += (h_dst - h_src) / 2;


     // We need a destination image

     IplImage *imgDst = cvCreateImage(cvSize(w_dst, h_dst), 8, 3);
     cvWarpAffine(
         imgSrc,
         imgDst,
         &map_matrix,
         CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS,
         cvScalarAll(0)
         );

     // Don't forget to release imgSrc and imgDst if you no longer need them
     cvNamedWindow( "dst_big", 1 );
     cvShowImage( "dst_big", imgDst);
     cvWaitKey(0);
     cvReleaseImage(&imgSrc);
     cvReleaseImage(&imgDst);
     return 0;
 }

 

法2：

 #include "cv.h"
 #include "highgui.h"
 #include "math.h"

 // clockwise 为true则顺时针旋转，否则为逆时针旋转
 IplImage* rotateImage(IplImage* src, int angle, bool clockwise)
 {
     angle = abs(angle) % 180;
     if (angle > 90)
     {
         angle = 90 - (angle % 90);
     }
     IplImage* dst = NULL;
     int width =
         (double)(src->height * sin(angle * CV_PI / 180.0)) +
         (double)(src->width * cos(angle * CV_PI / 180.0 )) + 1;
     int height =
         (double)(src->height * cos(angle * CV_PI / 180.0)) +
         (double)(src->width * sin(angle * CV_PI / 180.0 )) + 1;
     int tempLength = sqrt((double)src->width * src->width + src->height * src->height) + 10;
     int tempX = (tempLength + 1) / 2 - src->width / 2;
     int tempY = (tempLength + 1) / 2 - src->height / 2;
     int flag = -1;

     dst = cvCreateImage(cvSize(width, height), src->depth, src->nChannels);
     cvZero(dst);
     IplImage* temp = cvCreateImage(cvSize(tempLength, tempLength), src->depth, src->nChannels);
     cvZero(temp);

     cvSetImageROI(temp, cvRect(tempX, tempY, src->width, src->height));
     cvCopy(src, temp, NULL);
     cvResetImageROI(temp);

     if (clockwise)
         flag = 1;

     float m[6];
     int w = temp->width;
     int h = temp->height;
     m[0] = (float) cos(flag * angle * CV_PI / 180.);
     m[1] = (float) sin(flag * angle * CV_PI / 180.);
     m[3] = -m[1];
     m[4] = m[0];
     // 将旋转中心移至图像中间
     m[2] = w * 0.5f;
     m[5] = h * 0.5f;
     //
     CvMat M = cvMat(2, 3, CV_32F, m);
     cvGetQuadrangleSubPix(temp, dst, &M);
     cvReleaseImage(&temp);
     return dst;
 }

 int main(int argc, char **argv)
 {
     IplImage *src = 0;
     IplImage *dst = 0;

     int angle = 75;

     src = cvLoadImage("L:\\Test\\6.JPG");

     dst = rotateImage(src, angle, false);
     cvNamedWindow("dst", 1);
     cvShowImage("dst", dst);
     cvWaitKey(0);

     cvReleaseImage(&src);
     cvReleaseImage(&dst);
     return 0;
 }

2.图像大小始终不变，实现裁剪

法1：

 <span style="color:#000000;">#include "cv.h"
 #include "highgui.h"
 #include "math.h"
 void main( )
 {
     IplImage *Img_old=cvLoadImage("L:\\Test\\6.JPG");
     IplImage* Img_tmp =cvCloneImage( Img_old);

     int angle=45;
     float m[6];
     CvMat M = cvMat( 2, 3, CV_32F, m );
     CvPoint2D32f center;
     center.x=float (Img_old->width/2.0+0.5);
     center.y=float (Img_old->height/2.0+0.5);
     cv2DRotationMatrix( center, angle,1, &M);

     cvWarpAffine(Img_old,Img_tmp, &M,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) );

     cvNamedWindow ("src", 1);
     cvShowImage ("src", Img_old);
     cvNamedWindow( "dst", 1 );
     cvShowImage( "dst", Img_tmp );

     cvWaitKey(0);
     cvReleaseImage(&Img_old);
     cvReleaseImage(&Img_tmp);
 }</span>

 

法2：

 #include "cv.h"
 #include "highgui.h"
 #include "math.h"
 void main( )
 {
     IplImage *Img_old=cvLoadImage("L:\\Test\\6.JPG");
     IplImage* Img_tmp = NULL;

     int angle=45;
     double anglerad  = (CV_PI* (angle/180)) ;
     int newheight =int (fabs(( sin(anglerad)*Img_old->width )) + fabs(( cos(anglerad)*Img_old->height )) );//出现旋转后外围矩形大小哦！
     int newwidth  =int (fabs(( sin(anglerad)*Img_old->height)) + fabs(( cos(anglerad)*Img_old->width)) );
     Img_tmp = cvCreateImage(cvSize(newwidth,newheight), IPL_DEPTH_8U, 3);
     cvFillImage(Img_tmp,0);

     //对图像进行扩展
     //只能一定角度以内 不同象限的不同对待
     int dx=int((newwidth -Img_old->width )/2+0.5);
     int dy=int((newheight-Img_old->height)/2+0.5);
      //为了不越界
     uchar* old_ptr,*temp_ptr;
     for( int y=0 ; y<Img_old->height; y++)
     {
         for (int x=0 ; x< Img_old->width; x++)
         {
             old_ptr = &((uchar*)(Img_old->imageData + Img_old->widthStep*y))[(x)*3];
             temp_ptr = &((uchar*)(Img_tmp->imageData + Img_tmp->widthStep*(y+dy)))[(x+dx)*3];
             temp_ptr[0]=old_ptr[0]; //green
             temp_ptr[1]=old_ptr[1]; //blue
             temp_ptr[2]=old_ptr[2]; //Red
         }
     }//这里去掉就不行了

     float m[6];
     CvMat M = cvMat( 2, 3, CV_32F, m );
     CvPoint2D32f center;
     center.x=float (Img_tmp->width/2.0+0.5);
     center.y=float (Img_tmp->height/2.0+0.5);
     cv2DRotationMatrix( center, angle,1, &M);

     IplImage* temp = cvCloneImage( Img_tmp );
     cvWarpAffine( Img_tmp, temp, &M,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) );
     Img_tmp=cvCloneImage( temp );

     cvNamedWindow ("src", 1);
     cvShowImage ("src", Img_old);
     cvNamedWindow( "dst", 1 );
     cvShowImage( "dst", Img_tmp );
     cvWaitKey(0);
     cvReleaseImage(&Img_old);
     cvReleaseImage(&Img_tmp);
 }

 

3.图像大小不变，原图像内容也均保留，但是是由缩放所达到的

 #include "cv.h"
 #include "highgui.h"

 int _tmain(int argc, _TCHAR* argv[])
 {
    CvPoint2D32f srcTri[3],dstTri[3];
    CvMat* rot_mat=cvCreateMat(2,3,CV_32FC1);
    CvMat* warp_mat=cvCreateMat(2,3,CV_32FC1);
    IplImage *src,*dst;

    if(argc==2 && ((src=cvLoadImage(argv[1],1))!=0))
    {
       dst=cvCloneImage(src);
       dst->origin =src->origin ;
       cvZero(dst);
       //compute warp matrix
       srcTri[0].x =0;                            //src top left
       srcTri[0].y=0;
       srcTri[1].x =src->width -1;         //src top right
       srcTri[1].y=0;
       srcTri[2].x=0;                            //src bottom left offset
       srcTri[2].y=src->height -1;
       dstTri[0].x=src->width *0.0;       //dst top left
       dstTri[0].y=src->height *0.33;
       dstTri[1].x=src->width *0.85;     //dst top right
       dstTri[1].y=src->height *0.25;
       dstTri[2].x=src->width *0.15;     //dst bottom left offset
       dstTri[2].y=src->height *0.7;
       cvGetAffineTransform(srcTri,dstTri,warp_mat);
       cvWarpAffine(src,dst,warp_mat);
       cvCopy(dst,src);
       //compute rotation matrix
       CvPoint2D32f center=cvPoint2D32f(src->width /2,src->height /2);
       double angle=-50.0;
       double scale=0.6;
       cv2DRotationMatrix(center,angle,scale,rot_mat);
       //do the transformation
       cvWarpAffine(src,dst,rot_mat);
       cvNamedWindow("Affine_Transform",1);
       cvShowImage("Affine_Transform",dst);
       cvWaitKey();
     }

    cvReleaseImage(&dst);
    cvReleaseMat(&rot_mat);
    cvReleaseMat(&warp_mat);
    return 0;
 }