#include "TradeQueueCapture.h"
#include "CaptureUtil.h"



TradeQueueCapture::TradeQueueCapture() {
	openCLExcuter = new OpenCLExcuter();
	openCLExcuter->init();
}



list<int*>	TradeQueueCapture::split(cv::Mat img) {

	int full_row = -1;

	int content_start = -1;
	int content_end = -1;

	list<int*> dataItemList;

	for (int r = 5;r < img.rows;r++) {
		if (ImgDivider::isRowFull(img, r, 0, img.cols, 2, 45, 55)) {
			full_row = r;
			if (content_start >= 0 && content_end >= 0) {
				//¼ÓÈëÄÚÈÝ
				//printf("%d-%d\n", content_start, content_end);
				int* item = (int*)malloc(sizeof(int) * 2);
				item[0] = content_start;
				item[1] = content_end;
				dataItemList.push_back(item);
				content_start = -1;
				content_end = -1;
			}
		}
		else {
			if (full_row > -1) {
				if (content_start < 0) {
					content_start = r;
					content_end = r;
				}
				else {
					content_end = r;
				}
			}
		}
	}
	int index = 0;
	list<int*> rowDataList;
	for (list<int*>::iterator ele = dataItemList.begin();ele != dataItemList.end();ele++) {
		index++;
		int start_row = (*ele)[0];
		int end_row = (*ele)[1];
		free(*ele);

		int empty_start = -1;
		int empty_end = -1;

		int content_start = -1;
		int content_end = -1;


		for (int c = 0;c < img.cols;c += 1) {
			if (ImgDivider::isColEmpty(img, c, start_row, end_row, _IMG_BINARY_THRESHOLD)) {
				if (empty_start < 0) {
					empty_start = c;
					empty_end = c;
				}
				else {
					empty_end = c;
					if (empty_end - empty_start > 5) {
						if (content_start > -1 && content_end > -1) {
							//printf("%d-%d\n", content_start, content_end);
							int* item = (int*)malloc(sizeof(int) * 4);
							item[0] = content_start;
							item[1] = start_row;
							item[2] = content_end;
							item[3] = end_row;
							rowDataList.push_back(item);
							content_start = -1;
							content_end = -1;
						}
					}
				}
			}
			else {
				if (empty_end - empty_start >= 5) {
					content_start = c;
					content_end = c;
					empty_start = -1;
					empty_end = -1;

				}
				else {
					if (content_start >= 0) {
						content_end = c;
					}

					empty_start = -1;
					empty_end = -1;
				}
			}
		}

		if (content_start > -1 && content_end > -1) {
			printf("%d-%d\n", content_start, content_end);
			int* item = (int*)malloc(sizeof(int) * 4);
			item[0] = content_start;
			item[1] = start_row;
			item[2] = content_end;
			item[3] = end_row;
			rowDataList.push_back(item);
			content_start = -1;
			content_end = -1;
		}
	}
	return rowDataList;

}


list<int> TradeQueueCapture::recognition(cv::Mat img,list<int*> rowDataList) {

	int c = 0;
	int* pos = (int*)malloc(sizeof(int) * 4 * rowDataList.size());
	for (list<int*>::iterator ele = rowDataList.begin();ele != rowDataList.end();ele++) {
		pos[c * 4 + 0] = (*ele)[0];
		pos[c * 4 + 1] = (*ele)[1];
		pos[c * 4 + 2] = (*ele)[2];
		pos[c * 4 + 3] = (*ele)[3];
		/*
		string path = "C:\\Users\\Administrator\\Desktop\\ocr\\trade_queue\\num_";
		path.append(to_string(index)).append("_").append(to_string(c)).append(".jpg");
		cv::imwrite(path, cv::Mat(img, cv::Rect((*ele)[0], (*ele)[1], (*ele)[2] - (*ele)[0] + 1, (*ele)[3] - (*ele)[1] + 1)));
		*/
		free(*ele);
		c++;

	}


	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 length_per_num = 5;

	unsigned char* totalNumberData = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_GP_CODE_HEIGHT * rowDataList.size()) * _NUMBER_GP_CODE_WIDTH * 10 * length_per_num);

	openCLExcuter->splitTradeQueueNum(img, IntDataInfo({ pos, (int)(rowDataList.size()) }), zeroData, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, totalNumberData, length_per_num);


	/*

	cv::Mat m = cv::Mat::zeros(_NUMBER_GP_CODE_HEIGHT * rowDataList.size(), _NUMBER_GP_CODE_WIDTH * 10 * length_per_num, CV_8UC1);
	m.data = totalNumberData;
	cv::Mat binary;
	threshold(m, binary, 0, 255, cv::THRESH_BINARY);



	cv::imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\trade_queue\\test.jpg", binary);
	*/




	uchar* templateNums = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_GP_CODE_HEIGHT * rowDataList.size()) * _NUMBER_GP_CODE_WIDTH * 10 * length_per_num);
	openCLExcuter->createNumberTemplates(rowDataList.size(), _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, length_per_num, ImgUtil::numsOneLevel_gpcode, templateNums);
	uchar** numberResult = openCLExcuter->recognition_numbers(totalNumberData, templateNums, rowDataList.size() * _NUMBER_GP_CODE_HEIGHT, _NUMBER_GP_CODE_WIDTH * 10 * length_per_num, _NUMBER_GP_CODE_WIDTH, _NUMBER_GP_CODE_HEIGHT, length_per_num);

	list<int> numberList;

	for (int i = 0;i < rowDataList.size();i++) {
		string st = "";
		for (int j = 0;j < length_per_num;j++)
		{
			st.append(to_string(numberResult[i][j]));
		}
		numberList.push_back(stoi(st));
		free(numberResult[i]);
		//printf("½á¹û:%d\n", stoi(st));
	}

	free(numberResult);
	free(zeroData);
	free(templateNums);
	free(totalNumberData);

	return numberList;
}
list<int> TradeQueueCapture::recognition(HWND hwnd) {
	cv::Mat img = CaptureUtil::capture(hwnd);
	uchar* data = (uchar*)malloc(sizeof(uchar) * img.cols * img.rows);
	openCLExcuter->rgba2Gray(img.data, img.cols, img.rows, data);
	cv::Mat grayImg = cv::Mat::zeros(img.rows, img.cols, CV_8UC1);
	grayImg.data = data;
	img.release();
	list<int*> rowDataList = split(grayImg);
	return recognition(grayImg,rowDataList);
}


list<int> TradeQueueCapture::recognition(cv::Mat grayImg) {
	list<int*> rowDataList = split(grayImg);
	return recognition(grayImg, rowDataList);
}