#include "ImgUtil.h"
|
#include <io.h>
|
|
NumberData ImgUtil::NUMS_LEVEL2[10];
|
NumberData ImgUtil::NUMS_GP_CODE[10];
|
NumberData ImgUtil::NUMS_TRADE_QUEUE[10];
|
uchar* ImgUtil::numsOneLevel_level2;
|
uchar* ImgUtil::numsOneLevel_gpcode;
|
uchar* ImgUtil::numsOneLevel_trade_queue;
|
|
cv::Mat ImgUtil::formatNumGPCode(cv::Mat num) throw(string) {
|
if (num.empty()) {
|
//¿ÕÖµÌî³ä0
|
cv::Mat zero;
|
ImgUtil::NUMS_GP_CODE[0].data.copyTo(zero);
|
return zero;
|
}
|
|
//È¥³ýÖÜΧµÄºÚ±ß
|
int rows = num.rows;
|
int cols = num.cols;
|
int startRow = -1, endRow = -1;
|
for (int r = 0;r < rows;r++) {
|
if (!ImgDivider::isRowEmpty(num, r)) {
|
startRow = r;
|
break;
|
}
|
}
|
|
for (int r = rows - 1;r > -1;r--) {
|
if (!ImgDivider::isRowEmpty(num, r)) {
|
endRow = r;
|
break;
|
}
|
}
|
//È¥³ýÇ°ºóµÄ°×±ß
|
int startCol = -1, endCol = -1;
|
for (int c = 0;c < cols;c++) {
|
if (!ImgDivider::isColEmpty(num, c, 1)) {
|
startCol = c;
|
break;
|
}
|
}
|
|
for (int c = cols - 1;c > -1;c--) {
|
if (!ImgDivider::isColEmpty(num, c, 1)) {
|
endCol = c;
|
break;
|
}
|
}
|
|
num = cv::Mat(num, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1));
|
|
//ÅжÏÁÐÊýÊÇ·ñÕý³£
|
if (num.cols == _NUMBER_GP_CODE_WIDTH && num.rows == _NUMBER_GP_CODE_HEIGHT) {
|
return num;
|
}
|
//ÍùÓÒϽÇÌí¼ÓÊý¾Ý
|
cv::Mat m = cv::Mat::zeros(num.rows, _NUMBER_GP_CODE_WIDTH - num.cols, CV_8UC1);
|
cv::Mat dst;
|
cv::hconcat(num, m, dst);
|
return dst;
|
}
|
|
cv::Mat ImgUtil::formatNumTradeQueue(cv::Mat num) throw(string)
|
{
|
if (num.empty()) {
|
//¿ÕÖµÌî³ä0
|
cv::Mat zero;
|
ImgUtil::NUMS_TRADE_QUEUE[0].data.copyTo(zero);
|
return zero;
|
}
|
|
//È¥³ýÖÜΧµÄºÚ±ß
|
int rows = num.rows;
|
int cols = num.cols;
|
int startRow = -1, endRow = -1;
|
for (int r = 0;r < rows;r++) {
|
if (!ImgDivider::isRowEmpty(num, r)) {
|
startRow = r;
|
break;
|
}
|
}
|
|
for (int r = rows - 1;r > -1;r--) {
|
if (!ImgDivider::isRowEmpty(num, r)) {
|
endRow = r;
|
break;
|
}
|
}
|
//È¥³ýÇ°ºóµÄ°×±ß
|
int startCol = -1, endCol = -1;
|
for (int c = 0;c < cols;c++) {
|
if (!ImgDivider::isColEmpty(num, c, 1)) {
|
startCol = c;
|
break;
|
}
|
}
|
|
for (int c = cols - 1;c > -1;c--) {
|
if (!ImgDivider::isColEmpty(num, c, 1)) {
|
endCol = c;
|
break;
|
}
|
}
|
|
num = cv::Mat(num, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1));
|
|
//ÅжÏÁÐÊýÊÇ·ñÕý³£
|
if (num.cols == _NUMBER_TRADE_QUEUE_WIDTH && num.rows == _NUMBER_TRADE_QUEUE_HEIGHT) {
|
return num;
|
}
|
//ÍùÓÒϽÇÌí¼ÓÊý¾Ý
|
cv::Mat m = cv::Mat::zeros(num.rows, _NUMBER_TRADE_QUEUE_WIDTH - num.cols, CV_8UC1);
|
cv::Mat dst;
|
cv::hconcat(num, m, dst);
|
return dst;
|
}
|
|
|
|
//·Ö¸ôʱ¼ä
|
list<cv::Mat> ImgUtil::splitTime(cv::Mat src) throw(std::string) {
|
cv::Mat binary;
|
threshold(src, binary, 40, 255, cv::THRESH_BINARY);
|
int rows = src.rows;
|
int cols = src.cols;
|
|
//ÉÏϵİױßÈ¥³ý
|
int startRow = -1;
|
int endRow = -1;
|
for (int r = 0;r < rows;r++) {
|
if (!ImgDivider::isRowEmpty(binary, r)) {
|
startRow = r;
|
break;
|
}
|
}
|
|
for (int r = rows - 1;r > -1;r--) {
|
if (!ImgDivider::isRowEmpty(binary, r)) {
|
endRow = r;
|
break;
|
}
|
}
|
|
//ðºÅµÄµäÐÍÌØÕ÷0001000
|
//-----------´ÓÖмäÍùÁ½±ß±éÀú²éÕÒðºÅ·Ö¸ô·û----------
|
int s = cols / 2;
|
int i;
|
//ÍùÇ°²éÕÒðºÅ
|
int m1_s = -1, m1_e = -1, m2_s = -1, m2_e = -1;
|
uchar* temp = (uchar*)malloc(sizeof(uchar) * 7);
|
for (i = s;i > -1;i--) {
|
if (i < 6) {
|
break;
|
}
|
*temp = binary.ptr<uchar>(endRow)[i];
|
|
*(temp + 1) = binary.ptr<uchar>(endRow)[i - 1];
|
*(temp + 2) = binary.ptr<uchar>(endRow)[i - 2];
|
*(temp + 3) = binary.ptr<uchar>(endRow)[i - 3];
|
*(temp + 4) = binary.ptr<uchar>(endRow)[i - 4];
|
*(temp + 5) = binary.ptr<uchar>(endRow)[i - 5];
|
*(temp + 6) = binary.ptr<uchar>(endRow)[i - 6];
|
if (*(temp + 3) > 0 && binary.ptr<uchar>(endRow - 1)[i - 3] == 0) {
|
int t = *temp + *(temp + 1) + *(temp + 2) + *(temp + 4) + *(temp + 5) + *(temp + 6);
|
if (t == 0) {
|
m1_s = i - 6;
|
m1_e = i;
|
break;
|
}
|
}
|
|
}
|
//Íùºó²éÕÒðºÅ
|
|
for (i = s;i < cols;i++) {
|
if (i > cols - 6) {
|
break;
|
}
|
|
*temp = binary.ptr<uchar>(endRow)[i];
|
*(temp + 1) = binary.ptr<uchar>(endRow)[i + 1];
|
*(temp + 2) = binary.ptr<uchar>(endRow)[i + 2];
|
*(temp + 3) = binary.ptr<uchar>(endRow)[i + 3];
|
*(temp + 4) = binary.ptr<uchar>(endRow)[i + 4];
|
*(temp + 5) = binary.ptr<uchar>(endRow)[i + 5];
|
*(temp + 6) = binary.ptr<uchar>(endRow)[i + 6];
|
if (*(temp + 3) > 0 && binary.ptr<uchar>(endRow - 1)[i + 3] == 0) {
|
int t = *temp + *(temp + 1) + *(temp + 2) + *(temp + 4) + *(temp + 5) + *(temp + 6);
|
if (t == 0) {
|
m2_s = i;
|
m2_e = i + 6;
|
break;
|
}
|
}
|
}
|
|
free(temp);
|
|
if (m1_s < 0 || m1_e < 0 || m2_s < 0 || m2_e < 0) {
|
|
imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\error\\0.jpg", src);
|
|
throw ("δ²éѯµ½·Ö¸ô·û");
|
}
|
|
list<cv::Mat> nums;
|
//»ñÈ¡·Ö¸ôÊý×Ö×ø±ê(ʱ£¬·Ö£¬Ãë)
|
list<cv::Mat> tempMat;
|
list<cv::Mat>::iterator ele;
|
tempMat = splitNum(cv::Mat(binary, cv::Rect(0, startRow, m1_s - 1 - (0) + 1, endRow - startRow + 1)));
|
for (ele = tempMat.begin();ele != tempMat.end();ele++) {
|
nums.push_back(*ele);
|
}
|
tempMat = splitNum(cv::Mat(binary, cv::Rect(m1_e + 1, startRow, (m2_s - 1) - (m1_e + 1) + 1, endRow - startRow + 1)));
|
for (ele = tempMat.begin();ele != tempMat.end();ele++) {
|
nums.push_back(*ele);
|
}
|
tempMat = splitNum(cv::Mat(binary, cv::Rect(m2_e + 1, startRow, (cols - 1) - (m2_e + 1) + 1, endRow - startRow + 1)));
|
for (ele = tempMat.begin();ele != tempMat.end();ele++) {
|
nums.push_back(*ele);
|
}
|
return nums;
|
}
|
|
|
|
//·Ö¸ôСÊý£¬ÖмäµÄ¿ÕMat±íʾСÊýµã
|
list<cv::Mat> ImgUtil::splitDecimal(cv::Mat src) throw(string) {
|
cv::Mat binary;
|
//È¥³ýÉÏϵĿհ×ͼ
|
threshold(src, binary, 40, 255, cv::THRESH_BINARY);
|
int rows = src.rows;
|
int cols = src.cols;
|
|
|
|
|
//ÉÏϵİױßÈ¥³ý
|
int startRow = -1;
|
int endRow = -1;
|
for (int r = 0;r < rows;r++) {
|
if (!ImgDivider::isRowEmpty(binary, r)) {
|
startRow = r;
|
break;
|
}
|
}
|
for (int r = rows - 1;r > -1;r--) {
|
if (!ImgDivider::isRowEmpty(binary, r)) {
|
endRow = r;
|
break;
|
}
|
}
|
binary = cv::Mat(binary, cv::Rect(0, startRow, cols, endRow - startRow + 1));
|
rows = binary.rows;
|
cols = binary.cols;
|
|
|
int i;
|
//ÍùÇ°²éÕÒСÊýµã
|
int m_s = -1, m_e = -1;
|
uchar* temp = (uchar*)malloc(sizeof(uchar) * 6);
|
for (i = 0;i < cols;i++) {
|
if (i > cols - 5) {
|
break;
|
}
|
*temp = binary.ptr<uchar>(rows - 1)[i];
|
|
*(temp + 1) = binary.ptr<uchar>(rows - 1)[i + 1];
|
*(temp + 2) = binary.ptr<uchar>(rows - 1)[i + 2];
|
*(temp + 3) = binary.ptr<uchar>(rows - 1)[i + 3];
|
*(temp + 4) = binary.ptr<uchar>(rows - 1)[i + 4];
|
*(temp + 5) = binary.ptr<uchar>(rows - 1)[i + 5];
|
if (*(temp + 2) > 0 && ImgDivider::isColEmpty(binary, i + 2, 0, rows - 2)) {
|
int t = *temp + *(temp + 1) + *(temp + 3) + *(temp + 4) + *(temp + 5);
|
if (t == 0) {
|
m_s = i;
|
m_e = i + 5;
|
break;
|
}
|
}
|
}
|
|
if (m_s == -1 || m_e == -1) {
|
|
imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\error\\1.jpg", src);
|
throw("δ²éÕÒµ½Ð¡Êýµã");
|
}
|
|
|
cv::Mat dotBefore = cv::Mat(binary, cv::Rect(0, 0, m_s, rows));
|
cv::Mat dotAfter = cv::Mat(binary, cv::Rect(m_e + 1, 0, cols - (m_e + 1), rows));
|
|
|
list<cv::Mat> nums;
|
list<cv::Mat> tempMat;
|
list<cv::Mat>::iterator ele;
|
|
|
tempMat = splitNum(dotBefore);
|
for (ele = tempMat.begin();ele != tempMat.end();ele++) {
|
nums.push_back(*ele);
|
}
|
|
tempMat = splitNum(dotAfter);
|
for (ele = tempMat.begin();ele != tempMat.end();ele++) {
|
nums.push_back(*ele);
|
}
|
return nums;
|
}
|
|
list<cv::Mat> ImgUtil::splitNum(cv::Mat src,int threshold_value) throw(string) {
|
cv::Mat binary;
|
//È¥³ýÉÏϵĿհ×ͼ
|
threshold(src, binary, threshold_value , 255, cv::THRESH_BINARY);
|
int rows = src.rows;
|
int cols = src.cols;
|
|
|
|
|
//ÉÏϵİױßÈ¥³ý
|
int startRow = -1;
|
int endRow = -1;
|
for (int r = 0;r < rows;r++) {
|
if (!ImgDivider::isRowEmpty(binary, r)) {
|
startRow = r;
|
break;
|
}
|
}
|
|
for (int r = rows - 1;r > -1;r--) {
|
if (!ImgDivider::isRowEmpty(binary, r)) {
|
endRow = r;
|
break;
|
}
|
}
|
|
if (startRow < 0) {
|
throw string("Êý×Ö·Ö¸ôδ²éÕÒµ½ÆðʼÐÐ");
|
}
|
|
if (endRow < 0) {
|
throw string("Êý×Ö·Ö¸ôδ²éÕÒµ½½áÊøÐÐ");
|
}
|
|
binary = cv::Mat(binary, cv::Rect(0, startRow, cols, endRow - startRow + 1));
|
rows = binary.rows;
|
cols = binary.cols;
|
|
|
|
//·Ö¸îÊý×Ö
|
std::list<int*> numberCols;
|
int c, startC = -1, endC = -1;
|
for (c = 0;c < cols;c++) {
|
|
if (ImgDivider::isColEmpty(binary, c, 1)) {
|
if (startC > -1 && endC > -1) {
|
int* data = (int*)malloc(sizeof(int) * 2);
|
*data = startC;
|
*(data + 1) = endC;
|
numberCols.push_back(data);
|
}
|
startC = -1;
|
endC = -1;
|
}
|
else {
|
if (startC == -1) {
|
startC = c;
|
endC = c;
|
}
|
else {
|
endC = c;
|
}
|
}
|
}
|
|
if (startC > -1 && endC > -1) {
|
int* data = (int*)malloc(sizeof(int) * 2);
|
*data = startC;
|
*(data + 1) = endC;
|
numberCols.push_back(data);
|
}
|
|
list<cv::Mat> resultList;
|
std::list<int*>::iterator ele;
|
for (ele = numberCols.begin(); ele != numberCols.end();ele++) {
|
int start = **ele;
|
int end = *(*ele + 1);
|
|
free(*ele);
|
cv::Mat img = cv::Mat(binary, cv::Rect(start, 0, end - start + 1, rows));
|
resultList.push_back(img);
|
/*std::string path = "C:\\Users\\Administrator\\Desktop\\ocr\\";
|
path = path.append(std::to_string(rand()));
|
path = path.append(".jpg");
|
try {
|
LogUtil::debug("±£´æÃû³Æ:%s\n", path.c_str());
|
imwrite(path, img);
|
}
|
catch (...) {
|
|
}*/
|
}
|
return resultList;
|
}
|
|
//·Ö¸ôÕûÊý
|
list<cv::Mat> ImgUtil::splitNum(cv::Mat src) throw(string) {
|
return splitNum(src,_IMG_BINARY_THRESHOLD);
|
}
|
|
cv::Mat ImgUtil::formatNumLevel2(cv::Mat num) throw(string) {
|
if (num.empty()) {
|
//¿ÕÖµÌî³ä0
|
cv::Mat zero;
|
ImgUtil::NUMS_LEVEL2[0].data.copyTo(zero);
|
return zero;
|
}
|
|
//È¥³ýÖÜΧµÄºÚ±ß
|
int rows = num.rows;
|
int cols = num.cols;
|
int startRow = -1, endRow = -1;
|
for (int r = 0;r < rows;r++) {
|
if (!ImgDivider::isRowEmpty(num, r)) {
|
startRow = r;
|
break;
|
}
|
}
|
|
for (int r = rows - 1;r > -1;r--) {
|
if (!ImgDivider::isRowEmpty(num, r)) {
|
endRow = r;
|
break;
|
}
|
}
|
//È¥³ýÇ°ºóµÄ°×±ß
|
int startCol = -1, endCol = -1;
|
for (int c = 0;c < cols;c++) {
|
if (!ImgDivider::isColEmpty(num, c, 1)) {
|
startCol = c;
|
break;
|
}
|
}
|
|
for (int c = cols - 1;c > -1;c--) {
|
if (!ImgDivider::isColEmpty(num, c, 1)) {
|
endCol = c;
|
break;
|
}
|
}
|
|
num = cv::Mat(num, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1));
|
|
//ÅжÏÁÐÊýÊÇ·ñÕý³£
|
if (num.cols == _NUMBER_L2_WIDTH && num.rows == _NUMBER_L2_HEIGHT) {
|
return num;
|
}
|
//ÍùÓÒϽÇÌí¼ÓÊý¾Ý
|
cv::Mat m = cv::Mat::zeros(num.rows, _NUMBER_L2_WIDTH - num.cols, CV_8UC1);
|
cv::Mat dst;
|
cv::hconcat(num, m, dst);
|
return dst;
|
}
|
|
|
|
|
|
|
|
|
|
|
void ImgUtil::init() {
|
|
//LEVE2Êý×Ö³õʼ»¯
|
for (int i = 0;i < 10;i++) {
|
std::string sdir = "C:\\Users\\Administrator\\Desktop\\ocr\\number\\";
|
if (_access(sdir.c_str(), 0)) {
|
sdir = "sample\\number\\";
|
}
|
|
|
std::string path = sdir.append(std::to_string(i)).append(".jpg");
|
NumberData data = NumberData();
|
data.data = formatNumLevel2(cv::imread(path.c_str(), cv::IMREAD_GRAYSCALE));
|
data.num = std::to_string(i);
|
NUMS_LEVEL2[i] = data;
|
}
|
|
numsOneLevel_level2 = (uchar*)malloc(sizeof(uchar) * _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH * 10);
|
for (int i = 0;i < 10;i++) {
|
int baseIndex = i * _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH;
|
for (int r = 0;r < _NUMBER_L2_HEIGHT;r++) {
|
int baseIndex_1 = r * _NUMBER_L2_WIDTH;
|
for (int c = 0;c < _NUMBER_L2_WIDTH;c++) {
|
int index = baseIndex + baseIndex_1 + c;
|
numsOneLevel_level2[index] = NUMS_LEVEL2[i].data.ptr<uchar>(r)[c];
|
}
|
}
|
}
|
|
|
for (int i = 0;i < 10;i++) {
|
std::string sdir = "C:\\Users\\Administrator\\Desktop\\ocr\\number_2\\";
|
if (_access(sdir.c_str(), 0)) {
|
sdir = "sample\\number_2\\";
|
}
|
|
std::string path = sdir.append(std::to_string(i)).append(".jpg");
|
NumberData data = NumberData();
|
data.data = formatNumGPCode(cv::imread(path.c_str(), cv::IMREAD_GRAYSCALE));
|
data.num = std::to_string(i);
|
NUMS_GP_CODE[i] = data;
|
}
|
|
numsOneLevel_gpcode = (uchar*)malloc(sizeof(uchar) * _NUMBER_GP_CODE_HEIGHT * _NUMBER_GP_CODE_WIDTH * 10);
|
for (int i = 0;i < 10;i++) {
|
int baseIndex = i * _NUMBER_GP_CODE_HEIGHT * _NUMBER_GP_CODE_WIDTH;
|
for (int r = 0;r < _NUMBER_GP_CODE_HEIGHT;r++) {
|
int baseIndex_1 = r * _NUMBER_GP_CODE_WIDTH;
|
for (int c = 0;c < _NUMBER_GP_CODE_WIDTH;c++) {
|
int index = baseIndex + baseIndex_1 + c;
|
numsOneLevel_gpcode[index] = NUMS_GP_CODE[i].data.ptr<uchar>(r)[c];
|
}
|
}
|
}
|
|
|
for (int i = 0;i < 10;i++) {
|
std::string sdir = "C:\\Users\\Administrator\\Desktop\\ocr\\number_trade\\";
|
if (_access(sdir.c_str(), 0)) {
|
sdir = "sample\\number_trade\\";
|
}
|
|
std::string path = sdir.append(std::to_string(i)).append(".jpg");
|
NumberData data = NumberData();
|
data.data = formatNumGPCode(cv::imread(path.c_str(), cv::IMREAD_GRAYSCALE));
|
data.num = std::to_string(i);
|
NUMS_TRADE_QUEUE[i] = data;
|
}
|
|
numsOneLevel_trade_queue = (uchar*)malloc(sizeof(uchar) * _NUMBER_TRADE_QUEUE_HEIGHT * _NUMBER_TRADE_QUEUE_WIDTH * 10);
|
for (int i = 0;i < 10;i++) {
|
int baseIndex = i * _NUMBER_TRADE_QUEUE_HEIGHT * _NUMBER_TRADE_QUEUE_WIDTH;
|
for (int r = 0;r < _NUMBER_TRADE_QUEUE_HEIGHT;r++) {
|
int baseIndex_1 = r * _NUMBER_TRADE_QUEUE_WIDTH;
|
for (int c = 0;c < _NUMBER_TRADE_QUEUE_WIDTH;c++) {
|
int index = baseIndex + baseIndex_1 + c;
|
numsOneLevel_trade_queue[index] = NUMS_TRADE_QUEUE[i].data.ptr<uchar>(r)[c];
|
}
|
}
|
}
|
|
|
}
|
|
list<int*> ImgUtil::divideImg(cv::Mat img) {
|
|
return divideImg(img, 0);
|
}
|
|
list<int*> ImgUtil::divideImg(cv::Mat img, bool save) {
|
//cv::imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\demo\\0_gray.jpg", img);
|
clock_t start_time = clock();
|
list<list<int*>> resultList;
|
|
int cols = img.cols - 1;
|
int rows = img.rows - 2;
|
int startf = -1;
|
int endf = -1;
|
//»ñÈ¡±êÌâµÄ·Ö¸îÏß
|
int contentStartRow = -1;
|
for (int i = 10;i < rows;i++) {
|
bool full = ImgDivider::isRowFull(img, i);
|
if (full) {
|
if (startf < 0)
|
{
|
startf = i;
|
endf = i;
|
}
|
else {
|
endf = i;
|
}
|
}
|
else {
|
if (startf > -1 && endf > -1) {
|
int width = endf - startf + 1;
|
contentStartRow = i;
|
break;
|
}
|
startf = -1;
|
endf = -1;
|
}
|
}
|
|
if (contentStartRow < 0) {
|
throw string("ͼÏñ·Ö¸ô³ö´í£ºtitle·Ö¸ô³ö´í");
|
}
|
|
|
//·Ö¸ôÿһÁÐÊý¾Ý
|
startf = -1;
|
endf = -1;
|
std::list<int*> dataColIndexs;
|
int startIndex = -1;
|
for (int i = 10;i < cols;i++) {
|
if (startIndex == -1) {
|
startIndex = i;
|
}
|
|
bool full = ImgDivider::isColFull(img, i, contentStartRow);
|
if (full) {
|
if (startf < 0)
|
{
|
startf = i;
|
endf = i;
|
}
|
else {
|
endf = i;
|
}
|
}
|
else {
|
if (startf > -1 && endf > -1) {
|
int width = endf - startf + 1;
|
int* dd = (int*)malloc(sizeof(int) * 2);
|
|
*dd = startIndex;
|
*(dd + 1) = startf - 1;
|
|
dataColIndexs.push_back(dd);
|
startIndex = i;
|
}
|
startf = -1;
|
endf = -1;
|
}
|
|
}
|
|
if (startf > -1 && endf > -1) {
|
int width = endf - startf + 1;
|
int* dd = (int*)malloc(sizeof(int) * 2);
|
|
*dd = startIndex;
|
*(dd + 1) = startf - 1;
|
|
dataColIndexs.push_back(dd);
|
|
startf = -1;
|
endf = -1;
|
}
|
|
|
//·Ö¸ôÿһÐеÄÊý¾Ý
|
std::list<int*> dataItemList;
|
startf = -1;
|
endf = -1;
|
std::list<int*>::iterator ele;
|
bool deleteEmpty=0;
|
|
for (ele = dataColIndexs.begin(); ele != dataColIndexs.end();ele++) {
|
//LogUtil::debug("µØÖ·£º%d \n",*ele);
|
int startCol = **ele;
|
int endCol = *(*ele + 1);
|
free(*ele);
|
//×ܹ²µÄÊý¾ÝÊýÁ¿
|
int dataCount = 0;
|
for (int i = contentStartRow;i < rows;i++) {
|
bool empty = ImgDivider::isRowEmpty(img, i, startCol, endCol, 3, 64) && ImgDivider::isRowEmpty(img, i, endCol - 20, endCol, 1, 64);
|
if (empty) {
|
if (startf > -1 && endf > -1) {
|
//ÄÚÈÝ×ø±ê
|
//LogUtil::debug("ÄÚÈݵĸ߶ÈΪ£º%d \n", endf - startf);
|
|
//ÐÐÊý¾Ý¸ß´óÓÚ6²ÅΪÓÐЧµÄÐиß
|
if (endf - startf > 6)
|
{
|
//ɾ³ýµÚÒ»ÌõÊý¾Ý
|
if (deleteEmpty)
|
{
|
int* dd = (int*)malloc(sizeof(int) * 4);
|
*dd = startf;
|
*(dd + 1) = startCol;
|
*(dd + 2) = endf;
|
*(dd + 3) = endCol;
|
dataItemList.push_back(dd);
|
}
|
deleteEmpty = 1;
|
}
|
dataCount++;
|
}
|
startf = -1;
|
endf = -1;
|
}
|
else
|
{
|
//Êý¾Ý¿ªÊ¼
|
if (startf == -1) {
|
startf = i;
|
endf = i;
|
}
|
else {
|
endf = i;
|
}
|
//Êý¾Ý½áÊø
|
}
|
}
|
|
}
|
|
|
return dataItemList;
|
|
//·Ö¸ôÿһÁеÄÊý¾Ý
|
int index = 0;
|
for (ele = dataItemList.begin(); ele != dataItemList.end();ele++) {
|
index++;
|
//µÚÒ»ÐÐÊý¾ÝÓÐtitle
|
if (index == 1) {
|
continue;
|
}
|
int startRow = *(*ele + 0);
|
int startCol = *(*ele + 1);
|
int endRow = *(*ele + 2);
|
int endCol = *(*ele + 3);
|
|
//±£´æÐÐÊý¾Ý
|
if (save) {
|
std::string path = "C:\\Users\\Administrator\\Desktop\\ocr\\split\\";
|
path.append(std::to_string(index)).append(".jpg");
|
imwrite(path, cv::Mat(img, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1)));
|
}
|
|
int emptyStart = -1;
|
int emptyEnd = -1;
|
int dataStart = -1;
|
int dataEnd = -1;
|
|
std::list<int*> rowDataList;
|
|
for (int i = startCol;i <= endCol;i++) {
|
bool empty = ImgDivider::isColEmpty(img, i, startRow, endRow, 64);
|
if (empty) {
|
if (emptyStart < 0) {
|
emptyStart = i;
|
emptyEnd = i;
|
}
|
else {
|
emptyEnd = i;
|
}
|
|
//3¸ö¼°ÒÔÉϵĿհ×Êý¾Ý²Å·ÖÁÐ
|
if (emptyEnd - emptyStart >= 5 && dataEnd - dataStart > 0) {
|
int* dd = (int*)malloc(sizeof(int) * 4);
|
*dd = startRow;
|
*(dd + 1) = dataStart;
|
*(dd + 2) = endRow;
|
*(dd + 3) = dataEnd;
|
rowDataList.push_back(dd);
|
dataEnd = -1;
|
dataStart = -1;
|
}
|
}
|
else {
|
if (dataStart < 0) {
|
dataStart = i;
|
dataEnd = i;
|
}
|
else {
|
dataEnd = i;
|
}
|
|
emptyStart = -1;
|
emptyEnd = -1;
|
}
|
}
|
//ºóÃæµÄÊý¾ÝûÓÐ×ã¹»µÄ¿Õ°×·Ö¸ô
|
if (dataEnd - dataStart > 0) {
|
int* dd = (int*)malloc(sizeof(int) * 4);
|
*dd = startRow;
|
*(dd + 1) = dataStart;
|
*(dd + 2) = endRow;
|
*(dd + 3) = dataEnd;
|
rowDataList.push_back(dd);
|
}
|
|
int rowDataSize = rowDataList.size();
|
|
|
|
//Èç¹ûûÓÐÂú7¸öÊý¾Ý£¬ÐèÒªÔÚÖм䲹¿ÕÊý¾Ý
|
if (rowDataSize < 7) {
|
//²¹Âò³· £¬²¹ÕÇÍ£
|
if (rowDataSize == 5) {
|
//µÚ2¸öλÖò¹Âò³·
|
rowDataList.insert(++begin(rowDataList), 0);
|
//µÚ4¸öλÖò¹ÕÇÍ£
|
rowDataList.insert(++(++(++begin(rowDataList))), 0);
|
}
|
else if (rowDataSize == 6) {
|
std::list<int*>::iterator ele = rowDataList.begin();
|
int* d1 = *ele;
|
int* d2 = *(++ele);
|
//µÚ¶þ¸öÔªËØ¿ªÊ¼×ø±ê¼õÈ¥µÚÒ»¸öÔªËؽáÊø×ø±êСÓÚ20
|
if (*(d2 + 1) - *(d1 + 3) < 20) {
|
//ÓÐÂò³·,ÐèÒª²¹ÕÇÍ£
|
rowDataList.insert(++(++(++begin(rowDataList))), 0);
|
}
|
else {
|
//ÎÞÂò³·
|
rowDataList.insert(++begin(rowDataList), 0);
|
}
|
}
|
else {
|
string st = "Êý¾Ý·Ö¸ô³ö´í Ðб꣺";
|
st.append(to_string(index));
|
//throw(st);
|
}
|
}
|
|
|
resultList.push_back(rowDataList);
|
|
|
//±£´æÊý¾Ý
|
if (save)
|
{
|
std::list<int*>::iterator ele1;
|
int cc = 0;
|
for (ele1 = rowDataList.begin(); ele1 != rowDataList.end();ele1++) {
|
if (*ele1)
|
{
|
int startCRow = *(*ele1 + 0);
|
int startCCol = *(*ele1 + 1);
|
int endCRow = *(*ele1 + 2);
|
int endCCol = *(*ele1 + 3);
|
cv::Mat temp = cv::Mat(img, cv::Rect(startCCol, startCRow, endCCol - startCCol + 1, endCRow - startCRow + 1));
|
std::string path = "C:\\Users\\Administrator\\Desktop\\ocr\\split\\";
|
path = path.append(std::to_string(index));
|
path = path.append("_");
|
path = path.append(std::to_string(cc));
|
path = path.append(".jpg");
|
imwrite(path.c_str(), temp);
|
}
|
cc++;
|
}
|
}
|
|
//ÊÍ·ÅÊý¾Ý
|
free(*ele);
|
|
|
}
|
|
|
cout << "·Ö¸ôÁÐÊý¾ÝºÄʱ£º" << (clock() - start_time) << endl;
|
|
return dataItemList;
|
|
|
}
|
|
|
void ImgUtil::splitRowNumDataForOpenCL(cv::Mat img, list<int*> data, unsigned char* result, int rowIndex) throw(string) {
|
list<cv::Mat> numList;
|
list<int*>::iterator ele;
|
int index = 0;
|
for (ele = data.begin();ele != data.end();ele++) {
|
index++;
|
switch (index)
|
{
|
//ʱ¼ä
|
case 1:
|
{
|
int startX = *(*ele + 1);
|
int startY = *(*ele);
|
int endX = *(*ele + 3);
|
int endY = *(*ele + 2);
|
list<cv::Mat> timeImgs = splitTime(cv::Mat(img, cv::Rect(startX, startY, endX - startX + 1, endY - startY + 1)));
|
list<cv::Mat>::iterator eleChild;
|
for (eleChild = timeImgs.begin();eleChild != timeImgs.end();eleChild++) {
|
numList.push_back(*eleChild);
|
}
|
}
|
break;
|
|
//Âò³·Ê±¼ä
|
case 2:break;
|
|
//¼Û¸ñ
|
case 3:
|
{
|
|
|
int startX = *(*ele + 1);
|
int startY = *(*ele);
|
int endX = *(*ele + 3);
|
int endY = *(*ele + 2);
|
list<cv::Mat> priceImgs = splitDecimal(cv::Mat(img, cv::Rect(startX, startY, endX - startX + 1, endY - startY + 1)));
|
//¼Û¸ñµÄÊý×Ö¸ñʽΪxxxx.xx
|
int emptySize = 6 - priceImgs.size();
|
//СÓÚ6λµÄÔÚÇ°ÃæÌî³ä¿ÕÖµ
|
for (int i = 0;i < emptySize;i++) {
|
numList.push_back(cv::Mat());
|
}
|
|
//Ìî³äʣϵÄÕæʵֵ
|
list<cv::Mat>::iterator eleChild;
|
for (eleChild = priceImgs.begin();eleChild != priceImgs.end();eleChild++) {
|
numList.push_back(*eleChild);
|
}
|
|
}
|
break;
|
|
|
//ÊÇ·ñÕÇÍ£¼Û
|
case 4:
|
break;
|
|
|
//½ð¶î
|
case 5:break;
|
|
|
//ÊÖÊý
|
case 6:
|
{
|
int startX = *(*ele + 1);
|
int startY = *(*ele);
|
int endX = *(*ele + 3);
|
int endY = *(*ele + 2);
|
list<cv::Mat> numImgs = splitNum(cv::Mat(img, cv::Rect(startX, startY, endX - startX + 1, endY - startY + 1)));
|
//ÊÖÊýµÄÊý×Ö¸ñʽΪxxxxx È磺00001,00203,10000
|
int emptySize = 5 - numImgs.size();
|
//СÓÚ6λµÄÔÚÇ°ÃæÌî³ä¿ÕÖµ
|
for (int i = 0;i < emptySize;i++) {
|
numList.push_back(cv::Mat());
|
}
|
|
//Ìî³äʣϵÄÕæʵֵ
|
list<cv::Mat>::iterator eleChild;
|
for (eleChild = numImgs.begin();eleChild != numImgs.end();eleChild++) {
|
numList.push_back(*eleChild);
|
}
|
}
|
break;
|
|
|
//ÀàÐÍ
|
case 7:
|
break;
|
default:
|
break;
|
}
|
|
|
}
|
|
|
//½«ËùÓеÄÊý×Ö¸ñʽ»¯Îª5*8µÄµãÕó¸ñʽ
|
int ROW = _NUMBER_L2_HEIGHT, COL = _NUMBER_L2_WIDTH;
|
int rowData = ROW * COL * 10 * _NUMBER_L2_TOTAL_NUMBER;
|
|
list<cv::Mat>::iterator eleM;
|
index = 0;
|
for (eleM = numList.begin();eleM != numList.end();eleM++) {
|
index++;
|
cv::Mat numMat = formatNumLevel2(*eleM);
|
//תΪÊý×éµÄÐÎʽ
|
for (int r = 0;r < ROW;r++) {
|
//½«Ã¿¸öÊý×ÖÖظ´¼ÓÈë10´Î,ÓÃÓÚ¾ØÕóÏà¼õ
|
for (int re = 0;re < 10;re++)
|
{
|
for (int c = 0;c < COL;c++) {
|
//¶þÖµ»¯
|
unsigned char d = numMat.ptr<unsigned char>(r)[c] > 40 ? 1 : 0;
|
int y = (index - 1) * COL * 10 + re * COL + c;
|
result[rowData * rowIndex + r * (COL * 10 * numList.size()) + y] = d;
|
//printf("(%d,%d)=%d ", r, y, result[r][y]);
|
}
|
}
|
}
|
//ÊÍ·ÅÄÚ´æ
|
numMat.release();
|
//printf("ÄÚ´æµØÖ·£º%ld", &result[0][0]);
|
//printf("\n");
|
}
|
|
/*
|
for (int i = 0;i < ROW;i++) {
|
printf("\n");
|
|
for (int j = 0;j < 850;j++) {
|
printf("(%d,%d)=%d ", i, j, result[i][j]);
|
}
|
}
|
*/
|
|
|
}
|
|
list<HWND> winList;
|
BOOL CALLBACK EnumChildProc(HWND hwndChild, LPARAM lParam)
|
{
|
winList.push_back(hwndChild);
|
return TRUE;
|
}
|
|
|
cv::Mat ImgUtil::grayImage(cv::Mat src) {
|
cv::Mat grayImage;
|
if (src.channels() == 3)
|
{
|
cvtColor(src, grayImage, cv::COLOR_RGB2GRAY);
|
}else if (src.channels() == 4) {
|
cvtColor(src, grayImage, cv::COLOR_RGBA2GRAY);
|
}
|
else if (src.channels() == 1) {
|
return src;
|
}
|
return grayImage;
|
}
|
|
uchar* ImgUtil::createTemplateNumData(int lines) {
|
int LINE_NUMBER_COUNT = _NUMBER_L2_TOTAL_NUMBER;
|
int NUMBER_COUNT = 10;
|
unsigned char* data = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * lines) * _NUMBER_L2_WIDTH * NUMBER_COUNT * LINE_NUMBER_COUNT);
|
int outLineDataCount = _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH * NUMBER_COUNT * LINE_NUMBER_COUNT;
|
int inLineDataCount = _NUMBER_L2_WIDTH * NUMBER_COUNT * LINE_NUMBER_COUNT;
|
for (int l = 0;l < lines;l++)
|
{
|
int outLineCount = outLineDataCount * l;
|
for (int re = 0;re < LINE_NUMBER_COUNT;re++) {
|
for (int n = 0;n < NUMBER_COUNT;n++)
|
{
|
for (int r = 0;r < _NUMBER_L2_HEIGHT;r++) {
|
int intLineCount = inLineDataCount * r;
|
|
for (int c = 0;c < _NUMBER_L2_WIDTH;c++) {
|
uchar value = ImgUtil::NUMS_LEVEL2[n].data.ptr(r)[c];
|
int index = outLineCount;
|
index += intLineCount;
|
int x = re * NUMBER_COUNT * _NUMBER_L2_WIDTH + n * _NUMBER_L2_WIDTH + c;
|
index += x;
|
data[index] = value > 40 ? 1 : 0;
|
}
|
}
|
}
|
}
|
}
|
return data;
|
}
|
|
//TODO ÅжÏÁ½ÕÅͼÊÇ·ñÒ»ÖÂ
|
bool ImgUtil::isImgSame(cv::Mat m1,cv::Mat m2) {
|
if (m1.cols != m2.cols || m1.rows != m2.rows) {
|
return FALSE;
|
}
|
cv::Mat m3;
|
cv::subtract(m1, m2 ,m3);
|
for (int r = 0;r < m3.rows;r++) {
|
for (int c = 0;c < m3.cols;c++) {
|
uchar value = m3.ptr<uchar>(r)[c];
|
if (value > 0) {
|
return FALSE;
|
}
|
}
|
}
|
return TRUE;
|
}
|
