ScanLayer.cpp

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

using namespace cv;
using namespace std;

Mat imggryblr, imgcanny, imgdilate, imgwarp;

Mat preprocessing(Mat img) {
    cvtColor(img, imggryblr, COLOR_BGR2GRAY);
    GaussianBlur(imggryblr, imggryblr, Size(3, 3), 3, 0);
    Canny(imggryblr, imgcanny, 50, 150);
    Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3));
    dilate(imgcanny, imgdilate, kernel);
    return imgdilate;
}

vector<Point> getContours(Mat img, Mat &imgDraw) {
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    vector<Point> biggest;
    int maxArea = 0;

    findContours(img, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

    for (int i = 0; i < contours.size(); i++) {
        float area = contourArea(contours[i]);
        if (area > 1000) {
            vector<Point> approx;
            float peri = arcLength(contours[i], true);
            approxPolyDP(contours[i], approx, 0.02 * peri, true);
            if (approx.size() == 4) {
                Rect bound = boundingRect(approx);
                float aspectRatio = (float)bound.width / bound.height;
                if (area > maxArea && aspectRatio > 0.6 && aspectRatio < 1.5) {
                    biggest = approx;
                    maxArea = area;
                }
            }
        }
    }

    // Draw the biggest contour for visual debug
    if (!biggest.empty()) {
        vector<vector<Point>> drawBiggest{biggest};
        drawContours(imgDraw, drawBiggest, -1, Scalar(255, 0, 255), 3);
    }

    return biggest;
}

vector<Point> reorderPoints(vector<Point> points) {
    vector<Point> newPoints(4);
    vector<int> sumPts, diffPts;

    for (int i = 0; i < 4; i++) {
        sumPts.push_back(points[i].x + points[i].y);
        diffPts.push_back(points[i].y - points[i].x);
    }

    newPoints[0] = points[min_element(sumPts.begin(), sumPts.end()) - sumPts.begin()]; // Top-left
    newPoints[3] = points[max_element(sumPts.begin(), sumPts.end()) - sumPts.begin()]; // Bottom-right
    newPoints[1] = points[min_element(diffPts.begin(), diffPts.end()) - diffPts.begin()]; // Top-right
    newPoints[2] = points[max_element(diffPts.begin(), diffPts.end()) - diffPts.begin()]; // Bottom-left

    return newPoints;
}

void findXY(vector<Point> points, float &w, float &h) {
    float widthTop = norm(points[1] - points[0]);
    float widthBottom = norm(points[3] - points[2]);
    w = max(widthTop, widthBottom);

    float heightLeft = norm(points[2] - points[0]);
    float heightRight = norm(points[3] - points[1]);
    h = max(heightLeft, heightRight);
}

Mat getWarp(Mat img, vector<Point> points, float w, float h) {
    Point2f src[4] = {points[0], points[1], points[2], points[3]};
    Point2f dst[4] = {{0.0f, 0.0f}, {w, 0.0f}, {0.0f, h}, {w, h}};
    Mat matrix = getPerspectiveTransform(src, dst);
    warpPerspective(img, imgwarp, matrix, Size(w, h));
    return imgwarp;
}

int main() {
    string path = "E:/OpenCVResources/imgdoc.jpg";
    Mat imgOriginal = imread(path);
    if (imgOriginal.empty()) {
        cout << "Image not found!" << endl;
        return -1;
    }

    Mat imgDraw = imgOriginal.clone();
    Mat imgThres = preprocessing(imgOriginal);

    vector<Point> docPoints = getContours(imgThres, imgDraw);
    if (docPoints.empty()) {
        cout << "No document detected!" << endl;
        return -1;
    }

    docPoints = reorderPoints(docPoints);
    float width, height;
    findXY(docPoints, width, height);

    Mat warped = getWarp(imgOriginal, docPoints, width, height);

    // Optional cropping to remove white edges
    int cropVal = 5;
    Rect roi(cropVal, cropVal, width - 2 * cropVal, height - 2 * cropVal);
    Mat cropped = warped(roi);

    // Show results
    imshow("Original Image", imgDraw);
    imshow("Scanned Image", cropped);
    imwrite("E:/OpenCVResources/imgcrop.jpg", cropped);

    waitKey(0);
    return 0;
}