#include "THSDXJLCapture.h"
|
#include "GPUtil.h"
|
#include "OpenCLUtil.h"
|
#include "THSActionUtil.h"
|
#include "CaptureUtil.h"
|
#include <math.h>
|
#include "MD5.h"
|
#include <map>
|
|
OpenCLExcuter* THSDXJLCapture::openCLExcuter;
|
bool THSDXJLCapture::tradeTimeCapture;
|
bool THSDXJLCapture::running;
|
|
CallbackFun_DXJL_OCR THSDXJLCapture::ocr_fun;
|
|
void THSDXJLCapture::_run()
|
{
|
while (TRUE) {
|
if (tradeTimeCapture) {
|
if (!GPUtil::isTradeTime()) {
|
Sleep(2);
|
continue;
|
}
|
}
|
|
if (GPUtil::isBeforeTradeTime()) {
|
Sleep(1000);
|
}
|
if (running) {
|
try {
|
DXJLResult result = capture();
|
map<string, string> md5CodeNameMap;
|
int count = 0;
|
// API
|
for (std::list<DXJLOCRContent>::iterator ele = result.contentList.begin(); ele != result.contentList.end(); ele++) {
|
DXJLOCRContent content = *ele;
|
if (md5CodeNameMap.find(content.codeNameMD5) == md5CodeNameMap.end())
|
{
|
//mgUtil::markMat(grayImg, rect, 255, 1);
|
cv::Rect rect = content.codeNamePos;
|
rect.x = rect.x - 2;
|
rect.y = rect.y - 2;
|
rect.width = rect.width + 4;
|
rect.height = rect.height + 4;
|
|
//cv::imwrite(string("C:\\Users\\Administrator\\Desktop\\ocr\\dxjl\\code_name_").append(to_string(count)).append(".png"), cv::Mat(result.grayImg, rect));
|
count++;
|
cv::Mat mat = cv::Mat::zeros(rect.height, rect.width, CV_8UC1);
|
for (int r = rect.y; r < rect.y + rect.height; r++) {
|
for (int c = rect.x; c < rect.x + rect.width; c++) {
|
mat.ptr<uchar>(r - rect.y)[c - rect.x] = result.grayImg.ptr<uchar>(r)[c];
|
}
|
}
|
string code = ocr_fun(mat);
|
mat.release();
|
md5CodeNameMap[content.codeNameMD5] = code;
|
}
|
}
|
|
list<DXJLEvent> eventList;
|
for (std::list<DXJLOCRContent>::iterator ele = result.contentList.begin(); ele != result.contentList.end(); ele++) {
|
DXJLOCRContent content = *ele;
|
DXJLEvent event;
|
event.time = content.time;
|
event.code = md5CodeNameMap[content.codeNameMD5];
|
eventList.push_back(event);
|
}
|
}
|
catch (...) {
|
|
}
|
}
|
Sleep(5);
|
}
|
}
|
|
std::list<int*> THSDXJLCapture::splitRows(cv::Mat img, int contentStartRow, std::list<int*> dataColIndexs)
|
{
|
//·Ö¸ôÿһÐеÄÊý¾Ý
|
std::list<int*> dataItemList;
|
int startf = 0;
|
int endf = 0;
|
std::list<int*>::iterator ele;
|
|
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 < img.rows; i++) {
|
bool empty = ImgDivider::isRowEmpty(img, i, startCol, endCol, 2, 64);
|
if (empty) {
|
if (startf > -1 && endf > -1) {
|
//ÄÚÈÝ×ø±ê
|
//LogUtil::debug("ÄÚÈݵĸ߶ÈΪ£º%d \n", endf - startf);
|
|
//ÐÐÊý¾Ý¸ß´óÓÚ6²ÅΪÓÐЧµÄÐиß
|
if (endf - startf > 6)
|
{
|
|
int* dd = (int*)malloc(sizeof(int) * 4);
|
*dd = startCol;
|
*(dd + 1) = startf;
|
*(dd + 2) = endCol;
|
*(dd + 3) = endf;
|
dataItemList.push_back(dd);
|
|
}
|
dataCount++;
|
}
|
startf = -1;
|
endf = -1;
|
}
|
else
|
{
|
//Êý¾Ý¿ªÊ¼
|
if (startf == -1) {
|
startf = i;
|
endf = i;
|
}
|
else {
|
endf = i;
|
}
|
//Êý¾Ý½áÊø
|
}
|
}
|
|
}
|
|
return dataItemList;
|
}
|
|
std::list<int*> THSDXJLCapture::split(cv::Mat mat)
|
{
|
bool empty = false;
|
int startRow = -1;
|
for (int r =10; r < mat.rows; r++) {
|
if (ImgDivider::isRowEmpty(mat, r, 0, mat.cols-50, 1)) {
|
empty = TRUE;
|
}
|
else {
|
if (empty) {
|
startRow = r;
|
break;
|
}
|
}
|
}
|
|
cout << "ÆðʼÐУº" << startRow << endl;
|
|
|
int last_col = -1;
|
|
std::list<int*> colsIndex;
|
for (int c = 0; c < mat.cols; c++) {
|
//·Ö¸îÁÐ
|
int endRow = startRow + 100;
|
if (endRow >= mat.rows) {
|
endRow = mat.rows - 1;
|
}
|
if (ImgDivider::isColFull(mat, c, startRow, endRow, 2)) {
|
if (c - last_col > 20) {
|
|
int* pos = (int*)malloc(sizeof(int) * 2);
|
pos[0] = last_col + 1;
|
pos[1] = c - 1;
|
colsIndex.push_back(pos);
|
}
|
last_col = c;
|
}
|
}
|
|
if (mat.cols - last_col > 20) {
|
int* pos = (int*)malloc(sizeof(int) * 2);
|
pos[0] = last_col + 1;
|
pos[1] = mat.cols - 1;
|
colsIndex.push_back(pos);
|
}
|
|
return splitRows(mat, startRow, colsIndex);
|
|
}
|
|
string THSDXJLCapture::md5Mat(cv::Mat grayImg)
|
{
|
string st="";
|
for (int r = 0; r < grayImg.rows; r++) {
|
for (int c = 0; c < grayImg.cols; c++) {
|
uchar val = grayImg.ptr<uchar>(r)[c];
|
if (val >= _IMG_BINARY_THRESHOLD) {
|
val = 1;
|
}
|
else {
|
val = 0;
|
}
|
st.append(to_string(val)).append(",");
|
}
|
st.append("#");
|
}
|
return MD5(st).toStr();
|
}
|
|
DXJLResult THSDXJLCapture::capture()
|
{
|
HWND hwnd = THSActionUtil::getDXJLWindow();
|
if (hwnd <= 0) {
|
throw string("ÉÐδ»ñÈ¡µ½¶ÌÏß¾«Áé´°¿Ú");
|
}
|
|
return capture(hwnd);
|
}
|
|
DXJLResult THSDXJLCapture::capture(HWND hwnd)
|
{
|
cv::Mat img = CaptureUtil::capture(hwnd);
|
|
return capture(img, openCLExcuter);
|
}
|
|
void THSDXJLCapture::init(CallbackFun_DXJL_OCR matOcrFun)
|
{
|
ocr_fun = matOcrFun;
|
openCLExcuter = new OpenCLExcuter();
|
openCLExcuter->init();
|
thread rt(&(_run));
|
rt.detach();
|
inited = TRUE;
|
}
|
|
bool THSDXJLCapture::is_inited()
|
{
|
return inited;
|
}
|
|
void THSDXJLCapture::start()
|
{
|
running = TRUE;
|
}
|
|
void THSDXJLCapture::stop()
|
{
|
running = FALSE;
|
}
|
|
bool THSDXJLCapture::is_running()
|
{
|
return running;
|
}
|
|
DXJLResult THSDXJLCapture::capture(cv::Mat img, OpenCLExcuter* openCLExcuter)
|
{
|
cv::Mat grayImg = OpenCLUtil::grayImg(openCLExcuter, img);
|
std::list<DXJLOCRContent> contentList = captureGray(grayImg, openCLExcuter);
|
for (std::list<DXJLOCRContent>::iterator ele = contentList.begin(); ele != contentList.end(); ele++) {
|
cv::Rect rect = (*ele).codeNamePos;
|
string md5 = md5Mat(cv::Mat(grayImg,rect));
|
(*ele).codeNameMD5 = md5;
|
//ImgUtil::markMat(grayImg, rect, 255, 1);
|
}
|
//¹¹Ôìʶ±ðͼÐÎ
|
//cv::imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\dxjl\\mark1.png",grayImg);
|
return DXJLResult({ contentList ,grayImg });
|
}
|
|
std::list<DXJLOCRContent> THSDXJLCapture::captureGray(cv::Mat grayImg, OpenCLExcuter* openCLExcuter)
|
{
|
|
std::list<int*> rowDataList = split(grayImg);
|
|
int* rowDataOneLevel = (int*)malloc(sizeof(int) * rowDataList.size() * 4);
|
int index = 0;
|
for (list<int*>::iterator e = rowDataList.begin(); e != rowDataList.end(); e++) {
|
int* indexs = *e;
|
rowDataOneLevel[index * 4 + 0] = indexs[0];
|
rowDataOneLevel[index * 4 + 1] = indexs[1];
|
rowDataOneLevel[index * 4 + 2] = indexs[2];
|
rowDataOneLevel[index * 4 + 3] = indexs[3];
|
index++;
|
free(indexs);
|
}
|
//·Ö¸ôÔªËØ
|
int line_ele_count = 4;
|
int* rowSplitResultDataOneLevel = (int*)malloc(sizeof(int) * rowDataList.size() * 4 * line_ele_count);
|
std::list<cv::Rect> timeRectList;
|
std::list<DXJLOCRContent> contentList;
|
try {
|
openCLExcuter->splitRowData(grayImg, rowDataOneLevel, rowDataList.size(), line_ele_count, rowSplitResultDataOneLevel);
|
free(rowDataOneLevel);
|
|
//Êý¾ÝÊÕ¼¯
|
for (int i = 0; i < rowDataList.size(); i++) {
|
|
DXJLOCRContent content;
|
|
for (int p = 0; p < line_ele_count; p++)
|
{
|
int start_index = i * line_ele_count * 4 + p * 4;
|
int start_x = rowSplitResultDataOneLevel[start_index + 0];
|
int start_y = rowSplitResultDataOneLevel[start_index + 1];
|
int end_x = rowSplitResultDataOneLevel[start_index + 2];
|
int end_y = rowSplitResultDataOneLevel[start_index + 3];
|
|
cv::Rect rect = cv::Rect(start_x, start_y, end_x - start_x + 1, end_y - start_y + 1);
|
//ImgUtil::markMat(grayImg, rect, 255, 1);
|
switch (p)
|
{
|
case 0:
|
timeRectList.push_back(rect);
|
break;
|
case 1:
|
{
|
content.codeNamePos = rect;
|
}
|
break;
|
case 2:
|
content.eventNamePos = rect;
|
break;
|
case 3:
|
content.eventParamsPos = rect;
|
break;
|
default:
|
break;
|
}
|
}
|
contentList.push_back(content);
|
}
|
|
free(rowSplitResultDataOneLevel);
|
}
|
catch (string st) {
|
cout << "³ö´í£º" << st << endl;
|
}
|
|
catch (...) {
|
grayImg.release();
|
grayImg = NULL;
|
free(rowDataOneLevel);
|
free(rowSplitResultDataOneLevel);
|
throw string("ͼÏñϸ·Ö³ö´í");
|
}
|
|
//±£´æ·Ö¸ôÄÚÈÝ
|
//cv::imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\dxjl\\mark1.png",grayImg);
|
|
//------------ʱ¼äʶ±ð--------------
|
//ÿÐеÄÔªËظöÊý
|
int ele_count_per_line = 1;
|
int num_length_per_ele = 6;
|
int lines = timeRectList.size();
|
int* rowIndex = (int*)malloc(sizeof(int) * 4 * lines * ele_count_per_line);
|
int count = 0;
|
for (std::list<cv::Rect>::iterator ele = timeRectList.begin(); ele != timeRectList.end(); ele++) {
|
cv::Rect rect = *ele;
|
rowIndex[4 * count + 0] = rect.x;
|
rowIndex[4 * count + 1] = rect.y;
|
rowIndex[4 * count + 2] = rect.x + rect.width - 1;
|
rowIndex[4 * count + 3] = rect.y + rect.height - 1;
|
count++;
|
}
|
|
int line_number_count = ele_count_per_line * num_length_per_ele;
|
|
//·Ö¸îÊý×Ö
|
unsigned char* zeroData = (unsigned char*)malloc(sizeof(unsigned char) * _NUMBER_L2_WIDTH * _NUMBER_L2_HEIGHT);
|
for (int r = 0; r < _NUMBER_L2_HEIGHT; r++) {
|
for (int c = 0; c < _NUMBER_L2_WIDTH; c++)
|
{
|
zeroData[r * _NUMBER_L2_WIDTH + c] = ImgUtil::NUMS_LEVEL2[0].data.ptr<uchar>(r)[c];
|
}
|
}
|
unsigned char* totalNumberData = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * lines) * _NUMBER_L2_WIDTH * 10 * line_number_count);
|
unsigned char types[] = { NUM_TYPE_TIME };
|
UcharDataInfo typesData = UcharDataInfo();
|
typesData.length = 1;
|
typesData.data = types;
|
|
openCLExcuter->splitL2NumNew(grayImg, IntDataInfo({ rowIndex,(int)(ele_count_per_line * lines) }), UcharDataInfo({ totalNumberData, -1 }), typesData, zeroData, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, ele_count_per_line, num_length_per_ele);
|
free(rowIndex);
|
|
//ʶ±ðÊý×Ö
|
uchar* templateNums = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * lines) * _NUMBER_L2_WIDTH * 10 * line_number_count);
|
openCLExcuter->createNumberTemplates(lines, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, line_number_count, ImgUtil::numsOneLevel_level2, templateNums);
|
uchar** numberResult = openCLExcuter->recognition_numbers(totalNumberData, templateNums, lines * _NUMBER_L2_HEIGHT, _NUMBER_L2_WIDTH * 10 * line_number_count, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, line_number_count);
|
free(totalNumberData);
|
free(templateNums);
|
|
index = 0;
|
for (std::list<DXJLOCRContent>::iterator ele = contentList.begin(); ele != contentList.end(); ele++) {
|
DXJLOCRContent content = *ele;
|
string time = "";
|
for (int j = 0; j < num_length_per_ele; j++)
|
{
|
if (j == 2 || j == 4) {
|
time.append(":");
|
}
|
time.append(to_string(numberResult[index][j]));
|
}
|
free(numberResult[index]);
|
(*ele).time = time;
|
index++;
|
|
if (time == "00:00:00") {
|
cout << "´íÎóʶ±ð£º" << index << endl;
|
}
|
}
|
free(numberResult);
|
cout << "×ÜÊý£º" << contentList.size() << endl;
|
return contentList;
|
}
|
