C++印章提取功能使用python语言进行转换，请大佬指教！

[qq_43198759]

/**
* 合同图片中公章提取
* 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);