opencv几个自动检测图片方向的方法

有以下3种方法，minAreaRect就是将图像的有效点用一个矩形逼近，通过矩形的中心角计算偏转。存在目标图像过小就无效了。

2 PCA 计算主成份，算出角度，但是。存在目标图像过小就无效了。

3 DFT 貌似图小了，也可以看到频域的变化，可以进一步研究。

 

 

1 minAreaRect

//自动检测角度,只能针对背景简单的图来检测
//如果一个人手拿的纸文件是倾斜的，但整体是正向的，根本检测不出来
double getRotateDegreeWithSimpleBackGround(Mat img)
{
     

        int w = img.cols;
        int h = img.rows;
        Mat   resultColor, resultGray, whiteImage;
        double whitePoints = filteredRed(img, resultGray, resultColor, whiteImage);

        imshow("resultGray", resultGray);
        vector<Point> points;
        for (int x = 0; x < h; x++)
            for (int y = 0; y < w; y++)
            {

                int P = resultGray.at<uchar>(x, y);
                if (P == 0)
                {
                    Point pt;
                    pt.x = x;
                    pt.y = y;
                    points.push_back(pt);

                }

            }

        RotatedRect box = minAreaRect(Mat(points));

        cout << box.angle << endl;
        Mat NewDegreeImage;
        if (box.angle < -45)box.angle += 90;
        //旋转这块可以围绕那个中心左右转成功率高些 
        rotateImage1(img, NewDegreeImage, box.angle, 0);
        imshow("NewDegreeImage", NewDegreeImage);
        imshow("whiteImage", whiteImage);
        return box.angle;
     

}

 

2 PCA方法
int getRotateDegreeUsingPCA(Mat src, Mat ibw)
{
    // Load image
 // Mat src = imread("pca_test1.jpg");
//      Mat src = imread(argv[1]);
    // Check if image is loaded successfully
    if (!src.data || src.empty())
    {
        cout << "Problem loading image!!!" << endl;
        return EXIT_FAILURE;
    }
    imshow("src", src);
    // Convert image to grayscale
     Mat gray;
     cvtColor(src, gray, COLOR_BGR2GRAY);
    // Convert image to binary
     Mat bw;
     threshold(gray, bw, 50, 255,  THRESH_BINARY | THRESH_OTSU);
    // Find all the contours in the thresholded image
    vector<Vec4i> hierarchy;
    vector<vector<Point> > contours;
    //findContours(bw, contours, hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
    findContours(bw, contours, hierarchy,  RETR_LIST,  CHAIN_APPROX_NONE);
    for (size_t i = 0; i < contours.size(); ++i)
    {
        // Calculate the area of each contour
        double area = contourArea(contours[i]);
        // Ignore contours that are too small or too large
        if (area < 1e2 || 1e5 < area) continue;
        // Draw each contour only for visualisation purposes
        drawContours(src, contours, static_cast<int>(i), Scalar(0, 0, 255), 2, 8, hierarchy, 0);
        // Find the orientation of each shape
        getOrientation(contours[i], src);
    }
    imshow("output", src);
//    waitKey(0);
    return 0;
} 

3 DFT

//传入参数为灰度图
//图像必须足够大才会影响整体的DTE变换
double getRotateDegreeUsingDFT(Mat srcImg,Mat resultlImg)
{
#define GRAY_THRESH 100
#define HOUGH_VOTE 50
//    const char* filename = "imageText.jpg";
    //Mat srcImg = imread(filename,cv::IMREAD_GRAYSCALE);
    if (srcImg.empty())
        return -1;
    imshow("source", srcImg);

    Point center(srcImg.cols / 2, srcImg.rows / 2);

#ifdef DEGREE
    //Rotate source image
    Mat rotMatS = getRotationMatrix2D(center, DEGREE, 1.0);
    warpAffine(srcImg, srcImg, rotMatS, srcImg.size(), 1, 0, Scalar(255, 255, 255));
    imshow("RotatedSrc", srcImg);
    //imwrite("imageText_R.jpg",srcImg);
#endif

    //Expand image to an optimal size, for faster processing speed
    //Set widths of borders in four directions
    //If borderType==BORDER_CONSTANT, fill the borders with (0,0,0)
    Mat padded;
    int opWidth = getOptimalDFTSize(srcImg.rows);
    int opHeight = getOptimalDFTSize(srcImg.cols);
 
    copyMakeBorder(srcImg, padded, 0, opWidth - srcImg.rows, 0, opHeight - srcImg.cols, BORDER_CONSTANT, Scalar::all(0));

    Mat planes[] = { Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F) };
    Mat comImg;
    //Merge into a double-channel image
    merge(planes, 2, comImg);

    //Use the same image as input and output,
    //so that the results can fit in Mat well
    dft(comImg, comImg);

    //Compute the magnitude
    //planes[0]=Re(DFT(I)), planes[1]=Im(DFT(I))
    //magnitude=sqrt(Re^2+Im^2)
    split(comImg, planes);
    magnitude(planes[0], planes[1], planes[0]);

    //Switch to logarithmic scale, for better visual results
    //M2=log(1+M1)
    Mat magMat = planes[0];
    magMat += Scalar::all(1);
    log(magMat, magMat);

    //Crop the spectrum
    //Width and height of magMat should be even, so that they can be divided by 2
    //-2 is 11111110 in binary system, operator & make sure width and height are always even
    magMat = magMat(Rect(0, 0, magMat.cols & -2, magMat.rows & -2));

    //Rearrange the quadrants of Fourier image,
    //so that the origin is at the center of image,
    //and move the high frequency to the corners
    int cx = magMat.cols / 2;
    int cy = magMat.rows / 2;

    Mat q0(magMat, Rect(0, 0, cx, cy));
    Mat q1(magMat, Rect(0, cy, cx, cy));
    Mat q2(magMat, Rect(cx, cy, cx, cy));
    Mat q3(magMat, Rect(cx, 0, cx, cy));

    Mat tmp;
    q0.copyTo(tmp);
    q2.copyTo(q0);
    tmp.copyTo(q2);

    q1.copyTo(tmp);
    q3.copyTo(q1);
    tmp.copyTo(q3);

    //Normalize the magnitude to [0,1], then to[0,255]
    normalize(magMat, magMat, 0, 1,  cv::NORM_MINMAX);
    Mat magImg(magMat.size(), CV_8UC1);
    magMat.convertTo(magImg, CV_8UC1, 255, 0);
    imshow("magnitude", magImg);
    //imwrite("imageText_mag.jpg",magImg);

    //Turn into binary image
     
    threshold(magImg, magImg, GRAY_THRESH, 255,  THRESH_BINARY);
    imshow("mag_binary", magImg);
    //imwrite("imageText_bin.jpg",magImg);

    //Find lines with Hough Transformation
    vector<Vec2f> lines;
    float pi180 = (float)CV_PI / 720;
    Mat linImg(magImg.size(), CV_8UC3);
    HoughLines(magImg, lines, 1, pi180, HOUGH_VOTE, 0,5);
    //HoughLinesP(dst, lines, 1, CV_PI / 720, 30, roiImage.rows / 3, 3);
    int numLines = lines.size();
    for (int l = 0; l < numLines; l++)
    {
        float rho = lines[l][0], theta = lines[l][1];
        Point pt1, pt2;
        double a = cos(theta), b = sin(theta);
        double x0 = a * rho, y0 = b * rho;
        pt1.x = cvRound(x0 + 1000 * (-b));
        pt1.y = cvRound(y0 + 1000 * (a));
        pt2.x = cvRound(x0 - 1000 * (-b));
        pt2.y = cvRound(y0 - 1000 * (a));
        line(linImg, pt1, pt2, Scalar(255, 0, 0), 3, 8, 0);
    }
    imshow("lines", linImg);
    //imwrite("imageText_line.jpg",linImg);
    if (lines.size() == 3) {
        cout << "found three angels:" << endl;
        cout << lines[0][1] * 180 / CV_PI << endl << lines[1][1] * 180 / CV_PI << endl << lines[2][1] * 180 / CV_PI << endl << endl;
    }

    //Find the proper angel from the three found angels
    float angel = 0;
    float piThresh = (float)CV_PI / 90;
    float pi2 = CV_PI / 2;
    for (int l = 0; l < numLines; l++)
    {
        float theta = lines[l][1];
        if (abs(theta) < piThresh || abs(theta - pi2) < piThresh)
            continue;
        else {
            angel = theta;
            break;
        }
    }

    //Calculate the rotation angel
    //The image has to be square,
    //so that the rotation angel can be calculate right
    angel = angel < pi2 ? angel : angel - CV_PI;
    if (angel != pi2) {
        float angelT = srcImg.rows*tan(angel) / srcImg.cols;
        angel = atan(angelT);
    }
    float angelD = angel * 180 / (float)CV_PI;
    cout << "the rotation angel to be applied:" << endl << angelD << endl << endl;

    //Rotate the image to recover
    Mat rotMat = getRotationMatrix2D(center, angelD, 1.0);
    Mat dstImg = Mat::ones(srcImg.size(), CV_8UC3);
    warpAffine(srcImg, dstImg, rotMat, srcImg.size(), 1, 0, Scalar(255, 255, 255));
    imshow("DFT旋转结果", dstImg);
    //imwrite("imageText_D.jpg",dstImg);
    resultlImg=dstImg;
    //waitKey(0);
}