#include "ImgUtil.h"
#include <io.h>

NumberData ImgUtil::NUMS_LEVEL2[10];
NumberData ImgUtil::NUMS_GP_CODE[10];
NumberData ImgUtil::NUMS_TRADE_QUEUE[10];
uchar* ImgUtil::numsOneLevel_level2;
uchar* ImgUtil::numsOneLevel_gpcode;
uchar* ImgUtil::numsOneLevel_trade_queue;

cv::Mat  ImgUtil::formatNumGPCode(cv::Mat num)  throw(string) {
	if (num.empty()) {
		//¿ÕÖµÌî³ä0
		cv::Mat zero;
		ImgUtil::NUMS_GP_CODE[0].data.copyTo(zero);
		return zero;
	}

	//È¥³ýÖÜΧµÄºÚ±ß
	int rows = num.rows;
	int cols = num.cols;
	int startRow = -1, endRow = -1;
	for (int r = 0;r < rows;r++) {
		if (!ImgDivider::isRowEmpty(num, r)) {
			startRow = r;
			break;
		}
	}

	for (int r = rows - 1;r > -1;r--) {
		if (!ImgDivider::isRowEmpty(num, r)) {
			endRow = r;
			break;
		}
	}
	//È¥³ýÇ°ºóµÄ°×±ß
	int startCol = -1, endCol = -1;
	for (int c = 0;c < cols;c++) {
		if (!ImgDivider::isColEmpty(num, c, 1)) {
			startCol = c;
			break;
		}
	}

	for (int c = cols - 1;c > -1;c--) {
		if (!ImgDivider::isColEmpty(num, c, 1)) {
			endCol = c;
			break;
		}
	}

	num = cv::Mat(num, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1));

	//ÅжÏÁÐÊýÊÇ·ñÕý³£
	if (num.cols == _NUMBER_GP_CODE_WIDTH && num.rows == _NUMBER_GP_CODE_HEIGHT) {
		return num;
	}
	//ÍùÓÒϽÇÌí¼ÓÊý¾Ý
	cv::Mat m = cv::Mat::zeros(num.rows, _NUMBER_GP_CODE_WIDTH - num.cols, CV_8UC1);
	cv::Mat dst;
	cv::hconcat(num, m, dst);
	return dst;
}

cv::Mat ImgUtil::formatNumTradeQueue(cv::Mat num) throw(string)
{
	if (num.empty()) {
		//¿ÕÖµÌî³ä0
		cv::Mat zero;
		ImgUtil::NUMS_TRADE_QUEUE[0].data.copyTo(zero);
		return zero;
	}

	//È¥³ýÖÜΧµÄºÚ±ß
	int rows = num.rows;
	int cols = num.cols;
	int startRow = -1, endRow = -1;
	for (int r = 0;r < rows;r++) {
		if (!ImgDivider::isRowEmpty(num, r)) {
			startRow = r;
			break;
		}
	}

	for (int r = rows - 1;r > -1;r--) {
		if (!ImgDivider::isRowEmpty(num, r)) {
			endRow = r;
			break;
		}
	}
	//È¥³ýÇ°ºóµÄ°×±ß
	int startCol = -1, endCol = -1;
	for (int c = 0;c < cols;c++) {
		if (!ImgDivider::isColEmpty(num, c, 1)) {
			startCol = c;
			break;
		}
	}

	for (int c = cols - 1;c > -1;c--) {
		if (!ImgDivider::isColEmpty(num, c, 1)) {
			endCol = c;
			break;
		}
	}

	num = cv::Mat(num, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1));

	//ÅжÏÁÐÊýÊÇ·ñÕý³£
	if (num.cols == _NUMBER_TRADE_QUEUE_WIDTH && num.rows == _NUMBER_TRADE_QUEUE_HEIGHT) {
		return num;
	}
	//ÍùÓÒϽÇÌí¼ÓÊý¾Ý
	cv::Mat m = cv::Mat::zeros(num.rows, _NUMBER_TRADE_QUEUE_WIDTH - num.cols, CV_8UC1);
	cv::Mat dst;
	cv::hconcat(num, m, dst);
	return dst;
}



//·Ö¸ôʱ¼ä
list<cv::Mat> ImgUtil::splitTime(cv::Mat src) throw(std::string) {
	cv::Mat binary;
	threshold(src, binary, 40, 255, cv::THRESH_BINARY);
	int rows = src.rows;
	int cols = src.cols;

	//ÉÏϵİױßÈ¥³ý
	int startRow = -1;
	int endRow = -1;
	for (int r = 0;r < rows;r++) {
		if (!ImgDivider::isRowEmpty(binary, r)) {
			startRow = r;
			break;
		}
	}

	for (int r = rows - 1;r > -1;r--) {
		if (!ImgDivider::isRowEmpty(binary, r)) {
			endRow = r;
			break;
		}
	}

	//ðºÅµÄµäÐÍÌØÕ÷0001000
	//-----------´ÓÖмäÍùÁ½±ß±éÀú²éÕÒðºÅ·Ö¸ô·û----------
	int s = cols / 2;
	int i;
	//ÍùÇ°²éÕÒðºÅ
	int m1_s = -1, m1_e = -1, m2_s = -1, m2_e = -1;
	uchar* temp = (uchar*)malloc(sizeof(uchar) * 7);
	for (i = s;i > -1;i--) {
		if (i < 6) {
			break;
		}
		*temp = binary.ptr<uchar>(endRow)[i];

		*(temp + 1) = binary.ptr<uchar>(endRow)[i - 1];
		*(temp + 2) = binary.ptr<uchar>(endRow)[i - 2];
		*(temp + 3) = binary.ptr<uchar>(endRow)[i - 3];
		*(temp + 4) = binary.ptr<uchar>(endRow)[i - 4];
		*(temp + 5) = binary.ptr<uchar>(endRow)[i - 5];
		*(temp + 6) = binary.ptr<uchar>(endRow)[i - 6];
		if (*(temp + 3) > 0 && binary.ptr<uchar>(endRow - 1)[i - 3] == 0) {
			int t = *temp + *(temp + 1) + *(temp + 2) + *(temp + 4) + *(temp + 5) + *(temp + 6);
			if (t == 0) {
				m1_s = i - 6;
				m1_e = i;
				break;
			}
		}

	}
	//Íùºó²éÕÒðºÅ

	for (i = s;i < cols;i++) {
		if (i > cols - 6) {
			break;
		}

		*temp = binary.ptr<uchar>(endRow)[i];
		*(temp + 1) = binary.ptr<uchar>(endRow)[i + 1];
		*(temp + 2) = binary.ptr<uchar>(endRow)[i + 2];
		*(temp + 3) = binary.ptr<uchar>(endRow)[i + 3];
		*(temp + 4) = binary.ptr<uchar>(endRow)[i + 4];
		*(temp + 5) = binary.ptr<uchar>(endRow)[i + 5];
		*(temp + 6) = binary.ptr<uchar>(endRow)[i + 6];
		if (*(temp + 3) > 0 && binary.ptr<uchar>(endRow - 1)[i + 3] == 0) {
			int t = *temp + *(temp + 1) + *(temp + 2) + *(temp + 4) + *(temp + 5) + *(temp + 6);
			if (t == 0) {
				m2_s = i;
				m2_e = i + 6;
				break;
			}
		}
	}

	free(temp);

	if (m1_s < 0 || m1_e < 0 || m2_s < 0 || m2_e < 0) {

		imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\error\\0.jpg", src);

		throw ("δ²éѯµ½·Ö¸ô·û");
	}

	list<cv::Mat> nums;
	//»ñÈ¡·Ö¸ôÊý×Ö×ø±ê(ʱ£¬·Ö£¬Ãë)
	list<cv::Mat>  tempMat;
	list<cv::Mat>::iterator ele;
	tempMat = splitNum(cv::Mat(binary, cv::Rect(0, startRow, m1_s - 1 - (0) + 1, endRow - startRow + 1)));
	for (ele = tempMat.begin();ele != tempMat.end();ele++) {
		nums.push_back(*ele);
	}
	tempMat = splitNum(cv::Mat(binary, cv::Rect(m1_e + 1, startRow, (m2_s - 1) - (m1_e + 1) + 1, endRow - startRow + 1)));
	for (ele = tempMat.begin();ele != tempMat.end();ele++) {
		nums.push_back(*ele);
	}
	tempMat = splitNum(cv::Mat(binary, cv::Rect(m2_e + 1, startRow, (cols - 1) - (m2_e + 1) + 1, endRow - startRow + 1)));
	for (ele = tempMat.begin();ele != tempMat.end();ele++) {
		nums.push_back(*ele);
	}
	return nums;
}



//·Ö¸ôСÊý£¬ÖмäµÄ¿ÕMat±íʾСÊýµã
list<cv::Mat> ImgUtil::splitDecimal(cv::Mat src) throw(string) {
	cv::Mat binary;
	//È¥³ýÉÏϵĿհ×ͼ
	threshold(src, binary, 40, 255, cv::THRESH_BINARY);
	int rows = src.rows;
	int cols = src.cols;




	//ÉÏϵİױßÈ¥³ý
	int startRow = -1;
	int endRow = -1;
	for (int r = 0;r < rows;r++) {
		if (!ImgDivider::isRowEmpty(binary, r)) {
			startRow = r;
			break;
		}
	}
	for (int r = rows - 1;r > -1;r--) {
		if (!ImgDivider::isRowEmpty(binary, r)) {
			endRow = r;
			break;
		}
	}
	binary = cv::Mat(binary, cv::Rect(0, startRow, cols, endRow - startRow + 1));
	rows = binary.rows;
	cols = binary.cols;


	int i;
	//ÍùÇ°²éÕÒСÊýµã
	int m_s = -1, m_e = -1;
	uchar* temp = (uchar*)malloc(sizeof(uchar) * 6);
	for (i = 0;i < cols;i++) {
		if (i > cols - 5) {
			break;
		}
		*temp = binary.ptr<uchar>(rows - 1)[i];

		*(temp + 1) = binary.ptr<uchar>(rows - 1)[i + 1];
		*(temp + 2) = binary.ptr<uchar>(rows - 1)[i + 2];
		*(temp + 3) = binary.ptr<uchar>(rows - 1)[i + 3];
		*(temp + 4) = binary.ptr<uchar>(rows - 1)[i + 4];
		*(temp + 5) = binary.ptr<uchar>(rows - 1)[i + 5];
		if (*(temp + 2) > 0 && ImgDivider::isColEmpty(binary, i + 2, 0, rows - 2)) {
			int t = *temp + *(temp + 1) + *(temp + 3) + *(temp + 4) + *(temp + 5);
			if (t == 0) {
				m_s = i;
				m_e = i + 5;
				break;
			}
		}
	}

	if (m_s == -1 || m_e == -1) {

		imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\error\\1.jpg", src);
		throw("δ²éÕÒµ½Ð¡Êýµã");
	}


	cv::Mat dotBefore = cv::Mat(binary, cv::Rect(0, 0, m_s, rows));
	cv::Mat dotAfter = cv::Mat(binary, cv::Rect(m_e + 1, 0, cols - (m_e + 1), rows));


	list<cv::Mat> nums;
	list<cv::Mat>  tempMat;
	list<cv::Mat>::iterator ele;


	tempMat = splitNum(dotBefore);
	for (ele = tempMat.begin();ele != tempMat.end();ele++) {
		nums.push_back(*ele);
	}

	tempMat = splitNum(dotAfter);
	for (ele = tempMat.begin();ele != tempMat.end();ele++) {
		nums.push_back(*ele);
	}
	return nums;
}

list<cv::Mat> ImgUtil::splitNum(cv::Mat src,int threshold_value)  throw(string) {
	cv::Mat binary;
	//È¥³ýÉÏϵĿհ×ͼ
	threshold(src, binary, threshold_value , 255, cv::THRESH_BINARY);
	int rows = src.rows;
	int cols = src.cols;




	//ÉÏϵİױßÈ¥³ý
	int startRow = -1;
	int endRow = -1;
	for (int r = 0;r < rows;r++) {
		if (!ImgDivider::isRowEmpty(binary, r)) {
			startRow = r;
			break;
		}
	}

	for (int r = rows - 1;r > -1;r--) {
		if (!ImgDivider::isRowEmpty(binary, r)) {
			endRow = r;
			break;
		}
	}

	if (startRow < 0) {
		throw string("Êý×Ö·Ö¸ôδ²éÕÒµ½ÆðʼÐÐ");
	}

	if (endRow < 0) {
		throw string("Êý×Ö·Ö¸ôδ²éÕÒµ½½áÊøÐÐ");
	}

	binary = cv::Mat(binary, cv::Rect(0, startRow, cols, endRow - startRow + 1));
	rows = binary.rows;
	cols = binary.cols;



	//·Ö¸îÊý×Ö
	std::list<int*>  numberCols;
	int c, startC = -1, endC = -1;
	for (c = 0;c < cols;c++) {

		if (ImgDivider::isColEmpty(binary, c, 1)) {
			if (startC > -1 && endC > -1) {
				int* data = (int*)malloc(sizeof(int) * 2);
				*data = startC;
				*(data + 1) = endC;
				numberCols.push_back(data);
			}
			startC = -1;
			endC = -1;
		}
		else {
			if (startC == -1) {
				startC = c;
				endC = c;
			}
			else {
				endC = c;
			}
		}
	}

	if (startC > -1 && endC > -1) {
		int* data = (int*)malloc(sizeof(int) * 2);
		*data = startC;
		*(data + 1) = endC;
		numberCols.push_back(data);
	}

	list<cv::Mat> resultList;
	std::list<int*>::iterator ele;
	for (ele = numberCols.begin(); ele != numberCols.end();ele++) {
		int start = **ele;
		int end = *(*ele + 1);

		free(*ele);
		cv::Mat img = cv::Mat(binary, cv::Rect(start, 0, end - start + 1, rows));
		resultList.push_back(img);
		/*std::string path = "C:\\Users\\Administrator\\Desktop\\ocr\\";
		path = path.append(std::to_string(rand()));
		path = path.append(".jpg");
		try {
			LogUtil::debug("±£´æÃû³Æ:%s\n", path.c_str());
			imwrite(path, img);
		}
		catch (...) {

		}*/
	}
	return resultList;
}

//·Ö¸ôÕûÊý
list<cv::Mat> ImgUtil::splitNum(cv::Mat src)  throw(string) {
	return splitNum(src,_IMG_BINARY_THRESHOLD);
}

cv::Mat  ImgUtil::formatNumLevel2(cv::Mat num)  throw(string) {
	if (num.empty()) {
		//¿ÕÖµÌî³ä0
		cv::Mat zero;
		ImgUtil::NUMS_LEVEL2[0].data.copyTo(zero);
		return zero;
	}

	//È¥³ýÖÜΧµÄºÚ±ß
	int rows = num.rows;
	int cols = num.cols;
	int startRow = -1, endRow = -1;
	for (int r = 0;r < rows;r++) {
		if (!ImgDivider::isRowEmpty(num, r)) {
			startRow = r;
			break;
		}
	}

	for (int r = rows - 1;r > -1;r--) {
		if (!ImgDivider::isRowEmpty(num, r)) {
			endRow = r;
			break;
		}
	}
	//È¥³ýÇ°ºóµÄ°×±ß
	int startCol = -1, endCol = -1;
	for (int c = 0;c < cols;c++) {
		if (!ImgDivider::isColEmpty(num, c, 1)) {
			startCol = c;
			break;
		}
	}

	for (int c = cols - 1;c > -1;c--) {
		if (!ImgDivider::isColEmpty(num, c, 1)) {
			endCol = c;
			break;
		}
	}

	num = cv::Mat(num, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1));

	//ÅжÏÁÐÊýÊÇ·ñÕý³£
	if (num.cols == _NUMBER_L2_WIDTH && num.rows == _NUMBER_L2_HEIGHT) {
		return num;
	}
	//ÍùÓÒϽÇÌí¼ÓÊý¾Ý
	cv::Mat m = cv::Mat::zeros(num.rows, _NUMBER_L2_WIDTH - num.cols, CV_8UC1);
	cv::Mat dst;
	cv::hconcat(num, m, dst);
	return dst;
}










void ImgUtil::init() {

	//LEVE2Êý×Ö³õʼ»¯
	for (int i = 0;i < 10;i++) {
		std::string sdir = "C:\\Users\\Administrator\\Desktop\\ocr\\number\\";
		if (_access(sdir.c_str(), 0)) {
			sdir = "sample\\number\\";
		}


		std::string path = sdir.append(std::to_string(i)).append(".jpg");
		NumberData data = NumberData();
		data.data = formatNumLevel2(cv::imread(path.c_str(), cv::IMREAD_GRAYSCALE));
		data.num = std::to_string(i);
		NUMS_LEVEL2[i] = data;
	}

	numsOneLevel_level2 = (uchar*)malloc(sizeof(uchar) * _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH * 10);
	for (int i = 0;i < 10;i++) {
		int baseIndex = i * _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH;
		for (int r = 0;r < _NUMBER_L2_HEIGHT;r++) {
			int baseIndex_1 = r * _NUMBER_L2_WIDTH;
			for (int c = 0;c < _NUMBER_L2_WIDTH;c++) {
				int index = baseIndex + baseIndex_1 + c;
				numsOneLevel_level2[index] = NUMS_LEVEL2[i].data.ptr<uchar>(r)[c];
			}
		}
	}


	for (int i = 0;i < 10;i++) {
		std::string sdir = "C:\\Users\\Administrator\\Desktop\\ocr\\number_2\\";
		if (_access(sdir.c_str(), 0)) {
			sdir = "sample\\number_2\\";
		}

		std::string path = sdir.append(std::to_string(i)).append(".jpg");
		NumberData data = NumberData();
		data.data = formatNumGPCode(cv::imread(path.c_str(), cv::IMREAD_GRAYSCALE));
		data.num = std::to_string(i);
		NUMS_GP_CODE[i] = data;
	}

	numsOneLevel_gpcode = (uchar*)malloc(sizeof(uchar) * _NUMBER_GP_CODE_HEIGHT * _NUMBER_GP_CODE_WIDTH * 10);
	for (int i = 0;i < 10;i++) {
		int baseIndex = i * _NUMBER_GP_CODE_HEIGHT * _NUMBER_GP_CODE_WIDTH;
		for (int r = 0;r < _NUMBER_GP_CODE_HEIGHT;r++) {
			int baseIndex_1 = r * _NUMBER_GP_CODE_WIDTH;
			for (int c = 0;c < _NUMBER_GP_CODE_WIDTH;c++) {
				int index = baseIndex + baseIndex_1 + c;
				numsOneLevel_gpcode[index] = NUMS_GP_CODE[i].data.ptr<uchar>(r)[c];
			}
		}
	}


	for (int i = 0;i < 10;i++) {
		std::string sdir = "C:\\Users\\Administrator\\Desktop\\ocr\\number_trade\\";
		if (_access(sdir.c_str(), 0)) {
			sdir = "sample\\number_trade\\";
		}

		std::string path = sdir.append(std::to_string(i)).append(".jpg");
		NumberData data = NumberData();
		data.data = formatNumGPCode(cv::imread(path.c_str(), cv::IMREAD_GRAYSCALE));
		data.num = std::to_string(i);
		NUMS_TRADE_QUEUE[i] = data;
	}

	numsOneLevel_trade_queue = (uchar*)malloc(sizeof(uchar) * _NUMBER_TRADE_QUEUE_HEIGHT * _NUMBER_TRADE_QUEUE_WIDTH * 10);
	for (int i = 0;i < 10;i++) {
		int baseIndex = i * _NUMBER_TRADE_QUEUE_HEIGHT * _NUMBER_TRADE_QUEUE_WIDTH;
		for (int r = 0;r < _NUMBER_TRADE_QUEUE_HEIGHT;r++) {
			int baseIndex_1 = r * _NUMBER_TRADE_QUEUE_WIDTH;
			for (int c = 0;c < _NUMBER_TRADE_QUEUE_WIDTH;c++) {
				int index = baseIndex + baseIndex_1 + c;
				numsOneLevel_trade_queue[index] = NUMS_TRADE_QUEUE[i].data.ptr<uchar>(r)[c];
			}
		}
	}


}

list<int*> ImgUtil::divideImg(cv::Mat img) {

	return divideImg(img, 0);
}

list<int*> ImgUtil::divideImg(cv::Mat img, bool save) {
	//cv::imwrite("C:\\Users\\Administrator\\Desktop\\ocr\\demo\\0_gray.jpg", img);
	clock_t start_time = clock();
	list<list<int*>> resultList;

	int  cols = img.cols - 1;
	int rows = img.rows - 2;
	int startf = -1;
	int endf = -1;
	//»ñÈ¡±êÌâµÄ·Ö¸îÏß
	int contentStartRow = -1;
	for (int i = 10;i < rows;i++) {
		bool full = ImgDivider::isRowFull(img, i);
		if (full) {
			if (startf < 0)
			{
				startf = i;
				endf = i;
			}
			else {
				endf = i;
			}
		}
		else {
			if (startf > -1 && endf > -1) {
				int width = endf - startf + 1;
				contentStartRow = i;
				break;
			}
			startf = -1;
			endf = -1;
		}
	}

	if (contentStartRow < 0) {
		throw string("ͼÏñ·Ö¸ô³ö´í£ºtitle·Ö¸ô³ö´í");
	}


	//·Ö¸ôÿһÁÐÊý¾Ý
	startf = -1;
	endf = -1;
	std::list<int*>  dataColIndexs;
	int startIndex = -1;
	for (int i = 10;i < cols;i++) {
		if (startIndex == -1) {
			startIndex = i;
		}

		bool full = ImgDivider::isColFull(img, i, contentStartRow);
		if (full) {
			if (startf < 0)
			{
				startf = i;
				endf = i;
			}
			else {
				endf = i;
			}
		}
		else {
			if (startf > -1 && endf > -1) {
				int width = endf - startf + 1;
				int* dd = (int*)malloc(sizeof(int) * 2);

				*dd = startIndex;
				*(dd + 1) = startf - 1;

				dataColIndexs.push_back(dd);
				startIndex = i;
			}
			startf = -1;
			endf = -1;
		}

	}

	if (startf > -1 && endf > -1) {
		int width = endf - startf + 1;
		int* dd = (int*)malloc(sizeof(int) * 2);

		*dd = startIndex;
		*(dd + 1) = startf - 1;

		dataColIndexs.push_back(dd);

		startf = -1;
		endf = -1;
	}


	//·Ö¸ôÿһÐеÄÊý¾Ý
	std::list<int*> dataItemList;
	startf = -1;
	endf = -1;
	std::list<int*>::iterator ele;
	bool deleteEmpty=0;

	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 < rows;i++) {
			bool empty = ImgDivider::isRowEmpty(img, i, startCol, endCol, 3, 64) && ImgDivider::isRowEmpty(img, i, endCol - 20, endCol, 1, 64);
			if (empty) {
				if (startf > -1 && endf > -1) {
					//ÄÚÈÝ×ø±ê
					   //LogUtil::debug("ÄÚÈݵĸ߶ÈΪ£º%d \n", endf - startf);
					int* dd = (int*)malloc(sizeof(int) * 4);
					*dd = startf;
					*(dd + 1) = startCol;
					*(dd + 2) = endf;
					*(dd + 3) = endCol;
					//ÐÐÊý¾Ý¸ß´óÓÚ6²ÅΪÓÐЧµÄÐиß
					if (endf - startf > 6)
					{
						//ɾ³ýµÚÒ»ÌõÊý¾Ý
						if (deleteEmpty)
						{
							dataItemList.push_back(dd);
						}
						deleteEmpty = 1;
					}
					dataCount++;
				}
				startf = -1;
				endf = -1;
			}
			else
			{
				//Êý¾Ý¿ªÊ¼
				if (startf == -1) {
					startf = i;
					endf = i;
				}
				else {
					endf = i;
				}
				//Êý¾Ý½áÊø
			}
		}

	}


	return dataItemList;

	//·Ö¸ôÿһÁеÄÊý¾Ý
	int index = 0;
	for (ele = dataItemList.begin(); ele != dataItemList.end();ele++) {
		index++;
		//µÚÒ»ÐÐÊý¾ÝÓÐtitle
		if (index == 1) {
			continue;
		}
		int startRow = *(*ele + 0);
		int startCol = *(*ele + 1);
		int endRow = *(*ele + 2);
		int endCol = *(*ele + 3);

		//±£´æÐÐÊý¾Ý
		if (save) {
			std::string path = "C:\\Users\\Administrator\\Desktop\\ocr\\split\\";
			path.append(std::to_string(index)).append(".jpg");
			imwrite(path, cv::Mat(img, cv::Rect(startCol, startRow, endCol - startCol + 1, endRow - startRow + 1)));
		}

		int emptyStart = -1;
		int emptyEnd = -1;
		int dataStart = -1;
		int dataEnd = -1;

		std::list<int*> rowDataList;

		for (int i = startCol;i <= endCol;i++) {
			bool empty = ImgDivider::isColEmpty(img, i, startRow, endRow, 64);
			if (empty) {
				if (emptyStart < 0) {
					emptyStart = i;
					emptyEnd = i;
				}
				else {
					emptyEnd = i;
				}

				//3¸ö¼°ÒÔÉϵĿհ×Êý¾Ý²Å·ÖÁÐ
				if (emptyEnd - emptyStart >= 5 && dataEnd - dataStart > 0) {
					int* dd = (int*)malloc(sizeof(int) * 4);
					*dd = startRow;
					*(dd + 1) = dataStart;
					*(dd + 2) = endRow;
					*(dd + 3) = dataEnd;
					rowDataList.push_back(dd);
					dataEnd = -1;
					dataStart = -1;
				}
			}
			else {
				if (dataStart < 0) {
					dataStart = i;
					dataEnd = i;
				}
				else {
					dataEnd = i;
				}

				emptyStart = -1;
				emptyEnd = -1;
			}
		}
		//ºóÃæµÄÊý¾ÝûÓÐ×ã¹»µÄ¿Õ°×·Ö¸ô
		if (dataEnd - dataStart > 0) {
			int* dd = (int*)malloc(sizeof(int) * 4);
			*dd = startRow;
			*(dd + 1) = dataStart;
			*(dd + 2) = endRow;
			*(dd + 3) = dataEnd;
			rowDataList.push_back(dd);
		}

		int rowDataSize = rowDataList.size();



		//Èç¹ûûÓÐÂú7¸öÊý¾Ý£¬ÐèÒªÔÚÖм䲹¿ÕÊý¾Ý
		if (rowDataSize < 7) {
			//²¹Âò³· £¬²¹ÕÇÍ£
			if (rowDataSize == 5) {
				//µÚ2¸öλÖò¹Âò³·
				rowDataList.insert(++begin(rowDataList), 0);
				//µÚ4¸öλÖò¹ÕÇÍ£
				rowDataList.insert(++(++(++begin(rowDataList))), 0);
			}
			else if (rowDataSize == 6) {
				std::list<int*>::iterator ele = rowDataList.begin();
				int* d1 = *ele;
				int* d2 = *(++ele);
				//µÚ¶þ¸öÔªËØ¿ªÊ¼×ø±ê¼õÈ¥µÚÒ»¸öÔªËؽáÊø×ø±êСÓÚ20
				if (*(d2 + 1) - *(d1 + 3) < 20) {
					//ÓÐÂò³·,ÐèÒª²¹ÕÇÍ£
					rowDataList.insert(++(++(++begin(rowDataList))), 0);
				}
				else {
					//ÎÞÂò³·
					rowDataList.insert(++begin(rowDataList), 0);
				}
			}
			else {
				string st = "Êý¾Ý·Ö¸ô³ö´í Ðб꣺";
				st.append(to_string(index));
				//throw(st);
			}
		}


		resultList.push_back(rowDataList);


		//±£´æÊý¾Ý
		if (save)
		{
			std::list<int*>::iterator ele1;
			int cc = 0;
			for (ele1 = rowDataList.begin(); ele1 != rowDataList.end();ele1++) {
				if (*ele1)
				{
					int startCRow = *(*ele1 + 0);
					int startCCol = *(*ele1 + 1);
					int endCRow = *(*ele1 + 2);
					int endCCol = *(*ele1 + 3);
					cv::Mat	temp = cv::Mat(img, cv::Rect(startCCol, startCRow, endCCol - startCCol + 1, endCRow - startCRow + 1));
					std::string path = "C:\\Users\\Administrator\\Desktop\\ocr\\split\\";
					path = path.append(std::to_string(index));
					path = path.append("_");
					path = path.append(std::to_string(cc));
					path = path.append(".jpg");
					imwrite(path.c_str(), temp);
				}
				cc++;
			}
		}

		//ÊÍ·ÅÊý¾Ý
		free(*ele);


	}


	cout << "·Ö¸ôÁÐÊý¾ÝºÄʱ£º" << (clock() - start_time) << endl;

	return dataItemList;


}


void ImgUtil::splitRowNumDataForOpenCL(cv::Mat img, list<int*> data, unsigned char* result, int rowIndex) throw(string) {
	list<cv::Mat> numList;
	list<int*>::iterator ele;
	int index = 0;
	for (ele = data.begin();ele != data.end();ele++) {
		index++;
		switch (index)
		{
			//ʱ¼ä
		case 1:
		{
			int startX = *(*ele + 1);
			int startY = *(*ele);
			int endX = *(*ele + 3);
			int endY = *(*ele + 2);
			list<cv::Mat> timeImgs = splitTime(cv::Mat(img, cv::Rect(startX, startY, endX - startX + 1, endY - startY + 1)));
			list<cv::Mat>::iterator eleChild;
			for (eleChild = timeImgs.begin();eleChild != timeImgs.end();eleChild++) {
				numList.push_back(*eleChild);
			}
		}
		break;

		//Âò³·Ê±¼ä
		case 2:break;

			//¼Û¸ñ
		case 3:
		{


			int startX = *(*ele + 1);
			int startY = *(*ele);
			int endX = *(*ele + 3);
			int endY = *(*ele + 2);
			list<cv::Mat> priceImgs = splitDecimal(cv::Mat(img, cv::Rect(startX, startY, endX - startX + 1, endY - startY + 1)));
			//¼Û¸ñµÄÊý×Ö¸ñʽΪxxxx.xx
			int emptySize = 6 - priceImgs.size();
			//СÓÚ6λµÄÔÚÇ°ÃæÌî³ä¿ÕÖµ
			for (int i = 0;i < emptySize;i++) {
				numList.push_back(cv::Mat());
			}

			//Ìî³äʣϵÄÕæʵֵ
			list<cv::Mat>::iterator eleChild;
			for (eleChild = priceImgs.begin();eleChild != priceImgs.end();eleChild++) {
				numList.push_back(*eleChild);
			}

		}
		break;


		//ÊÇ·ñÕÇÍ£¼Û
		case 4:
			break;


			//½ð¶î
		case 5:break;


			//ÊÖÊý
		case 6:
		{
			int startX = *(*ele + 1);
			int startY = *(*ele);
			int endX = *(*ele + 3);
			int endY = *(*ele + 2);
			list<cv::Mat> numImgs = splitNum(cv::Mat(img, cv::Rect(startX, startY, endX - startX + 1, endY - startY + 1)));
			//ÊÖÊýµÄÊý×Ö¸ñʽΪxxxxx È磺00001,00203,10000 
			int emptySize = 5 - numImgs.size();
			//СÓÚ6λµÄÔÚÇ°ÃæÌî³ä¿ÕÖµ
			for (int i = 0;i < emptySize;i++) {
				numList.push_back(cv::Mat());
			}

			//Ìî³äʣϵÄÕæʵֵ
			list<cv::Mat>::iterator eleChild;
			for (eleChild = numImgs.begin();eleChild != numImgs.end();eleChild++) {
				numList.push_back(*eleChild);
			}
		}
		break;


		//ÀàÐÍ
		case 7:
			break;
		default:
			break;
		}


	}


	//½«ËùÓеÄÊý×Ö¸ñʽ»¯Îª5*8µÄµãÕó¸ñʽ
	int ROW = _NUMBER_L2_HEIGHT, COL = _NUMBER_L2_WIDTH;
	int rowData = ROW * COL * 10 * _NUMBER_L2_TOTAL_NUMBER;

	list<cv::Mat>::iterator eleM;
	index = 0;
	for (eleM = numList.begin();eleM != numList.end();eleM++) {
		index++;
		cv::Mat numMat = formatNumLevel2(*eleM);
		//תΪÊý×éµÄÐÎʽ
		for (int r = 0;r < ROW;r++) {
			//½«Ã¿¸öÊý×ÖÖظ´¼ÓÈë10´Î,ÓÃÓÚ¾ØÕóÏà¼õ
			for (int re = 0;re < 10;re++)
			{
				for (int c = 0;c < COL;c++) {
					//¶þÖµ»¯
					unsigned char d = numMat.ptr<unsigned char>(r)[c] > 40 ? 1 : 0;
					int y = (index - 1) * COL * 10 + re * COL + c;
					result[rowData * rowIndex + r * (COL * 10 * numList.size()) + y] = d;
					//printf("(%d,%d)=%d ", r, y, result[r][y]);
				}
			}
		}
		//ÊÍ·ÅÄÚ´æ
		numMat.release();
		//printf("ÄÚ´æµØÖ·£º%ld", &result[0][0]);
		//printf("\n");
	}

	/*
	for (int i = 0;i < ROW;i++) {
		printf("\n");

		for (int j = 0;j < 850;j++) {
			printf("(%d,%d)=%d ", i, j, result[i][j]);
		}
	}
	*/


}

list<HWND> winList;
BOOL CALLBACK EnumChildProc(HWND hwndChild, LPARAM lParam)
{
	winList.push_back(hwndChild);
	return TRUE;
}


cv::Mat ImgUtil::grayImage(cv::Mat src) {
	cv::Mat grayImage;
	if (src.channels() == 3)
	{
		cvtColor(src, grayImage, cv::COLOR_RGB2GRAY);
	}else if (src.channels() == 4) {
		cvtColor(src, grayImage, cv::COLOR_RGBA2GRAY);
	}
	else if (src.channels() == 1) {
		return src;
	}
	return grayImage;
}

uchar* ImgUtil::createTemplateNumData(int lines) {
	int LINE_NUMBER_COUNT = _NUMBER_L2_TOTAL_NUMBER;
	int NUMBER_COUNT = 10;
	unsigned char* data = (unsigned char*)malloc(sizeof(unsigned char) * (_NUMBER_L2_HEIGHT * lines) * _NUMBER_L2_WIDTH * NUMBER_COUNT * LINE_NUMBER_COUNT);
	int outLineDataCount = _NUMBER_L2_HEIGHT * _NUMBER_L2_WIDTH * NUMBER_COUNT * LINE_NUMBER_COUNT;
	int inLineDataCount = _NUMBER_L2_WIDTH * NUMBER_COUNT * LINE_NUMBER_COUNT;
	for (int l = 0;l < lines;l++)
	{
		int outLineCount = outLineDataCount * l;
		for (int re = 0;re < LINE_NUMBER_COUNT;re++) {
			for (int n = 0;n < NUMBER_COUNT;n++)
			{
				for (int r = 0;r < _NUMBER_L2_HEIGHT;r++) {
					int intLineCount = inLineDataCount * r;

					for (int c = 0;c < _NUMBER_L2_WIDTH;c++) {
						uchar value = ImgUtil::NUMS_LEVEL2[n].data.ptr(r)[c];
						int index = outLineCount;
						index += intLineCount;
						int x = re * NUMBER_COUNT * _NUMBER_L2_WIDTH + n * _NUMBER_L2_WIDTH + c;
						index += x;
						data[index] = value > 40 ? 1 : 0;
					}
				}
			}
		}
	}
	return data;
}

//TODO ÅжÏÁ½ÕÅͼÊÇ·ñÒ»ÖÂ
bool  ImgUtil::isImgSame(cv::Mat m1,cv::Mat m2) {
	if (m1.cols != m2.cols || m1.rows != m2.rows) {
		return FALSE;
	}
	cv::Mat m3;
	cv::subtract(m1, m2 ,m3);
	for (int r = 0;r < m3.rows;r++) {
		for (int c = 0;c < m3.cols;c++) {
		uchar value =	m3.ptr<uchar>(r)[c];
		if (value > 0) {
			return FALSE;
		}
		}
	}
	return TRUE;
}