/**
 * 合同图片中公章提取
 * 1) 输入与输出都为PNG高保真图像 
 * 2) compile： g++ -g -o sealcut sealcut.cpp `pkg-config --cflags --libs opencv`
 * 3) usage: sealcut filename
 *
 * @yangxf
 * @date 2018-03
 */

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

#include <iostream>

#include <stdio.h>

#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <string.h>

using namespace std;
using namespace cv;
  
const char* windowname = "sealcut Demo";
const char* sealimgpath = "./sample";
const char* benchmarkpath = "./benchmark";

// 红色阈值
int hsvredlovalue = 140;
int hsvredhivalue = 250;

// 公章半径
int sealredius=154;

// 图像预处理
Mat initimage(char* imgname);

// 采用轮廓中的五角星定位公章图像：该算法对于五角星不明显的印章效果不佳
vector<Rect> locsealbycontours(Mat hqimg);

// 采用霍夫圆拟近圆形定位公章图像：该算法普适性较高，可以定位到图像中的所有圆形
vector<Rect> locsealbyhough(Mat hqimg);

// 公章图像切割
void cutseal(Mat srcimg, vector<Rect> rects, char* imgname);

// 霍夫圆变换
void houghseal(Mat srcimg, int index, char* imgname);

// 采用阈值法剔除红色公章，获得自由文字和签字的合同页
Mat maskimage(char* imgname);


int main( int argc, char** argv ) {
if(argc != 2) {
cout << " usage: sealocr filename, please input image file name!" << endl;
return 0;
}

char imgpath[200], srcimgname[200];
memset(imgpath, 0, sizeof(imgpath));
memset(srcimgname, 0, sizeof(srcimgname));

sprintf(srcimgname, "%s", argv[1]);
sprintf(imgpath, "%s/%s", sealimgpath, srcimgname);

cout << imgpath << endl;

// 图像增强
Mat imageGamma=initimage(imgpath);

// 采用霍夫圆拟近圆形定位公章图像
vector<Rect> rects=locsealbyhough(imageGamma);
    // 采用轮廓中的五角星定位公章图像, 该算法效果不佳，暂不用
// vector<Rect> rects= locseal(imageGamma);

// 根据grabcut实现公章图像提取
cutseal(imageGamma, rects, srcimgname);

// 如果需要调试，请打开如下语句
//waitKey();
return 1;
}

/**
 * 图像预处理
 * 1) 加载图像文件
 * 2) 图像增强
 *
 */
Mat initimage(char* imgname) {
Mat srcimg = imread(imgname);
namedWindow("srcimg",CV_WINDOW_NORMAL);
    imshow("srcimg", srcimg);
    
    // Gamma图像增强: 解决印章模糊不清的问题
    Mat imageGamma(srcimg.size(), CV_32FC3);  
    for (int i = 0; i < srcimg.rows; i++) {  
        for (int j = 0; j < srcimg.cols; j++) {  
            imageGamma.at<Vec3f>(i, j)[0] = (srcimg.at<Vec3b>(i, j)[0])*(srcimg.at<Vec3b>(i, j)[0])*(srcimg.at<Vec3b>(i, j)[0]);
            imageGamma.at<Vec3f>(i, j)[1] = (srcimg.at<Vec3b>(i, j)[1])*(srcimg.at<Vec3b>(i, j)[1])*(srcimg.at<Vec3b>(i, j)[1]);
            imageGamma.at<Vec3f>(i, j)[2] = (srcimg.at<Vec3b>(i, j)[2])*(srcimg.at<Vec3b>(i, j)[2])*(srcimg.at<Vec3b>(i, j)[2]);
        }
    }
    // 归一化到0~255
    normalize(imageGamma, imageGamma, 0, 255, CV_MINMAX);
    
    // 转换成8bit图像    
    convertScaleAbs(imageGamma, imageGamma);  
    //namedWindow("imageGamma",CV_WINDOW_NORMAL);
    //imshow("imageGamma", imageGamma);
    
    return imageGamma;
}

// 采用霍夫圆拟近圆形定位公章图像
vector<Rect> locsealbyhough(Mat hqimg) {
// RGB颜色转换为HSV
Mat hsvimage;
cvtColor(hqimg, hsvimage, COLOR_BGR2HSV);

// 阈值操作:查找指定范围内的颜色
Mat dstimage;
inRange(hsvimage, Scalar( hsvredlovalue,  40,  40), Scalar (hsvredhivalue, 255, 255), dstimage);

// 查找轮廓
vector<vector<Point> > contours;
findContours(dstimage, contours, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
namedWindow("findContours",CV_WINDOW_NORMAL);
imshow("findContours", dstimage);

// 将轮廓渲染为红色
vector<Rect> rects;
Mat drawimage = Mat::zeros(dstimage.size(), CV_8UC3);
for(int index = 0; index < contours.size(); index ++) {
vector<Point> dstcontour=contours[index];

drawContours(drawimage, contours, index, Scalar(0, 0, 255), 3, 8);
}
namedWindow("drawimage", CV_WINDOW_NORMAL);
imshow("drawimage", drawimage);

// 转为灰度图，进行图像平滑
Mat graymage;
    cvtColor(drawimage, graymage, CV_BGR2GRAY);
    GaussianBlur(graymage, graymage, Size(9, 9), 2, 2);

// 霍夫圆变换：去掉公章圆外部的噪声块
    Mat houghimage=Mat::zeros(drawimage.size(), CV_8UC3);
    
    vector<Vec3f> circles;
HoughCircles(graymage, circles, CV_HOUGH_GRADIENT, 2/*霍夫空间的分辨率*/, 300/*两个圆心之间最小距离*/, 100/*Canny阈值*/, 25, 100/*最小半径*/, 300/*最大半径*/);  
    
Point center;
int radius=0;

cout << "hough circles " << circles.size() << endl;
    for(size_t i = 0; i < circles.size(); i++) {
        center=Point(cvRound(circles[i][0]), cvRound(circles[i][1]));  
        radius = cvRound(circles[i][2]);
       
        if(radius < 130 || radius > 160)
         continue;
        
        cout << "locsealbyhough hough center " << center << endl;
        cout << "locsealbyhough hough radius " << radius << endl;
                
         //测试: 绘制圆心
        circle(houghimage, center, 3, Scalar(0, 255, 0), -1, 8, 0);  
        
        //测试: 绘制圆轮廓
        circle(houghimage, center, radius, Scalar(155, 50, 255), 3, 8, 0);
     
       rects.push_back(Rect(center.x - sealredius, center.y - sealredius, sealredius*2, sealredius*2));
}

namedWindow("houghseal", CV_WINDOW_NORMAL);
    imshow("houghseal", houghimage);
    
return rects;
}


/**
 * 采用轮廓中的五角星定位公章图像
 * 1) 采用HSV颜色阈值查找图像轮廓：公章图像是红色的
 * 2) 根据轮廓形态定位五角星位置，并计算出公章的矩形
 *
 */
vector<Rect> locsealbycontours(Mat hqimg) {
// RGB颜色转换为HSV
Mat hsvimage;
cvtColor(hqimg, hsvimage, COLOR_BGR2HSV);
//namedWindow("hsvimage", CV_WINDOW_NORMAL);
//imshow("hsvimage", hsvimage);

// 图像腐蚀和膨胀
/*
dilate(hsvimage, hsvimage, Mat(7,7,CV_8U), Point(-1,-1), 2);
erode(hsvimage, hsvimage, Mat(8,8,CV_8U), Point(-1,-1), 1);
namedWindow("hsvimage2",CV_WINDOW_NORMAL);
imshow("hsvimage2", HSVImage);
*/

// 阈值操作:查找指定范围内的颜色
Mat dstimage;
inRange(hsvimage, Scalar( hsvredlovalue,  40,  40), Scalar (hsvredhivalue, 255, 255), dstimage);

// 转换成二值图 
/*
threshold(dstimage, dstimage, 1, 255, THRESH_BINARY);  
namedWindow("dstimage",CV_WINDOW_NORMAL);
imshow(window_name, dstimage);
*/

// 查找轮廓
vector<vector<Point> > contours;
findContours(dstimage, contours, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
//namedWindow("findContours",CV_WINDOW_NORMAL);
//imshow("findContours", dstimage);

// 定位公章图像
vector<Rect> rects;
Mat drawimage = Mat::zeros(dstimage.size(), CV_8UC3);
for(int index = 0; index < contours.size(); index ++) {
vector<Point> dstcontour=contours[index];

// 测试：为了能看到公章图像效果
drawimage = Mat::zeros(dstimage.size(), CV_8UC3);
drawContours(drawimage, contours, index, Scalar(0, 0, 255), 3, 8);

// 轮廓面积
int area= int(fabs(contourArea( dstcontour )));

// 【重要】根据轮廓形态找到五角星(公章中间都有五角星)：面积>1000,  40<外接圆半径<60
if(area < 1000) {
continue;
}

     Point2f center; float radius;   
     minEnclosingCircle(dstcontour, center, radius);
     if(radius < 40 || radius > 60)
continue;

     cout << "area " << area << endl;
cout << "radius " << radius << endl;

// 测试：画轮廓的外接圆
     //circle(drawimage, center, (int)radius, Scalar(255, 0, 0), 2, 8, 0);
    
// 根据五角星中心点找到印章半径：印章半径值=154
circle( drawimage, center, sealredius, Scalar(0, 255, 0), 2, 8, 0 );
// 测试：是否为印章的外接矩形
//rectangle(drawimage, Point(center.x - 154, center.y - 154), Point(center.x + 154, center.y + 154), Scalar( 255, 0, 0), -1, 8); 

rects.push_back(Rect(center.x - sealredius, center.y - sealredius, sealredius*2, sealredius*2));
}

    //namedWindow("sealocr", CV_WINDOW_NORMAL);
    //imshow("sealocr", drawimage);

return rects;
}

/**
 * 公章图像切割
 * 1) 采用grabCut算法实现公章图像自动切割
 */
void cutseal(Mat srcimg, vector<Rect> rects, char* imgname) {
Mat bgModel;
Mat fgModel;

// 设置掩码图像
Mat result = cv::Mat::ones(srcimg.size(), CV_8U) * cv::GC_BGD;
for(int i = 0; i < rects.size(); i ++) {
Rect rect=rects[i];

// 设置前景掩码
rectangle(result, rect , cv::Scalar(cv::GC_PR_FGD), -1, 8, 0);
}
    Rect rect;
grabCut(srcimg, result, rect, bgModel, fgModel, 1, GC_INIT_WITH_MASK);
// 得到前景mask
compare(result, GC_PR_FGD, result, CMP_EQ);
Mat foreground(srcimg.size(), CV_8UC3, Scalar::all(255));
srcimg.copyTo(foreground, result);
namedWindow("foreground", CV_WINDOW_NORMAL);
    imshow("foreground", foreground);
for(int index = 0; index < rects.size(); index ++) {
Rect rect=rects[index];
cout << "index " << index << endl;
// 设置公章图像ROI
Mat fgroi(foreground, rect);
char winname[100];
sprintf(winname, "cutseal reslut  %d", index);
namedWindow(winname, CV_WINDOW_NORMAL);
        imshow(winname, fgroi);
        houghseal(fgroi, index, imgname);
}
}

/**
 * 霍夫圆变换
 * 1) 根据Hough圆变换找到标准的圆
 * 2) 剔除圆意外的其他噪声干扰
 *
 */
void houghseal(Mat srcimg, int index, char* imgname) {
// 转为灰度图，进行图像平滑
Mat graymage;
    cvtColor(srcimg, graymage, CV_BGR2GRAY);
    GaussianBlur(graymage, graymage, Size(9, 9), 2, 2);
// 霍夫圆变换：去掉公章圆外部的噪声块
    Mat houghimage=Mat::zeros(srcimg.size(), CV_8UC3);
    
    vector<Vec3f> circles;
//HoughCircles(graymage, circles, CV_HOUGH_GRADIENT, 2/*霍夫空间的分辨率*/, sealredius/*两个圆心之间最小距离*/, 200/*Canny阈值*/, 100, 100/*最小半径*/, 200/*最大半径*/);  
    
    HoughCircles(graymage, circles, CV_HOUGH_GRADIENT, 2/*霍夫空间的分辨率*/, 300/*两个圆心之间最小距离*/, 100/*Canny阈值*/, 25, 100/*最小半径*/, 300/*最大半径*/);  
   
Point center;
int radius=0;

cout << "hough circles " << circles.size() << endl;
    for(size_t i = 0; i < circles.size(); i++) {
        center=Point(cvRound(circles[i][0]), cvRound(circles[i][1]));  
        radius = cvRound(circles[i][2]);
        
        cout << "hough center " << center << endl;
        cout << "hough radius " << radius << endl;
        
        // 圆心与图像中心点距离太远
        if(abs(center.x - sealredius) > 20 || abs(center.y - sealredius) >20) {
         // Hough检测到非完整的圆(超出图像边界)，忽略
         return;
        }
        
        //测试: 绘制圆心
        circle(houghimage, center, 3, Scalar(0, 255, 0), -1, 8, 0);  
        
        //测试: 绘制圆轮廓
        circle(houghimage, center, radius, Scalar(155, 50, 255), 3, 8, 0);
}

char winname[100];
sprintf(winname, "houghseal reslut  %d", index);
    namedWindow(winname, CV_WINDOW_NORMAL);
    imshow(winname, houghimage); 
    // 建立圆形腌膜剔除其他噪声
    Mat circleimg(srcimg.size(), CV_8UC1, Scalar(0));
    
    // mask建立
    Mat roi = Mat::zeros(srcimg.size(), CV_8UC3);
    circle(roi, center, radius + 20, CV_RGB(255, 255, 255), -1);
    srcimg.copyTo(circleimg, roi);