#include "L2DataCapture.h"
#include <thread>
#include<fstream>
#include "THSActionUtil.h"
#include <thread>
#include "TaskChecker.h"
#include "GPUtil.h"
#include "LogUtil.h"
#include "L2TradeQueueUtil.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) {
		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) {
			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 <= 1800) {
					mat.release();
					mat = NULL;
					Sleep(100);
					throw string("½Øͼ³ö´í");
				}

				list<TradeData> resultList = captureLevel2TradeData(mat, index);
				long processTime = clock() - start;
				data_callback(index, code, start, processTime, resultList, context);
				cout << "ʱ¼äÏûºÄ£º" << processTime << 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);
	}
}


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();
				cv::Mat mat = CaptureUtil::capture(index, CAPTURE_TYPE_TRADE_QUEUE);
				if (mat.cols <= 400 || mat.rows <= 30) {
					mat.release();
					mat = NULL;
					Sleep(100);
					throw string("½Øͼ³ö´í");
				}

				L2TradeQueue result = captureLevel2TradeQueueData(mat, index);
				long processTime = clock() - start;
				cout << "ʱ¼äÏûºÄ£º" << processTime << endl;
				trade_queue_data_callback(index, code, result, context);
			}
			catch (...) {

			}
		}
		Sleep(2);
	}
}

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)
{

	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)
		{
			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();



	//ͼÏñ·Ö¸î---¿ªÊ¼
	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 * 7);
	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 (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->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;
	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³ö´í");
	}



	/*
	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);
	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)
		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 = 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)
		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);
	free(rowSplitDataOneLevel);
	return resultList;
}

L2TradeQueue L2DataCapture::captureLevel2TradeQueueData(HWND hwnd, int index)
{
	cv::Mat mat =	CaptureUtil::capture(hwnd);
	return captureLevel2TradeQueueData(mat,index);
}

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

L2TradeQueue L2DataCapture::captureLevel2TradeQueueData(OpenCLExcuter* openCLExcuter, cv::Mat& oimg, int identify)
{
	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("»Ò¶È³ö´í");
		}
	}


	try {
		list<ImgArea> splitAreas = L2TradeQueueUtil::splitElements(img);
		int* splitResult = (int*)malloc(sizeof(int) * 4 * 6);
		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 = 6;
		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 };
		UcharDataInfo typesData = UcharDataInfo();
		typesData.length = 6;
		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[0])).append(to_string(lineData[1]));
		sellOneTime.append(":");
		sellOneTime.append(to_string(lineData[2])).append(to_string(lineData[3]));
		sellOneTime.append(":");
		sellOneTime.append(to_string(lineData[4])).append(to_string(lineData[5]));

		string buyOneTime = "";
		buyOneTime.append(to_string(lineData[6])).append(to_string(lineData[7]));
		buyOneTime.append(":");
		buyOneTime.append(to_string(lineData[8])).append(to_string(lineData[9]));
		buyOneTime.append(":");
		buyOneTime.append(to_string(lineData[10])).append(to_string(lineData[11]));


		string sellOnePrice = "";
		for (int i = 0; i < 6; i++)
		{
			sellOnePrice.append(to_string(lineData[12 + i]));
			if (i == 3) {
				sellOnePrice.append(".");
			}
		}

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

		string buyOnePrice = "";
		for (int i = 0; i < 6; i++)
		{
			buyOnePrice.append(to_string(lineData[24 + i]));
			if (i == 3) {
				buyOnePrice.append(".");
			}
		}

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

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

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