#include "L2DataCapture.h"
#include <thread>
#include<fstream>
#include "THSActionUtil.h"
#include <thread>
#include "TaskChecker.h"
#include "GPUtil.h"
#include "LogUtil.h"
#include "L2TradeQueueUtil.h"
#include "Win32Util.h"

//#define malloc(size) malloc(size)
//#define free(ptr) free(ptr)

bool L2DataCapture::inited;
bool L2DataCapture::tradeTimeCapture;

OpenCLExcuter* L2DataCapture::openCLExcuter[THS_FRAME_COUNT];
OpenCLExcuter* L2DataCapture::openCLExcuterQueue[THS_FRAME_COUNT];

TradeQueueCapture* L2DataCapture::tradeQueueCapture[THS_FRAME_COUNT];


//ÊÇ·ñÕýÔÚÖ´ÐÐ
bool L2DataCapture::running;
bool L2DataCapture::runnings[THS_FRAME_COUNT];
bool L2DataCapture::killRunnings[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;

//ÔËÐÐ
void L2DataCapture::_run(int index)
{
	while (true) {
		
		
		clock_t origin_start_time = clock();
		if (killRunnings[index])
			break;
		TaskChecker::clientLiveTime.l2[index] = clock();
		if (tradeTimeCapture) {
			if (!GPUtil::isTradeTime()) {
				Sleep(2);
				continue;
			}
		}

		if (GPUtil::isBeforeTradeTime()) {
			Sleep(1000);
		}

		if (running && runnings[index] && gpCodes[index].length() > 0) {
			if (index == 0) {
				cout << "-----------------------¿ªÊ¼--------------------  " << endl;
			}
			latest_running_times[index] = clock();
			//ʶ±ðÊý¾Ý
			string code = gpCodes[index];
			try {
				clock_t start = clock();
				cv::Mat mat = CaptureUtil::capture(index, CAPTURE_TYPE_L2);
				if (mat.cols <= 400 || mat.rows <= 1600) {
					mat.release();
					mat = NULL;
					Sleep(100);
					throw string("½Øͼ³ö´í");
				}
				if (index == 0)
				{
					cout << "-----------½Øͼʱ¼äÏûºÄ£º---------  " << index << "  " << clock() - start << endl;
				}

				start = clock();
				list<TradeData*> resultList = captureLevel2TradeData(mat, index);
				if (index == 0)
				{
					cout << "-----------ʶ±ðʱ¼äÏûºÄ:---------- " << index <<" ÊýÁ¿£º"<< resultList.size() << "  " << clock() - start << endl;
				}
				long processTime = clock() - origin_start_time;
				start = clock();
				data_callback(index, code, start, processTime, resultList, context);
				if (index == 0)
				{
					cout << "------------Êý¾Ý»Øµ÷ʱ¼äÏûºÄ£º-----------" << clock() - start << endl;
				}
			}
			catch (string st) {
				//delete (openCLExcuter[index]);
				//openCLExcuter[index] = new OpenCLExcuter();
				//openCLExcuter[index]->init();
				LogUtil::getInstance()->getL2Logger().error(string("ʶ±ð³ö´í£º").append(st));
			}
			catch (int error_code) {
				LogUtil::getInstance()->getL2Logger().error(string("ʶ±ð³ö´í£ºcode-").append(to_string(error_code)));
			}
			catch (exception& e) {
				LogUtil::getInstance()->getL2Logger().error(string("ʶ±ð³ö´í£º").append(e.what()));
			}
			catch (...) {
				LogUtil::getInstance()->getL2Logger().error(string("ʶ±ð³ö´í£º").append("δ֪´íÎó"));
			}
		}
		Sleep(2);
		if (index == 0)
		{
			cout << "-----------Õû¸öL2ÖÜÆÚʱ¼äÏûºÄʱ¼äÏûºÄ£º-------------  " << index << "  " << clock() - origin_start_time << endl;
		}
		if (index == 0)
		{
			cout << "-----------------------½áÊø-------------------- \n\n " << endl;
		}
	}
}


void L2DataCapture::_run_trade_queue(int index)
{
	while (true) {
		if (killRunnings[index])
			break;
		TaskChecker::clientLiveTime.l2[index] = clock();
		if (tradeTimeCapture) {
			if (!GPUtil::isTradeTime()) {
				Sleep(2);
				continue;
			}
		}

		if (GPUtil::isBeforeTradeTime()) {
			Sleep(1000);
		}

		if (running && runnings[index] && gpCodes[index].length() > 0) {
			//ʶ±ðÊý¾Ý
			string code = gpCodes[index];
			try {
				clock_t start = clock();
				HWND queueHWND = CaptureUtil::getHWND(index, CAPTURE_TYPE_TRADE_QUEUE);
				L2TradeQueue result = captureLevel2TradeQueueData(queueHWND, index);
				long processTime = clock() - start;
				//cout << "ʱ¼äÏûºÄ£º" << processTime << endl;
				trade_queue_data_callback(index, code, result, context);
			}
			catch (...) {

			}
		}
		Sleep(600);
	}
}

std::list<string> L2DataCapture::captureLevel2TradeQueueBuyData(OpenCLExcuter* openCLExcuter, cv::Mat& grayImg, int identify)
{
	if (grayImg.cols == 0 || grayImg.rows == 0) {
		return list<string>();
	}
	cv::Mat img;
	try {
		list<ImgArea> splitAreas = L2TradeQueueUtil::splitBuyQueue(grayImg, identify);
		int* splitResult = (int*)malloc(sizeof(int) * 4 * splitAreas.size());
		int index = 0;
		for (list<ImgArea>::iterator ele = splitAreas.begin(); ele != splitAreas.end(); ++ele) {
			ImgArea area = *ele;
			splitResult[index * 4 + 0] = area.startx;
			splitResult[index * 4 + 1] = area.starty;
			splitResult[index * 4 + 2] = area.endx;
			splitResult[index * 4 + 3] = area.endy;

			index++;
		}


		//¶þÖµ»¯£¬·½±ã´¦Àí
		threshold(grayImg, img, _IMG_BINARY_THRESHOLD, 255, cv::THRESH_BINARY);



		clock_t time_2 = clock();
		unsigned char* zeroData = (unsigned char*)malloc(sizeof(unsigned char) * _NUMBER_GP_CODE_WIDTH * _NUMBER_GP_CODE_HEIGHT);
		for (int r = 0; r < _NUMBER_GP_CODE_HEIGHT; r++) {
			for (int c = 0; c < _NUMBER_GP_CODE_WIDTH; c++)
			{
				zeroData[r * _NUMBER_GP_CODE_WIDTH + c] = ImgUtil::NUMS_GP_CODE[0].data.ptr<uchar>(r)[c];
			}
		}
		int num_length_per_ele = 5;
		//splitAreasQueue×î¶à12¸öÊý×Ö
		int ele_count_per_line = splitAreas.size();
		int line_number_count = ele_count_per_line * num_length_per_ele;
		unsigned char* totalNumberData = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_GP_CODE_HEIGHT * 1) * _NUMBER_GP_CODE_WIDTH * 10 * line_number_count);
		unsigned char types[24];
		for (int i = 0; i < 24; i++) {
			types[i] = NUM_TYPE_NUM;
		}
		UcharDataInfo typesData = UcharDataInfo();
		typesData.length = ele_count_per_line;
		typesData.data = types;

		openCLExcuter->splitPlateNum(img, IntDataInfo({ splitResult,(int)(ele_count_per_line * 1) }), UcharDataInfo({ totalNumberData, -1 }), typesData, zeroData, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, ele_count_per_line, num_length_per_ele);
		free(splitResult);
		free(zeroData);

		//ʶ±ð
		uchar* templateNums = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_GP_CODE_HEIGHT * 1) * _NUMBER_GP_CODE_WIDTH * 10 * line_number_count);
		try {
			openCLExcuter->createNumberTemplates(1, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, line_number_count, ImgUtil::numsOneLevel_gpcode, templateNums);
		}
		catch (...) {
			free(totalNumberData);
			free(templateNums);
			throw string("´´½¨Êý¾ÝÄ£°å³ö´í");
		}


		uchar** numberResult = nullptr;
		//Êý×Öʶ±ð
		try {
			numberResult = openCLExcuter->recognition_numbers(totalNumberData, templateNums, 1 * _NUMBER_GP_CODE_HEIGHT, _NUMBER_GP_CODE_WIDTH * 10 * line_number_count, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, line_number_count);
			//ÊÍ·ÅÄÚ´æ
			free(totalNumberData);
			free(templateNums);
		}
		catch (...) {
			//ÊÍ·ÅÄÚ´æ
			free(totalNumberData);
			free(templateNums);
			throw string("Êý×Öʶ±ð³ö´í");
		}

		img.release();

		//Ñ­»·¶ÁÈ¡Êý×Ö
		uchar* lineData = numberResult[0];
		list<string> buyQueueList;
		for (int i = 0; i < ele_count_per_line; i++) {
			string num = "";
			for (int j = 0; j < num_length_per_ele; j++) {
				num.append(to_string(lineData[num_length_per_ele * i + j]));
			}
			buyQueueList.push_back(num);
		}

		//ÊÍ·ÅÄÚ´æ
		free(lineData);
		index++;
		free(numberResult);
		return buyQueueList;
	}
	catch (...) {
		img.release();
		img = NULL;
		throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
	}
}

cv::Mat L2DataCapture::grayImg(OpenCLExcuter* openCLExcuter, cv::Mat& oimg)
{
	cv::Mat img = cv::Mat::zeros(oimg.rows, oimg.cols, CV_8UC1);

	if (oimg.channels() == 1) {
		//ºÚ°×ͼƬ
		img.data = oimg.data;
	}
	else {
		try {
			if (oimg.channels() == 3)
			{
				openCLExcuter->rgb2Gray(oimg, img.data);
			}
			else {
				openCLExcuter->rgba2Gray(oimg, img.data);
			}
			oimg.release();
		}
		catch (...) {
			oimg.release();
			oimg = NULL;
			img.release();
			img = NULL;
			throw string("»Ò¶È³ö´í");
		}
	}

	return img;
}

void L2DataCapture::setGPCode(int index, string code) {
	if (THS_FRAME_COUNT <= index) {
		return;
	}
	gpCodes[index] = code;
}

string L2DataCapture::getGPCode(int index) {
	return	gpCodes[index];
}

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();
		openCLExcuterQueue[i] = new OpenCLExcuter();
		openCLExcuterQueue[i]->init();

		tradeQueueCapture[i] = new TradeQueueCapture();
	}

	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();
		killRunnings[i] = FALSE;
		thread rt_trade_queue(&(L2DataCapture::_run_trade_queue), i);
		rt_trade_queue.detach();
	}

	//»ñȡͬ»¨Ë³´°¿Ú¾ä±ú
	try {
		refreshHWND();
	}
	catch (string st) {
		throw st;
	}

}

void L2DataCapture::reCreateChannelRunner(int index)
{
	//ÏÈɱËÀÔ­ÓÐÏß³Ì
	killRunnings[index] = TRUE;
	Sleep(500);
	killRunnings[index] = FALSE;

	thread rt(&(L2DataCapture::_run), index);
	rt.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();

	list<TradeData*> resultList = captureLevel2TradeData(openCLExcuter[identify], oimg, identify);

	//std::cout << "-------L2ÐÐÇéʶ±ð½áÊøÈÎÎñ: threadid-" << std::this_thread::get_id() << "  ÐòºÅ£º" << identify << " CODE£º" << gpCodes[identify] << " ºÄʱ£º" << clock() - starttime << "  Êý¾ÝÁ¿£º" << resultList.size() << endl;

	return resultList;
}


list<TradeData*> L2DataCapture::captureLevel2TradeData(OpenCLExcuter* openCLExcuter, cv::Mat& oimg, int identify)
{
	bool ENABLE_LOG = FALSE;

	if (oimg.cols <= 0 || oimg.rows <= 0) {
		throw string("ͼÏñÊý¾Ý´íÎó");
	}

	//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);

	//
	if (oimg.channels() == 1) {
		//ºÚ°×ͼƬ
		img.data = oimg.data;
	}
	else {
		try {
			if (oimg.channels() == 3)
			{
				openCLExcuter->rgb2Gray(oimg, img.data);
			}
			else {
				openCLExcuter->rgba2Gray(oimg, img.data);
			}
			oimg.release();
		}
		catch (...) {
			oimg.release();
			oimg = NULL;
			img.release();
			img = NULL;
			throw string("»Ò¶È³ö´í");
		}
		//img.data = imgData;
		clock_t time_2_ = clock();
		if (identify == 0&& ENABLE_LOG)
		{
			std::cout << "»Ò¶ÈÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << (time_2_ - time_1) << "   ½Øͼ³ß´ç£º" << img.cols << "x" << img.rows << endl;

			std::cout << "ͨµÀÊý£º" << oimg.channels() << endl;

			LogUtil::debug("»Ò¶ÈÍê³É");
		}
	}

	clock_t time_2 = clock();

	int ele_count_per_line = 7;



	//ͼÏñ·Ö¸î---¿ªÊ¼
	list<int*>  rowDataList;
	try {
		rowDataList = ImgUtil::divideImg(img);
		if (rowDataList.size() == 0) {
			throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
		}
	}
	catch (...) {
		img.release();
		img = NULL;
		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 * ele_count_per_line);
	try {
		openCLExcuter->splitL2RowData(img, rowDataOneLevel, rowDataList.size(), rowSplitDataOneLevel);
		free(rowDataOneLevel);
	}
	catch (...) {
		img.release();
		img = NULL;
		free(rowDataOneLevel);
		free(rowSplitDataOneLevel);
		throw string("ͼƬ·Ö¸ô³ö´í");
	}


	/*
	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 (false) {
			int start = 4 * ele_count_per_line * (138);
			start += 4 * (1);
			int startx = 385;//rowSplitDataOneLevel[start];
			int starty = 1071;//rowSplitDataOneLevel[start + 1];
			int endx = 389;//rowSplitDataOneLevel[start + 2];
			int endy = 1078;//rowSplitDataOneLevel[start + 3];
			cv::imwrite(string("C:\\Users\\Administrator\\Desktop\\ocr\\l2·ÖÎö\\test.png"), cv::Mat(img, cv::Rect(startx, starty, endx - startx + 1, endy - starty + 1)));
	}
	




	clock_t time_3 = clock();
	//LogUtil::debug("·Ö¸ôÍê³É");
	if (identify == 0 && ENABLE_LOG)
		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 = new TradeData;
		resultList.push_back(td);
	}

	//------·ÇÊý×Öʶ±ð¿ªÊ¼-------
	//ͼÏñʶ±ð(³ý¿ªÊý×ֵIJ¿·Ö)

	int* notNumberResult = (int*)malloc(sizeof(int) * rowDataList.size() * 3);
	openCLExcuter->recognitionNotNum(img.data, img.cols, img.rows, rowSplitDataOneLevel, ele_count_per_line, 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 && ENABLE_LOG)
		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 && ENABLE_LOG)
		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 * ele_count_per_line;


		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++;
	}

	free(rowSplitDataOneLevel);


	clock_t time_32 = clock();
	if (identify == 0 && ENABLE_LOG)
		std::cout << "Êý¾Ý×¼±¸-λÖÃÊý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_32 - time_31 << "×ܺÄʱ£º" << time_32 - time_1 << endl;

	// TODO ±ä³ÉÈ«¾Ö
	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 && ENABLE_LOG)
		std::cout << "Êý¾Ý×¼±¸-0Êý¾Ý×¼±¸: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_33 - time_32 << "×ܺÄʱ£º" << time_33 - time_1 << endl;
	try {
		openCLExcuter->splitL2Num(img.data, img.cols, img.rows, pos, 4 * rowDataList.size(), zeroData, _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER, totalNumberData);
		free(zeroData);
		free(pos);
	}
	catch (...) {
		free(zeroData);
		free(pos);
		free(totalNumberData);
		throw string("splitL2Num³ö´í");
	}

	//²âÊÔ£¬Õ¹Ê¾Í¼Ïñ
	//cv::Mat imgTest = cv::Mat::zeros(_NUMBER_L2_HEIGHT * rowDataList.size(), _NUMBER_L2_WIDTH * 10 * _NUMBER_L2_TOTAL_NUMBER, CV_8UC1);
	//imgTest.data = totalNumberData;
	//cv::imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\l2·ÖÎö\\test1.png", imgTest);




	/*
	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 && ENABLE_LOG)
		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);
	try {
		openCLExcuter->createNumberTemplates(rowDataList.size(), _NUMBER_L2_WIDTH, _NUMBER_L2_HEIGHT, _NUMBER_L2_TOTAL_NUMBER, ImgUtil::numsOneLevel_level2, templateNums);
	}
	catch (...) {
		free(totalNumberData);
		free(templateNums);
		throw string("´´½¨Êý¾ÝÄ£°å³ö´í");
	}

	//ImgUtil::createTemplateNumData(data.size());
	clock_t time_4 = clock();
	if (identify == 0 && ENABLE_LOG)
		std::cout << "Êý¾Ý×¼±¸-Ä£°åÊý×Ö×¼±¸Íê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_4 - time_34 << "×ܺÄʱ£º" << time_4 - time_1 << endl;


	if (identify == 0 && ENABLE_LOG)
		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 = nullptr;
	//Êý×Öʶ±ð
	try {
		numberResult = openCLExcuter->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);
	}
	catch (...) {
		//ÊÍ·ÅÄÚ´æ
		free(totalNumberData);
		free(templateNums);
		throw string("Êý×Öʶ±ð³ö´í");
	}

	//Ñ­»·¶ÁÈ¡Êý×Ö
	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 && ENABLE_LOG)
		std::cout << "Êý×Öʶ±ðÍê³É: threadid-" << std::this_thread::get_id() << " ºÄʱ£º" << time_6 - time_5 << "×ܺÄʱ£º" << time_6 - time_1 << endl;

	//ÊÍ·ÅÄÚ´æ
	img.release();
	rowDataList.clear();
	list<int*>().swap(rowDataList);

	return resultList;
}

L2TradeQueue L2DataCapture::captureLevel2TradeQueueData(HWND hwnd, int index)
{
	HWND buyQueueHWND = L2TradeQueueUtil::getTradeQueueBuyHWND(hwnd);
	//»ñȡλÖÃ
	RECT prect;
	Win32Util::getWindowRect(hwnd, &prect);
	RECT buyRect;
	Win32Util::getWindowRect(buyQueueHWND, &buyRect);
	cv::Mat mat = CaptureUtil::capture(hwnd);
	if (mat.cols <= 400 || mat.rows <= 30) {
		mat.release();
		mat = NULL;
		Sleep(100);
		throw string("½Øͼ³ö´í");
	}
	cv::Rect rect = cv::Rect(buyRect.left - prect.left, buyRect.top - prect.top, buyRect.right - buyRect.left + 1, buyRect.bottom - buyRect.top + 1);
	return captureLevel2TradeQueueData(mat, rect, index);
}

L2TradeQueue L2DataCapture::captureLevel2TradeQueueData(cv::Mat& oimg, cv::Rect buyQueueArea, int identify)
{
	return captureLevel2TradeQueueData(openCLExcuterQueue[identify], oimg, buyQueueArea, identify);
}

L2TradeQueue L2DataCapture::captureLevel2TradeQueueData(OpenCLExcuter* openCLExcuter, cv::Mat& oimg, cv::Rect buyQueueArea, int identify)
{
	cv::Mat img = grayImg(openCLExcuter, oimg);
	cv::Mat tmpImg = cv::Mat(img, buyQueueArea);
	cv::Mat	buyQueueImg = cv::Mat::zeros(buyQueueArea.height, buyQueueArea.width, CV_8UC1);
	uchar* datas = (uchar*)malloc(sizeof(uchar)* buyQueueArea.height* buyQueueArea.width);
	for (int r = 0; r < buyQueueImg.rows; r++) {
		for (int c = 0; c < buyQueueImg.cols; c++) {
			datas[r * buyQueueImg.cols + c] = tmpImg.ptr<uchar>(r)[c];
		}
	}
	buyQueueImg.data = datas;

	//¹ýÂ˻Ƶװ××Ö
	L2TradeQueueUtil::filterTradeQueueBuyMat(buyQueueImg);
	if (FALSE)
	{
		string path = string("C:\\Users\\Administrator\\Desktop\\ocr\\trade_queue\\origin\\").append(to_string(identify)).append("_").append(to_string(rand()).append(".png"));
		cv::imwrite(path, buyQueueImg);
	}
	L2TradeQueue tradeQueue = captureLevel2TradeQueueViewData(openCLExcuter, img, identify);
	try {
		std::list<string> buyQueueList = captureLevel2TradeQueueBuyData(openCLExcuter, buyQueueImg, identify);
		tradeQueue.buyQueue = buyQueueList;
	}
	catch (...) {
	
	}
	free(datas);
	return tradeQueue;
}

L2TradeQueue L2DataCapture::captureLevel2TradeQueueViewData(OpenCLExcuter* openCLExcuter, cv::Mat& img, int identify)
{
	L2TradeQueue tradeQueue;
	try {
		list<ImgArea> splitAreas = L2TradeQueueUtil::splitViewElements(img);
		int* splitResult = (int*)malloc(sizeof(int) * 4 * splitAreas.size());
		int index = 0;
		for (list<ImgArea>::iterator ele = splitAreas.begin(); ele != splitAreas.end(); ++ele) {
			ImgArea area = *ele;
			if (area.startx < 0) {
				splitResult[index * 4 + 0] = 0;
				splitResult[index * 4 + 1] = 0;
				splitResult[index * 4 + 2] = 0;
				splitResult[index * 4 + 3] = 0;
			}
			else {
				splitResult[index * 4 + 0] = area.startx;
				splitResult[index * 4 + 1] = area.starty;
				splitResult[index * 4 + 2] = area.endx;
				splitResult[index * 4 + 3] = area.endy;
			}
			index++;
		}



		clock_t time_2 = clock();
		unsigned char* zeroData = (unsigned char*)malloc(sizeof(unsigned char) * _NUMBER_GP_CODE_WIDTH * _NUMBER_GP_CODE_HEIGHT);
		for (int r = 0; r < _NUMBER_GP_CODE_HEIGHT; r++) {
			for (int c = 0; c < _NUMBER_GP_CODE_WIDTH; c++)
			{
				zeroData[r * _NUMBER_GP_CODE_WIDTH + c] = ImgUtil::NUMS_GP_CODE[0].data.ptr<uchar>(r)[c];
			}
		}
		int num_length_per_ele = 7;
		//splitAreasQueue×î¶à8¸öÊý×Ö
		int ele_count_per_line = 6;
		int line_number_count = ele_count_per_line * num_length_per_ele;
		unsigned char* totalNumberData = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_GP_CODE_HEIGHT * 1) * _NUMBER_GP_CODE_WIDTH * 10 * line_number_count);
		unsigned char types[] = { NUM_TYPE_TIME,NUM_TYPE_TIME,NUM_TYPE_PRICE, NUM_TYPE_NUM_SHOU,NUM_TYPE_PRICE, NUM_TYPE_NUM_SHOU,NUM_TYPE_NUM,NUM_TYPE_NUM };
		UcharDataInfo typesData = UcharDataInfo();
		typesData.length = ele_count_per_line;
		typesData.data = types;

		openCLExcuter->splitPlateNum(img, IntDataInfo({ splitResult,(int)(ele_count_per_line * 1) }), UcharDataInfo({ totalNumberData, -1 }), typesData, zeroData, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, ele_count_per_line, num_length_per_ele);
		free(splitResult);
		free(zeroData);

		//ʶ±ð
		uchar* templateNums = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_GP_CODE_HEIGHT * 1) * _NUMBER_GP_CODE_WIDTH * 10 * line_number_count);
		try {
			openCLExcuter->createNumberTemplates(1, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, line_number_count, ImgUtil::numsOneLevel_gpcode, templateNums);
		}
		catch (...) {
			free(totalNumberData);
			free(templateNums);
			throw string("´´½¨Êý¾ÝÄ£°å³ö´í");
		}


		uchar** numberResult = nullptr;
		//Êý×Öʶ±ð
		try {
			numberResult = openCLExcuter->recognition_numbers(totalNumberData, templateNums, 1 * _NUMBER_GP_CODE_HEIGHT, _NUMBER_GP_CODE_WIDTH * 10 * line_number_count, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, line_number_count);
			//ÊÍ·ÅÄÚ´æ
			free(totalNumberData);
			free(templateNums);
		}
		catch (...) {
			//ÊÍ·ÅÄÚ´æ
			free(totalNumberData);
			free(templateNums);
			throw string("Êý×Öʶ±ð³ö´í");
		}

		img.release();

		//Ñ­»·¶ÁÈ¡Êý×Ö
		uchar* lineData = numberResult[0];
		string sellOneTime = "";
		sellOneTime.append(to_string(lineData[1])).append(to_string(lineData[2]));
		sellOneTime.append(":");
		sellOneTime.append(to_string(lineData[3])).append(to_string(lineData[4]));
		sellOneTime.append(":");
		sellOneTime.append(to_string(lineData[5])).append(to_string(lineData[6]));

		string buyOneTime = "";
		buyOneTime.append(to_string(lineData[num_length_per_ele * 1 + 1])).append(to_string(lineData[num_length_per_ele * 1 + 2]));
		buyOneTime.append(":");
		buyOneTime.append(to_string(lineData[num_length_per_ele * 1 + 3])).append(to_string(lineData[num_length_per_ele * 1 + 4]));
		buyOneTime.append(":");
		buyOneTime.append(to_string(lineData[num_length_per_ele * 1 + 5])).append(to_string(lineData[num_length_per_ele * 1 + 6]));


		string sellOnePrice = "";
		for (int i = 0; i < num_length_per_ele; i++)
		{
			sellOnePrice.append(to_string(lineData[num_length_per_ele * 2 + i]));
			if (i == num_length_per_ele - 3) {
				sellOnePrice.append(".");
			}
		}

		string sellOneNum = "";
		for (int i = 0; i < num_length_per_ele; i++)
		{
			sellOneNum.append(to_string(lineData[num_length_per_ele * 3 + i]));
		}

		string buyOnePrice = "";
		for (int i = 0; i < num_length_per_ele; i++)
		{
			buyOnePrice.append(to_string(lineData[num_length_per_ele * 4 + i]));
			if (i == num_length_per_ele - 3) {
				buyOnePrice.append(".");
			}
		}

		string buyOneNum = "";
		for (int i = 0; i < num_length_per_ele; i++)
		{
			buyOneNum.append(to_string(lineData[num_length_per_ele * 5 + i]));
		}

		//ÊÍ·ÅÄÚ´æ
		free(lineData);
		index++;
		free(numberResult);


		tradeQueue = L2TradeQueue();
		tradeQueue.buyOnePrice = buyOnePrice;
		tradeQueue.buyOneVolumn = buyOneNum;
		tradeQueue.buyTime = buyOneTime;
		tradeQueue.sellOnePrice = sellOnePrice;
		tradeQueue.sellOneVolumn = sellOneNum;
		tradeQueue.sellTime = sellOneTime;
		return tradeQueue;
	}
	catch (...) {
		img.release();
		img = NULL;
		throw int(ERROR_CODE_DIVIDE_IMG_FAIL);
	}
}

//²¶»ñ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;
}