图像切边

 这里采用第一种方法

待处理得图

#include <opencv2/opencv.hpp>
#include <iostream>
#include <math.h>

using namespace cv;
using namespace std;

Mat src, gray_src, dst;
int threshold_value = 100;
int max_level = 255;

const char* output_win = "Contours Result";
const char* roi_win = "Final Result";

void FindROI(int, void*);
void Check_Skew(int, void*);

int main(int argc, char** argv) {
    src = imread("timg.jpg");
    if (src.empty()) {
        printf("could not load image...
");
        return -1;
    }
    namedWindow("input image", CV_WINDOW_AUTOSIZE);
    imshow("input image", src);
    namedWindow(output_win, CV_WINDOW_AUTOSIZE);
    Check_Skew(0, 0);
    // namedWindow(roi_win, CV_WINDOW_AUTOSIZE);
    //createTrackbar("Threshold:", output_win, &threshold_value, max_level, FindROI);
    // FindROI(0, 0);

    waitKey(0);
    return 0;
}

//将原图放正，如需切边还需执行另一个函数一次（因为不能对斜着的图直接切边）
void Check_Skew(int, void*) {
    Mat canny_output;
    cvtColor(src, gray_src, COLOR_BGR2GRAY);
    Canny(gray_src, canny_output, threshold_value, threshold_value * 2, 3, false);

    vector<vector<Point>> contours;
    vector<Vec4i> hireachy;
    findContours(canny_output, contours, hireachy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0));
    Mat drawImg = Mat::zeros(src.size(), CV_8UC3);
    float maxw = 0;
    float maxh = 0;
    double degree = 0;

    //获取最大旋转矩形的尺寸
    for (size_t t = 0; t < contours.size(); t++) {
        RotatedRect minRect = minAreaRect(contours[t]);
        degree = abs(minRect.angle);
        if (degree > 0) {//判断是否有旋转
            maxw = max(maxw, minRect.size.width);
            maxh = max(maxh, minRect.size.height);
        }
    }
    RNG rng(12345);

    //根据最大旋转矩形的尺寸，判断并画出来轮廓同时得到旋转角度
    for (size_t t = 0; t < contours.size(); t++) {
        RotatedRect minRect = minAreaRect(contours[t]);
        if (maxw == minRect.size.width && maxh == minRect.size.height) {//判断是否是最大边界
            degree = minRect.angle+90;//判断得是0点到height边的角度，逆时针为负，即使正放也有-90°所以要+90
            Point2f pts[4];
            minRect.points(pts);
            Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
            for (int i = 0; i < 4; i++) {
                line(drawImg, pts[i], pts[(i + 1) % 4], color, 2, 8, 0);
            }
        }
    }
    printf("max contours width : %f
", maxw);
    printf("max contours height : %f
", maxh);
    printf("max contours angle : %f
", degree);
    imshow(output_win, drawImg);

    //旋转成正的
    Point2f center(src.cols / 2, src.rows / 2);//旋转中心
    Mat rotm = getRotationMatrix2D(center, degree, 1.0);//函数调用形式：
                                                        //Mat getRotationMatrix2D(Point2f center,表示旋转的中心点
                                                                                //double angle, 表示旋转的角度
                                                                                //double scale)        图像缩放因子                                        
    Mat dst;
    warpAffine(src, dst, rotm, src.size(), INTER_LINEAR, 0, Scalar(255, 255, 255));//仿射变换
    imshow("Correct Image", dst);
}

//无旋转的处理函数，对已经放正的函数切边
void FindROI(int, void*) {

    //提取边缘
    cvtColor(src, gray_src, COLOR_BGR2GRAY);
    Mat canny_output;
    Canny(gray_src, canny_output, threshold_value, threshold_value * 2, 3, false);

    //绘制轮廓
    vector<vector<Point>> contours;
    vector<Vec4i> hireachy;
    findContours(canny_output, contours, hireachy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0));

    //画出最大轮廓的最小外接矩形
    int minw = src.cols*0.75;
    int minh = src.rows*0.75;
    RNG rng(12345);
    Mat drawImage = Mat::zeros(src.size(), CV_8UC3);
    Rect bbox;
    for (size_t t = 0; t < contours.size(); t++) {
        RotatedRect minRect = minAreaRect(contours[t]);//获取轮廓t的最小外接矩形，RotatedRect旋转矩形，可以设置矩形中心，矩形长宽，旋转角度
        float degree = abs(minRect.angle);//获取旋转角度
        if (minRect.size.width > minw && minRect.size.height > minh && minRect.size.width < (src.cols - 5)) {//轮廓筛选，选出最大的外接矩形
            printf("current angle : %f
", degree);
            Point2f pts[4];
            minRect.points(pts);//将最大的外接矩形的四个点赋给pts
            bbox = minRect.boundingRect();//外接正矩形边界
            Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
            for (int i = 0; i < 4; i++) {
                line(drawImage, pts[i], pts[(i + 1) % 4], color, 2, 8, 0);
            }
        }
    }
    imshow(output_win, drawImage);

    //用找到的最小外接矩形截取图像
    if (bbox.width > 0 && bbox.height > 0) {
        Mat roiImg = src(bbox);//用括号内的范围截取ROI区域
        imshow(roi_win, roiImg);
    }
    return;
}