#include "ImageResultJudge.h"

// 检测图坐标 -> 原图坐标(detToSrcMat 非空时按矩阵映射; 否则退回 CutRoi 平移)
static cv::Rect DetRoiToSrcRoi(const cv::Mat &detToSrcMat, cv::Rect detRoi, const cv::Rect &cutRoi, const cv::Size &srcSize)
{
	if (detToSrcMat.empty() || detToSrcMat.rows != 2 || detToSrcMat.cols != 3)
	{
		cv::Rect srcRoi = detRoi;
		srcRoi.x += cutRoi.x;
		srcRoi.y += cutRoi.y;
		return srcRoi;
	}

	const double *m = detToSrcMat.ptr<double>(0);
	cv::Point2f pts[4] = {
		cv::Point2f((float)detRoi.x, (float)detRoi.y),
		cv::Point2f((float)(detRoi.x + detRoi.width), (float)detRoi.y),
		cv::Point2f((float)(detRoi.x + detRoi.width), (float)(detRoi.y + detRoi.height)),
		cv::Point2f((float)detRoi.x, (float)(detRoi.y + detRoi.height))};
	float fminX = 1e18f, fmaxX = -1e18f, fminY = 1e18f, fmaxY = -1e18f;
	for (int i = 0; i < 4; i++)
	{
		float x = (float)(m[0] * pts[i].x + m[1] * pts[i].y + m[2]);
		float y = (float)(m[3] * pts[i].x + m[4] * pts[i].y + m[5]);
		if (x < fminX)
			fminX = x;
		if (x > fmaxX)
			fmaxX = x;
		if (y < fminY)
			fminY = y;
		if (y > fmaxY)
			fmaxY = y;
	}
	cv::Rect srcRoi(cvFloor(fminX), cvFloor(fminY), cvCeil(fmaxX) - cvFloor(fminX), cvCeil(fmaxY) - cvFloor(fminY));
	if (srcSize.width > 0 && srcSize.height > 0)
	{
		srcRoi &= cv::Rect(0, 0, srcSize.width, srcSize.height);
	}
	return srcRoi;
}

// 从原图取缺陷小图：detCutRoi 为检测图坐标下的截取框；输出按检测图坐标映射从原图取回(原图通道)
static bool WarpSrcCutImg(const cv::Mat &srcImg, const cv::Mat &detToSrcMat, const cv::Rect &detCutRoi, cv::Mat &outPatch)
{
	outPatch.release();
	if (srcImg.empty() || detToSrcMat.empty() || detToSrcMat.rows != 2 || detToSrcMat.cols != 3 ||
		detCutRoi.width <= 0 || detCutRoi.height <= 0)
	{
		return false;
	}

	// detCutRoi 四角映射回原图，得到需要取的原图范围
	cv::Rect srcBBox = DetRoiToSrcRoi(detToSrcMat, detCutRoi, cv::Rect(0, 0, 0, 0), srcImg.size());
	if (srcBBox.width <= 0 || srcBBox.height <= 0)
	{
		return false;
	}

	// dst 为截取框局部坐标, src 为原图坐标(再平移到 srcBBox 内):
	// src = detToSrcMat * (dst + detCutRoi.tl()) - srcBBox.tl()
	cv::Mat mat = detToSrcMat.clone();
	mat.at<double>(0, 2) += mat.at<double>(0, 0) * detCutRoi.x + mat.at<double>(0, 1) * detCutRoi.y - srcBBox.x;
	mat.at<double>(1, 2) += mat.at<double>(1, 0) * detCutRoi.x + mat.at<double>(1, 1) * detCutRoi.y - srcBBox.y;

	cv::warpAffine(srcImg(srcBBox), outPatch, mat, detCutRoi.size(), cv::INTER_LINEAR, cv::BORDER_REPLICATE);
	return !outPatch.empty();
}

ImageResultJudge::ImageResultJudge(/* args */)
{
	m_pCommonAnalysisyConfig = NULL;
	ptr_thread_Draw = NULL;

	m_bExit = false;
}

ImageResultJudge::~ImageResultJudge()
{
}

int ImageResultJudge::SetAnalysisyConfig(AnalysisyConfigST *pAnalysisyConfig)
{
	m_pAnalysisyConfig = pAnalysisyConfig;
	m_pChannelFuntion = &m_pAnalysisyConfig->checkFunction;
	m_pbaseCheckFunction = &m_pAnalysisyConfig->baseFunction;
	return 0;
}

cv::Rect ImageResultJudge::GetCutRoi(cv::Rect &roi, const cv::Mat &img)
{

	cv::Rect cutroi;
	int pc_x = roi.x + roi.width * 0.5;
	int pc_y = roi.y + roi.height * 0.5;
	bool bresize = false;
	if (roi.width < QX_SAMLLIMG_WIDTH && roi.height < QX_SAMLLIMG_HEIGHT)
	{
		cutroi.width = QX_SAMLLIMG_WIDTH;
		cutroi.x = pc_x - QX_SAMLLIMG_WIDTH * 0.5;
		cutroi.height = QX_SAMLLIMG_HEIGHT;
		cutroi.y = pc_y - QX_SAMLLIMG_HEIGHT * 0.5;
	}
	else
	{
		// 宽 高
		if (roi.width > roi.height)
		{
			cutroi.width = roi.width + 20;
			cutroi.x = roi.x - 10;

			float fsx = QX_SAMLLIMG_HEIGHT * 1.0f / QX_SAMLLIMG_WIDTH;
			cutroi.height = cutroi.width * fsx;
			cutroi.y = pc_y - cutroi.height * 0.5;
		}
		else
		{
			cutroi.height = roi.height + 20;
			cutroi.y = roi.y - 10;

			float fsy = QX_SAMLLIMG_WIDTH * 1.0f / QX_SAMLLIMG_HEIGHT;
			cutroi.width = cutroi.height * fsy;
			cutroi.x = pc_x - cutroi.width * 0.5;
		}

		bresize = true;
	}

	if (cutroi.x < 0)
	{
		cutroi.x = 0;
	}
	if (cutroi.y < 0)
	{
		cutroi.y = 0;
	}
	if (cutroi.x + cutroi.width >= img.cols)
	{
		cutroi.x = img.cols - cutroi.width;
		if (cutroi.x < 0)
		{
			cutroi.x = 0;
			if (cutroi.x + cutroi.width >= img.cols)
			{
				cutroi.width = img.cols;
			}
		}
	}
	if (cutroi.y + cutroi.height >= img.rows)
	{
		cutroi.y = img.rows - cutroi.height;
		if (cutroi.y < 0)
		{
			cutroi.y = 0;
			if (cutroi.y + cutroi.height >= img.rows)
			{
				cutroi.height = img.rows;
			}
		}
	}

	return cutroi;
}
int ImageResultJudge::GetAIDetImg(std::shared_ptr<ImageAllResult> pImageResult, cv::Point pcenter, cv::Mat &AI_InImg, cv::Mat &AI_OutImg)
{

	// printf("%d %d \n", pcenter.x, pcenter.y);
	// int AINum = pImageResult->AI_Qx_MaskList.size();
	for (auto &pAIMask : pImageResult->AI_Qx_MaskList)
	{
		cv::Rect roi = pAIMask->roi;

		if (pcenter.x >= roi.x && pcenter.x <= (roi.x + roi.width) &&
			pcenter.y >= roi.y && pcenter.y <= (roi.y + roi.height))
		{
			// printf("%d %d %d  %d \n", roi.x, roi.y, roi.width, roi.height);
			//  点 (x, y) 在矩形区域内
			// printf("--------------------------\n");
			AI_InImg = pAIMask->AI_inImg;
			AI_OutImg = pAIMask->AI_mask;
		}
	}
	return 0;
}
int ImageResultJudge::UpdateImgageScale()
{

	if (m_pBasicConfig->fImage_Scale_x > 0 && m_pBasicConfig->fImage_Scale_x < 1 &&
		m_pBasicConfig->fImage_Scale_y > 0 && m_pBasicConfig->fImage_Scale_y < 1)
	{

		m_fImgage_Scale_X = m_pBasicConfig->fImage_Scale_x;
		m_fImgage_Scale_Y = m_pBasicConfig->fImage_Scale_y;
	}

	return 0;
}
int ImageResultJudge::ResultJudge(std::shared_ptr<ImageAllResult> pImageResult)
{
	std::shared_ptr<DetLog> pImageLog = pImageResult->detlog;
	int regionNum = m_pCommonAnalysisyConfig->regionConfigArr.size();
	if (regionNum <= 0)
	{
		return 1;
	}

	pImageLog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Param Judge", "img %s ====================start  regon num %d", pImageResult->strChannel.c_str(), regionNum);

	float fs_resize_x = pImageResult->fscale_detToresult_x;
	float fs_resize_y = pImageResult->fscale_detToresult_x;

	std::shared_ptr<One_Image_CheckResult_> pDetResult = pImageResult->pDetResult; // 检测结果
	std::shared_ptr<CheckResult> m_CheckResult_shareP = pImageResult->result;	   // 返回结果
	int qxNum = pDetResult->pQx_ErrorList->size();

	// map<string, vector<iregionQxZoningInfo>> allQxZoning;

	map<string, vector<singleQxZoningInfo>> allQxZoning;
	set<string> qx_name_list;

	for (int qxidx = 0; qxidx < qxNum; qxidx++)
	{
		QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
		std::shared_ptr<DetLog> pQxLog = pDetResult->pQx_ErrorList->at(qxidx).detlog;
		// pQxLog->bPrintStr = true;
		cv::Rect roi = QX_info->roi;
		float JudgArea = QX_info->JudgArea;
		float JudgArea_second = QX_info->JudgArea_second;
		float flen = QX_info->flen;
		float fbreadth = QX_info->fbreadth;
		float grayDis = QX_info->grayDis;
		int energy = QX_info->energy;
		float fupS = QX_info->fUpIou;
		int maxValue = QX_info->maxValue;
		float density = QX_info->density;
		int QX_whiteBLACK = QX_info->whiteOrBlack;
		int config_qx_type = QX_info->nconfig_qx_type;
		std::string qx_name = CONFIG_QX_NAME_Names[config_qx_type];
		std::string qx_wb = WHITE_BLCAK_Names[QX_whiteBLACK];

		pQxLog->AddCheckstr(PrintLevel_1,
							"", "qxidx: %d   roi[%d %d  %d  %d]  qx %d %s %s JudgArea %f  hj %f len %f breadth %f energy %d region num %ld",
							qxidx, roi.x, roi.y, roi.width, roi.height, config_qx_type, qx_name.c_str(), qx_wb.c_str(),
							JudgArea, grayDis, flen, fbreadth, energy, QX_info->detRegionidxList.size());

		cv::Point pCenter;
		pCenter.x = roi.x + roi.width * 0.5;
		pCenter.y = roi.y + roi.height * 0.5;

		bool bNG_Status = false;
		bool bYS_Status = false;
		bool Judge_Status = false;

		QX_info->result = QX_RESULT_TYPE_NoJduge;

		allQxZoning[qx_name].reserve(20);
		qx_name_list.insert(qx_name);

		// 遍历当前区域所属的 区域进行参数判断。
		for (auto iregion : QX_info->detRegionidxList)
		{
			pQxLog->AddCheckstr(PrintLevel_2, "QX info", ">>>>>>>> region  %d  ",
								iregion + 1);

			// 1、判断当前区域是否要检测该通道画面。

			// 2、基础的参数判断
			if (iregion >= regionNum)
			{
				pQxLog->AddCheckstr(PrintLevel_3, "QX info", "Error regionIdx %d > param size %d ",
									iregion, regionNum);
				addInDrawBlob(config_qx_type, qxidx, QX_info, fs_resize_x, fs_resize_y);
				continue;
			}
			if (config_qx_type >= CONFIG_QX_NAME_count || config_qx_type < 0)
			{
				pQxLog->AddCheckstr(PrintLevel_3, "QX info", "Error def_type %d  size %d ",
									config_qx_type, CONFIG_QX_NAME_count);
				addInDrawBlob(config_qx_type, qxidx, QX_info, fs_resize_x, fs_resize_y);
				continue;
			}
			int paramIdx = m_QxInParamListIdx[config_qx_type];
			if (paramIdx < 0)
			{
				pQxLog->AddCheckstr(PrintLevel_3, "qx error", "  paramIdx < 0 ");
				addInDrawBlob(config_qx_type, qxidx, QX_info, fs_resize_x, fs_resize_y);
				continue;
			}

			// 3、 基本参数判断
			int checkFlage = 0;
			int nerrortype = 0;
			for (int ict = 0; ict < ANALYSIS_TYPE_COUNT; ict++)
			{

				std::string str_checkflag = "QX-check";
				checkFlage = ict;
				if (ict == ANALYSIS_TYPE_YS)
				{
					str_checkflag = "YS-check";
				}
				// pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "qx judge", " %s start", str_checkflag.c_str());

				CheckConfig_Regions_Param *pParam = &m_pCommonAnalysisyConfig->regionConfigArr.at(iregion).checkConfig_Regions_type[ict].checkConfig_Regions_Param.at(paramIdx);

				bool bUse = false;

				for (int j = 0; j < pParam->useNum; j++)
				{

					bool result = true;
					if (!pParam->paramArr[j].bEnable)
					{
						// pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "error ", "param is CLosed");
						continue;
					}

					bUse = true;
					float At = pParam->paramArr[j].area;
					float Et = pParam->paramArr[j].energy;
					float hj = pParam->paramArr[j].hj;
					float Len = pParam->paramArr[j].length;
					float Breadth = pParam->paramArr[j].breadth;
					float md = pParam->paramArr[j].density;
					float dis = pParam->paramArr[j].dis;
					float num = pParam->paramArr[j].num;

					if(dis > 0 && num > 0 && allQxZoning[qx_name].size() == 0){
						pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "Dis | Num", "qx_name : %s, dis : %f, num : %f, scale_X : %f, scale_Y : %f", 
							qx_name.c_str(), dis, num, m_fImgage_Scale_X, m_fImgage_Scale_Y);
						singleQxZoningInfo singleQxZoningInfoTemp;
						singleQxZoningInfoTemp.Init();
						singleQxZoningInfoTemp.judge_dis = dis;
						singleQxZoningInfoTemp.judge_num = num;
						singleQxZoningInfoTemp.scale_X = m_fImgage_Scale_X;
						singleQxZoningInfoTemp.scale_Y = m_fImgage_Scale_Y;
						allQxZoning[qx_name].push_back(singleQxZoningInfoTemp);
					}

					// 黑缺陷
					if (QX_whiteBLACK == CONFIG_QX_WHITE)
					{
						// pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "param---", "qx :white");
						if (hj >= 0 || Et >= 0)
						{
							pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "param ", "Error param idx %d / %d qx white  hj %f and energ %f >0",
												j + 1, pParam->useNum, hj, Et);
							continue;
						}
						Et = std::abs(Et);
						hj = std::abs(hj);
					}
					else
					{
						// pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "param---", "qx :blcak");
						if (hj < 0 || Et < 0)
						{
							pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "param ", "Error param idx %d / %d qx blcak  hj %f and energ %f < 0",
												j + 1, pParam->useNum, hj, Et);
							continue;
						}
					}
					Judge_Status = true;

					float detArea = JudgArea;

					if (energy >= Et &&
						detArea >= At &&
						grayDis >= hj &&
						flen >= Len &&
						fbreadth >= Breadth)
					{
						nerrortype = 1;
						result = false;
						if (ict == ANALYSIS_TYPE_YS)
						{
							bYS_Status = true;
						}
						else
						{
							bNG_Status = true;
						}
					}
					if (!result)
					{
						pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "result", "%s   param idx %d / %d parma A %f E %f HJ %f L %f B %f",
											BOOL_TO_STROK(result), j + 1, pParam->useNum, At, Et, hj, Len, Breadth);
					}
					else
					{
						pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "result", "%s   param idx %d / %d", BOOL_TO_STROK(result), j + 1, pParam->useNum);
					}

					if (detArea < At)
					{
						pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "Area", "%s -> %f %s %f ",
											BOOL_TO_STR(detArea >= At), detArea, BOOL_TO_ThanLess(detArea >= At), At);
					}
					if (energy < Et)
					{
						pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "Energy", "%s -> %d %s %f ",
											BOOL_TO_STR(energy >= Et), energy, BOOL_TO_ThanLess(energy >= Et), Et);
					}
					if (grayDis < hj)
					{
						pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "HJ", "%s -> %f %s %f ",
											BOOL_TO_STR(grayDis >= hj), grayDis, BOOL_TO_ThanLess(grayDis > hj), hj);
					}
					if (flen < Len)
					{
						pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "Len", "%s -> %f %s %f ",
											BOOL_TO_STR(flen >= Len), flen, BOOL_TO_ThanLess(flen > Len), Len);
					}
					if	(fbreadth < Breadth)
					{
						pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "Breadth", "%s -> %f %s %f ",
											BOOL_TO_STR(fbreadth >= Breadth), fbreadth, BOOL_TO_ThanLess(fbreadth > Breadth), Breadth);
					}

					if (!result)
					{
						break;
					}
				}
				if (!bUse)
				{
					pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "info", "Not Use Param Judge");
				}

				if (nerrortype != 0)
				{
					pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "info", " %s end   result: erorr  type %s", str_checkflag.c_str(), qx_name.c_str());
					break;
				}
				else
				{
					pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "info", " %s end   result: OK ", str_checkflag.c_str());
				}
			}

			// 已经NG 就不继续判断了。
			if (bNG_Status)
			{
				break;
			}
		}

		// 标签缺陷（TBBQ）：检测到标签直接判 NG
		if (config_qx_type == CONFIG_QX_NAME_cell_TBBQ)
		{
			bNG_Status = true;
			Judge_Status = true;
		}

		std::string resultType = "OK";

		if (!Judge_Status)
		{
			QX_info->result = QX_RESULT_TYPE_NoJduge;
		}
		else
		{
			if (bNG_Status)
			{
				QX_info->result = QX_RESULT_TYPE_NG;
			}
			else if (bYS_Status)
			{
				QX_info->result = QX_RESULT_TYPE_YS;
				int if_insert = false;
				singleQxInfo current_YS_info(qxidx, QX_RESULT_TYPE_YS, pCenter);
				for(int i = 0; i < allQxZoning[qx_name].size(); i++){
					if(allQxZoning[qx_name][i].Insert(current_YS_info)){
						if_insert = true;
						break;					
					}
				}
				if(!if_insert && allQxZoning[qx_name].size() > 0){
					singleQxZoningInfo newZoningInfoTemp;
					newZoningInfoTemp.Init();
					newZoningInfoTemp.judge_dis = allQxZoning[qx_name][0].judge_dis;
					newZoningInfoTemp.judge_num = allQxZoning[qx_name][0].judge_num;
					newZoningInfoTemp.center = pCenter;
					newZoningInfoTemp.scale_X = m_fImgage_Scale_X;
					newZoningInfoTemp.scale_Y = m_fImgage_Scale_Y;
					newZoningInfoTemp.qxList.push_back(current_YS_info);
					allQxZoning[qx_name].push_back(newZoningInfoTemp); // 插入失败，添加一个新分组	
				} 			
			}
			else
			{
				QX_info->result = QX_RESULT_TYPE_OK;
			}
		}
		QX_info->result_name = QX_RESULT_TYPE_Names[QX_info->result];
		resultType = QX_info->result_name;

		pQxLog->AddCheckstr(PrintLevel_2, DET_LOG_LEVEL_3, "10、Param Judge", "qx %s ,result = %s", qx_name.c_str(), resultType.c_str());

		// 当前是好品
		if (!bNG_Status)
		{
			// 大缺陷判断
			if (m_pbaseCheckFunction->bigNG.bOpen)
			{
				bool berror = false;
				if (config_qx_type >= 0 || config_qx_type < CONFIG_QX_NAME_count)
				{
					bool qx_config_open = m_pbaseCheckFunction->bigNG.qx[config_qx_type].bOpen;
					float qx_config_area = m_pbaseCheckFunction->bigNG.qx[config_qx_type].fArea;
					if (qx_config_open)
					{
						if (JudgArea > qx_config_area)
						{
							berror = true;
							bNG_Status = true;
						}
						pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "Big QX single result ", "%s ", BOOL_TO_STROK(!berror));
						pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, "Area", "%s -> %f %s %f ",
											BOOL_TO_STR(JudgArea > qx_config_area), JudgArea, BOOL_TO_ThanLess(JudgArea > qx_config_area), qx_config_area);
					}
					else
					{
						pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, " big qx", "qx %s param close ", m_pbaseCheckFunction->bigNG.qx[config_qx_type].strname.c_str());
					}
				}
			}
			else
			{
				pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, " big qx", " param close ");
			}

			if (!Judge_Status)
			{
				QX_info->result = QX_RESULT_TYPE_NoJduge;
			}
			else
			{
				if (bNG_Status)
				{
					QX_info->result = QX_RESULT_TYPE_NG;
				}
				else if (bYS_Status)
				{
					QX_info->result = QX_RESULT_TYPE_YS;
				}
				else
				{
					QX_info->result = QX_RESULT_TYPE_OK;
				}
			}
			QX_info->result_name = QX_RESULT_TYPE_Names[QX_info->result];
			resultType = QX_info->result_name;

			pQxLog->AddCheckstr(PrintLevel_2, DET_LOG_LEVEL_3, "12、big qx ", "qx %s ,result = %s", qx_name.c_str(), resultType.c_str());
		}

		if (bNG_Status)
		{
			m_CheckResult_shareP->nresult = 1;
		}
		if (bYS_Status)
		{
			m_CheckResult_shareP->nYS_result = 1;
		}

		m_CheckResult_shareP->checkStatus = 0;
		// 生成缺陷小图
		if (bYS_Status || bNG_Status)
		{

			// 生成图片
			QXImageResult tem;
			tem.idx = qxidx;
			cv::Rect CutRoi = GetCutRoi(roi, pImageResult->detImg);
			// CheckUtil::printROI(CutRoi, "CutRoi");
			cv::Size sz = cv::Size(QX_SAMLLIMG_WIDTH, QX_SAMLLIMG_HEIGHT);

			// 缺陷小图直接取自原图裁剪区(保持原图通道 -> 真实彩色);按仿射矩阵从原图取回,
			// ReJson/异常时退回检测图
			{
				const cv::Mat &srcImg = pImageResult->result->in_shareImage->img;
				bool bGot = false;
				if (pImageResult->result->in_shareImage->Det_Mode != DET_MODE_ReJson)
				{
					bGot = WarpSrcCutImg(srcImg, pDetResult->detToSrcMat, CutRoi, tem.srcImg);
				}
				if (!bGot)
				{
					int nOffsetX = (pImageResult->result->in_shareImage->Det_Mode != DET_MODE_ReJson) ? pDetResult->CutRoi.x : 0;
					int nOffsetY = (pImageResult->result->in_shareImage->Det_Mode != DET_MODE_ReJson) ? pDetResult->CutRoi.y : 0;
					cv::Rect srcCanvasRoi(CutRoi.x + nOffsetX, CutRoi.y + nOffsetY, CutRoi.width, CutRoi.height);
					if (!srcImg.empty() && CheckUtil::RoiInImg(srcCanvasRoi, srcImg))
					{
						tem.srcImg = srcImg(srcCanvasRoi).clone();
					}
					else
					{
						tem.srcImg = pImageResult->detImg(CutRoi).clone();
					}
				}
			}
			cv::resize(tem.srcImg, tem.resizeImg, sz);

			int nqx_type = ConfigTypeToResultType(config_qx_type);
			tem.type = nqx_type;
			tem.area = JudgArea;
			tem.energy = energy;
			tem.hj = grayDis;
			tem.max_v = maxValue;
			tem.strTypeName = QX_Result_Names[nqx_type];
			tem.qx_Code = QX_Result_Code[nqx_type];
			tem.qx_level = QX_info->qx_level;
			// 缺陷 roi 映射回原图(按仿射矩阵映射, 否则按 CutRoi 平移)
			{
				const cv::Mat &srcSizeImg = pImageResult->result->in_shareImage->img;
				tem.srcImgroi = DetRoiToSrcRoi(pDetResult->detToSrcMat, roi, pDetResult->CutRoi,
											   srcSizeImg.empty() ? pImageResult->detImg.size() : srcSizeImg.size());
			}
			tem.len = flen;
			tem.breadth = fbreadth;
			tem.qx_type = 0;
			tem.fScore = 0;
			tem.density = 0;

			tem.resizeImgroi.x = roi.x * fs_resize_x;
			tem.resizeImgroi.width = roi.width * fs_resize_x;
			tem.resizeImgroi.y = roi.y * fs_resize_y;
			tem.resizeImgroi.height = roi.height * fs_resize_y;

			tem.x_pixel = roi.x + roi.width * 0.5;
			tem.y_pixel = roi.y + roi.height * 0.5;

			tem.x_mm = tem.x_pixel * m_fImgage_Scale_X;
			tem.y_mm = tem.y_pixel * m_fImgage_Scale_Y;

			tem.CutImgroi = roi;
			tem.CutImgroi.x -= CutRoi.x;
			tem.CutImgroi.y -= CutRoi.y;

			if (bNG_Status)
			{

				m_CheckResult_shareP->defectResultList[nqx_type].nresult = 1;
				m_CheckResult_shareP->defectResultList[nqx_type].keyName = QX_Result_Names[nqx_type];
				m_CheckResult_shareP->defectResultList[nqx_type].keyCode = QX_Result_Code[nqx_type];
				m_CheckResult_shareP->defectResultList[nqx_type].num++;
				if (m_CheckResult_shareP->nresult <= ERROR_TYPE_OK)
				{
					m_CheckResult_shareP->nresult = nqx_type;
				}

				GetAIDetImg(pImageResult, pCenter, tem.AI_in_Img, tem.AI_out_img);
				m_CheckResult_shareP->qxImageResult.push_back(tem);
				pQxLog->AddCheckstr(PrintLevel_4, DET_LOG_LEVEL_3, " result ", " ---name: %s ---code: %s  ---srcImgroi.x: %d  ---srcImgroi.y: %d\n", tem.strTypeName.c_str(), tem.qx_Code.c_str(), tem.srcImgroi.x, tem.srcImgroi.y);
			}
			else
			{

				if (m_CheckResult_shareP->nYS_result <= ERROR_TYPE_OK)
				{
					m_CheckResult_shareP->nYS_result = nqx_type;
				}

				GetAIDetImg(pImageResult, pCenter, tem.AI_in_Img, tem.AI_out_img);

				m_CheckResult_shareP->YS_ImageResult.push_back(tem);
			}
		}
	}

	for (const auto& name : qx_name_list) 
	{
		string qx_name = name;
		for(int i = 0; i < allQxZoning[qx_name].size(); i++)
		{
			// 个数超过设定值，YS改为NG
			if(allQxZoning[qx_name][i].judgeNum()){
				for(int j = 0; j < allQxZoning[qx_name][i].qxList.size(); j++)
				{
					int qxidx = allQxZoning[qx_name][i].qxList[j].qxidx;
					cv::Point pCenter = allQxZoning[qx_name][i].qxList[j].pcenter;
					QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
					std::shared_ptr<DetLog> pQxLog = pDetResult->pQx_ErrorList->at(qxidx).detlog;

					pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "YS to NG", " name: %s, idx: %d	|	Index %d / %d > %d", qx_name.c_str(), qxidx, j + 1, allQxZoning[qx_name][i].qxList.size(), allQxZoning[qx_name][i].judge_num);

					// pQxLog->bPrintStr = true;
					cv::Rect roi = QX_info->roi;
					float JudgArea = QX_info->JudgArea;
					float JudgArea_second = QX_info->JudgArea_second;
					float flen = QX_info->flen;
					float fbreadth = QX_info->fbreadth;
					float grayDis = QX_info->grayDis;
					int energy = QX_info->energy;
					float fupS = QX_info->fUpIou;
					int maxValue = QX_info->maxValue;
					float density = QX_info->density;
					int QX_whiteBLACK = QX_info->whiteOrBlack;
					int config_qx_type = QX_info->nconfig_qx_type;
					std::string qx_name = CONFIG_QX_NAME_Names[config_qx_type];
					std::string qx_wb = WHITE_BLCAK_Names[QX_whiteBLACK];
					
					QX_info->result = QX_RESULT_TYPE_NG;
					QX_info->result_name = QX_RESULT_TYPE_Names[QX_info->result];
					std::string resultType = QX_info->result_name;
					m_CheckResult_shareP->nresult = 1;

					// 生成图片
					QXImageResult tem;
					tem.idx = qxidx;
					cv::Rect CutRoi = GetCutRoi(roi, pImageResult->detImg);
					// CheckUtil::printROI(CutRoi, "CutRoi");
					cv::Size sz = cv::Size(QX_SAMLLIMG_WIDTH, QX_SAMLLIMG_HEIGHT);
				
					// 缺陷小图直接取自原图裁剪区(保持原图通道 -> 真实彩色);按仿射矩阵从原图取回,
					// ReJson/异常时退回检测图
					{
						const cv::Mat &srcImg = pImageResult->result->in_shareImage->img;
						bool bGot = false;
						if (pImageResult->result->in_shareImage->Det_Mode != DET_MODE_ReJson)
						{
							bGot = WarpSrcCutImg(srcImg, pDetResult->detToSrcMat, CutRoi, tem.srcImg);
						}
						if (!bGot)
						{
							int nOffsetX = (pImageResult->result->in_shareImage->Det_Mode != DET_MODE_ReJson) ? pDetResult->CutRoi.x : 0;
							int nOffsetY = (pImageResult->result->in_shareImage->Det_Mode != DET_MODE_ReJson) ? pDetResult->CutRoi.y : 0;
							cv::Rect srcCanvasRoi(CutRoi.x + nOffsetX, CutRoi.y + nOffsetY, CutRoi.width, CutRoi.height);
							if (!srcImg.empty() && CheckUtil::RoiInImg(srcCanvasRoi, srcImg))
							{
								tem.srcImg = srcImg(srcCanvasRoi).clone();
							}
							else
							{
								tem.srcImg = pImageResult->detImg(CutRoi).clone();
							}
						}
					}
					cv::resize(tem.srcImg, tem.resizeImg, sz);
				
					int nqx_type = ConfigTypeToResultType(config_qx_type);
					tem.type = nqx_type;
					tem.area = JudgArea;
					tem.energy = energy;
					tem.hj = grayDis;
					tem.max_v = maxValue;
					tem.strTypeName = QX_Result_Names[nqx_type];
					tem.qx_Code = QX_Result_Code[nqx_type];
					tem.qx_level = QX_info->qx_level;
					// 缺陷 roi 映射回原图(按仿射矩阵映射, 否则按 CutRoi 平移)
					{
						const cv::Mat &srcSizeImg = pImageResult->result->in_shareImage->img;
						tem.srcImgroi = DetRoiToSrcRoi(pDetResult->detToSrcMat, roi, pDetResult->CutRoi,
												   srcSizeImg.empty() ? pImageResult->detImg.size() : srcSizeImg.size());
					}
					tem.len = flen;
					tem.breadth = fbreadth;
					tem.qx_type = 0;
					tem.fScore = 0;
					tem.density = 0;
				
					tem.resizeImgroi.x = roi.x * fs_resize_x;
					tem.resizeImgroi.width = roi.width * fs_resize_x;
					tem.resizeImgroi.y = roi.y * fs_resize_y;
					tem.resizeImgroi.height = roi.height * fs_resize_y;
				
					tem.x_pixel = roi.x + roi.width * 0.5;
					tem.y_pixel = roi.y + roi.height * 0.5;
				
					tem.x_mm = tem.x_pixel * m_fImgage_Scale_X;
					tem.y_mm = tem.y_pixel * m_fImgage_Scale_Y;
				
					tem.CutImgroi = roi;
					tem.CutImgroi.x -= CutRoi.x;
					tem.CutImgroi.y -= CutRoi.y;
					
					m_CheckResult_shareP->defectResultList[nqx_type].nresult = 1;
					m_CheckResult_shareP->defectResultList[nqx_type].keyName = QX_Result_Names[nqx_type];
					m_CheckResult_shareP->defectResultList[nqx_type].keyCode = QX_Result_Code[nqx_type];
					m_CheckResult_shareP->defectResultList[nqx_type].num++;
					if (m_CheckResult_shareP->nresult <= ERROR_TYPE_OK)
					{
						m_CheckResult_shareP->nresult = nqx_type;
					}
				
					GetAIDetImg(pImageResult, pCenter, tem.AI_in_Img, tem.AI_out_img);
					m_CheckResult_shareP->qxImageResult.push_back(tem);
				}
			}		
		}
		
	}

	for (int qxidx = 0; qxidx < qxNum; qxidx++)
	{

		QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
		switch (QX_info->result)
		{
		case QX_RESULT_TYPE_OK:
			pImageResult->Ok_num++;
			break;
		case QX_RESULT_TYPE_NG:
			pImageResult->NG_num++;
			break;
		case QX_RESULT_TYPE_YS:
			pImageResult->YS_num++;
			break;
		case QX_RESULT_TYPE_NoJduge:
			pImageResult->NoJudge_num++;
			break;
		default:
			pImageResult->NoJudge_num++;
			break;
		}
	}

	pImageLog->AddCheckstr(PrintLevel_1, DET_LOG_LEVEL_3, "Param Judge", "img %s ====================End ng %d ys %d ok %d nojudge %d ",
						   pImageResult->strChannel.c_str(), pImageResult->NG_num, pImageResult->YS_num, pImageResult->Ok_num, pImageResult->NoJudge_num);

	return 0;
}

int ImageResultJudge::UpdateConfig()
{
	if (m_pAnalysisyConfig->commonCheckConfig.nodeConfigArr.size() > 0)
	{
		m_pCommonAnalysisyConfig = &m_pAnalysisyConfig->commonCheckConfig.nodeConfigArr.at(0);
		m_pRegionAnalysisyParam = &m_pCommonAnalysisyConfig->regionConfigArr.at(0);
		m_pBasicConfig = &m_pAnalysisyConfig->commonCheckConfig.baseConfig;
	}
	else
	{
		m_pCommonAnalysisyConfig = NULL;
	}

	GetParamidx();
	UpdateImgageScale();
	return 0;
}

int ImageResultJudge::DrawResult(std::shared_ptr<ImageAllResult> pImageResult)
{
	std::shared_ptr<txtDrawBackgroundk> txtbackgroundk = std::make_shared<txtDrawBackgroundk>();
	if (!ptr_thread_Draw)
	{
		ptr_thread_Draw = std::make_shared<std::thread>(std::bind(&ImageResultJudge::ThreadDraw, this));
	}

	float fs_resize_x = pImageResult->fscale_detToresult_x;
	float fs_resize_y = pImageResult->fscale_detToresult_x;

	std::shared_ptr<CheckResult> m_CheckResult_shareP = pImageResult->result; // 返回结果
	std::vector<cv::Rect> m_drawList;
	if (m_CheckResult_shareP->resultimg.empty())
	{
		return 0;
	}

	cv::Scalar color_NG = cv::Scalar(0, 0, 255);
	cv::Scalar color_Ys = cv::Scalar(0, 255, 255);
	cv::Scalar color_Nojudge = cv::Scalar(0, 255, 0);

	long t1 = CheckUtil::getcurTime();
	for (int i = 0; i < m_CheckResult_shareP->qxImageResult.size(); i++)
	{
		std::shared_ptr<DrawInfo> draw_qx = std::make_shared<DrawInfo>();

		QXImageResult *pqx = &m_CheckResult_shareP->qxImageResult.at(i);
		cv::Rect drawroi = pqx->resizeImgroi;

		cv::Point cp = cv::Point(drawroi.x + drawroi.width * .5, drawroi.y + drawroi.height * 0.5);
		int r = drawroi.width;
		if (drawroi.height > r)
		{
			r = drawroi.height;
		}
		r += 10;
		draw_qx->dr = r;
		draw_qx->cp = cp;
		draw_qx->color = color_NG;
		draw_qx->drawImg = m_CheckResult_shareP->resultimg;
		draw_qx->type = Draw_circle;
		sendTask(draw_qx);

		std::shared_ptr<DrawInfo> draw_str = std::make_shared<DrawInfo>();
		draw_str->drawImg = m_CheckResult_shareP->resultimg;
		draw_str->type = Draw_str;
		draw_str->color = color_NG;
		draw_str->cp = cp;
		draw_str->txtP = cv::Point(draw_qx->cp.x + r, draw_qx->cp.y - r);
		draw_str->txtsize = 0.5;
		draw_str->txtbackgroundk = txtbackgroundk;
		cv::Rect srcroi = pqx->srcImgroi;
		cv::Point srccp = cv::Point(srcroi.x + srcroi.width * .5, srcroi.y + srcroi.height * 0.5);

		char buffer[128];
		{
			std::string text = std::to_string(pqx->idx) + ":" + pqx->strTypeName;
			draw_str->strlist.push_back(text);
		}
		{
			sprintf(buffer, " center:%d %d", srccp.x, srccp.y);
			std::string text = buffer;
			draw_str->strlist.push_back(text);
		}
		{
			sprintf(buffer, " len %0.2f A: %0.2f ", pqx->len, pqx->area);
			std::string text = buffer;
			draw_str->strlist.push_back(text);
		}
		{
			sprintf(buffer, " breadth %0.2f A: %0.2f ", pqx->breadth, pqx->area);
			std::string text = buffer;
			draw_str->strlist.push_back(text);
		}
		{
			sprintf(buffer, " E:%0.2f hj %0.2f", pqx->energy, pqx->hj);
			std::string text = buffer;
			draw_str->strlist.push_back(text);
		}
		sendTask(draw_str);
		// 在小图上绘制
		{
			cv::Rect drawroi = pqx->CutImgroi;
			cv::Point cp = cv::Point(drawroi.x + drawroi.width * .5, drawroi.y + drawroi.height * 0.5);
			int r = drawroi.width;
			if (drawroi.height > r)
			{
				r = drawroi.height;
			}
			r += 10;
			std::shared_ptr<DrawInfo> draw_qx_small = std::make_shared<DrawInfo>();
			draw_qx_small->drawImg = pqx->srcImg;
			draw_qx_small->cp = cp;
			draw_qx_small->dr = r;
			draw_qx_small->color = color_NG;
			draw_qx_small->type = Draw_circle;
			sendTask(draw_qx_small);
			std::shared_ptr<DrawInfo> draw_str_small = std::make_shared<DrawInfo>();
			draw_str_small->drawImg = pqx->srcImg;
			draw_str_small->type = Draw_str;
			draw_str_small->color = color_NG;
			draw_str_small->txtP = cp;
			draw_str_small->cp = cp;
			draw_str_small->strlist.assign(draw_str->strlist.begin(), draw_str->strlist.end());
			draw_str_small->txtsize = 0.45;
			sendTask(draw_str_small);
		}
	}
	for (int i = 0; i < m_CheckResult_shareP->YS_ImageResult.size(); i++)
	{
		std::shared_ptr<DrawInfo> draw_qx = std::make_shared<DrawInfo>();

		QXImageResult *pqx = &m_CheckResult_shareP->YS_ImageResult.at(i);
		cv::Rect drawroi = pqx->resizeImgroi;

		cv::Point cp = cv::Point(drawroi.x + drawroi.width * .5, drawroi.y + drawroi.height * 0.5);
		int r = drawroi.width;
		if (drawroi.height > r)
		{
			r = drawroi.height;
		}
		r += 10;
		draw_qx->dr = r;
		draw_qx->cp = cp;
		draw_qx->color = color_Ys;
		draw_qx->drawImg = m_CheckResult_shareP->resultimg;
		draw_qx->type = Draw_circle;
		sendTask(draw_qx);

		std::shared_ptr<DrawInfo> draw_str = std::make_shared<DrawInfo>();
		draw_str->drawImg = m_CheckResult_shareP->resultimg;
		draw_str->type = Draw_str;
		draw_str->color = color_Ys;
		draw_str->cp = cp;
		draw_str->txtP = cv::Point(draw_qx->cp.x + r, draw_qx->cp.y - r);
		draw_str->txtbackgroundk = txtbackgroundk;
		draw_str->txtsize = 0.5;
		cv::Rect srcroi = pqx->srcImgroi;
		cv::Point srccp = cv::Point(srcroi.x + srcroi.width * .5, srcroi.y + srcroi.height * 0.5);

		char buffer[128];
		{
			std::string text = std::to_string(pqx->idx);
			draw_str->strlist.push_back(text);
		}
		// {
		// 	sprintf(buffer, " center:%d %d", srccp.x, srccp.y);
		// 	std::string text = buffer;
		// 	draw_str->strlist.push_back(text);
		// }
		// {
		// 	sprintf(buffer, " len %0.2f A: %0.2f ", pqx->len, pqx->area);
		// 	std::string text = buffer;
		// 	draw_str->strlist.push_back(text);
		// }
		// {
		// 	sprintf(buffer, " E:%0.2f hj %0.2f", pqx->energy, pqx->hj);
		// 	std::string text = buffer;
		// 	draw_str->strlist.push_back(text);
		// }
		sendTask(draw_str);
		// 在小图上绘制
		{
			cv::Rect drawroi = pqx->CutImgroi;
			cv::Point cp = cv::Point(drawroi.x + drawroi.width * .5, drawroi.y + drawroi.height * 0.5);
			int r = drawroi.width;
			if (drawroi.height > r)
			{
				r = drawroi.height;
			}
			r += 10;
			std::shared_ptr<DrawInfo> draw_qx_small = std::make_shared<DrawInfo>();
			draw_qx_small->drawImg = pqx->srcImg;
			draw_qx_small->cp = cp;
			draw_qx_small->dr = r;
			draw_qx_small->color = color_Ys;
			draw_qx_small->type = Draw_circle;
			sendTask(draw_qx_small);
			std::shared_ptr<DrawInfo> draw_str_small = std::make_shared<DrawInfo>();
			draw_str_small->drawImg = pqx->srcImg;
			draw_str_small->type = Draw_str;
			draw_str_small->color = color_Ys;
			draw_str_small->txtP = cp;
			draw_str_small->cp = cp;
			draw_str_small->strlist.assign(draw_str->strlist.begin(), draw_str->strlist.end());
			draw_str_small->txtsize = 0.45;
			sendTask(draw_str_small);
		}
	}

	std::shared_ptr<One_Image_CheckResult_> pDetResult = pImageResult->pDetResult; // 检测结果

	int qxNum = pDetResult->pQx_ErrorList->size();

	for (int qxidx = 0; qxidx < qxNum; qxidx++)
	{
		QX_ERROR_INFO_ *QX_info = &pDetResult->pQx_ErrorList->at(qxidx);
		// 只绘制 未分析 或分析失败的。
		if (QX_info->result != QX_RESULT_TYPE_NoJduge)
		{
			continue;
		}

		std::shared_ptr<DrawInfo> draw_qx = std::make_shared<DrawInfo>();

		cv::Rect roi = QX_info->roi;
		cv::Rect drawroi;

		drawroi.x = roi.x * fs_resize_x;
		drawroi.width = roi.width * fs_resize_x;
		drawroi.y = roi.y * fs_resize_y;
		drawroi.height = roi.height * fs_resize_y;

		cv::Point cp = cv::Point(drawroi.x + drawroi.width * .5, drawroi.y + drawroi.height * 0.5);
		int r = drawroi.width;
		if (drawroi.height > r)
		{
			r = drawroi.height;
		}
		r += 10;
		draw_qx->cp = cp;
		draw_qx->dr = r;
		draw_qx->color = color_Nojudge;
		draw_qx->drawImg = m_CheckResult_shareP->resultimg;
		draw_qx->type = Draw_circle;
		sendTask(draw_qx);

		std::shared_ptr<DrawInfo> draw_str = std::make_shared<DrawInfo>();
		draw_str->drawImg = m_CheckResult_shareP->resultimg;
		draw_str->type = Draw_str;
		draw_str->color = color_Nojudge;
		draw_str->cp = cp;
		draw_str->txtP = cv::Point(draw_qx->cp.x + r, draw_qx->cp.y - r);
		draw_str->txtbackgroundk = txtbackgroundk;
		draw_str->txtsize = 0.5;

		char buffer[128];
		{
			std::string text = std::to_string(QX_info->Idx);
			draw_str->strlist.push_back(text);
		}
		sendTask(draw_str);
	}
	long t2 = CheckUtil::getcurTime();

	// 等待绘制完成
	WaiteDrawComplate();
	long t3 = CheckUtil::getcurTime();

	// printf("=====draw=all  %ld send  %ld wait %ld \n", t3 - t1, t2 - t1, t3 - t2);
	return 0;
}

int ImageResultJudge::GetParamidx()
{
	int region = 0;
	if (m_pCommonAnalysisyConfig == NULL || m_pCommonAnalysisyConfig->regionConfigArr.size() <= 0)
	{
		return 1;
	}

	CheckConfig_Regions_type *p = &m_pCommonAnalysisyConfig->regionConfigArr.at(region).checkConfig_Regions_type[0];
	for (int iqx = 0; iqx < CONFIG_QX_NAME_count; iqx++)
	{
		m_QxInParamListIdx[iqx] = -1;
		std::string strqx_name = CONFIG_QX_NAME_Names[iqx];
		for (int i = 0; i < p->checkConfig_Regions_Param.size(); i++)
		{
			std::string strconfig_name = p->checkConfig_Regions_Param[i].param_name;

			// getchar();
			if (strqx_name == strconfig_name)
			{
				printf("strqx_name %s  strconfig_name %s \n", strqx_name.c_str(), strconfig_name.c_str());
				m_QxInParamListIdx[iqx] = i;
				break;
			}
		}
	}
	// getchar();
	return 0;
}

int ImageResultJudge::addInDrawBlob(int errortype, int blobidx, QX_ERROR_INFO_ *QX_info, float fs_resize_x, float fs_resize_y)
{
	return 0;
}

int ImageResultJudge::ConfigTypeToResultType(int nconfigType)
{

	// 缺陷类型(CONFIG_QX_NAME_)与结果列表(QX_Result_Names/QX_Result_Code)按配置顺序一一对应，直接按下标映射
	if (nconfigType >= 0 && nconfigType < CONFIG_QX_NAME_count &&
		nconfigType < (int)QX_Result_Names.size())
	{
		return nconfigType;
	}
	return ERROR_TYPE_OK;
}

int ImageResultJudge::sendTask(std::shared_ptr<DrawInfo> task)
{
	{
		std::lock_guard<std::mutex> lock(m_task_mutex_);
		m_DrawInfoList.push(task);
	}
	m_task_cv_.notify_one();
	return 0;
}

std::shared_ptr<ImageResultJudge::DrawInfo> ImageResultJudge::GetTask()
{
	std::shared_ptr<DrawInfo> task;
	{
		std::unique_lock<std::mutex> lock(m_task_mutex_);
		m_task_cv_.wait(lock, [this]()
						{ return !m_DrawInfoList.empty(); });

		task = std::move(m_DrawInfoList.front());
		m_DrawInfoList.pop();
	}

	return task;
}

void ImageResultJudge::ThreadDraw()
{
	while (!m_bExit)
	{
		std::this_thread::sleep_for(std::chrono::milliseconds(0));
		// 等待是否有任务
		std::shared_ptr<ImageResultJudge::DrawInfo> draw = GetTask();

		// 把任务发送给对应的任务处理函数进行处理
		DrawResultTask(draw);
		m_drawComplate_cv_.notify_all();
	}
}

int ImageResultJudge::DrawResultTask(std::shared_ptr<ImageResultJudge::DrawInfo> task)
{

	if (task->type == Draw_circle)
	{
		cv::circle(task->drawImg, task->cp, task->dr, CheckUtil::GetDrawColor(task->drawImg, task->color));
		if (task->txtbackgroundk)
		{
			task->txtbackgroundk->txtDrawRoi.push_back(task->roi);
		}
	}
	if (task->type == Draw_rect)
	{
		cv::rectangle(task->drawImg, task->roi, CheckUtil::GetDrawColor(task->drawImg, task->color));
		if (task->txtbackgroundk)
		{
			task->txtbackgroundk->txtDrawRoi.push_back(task->roi);
		}
	}
	if (task->type == Draw_str)
	{
		int fontFace = cv::FONT_HERSHEY_SIMPLEX;
		double fontScale = task->txtsize;
		int thickness = 0.5;
		int baseline = 0;

		// 行高（根据字体大小计算）

		int txtH = cv::getTextSize("Test", fontFace, fontScale, thickness, &baseline).height;
		int lineHeight = txtH + 5;
		// 起始位置
		int x = task->txtP.x;
		int y = task->txtP.y;

		int height = 0;
		int maxw = 0;
		for (const auto &txt : task->strlist)
		{
			// 计算文本大小
			cv::Size textSize = cv::getTextSize(txt, fontFace, fontScale, thickness, &baseline);
			if (textSize.width > maxw)
			{
				maxw = textSize.width;
			}
			height += lineHeight; // 下一行
		}
		cv::Rect rtxt = cv::Rect(x, y - txtH, maxw, height);
		cv::Rect r = cv::Rect(x, y, maxw, height);
		if (task->txtbackgroundk)
		{

			cv::Rect newr = task->txtbackgroundk->findNonOverlappingPos(rtxt);
			task->txtbackgroundk->txtDrawRoi.push_back(newr);
			rtxt = newr;
			r = rtxt;
			r.y += txtH;
		}

		// 左边界
		if (r.x < 0)
			r.x = 0;
		// 上边界
		if (r.y < 0)
			r.y = 0;
		// 右边界
		if (r.x + r.width > task->drawImg.cols)
			r.x = task->drawImg.cols - r.width;
		// 下边界
		if (r.y + r.height > task->drawImg.rows)
			r.y = task->drawImg.rows - r.height;

		height = 0;
		for (const auto &txt : task->strlist)
		{

			// 画文字
			cv::putText(task->drawImg, txt, cv::Point(r.x, r.y + height),
						fontFace, fontScale, CheckUtil::GetDrawColor(task->drawImg, task->color), thickness);
			height += lineHeight; // 下一行
		}
		// cv::rectangle(task->drawImg, rtxt, cv::Scalar(255, 0, 0));

		cv::Point p(r.x, r.y);
		if (task->cp.x - r.x > 30 || task->cp.y - r.y > 30)
		{
			cv::line(task->drawImg, p, task->cp, CheckUtil::GetDrawColor(task->drawImg, cv::Scalar(80, 0, 200)));
		}

		// cv::circle(task->drawImg, task->cp, 3, task->color);
	}

	return 0;
}

int ImageResultJudge::WaiteDrawComplate()
{
	{
		std::unique_lock<std::mutex> lock(m_task_mutex_);
		m_drawComplate_cv_.wait(lock, [this]()
								{ return m_DrawInfoList.empty(); });
	}
	return 0;
}