#include "L2DataCapture.h"
|
#include <thread>
|
#include<fstream>
|
#include "THSActionUtil.h"
|
#include <thread>
|
bool L2DataCapture::inited;
|
bool L2DataCapture::tradeTimeCapture;
|
|
OpenCLExcuter* L2DataCapture::openCLExcuter[THS_FRAME_COUNT];
|
TradeQueueCapture* L2DataCapture::tradeQueueCapture[THS_FRAME_COUNT];
|
|
|
//ÊÇ·ñÕýÔÚÖ´ÐÐ
|
bool L2DataCapture::running;
|
bool L2DataCapture::runnings[THS_FRAME_COUNT];
|
clock_t L2DataCapture::latest_running_times[THS_FRAME_COUNT];
|
|
CallbackFun L2DataCapture::data_callback;
|
|
CallbackFun_Trade_Queue L2DataCapture::trade_queue_data_callback;
|
|
string L2DataCapture::gpCodes[THS_FRAME_COUNT];
|
|
void* L2DataCapture::context;
|
|
//½«µ±Ç°Ê±¼ä»»Ëã³ÉÃë
|
int getNowSecondTime() {
|
time_t timep;
|
time(&timep);
|
char tmp_h[64];
|
strftime(tmp_h, sizeof(tmp_h), "%H", localtime(&timep));
|
char tmp_m[64];
|
strftime(tmp_m, sizeof(tmp_m), "%M", localtime(&timep));
|
char tmp_s[64];
|
strftime(tmp_s, sizeof(tmp_s), "%S", localtime(&timep));
|
return stoi(string(tmp_h)) * 3600 + stoi(string(tmp_m)) * 60 + stoi(string(tmp_s));
|
}
|
|
//ÔËÐÐ
|
void L2DataCapture::_run(int index)
|
{
|
while (true) {
|
|
if (tradeTimeCapture) {
|
int time = getNowSecondTime();
|
//9:20-11:31 12:59-15:01
|
bool in = false;
|
if ((time >= 9 * 3600 + 20 * 60 && time <= 11 * 3600 + 31 * 60) || (time >= 12 * 3600 + 59 * 60 && time <= 15 * 3600 + 1 * 60)) {
|
in = true;
|
}
|
if (!in) {
|
Sleep(2);
|
continue;
|
}
|
}
|
|
if (running && runnings[index] && gpCodes[index].length() > 0) {
|
latest_running_times[index] = clock();
|
//ʶ±ðÊý¾Ý
|
string code = gpCodes[index];
|
try {
|
list<TradeData> resultList = captureLevel2TradeData(CaptureUtil::capture(index, CAPTURE_TYPE_L2), index);
|
data_callback(index, code, resultList, context);
|
}
|
catch (...) {
|
|
}
|
}
|
Sleep(2);
|
}
|
}
|
|
|
void L2DataCapture::_run_trade_queue(int index)
|
{
|
while (true) {
|
if (running && runnings[index] && gpCodes[index].length() > 0) {
|
//ʶ±ðÊý¾Ý
|
string code = gpCodes[index];
|
try {
|
list<int> numList = tradeQueueCapture[index]->recognition(CaptureUtil::getHWND(index, CAPTURE_TYPE_TRADE_QUEUE));
|
trade_queue_data_callback(index, code, numList, context);
|
}
|
catch (...) {
|
|
}
|
}
|
Sleep(2);
|
}
|
}
|
|
void L2DataCapture::setGPCode(int index, string code) {
|
int length = sizeof(gpCodes) / sizeof(gpCodes[0]);
|
if (length <= index) {
|
return;
|
}
|
|
gpCodes[index] = code;
|
}
|
|
string L2DataCapture::getGPCode(int index) {
|
return gpCodes[index];
|
}
|
|
void L2DataCapture::setTradeTimeCapture(bool enable)
|
{
|
tradeTimeCapture = enable;
|
}
|
|
static string getGPCode(int index);
|
|
L2DataCapture::L2DataCapture() {
|
|
}
|
void L2DataCapture::refreshHWND() {
|
HWND win = THSActionUtil::getL2Win();
|
if (win <= 0) {
|
throw string("δ»ñÈ¡µ½Í¬»¨Ë³LEVEL2ÅÌ¿Ú");
|
}
|
CaptureUtil::init(win);
|
}
|
|
void L2DataCapture::init(CallbackFun callback, CallbackFun_Trade_Queue trade_queue_callback, void* contex) {
|
inited = true;
|
data_callback = callback;
|
trade_queue_data_callback = trade_queue_callback;
|
context = contex;
|
|
|
for (int i = 0;i < THS_FRAME_COUNT;i++)
|
{
|
openCLExcuter[i] = new OpenCLExcuter();
|
openCLExcuter[i]->init();
|
tradeQueueCapture[i] = new TradeQueueCapture();
|
}
|
|
|
|
//»ñȡͬ»¨Ë³´°¿Ú¾ä±ú
|
try {
|
refreshHWND();
|
}
|
catch (string st) {
|
throw st;
|
}
|
running = false;
|
int length = sizeof(runnings) / sizeof(runnings[0]);
|
for (int i = 0;i < length;i++) {
|
runnings[i] = false;
|
thread rt(&(L2DataCapture::_run), i);
|
rt.detach();
|
|
//thread rt_trade_queue(&(L2DataCapture::_run_trade_queue), i);
|
//rt_trade_queue.detach();
|
}
|
|
}
|
|
bool L2DataCapture::isRunning() {
|
return running;
|
}
|
|
void L2DataCapture::start(int index) {
|
runnings[index] = true;
|
}
|
//½áÊø
|
void L2DataCapture::stop(int index) {
|
runnings[index] = false;
|
}
|
//È«²¿¿ªÊ¼
|
void L2DataCapture::start() {
|
running = true;
|
}
|
//È«²¿½áÊø
|
void L2DataCapture::stop() {
|
running = false;
|
}
|
|
void L2DataCapture::startAll() {
|
int length = sizeof(runnings) / sizeof(runnings[0]);
|
for (int i = 0;i < length;i++) {
|
runnings[i] = true;
|
}
|
}
|
|
void L2DataCapture::stopAll() {
|
int length = sizeof(runnings) / sizeof(runnings[0]);
|
for (int i = 0;i < length;i++) {
|
runnings[i] = false;
|
}
|
}
|
|
bool L2DataCapture::isInited() {
|
return inited;
|
}
|
|
list<TradeData> L2DataCapture::captureLevel2TradeData(cv::Mat oimg, int identify) {
|
if (oimg.rows == 0 || oimg.cols == 0) {
|
throw ERROR_CODE_CAPTURE_FAIL;
|
}
|
|
clock_t starttime = clock();
|
|
/*
|
if (1 > 0) {
|
std:map<string, TradeData> map;
|
return map;
|
}
|
*/
|
|
|
//LogUtil::debug("½ØͼÍê³É");
|
clock_t time_1 = clock();
|
//std::cout << "½ØͼÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << (time_1 - starttime) << endl;
|
|
//»Ò¶È»¯
|
cv::Mat img = cv::Mat::zeros(oimg.rows, oimg.cols, CV_8UC1);//ImgUtil::grayImage(oimg);
|
|
uchar* imgData = (uchar*)malloc(sizeof(uchar) * oimg.rows * oimg.cols);
|
//
|
if (oimg.channels() == 1) {
|
//ºÚ°×ͼƬ
|
img.data = oimg.data;
|
}
|
else {
|
if (oimg.channels() == 3)
|
{
|
openCLExcuter[identify]->rgb2Gray(oimg.data, oimg.cols, oimg.rows, imgData);
|
}
|
else {
|
openCLExcuter[identify]->rgba2Gray(oimg.data, oimg.cols, oimg.rows, imgData);
|
}
|
img.data = imgData;
|
oimg.release();
|
clock_t time_2_ = clock();
|
if (identify == 0)
|
{
|
std::cout << "»Ò¶ÈÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << (time_2_ - time_1) << endl;
|
|
std::cout <<"ͨµÀÊý£º"<<oimg.channels()<<endl;
|
|
LogUtil::debug("»Ò¶ÈÍê³É");
|
}
|
}
|
|
clock_t time_2 = clock();
|
|
|
|
//ͼÏñ·Ö¸î---¿ªÊ¼
|
list<int*> rowDataList;
|
try {
|
rowDataList = ImgUtil::divideImg(img);
|
if (rowDataList.size() == 0) {
|
throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
|
}
|
}
|
catch (...) {
|
//ÊÍ·ÅÄÚ´æ
|
free(imgData);
|
throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
|
}
|
//һάÐÐͼÏñÊý¾Ý
|
int* rowDataOneLevel = (int*)malloc(sizeof(int) * rowDataList.size() * 4);
|
list<int*>::iterator e;
|
int index = 0;
|
for (e = rowDataList.begin();e != rowDataList.end();e++) {
|
int* indexs = *e;
|
rowDataOneLevel[index * 4 + 0] = indexs[1];
|
rowDataOneLevel[index * 4 + 1] = indexs[0];
|
rowDataOneLevel[index * 4 + 2] = indexs[3];
|
rowDataOneLevel[index * 4 + 3] = indexs[2];
|
index++;
|
free(indexs);
|
}
|
//һά·Ö¿éͼÏñÊý¾Ý
|
int* rowSplitDataOneLevel = (int*)malloc(sizeof(int) * rowDataList.size() * 4 * 7);
|
openCLExcuter[identify]->splitL2RowData(imgData, img.cols, img.rows, rowDataOneLevel, rowDataList.size(), rowSplitDataOneLevel);
|
free(rowDataOneLevel);
|
|
/*
|
for (int i = 0;i < rowDataList.size();i++) {
|
string path = "C:\\Users\\Administrator\\Desktop\\ocr\\cancel_time\\";
|
path.append(to_string(identify)).append("_").append(to_string(i)).append(".jpg");
|
int start = 4 * 7 * i;
|
start += 4 * (1);
|
int startx = rowSplitDataOneLevel[start];
|
int starty = rowSplitDataOneLevel[start + 1];
|
int endx = rowSplitDataOneLevel[start + 2];
|
int endy = rowSplitDataOneLevel[start + 3];
|
if (startx > 0) {
|
cv::imwrite(path, cv::Mat(img, cv::Rect(startx, starty, endx - startx + 1, endy - starty + 1)));
|
}
|
}
|
*/
|
|
/*
|
//±£´æ·Ö¸ôµÄͼƬ
|
if (true) {
|
int start = 4 * 7 * (558 - 1);
|
start += 4 * (2);
|
int startx= rowSplitDataOneLevel[start];
|
int starty = rowSplitDataOneLevel[start+1];
|
int endx = rowSplitDataOneLevel[start+2];
|
int endy = rowSplitDataOneLevel[start+3];
|
cv::imshow("¼Û¸ñ", cv::Mat(img, cv::Rect(startx, starty, endx - startx + 1, endy - starty + 1)));
|
}
|
*/
|
|
|
|
|
clock_t time_3 = clock();
|
//LogUtil::debug("·Ö¸ôÍê³É");
|
if (identify == 0)
|
std::cout << "·Ö¸ôÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_3 - time_2 << "×ܺÄʱ£º" << time_3 - time_1 << endl;
|
|
//½á¹û³õʼ»¯
|
list<TradeData> resultList;
|
for (int i = 0;i < rowDataList.size();i++) {
|
TradeData td = TradeData();
|
resultList.push_back(td);
|
}
|
|
//------·ÇÊý×Öʶ±ð¿ªÊ¼-------
|
//ͼÏñʶ±ð(³ý¿ªÊý×ֵIJ¿·Ö)
|
|
int* notNumberResult = (int*)malloc(sizeof(int) * rowDataList.size() * 3);
|
openCLExcuter[identify]->recognitionNotNum(img.data, img.cols, img.rows, rowSplitDataOneLevel, 7, rowDataList.size(), notNumberResult);
|
|
|
int i = 0;
|
for (list<TradeData>::iterator ele = resultList.begin();ele != resultList.end();++ele) {
|
switch (notNumberResult[i * 3])
|
{
|
case 0:
|
(*ele).cancelTimeUnit = TIME_SECOND;break;
|
case 1:
|
(*ele).cancelTimeUnit = TIME_MINITE;break;
|
case 2:
|
(*ele).cancelTimeUnit = TIME_HOUR;break;
|
|
default:
|
break;
|
}
|
|
switch (notNumberResult[i * 3 + 1])
|
{
|
case 0:
|
(*ele).limitPrice = LIMIT_PRICE_NORMAL;break;
|
case 1:
|
(*ele).limitPrice = LIMIT_PRICE_UP;break;
|
case 2:
|
(*ele).limitPrice = LIMIT_PRICE_DOWN;break;
|
|
default:
|
break;
|
}
|
switch (notNumberResult[i * 3 + 2])
|
{
|
case OPERATE_BUY:
|
(*ele).operateType = OPERATE_BUY;
|
break;
|
case OPERATE_BUY_CANCEL:
|
(*ele).operateType = OPERATE_BUY_CANCEL;
|
break;
|
case OPERATE_SELL:
|
(*ele).operateType = OPERATE_SELL;
|
break;
|
case OPERATE_SELL_CANCEL:
|
(*ele).operateType = OPERATE_SELL_CANCEL;
|
break;
|
case OPERATE_OPERATE_ERROR:
|
(*ele).operateType = OPERATE_OPERATE_ERROR;
|
break;
|
};
|
|
i++;
|
}
|
|
free(notNumberResult);
|
|
clock_t time_5 = clock();
|
if (identify == 0)
|
std::cout << "·ÇÊý×ÖÊý¾Ýʶ±ðÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_5 - time_3 << "×ܺÄʱ£º" << time_5 - time_1 << endl;
|
|
|
//------·ÇÊý×Öʶ±ð½áÊø-------
|
|
|
|
//------Êý×Öʶ±ð¿ªÊ¼---------
|
|
unsigned char* totalNumberData = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * rowDataList.size()) * _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER);
|
clock_t time_31 = clock();
|
if (identify == 0)
|
std::cout << "Êý¾Ý×¼±¸-ͼÏñÊý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_31 - time_3 << "×ܺÄʱ£º" << time_31 - time_1 << endl;
|
|
int* pos = (int*)malloc(sizeof(int) * 4 * 4 * rowDataList.size());
|
|
|
index = 0;
|
for (e = rowDataList.begin();e != rowDataList.end();e++) {
|
|
int startS = index * 4 * 7;
|
|
|
int start = index * 4 * 4;
|
pos[start] = rowSplitDataOneLevel[startS + 0];
|
pos[start + 1] = rowSplitDataOneLevel[startS + 1];
|
pos[start + 2] = rowSplitDataOneLevel[startS + 2];
|
pos[start + 3] = rowSplitDataOneLevel[startS + 3];
|
|
|
start = index * 4 * 4 + 4 * 1;
|
pos[start] = rowSplitDataOneLevel[startS + 4 * 1 + 0];
|
pos[start + 1] = rowSplitDataOneLevel[startS + 4 * 1 + 1];
|
pos[start + 2] = rowSplitDataOneLevel[startS + 4 * 1 + 2];
|
pos[start + 3] = rowSplitDataOneLevel[startS + 4 * 1 + 3];
|
|
|
start = index * 4 * 4 + 4 * 2;
|
pos[start] = rowSplitDataOneLevel[startS + 4 * 2 + 0];
|
pos[start + 1] = rowSplitDataOneLevel[startS + 4 * 2 + 1];
|
pos[start + 2] = rowSplitDataOneLevel[startS + 4 * 2 + 2];
|
pos[start + 3] = rowSplitDataOneLevel[startS + 4 * 2 + 3];
|
|
|
|
start = index * 4 * 4 + 4 * 3;
|
pos[start] = rowSplitDataOneLevel[startS + 4 * 5 + 0];
|
pos[start + 1] = rowSplitDataOneLevel[startS + 4 * 5 + 1];
|
pos[start + 2] = rowSplitDataOneLevel[startS + 4 * 5 + 2];
|
pos[start + 3] = rowSplitDataOneLevel[startS + 4 * 5 + 3];
|
|
index++;
|
}
|
|
|
clock_t time_32 = clock();
|
if (identify == 0)
|
std::cout << "Êý¾Ý×¼±¸-λÖÃÊý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_32 - time_31 << "×ܺÄʱ£º" << time_32 - time_1 << endl;
|
|
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];
|
}
|
}
|
|
clock_t time_33 = clock();
|
if (identify == 0)
|
std::cout << "Êý¾Ý×¼±¸-0Êý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_33 - time_32 << "×ܺÄʱ£º" << time_33 - time_1 << endl;
|
|
openCLExcuter[identify]->splitL2Num(imgData, img.cols, img.rows, pos, 4 * rowDataList.size(), zeroData, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER, totalNumberData);
|
free(zeroData);
|
free(pos);
|
|
|
|
/*
|
list<list<int*>>::iterator e;
|
int index = 0;
|
for (e = data.begin();e != data.end();e++) {
|
index++;
|
ImgUtil::splitRowNumDataForOpenCL(img, *e, totalNumberData,index-1);
|
}
|
|
*/
|
clock_t time_34 = clock();
|
if (identify == 0)
|
std::cout << "Êý¾Ý×¼±¸-Êý×Ö·Ö¸ôÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_34 - time_33 << "×ܺÄʱ£º" << time_34 - time_1 << endl;
|
|
//×¼±¸Ä£°åÊý×Ö
|
uchar* templateNums = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * rowDataList.size()) * _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER);
|
|
openCLExcuter[identify]->createNumberTemplates(rowDataList.size(), _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER, ImgUtil::numsOneLevel_level2, templateNums);
|
|
//ImgUtil::createTemplateNumData(data.size());
|
clock_t time_4 = clock();
|
if (identify == 0)
|
std::cout << "Êý¾Ý×¼±¸-Ä£°åÊý×Ö×¼±¸Íê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_4 - time_34 << "×ܺÄʱ£º" << time_4 - time_1 << endl;
|
|
|
if (identify == 0)
|
std::cout << "Êý¾Ý×¼±¸Íê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_4 - time_3 << "×ܺÄʱ£º" << time_4 - time_1 << endl;
|
|
|
|
|
/*
|
try {
|
resultList = (*recognitionManager).recognition(img, rowSplitDataOneLevel, rowDataList.size());
|
}
|
catch (...) {
|
throw ERROR_CODE_RECOGNITION_FAIL;
|
}
|
*/
|
|
|
//Êý×Öʶ±ð
|
uchar** numberResult = openCLExcuter[identify]->recognition_numbers(totalNumberData, templateNums, rowDataList.size() * _NUMBER_L2_HEIGHT, _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER);
|
//ÊÍ·ÅÄÚ´æ
|
free(totalNumberData);
|
free(templateNums);
|
//Ñ»·¶ÁÈ¡Êý×Ö
|
list<TradeData>::iterator tradeEle;
|
index = 0;
|
for (tradeEle = resultList.begin();tradeEle != resultList.end();tradeEle++) {
|
uchar* lineData = numberResult[index];
|
string time = "";
|
time.append(to_string(lineData[0])).append(to_string(lineData[1]));
|
time.append(":");
|
time.append(to_string(lineData[2])).append(to_string(lineData[3]));
|
time.append(":");
|
time.append(to_string(lineData[4])).append(to_string(lineData[5]));
|
|
string cancelTime = "";
|
cancelTime.append(to_string(lineData[6])).append(to_string(lineData[7]));
|
|
|
string price = "";
|
price.append(to_string(lineData[6 + 2])).append(to_string(lineData[7 + 2])).append(to_string(lineData[8 + 2])).append(to_string(lineData[9 + 2]));
|
price.append(".");
|
price.append(to_string(lineData[10 + 2])).append(to_string(lineData[11 + 2]));
|
|
string num = "";
|
num.append(to_string(lineData[12 + 2])).append(to_string(lineData[13 + 2])).append(to_string(lineData[14 + 2])).append(to_string(lineData[15 + 2])).append(to_string(lineData[16 + 2]));
|
|
|
(*tradeEle).time = time;
|
(*tradeEle).num = stoi(num);
|
(*tradeEle).price = price;
|
(*tradeEle).index = index;
|
(*tradeEle).cancelTime = stoi(cancelTime);
|
|
//ÊÍ·ÅÄÚ´æ
|
free(lineData);
|
|
index++;
|
}
|
|
free(numberResult);
|
|
clock_t time_6 = clock();
|
//LogUtil::debug("ʶ±ðÍê³É");
|
if (identify == 0)
|
std::cout << "Êý×Öʶ±ðÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_6 - time_5 << "×ܺÄʱ£º" << time_6 - time_1 << endl;
|
|
//ÊÍ·ÅÄÚ´æ
|
//img.release();
|
free(imgData);
|
img.release();
|
rowDataList.clear();
|
list<int*>().swap(rowDataList);
|
free(rowSplitDataOneLevel);
|
|
if (identify == 0)
|
std::cout << "-------L2ÐÐÇéʶ±ð½áÊøÈÎÎñ: threadid-" << std::this_thread::get_id() << " ÐòºÅ£º" << identify << " ºÄʱ£º" << clock() - starttime << endl;
|
|
return resultList;
|
}
|
|
//²¶»ñlevel2µÄÅÌ¿ÚÊý¾Ý
|
list<TradeData> L2DataCapture::captureLevel2TradeData(HWND hwnd, int index) throw(int) {
|
clock_t starttime = clock();
|
cv::Mat img = CaptureUtil::capture(hwnd);
|
|
|
/*
|
string path1 = "E:\\temp\\";
|
|
path1.append(to_string(frameIndex));
|
path1.append("\\");
|
path1.append(to_string(clock()));
|
path1.append(".jpg");
|
cv::imwrite(path1, img);
|
std::map<string, TradeData> map;
|
*/
|
try {
|
list<TradeData> resultList = captureLevel2TradeData(img, index);
|
return resultList;
|
}
|
catch (int code) {
|
|
}
|
list<TradeData> tempList;
|
return tempList;
|
}
|
