feat 同步云平台部分修改

AlgorithmModule/include/ImageDetConfig.h

@@ -346,6 +346,7 @@ struct BQ_Result
 	int nresult = 1;
 	bool bShield_BQ = true;			   // 是否屏蔽标签
 	bool bBQ_AI_Det = false;		   // 是否启用标签独立AI检测
+	bool bsaveAll = false;			   // 是否保存所有的检测结果
 	std::vector<cv::Rect> pBQ_roiList;	   // 标签的原始区域
 	std::vector<cv::Rect> pBQ_expandedRoiList; // 标签的扩展后区域（用于AI检测）
 	std::vector<cv::Mat> pBQ_cropImages;	   // 标签扩展区域图像

AlgorithmModule/src/CameraCheckAnalysisy.cpp

@@ -694,8 +694,13 @@ int CameraCheckAnalysisy::preDet_BQ(const cv::Mat &L255CutImg, std::shared_ptr<I
 {
 	long ts = CheckUtil::getcurTime();
 	m_pCheck_Result->cameraBaseResult->pBQ_Result = std::make_shared<BQ_Result>();
-	m_pCheck_Result->cameraBaseResult->pBQ_Result->bShield_BQ = m_AnalysisyConfig.commonCheckConfig.baseConfig.bShield_BQ;
+
-	m_pCheck_Result->cameraBaseResult->pBQ_Result->bBQ_AI_Det = m_pbaseCheckFunction->Det_BQ.bBQ_AI_Det;
+	ChannelCheckFunction *pChannelFuntion_BQ = GetChannelFuntion(L255->strChannel);
+	if (pChannelFuntion_BQ)
+	{
+		m_pCheck_Result->cameraBaseResult->pBQ_Result->bBQ_AI_Det = pChannelFuntion_BQ->function.f_Det_BQ.bBQ_AI_Det;
+		m_pCheck_Result->cameraBaseResult->pBQ_Result->bsaveAll = pChannelFuntion_BQ->function.f_Det_BQ.bsaveAll;
+	}
 
 	cv::Rect Det_CropRoi = m_pCheck_Result->cameraBaseResult->pEdgeDetResult->cutRoi;
 
@@ -716,15 +721,13 @@ int CameraCheckAnalysisy::preDet_BQ(const cv::Mat &L255CutImg, std::shared_ptr<I
 		return re;
 	}
 
-	// 如果要屏蔽标签
+	// 默认屏蔽标签
-	if (m_pCheck_Result->cameraBaseResult->pBQ_Result->bShield_BQ)
 	{
-		m_pdetlog->AddCheckstr(PrintLevel_2, "preDet_BQ", "shieldBQ is Open");
 		cv::Mat detImg_mask = m_pCheck_Result->cameraBaseResult->pEdgeDetResult->shieldMask;
 		for (int i = 0; i < m_pCheck_Result->cameraBaseResult->pBQ_Result->pBQ_roiList.size(); i++)
 		{
 			cv::Rect boundingRect = m_pCheck_Result->cameraBaseResult->pBQ_Result->pBQ_roiList.at(i);
-			int BQ_expand = m_pbaseCheckFunction->Det_BQ.BQ_expand;
+			int BQ_expand = pChannelFuntion_BQ ? pChannelFuntion_BQ->function.f_Det_BQ.BQ_expand : 0;
 			boundingRect.x -= BQ_expand;
 			boundingRect.y -= BQ_expand;
 			boundingRect.width += 2 * BQ_expand;
@@ -732,13 +735,12 @@ int CameraCheckAnalysisy::preDet_BQ(const cv::Mat &L255CutImg, std::shared_ptr<I
 			boundingRect = boundingRect & cv::Rect(0, 0, detImg_mask.cols, detImg_mask.rows);
 			if (boundingRect.width > 0 && boundingRect.height > 0)
 			{
-				// 同时屏蔽主AI，避免重复检测
 				detImg_mask(boundingRect).setTo(255);
+				m_pCheck_Result->cameraBaseResult->pBQ_Result->pBQ_expandedRoiList.push_back(boundingRect);
 
 				// 保存裁剪图像供独立BQ AI检测
-				if (m_pbaseCheckFunction->Det_BQ.bBQ_AI_Det)
+				if (pChannelFuntion_BQ && pChannelFuntion_BQ->function.f_Det_BQ.bBQ_AI_Det)
 				{
-					m_pCheck_Result->cameraBaseResult->pBQ_Result->pBQ_expandedRoiList.push_back(boundingRect);
 					cv::Mat bqCrop = L255CutImg(boundingRect).clone();
 					m_pCheck_Result->cameraBaseResult->pBQ_Result->pBQ_cropImages.push_back(bqCrop);
 				}
@@ -749,10 +751,6 @@ int CameraCheckAnalysisy::preDet_BQ(const cv::Mat &L255CutImg, std::shared_ptr<I
 			cv::imwrite("sheildImg.png", m_pCheck_Result->cameraBaseResult->pEdgeDetResult->shieldMask);
 		}
 	}
-	else
-	{
-		m_pdetlog->AddCheckstr(PrintLevel_2, "preDet_BQ", "shieldBQ is false");
-	}
 	std::shared_ptr<BQ_Result> pBQ_Result = m_pCheck_Result->cameraBaseResult->pBQ_Result; // BQ 检测结果
 	pBQ_Result->BQ_centerPoint.erase(pBQ_Result->BQ_centerPoint.begin(), pBQ_Result->BQ_centerPoint.end());
 	for (int i = 0; i < pBQ_Result->pBQ_roiList.size(); i++)

AlgorithmModule/src/ImageResultJudge.cpp

@@ -447,33 +447,28 @@ int ImageResultJudge::ResultJudge(std::shared_ptr<ImageAllResult> pImageResult)
 			}
 		}
 		// 暗点 3S 分析  对 好品 或者 是 疑是的缺陷进行3S分析。S数量分析。 3S的暗点直接NG.
-		// if ((nerrortype == 0 || checkFlage != ANALYSIS_TYPE_TF) &&
-		// 	config_qx_type == CONFIG_QX_NAME_AD && pFuntion &&
-		// 	pFuntion->function.f_AD_Check.bOpen &&
-		// 	pFuntion->function.f_AD_Check.analysis_s.bOpen &&
-		// 	pFuntion->function.f_AD_Check.analysis_s.NG_3s && bpreSucc)
 		if ((nerrortype == 0 || checkFlage != ANALYSIS_TYPE_TF) &&
-			config_qx_type == CONFIG_QX_NAME_AD && m_pbaseCheckFunction &&
+			config_qx_type == CONFIG_QX_NAME_AD && pFuntion != NULL && m_pbaseCheckFunction &&
 			m_pbaseCheckFunction->ad_check.bOpen &&
 			m_pbaseCheckFunction->ad_check.analysis_s.bOpen &&
 			m_pbaseCheckFunction->ad_check.analysis_s.NG_3s && bpreSucc)
 		{
 			Judge_Status = true;
 			int det_s_Vale = 0;
-			if (JudgArea >= pFuntion->function.f_AD_Check.S_standard_3s.area &&
+			if (JudgArea >= m_pbaseCheckFunction->ad_check.S_standard_3s.area &&
-				flen >= pFuntion->function.f_AD_Check.S_standard_3s.len)
+				flen >= m_pbaseCheckFunction->ad_check.S_standard_3s.len && (strChannel == "L127" || strChannel == "L255"))
 			{
 				nerrortype = 1;
 				checkFlage = ANALYSIS_TYPE_TF;
 				bNG_Status = true;
 
 				pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "info", " AD 3S result NG, det area %f len %f >=3s param area %f len %f  ",
-									JudgArea, flen, pFuntion->function.f_AD_Check.S_standard_3s.area, pFuntion->function.f_AD_Check.S_standard_3s.len);
+									JudgArea, flen, m_pbaseCheckFunction->ad_check.S_standard_3s.area, m_pbaseCheckFunction->ad_check.S_standard_3s.len);
 			}
 			else
 			{
 				pQxLog->AddCheckstr(PrintLevel_3, DET_LOG_LEVEL_3, "info", " AD 3S result OK, det area %f len %f < 3s param area %f len %f  ",
-									JudgArea, flen, pFuntion->function.f_AD_Check.S_standard_3s.area, pFuntion->function.f_AD_Check.S_standard_3s.len);
+									JudgArea, flen, m_pbaseCheckFunction->ad_check.S_standard_3s.area, m_pbaseCheckFunction->ad_check.S_standard_3s.len);
 			}
 		}
 

AlgorithmModule/src/ImgCheckAnalysisy.cpp

@@ -2175,7 +2175,7 @@ int ImgCheckAnalysisy::AI_Detect_BQ()
 	{
 		return 0;
 	}
-	if (!m_pImageAllResult->cameraBaseResult->pBQ_Result->bBQ_AI_Det)
+	if (!m_pFuntion->function.f_Det_BQ.bBQ_AI_Det)
 	{
 		return 0;
 	}
@@ -2189,77 +2189,179 @@ int ImgCheckAnalysisy::AI_Detect_BQ()
 	m_pdetlog->AddCheckstr(PrintLevel_1, strBaseLog, "============= Start, BQ num = %d", bqNum);
 	long ts = CheckUtil::getcurTime();
 
+	std::string BQ_save_path = "/home/aidlux/BOE/FOG/BQ_AI_Det/"+ m_pImageAllResult->productBaseResult->strproductName + "/";
+	CheckUtil::CreateDir(BQ_save_path);
+
 	// 初始化BQ AI检测结果
 	m_pImageAllResult->bq_DetAIResult = std::make_shared<ImageAllResult::Image_AI_Det_Result>();
 	std::shared_ptr<ImageAllResult::Image_AI_Det_Result> pDetAIResult = m_pImageAllResult->bq_DetAIResult;
 
-	// 使用与主检测相同的AI模型（后续更改为BQ AI模型）
+	// 使用BQ AI
 	std::shared_ptr<AIModel_Base> pAI_Model = AI_Factory->AI_defect_Tag;
 
 	int AIInputImg_width = pAI_Model->input_0.width;
 	int AIInputImg_height = pAI_Model->input_0.height;
-	cv::Size modelInputSize(AIInputImg_width, AIInputImg_height);
+
+	int AIOutputImg_width = pAI_Model->output_0.width;
+	int AIOutputImg_height = pAI_Model->output_0.height;
+
+	// 是否需要 resize到输入图大小进行后续处理
+	bool bResizeToSrc = false;
+	if (AIOutputImg_width != AIInputImg_width || AIOutputImg_height != AIInputImg_height)
+	{
+		bResizeToSrc = true;
+	}
+
+	cv::Size src_sz;
+	src_sz.width = AIInputImg_width;
+	src_sz.height = AIInputImg_height;
 
 	// 创建全图大小的AI mask（与主检测detImg同尺寸）
 	cv::Mat AI_detImage = m_pImageAllResult->AI_detImg;
 	pDetAIResult->AI_MaskImg = cv::Mat::zeros(AI_detImage.size(), CV_8UC1);
+	cv::Mat AIresultMask = pDetAIResult->AI_MaskImg;
 
-	// 先提交所有BQ AI推理任务（仿照AI_Detect_QX的提交-收集模式）
+	// 为每个BQ区域生成小ROI列表，仿照AI_Detect_QX的裁剪小块方式
-	int submitted = 0;
+	std::vector<cv::Rect> BQ_SmallRoiList;
-	int completed = 0;
+	for (int i = 0; i < bqNum; i++)
-	while (completed < bqNum)
+	{
+		cv::Rect bqRoi = m_pImageAllResult->cameraBaseResult->pBQ_Result->pBQ_expandedRoiList.at(i);
+		cv::Rect validRoi = bqRoi & cv::Rect(0, 0, AI_detImage.cols, AI_detImage.rows);
+		if (validRoi.width <= 0 || validRoi.height <= 0) continue;
+
+		// 如果BQ区域大于等于模型输入尺寸，切分成小块
+		if (validRoi.width >= AIInputImg_width && validRoi.height >= AIInputImg_height)
+		{
+			std::vector<cv::Rect> smallList;
+			int re = CheckUtil::cutSmallImg(AI_detImage, smallList, validRoi, AIInputImg_width, AIInputImg_height, 0, 0);
+			if (re == 0)
+			{
+				for (const auto& roi : smallList)
+				{
+					BQ_SmallRoiList.push_back(roi);
+				}
+			}
+		}
+		else
+		{
+			// BQ区域小于模型输入尺寸，以BQ区域中心创建模型输入大小的ROI
+			int cx = validRoi.x + validRoi.width / 2;
+			int cy = validRoi.y + validRoi.height / 2;
+			cv::Rect newRoi;
+			newRoi.x = cx - AIInputImg_width / 2;
+			newRoi.y = cy - AIInputImg_height / 2;
+			newRoi.width = AIInputImg_width;
+			newRoi.height = AIInputImg_height;
+			// 裁剪到图像边界
+			if (newRoi.x < 0) newRoi.x = 0;
+			if (newRoi.y < 0) newRoi.y = 0;
+			if (newRoi.x + newRoi.width > AI_detImage.cols) newRoi.x = AI_detImage.cols - newRoi.width;
+			if (newRoi.y + newRoi.height > AI_detImage.rows) newRoi.y = AI_detImage.rows - newRoi.height;
+			if (newRoi.x < 0) { newRoi.x = 0; newRoi.width = AI_detImage.cols; }
+			if (newRoi.y < 0) { newRoi.y = 0; newRoi.height = AI_detImage.rows; }
+			BQ_SmallRoiList.push_back(newRoi);
+		}
+	}
+
+	const int totalTasks = BQ_SmallRoiList.size();
+	if (totalTasks <= 0)
+	{
+		m_pdetlog->AddCheckstr(PrintLevel_2, strBaseLog, "no valid small roi for BQ");
+		return 0;
+	}
+
+	m_pdetlog->AddCheckstr(PrintLevel_2, strBaseLog, "BQ small roi num = %d", totalTasks);
+
+	// 调试存图：原图 + BQ小ROI框
+	if (m_pFuntion->function.f_Det_BQ.bsaveAll)
+	{
+		cv::Mat debugImg;
+		if (AI_detImage.channels() == 1)
 		{
-		// 提交任务（限制并发数不超过2，避免占用过多资源）
+			cv::cvtColor(AI_detImage, debugImg, cv::COLOR_GRAY2BGR);
-		if (submitted < bqNum && runner->GetProcessingCount() < 2)
+		}
+		else
 		{
-			cv::Mat bqCrop = m_pImageAllResult->cameraBaseResult->pBQ_Result->pBQ_cropImages.at(submitted);
+			debugImg = AI_detImage.clone();
-			if (!bqCrop.empty())
+		}
+		for (size_t i = 0; i < BQ_SmallRoiList.size(); i++)
 		{
-				cv::Mat resizedCrop;
+			cv::rectangle(debugImg, BQ_SmallRoiList.at(i), cv::Scalar(0, 0, 255), 2);
-				cv::resize(bqCrop, resizedCrop, modelInputSize);
+		}
+		cv::imwrite(BQ_save_path + m_strCurDetCamChannel + "_BQ_original_with_rois.png", debugImg);
+	}
 
+	int submitted = 0;
+	int completed = 0;
+
+	// 资源控制：限制最大并发数和最大待处理数
+	const int MAX_CONCURRENT = 5;
+	const int MAX_PENDING = 5;
+
+	long t2 = CheckUtil::getcurTime();
+
+	while (completed < totalTasks)
+	{
+		// 提交任务：满足并发限制和待处理限制
+		if (submitted < totalTasks
+			&& runner->GetProcessingCount() < MAX_CONCURRENT
+			&& (submitted - completed) < MAX_PENDING)
+		{
 			std::shared_ptr<AIMulThreadRunBase::AITask> task = std::make_shared<AIMulThreadRunBase::AITask>();
 			task->id = submitted;
-				task->roi = cv::Rect(0, 0, modelInputSize.width, modelInputSize.height);
+			task->roi = BQ_SmallRoiList.at(submitted);
-				task->input = resizedCrop;
+			task->input = AI_detImage(task->roi).clone();
 			task->output = std::make_shared<cv::Mat>();
 			task->engine = pAI_Model;
 
-				runner->SubmitTask(task);
+			// 调试存图：保存每个小块
+			if (m_pFuntion->function.f_Det_BQ.bsaveAll)
+			{
+				cv::imwrite(BQ_save_path +m_strCurDetCamChannel + "_" + std::to_string(submitted) + "_BQ_crop_in.png", task->input);
 			}
+
+			runner->SubmitTask(task);
 			submitted++;
 		}
 
-		// 收集已完成的结果
+		// 收集结果
 		std::shared_ptr<AIMulThreadRunBase::AITask> result;
 		if (runner->PopResult(result))
 		{
-			int idx = result->id;
+			cv::Mat &outimg = *(result->output);
-			if (idx >= 0 && idx < bqNum)
+			if (!outimg.empty())
 			{
-				cv::Rect bqRoi = m_pImageAllResult->cameraBaseResult->pBQ_Result->pBQ_expandedRoiList.at(idx);
+				// 调试存图：保存模型原始输出mask
-				cv::Rect validRoi = bqRoi & cv::Rect(0, 0, AI_detImage.cols, AI_detImage.rows);
+				if (m_pFuntion->function.f_Det_BQ.bsaveAll)
+				{
+					cv::imwrite(BQ_save_path + m_strCurDetCamChannel+ "_" + std::to_string(result->id) + "_BQ_crop_out.png", outimg);
+				}
 
-				if (validRoi.width > 0 && validRoi.height > 0)
+				cv::Mat AIresult;
+				if (bResizeToSrc)
 				{
-					cv::Mat &outMask = *(result->output);
+					cv::resize(outimg, AIresult, src_sz, 0, 0, 0);
-					if (!outMask.empty())
+				}
+				else
 				{
-						// 将AI输出mask resize回BQ裁剪图原始尺寸
+					AIresult = outimg;
-						cv::Mat resizedMask;
+				}
-						cv::resize(outMask, resizedMask, cv::Size(bqRoi.width, bqRoi.height));
 
-						// 将BQ的mask结果放到全图mask的对应位置
+				cv::Rect srcsize_roi = result->roi;
-						resizedMask.copyTo(pDetAIResult->AI_MaskImg(validRoi), resizedMask);
+				AIresult.copyTo(AIresultMask(srcsize_roi), AIresult);
+
+				// 调试存图：保存resize后的mask
+				if (m_pFuntion->function.f_Det_BQ.bsaveAll && bResizeToSrc)
+				{
+					cv::imwrite(BQ_save_path + m_strCurDetCamChannel + "_BQ_mask_resized_" + std::to_string(result->id) + ".png", AIresult);
+				}
 
 				m_pdetlog->AddCheckstr(PrintLevel_2, strBaseLog, "BQ[%d] AI done, roi=[%d,%d,%d,%d]",
-											   idx, validRoi.x, validRoi.y, validRoi.width, validRoi.height);
+									   result->id, srcsize_roi.x, srcsize_roi.y, srcsize_roi.width, srcsize_roi.height);
 			}
 			else
 			{
-						m_pdetlog->AddCheckstr(PrintLevel_2, strBaseLog, "BQ[%d] AI output empty", idx);
+				m_pdetlog->AddCheckstr(PrintLevel_2, strBaseLog, "BQ[%d] AI output empty", result->id);
-					}
-				}
 			}
 			completed++;
 		}
@@ -2270,12 +2372,13 @@ int ImgCheckAnalysisy::AI_Detect_BQ()
 	}
 
 	long te = CheckUtil::getcurTime();
-	m_pdetlog->AddCheckstr(PrintLevel_1, strBaseLog, "============= End, time=%ld ms", te - ts);
+	float mean_AI = (te - t2) / totalTasks;
+	m_pdetlog->AddCheckstr(PrintLevel_1, strBaseLog, "============= End; AI Run Time: sum %ld pre %ld Run %ld mean One Small Img %f", te - ts, t2 - ts, te - t2, mean_AI);
 
 	// 调试存图
-	if (DetImgInfo_shareP->bDebugsaveImg)
+	if (m_pFuntion->function.f_Det_BQ.bsaveAll)
 	{
-		cv::imwrite(m_strCurDetCamChannel + "_AI_BQ_mask.png", pDetAIResult->AI_MaskImg);
+		cv::imwrite(BQ_save_path + m_strCurDetCamChannel + "_AI_BQ_mask.png", pDetAIResult->AI_MaskImg);
 	}
 
 	return 0;

ConfigModule/include/CheckConfigDefine.h

@@ -469,6 +469,7 @@ struct BasicConfig
 		height_max = 999999;
 		bDrawShieldRoi = false;
 		bShield_ZF = false;
+		bShield_BQ = true;
 		bDrawPreRoi = false;
 		fUP_IOU = 0.9;
 		bCal_ImageScale = false;
@@ -797,6 +798,7 @@ struct Function_YXDet
 {
 	bool bOpen; // 是否开启
 	std::string strModle;
+	int minArea;
 	Function_YXDet()
 	{
 		Init();
@@ -805,20 +807,22 @@ struct Function_YXDet
 	{
 		bOpen = false;
 		strModle = "";
+		minArea = 0;
 	}
 	void copy(Function_YXDet tem)
 	{
 		this->bOpen = tem.bOpen;
 		this->strModle = tem.strModle;
+		this->minArea = tem.minArea;
 	}
 	void print(std::string str)
 	{
-		// printf("%s>>bOpen %d strModle %s\n", str.c_str(), bOpen, strModle.c_str());
+		// printf("%s>>bOpen %d strModle %s minArea %d\n", str.c_str(), bOpen, strModle.c_str(), minArea);
 	}
 	std::string GetInfo(std::string str)
 	{
 		char buffer[64];
-		sprintf(buffer, "%s>>bOpen %d strModle %s\n", str.c_str(), bOpen, strModle.c_str());
+		sprintf(buffer, "%s>>bOpen %d strModle %s minArea %d\n", str.c_str(), bOpen, strModle.c_str(), minArea);
 		std::string str123 = buffer;
 		return str123;
 	}
@@ -1290,8 +1294,19 @@ struct Function_Image_Align
 			{
 				printf("pointArry1 == 0 \n\n\n");
 			}
-			feature_Roi = feature_Roi & cv::Rect(0, 0, img_W, img_H);
+			// 防御：feature_Roi 相对图像尺寸 img_W x img_H 可能越界，
-			feature_Mask = tem_feature_Mask(feature_Roi).clone();
+			// 越界会导致 cv::Mat(Mat, Rect) 断言失败并抛 cv::Exception，进而 abort。
+			cv::Rect roi = feature_Roi & cv::Rect(0, 0, img_W, img_H);
+			if (roi.width <= 0 || roi.height <= 0)
+			{
+				printf("[ToMaskImg] WARNING feature_Roi (%d,%d,%d,%d) out of range, img %dx%d\n",
+					   feature_Roi.x, feature_Roi.y, feature_Roi.width, feature_Roi.height, img_W, img_H);
+				feature_Mask = tem_feature_Mask.clone();
+			}
+			else
+			{
+				feature_Mask = tem_feature_Mask(roi).clone();
+			}
 		}
 	}
 	void print(std::string str)
@@ -1567,74 +1582,80 @@ struct AD_Analysisy_IOU
 		return str123;
 	}
 };
-// 暗点检测功能
+struct AD_Analysisy_Bind
-struct Function_AD_Check
 {
+	bool bUse;
+	std::vector<std::string> main_channel_2s;
+	std::vector<std::string> second_channel_2s;
+	std::vector<std::string> main_channel_3s;
+	std::vector<std::string> second_channel_3s;
+	std::vector<std::string> correlated_channels;
 
-	bool bOpen;					   // 是否开启
+	AD_Analysisy_Bind()
-	AD_S_Standard S_standard_3s;   // 3s 标准
-	AD_S_Standard S_standard_2s;   // 2s 标准
-	AD_S_Standard S_standard_1s;   // 1s 标准
-	AD_Analysisy_Num analysis_num; // 数量分析
-	AD_Analysisy_Dis analysis_dis; // 距离分析
-	AD_Analysisy_S analysis_s;	   // s 标准分析
-	AD_Analysisy_IOU analysis_iou; // IOU 分析
-
-	Function_AD_Check()
 	{
 		Init();
 	}
 	void Init()
 	{
-		bOpen = false;
+		bUse = false;
-		S_standard_3s.Init();
+		main_channel_2s.clear();
-		S_standard_2s.Init();
+		second_channel_2s.clear();
-		S_standard_1s.Init();
+		main_channel_3s.clear();
-		analysis_num.Init();
+		second_channel_3s.clear();
-		analysis_dis.Init();
+		correlated_channels.clear();
-		analysis_s.Init();
-		analysis_iou.Init();
-	}
-
-	void copy(Function_AD_Check tem)
-	{
-		this->bOpen = tem.bOpen;
-		this->S_standard_3s.copy(tem.S_standard_3s);
-		this->S_standard_2s.copy(tem.S_standard_2s);
-		this->S_standard_1s.copy(tem.S_standard_1s);
-		this->analysis_num.copy(tem.analysis_num);
-		this->analysis_dis.copy(tem.analysis_dis);
-		this->analysis_s.copy(tem.analysis_s);
-		this->analysis_iou.copy(tem.analysis_iou);
 	}
-	void print(std::string str)
+	void copy (AD_Analysisy_Bind tem)
 	{
-		printf("%s>>bOpen %d %s %s %s %s %s %s %s\n", str.c_str(),
+		this->bUse = tem.bUse;
-			   bOpen, S_standard_3s.GetInfo("3S").c_str(),
+		this->main_channel_2s = tem.main_channel_2s;
-			   S_standard_2s.GetInfo("2S").c_str(),
+		this->second_channel_2s = tem.second_channel_2s;
-			   S_standard_1s.GetInfo("1S").c_str(),
+		this->main_channel_3s = tem.main_channel_3s;
-			   analysis_num.GetInfo("analysis_num").c_str(),
+		this->second_channel_3s = tem.second_channel_3s;
-			   analysis_dis.GetInfo("analysis_dis").c_str(),
+		this->correlated_channels = tem.correlated_channels;
-			   analysis_s.GetInfo("analysis_s").c_str(),
-			   analysis_iou.GetInfo("analysis_iou").c_str());
 	}
 	std::string GetInfo(std::string str)
 	{
 		char buffer[256];
-		sprintf(buffer, "%s>>bOpen %d ", str.c_str(), bOpen);
+		sprintf(buffer, "%s:bUse %d;", str.c_str(),
+				bUse);
 		std::string str123 = buffer;
-		str123 += S_standard_3s.GetInfo("3S");
-		str123 += S_standard_2s.GetInfo("2S");
-		str123 += S_standard_1s.GetInfo("1S");
-		str123 += analysis_num.GetInfo("analysis_num");
-		str123 += analysis_dis.GetInfo("analysis_dis");
-		str123 += analysis_s.GetInfo("analysis_s");
-		str123 += analysis_iou.GetInfo("analysis_iou");
-
 		return str123;
 	}
 };
 
+struct AD_Analysisy_SF
+{
+	std::vector<std::string> s_sf;
+	std::vector<std::string> region_sf;
+
+	AD_Analysisy_SF()
+	{
+		Init();
+	}
+	void Init()
+	{
+		s_sf.clear();
+		region_sf.clear();
+	}
+	void copy (AD_Analysisy_SF tem)
+	{
+		this->s_sf = tem.s_sf;
+		this->region_sf = tem.region_sf;
+	}
+	std::string GetInfo(std::string str)
+	{
+    	std::string str123;
+    	for (int i = 0; i < s_sf.size(); i++)
+    	{
+    	    str123 += str + ":s_sf " + s_sf[i] + ";";
+    	}
+    	for (int i = 0; i < region_sf.size(); i++)
+    	{
+    	    str123 += str + ":region_sf " + region_sf[i] + ";";
+    	}
+    	return str123;
+	}
+};
 // 异物检测功能
 struct Function_POL_Check
 {
@@ -1723,6 +1744,44 @@ struct Function_Edge_Det
 		return str123;
 	}
 };
+struct Function_Det_BQ
+{ 
+	bool bBQ_AI_Det;		// 是否启用标签独立AI检测
+	int BQ_expand;
+	bool bsaveAll;
+
+	Function_Det_BQ()
+	{
+		Init();
+	}
+	void Init()
+	{
+		BQ_expand = 0;
+		bBQ_AI_Det = false;
+		bsaveAll = false;
+	}
+	void copy(Function_Det_BQ tem)
+	{
+		this->BQ_expand = tem.BQ_expand;
+		this->bBQ_AI_Det = tem.bBQ_AI_Det;
+		this->bsaveAll = tem.bsaveAll;
+	}
+	void print(std::string str)
+	{
+		printf("%d BQ_expand %d bBQ_AI_Det %d bsaveAll %d\n", str.c_str(),
+			   BQ_expand, bBQ_AI_Det, bsaveAll);
+	}
+	std::string GetInfo(std::string str)
+	{
+		char buffer[256];
+		sprintf(buffer, "%d BQ_expand %d bBQ_AI_Det %d bsaveAll %d\n", str.c_str(),
+				BQ_expand, bBQ_AI_Det, bsaveAll);
+		std::string str123 = buffer;
+		return str123;
+	}
+
+};
+
 // 检测功能
 struct CheckFunction
 {
@@ -1739,9 +1798,9 @@ struct CheckFunction
 	Function_Image_Align f_Image_Align;		   // 图片特征对齐
 	Function_Detect_LackPol f_Dectect_LackPol; // 缺失POL检测
 	Function_SecondDet f_SecondDetect;		   // 二次检测分析
-	Function_AD_Check f_AD_Check;			   // 暗点的检测功能
 	Function_POL_Check f_POL_Check;			   // 异物的检测功能
 	Function_Edge_Det f_dege_Det;
+	Function_Det_BQ f_Det_BQ;
 	CheckFunction()
 	{
 		Init();
@@ -1761,9 +1820,9 @@ struct CheckFunction
 		f_Image_Align.Init();
 		f_Dectect_LackPol.Init();
 		f_SecondDetect.Init();
-		f_AD_Check.Init();
 		f_POL_Check.Init();
 		f_dege_Det.Init();
+		f_Det_BQ.Init();
 	}
 	void copy(CheckFunction tem)
 	{
@@ -1781,9 +1840,9 @@ struct CheckFunction
 		this->f_Image_Align.copy(tem.f_Image_Align);
 		this->f_Dectect_LackPol.copy(tem.f_Dectect_LackPol);
 		this->f_SecondDetect.copy(tem.f_SecondDetect);
-		this->f_AD_Check.copy(tem.f_AD_Check);
 		this->f_POL_Check.copy(tem.f_POL_Check);
 		this->f_dege_Det.copy(tem.f_dege_Det);
+		this->f_Det_BQ.copy(tem.f_Det_BQ);
 	}
 	void print(std::string str)
 	{
@@ -1801,9 +1860,9 @@ struct CheckFunction
 		f_Image_Align.print("Image_Align");
 		f_Dectect_LackPol.print("Dectect_LackPol");
 		f_SecondDetect.print("SecondDetect");
-		f_AD_Check.print("f_AD_Check");
 		f_POL_Check.print("f_POL_Check");
 		f_dege_Det.print("f_dege_Det");
+		f_Det_BQ.print("f_Det_BQ");
 	}
 	std::string GetInfo(std::string str)
 	{
@@ -1822,9 +1881,9 @@ struct CheckFunction
 		str123 += f_Image_Align.GetInfo("Image_Align");
 		str123 += f_Dectect_LackPol.GetInfo("Dectect_LackPol");
 		str123 += f_SecondDetect.GetInfo("SecondDetect");
-		str123 += f_AD_Check.GetInfo("f_AD_Check");
 		str123 += f_POL_Check.GetInfo("f_POL_Check");
 		str123 += f_dege_Det.GetInfo("f_dege_Det");
+		str123 += f_Det_BQ.GetInfo("f_Det_BQ");
 		return str123;
 	}
 };
@@ -2209,6 +2268,9 @@ struct Base_Function_AD_Check
 	AD_Analysisy_Dis analysis_dis; // 距离分析
 	AD_Analysisy_S analysis_s;	   // s 标准分析
 	AD_Analysisy_IOU analysis_iou; // IOU 分析
+	AD_Analysisy_Bind analysis_bind; // 绑定分析
+	AD_Analysisy_SF analysis_sf; // 同画面参数分析
+
 
 	Base_Function_AD_Check()
 	{
@@ -2224,6 +2286,8 @@ struct Base_Function_AD_Check
 		analysis_dis.Init();
 		analysis_s.Init();
 		analysis_iou.Init();
+		analysis_bind.Init();
+		analysis_sf.Init();
 	}
 
 	void copy(Base_Function_AD_Check tem)
@@ -2236,17 +2300,21 @@ struct Base_Function_AD_Check
 		this->analysis_dis.copy(tem.analysis_dis);
 		this->analysis_s.copy(tem.analysis_s);
 		this->analysis_iou.copy(tem.analysis_iou);
+		this->analysis_bind.copy(tem.analysis_bind);
+		this->analysis_sf.copy(tem.analysis_sf);
 	}
 	void print(std::string str)
 	{
-		printf("%s>>bOpen %d %s %s %s %s %s %s\n", str.c_str(),
+		printf("%s>>bOpen %d %s %s %s %s %s %s %s %s %s\n", str.c_str(),
 			   bOpen, S_standard_3s.GetInfo("3S").c_str(),
 			   S_standard_2s.GetInfo("2S").c_str(),
 			   S_standard_1s.GetInfo("1S").c_str(),
 			   analysis_num.GetInfo("analysis_num").c_str(),
 			   analysis_dis.GetInfo("analysis_dis").c_str(),
 			   analysis_s.GetInfo("analysis_s").c_str(),
-			   analysis_iou.GetInfo("analysis_iou").c_str());
+			   analysis_iou.GetInfo("analysis_iou").c_str(),
+			   analysis_bind.GetInfo("analysis_bind").c_str(),
+			   analysis_sf.GetInfo("analysis_sf").c_str());			   
 	}
 	std::string GetInfo(std::string str)
 	{
@@ -2260,45 +2328,13 @@ struct Base_Function_AD_Check
 		str123 += analysis_dis.GetInfo("analysis_dis");
 		str123 += analysis_s.GetInfo("analysis_s");
 		str123 += analysis_iou.GetInfo("analysis_iou");
+		str123 += analysis_bind.GetInfo("analysis_time");
+		str123 += analysis_sf.GetInfo("analysis_sf");
 
 		return str123;
 	}
 };
 
-struct Base_Function_Det_BQ
-{ 
-	int BQ_expand;
-	bool bBQ_AI_Det;		// 是否启用标签独立AI检测，汇入主流程分类
-
-	Base_Function_Det_BQ()
-	{
-		Init();
-	}
-	void Init()
-	{
-		BQ_expand = 0;
-		bBQ_AI_Det = false;
-	}
-	void copy(Base_Function_Det_BQ tem)
-	{
-		this->BQ_expand = tem.BQ_expand;
-		this->bBQ_AI_Det = tem.bBQ_AI_Det;
-	}
-	void print(std::string str)
-	{
-		printf("%d BQ_expand %d bBQ_AI_Det %d\n", str.c_str(),
-			   BQ_expand, bBQ_AI_Det);
-	}
-	std::string GetInfo(std::string str)
-	{
-		char buffer[256];
-		sprintf(buffer, "%d BQ_expand %d bBQ_AI_Det %d\n", str.c_str(),
-				BQ_expand, bBQ_AI_Det);
-		std::string str123 = buffer;
-		return str123;
-	}
-
-};
 // 基础检测功能
 struct BaseCheckFunction
 {
@@ -2308,7 +2344,6 @@ struct BaseCheckFunction
 	Base_Function_BigNG bigNG;
 	Base_Function_EdgeChannel edgeChannel;
 	Base_Function_AD_Check ad_check;
-	Base_Function_Det_BQ Det_BQ;
 	BaseCheckFunction()
 	{
 		Init();
@@ -2321,7 +2356,6 @@ struct BaseCheckFunction
 		bigNG.Init();
 		edgeChannel.Init();
 		ad_check.Init();
-		Det_BQ.Init();
 	}
 	void copy(BaseCheckFunction tem)
 	{
@@ -2331,7 +2365,6 @@ struct BaseCheckFunction
 		this->bigNG.copy(tem.bigNG);
 		this->edgeChannel.copy(tem.edgeChannel);
 		this->ad_check.copy(tem.ad_check);
-		this->Det_BQ.copy(tem.Det_BQ);
 	}
 	void print(std::string str)
 	{
@@ -2342,7 +2375,6 @@ struct BaseCheckFunction
 		bigNG.print("bigNG");
 		edgeChannel.print("edgeChannel");
 		ad_check.print("ad_check");
-		Det_BQ.print("Det_BQ");
 	}
 	std::string GetInfo(std::string str)
 	{
@@ -2353,7 +2385,6 @@ struct BaseCheckFunction
 		str123 += bigNG.GetInfo("bigNG");
 		str123 += edgeChannel.GetInfo("edgeChannel");
 		str123 += ad_check.GetInfo("ad_check");
-		str123 += Det_BQ.GetInfo("Det_BQ");
 		// str123 += "\n";
 		return str123;
 	}

ConfigModule/src/JsonConfig.cpp

@@ -536,6 +536,10 @@ int ChannelFuntonConfigJson::GetFunction(Json::Value value, CheckFunction &funct
                 {
                     function.f_YXDet.strModle = value_f["form"]["YX_Det"]["AI_Model"].asString();
                 }
+                if (value_f["form"]["YX_Det"]["minArea"])
+                {
+                    function.f_YXDet.minArea = value_f["form"]["YX_Det"]["minArea"].asInt();
+                }
 
                 // function.f_UseUpQX.print("UpQX");
             }
@@ -980,89 +984,6 @@ int ChannelFuntonConfigJson::GetFunction(Json::Value value, CheckFunction &funct
                 }
                 // getchar();
             }
-            // 暗点检测
-            if ("AD_Check" == strCode)
-            {
-                auto value_f = value[i];
-                // std::cout << value_f << std::endl;
-                function.f_AD_Check.bOpen = value_f["isOpen"].asBool();
-                if (function.f_AD_Check.bOpen)
-                {
-                    if (value_f["form"]["AD_S_Standard"]["AD_3S_Area"])
-                    {
-                        function.f_AD_Check.S_standard_3s.area = value_f["form"]["AD_S_Standard"]["AD_3S_Area"].asFloat();
-                    }
-                    if (value_f["form"]["AD_S_Standard"]["AD_3S_Len"])
-                    {
-                        function.f_AD_Check.S_standard_3s.len = value_f["form"]["AD_S_Standard"]["AD_3S_Len"].asFloat();
-                    }
-                    if (value_f["form"]["AD_S_Standard"]["AD_2S_Area"])
-                    {
-                        function.f_AD_Check.S_standard_2s.area = value_f["form"]["AD_S_Standard"]["AD_2S_Area"].asFloat();
-                    }
-                    if (value_f["form"]["AD_S_Standard"]["AD_2S_Len"])
-                    {
-                        function.f_AD_Check.S_standard_2s.len = value_f["form"]["AD_S_Standard"]["AD_2S_Len"].asFloat();
-                    }
-                    if (value_f["form"]["AD_S_Standard"]["AD_1S_Area"])
-                    {
-                        function.f_AD_Check.S_standard_1s.area = value_f["form"]["AD_S_Standard"]["AD_1S_Area"].asFloat();
-                    }
-                    if (value_f["form"]["AD_S_Standard"]["AD_1S_Len"])
-                    {
-                        function.f_AD_Check.S_standard_1s.len = value_f["form"]["AD_S_Standard"]["AD_1S_Len"].asFloat();
-                    }
-
-                    if (value_f["form"]["AD_Check_Num"]["Open"])
-                    {
-                        function.f_AD_Check.analysis_num.bOpen = value_f["form"]["AD_Check_Num"]["Open"].asBool();
-                    }
-                    if (value_f["form"]["AD_Check_Num"]["Num"])
-                    {
-                        function.f_AD_Check.analysis_num.numT = value_f["form"]["AD_Check_Num"]["Num"].asInt();
-                    }
-
-                    if (value_f["form"]["AD_Check_Dis"]["Open"])
-                    {
-                        function.f_AD_Check.analysis_dis.bOpen = value_f["form"]["AD_Check_Dis"]["Open"].asBool();
-                    }
-                    if (value_f["form"]["AD_Check_Dis"]["Dis"])
-                    {
-                        function.f_AD_Check.analysis_dis.disT = value_f["form"]["AD_Check_Dis"]["Dis"].asFloat();
-                    }
-
-                    if (value_f["form"]["AD_Check_S"]["Open"])
-                    {
-                        function.f_AD_Check.analysis_s.bOpen = value_f["form"]["AD_Check_S"]["Open"].asBool();
-                    }
-                    if (value_f["form"]["AD_Check_S"]["S_value"])
-                    {
-                        function.f_AD_Check.analysis_s.Check_s_Value = value_f["form"]["AD_Check_S"]["S_value"].asInt();
-                    }
-                    if (value_f["form"]["AD_Check_S"]["NG_3s"])
-                    {
-                        function.f_AD_Check.analysis_s.NG_3s = value_f["form"]["AD_Check_S"]["NG_3s"].asBool();
-                    }
-                    if (value_f["form"]["AD_Check_S"]["Num"])
-                    {
-                        function.f_AD_Check.analysis_s.Check_s_Num = value_f["form"]["AD_Check_S"]["Num"].asInt();
-                    }
-
-                    if (value_f["form"]["AD_Check_IOU"]["AD_IOU"])
-                    {
-                        function.f_AD_Check.analysis_iou.AD_IOU = value_f["form"]["AD_Check_IOU"]["AD_IOU"].asFloat();
-                    }
-                    if (value_f["form"]["AD_Check_IOU"]["AD_Expand"])
-                    {
-                        function.f_AD_Check.analysis_iou.AD_Expand = value_f["form"]["AD_Check_IOU"]["AD_Expand"].asFloat();
-                    }
-                }
-                else
-                {
-                    function.f_AD_Check.Init();
-                }
-                // getchar();
-            }
             // 异物检测
             if ("POL_Cam" == strCode)
             {
@@ -1116,6 +1037,24 @@ int ChannelFuntonConfigJson::GetFunction(Json::Value value, CheckFunction &funct
                 // function.f_markDet.print("UpQX");
                 // getchar();
             }
+            // 标签配置参数
+            if ("Det_BQ" == strCode)
+            {
+                auto value_f = value[i];
+                // std::cout << value_f << std::endl;
+                // getchar();
+                function.f_Det_BQ.bBQ_AI_Det = value_f["isOpen"].asBool();
+                {
+                    if (value_f["form"]["BQ_Param"]["BQ_expand"])
+                    {
+                        function.f_Det_BQ.BQ_expand = value_f["form"]["BQ_Param"]["BQ_expand"].asInt();
+                    }
+                    if (value_f["form"]["BQ_Param"]["bsaveAll"])
+                    {
+                        function.f_Det_BQ.bsaveAll = value_f["form"]["BQ_Param"]["bsaveAll"].asBool();
+                    }
+                }
+            }
         }
     }
     return 0;
@@ -1408,6 +1347,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
         _config.ad_check.bOpen = value_f["isOpen"].asBool();
         if (_config.ad_check.bOpen)
         {
+            // S标准
             if (value_f["form"]["AD_S_Standard"]["AD_3S_Area"])
             {
                 _config.ad_check.S_standard_3s.area = value_f["form"]["AD_S_Standard"]["AD_3S_Area"].asFloat();
@@ -1435,6 +1375,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
                 _config.ad_check.S_standard_1s.len = value_f["form"]["AD_S_Standard"]["AD_1S_Len"].asFloat();
             }
 
+            // 数量分析
             if (value_f["form"]["AD_Check_Num"]["Open"])
             {
                 _config.ad_check.analysis_num.bOpen = value_f["form"]["AD_Check_Num"]["Open"].asBool();
@@ -1444,6 +1385,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
                 _config.ad_check.analysis_num.numT = value_f["form"]["AD_Check_Num"]["Num"].asInt();
             }
 
+            // S数量分析
             if (value_f["form"]["AD_Check_Dis"]["Open"])
             {
                 _config.ad_check.analysis_dis.bOpen = value_f["form"]["AD_Check_Dis"]["Open"].asBool();
@@ -1453,6 +1395,7 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
                 _config.ad_check.analysis_dis.disT = value_f["form"]["AD_Check_Dis"]["Dis"].asFloat();
             }
 
+            // 距离分析
             if (value_f["form"]["AD_Check_S"]["Open"])
             {
                 _config.ad_check.analysis_s.bOpen = value_f["form"]["AD_Check_S"]["Open"].asBool();
@@ -1470,27 +1413,95 @@ int BaseFuntonConfigJson::GetFunction(Json::Value value)
             {
                 _config.ad_check.analysis_s.Check_s_Num = value_f["form"]["AD_Check_S"]["Num"].asInt();
             }
+
+            // IOU分析
+            if (value_f["form"]["AD_Check_IOU"]["AD_IOU"])
+            {
+                _config.ad_check.analysis_iou.AD_IOU = value_f["form"]["AD_Check_IOU"]["AD_IOU"].asFloat();
             }
-        else
+            if (value_f["form"]["AD_Check_IOU"]["AD_Expand"])
             {
-            _config.ad_check.Init();
+                _config.ad_check.analysis_iou.AD_Expand = value_f["form"]["AD_Check_IOU"]["AD_Expand"].asFloat();
             }
+
+            // 通道绑定
+            if (value_f["form"]["Bind_Channel"]["bUse_bind"])
+            {
+                _config.ad_check.analysis_bind.bUse = value_f["form"]["Bind_Channel"]["bUse_bind"].asBool();
             }
-    // 标签配置参数
+            auto value_qx = value_f["form"]["Bind_Channel"]["2s_main_channel"];
-    if ("Det_BQ" == strCode)
+            if (value_qx.isArray())
             {
-        auto value_f = value;
+                for (int idx = 0; idx < value_qx.size(); idx++)
-        // std::cout << value_f << std::endl;
-        // getchar();
-        _config.Det_BQ.bBQ_AI_Det = value_f["isOpen"].asBool();
                 {
-            if (value_f["form"]["bShield_BQ"]["BQ_expand"])
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_bind.main_channel_2s.push_back(channel);
+                }
+            }
+            value_qx = value_f["form"]["Bind_Channel"]["2s_second_channel"];
+            if (value_qx.isArray())
             {
-                _config.Det_BQ.BQ_expand = value_f["form"]["bShield_BQ"]["BQ_expand"].asInt();
+                for (int idx = 0; idx < value_qx.size(); idx++)
+                {
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_bind.second_channel_2s.push_back(channel);
                 }
             }
-        //  _config.edgeDet.print("edgeDet");
+
-        //  getchar();
+            value_qx = value_f["form"]["Bind_Channel"]["3s_main_channel"];
+            if (value_qx.isArray())
+            {
+                for (int idx = 0; idx < value_qx.size(); idx++)
+                {
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_bind.main_channel_3s.push_back(channel);
                 }
+            }
+            value_qx = value_f["form"]["Bind_Channel"]["3s_second_channel"];
+            if (value_qx.isArray())
+            {
+                for (int idx = 0; idx < value_qx.size(); idx++)
+                {
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_bind.second_channel_3s.push_back(channel);
+                }
+            }
+
+            value_qx = value_f["form"]["Bind_Channel"]["correlated_channels"];
+            if (value_qx.isArray())
+            {
+                for (int idx = 0; idx < value_qx.size(); idx++)
+                {
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_bind.correlated_channels.push_back(channel);
+                }
+            }
+
+            // 同画面分析
+            value_qx = value_f["form"]["Single_Channel"]["s_channel"];
+            if (value_qx.isArray())
+            {
+                for (int idx = 0; idx < value_qx.size(); idx++)
+                {
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_sf.s_sf.push_back(channel);
+                }
+            }
+            value_qx = value_f["form"]["Single_Channel"]["region1_channel"];
+            if (value_qx.isArray())
+            {
+                for (int idx = 0; idx < value_qx.size(); idx++)
+                {
+                    std::string channel = value_qx[idx].asString();
+                    _config.ad_check.analysis_sf.region_sf.push_back(channel);
+                }
+            }
+        }
+        else
+        {
+            _config.ad_check.Init();
+        }
+    }
+
     return 0;
 }