#include "QX_Merge_Analysis.h"
#include <memory>
#include <string>
#include <mutex>
#include <thread>
#include <chrono>
#include "CheckUtil.hpp"
#include "CheckConfigDefine.h"

QX_Merge_Analysis::QX_Merge_Analysis()
{
	m_bExit = false;
	Clear();
	StartThread(0);
}

QX_Merge_Analysis::~QX_Merge_Analysis()
{
	StopThread();
}

std::shared_ptr<QX_Merge_Analysis> QX_Merge_Analysis::GetInstance()
{
	std::shared_ptr<QX_Merge_Analysis> instance = std::make_shared<QX_Merge_Analysis>();
	return instance;
}
int QX_Merge_Analysis::Clear()
{
	m_pdetlogList.clear();
	m_statusList.clear();
	{
		std::lock_guard<std::mutex> lock(mtx_correlatedQx);
		m_correlatedQxMap.clear();
	}

	return 0;
}
int QX_Merge_Analysis::AddCamer(std::string cameraName)
{
	setSendStatus(cameraName, RUN_STATUS_NULL);
	for (auto &it : m_statusList)
	{
		m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "AddCamer %s %d", it.first.c_str(), it.second);
	}
	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "AddCamer %s %s", cameraName.c_str(),CheckUtil::getCurTimeHMS().c_str());

	return 0;
}
int QX_Merge_Analysis::InitData()
{
	m_reultList.Init();
	{
		std::lock_guard<std::mutex> lock(mtx_correlatedQx);
		m_correlatedQxMap.clear();
	}
	m_pMergedetlog = std::make_shared<DetLog>();
	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "InitData %s",CheckUtil::getCurTimeHMS().c_str());

	{
		std::lock_guard<std::mutex> lock(mtx_QXList);
		for (int i = 0; i < QX_ANALYSIS_COUNT; i++)
		{
			m_QXList[i].Init();
		}
	}
	return 0;
}

int QX_Merge_Analysis::GetReusult(QX_Analysis_Result_List *&presult)
{
	presult = &m_reultList;
	return 0;
}

void QX_Merge_Analysis::SetConfig(std::string cameraName, int qxidx,
								  QXAnalysis_Config config)
{
	if (cameraName == "")
	{
		return;
	}
	// if (cameraName != QX_MEREGE_CONFIG_CAMERA_NAME)
	// {
	// 	return;
	// }

	ALL_QX_ParamList *pqxConfigList = nullptr;
	{
		std::lock_guard<std::mutex> lock(mtx_ConfigList); //
		pqxConfigList = &m_ConfigList[qxidx];
		pqxConfigList->configlsit.push_back(config);
	}
	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "SetConfig cameraName %s qxidx %d ", cameraName.c_str(), qxidx);
}

void QX_Merge_Analysis::InitConfig(std::string cameraName)
{
	// if (cameraName != QX_MEREGE_CONFIG_CAMERA_NAME)
	// {
	// 	return;
	// }
	{
		std::lock_guard<std::mutex> lock(mtx_ConfigList);
		for (int i = 0; i < QX_ANALYSIS_COUNT; i++)
		{
			m_ConfigList[i].Init();
		}
	}
	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "QX_Merge_Analysis", "InitConfig cameraName %s   ", cameraName.c_str());
}

void QX_Merge_Analysis::SetbaseCheckFunction(std::string cameraName, ALLChannelCheckFunction *pChannelFuntion, BaseCheckFunction *pbaseCheckFunction)
{
	if (cameraName == "")
	{
		return;
	}
	// if (cameraName != QX_MEREGE_CONFIG_CAMERA_NAME)
	// {
	// 	return;
	// }
	m_pChannelFuntion = pChannelFuntion;
	m_pbaseCheckFunction = pbaseCheckFunction;
}

int QX_Merge_Analysis::ConfigTypeToQXAnalysis(int nconfigType)
{
	int QXAnalysis_type = -1;
	switch (nconfigType)
	{
	case CONFIG_QX_NAME_POL_Cell:
		QXAnalysis_type = QX_ANALYSIS_POL_CELL; // 异物
		break;
	case CONFIG_QX_NAME_AD:
		QXAnalysis_type = QX_ANALYSIS_AD; // 暗点
		break;
	case CONFIG_QX_NAME_Scratch_L1:
	case CONFIG_QX_NAME_Scratch_L2:
		QXAnalysis_type = QX_ANALYSIS_Scratch; // 划伤
		break;
	case CONFIG_QX_NAME_X_line:
	case CONFIG_QX_NAME_Y_line:
	case CONFIG_QX_NAME_line:
	case CONFIG_QX_NAME_Fangge:
		QXAnalysis_type = QX_ANALYSIS_LINE; // 线类
		break;
	case CONFIG_QX_NAME_MTX:
		QXAnalysis_type = QX_ANALYSIS_MTX; // MTX
		break;
		// case CONFIG_QX_NAME_Broken_line:
		// 	QXAnalysis_type = QX_ANALYSIS_ALL, // MTX&异物
		// 		break;

	default:
		QXAnalysis_type = -1;
		break;
	}
	return QXAnalysis_type;
}
bool QX_Merge_Analysis::Idx(int qxidx)
{
	if (qxidx < 0 || qxidx >= QX_ANALYSIS_COUNT)
	{
		return false;
	}
	return true;
}
bool QX_Merge_Analysis::AddQxInfo(int qxidx, QX_Info qxinfo, std::shared_ptr<DetLog> plog, std::shared_ptr<DetLog> pchannelLog)
{
	std::string channel_name = qxinfo.channel_name;
	std::string cam_name = qxinfo.camera_name;
	ALL_QX_ParamList *pconfigList = nullptr;
	{
		std::lock_guard<std::mutex> lock(mtx_ConfigList);
		pconfigList = &m_ConfigList[qxidx];
	}

	if (pconfigList == nullptr)
	{
		plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "cam_name = %s config error",
						  cam_name.c_str());
		return false;
	}
	if (!Idx(qxidx))
	{
		plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "qxidx  error");
		return false;
	}

	// 初步筛选一次
	bool badd = false;
	{
		std::lock_guard<std::mutex> lock(mtx_ConfigList);
		for (int i = 0; i < (int)pconfigList->configlsit.size(); i++)
		{
			QXAnalysis_Config *pconfig = &pconfigList->configlsit.at(i);
			// 面积 灰阶满足要求
			if (qxinfo.area >= pconfig->area &&
				qxinfo.hj >= pconfig->hj &&
				qxinfo.length >= pconfig->len &&
				qxinfo.density >= pconfig->density)
			{
				badd = true;
			}
			plog->AddCheckstr(PrintLevel_3, 3, "preA", "add = %s congfig idx %d / %d ", BOOL_TO_STR(badd), i, (int)pconfigList->configlsit.size());
			plog->AddCheckstr(PrintLevel_4, 3, "Area", "%s -> %f %s %f ",
							  BOOL_TO_STR(qxinfo.area >= pconfig->area), qxinfo.area, BOOL_TO_ThanLess(qxinfo.area >= pconfig->area), pconfig->area);
			plog->AddCheckstr(PrintLevel_4, 3, "HJ", "%s -> %f %s %d ",
							  BOOL_TO_STR(qxinfo.hj >= pconfig->hj), qxinfo.hj, BOOL_TO_ThanLess(qxinfo.hj >= pconfig->hj), pconfig->hj);
			plog->AddCheckstr(PrintLevel_4, 3, "Len", "%s -> %f %s %f ",
							  BOOL_TO_STR(qxinfo.length >= pconfig->len), qxinfo.length, BOOL_TO_ThanLess(qxinfo.length >= pconfig->len), pconfig->len);
			plog->AddCheckstr(PrintLevel_4, 3, "md", "%s -> %f %s %f ",
							  BOOL_TO_STR(qxinfo.density >= pconfig->density), qxinfo.density, BOOL_TO_ThanLess(qxinfo.density >= pconfig->density), pconfig->density);

			if (badd)
			{
				break;
				/* code */
			}
		}
	}
	{
		std::lock_guard<std::mutex> lock(mtx_QXList);

		if (badd)
		{
			QX_channel_List *pQXChannelList = nullptr;
			for (auto &config : m_QXList[qxidx].channelqxList)
			{
				if (config.channel_name == channel_name)
				{
					pQXChannelList = &config;
					break;
				}
			}
			if (pQXChannelList == nullptr)
			{
				plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "new channel_name %s ", channel_name.c_str());
				QX_channel_List tempchannel;
				tempchannel.channel_name = channel_name;
				tempchannel.pChannelDetlog = pchannelLog;
				tempchannel.qxList.push_back(qxinfo);

				m_QXList[qxidx].channelqxList.push_back(tempchannel);
			}
			else
			{
				plog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "have channel_name %s ", channel_name.c_str());
				pQXChannelList->pChannelDetlog2 = pchannelLog;
				pQXChannelList->qxList.push_back(qxinfo);
			}

			m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "AddQxInfo", "m_QXList[%d].channelqxList.size() = %d cam %s channel %s  %s",
										qxidx, (int)m_QXList[qxidx].channelqxList.size(), cam_name.c_str(), channel_name.c_str(), CheckUtil::getCurTimeHMS().c_str());
		}
	}
	return badd;
}

bool QX_Merge_Analysis::setSendStatus(std::string cameraName, RUN_STATUS_ status)
{
	{
		std::lock_guard<std::mutex> lock(mtx_status);
		m_statusList[cameraName] = status;
	}
	cv_status.notify_all();
	return false;
}

/**
 * @brief 判断缺陷配置类型是否为脏污(dirty)
 * @param nconfigType 缺陷配置类型 CONFIG_QX_NAME_
 * @return bool 是脏污返回true
 */
static bool IsDirtyConfigType(int nconfigType)
{
	return nconfigType == CONFIG_QX_NAME_Dirty_L0 ||
		   nconfigType == CONFIG_QX_NAME_Dirty_L1 ||
		   nconfigType == CONFIG_QX_NAME_Dirty_L2;
}

/**
 * @brief 判断关联通道名称是否需要参与判断(为空或NONE则不参与)
 * @param strChannelName 关联通道名称
 * @return bool 需要判断返回true
 */
static bool IsValidCorrelatedChannel(const std::string &strChannelName)
{
	if (strChannelName == "")
	{
		return false;
	}
	if (CheckUtil::compareIgnoreCase(strChannelName, "NONE"))
	{
		return false;
	}
	return true;
}

bool QX_Merge_Analysis::AddCorrelatedQxInfo(Correlated_Qx_Info_ qxinfo, std::shared_ptr<DetLog> plog)
{
	// 防御：通道为空或ROI非法时不登记，避免无效数据参与后续判断
	if (qxinfo.channel_name == "" || qxinfo.product_roi.width <= 0 || qxinfo.product_roi.height <= 0)
	{
		return false;
	}

	{
		std::lock_guard<std::mutex> lock(mtx_correlatedQx);
		std::vector<Correlated_Qx_Info_> &qxList = m_correlatedQxMap[qxinfo.channel_name];
		// 同一相机同一通道同一位置只登记一次，避免同一缺陷被重复登记
		for (int i = 0; i < (int)qxList.size(); i++)
		{
			if (qxList.at(i).camera_name == qxinfo.camera_name &&
				qxList.at(i).config_qx_type == qxinfo.config_qx_type &&
				qxList.at(i).product_roi == qxinfo.product_roi)
			{
				return true;
			}
		}
		qxList.push_back(qxinfo);
	}

	if (plog)
	{
		plog->AddCheckstr(PrintLevel_3, 3, "AddCorrelatedQxInfo", "add %s", qxinfo.GetInfo().c_str());
	}
	if (m_pMergedetlog)
	{
		m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "AddCorrelatedQxInfo", "add %s", qxinfo.GetInfo().c_str());
	}
	return true;
}

bool QX_Merge_Analysis::IsOverlapDirtyInCorrelatedChannel(const std::vector<std::string> &correlated_channels,
														  const std::string &cur_channel_name,
														  const std::string &cur_camera_name,
														  const cv::Rect &qx_product_roi,
														  int roi_expand,
														  float iou_threshold,
														  std::shared_ptr<DetLog> plog)
{
	// 未配置关联通道(NONE/空)时不需要判断
	if (correlated_channels.empty())
	{
		return false;
	}
	// 防御：ROI非法时不判断，避免无效计算与除零
	if (qx_product_roi.width <= 0 || qx_product_roi.height <= 0)
	{
		return false;
	}

	// 拷贝出需要比较的脏污缺陷列表，避免在锁内做IoU计算
	std::vector<Correlated_Qx_Info_> dirtyList;
	{
		std::lock_guard<std::mutex> lock(mtx_correlatedQx);
		for (int i = 0; i < (int)correlated_channels.size(); i++)
		{
			const std::string &channel_name = correlated_channels.at(i);
			if (!IsValidCorrelatedChannel(channel_name))
			{
				continue;
			}
			auto it = m_correlatedQxMap.find(channel_name);
			if (it == m_correlatedQxMap.end())
			{
				continue;
			}
			for (int j = 0; j < (int)it->second.size(); j++)
			{
				if (IsDirtyConfigType(it->second.at(j).config_qx_type))
				{
					dirtyList.push_back(it->second.at(j));
				}
			}
		}
	}

	if (dirtyList.empty())
	{
		return false;
	}

	// 与 Analysis_AD_Bind 中主次通道判断保持一致：双方均按 AD_Expand 扩张后再计算 IOU
	cv::Rect roi_expanded(qx_product_roi.x - roi_expand, qx_product_roi.y - roi_expand,
						  qx_product_roi.width + roi_expand * 2, qx_product_roi.height + roi_expand * 2);

	for (int i = 0; i < (int)dirtyList.size(); i++)
	{
		cv::Rect dirty_roi = dirtyList.at(i).product_roi;
		cv::Rect dirty_expanded(dirty_roi.x - roi_expand, dirty_roi.y - roi_expand,
								dirty_roi.width + roi_expand * 2, dirty_roi.height + roi_expand * 2);

		float fiou = CheckUtil::CalIoU(roi_expanded, dirty_expanded);

		if (plog)
		{
			plog->AddCheckstr(PrintLevel_3, 3, "CorrelatedDirty",
							  "cur %s cam %s roi %s <-> dirty %s roi %s expand %d iou %f",
							  cur_channel_name.c_str(), cur_camera_name.c_str(),
							  CheckUtil::GetRectString(qx_product_roi).c_str(),
							  dirtyList.at(i).channel_name.c_str(),
							  CheckUtil::GetRectString(dirty_roi).c_str(),
							  roi_expand, fiou);
		}
		// IOU 为 NaN(ROI 非法导致的除零)时比较结果为 false，不会误抑制 NG
		if (fiou > iou_threshold)
		{
			if (plog)
			{
				plog->AddCheckstr(PrintLevel_1, 3, "CorrelatedDirty",
								  "cur %s cam %s roi %s overlap dirty %s cam %s roi %s expand %d iou %f > %f",
								  cur_channel_name.c_str(), cur_camera_name.c_str(),
								  CheckUtil::GetRectString(qx_product_roi).c_str(),
								  dirtyList.at(i).channel_name.c_str(), dirtyList.at(i).camera_name.c_str(),
								  CheckUtil::GetRectString(dirty_roi).c_str(),
								  roi_expand, fiou, iou_threshold);
			}
			return true;
		}
	}

	return false;
}

/**
 * @brief 等待所有任务完成
 * @param timeoutMs 超时时间（毫秒）
 * @return bool 如果所有任务在超时前完成返回true，否则返回false
 */
bool QX_Merge_Analysis::waitComplete(int timeoutMs)
{
	// 使用互斥锁保护共享资源m_statusList
	std::unique_lock<std::mutex> lock(mtx_status);
	// 记录开始时间
	auto startTime = std::chrono::steady_clock::now();
	// 循环检查直到所有任务完成或超时或退出标志被设置
	while (!m_bExit)
	{
		// 假设所有任务已完成
		bool allComplete = !m_statusList.empty();
		// 遍历状态列表检查每个任务的状态
		for (auto &it : m_statusList)
		{
			// 如果发现未完成的任务，设置allComplete为false并跳出循环
			if (it.second != RUN_STATUS_COMPLETE)
			{
				allComplete = false;
				break;
			}
		}
		// 如果所有任务都已完成，返回true
		if (allComplete)
		{
			return true;
		}

		auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
							 std::chrono::steady_clock::now() - startTime)
							 .count();
		if (elapsedMs >= timeoutMs)
		{
			return false;
		}

		cv_status.wait_for(lock, std::chrono::milliseconds(100));
	}
	return false;
}

int QX_Merge_Analysis::Run(int nId)
{
	std::unique_lock<std::mutex> lock(mtx_status);

	while (!m_bExit)
	{
		cv_status.wait(lock, [this]()
					   {
			if (m_bExit)
				return true;
			if (m_statusList.empty())
				return false;
			for (auto &it : m_statusList)
			{
				if (it.second != RUN_STATUS_READY)
					return false;
			}
			return true; });

		if (m_bExit)
			break;

		if (!m_statusList.empty())
		{

			for (auto &it : m_statusList)
			{

				it.second = RUN_STATUS_BUSY;
			}

			lock.unlock();

			StartAnalysis();
			lock.lock();

			for (auto &it : m_statusList)
			{
				it.second = RUN_STATUS_COMPLETE;
			}
			cv_status.notify_all();
		}
	}
	return 0;
}

int QX_Merge_Analysis::StartThread(int nId)
{
	// 开启检测线程
	ptr_thread_Run = std::make_shared<std::thread>(std::bind(&QX_Merge_Analysis::Run, this, nId));

	return 0;
}

int QX_Merge_Analysis::StopThread()
{
	m_bExit = true;
	cv_status.notify_all();
	if (ptr_thread_Run != nullptr)
	{
		if (ptr_thread_Run->joinable())
		{
			ptr_thread_Run->join();
		}
	}
	return 0;
}

int QX_Merge_Analysis::StartAnalysis()
{
	m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "==========Start========%s", CheckUtil::getCurTimeHMS().c_str());
	// 分析每一个缺陷类型
	for (int i = 0; i < QX_ANALYSIS_COUNT; i++)
	{
		if (QX_ANALYSIS_POL_CELL != i && QX_ANALYSIS_AD != i && QX_ANALYSIS_MTX != i && QX_ANALYSIS_Scratch != i && QX_ANALYSIS_LINE != i)
		{
			m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "== %d  11", i);
			continue;
		}
		if (m_QXList[i].channelqxList.size() <= 0 || m_ConfigList[i].configlsit.size() <= 0)
		{
			m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "== %d  channelqxList %ld configlsit %ld",
										i, m_QXList[i].channelqxList.size(), m_ConfigList[i].configlsit.size());
			continue;
		}

		m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "%s start", QX_ANALYSIS_NAME_Names[i].c_str());
		Analysis_QXtype(&m_QXList[i], i);
		m_pMergedetlog->AddCheckstr(PrintLevel_0, 3, "Num And Dis Judge", "%s end", QX_ANALYSIS_NAME_Names[i].c_str());
	}

	// presult = &m_reultList;

	return 0;
}

int QX_Merge_Analysis::Analysis_single_Config(QXAnalysis_Config *pconfig, QX_channel_List *pqxList, int qx_type, std::shared_ptr<DetLog> pchannelLog)
{
	// AD 单通道参数判定受 merge_analysy_region_sf 通道过滤约束
	if (qx_type == QX_ANALYSIS_AD && m_pbaseCheckFunction)
	{
		std::vector<std::string> merge_analysy_region_sf = m_pbaseCheckFunction->ad_check.analysis_sf.region_sf;
		if (std::find(merge_analysy_region_sf.begin(), merge_analysy_region_sf.end(), pqxList->channel_name) == merge_analysy_region_sf.end())
		{
			pchannelLog->AddCheckstr(PrintLevel_1, 3, "Analysis_single_Config", "merge_analysy_region_sf not found %s --> skip", pqxList->channel_name.c_str());
			return 0;
		}
	}

	pchannelLog->AddCheckstr(PrintLevel_2, 3, "param",
							 " okparam =  %d  area %f  max_area %f  hj %d  num %d dis  %f len %f md %f",
							 pconfig->bok, pconfig->area, pconfig->sum_area, pconfig->hj, pconfig->num, pconfig->dis, pconfig->len, pconfig->density);

	float sumarea = 0;
	float fmaxarea = 0;
	int num = 0;
	// 遍历每一个相机
	Pre_Analysisy_Param param;
	param.fAreaMin = pconfig->area;
	param.fHJMin = pconfig->hj;
	param.fLenMin = pconfig->len;
	param.fMdMin = pconfig->density;

	pqxList->Initstatus();
	for (int i = 0; i < (int)pqxList->qxList.size(); i++)
	{
		std::string str = "";
		// 面积 灰阶满足要求
		if (pqxList->preDet(i, param, str))
		{
			num++;
			pqxList->qxList.at(i).nstatus = 1;
			sumarea += pqxList->qxList.at(i).area;
			if (pqxList->qxList.at(i).area > fmaxarea)
			{
				fmaxarea = pqxList->qxList.at(i).area;
			}
		}

		pchannelLog->AddCheckstr(PrintLevel_3, 3, "preA", "qx_idx %d : %s  count = %d; %s ",
								 i, Re_TO_STR_Pass_1(pqxList->qxList.at(i).nstatus), num,
								 pqxList->qxList.at(i).GetInfo().c_str(), str.c_str());
	}
	if (num <= 0 && pconfig->num > 0)
	{
		pchannelLog->AddCheckstr(PrintLevel_3, 3, "result", "fail num = 0");
		return 0;
	}

	// 对距离有要求
	if (pconfig->dis > 0)
	{
		pqxList->claDis();
	}

	if (pconfig->bok == 1 && num > 0)
	{
		// 只要有一个条件大于阈值参数，就NG;
		std::string strresult = "param type=OK:";
		bool bresult = true;
		// 数量不满足要求。
		if (num >= pconfig->num)
		{
			bresult = false;
			strresult += "Num = false : " + std::to_string(num) + ">=" + std::to_string(pconfig->num) + ";";
			int are = QX_ERROR_TYPE_NUM;
			for (int i = 0; i < (int)pqxList->qxList.size(); i++)
			{
				if (pqxList->qxList.at(i).nstatus == 1)
				{
					pqxList->qxList.at(i).nqx_type = QX_ERROR_TYPE_NUM;
				}
			}
		}
		else
		{
			strresult += "Num = true: " + std::to_string(num) + "<" + std::to_string(pconfig->num) + ";";
		}

		float fmaxLen = 0;
		bool blenerror = false;
		float allmindis = 99999999999;
		bool bdiserror = false;
		for (int i = 0; i < (int)pqxList->qxList.size(); i++)
		{
			if (pqxList->qxList.at(i).nstatus == 1)
			{
				if (pqxList->qxList.at(i).length > fmaxLen)
				{
					fmaxLen = pqxList->qxList.at(i).length;
				}
				// 长度超过阈值
				if (pconfig->len > 0 && pqxList->qxList.at(i).length > pconfig->len)
				{
					blenerror = true;
					pqxList->qxList.at(i).nqx_type = QX_ERROR_TYPE_Len;
				}

				// 对距离有要求
				if (pconfig->dis > 0)
				{
					if (pqxList->qxList.at(i).tem_dis_idx >= 0)
					{
						// 最小距离 大于 阈值
						if (pqxList->qxList.at(i).tem_dis <= pconfig->dis)
						{
							bdiserror = true;
							pqxList->qxList.at(i).nqx_type = QX_ERROR_TYPE_DIS;
							pqxList->qxList.at(i).fmindis = pqxList->qxList.at(i).tem_dis;
							pqxList->qxList.at(i).nmindis_BlobIdx = pqxList->qxList.at(i).tem_dis_idx;
						}
						if (pqxList->qxList.at(i).tem_dis < allmindis)
						{
							allmindis = pqxList->qxList.at(i).tem_dis;
						}
					}
				}
			}
		}
		if (blenerror)
		{
			bresult = false;
			strresult += "Len = false : " + std::to_string(fmaxLen) + ">=" + std::to_string(pconfig->len) + ";";
		}
		else
		{
			strresult += "Len = true: " + std::to_string(fmaxLen) + ">=" + std::to_string(pconfig->len) + ";";
		}
		if (bdiserror)
		{
			bresult = false;
			strresult += "dis = false : " + std::to_string(allmindis) + ">=" + std::to_string(pconfig->dis) + ";";
		}
		else
		{
			strresult += "dis = true: " + std::to_string(allmindis) + ">=" + std::to_string(pconfig->dis) + ";";
		}

		for (int i = 0; i < (int)pqxList->qxList.size(); i++)
		{

			if (pqxList->qxList.at(i).nqx_type > QX_ERROR_TYPE_OK)
			{
				if (pqxList->qxList.at(i).result == 0)
				{
					pqxList->qxList.at(i).result = 1;

					QX_RESULT tem;
					tem.blobIdx = pqxList->qxList.at(i).blobIdx;
					tem.qx_Num = num;
					tem.mindis = pqxList->qxList.at(i).fmindis;
					tem.flen = pqxList->qxList.at(i).length;
					tem.error_Type = pqxList->qxList.at(i).nqx_type;
					tem.camera_name = pqxList->qxList.at(i).camera_name;
					tem.channel_name = pqxList->qxList.at(i).channel_name;
					pchannelLog->AddCheckstr(PrintLevel_4, 3, "result = NG", "Add New qx,Blob idx %d  type %d  num %d dis %f  len %f ", tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);

					m_reultList.resultList.push_back(tem);
				}
			}
		}
	}
	else
	{

		std::string strresult = "param type=NG:";
		bool bpass = true;
		if (num >= pconfig->num)
		{
			strresult += "Num = true : " + std::to_string(num) + ">=" + std::to_string(pconfig->num) + ";";
		}
		else
		{
			bpass = false;
			strresult += "Num = false: " + std::to_string(num) + "<" + std::to_string(pconfig->num) + ";";
		}
		if (fmaxarea >= pconfig->sum_area)
		{
			strresult += "maxarea = true : " + std::to_string(fmaxarea) + ">=" + std::to_string(pconfig->sum_area) + ";";
		}
		else
		{
			bpass = false;
			strresult += "maxarea = false: " + std::to_string(fmaxarea) + "<" + std::to_string(pconfig->sum_area) + ";";
		}
		// 数量满足要求
		if (bpass)
		{
			float allmindis = 99999999999;
			for (int i = 0; i < (int)pqxList->qxList.size(); i++)
			{
				// pchannelLog->AddCheckstr(PrintLevel_4, 3, "ddddddd", "%d  %f %f %s ",
				// 						 i, pqxList->qxList.at(i).plocatin_mm.x, pqxList->qxList.at(i).plocatin_mm.y,
				// 						 pqxList->qxList.at(i).GetInfo().c_str());

				// 面积 灰阶满足要求
				if (pqxList->qxList.at(i).nstatus == 1)
				{

					int minidx = -1;
					bool bdis = (pconfig->dis > 0);
					double remindis = 0;
					// 对距离有要求
					if (pconfig->dis > 0)
					{
						// pchannelLog->AddCheckstr(PrintLevel_3, 3, "result", "%d %f",i,pqxList->qxList.at(i).tem_dis);
						if (pqxList->qxList.at(i).tem_dis_idx >= 0)
						{

							// 最小距离 大于 阈值
							if (pqxList->qxList.at(i).tem_dis > pconfig->dis)
							{
								bdis = false;
							}
							if (pqxList->qxList.at(i).tem_dis < allmindis)
							{
								allmindis = pqxList->qxList.at(i).tem_dis;
							}
						}
						else
						{
							// 无邻近缺陷，距离检查自动通过
							bdis = false;
						}

						remindis = pqxList->qxList.at(i).tem_dis;
					}

					// 距离满足要求
					if (bdis && pqxList->qxList.at(i).result == 0)
					{
						pqxList->qxList.at(i).result = 1;

						QX_RESULT tem;
						tem.blobIdx = pqxList->qxList.at(i).blobIdx;
						tem.qx_Num = num;
						tem.mindis = remindis;
						tem.camera_name = pqxList->qxList.at(i).camera_name;
						tem.channel_name = pqxList->qxList.at(i).channel_name;
						if (pconfig->num <= 0 && pconfig->dis <= 0)
						{
							tem.error_Type = QX_ERROR_TYPE_AREA;
						}
						else if (pconfig->dis <= 0)
						{
							tem.error_Type = QX_ERROR_TYPE_NUM;
						}
						else
						{
							tem.error_Type = QX_ERROR_TYPE_DIS;
						}
						pchannelLog->AddCheckstr(PrintLevel_4, 3, "Add New QX",
												 "result = NG, Add New qx,Blob idx %d -> num %d >= %d is true; dis %f <= %f is true; max_area %f >= %f is true ",
												 tem.blobIdx, num, pconfig->num, remindis, pconfig->dis, fmaxarea, pconfig->sum_area);

						m_reultList.resultList.push_back(tem);
					}
				}
			}
			if (pconfig->dis > 0)
			{
				if (allmindis <= pconfig->dis)
				{
					strresult += "dis = true : " + std::to_string(allmindis) + "<=" + std::to_string(pconfig->dis) + ";";
				}
				else
				{
					bpass = false;
					strresult += "dis = false : " + std::to_string(allmindis) + ">" + std::to_string(pconfig->dis) + ";";
				}
			}
			else
			{
				strresult += "dis = true : dis param is 0";
			}
		}
		if (!bpass)
		{
			pchannelLog->AddCheckstr(PrintLevel_2, 3, "result", "OK==>%s", strresult.c_str());
		}
		else
		{
			pchannelLog->AddCheckstr(PrintLevel_2, 3, "result", "NG==>%s", strresult.c_str());
		}
	}

	return 0;
}

int QX_Merge_Analysis::Analysis_QXtype(ALL_Qx_DataList *pALLTypeqxList, int qx_idx)
{

	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "Num And Dis Judge", "pALLTypeqxList->channelqxList.size() %ld",
								pALLTypeqxList->channelqxList.size());
	for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
	{
		QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];

		Analysis_Channel(pQXChannelList, qx_idx);
	}
	// AD 要进行额外的分析
	if (qx_idx == QX_ANALYSIS_AD)
	{
		if(m_pbaseCheckFunction->ad_check.analysis_bind.bUse)
		{
			Analysis_AD_Bind(pALLTypeqxList, qx_idx);
		}
		else
		{
			Analysis_AD(pALLTypeqxList, qx_idx);
		}
		
	}

	return 0;
}

int QX_Merge_Analysis::Analysis_Channel(QX_channel_List *pChannelqxList, int qx_idx)
{
	int param_num = 0;
	int param_dis = 0;

	ALL_QX_ParamList *pConfigList = &m_ConfigList[qx_idx];
	// 用单面相机的参数去处理 所有相机的缺陷。
	m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "Num And Dis Judge", "pConfigList->configlsit.size() %ld",
								pConfigList->configlsit.size());
	for (int i = 0; i < (int)pConfigList->configlsit.size(); i++)
	{
		pChannelqxList->pChannelDetlog->AddCheckstr(PrintLevel_1, 3, "Num And Dis Judge", "QX %s channel %s param  %d / %d Analysis start ",
													QX_ANALYSIS_NAME_Names[qx_idx].c_str(), pChannelqxList->channel_name.c_str(), i, (int)pConfigList->configlsit.size());
		Analysis_single_Config(&pConfigList->configlsit.at(i), pChannelqxList, qx_idx, pChannelqxList->pChannelDetlog);
	}
	if (pChannelqxList->pChannelDetlog2 && pChannelqxList->pChannelDetlog)
	{
		for (auto log : pChannelqxList->pChannelDetlog->logList)
		{
			pChannelqxList->pChannelDetlog2->logList.push_back(log);
		}
	}

	return 0;
}

int QX_Merge_Analysis::Judge_OK_Config()
{
	return 0;
}

int QX_Merge_Analysis::Judge_NG_Config()
{
	return 0;
}

int QX_Merge_Analysis::Analysis_AD(ALL_Qx_DataList *pALLTypeqxList, int qx_idx)
{
	AD_list.clear();
	if (!m_pbaseCheckFunction)
	{
		return 1;
	}

	Base_Function_AD_Check *pAd_checkParma = &m_pbaseCheckFunction->ad_check;

	int product_AD_num = 0; // 整个产品的 暗点数目。
	int check_s_Num = 0;
	int s_param_value = -1;
	int s_param_num = 0;
	// 遍历每个通道，找到开启的 进行分析。
	for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
	{
		QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];

		if (!pAd_checkParma)
		{
			continue;
		}
		if (pAd_checkParma && !pAd_checkParma->bOpen)
		{
			pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ",
														"channel %s AD Check is close", pQXChannelList->channel_name.c_str());
			continue;
		}
		bool bana_num = false;
		bool bana_dis = false;
		bool bana_S = false;
		if (pAd_checkParma->analysis_num.bOpen)
		{
			bana_num = true;
		}
		if (pAd_checkParma->analysis_dis.bOpen)
		{
			bana_dis = true;
		}
		if (pAd_checkParma->analysis_s.bOpen)
		{
			bana_S = true;
		}
		{
			pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ", "NUM --> %s  Param  num check %d dis check %d  S check %d",
														pQXChannelList->channel_name.c_str(), bana_num, bana_dis, bana_S);
		}
		if (!bana_num && !bana_dis && !bana_S)
		{
			continue;
		}

		for (int j = 0; j < pQXChannelList->qxList.size(); j++)
		{
			if (pQXChannelList->qxList[j].area >= pAd_checkParma->S_standard_1s.area &&
				pQXChannelList->qxList[j].length >= pAd_checkParma->S_standard_1s.len)
			{
			}
			else
			{
				continue;
			}

			tem_AD_QX_Info tem_AD_qx; // 暗点信息
			tem_AD_qx.channelidx = i;
			tem_AD_qx.qxidx = j;

			int s_det_value = 0;
			// 当前通道 要参与s标准分析
			if (pAd_checkParma->analysis_s.bOpen)
			{
				s_param_num = pAd_checkParma->analysis_s.Check_s_Num;
				s_param_value = pAd_checkParma->analysis_s.Check_s_Value;

				if (pQXChannelList->qxList[j].area >= pAd_checkParma->S_standard_3s.area &&
					pQXChannelList->qxList[j].length >= pAd_checkParma->S_standard_3s.len)
				{
					s_det_value = 3;
					pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "add AD ",
																"%d %s 3S: cur[A %0.2f L %0.2f]  parm[A %0.2f L %0.2f]",
																j, pQXChannelList->channel_name.c_str(),
																pQXChannelList->qxList[j].area, pQXChannelList->qxList[j].length,
																pAd_checkParma->S_standard_3s.area, pAd_checkParma->S_standard_3s.len);
				}
				else if (pQXChannelList->qxList[j].area >= pAd_checkParma->S_standard_2s.area &&
						 pQXChannelList->qxList[j].length >= pAd_checkParma->S_standard_2s.len)
				{
					s_det_value = 2;
					pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "  add AD ",
																"%d %s 2S: cur[A %0.2f L %0.2f]  parm[A %0.2f L %0.2f]",
																j, pQXChannelList->channel_name.c_str(),
																pQXChannelList->qxList[j].area, pQXChannelList->qxList[j].length,
																pAd_checkParma->S_standard_2s.area, pAd_checkParma->S_standard_2s.len);
				}
				else
				{
					pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "add AD ",
																"%d %s 1S: cur[A %0.2f L %0.2f]  parm[A %0.2f L %0.2f]",
																j, pQXChannelList->channel_name.c_str(),
																pQXChannelList->qxList[j].area, pQXChannelList->qxList[j].length,
																pAd_checkParma->S_standard_1s.area, pAd_checkParma->S_standard_1s.len);
					s_det_value = 1;
				}
				if (s_det_value >= s_param_value)
				{
					check_s_Num++;
				}
			}

			cv::Rect roi = pQXChannelList->qxList[j].product_roi;

			int list_idx = -1;
			int channel_s = 0;
			int roi_expand = (round)(pAd_checkParma->analysis_iou.AD_Expand);
			bool bnew_add = true;
			for (int idx = 0; idx < AD_list.size(); idx++)
			{
				cv::Rect tem_roi(AD_list.at(idx).roi.x-roi_expand, AD_list.at(idx).roi.y-roi_expand, AD_list.at(idx).roi.width+2*roi_expand, AD_list.at(idx).roi.height+2*roi_expand);
				cv::Rect tem_roi2(roi.x-roi_expand, roi.y-roi_expand, roi.width+2*roi_expand, roi.height+2*roi_expand);
				
				float fiou = CheckUtil::CalIoU(AD_list.at(idx).roi, roi);
				m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "CalIoU", 
					"roi1 %s roi2 %s expand %d iou %f",
					CheckUtil::GetRectString(AD_list.at(idx).roi).c_str(),
					CheckUtil::GetRectString(roi).c_str(),
					roi_expand, fiou);
				if (fiou > pAd_checkParma->analysis_iou.AD_IOU)
				{
					list_idx = idx;
				}
			}
			// 在list已存在。
			if (list_idx >= 0)
			{
				AD_list.at(list_idx).num++;
				AD_list.at(list_idx).numIdxList.push_back(tem_AD_qx);

				channel_s = AD_list.at(list_idx).num;
				if (s_det_value == 1)
				{
					AD_list.at(list_idx).num_1s++;
				}
				else if (s_det_value == 2)
				{
					AD_list.at(list_idx).num_2s++;
					AD_list.at(list_idx).num_2sIdxList.push_back(tem_AD_qx);
				}
				else
				{
					AD_list.at(list_idx).num_3s++;
					AD_list.at(list_idx).num_3sIdxList.push_back(tem_AD_qx);
				}
				bnew_add = false;
			}
			else
			{ // 在list不存在。
				AD_Channel_Info_ tem;
				tem.roi = roi;
				tem.location_product_mm = pQXChannelList->qxList[j].pLocation_Product_mm;
				tem.num = 1;
				channel_s = 1;
				tem.fdis = 99999999999;

				tem.numIdxList.push_back(tem_AD_qx);

				if (s_det_value == 1)
				{
					tem.num_1s++;
				}
				else if (s_det_value == 2)
				{
					tem.num_2s++;
					tem.num_2sIdxList.push_back(tem_AD_qx);
				}
				else
				{
					tem.num_3s++;
					tem.num_3sIdxList.push_back(tem_AD_qx);
				}
				AD_list.push_back(tem);
				// 如果要参与数量统计
				if (bana_num)
				{
					product_AD_num++;
				}
			}

			m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "AD list size %ld; channel %s blob idx %d,new_add %d ,A %f len %f p %d %d",
										AD_list.size(), pQXChannelList->channel_name.c_str(), j, bnew_add, pQXChannelList->qxList[j].area,
										pQXChannelList->qxList[j].length, roi.x, roi.y);

			pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ",
														"%d %s  AD list size %ld  product_AD_num Num %d; cur channel num = %d;cur S = %ds; param :%ds num %d;->S check_s_Num = %d",
														j, pQXChannelList->channel_name.c_str(), AD_list.size(),
														product_AD_num, channel_s, s_det_value, s_param_value, s_param_num, check_s_Num);
		}
	}

	float min_dis = 9999999999;
	// 求最小距离
	if (true)
	{
		for (int ad_i = 0; ad_i < AD_list.size(); ad_i++)
		{
			for (int ad_j = 0; ad_j < AD_list.size(); ad_j++)
			{
				if (ad_i == ad_j)
				{
					continue;
				}
				// double dis = DistanceBetweenRectCenters(AD_list.at(ad_i).roi, AD_list.at(ad_j).roi,
				// 										1,
				// 										1);

				float dis = CheckUtil::calDis(AD_list.at(ad_i).location_product_mm, AD_list.at(ad_j).location_product_mm);
				if (dis < AD_list.at(ad_i).fdis)
				{
					AD_list.at(ad_i).fdis = dis;
					AD_list.at(ad_i).dist_idx = ad_j;
					if (dis < min_dis)
					{
						min_dis = dis;
					}
				}
			}
		}
	}
	int A_2S_num = 0;
	int A_3S_num = 0;
	// 统计 2s 总数
	if (s_param_value > 0)
	{
		int channels = 0;
		int oneimgs = check_s_Num;

		for (int ad_i = 0; ad_i < AD_list.size(); ad_i++)
		{
			if (AD_list.at(ad_i).num > 1)
			{
				AD_list.at(ad_i).num_2s++;
				for (int i = 0; i < AD_list.at(ad_i).numIdxList.size(); i++)
				{
					AD_list.at(ad_i).num_2sIdxList.push_back(AD_list.at(ad_i).numIdxList.at(i));
				}
			}
			A_2S_num += AD_list.at(ad_i).num_2s;
			A_3S_num += AD_list.at(ad_i).num_3s;

	
			if(AD_list.at(ad_i).num_1s >= 3) A_3S_num++;

			m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "AD_list %d  %s",
										ad_i, AD_list.at(ad_i).GetInfo().c_str());
		}
		m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "product_AD_num %d  2S_num = %d 3S_num s = %d min_dis %0.2f",
									product_AD_num, A_2S_num, A_3S_num, min_dis);
	}

	for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
	{
		QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];

		if (!pAd_checkParma->bOpen)
		{

			continue;
		}
		bool bNG = false;

		bool NG_num = false;
		bool NG_3S = false;
		bool NG_2S = false;
		bool NG_dis = false;

		if (pAd_checkParma->analysis_num.bOpen)
		{
			// 数量分析
			if (product_AD_num >= pAd_checkParma->analysis_num.numT)
			{
				m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Num Analysis --> %s  result NG ,product_AD_num %d >= parm num %d",
											pQXChannelList->channel_name.c_str(), product_AD_num, pAd_checkParma->analysis_num.numT);
				bNG = true;
				NG_num = true;
			}
			else
			{
				m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Num Analysis--> %s  result OK ,product_AD_num  %d < parm num %d",
											pQXChannelList->channel_name.c_str(), product_AD_num, pAd_checkParma->analysis_num.numT);
			}
		}
		// 不NG
		if (!bNG)
		{
			// 3S直接 NG
			if (pAd_checkParma->analysis_s.NG_3s)
			{
				// 数量分析
				if (A_3S_num >= 1)
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "3S Analysis --> %s  result NG  3S %d >= 1",
												pQXChannelList->channel_name.c_str(), A_3S_num);

					bNG = true;
					NG_3S = true;
				}
				else
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "3S Analysis --> %s  result OK   3S %d < 1",
												pQXChannelList->channel_name.c_str(), A_3S_num);
				}
			}
		}
		// 不NG
		if (!bNG)
		{
			// 距离判断
			if (pAd_checkParma->analysis_dis.bOpen)
			{
				// 数量分析
				if (min_dis <= pAd_checkParma->analysis_dis.disT)
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Dis Analysis--> %s Dis  result NG ,min dis %f <= parm dis %f",
												pQXChannelList->channel_name.c_str(), min_dis, pAd_checkParma->analysis_dis.disT);

					bNG = true;
					NG_2S = true;
				}
				else
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Dis Analysis--> %s Dis  result OK ,min dis %f > parm dis %f",
												pQXChannelList->channel_name.c_str(), min_dis, pAd_checkParma->analysis_dis.disT);
				}
			}
		}
		// 不NG
		if (!bNG)
		{
			// S标准判断
			if (pAd_checkParma->analysis_s.bOpen)
			{
				// 数量分析
				if (A_2S_num >= pAd_checkParma->analysis_s.Check_s_Num)
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "S Analysis--> %s  result NG , Check %ds Num %d >= parm S Num %d",
												pQXChannelList->channel_name.c_str(), pAd_checkParma->analysis_s.Check_s_Value, A_2S_num, pAd_checkParma->analysis_s.Check_s_Num);

					bNG = true;
					NG_2S = true;
				}
				else
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "S Analysis--> %s  result OK , Check %ds Num %d < parm S Num %d",
												pQXChannelList->channel_name.c_str(), pAd_checkParma->analysis_s.Check_s_Value, A_2S_num, pAd_checkParma->analysis_s.Check_s_Num);
				}
			}
		}
		// 已经NG
		if (bNG)
		{

			QX_channel_List *pqxList = pQXChannelList;
			for (int i = 0; i < (int)pqxList->qxList.size(); i++)
			{

				if (pqxList->qxList.at(i).result == 0)
				{
					pqxList->qxList.at(i).result = 1;

					QX_RESULT tem;
					tem.blobIdx = pqxList->qxList.at(i).blobIdx;
					tem.mindis = pqxList->qxList.at(i).fmindis;
					tem.flen = pqxList->qxList.at(i).length;
					tem.error_Type = pqxList->qxList.at(i).nqx_type;
					tem.camera_name = pqxList->qxList.at(i).camera_name;
					tem.channel_name = pqxList->qxList.at(i).channel_name;
					pqxList->pChannelDetlog->AddCheckstr(PrintLevel_4, 3, "result = NG", "Add New qx,Blob idx %d  type %d  num %d dis %f  len %f ", tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);
					m_pMergedetlog->AddCheckstr(PrintLevel_4, 3, "result = NG", "%s Add New qx,Blob idx %d  type %d  num %d dis %f  len %f ",
												tem.channel_name.c_str(), tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);

					m_reultList.resultList.push_back(tem);
				}
			}
		}
	}

	return 0;
}

int QX_Merge_Analysis::Analysis_AD_Bind(ALL_Qx_DataList *pALLTypeqxList, int qx_idx)
{
	if (!m_pbaseCheckFunction)
	{
		return 1;
	}

	Base_Function_AD_Check *pAd_checkParma = &m_pbaseCheckFunction->ad_check;

	int check_s_Num = 0;
	int s_param_value = -1;
	int s_param_num = 0;

	bool bana_num = false;
	bool bana_dis = false;
	bool bana_S = false;
	if (pAd_checkParma->analysis_num.bOpen)
	{
		bana_num = true;
	}
	if (pAd_checkParma->analysis_dis.bOpen)
	{
		bana_dis = true;
	}
	if (pAd_checkParma->analysis_s.bOpen)
	{
		bana_S = true;
	}

	m_pMergedetlog->AddCheckstr(PrintLevel_1, 3, "Analysis_AD_Bind", "start bOpen %d num %d dis %d S %d",
								pAd_checkParma->bOpen, bana_num, bana_dis, bana_S);

	/* 获取绑定通道 */
	vector<string> merge_analysy_s_sf = pAd_checkParma->analysis_sf.s_sf;
	vector<string> main_channel_2s = pAd_checkParma->analysis_bind.main_channel_2s;
	vector<string> second_channel_2s = pAd_checkParma->analysis_bind.second_channel_2s;
	vector<string> main_channel_3s = pAd_checkParma->analysis_bind.main_channel_3s;
	vector<string> second_channel_3s = pAd_checkParma->analysis_bind.second_channel_3s;
	/* 获取关联通道 */
	vector<string> correlated_channels = pAd_checkParma->analysis_bind.correlated_channels;

	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD_Bind", "bind main_2s %d second_2s %d main_3s %d second_3s %d",
								(int)main_channel_2s.size(), (int)second_channel_2s.size(), (int)main_channel_3s.size(), (int)second_channel_3s.size());

	/* 获取主次通道的缺陷列表 */
	vector<QX_channel_List> main_channel_s_qxList;
	vector<QX_channel_List> second_channel_s_qxList;
	for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
	{
		QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];

		if (!pAd_checkParma)
		{
			continue;
		}
		if (pAd_checkParma && !pAd_checkParma->bOpen)
		{
			pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ",
														"channel %s AD Check is close", pQXChannelList->channel_name.c_str());
			continue;
		}
		{
			pQXChannelList->pChannelDetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD ", "NUM --> %s  Param  num check %d dis check %d  S check %d",
														pQXChannelList->channel_name.c_str(), bana_num, bana_dis, bana_S);
		}
		
    	string cur_channel_name = pQXChannelList->channel_name;

		if (std::find(main_channel_2s.begin(), main_channel_2s.end(), cur_channel_name) != main_channel_2s.end() ||
			std::find(main_channel_3s.begin(), main_channel_3s.end(), cur_channel_name) != main_channel_3s.end())
    	{
    	    main_channel_s_qxList.push_back(pALLTypeqxList->channelqxList[i]);
    	}
		if (std::find(second_channel_2s.begin(), second_channel_2s.end(), cur_channel_name) != second_channel_2s.end() ||
			std::find(second_channel_3s.begin(), second_channel_3s.end(), cur_channel_name) != second_channel_3s.end())
    	{
    	    second_channel_s_qxList.push_back(pALLTypeqxList->channelqxList[i]);
    	}
	}

	m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "Analysis_AD_Bind", "main_channel %d second_channel %d",
								(int)main_channel_s_qxList.size(), (int)second_channel_s_qxList.size());

	/* 画面分析 */
	AD_list_bind.clear();
	for(int i_main = 0; i_main < main_channel_s_qxList.size(); i_main++)
	{
		string main_channel_name = main_channel_s_qxList[i_main].channel_name;
		QX_channel_List *pQXChannelList_main = &main_channel_s_qxList[i_main];
		vector<AD_Channel_BD_Info_> tmp_main_qxInfo_all;
		// 遍历主通道cur_channel_name通道的缺陷
		for (int j_main = 0; j_main < pQXChannelList_main->qxList.size(); j_main++)
		{	
			AD_Channel_BD_Info_ tmp_main_qxInfo; // 主通道单个缺陷
			if (pQXChannelList_main->qxList[j_main].area >= pAd_checkParma->S_standard_1s.area &&
				pQXChannelList_main->qxList[j_main].length >= pAd_checkParma->S_standard_1s.len)
			{
			}
			else
			{
				continue;
			}
			tmp_main_qxInfo.roi = pQXChannelList_main->qxList[j_main].product_roi;
			tmp_main_qxInfo.location_product_mm = pQXChannelList_main->qxList[j_main].pLocation_Product_mm;

			/*单画面*/
			// 当前通道 要参与s标准分析
			if (pAd_checkParma->analysis_s.bOpen)
			{
				s_param_num = pAd_checkParma->analysis_s.Check_s_Num;
				s_param_value = pAd_checkParma->analysis_s.Check_s_Value;

				if (pQXChannelList_main->qxList[j_main].area >= pAd_checkParma->S_standard_3s.area &&
					pQXChannelList_main->qxList[j_main].length >= pAd_checkParma->S_standard_3s.len)
				{
					tmp_main_qxInfo.s_type = 3;
					pQXChannelList_main->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "add AD ",
																"%d %s 3S: cur[A %0.2f L %0.2f]  parm[A %0.2f L %0.2f]",
																j_main, pQXChannelList_main->channel_name.c_str(),
																pQXChannelList_main->qxList[j_main].area, pQXChannelList_main->qxList[j_main].length,
																pAd_checkParma->S_standard_3s.area, pAd_checkParma->S_standard_3s.len);
				}
				else if (pQXChannelList_main->qxList[j_main].area >= pAd_checkParma->S_standard_2s.area &&
						 pQXChannelList_main->qxList[j_main].length >= pAd_checkParma->S_standard_2s.len)
				{
					tmp_main_qxInfo.s_type = 2;
					pQXChannelList_main->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "  add AD ",
																"%d %s 2S: cur[A %0.2f L %0.2f]  parm[A %0.2f L %0.2f]",
																j_main, pQXChannelList_main->channel_name.c_str(),
																pQXChannelList_main->qxList[j_main].area, pQXChannelList_main->qxList[j_main].length,
																pAd_checkParma->S_standard_2s.area, pAd_checkParma->S_standard_2s.len);
				}
				else
				{
					pQXChannelList_main->pChannelDetlog->AddCheckstr(PrintLevel_3, 3, "add AD ",
																"%d %s 1S: cur[A %0.2f L %0.2f]  parm[A %0.2f L %0.2f]",
																j_main, pQXChannelList_main->channel_name.c_str(),
																pQXChannelList_main->qxList[j_main].area, pQXChannelList_main->qxList[j_main].length,
																pAd_checkParma->S_standard_1s.area, pAd_checkParma->S_standard_1s.len);
					tmp_main_qxInfo.s_type = 1;
				}
			}

			cv::Rect roi_main = pQXChannelList_main->qxList[j_main].product_roi;
			int roi_expand = (round)(pAd_checkParma->analysis_iou.AD_Expand);
			roi_main = cv::Rect(roi_main.x - roi_expand, roi_main.y - roi_expand, roi_main.width + roi_expand * 2, roi_main.height + roi_expand * 2);

			// 遍历次通道
			for(int i_second = 0; i_second < second_channel_s_qxList.size(); i_second++)
			{
				string second_channel_name = second_channel_s_qxList[i_second].channel_name;
				if(second_channel_name == main_channel_name)
				{
					continue;
				}
				QX_channel_List *pQXChannelList_second = &second_channel_s_qxList[i_second];
				// 遍历次通道second_channel_name通道的缺陷
				for (int j_second = 0; j_second < pQXChannelList_second->qxList.size(); j_second++)
				{
					if (pQXChannelList_second->qxList[j_second].area >= pAd_checkParma->S_standard_1s.area &&
						pQXChannelList_second->qxList[j_second].length >= pAd_checkParma->S_standard_1s.len)
					{
					}
					else
					{
						continue;
					}
					cv::Rect roi_second = pQXChannelList_second->qxList[j_second].product_roi;
					roi_second = cv::Rect(roi_second.x - roi_expand, roi_second.y - roi_expand, roi_second.width + roi_expand * 2, roi_second.height + roi_expand * 2);
					float fiou = CheckUtil::CalIoU(roi_main, roi_second);
					// m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "CalIoU", 
					// "roi1 %s roi2 %s expand %d iou %f",
					// CheckUtil::GetRectString(roi_main).c_str(),
					// CheckUtil::GetRectString(roi_second).c_str(),
					// roi_expand, fiou);
					if (fiou > pAd_checkParma->analysis_iou.AD_IOU)
					{
						if (std::find(second_channel_2s.begin(), second_channel_2s.end(), second_channel_name) != second_channel_2s.end())
						{
							tmp_main_qxInfo.s_name_2.push_back(second_channel_name);
							m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "Add 2s", "%s roi1 %s roi2 %s expand %d iou %f",
							second_channel_name.c_str(), CheckUtil::GetRectString(roi_main).c_str(),CheckUtil::GetRectString(roi_second).c_str(),roi_expand, fiou);
						}
						if(std::find(second_channel_3s.begin(), second_channel_3s.end(), second_channel_name) != second_channel_3s.end())
						{
							tmp_main_qxInfo.s_name_3.push_back(second_channel_name);
							m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "Add 3s", "%s roi1 %s roi2 %s expand %d iou %f",
							second_channel_name.c_str(), CheckUtil::GetRectString(roi_main).c_str(),CheckUtil::GetRectString(roi_second).c_str(),roi_expand, fiou);
						}
						
						break;
					}
				}	
			}
			m_pMergedetlog->AddCheckstr(PrintLevel_3, 3, "Analysis_AD_Bind", "main %s blob %d s_type %d s_name_2 %d s_name_3 %d roi %s",
										main_channel_name.c_str(), j_main, tmp_main_qxInfo.s_type,
										(int)tmp_main_qxInfo.s_name_2.size(), (int)tmp_main_qxInfo.s_name_3.size(),
										CheckUtil::GetRectString(tmp_main_qxInfo.roi).c_str());
			tmp_main_qxInfo_all.push_back(tmp_main_qxInfo);
			
		}
		AD_list_bind[main_channel_name] = tmp_main_qxInfo_all;
	}

	/* 数量距离统计 */
	std::unordered_map<string, AD_Channel_Stat_> AD_stat_map;
	for(int i_main = 0; i_main < main_channel_s_qxList.size(); i_main++)
	{
		string main_channel_name = main_channel_s_qxList[i_main].channel_name;
		AD_Channel_Stat_ &stat = AD_stat_map[main_channel_name];
		for(int j = 0; j < AD_list_bind[main_channel_name].size(); j++)
		{
			bool bproduct_AD_num = false;
			// 数量统计
			if(AD_list_bind[main_channel_name][j].s_type == 1)
			{
				bproduct_AD_num = true;
				stat.num_1s++;
			}
			if(AD_list_bind[main_channel_name][j].s_type == 2 || AD_list_bind[main_channel_name][j].s_name_2.size() >= 2)
			{
				if(AD_list_bind[main_channel_name][j].s_type == 2) stat.num_2s_s++;
				if(AD_list_bind[main_channel_name][j].s_name_2.size() >= 2) stat.num_2s_m++;
				bproduct_AD_num = true;
				stat.num_2s++;
			}
			if(AD_list_bind[main_channel_name][j].s_type == 3 || AD_list_bind[main_channel_name][j].s_name_3.size() >= 3)
			{
				if(AD_list_bind[main_channel_name][j].s_type == 3) stat.num_3s_s++;
				if(AD_list_bind[main_channel_name][j].s_name_3.size() >= 3) stat.num_3s_m++;
				bproduct_AD_num = true;
				stat.num_3s++;
			}
			if(bproduct_AD_num)
			{
				stat.product_AD_num++;
			}
			// 距离计算
			for(int k = j + 1; k < AD_list_bind[main_channel_name].size(); k++)
			{
				float dis = CheckUtil::calDis(AD_list_bind[main_channel_name][j].location_product_mm, AD_list_bind[main_channel_name][k].location_product_mm);
				if (dis < stat.min_dis)
				{
					stat.min_dis = dis;
				}
			}
		}

		m_pMergedetlog->AddCheckstr(PrintLevel_1, 3, "Analysis_AD_Bind", "stat %s num_1s %d | num_2s %d [s %d m %d] | num_3s %d [s %d m %d] | product_AD_num %d | min_dis %0.2f",
									main_channel_name.c_str(), stat.num_1s, stat.num_2s, stat.num_2s_s, stat.num_2s_m, stat.num_3s, stat.num_3s_s, stat.num_3s_m, stat.product_AD_num, stat.min_dis);
	}

	/* NG分析 */
	for (int i = 0; i < pALLTypeqxList->channelqxList.size(); i++)
	{
		QX_channel_List *pQXChannelList = &pALLTypeqxList->channelqxList[i];

		if (!pAd_checkParma->bOpen)
		{
			continue;
		}
		if(std::find(merge_analysy_s_sf.begin(), merge_analysy_s_sf.end(), pQXChannelList->channel_name) != merge_analysy_s_sf.end())
		{		
		}
		else
		{
			m_pMergedetlog->AddCheckstr(PrintLevel_1, 3, "Analysis_AD_Bind", "merge_analysy_s_sf not found %s --> skip", pQXChannelList->channel_name.c_str());
			continue;
		}
		// 获取该通道独立的统计
		auto it_stat = AD_stat_map.find(pQXChannelList->channel_name);
		if (it_stat == AD_stat_map.end())
		{
			m_pMergedetlog->AddCheckstr(PrintLevel_1, 3, "Analysis_AD_Bind", "AD_stat_map not found %s --> skip", pQXChannelList->channel_name.c_str());
			continue;
		}
		AD_Channel_Stat_ &stat = it_stat->second;
		bool bNG = false;

		bool NG_num = false;
		bool NG_3S = false;
		bool NG_2S = false;
		bool NG_dis = false;

		if (pAd_checkParma->analysis_num.bOpen)
		{
			// 数量分析
			if (stat.product_AD_num >= pAd_checkParma->analysis_num.numT)
			{
				m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Num Analysis --> %s  result NG ,product_AD_num %d >= parm num %d",
											pQXChannelList->channel_name.c_str(), stat.product_AD_num, pAd_checkParma->analysis_num.numT);
				bNG = true;
				NG_num = true;
			}
			else
			{
				m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Num Analysis--> %s  result OK ,product_AD_num  %d < parm num %d",
											pQXChannelList->channel_name.c_str(), stat.product_AD_num, pAd_checkParma->analysis_num.numT);
			}
		}
		// 不NG
		if (!bNG)
		{
			// 3S直接 NG
			if (pAd_checkParma->analysis_s.NG_3s)
			{
				if (stat.num_3s >= 1)
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "3S Analysis --> %s  result NG  3S %d >= 1",
												pQXChannelList->channel_name.c_str(), stat.num_3s);
					bNG = true;
					NG_3S = true;
				}
				else
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "3S Analysis --> %s  result OK   3S %d < 1",
												pQXChannelList->channel_name.c_str(), stat.num_3s);
				}
			}
		}
		// 不NG
		if (!bNG)
		{
			// 距离判断
			if (pAd_checkParma->analysis_dis.bOpen)
			{
				if (stat.min_dis <= pAd_checkParma->analysis_dis.disT)
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Dis Analysis--> %s Dis  result NG ,min dis %f <= parm dis %f",
												pQXChannelList->channel_name.c_str(), stat.min_dis, pAd_checkParma->analysis_dis.disT);
					bNG = true;
					NG_dis = true;
				}
				else
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "Dis Analysis--> %s Dis  result OK ,min dis %f > parm dis %f",
												pQXChannelList->channel_name.c_str(), stat.min_dis, pAd_checkParma->analysis_dis.disT);
				}
			}
		}
		// 不NG
		if (!bNG)
		{
			// S标准判断
			if (pAd_checkParma->analysis_s.bOpen)
			{
				if (stat.num_2s >= pAd_checkParma->analysis_s.Check_s_Num)
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "S Analysis--> %s  result NG , Check %ds Num %d >= parm S Num %d",
												pQXChannelList->channel_name.c_str(), pAd_checkParma->analysis_s.Check_s_Value, stat.num_2s, pAd_checkParma->analysis_s.Check_s_Num);
					bNG = true;
					NG_2S = true;
				}
				else
				{
					m_pMergedetlog->AddCheckstr(PrintLevel_2, 3, "AD RGBL255", "S Analysis--> %s  result OK , Check %ds Num %d < parm S Num %d",
												pQXChannelList->channel_name.c_str(), pAd_checkParma->analysis_s.Check_s_Value, stat.num_2s, pAd_checkParma->analysis_s.Check_s_Num);
				}
			}
		}
		// 已经NG
		if (bNG)
		{
			// 注意：按缺陷(blob)粒度逐条判断，避免把同一通道内与脏污无关的缺陷也一并放过
			const int roi_expand = (int)(round)(pAd_checkParma->analysis_iou.AD_Expand);
			const float iou_threshold = pAd_checkParma->analysis_iou.AD_IOU;

			QX_channel_List *pqxList = pQXChannelList;
			for (int idx = 0; idx < (int)pqxList->qxList.size(); idx++)
			{
				if (pqxList->qxList.at(idx).result != 0)
				{
					continue;
				}

				// 关联通道存在与当前缺陷重叠的脏污缺陷时，该缺陷不记录NG结果
				if (IsOverlapDirtyInCorrelatedChannel(correlated_channels,
													  pqxList->qxList.at(idx).channel_name,
													  pqxList->qxList.at(idx).camera_name,
													  pqxList->qxList.at(idx).product_roi,
													  roi_expand, iou_threshold,
													  pqxList->pChannelDetlog))
				{
					pqxList->pChannelDetlog->AddCheckstr(PrintLevel_1, 3, "result = NG skip",
														 "channel %s cam %s blob %d roi %s : 关联通道存在重叠, 不记录NG结果",
														 pqxList->qxList.at(idx).channel_name.c_str(),
														 pqxList->qxList.at(idx).camera_name.c_str(),
														 pqxList->qxList.at(idx).blobIdx,
														 CheckUtil::GetRectString(pqxList->qxList.at(idx).product_roi).c_str());
					m_pMergedetlog->AddCheckstr(PrintLevel_1, 3, "result = NG skip",
												"channel %s cam %s blob %d roi %s : 关联通道存在重叠, 不记录NG结果",
												pqxList->qxList.at(idx).channel_name.c_str(),
												pqxList->qxList.at(idx).camera_name.c_str(),
												pqxList->qxList.at(idx).blobIdx,
												CheckUtil::GetRectString(pqxList->qxList.at(idx).product_roi).c_str());
					continue;
				}

				pqxList->qxList.at(idx).result = 1;

				QX_RESULT tem;
				tem.blobIdx = pqxList->qxList.at(idx).blobIdx;
				tem.mindis = pqxList->qxList.at(idx).fmindis;
				tem.flen = pqxList->qxList.at(idx).length;
				tem.error_Type = pqxList->qxList.at(idx).nqx_type;
				tem.camera_name = pqxList->qxList.at(idx).camera_name;
				tem.channel_name = pqxList->qxList.at(idx).channel_name;
				pqxList->pChannelDetlog->AddCheckstr(PrintLevel_4, 3, "result = NG", "Add New qx,Blob idx %d  type %d  num %d dis %f  len %f ", tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);
				m_pMergedetlog->AddCheckstr(PrintLevel_4, 3, "result = NG", "%s Add New qx,Blob idx %d  type %d  num %d dis %f  len %f ",
											tem.channel_name.c_str(), tem.blobIdx, tem.error_Type, tem.qx_Num, tem.mindis, tem.flen);

				m_reultList.resultList.push_back(tem);
			}
		}
	}

	return 0;
}


ChannelCheckFunction *QX_Merge_Analysis::GetChannelFuntion(std::string strChannelName)
{
	ChannelCheckFunction *p = NULL;
	for (int i = 0; i < m_pChannelFuntion->channelFunctionArr.size(); i++)
	{
		if (CheckUtil::compareIgnoreCase(m_pChannelFuntion->channelFunctionArr[i].strChannelName, strChannelName))
		{
			p = &m_pChannelFuntion->channelFunctionArr[i];
		}
	}

	return p;
}
double QX_Merge_Analysis::DistanceBetweenRectCenters(const cv::Rect &rect1, const cv::Rect &rect2, float fx, float fy)
{
	// 计算矩形1的中心点
	cv::Point center1(rect1.x + rect1.width / 2, rect1.y + rect1.height / 2);

	// 计算矩形2的中心点
	cv::Point center2(rect2.x + rect2.width / 2, rect2.y + rect2.height / 2);
	center1.x *= fx;
	center1.y *= fy;

	center2.x *= fx;
	center2.y *= fy;

	// 计算中心点之间的欧几里得距离
	double distance = cv::norm(center1 - center2);

	return distance;
}