#include <vector>
#include <algorithm>
#include <iostream>
#include <string>

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;


vector<string> files = { "P_20210309_064128_vHDR_Auto.jpg",
                         //"P_20210410_170757_vHDR_On.jpg" ,
                         //"P_20210410_170813_vHDR_On.jpg" ,
                         //"P_20210410_170832_vHDR_On.jpg" ,
                         "P_20210410_170858_vHDR_On.jpg" ,
                         "P_20210410_170941_vHDR_On.jpg" ,
                         "P_20210410_171129_vHDR_On.jpg" ,
                         "P_20210410_171136_vHDR_On.jpg" ,
                         "P_20210410_171334_vHDR_On.jpg" ,
};


void VizContours(Mat& src, const vector<Point>& points, const Scalar& color) {
    Point pt = points.back();
    for (auto& cur : points) {
        line(src, pt, cur, color, 5, LINE_AA);
        pt = cur;
    }
}


void FillHoles(const Mat& src, Mat& dst, int d) {
    src.copyTo(dst);
    for (int i = 0; i + d < src.rows; i += d) {
        for (int j = 0; j + d < src.cols; j += d) {
            int k = 0;
            for (int l = 0; l < d; ++l) {
                for (int m = 0; m < d; ++m) {
                    if (dst.at<uchar>(i + l, j + m) < 128) {
                        ++k;
                    }
                }
            }
            if (k > 0.1 * d * d) {
                for (int l = 0; l < d; ++l) {
                    for (int m = 0; m < d; ++m) {
                        dst.at<uchar>(i + l, j + m) = 0;
                    }
                }
            }
        }
    }
}

int main() {
    for (int i = 0; i < files.size(); ++i)
    {
        cout << "Image #" << i << endl;
        Mat src = imread(files[i]);
        Mat grayImg, blurImg, binImg, cannyImg, filtImg, dilImg, GausImg, lineImg;

        cvtColor(src, grayImg, COLOR_BGR2GRAY);
        GaussianBlur(grayImg, GausImg, {3, 3}, 0);
        dilate(GausImg, dilImg, getStructuringElement(cv::MORPH_RECT, cv::Point(9, 9)));
        //bilateralFilter(grayImg, filtImg, 9, 75, 75);
        Mat temp1, temp2;
       // adaptiveThreshold(filtImg, temp1, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 11, 2);
        //adaptiveThreshold(temp1, temp2, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 21, 5);
        adaptiveThreshold(dilImg, binImg, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 51, 5);
        //adaptiveThreshold(filtImg, binImg, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 21, 3);
        medianBlur(binImg, blurImg, 3);
        //FillHoles(blurImg, blurImg, 15);

        //copyMakeBorder(blurImg, blurImg, 10, 10, 10, 10, BORDER_CONSTANT, { 0, 0, 0 });
        //copyMakeBorder(src, src, 10, 10, 10, 10, BORDER_DEFAULT, { 0, 0, 0 });
        imwrite("1bin" + to_string(i) + ".jpg", blurImg);

        //Mat revImg;
        //bitwise_not(blurImg, revImg);
        Canny(blurImg, cannyImg, 0, 300);
        imwrite("3conturs" + to_string(i) + ".jpg", cannyImg);

        vector<Vec4i> lines;
        HoughLinesP(cannyImg, lines, 1, CV_PI / 180, 1, 1, 20);
        cannyImg.copyTo(lineImg);
        for (auto& l : lines) {
            Point pt1(l[0], l[1]);
            Point pt2(l[2], l[3]);
            //Point del = 0.3 * (pt2 - pt1);
            Point del = 0;
            line(lineImg, pt1 - del , pt2 + del, cv::Scalar(255, 0, 0), 3, 8);
        }
        //bitwise_not(lineImg, lineImg);
        //FillHoles(lineImg, lineImg, 7);
        //medianBlur(lineImg, lineImg, 5);
        medianBlur(lineImg, lineImg, 9);
        //medianBlur(lineImg, lineImg, 21);
        bitwise_not(lineImg, lineImg);

        imwrite("2line" + to_string(i) + ".jpg", lineImg);

        vector<vector<Point>> contours;
        vector<Vec4i> hierarchy;

        findContours(lineImg, contours, hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
        //findContours(lineImg, contours, hierarchy, RETR_LIST, CHAIN_APPROX_TC89_L1);
        sort(contours.begin(), contours.end(), [](vector<Point>& lhs, vector<Point>& rhs) {
            //return fabs(arcLength(Mat(lhs), true)) < fabs(arcLength(Mat(rhs), true));
            return fabs(contourArea(Mat(lhs))) < fabs(contourArea(Mat(rhs)));
        });
        //Mat trash;
        //src.copyTo(trash);
        //drawContours(trash, contours, -1, Scalar(255, 0, 0), 2, LINE_AA, hierarchy, 1);
        //imwrite("4trash" + to_string(i) + ".jpg", trash);
        vector<Point> mainContour = contours.back();
        double perimetr = arcLength(mainContour, true);
        Mat result1, result2;
        approxPolyDP(mainContour, result1, 0.02 * perimetr, true);
        approxPolyDP(mainContour, result2, 1e-9, true);
        //drawContours(src, { result2 }, -1, Scalar(0, 165, 255), 10, LINE_8);
        //drawContours(src, { mainContour }, -1, Scalar(0, 165, 255), 1, LINE_8);
        //VizContours(src, result2, Scalar(0, 165, 255));
        VizContours(src, result1, Scalar(255, 165, 0));
        imwrite("2result" + to_string(i) + ".jpg", src);

    }
    waitKey(0);
}

/*
*
### Задание
1. Реализовать выделение "границ и уголков" на фотографиях документа.
2. Реализовать детектирование наиболее правдоподобного четырехугольника изображения страницы документа на фото.
3. Используя эталонную геометрическую разметку из лабораторной 5 реализовать численную оценку качества выделения отдельных примитивов и финального результата для отдельных изображений и для набора.
4. Реализовать представление результатов выполнения лабораторной (иллюстрации, таблицы, графики и т.д.) и вставить в отчет.
*/