修复赢合单触发地址类型无法触发的问题。

添加三协预焊焊前模板。

include/sxGlobal.h

@@ -0,0 +1,142 @@
+#pragma once
+#include <missionBase.hpp>
+#include <detCallbackChain.hpp>
+#include <share.h>
+#include <QObject>
+#include <opencvPaintAlgo.hpp>
+#pragma region 基础函数
+#define CATCH_EXCEPTIONS \
+    catch (HDevEngineCpp::HDevEngineException& ex) { \
+        std::cout << "HDevEngineException: " << ex.Message() << std::endl; \
+        qDebug() << "HDevEngineException: " << ex.Message(); \
+    } \
+    catch (HalconCpp::HException& ex) { \
+        std::cout << "Halcon Exception Caught!" << std::endl; \
+        std::cout << "Error Code: " << ex.ErrorCode() << std::endl; \
+        std::cout << "Error Message: " << ex.ErrorMessage() << std::endl; \
+        qDebug() << "Halcon Exception Caught!"; \
+        qDebug() << "Error Code: " << ex.ErrorCode(); \
+        qDebug() << "Error Message: " << ex.ErrorMessage(); \
+    } \
+    catch (const std::exception& e) { \
+        std::cout << "Caught exception: " << e.what() << std::endl; \
+        qDebug() << "Caught exception: " << e.what(); \
+    }
+struct sx_581_address {
+    int triggerAddr = -1;
+    int triggerValue = -1;
+    int snAddr = -1;
+    QByteArray completeAddr = "-1";
+    QByteArray resultAddr = "-1";
+    int valueOffsetAddr = -1;
+};
+
+class detParams {
+public:
+
+};
+#pragma endregion
+
+//算法回调函数需要包含完整的算法流程以及发送信号,发送ui图表，捕获异常，处理异常等操作
+//并且注意 异常可能会导致运行不到发送信号的函数，请在处理异常时发送异常结果
+static bool generalAlgoTest(std::shared_ptr <detData> data, detParams* _detParams, sx_581_address address) {
+    try {
+        qDebug() << "SN" << QString::fromStdString(data->SNcode) << "algo start";
+        std::vector < std::string> defects = {"测试"};
+        ///////////////////取图//处理//////////////////
+        if (data->oriImgs.size() < 1)
+        {
+            qCritical() << "图片数量不满足要求：" << data->oriImgs.size();
+            return false;
+        }
+        if (data->oriImgs[0].rows == 100) {
+            cv::Mat Paint;
+            data->oriImgs[0].copyTo(Paint);
+            cv::putText(Paint, "time out", cv::Point(0, 50), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(255), 2);
+            return false;
+        }
+
+        cv::Mat Paint;
+        QMutex paintMutex;
+        clock_t start, finish;
+        start = clock();       
+        cv::Mat src1 = data->oriImgs[0];
+        if (src1.channels() != 3)
+            cv::cvtColor(src1, Paint, cv::COLOR_GRAY2BGR);
+        else
+            src1.copyTo(Paint);
+        
+        TextRendererZH textPainter(Paint.cols, Paint.rows, 15);
+        textPainter.putText(Paint, "划伤", cv::Point(10,10), cv::Scalar(0, 255, 0));
+        cv::putText(Paint, "pos:" + data->additional["触发地址"].toString().toStdString(), cv::Point(0, 50), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(255, 0, 0), 2);
+        data->service->_triggerManager->writeShort("D" + address.resultAddr + "_1");//发送结果
+        data->service->_missionResultHandle->handleAllResult(data->SNcode, !defects.size() > 0, defects);//发送图标操作
+        data->resultImgs.push_back(Paint);
+        return true;
+    }
+    CATCH_EXCEPTIONS
+    data->service->_triggerManager->writeShort("D" + address.resultAddr + "_2");//发送异常结果
+    return false;
+}
+template <typename paramTemplte>
+//此类适用于单相机多触发地址单次判断的情况，比如密封钉，三协机台
+//例触发地址有4个，输入信号为 1 0 0 1 则按顺序触发1和4的地址拍照检测，2和3不做处理
+class _581_SX_Single_triggerTemplate {
+public:
+    paramTemplte _detParams;
+    detCallbackChain<paramTemplte, sx_581_address>* generalDet;
+    std::string cameraName;
+    QString viewerName;
+    std::vector<sx_581_address>address;
+    /// <summary>
+    /// 初始化
+    /// </summary>
+    /// <param name="cameraNameIn">相机名</param>
+    /// <param name="viewerNameIN">窗口名</param>
+    /// <param name="startAddr">开始地址</param>
+    /// <param name="triggerCount">触发信号数</param>
+    /// <param name="oneTriggerCaptrueTimes">单次触发调用几次相机模块</param>
+    /// <param name="detParamsIn">参数输入</param>
+    /// <param name="_serviceManagerIn">默认</param>
+    /// <param name="bridgeIn">默认</param>
+    /// <param name="_processAlgoCallback">算法函数</param>
+    /// <param name="resultHandlerIn"></param>
+    void init(std::string cameraNameIn, QString viewerNameIN, std::vector<sx_581_address> addressIN, int oneTriggerCaptrueTimes,
+        paramTemplte& detParamsIn, ServiceManager* _serviceManagerIn, qtFuncBridge* bridgeIn,
+        typename detCallbackChain<paramTemplte, sx_581_address>::processAlgoCallback _processAlgoCallback,
+        QString saveObjectNameIN = "") {
+        viewerName = viewerNameIN;
+        cameraName = cameraNameIn;
+        _serviceManager = _serviceManagerIn;
+        _detParams = detParamsIn;
+        bridge = bridgeIn;
+        address = addressIN;
+        saveObjectName = saveObjectNameIN;
+        generalDet = new detCallbackChain<paramTemplte, sx_581_address>(_serviceManager, &_detParams, bridge);
+        generalDet->registerProcessAlgoCallback(_processAlgoCallback);
+        //单次触发器条件
+        for (int i = 0; i < addressIN.size(); i++) {
+            //注册单触发器 触发地址置1时触发
+            _serviceManager->_triggerManager->registerCallback(address[i].triggerAddr, 1, [this, i](int triggerPos, int triggerValue, QByteArray& byteArray) {
+                evaluate(i, byteArray);}, "");
+        }
+        
+    }
+    //获取图片并进行检测
+    void evaluate(int batteryOffset, QByteArray& byteArray) {
+        _serviceManager->_triggerManager->writeShort("D" + QByteArray::number(address[0].triggerAddr) + "_0");//触发信号清零
+        std::string sn = _serviceManager->_triggerManager->readSnFromQByteArray(byteArray, address[batteryOffset].snAddr, false, false, -1);
+		auto camera = _serviceManager->_cameraManager->getCamera(cameraName);//获取相机
+		camera->clearCache();//清除缓存
+        std::shared_ptr <detData> data = _serviceManager->_detDataManager->createDetData(
+            QString::number(address[batteryOffset].triggerAddr), sn, 1, camera->config.oriSaveFormat);//创建数据包
+        camera->captureImage(data);//拍照
+        data->saveObjectName = saveObjectName;
+        generalDet->ansyncProcess(data, address[batteryOffset], ("D" + address[0].completeAddr + "_0"));//处理算法 并在取到图片后发送完成信号
+        data->resultImgShowSet.push_back(showImgPack(viewerName, "结果图"));
+    }
+private:
+    QString saveObjectName = "";
+    qtFuncBridge* bridge;
+    ServiceManager* _serviceManager = nullptr;
+};

include/yhGlobal.h

@@ -218,7 +218,7 @@ public:
         //单次触发器条件
         for (int i = 0; i < triggerCount; i++) {
             //注册单触发器 触发地址置1时触发
-            _serviceManager->_triggerManager->registerCallback(address[i].triggerAddr, 0, [this, i](int triggerPos, int triggerValue, QByteArray& byteArray) {
+            _serviceManager->_triggerManager->registerCallback(address[i].triggerAddr, 1, [this, i](int triggerPos, int triggerValue, QByteArray& byteArray) {
                 evaluate(i, byteArray);}, "");
             //注册清除完成信号触发器 任意触发地址归零时触发一次
             _serviceManager->_triggerManager->registerCallback(address[i].triggerAddr, 0, [this, i](int triggerPos, int triggerValue, QByteArray& byteArray) {

src/core/back/detCallbackChain.hpp

@@ -26,17 +26,18 @@ public:
 
 	}
 	//异步启动检测
-	void ansyncProcess(std::shared_ptr <detData> data, addressTemplate address = addressTemplate()) {
-		QFuture<void> future = QtConcurrent::run([this, data, address]() {
+	void ansyncProcess(std::shared_ptr <detData> data, addressTemplate address, QByteArray completeSignal = "") {
+		QFuture<void> future = QtConcurrent::run([this, data, address, completeSignal]() {
 			process(data, address);
 			});
 	}
 	//启动检测
-	void process(std::shared_ptr <detData> data, addressTemplate address = addressTemplate()) {
+	void process(std::shared_ptr <detData> data, addressTemplate address, QByteArray completeSignal = "") {
 		data->service = _serviceManager;
 		while (data->oriImgs.size() < data->imgAmountMin) {
 			std::this_thread::sleep_for(std::chrono::milliseconds(1));
 		}
+		_triggerManager->writeShort(completeSignal);
 		//等待图片满足要求后，储存原图，异步执行算法函数
 		auto resultData = algoEvaluate(data, _handleAiModels, address);
 		// 确保线程安全退出

src/launcher/GUI/mainwindow.h

@@ -27,7 +27,7 @@
 #include "front/pages/historyWidget.h"
 #include <appConfig/appConfig.h>
 #include "front/pages/pluginManagerWidget.hpp"
-#include "front/pages/summary_data_page.h"
+#include "front/pages/summaryDataPage.h"
 #include <qtBridge.h>
 #include <hardwareInfo.h>
 #pragma execution_character_set("utf-8")

src/mission/581-Mfd_yh_mh_hh/581-Mfd.h

@@ -1,15 +1,59 @@
 #include <missionBase.hpp>
 #include <yhGlobal.h>
+#include "cal_disJiao.h"
 class mfd_detParams {
 public:
     int biaoding = 0;
 };
 #pragma region 算法
+
 #include <simpleAlgo.h>
 #include <hdevengine/HDevEngineCpp.h>
 #include <opencvPaintAlgo.hpp>
+#  include "HalconCpp.h"
 using namespace HDevEngineCpp;
+using namespace HalconCpp;
+
 static bool ManHan(std::shared_ptr <detData> data, mfd_detParams* _detParams, yh_581_address address){
+    HObject ho_in_image;
+
+    HTuple hv_out_standardPar;
+    HTuple hv_out_flat;
+    HTuple in_ProductType;
+    HTuple hv_out_disLeftVertical;
+    HTuple hv_out_LeftVerticalLinePar;
+    HTuple hv_out_disLeftLevel;
+    HTuple hv_out_LeftLevelLinePar;
+    HTuple hv_out_disRightVertical;
+    HTuple hv_out_RightVerticalLinePar;
+    HTuple hv_out_disRightLevel;
+    HTuple hv_out_RightLevelLinePar;
+	cv::Mat img = cv::imread("D:/CCD/2025-10-04-19-57-14-928_04QCB6CJ27501JFA40006167_camera4_3.bmp", -1);
+    cv::cvtColor(img, img, cv::COLOR_BGR2GRAY);
+    cv::threshold(img, img, 60, 255, cv::THRESH_BINARY);
+    std::vector<std::vector<cv::Point>> contours;
+    cv::findContours(img, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
+    if (contours.size() != 0)
+    {
+        for (int j = 0; j < contours.size(); j++)
+        {
+            cv::Rect rect = cv::boundingRect(contours[j]);
+
+            if (rect.width > 1000 && rect.height > 900 )
+            {
+                return true;
+            }
+        }
+    }
+    //cv::cvtColor(img, img, cv::COLOR_GRAY2BGR);
+    ho_in_image = MatToHObject(img);
+    in_ProductType = "181-2";
+    cal_distanceJiao_4(ho_in_image, in_ProductType, &hv_out_standardPar, &hv_out_flat,
+        &hv_out_disLeftVertical, &hv_out_LeftVerticalLinePar, &hv_out_disLeftLevel,
+        &hv_out_LeftLevelLinePar, &hv_out_disRightVertical, &hv_out_RightVerticalLinePar,
+        &hv_out_disRightLevel, &hv_out_RightLevelLinePar);
+    int falg = hv_out_flat.I();
+    return true;
     std::map<QString, QVariant> sqlMapData;
     sqlMapData["项目"] = "上钉";
     sqlMapData["相机"] = "相机" + address.triggerAddr;
@@ -283,6 +327,8 @@ static bool YuHan(std::shared_ptr <detData> data, mfd_detParams* _detParams, yh_
 
     return true;
 }
+
+
 #pragma endregion
 class _581_Mfd : public mission {
 public:

src/mission/581_YuHan_hanqian/581_YuHan_hanqian.cpp

@@ -0,0 +1,8 @@
+#include <581_YuHan_hanqian.h>
+
+mission* createMission() {
+	return new _581_YuHan_hanqian();
+}
+void destroyMission(mission* _mission) {
+	delete _mission;
+}

src/mission/581_YuHan_hanqian/581_YuHan_hanqian.h

@@ -0,0 +1,255 @@
+#include <missionBase.hpp>
+#include <sxGlobal.h>
+#pragma region 算法
+#include <simpleAlgo.h>
+#include <hdevengine/HDevEngineCpp.h>
+#include <opencvPaintAlgo.hpp>
+using namespace HDevEngineCpp;
+#pragma endregion
+class yuHanHanQianParams {
+public:
+    handleAiModelSeg* segDingWei = nullptr;
+
+	handleAiModelSeg* segJiErFanZhe = nullptr;
+    handleAiModelCls* clsJiErFanZhe = nullptr;
+};
+void halconProcess(cv::Mat& sourceImg, cv::Mat& Paint) {
+	try {
+		HDevEngineCpp::HDevProcedure proc("Inspection_YH_JE");
+		HDevEngineCpp::HDevProcedureCall procedureCall(proc);
+		HObject in_Image = MatToHObject(sourceImg);
+		procedureCall.SetInputIconicParamObject("in_Image", in_Image);//设置输入图像类变量
+		procedureCall.Execute();//执行halcon程序
+		HTuple out_X, out_Y, out_Flag;
+		out_X = procedureCall.GetOutputCtrlParamTuple("out_X");
+		out_Y = procedureCall.GetOutputCtrlParamTuple("out_Y");
+		out_Flag = procedureCall.GetOutputCtrlParamTuple("out_Flag");
+		if (out_Flag.D() == 0) {
+			for (int i = 0; i < out_X.Length(); i++)
+				Paint.at<cv::Vec3b>(out_X[i].D(), out_Y[i].D()) = { 255,255,0 };
+		}
+	}
+	catch (HDevEngineCpp::HDevEngineException& ex) {
+		
+			std::cout << "HDevEngineException: " << ex.Message() << std::endl; \
+			qDebug() << "HDevEngineException: " << ex.Message(); \
+	} 
+	catch (HalconCpp::HException& ex) {
+			
+			std::cout << "Halcon Exception Caught!" << std::endl; \
+			std::cout << "Error Code: " << ex.ErrorCode() << std::endl; \
+			std::cout << "Error Message: " << ex.ErrorMessage() << std::endl; \
+			qDebug() << "Halcon Exception Caught!"; \
+			qDebug() << "Error Code: " << ex.ErrorCode(); \
+			qDebug() << "Error Message: " << ex.ErrorMessage(); \
+	} 
+}
+cv::Rect getImageLocateRect(cv::Mat& src, handdleAI::pSegmentation* seg, double bounus = 0.1) {
+	cv::Mat tmpImg;
+	cv::resize(src, tmpImg, cv::Size(), bounus, bounus);
+	cv::Mat ouput = ~seg->Evaluate(tmpImg);
+	auto rect = findMaxAreaContour(ouput);
+	rect.x /= bounus; rect.y /= bounus;
+	rect.width /= bounus; rect.height /= bounus;
+	return rect;
+}
+bool handleAiProcess(cv::Mat& seg_detImg, cv::Mat& seg_Paint,
+	handdleAI::pSegmentation* segPtr, handdleAI::pClassification* clsPtr,
+	std::vector< std::pair <std::string, cv::Mat>>& clsImgs){
+	cv::Mat segResizeImg;
+	float resizeRate = 1.0;
+	cv::resize(seg_detImg, segResizeImg, cv::Size(), 1.0 / resizeRate, 1.0 / resizeRate);
+	cv::Mat seg_ResultImg = ~segPtr->Evaluate(segResizeImg);
+	cv::resize(seg_ResultImg, seg_ResultImg, cv::Size(), resizeRate, resizeRate);
+	std::vector<std::vector<cv::Point>> contours;
+	cv::findContours(seg_ResultImg, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
+	bool finalNg = false;
+	for (int i = 0; i < contours.size(); i++)
+	{
+		cv::Rect cls_rect = cv::boundingRect(contours[i]);
+		if (cls_rect.width < 50 || cls_rect.height < 50)
+			continue;
+#if 1
+		std::vector<cv::Mat> clsImgVec = cutImg2ClsVec(cls_rect, seg_detImg);
+		std::vector<int> clsRes;//true ok
+		bool isNg = false;
+		for (auto& cls : clsImgVec) {
+			cv::resize(cls, cls, cv::Size(128, 128));//根据需要设定大小
+			int Result = clsPtr->Evaluate(cls);
+			if (Result != 0)isNg = true;
+			clsRes.push_back(Result);
+			clsImgs.push_back({ std::to_string(Result) ,cls });
+		}
+		if (isNg == true) {
+			cv::Scalar color = cv::Scalar(0, 255, 255, 30);
+			cv::rectangle(seg_Paint, cls_rect, color, 4);
+			drawContours(seg_Paint, contours, i, cv::Scalar(0, 0, 255, 30), 3);
+			finalNg = true;
+		}
+		else {
+			//drawContours(seg_Paint, contours, i, cv::Scalar(0, 255, 0, 30), 3);
+		}
+#else
+		bool isNg = false;
+		cv::Mat clsImage = cutLabelImg(seg_detImg, 200, 200, cls_rect, 0, 1, 1);
+		int Result = clsPtr->Evaluate(clsImage);
+		if (Result != 0) {
+			isNg = true;
+			cv::Scalar color = cv::Scalar(0, 255, 255, 30);
+			cv::rectangle(seg_Paint, cls_rect, color, 4);
+			drawContours(seg_Paint, contours, i, cv::Scalar(0, 0, 255, 30), 3);
+			finalNg = true;
+		}
+		else {
+
+		}
+		clsImgs.push_back({ Result , clsImage });
+#endif
+	}
+	return finalNg;
+}
+bool jiErFanZhe(std::shared_ptr <detData> data, yuHanHanQianParams* _detParams, sx_581_address address) {
+	try{
+#if 0
+		/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓调试用↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
+		cv::Mat resultImage = img2D.clone();
+		if (resultImage.channels() == 1) {
+			cv::cvtColor(resultImage, resultImage, cv::COLOR_GRAY2BGR);
+		}
+		QString okng_tag = "OK";
+		cv::Mat seg_detectImage;
+		cv::resize(img2D, seg_detectImage, cv::Size(), 1, 1);
+		plcResult = "1";
+		bool isNG = false;
+		if (DOGLIVE) {
+			std::vector<std::pair <int, cv::Mat >>clsImgs;
+			bool isNG = handleAiProcess(seg_detectImage, resultImage, seg_jierFanZhe, cls_jierFanZhe, clsImgs);
+			for (int i = 0; i < clsImgs.size(); i++) {
+				addImgToSaveStruct(clsImgs[i].second, "0", getClsSaveFormat(SN, okng_tag, i, clsImgs[i].first));
+			}
+		}
+		if (isNG == false)//OK
+		{
+			putTextHusky(resultImage, utf8_to_gbk("OK").c_str(), cv::Point(50, 50), cv::Scalar(0, 255, 0), 200);
+			okng_tag = "OK";
+		}
+		else
+		{
+			putTextHusky(resultImage, utf8_to_gbk("NG").c_str(), cv::Point(50, 50), cv::Scalar(0, 0, 255), 200);
+			plcResult = "2";
+		}
+		cv::resize(resultImage, resultImage, cv::Size(), 0.5, 0.5);
+		resMat.push_back(resultImage);
+		if (resMat.size() > 0)
+		{
+			addImgToSaveStruct(seg_detectImage, "0", getSegSaveFormat(SN, okng_tag));//存seg图
+			addImgToSaveStruct(resMat[0], "0", getResSaveFormat(SN, okng_tag));//存结果图
+		}
+		addImgToSaveStruct(HikMat[0], "0", getOriSaveFormat(SN, okng_tag));//存原图图
+
+		return true;
+		/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑调试用↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
+#else
+		//存图数据加保存队列，加锁，避免数据访问冲突
+		QByteArray plcResult = "2";
+		cv::Mat sourceImg;
+		data->oriImgs[0].copyTo(sourceImg);
+		cv::Mat Paint;
+		sourceImg.copyTo(Paint);
+		if (Paint.channels() == 1)
+			cvtColor(Paint, Paint, cv::COLOR_GRAY2BGR);
+		halconProcess(sourceImg, Paint);
+		float resizeRate = 5.0;
+		auto rect = getImageLocateRect(sourceImg, _detParams->segDingWei->segPtr, 1.0 / resizeRate);//定位
+		rect = rect & (cv::Rect(0, 0, sourceImg.cols, sourceImg.rows));//防止越界
+		bool isNG = false;
+		cv::Mat seg_saveImg;
+		if (rect.width > 500 || rect.height > 500) {
+			isNG = handleAiProcess(sourceImg(rect), Paint(rect), _detParams->segJiErFanZhe->segPtr, _detParams->clsJiErFanZhe->clsPtr, data->clsOriginImgs);
+			cv::rectangle(Paint, rect, cv::Scalar(0, 255, 255), 3);
+			cv::resize(sourceImg(rect), seg_saveImg, cv::Size(), 0.5, 0.5);
+		}
+		else {
+			isNG = true;
+		}
+		QString okNgSaveText = "NG";
+		TextRendererZH textPainter(Paint.cols, Paint.rows, 15);
+		if (isNG == false)//OK
+		{
+			textPainter.putText(Paint, "OK", cv::Point(1000, 50), cv::Scalar(0, 255, 0));
+			okNgSaveText = "OK";
+		}
+		else
+		{
+			textPainter.putText(Paint, "NG", cv::Point(1000, 50), cv::Scalar(0, 255, 0));
+			data->aiDetOK = false;
+			plcResult = "2";
+		}
+		plcResult = "1";//强制OK
+		data->resultImgs.push_back(Paint);
+		sourceImg.release();
+		data->service->_triggerManager->writeShort("D" + address.resultAddr + "_" + plcResult);//结果反馈
+#endif
+	}
+	CATCH_EXCEPTIONS
+	
+	qDebug() << "[Error] " << QString::fromUtf8("检测失败!");
+	cv::Mat Paint;
+	data->oriImgs[0].copyTo(Paint);
+	if (Paint.channels() == 1)
+		cvtColor(Paint, Paint, cv::COLOR_GRAY2BGR);
+	TextRendererZH textPainter(Paint.cols, Paint.rows, 15);
+	textPainter.putText(Paint, "NG", cv::Point(1000, 50), cv::Scalar(0, 255, 0));
+	cv::resize(Paint, Paint, cv::Size(), 0.5, 0.5);
+	data->resultImgs.push_back(Paint);
+	data->service->_triggerManager->writeShort("D" + address.resultAddr + "_2");//结果反馈
+	return true;
+}
+class _581_YuHan_hanqian : public mission {
+public:
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> in_lv_top_1;
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> in_lv_down_2;
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> in_tong_top_3;
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> in_tong_down_4;
+
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> out_lv_top_5;
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> out_lv_down_6;
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> out_tong_top_7;
+    _581_SX_Single_triggerTemplate< yuHanHanQianParams> out_tong_down_8;
+    yuHanHanQianParams tongDetParams;
+	yuHanHanQianParams lvDetParams;
+    void onConfigReloaded() {
+        HDevEngineCpp::HDevEngine myEngine;
+        myEngine.SetProcedurePath("./halconAlgoFiles/AlgoLibrary_602.hdpl");
+
+		tongDetParams.segDingWei = _serviceManager->_handleAiModelManager->getSegModel("segDingWei_GPU0");
+		tongDetParams.segJiErFanZhe = _serviceManager->_handleAiModelManager->getSegModel("segTongJiErFanZhe_GPU0");
+		tongDetParams.clsJiErFanZhe = _serviceManager->_handleAiModelManager->getClsModel("clsTongJiErFanZhe_GPU0");
+
+
+		lvDetParams.segDingWei = _serviceManager->_handleAiModelManager->getSegModel("clsLvJiErFanZhe_GPU1");
+		lvDetParams.segJiErFanZhe = _serviceManager->_handleAiModelManager->getSegModel("segLvJiErFanZhe_GPU1");
+		lvDetParams.clsJiErFanZhe = _serviceManager->_handleAiModelManager->getClsModel("clsLvJiErFanZhe_GPU1");
+
+    }
+    bool initCustom() {
+#pragma region 注册触发器回调
+		in_lv_top_1.init("Camera1", "极耳翻折-铝-内-相机1（顶部）", { { 522, 1,540,"523","530",-1} }, 1, tongDetParams, _serviceManager, bridge, jiErFanZhe);
+		in_lv_down_2.init("Camera2", "极耳翻折-铝-内-相机2（底部）", { { 524, 1,620,"525","532",-1} }, 1, tongDetParams, _serviceManager, bridge, jiErFanZhe);
+		in_tong_top_3.init("Camera3", "极耳翻折-铜-内-相机3（顶部）", { { 526,1,540,"527","534",-1} }, 1, tongDetParams, _serviceManager, bridge, jiErFanZhe);
+		in_tong_down_4.init("Camera4", "极耳翻折-铜-内-相机4（底部）", { { 528, 1,620,"529","536",-1} }, 1, tongDetParams, _serviceManager, bridge, jiErFanZhe);
+
+		out_lv_top_5.init("Camera5", "极耳翻折-铝-外-相机5（顶部）", { { 562,1,580,"563","570",-1} }, 1, lvDetParams, _serviceManager, bridge, jiErFanZhe);
+		out_lv_down_6.init("Camera6", "极耳翻折-铝-外-相机6（底部）", { { 564, 1,660,"565","572",-1} }, 1, lvDetParams, _serviceManager, bridge, jiErFanZhe);
+		out_tong_top_7.init("Camera7", "极耳翻折-铜-外-相机7（顶部）", { { 566, 1,580,"567","574",-1} }, 1, lvDetParams, _serviceManager, bridge, jiErFanZhe);
+		out_tong_down_8.init("Camera8", "极耳翻折-铜-外-相机8（底部）", { { 568, 1,660,"569","576",-1} }, 1, lvDetParams, _serviceManager, bridge, jiErFanZhe);
+#pragma endregion
+        return true;
+    }
+};
+
+
+
+
+
+#pragma once

src/mission/581_YuHan_hanqian/CMakeLists.txt

@@ -0,0 +1,78 @@
+# 获取获取当前目录名
+get_filename_component(CURRENT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+string(TIMESTAMP RUN_TIME)
+message( " model start : " ${CURRENT_FOLDER}:${RUN_TIME})
+
+set(DLL_NAMES "opencv" "halcon" "handdleAI")
+foreach(child ${DLL_NAMES})         
+    LIST(APPEND ENV_INCLUDE ${${child}_include})
+    LIST(APPEND ENV_LIB ${${child}_lib})
+    LIST(APPEND ENV_TARGET ${${child}_target_link})         
+endforeach()
+message("   ENV_INCLUDE : " ${ENV_INCLUDE} )
+message("   ENV_LIB : " ${ENV_LIB} )
+message("   ENV_TARGET : " ${ENV_TARGET} )
+include_directories(
+    ${PROJECT_ROOT_PATH}/src/core
+    ${PROJECT_ROOT_PATH}/src/core/handleAi
+    ${PROJECT_ROOT_PATH}/src/core/back
+    ${PROJECT_ROOT_PATH}/src/core/sql
+    ${ENV_INCLUDE}
+    )
+
+link_directories (
+    ${ENV_LIB}
+
+    )
+add_compile_options(/utf-8)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_AUTOMOC ON)
+SET(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+ 
+FILE(GLOB HEAD_FILES "*.h" )
+FILE(GLOB SRC_FILES "./*.cpp")
+FILE(GLOB UI_FILES "./*.ui")
+
+
+#find_package(Qt5 COMPONENTS Core REQUIRED)
+find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Gui Network Sql REQUIRED)
+find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Gui Network Sql REQUIRED)
+
+add_library(${CURRENT_FOLDER} SHARED
+    ${HEAD_FILES}
+    ${SRC_FILES}
+    ${UI_FILES}
+    ${PROJECT_ROOT_PATH}/include/qtBridge.h
+    )
+
+
+
+set_target_properties(${CURRENT_FOLDER} PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+    LIBRARY_OUTPUT_DIRECTORY  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
+    ARCHIVE_OUTPUT_DIRECTORY  ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}
+    )
+
+
+target_link_libraries(${CURRENT_FOLDER} PRIVATE
+    ${ENV_TARGET}
+    Qt${QT_VERSION_MAJOR}::Core
+    Qt${QT_VERSION_MAJOR}::Gui 
+    Qt${QT_VERSION_MAJOR}::Network
+    Qt${QT_VERSION_MAJOR}::Sql
+    )
+
+
+# target_compile_definitions(${CURRENT_FOLDER} PRIVATE HD_AIDEMO_MODULE_LIBRARY)
+
+
+
+
+string(TIMESTAMP RUN_TIME)
+message( " modelx end : " ${CURRENT_FOLDER}:${RUN_TIME})
+message( " header files "${HEAD_FILES})