优化整体，模型算法测试完毕，切换机型留坑

HanddleAI/HandleAiUi-new/algo/ALGO_Inspection.h

@@ -1,5 +1,7 @@
 #include <back/threadPoolManager.h>
 #include <halconAlgo/Inspection.h>
+#include <future>
+#include <chrono>
 
 static HalconCpp::HObject MatToHObject(cv::Mat& image)
 {
@@ -212,39 +214,52 @@ static void MatToHObjectV(cv::Mat& image, HalconCpp::HObject& Hobj)
 
 }
 
-
 void pinHandleAiEvaluate(cv::Mat& src, cv::Mat& Paint, 
-    handdleAI::pSegmentation *segPtr, handdleAI::pClassification* clsPtr)
+    handleAiModelSeg*segPtr, handleAiModelCls* clsPtr)
 {
+    auto start = std::chrono::high_resolution_clock::now();
     cv::Mat segRes = ~segPtr->Evaluate(src);
     std::vector<std::vector<cv::Point>> contours;
     cv::findContours(segRes, contours, cv::RETR_EXTERNAL,cv::CHAIN_APPROX_NONE);
+    int cnt = 0;
+
     for (auto contour : contours)
     {
         cv::Rect rect = cv::boundingRect(contour);
-        rect += cv::Size(1, 1);
-        rect = cv::Rect(
-            max(0, rect.x),
-            max(0, rect.y),
-            min(rect.x + rect.width, src.rows),
-            min(rect.y + rect.height, src.cols)
-        );
+        if (rect.width < 10 || rect.height < 10)
+            continue;
 
-        int clsRes = clsPtr->Evaluate(src(rect));
+        int maxHeightOrWidth = max(rect.width, rect.height);
+        int exHeight = max(maxHeightOrWidth - rect.height, 0);
+        int exWidth = max(maxHeightOrWidth - rect.width, 0);
+        rect += cv::Size(exWidth, exHeight);
+        //判断左上是否越界
+        rect.x = max(0, rect.x);
+        rect.y = max(0, rect.y);
+        //判断右下是否越界
+        rect.x = min(src.cols - rect.width, rect.x);
+        rect.y = min(src.rows - rect.height, rect.y);
+
+        cv::Mat clsImg;
+        src(rect).copyTo(clsImg);
+        cv::resize(clsImg, clsImg, cv::Size(128, 128));
+
+        int clsRes = clsPtr->Evaluate(clsImg);
         cv::Scalar color;
         switch (clsRes)
         {
         case 0:
-            color = cv::Scalar(0, 255, 0, 128);
+            color = cv::Scalar(0, 255, 0, 30);
             break;
         case 1:
-            color = cv::Scalar(255, 0, 0, 128);
+            color = cv::Scalar(255, 0, 0, 30);
             break;
         default:
-            color = cv::Scalar(255, 255, 255, 128);
+            color = cv::Scalar(255, 255, 255, 30);
         }
         cv::rectangle(Paint, rect, color, 2);
     }
+
 }
 
 void pinHalconEvaluate(std::vector<cv::Rect>& Result,cv::Mat& src, cv::Mat& Paint)
@@ -315,6 +330,7 @@ void ALGO_Inspection(std::shared_ptr <detData> data, handleAiModelManager* _hand
     std::vector<cv::Rect>halconResult;
     //hv_in_Parameter
     //[0]-产品种类; 1A正面 2A反面 3B正面 4C正面
+    int productType = 2;
     //[1]-图像序号第一位;
     //[2]-图像序号第二位;
     //[3]-3d相机精度（mm）;
@@ -332,15 +348,15 @@ void ALGO_Inspection(std::shared_ptr <detData> data, handleAiModelManager* _hand
         pinHandleAiEvaluate(src(halconResult[0]), Paint(halconResult[0]),
             _handleAiModelManager->largeSeg, _handleAiModelManager->largeCls);
         break;
-    case 1:
+    case 1://3 p
         pinHandleAiEvaluate(src(halconResult[0]), Paint(halconResult[0]),
             _handleAiModelManager->largeSeg, _handleAiModelManager->largeCls);
         break;
-    case 2:
+    case 2://2
         pinHandleAiEvaluate(src(halconResult[0]), Paint(halconResult[0]),
             _handleAiModelManager->midSeg, _handleAiModelManager->midCls);
         break;
-    case 3:
+    case 3://1
         pinHandleAiEvaluate(src(halconResult[0]), Paint(halconResult[0]),
             _handleAiModelManager->smallSeg, _handleAiModelManager->smallCls);
         break;
@@ -349,4 +365,5 @@ void ALGO_Inspection(std::shared_ptr <detData> data, handleAiModelManager* _hand
 	rectangle(Paint, halconResult[0], cv::Scalar(0, 0, 255), 4);
     data->resultImgs.push_back(Paint);
 	_sleep(100);
-}
+}
+

HanddleAI/HandleAiUi-new/back/backEndManager.cpp

@@ -32,21 +32,33 @@ void backEndManager::run()
 	}
 	if(isInit == NotInit)
 	{
-
+		//µÈ´ý³õʼ»¯
 		std::vector<std::future<void>> futures;//Òì²½³õʼ»¯
-		futures.push_back(std::async(std::launch::async, &threadManager::init, _threadManager, this));
-		futures.push_back(std::async(std::launch::async, &triggerManager::init, _triggerManager, this));
-		futures.push_back(std::async(std::launch::async, &cameraManager::init, _cameraManager, this));
-		futures.push_back(std::async(std::launch::async, &sqlManager::initPara, &_sqlManager, sqlDefaultDatabasePath,true));
-		futures.push_back(std::async(std::launch::async, &handleAiModelManager::init, _handleAiModelManager,this));
+		futures.push_back(std::async(std::launch::async, &threadManager::initialization, _threadManager, this));
+		futures.push_back(std::async(std::launch::async, &triggerManager::initialization, _triggerManager, this));
+		futures.push_back(std::async(std::launch::async, &cameraManager::initialization, _cameraManager, this));
+		futures.push_back(std::async(std::launch::async, &sqlManager::initialization, &_sqlManager, sqlDefaultDatabasePath,true));
+		futures.push_back(std::async(std::launch::async, &handleAiModelManager::initialization, _handleAiModelManager,this));
 		for (auto& future : futures) {
 			future.wait();
 		}
+
 		_imgSaveThreadManager->start();
-		if (_triggerManager->isInit == true && _cameraManager->isInit == true)
+		_triggerManager->start();
+		if (_threadManager->initFlag == true)
+		{
+			_threadManager->start();
+		}
+		if (_triggerManager->initFlag == true && _cameraManager->initFlag == true)
+		{
 			isInit = InitOK;
+			_triggerManager->start();
+			_cameraManager->start();
+		}
 		else
+		{
 			isInit = InitFailure;
+		}
 		sendInitFinished(isInit);
 	}
 }

HanddleAI/HandleAiUi-new/back/backEndManager.h

@@ -17,7 +17,7 @@ class backEndManager :public QThread
 	Q_OBJECT
 public:
 	initStatus isInit = NotInit;
-	QMutex mutex;
+	std::mutex mutex;
 
 	//数据类
 	jsonConfiguration* _jsonConfiguration = nullptr;
@@ -33,21 +33,15 @@ public:
 
 	backEndManager();
 	~backEndManager();
-
-	void init()
+public slots:
+	void initialization()
 	{
 		isInit = NotInit;
 		this->start();
-	}
-	void run();
-public slots:
-	void reInitSlot()
-	{
-		isInit = ReInit;
-		this->start();
+		//std::async(std::launch::async, &backEndManager::run, this);
 	}
 private:
-	
+	void run();
 signals:
 	void sendErrorToMainwindow(backEndError);
 	void sendPixmapImageWidget(showImgPack*);

HanddleAI/HandleAiUi-new/back/cameraManager.cpp

@@ -99,7 +99,7 @@ cameraManager::~cameraManager()
 
 	
 }
-void cameraManager::init(backEndManager* input)
+void cameraManager::initialization(backEndManager* input)
 {
 	_backEndManager = input;
 #pragma region 加载相机dll
@@ -160,13 +160,11 @@ void cameraManager::init(backEndManager* input)
 		{
 			QByteArray errorStr("getStatus");
 			m_module.module_ptr->sendData(vec_mat,errorStr);
-			isInit = false;
+			initFlag = false;
 			qCritical() << "[Error] " << " moduleName:" << m_module.moduleName << " initParas failed!";
 			emit _backEndManager->sendInitString("相机" + m_module.key + "初始化失败->"+ errorStr);
 		}
 	}
-
-	this->start();
 }
 bool cameraManager::loadModule(QString keyName, QString moduleName, QByteArray initByte)
 {

HanddleAI/HandleAiUi-new/back/cameraManager.h

@@ -106,7 +106,8 @@ class cameraManager : public QThread
 {
 	Q_OBJECT
 public:
-	void init(backEndManager*);
+	bool initFlag = true;
+	void initialization(backEndManager*);
 	~cameraManager();
 	std::unordered_map<std::string, camera*>cameras;//key 相机名
 	camera* getCamera(std::string cameraName)
@@ -133,7 +134,6 @@ public:
 			camera.second->stop();
 		this->terminate();
 	}
-	bool isInit = true;
 private:
 	bool loadModule(QString keyName, QString moduleName, QByteArray initByte);
 	backEndManager* _backEndManager;

HanddleAI/HandleAiUi-new/back/threadPoolManager.cpp

@@ -42,15 +42,16 @@ threadManager::threadManager()
 	//this->start();
 }
 
-void threadManager::init(backEndManager* _backEndManagerIn)
+void threadManager::initialization(backEndManager* _backEndManagerIn)
 {
 	_backEndManager = _backEndManagerIn;
 	sql = &_backEndManager->_sqlManager;
 	_imgSaveThreadManager = _backEndManagerIn->_imgSaveThreadManager;
 	_triggerManager = _backEndManagerIn->_triggerManager;
 	_handleAiModelManager = _backEndManager->_handleAiModelManager;
-	this->start();
+	initFlag = true;
 }
+
 void threadManager::process()
 {
 
@@ -60,12 +61,14 @@ void threadManager::process()
 		waitImgData.push_back(insertQueue.dequeue());
 	queueMutex.unlock();
 #pragma endregion
-#pragma region 等待图片满足要求后异步执行算法函数
+#pragma region 等待图片满足要求后，储存原图，异步执行算法函数
 	for (auto it = waitImgData.begin(); it != waitImgData.end();)
 	{
 		std::shared_ptr<detData> ptr = *it;
 		if (ptr->oriImgs.size() >= ptr->imgAmountMin)
 		{
+			_imgSaveThreadManager->oriSaveThread->imgDataQueue.append(ptr);
+
 			algoFutures.insert(std::make_pair(ptr->timeCode, std::async(std::launch::async, processAlgo, ptr,_handleAiModelManager)));
 			processData.push_back(ptr);
 

HanddleAI/HandleAiUi-new/back/threadPoolManager.h

@@ -189,6 +189,7 @@ class threadManager : public QThread
     Q_OBJECT
         
 public:
+    bool initFlag = false;
     threadManager();
 
     sqlManager* sql;
@@ -198,7 +199,7 @@ public:
 
     QQueue<std::shared_ptr <detData>> detDataQueue;
     autoDelete* autoDeleteThread;
-    void init(backEndManager* _backEndManagerIn);
+    void initialization(backEndManager* _backEndManagerIn);
     void run();
     void stop()
     {
@@ -214,7 +215,7 @@ public:
     QMutex queueMutex;
 
     QMutex insertQueueMutex;
-    QQueue<std::shared_ptr <detData>>insertQueue;
+    QQueue<std::shared_ptr  <detData>>insertQueue;
     void process();
 private:
     backEndManager* _backEndManager;

HanddleAI/HandleAiUi-new/back/triggerManager.cpp

@@ -6,6 +6,56 @@
 #include <jsonParsing.h>
 #define debugTesting 1
 static correctionStruct* correctionData;
+void triggerManager::initialization(backEndManager* input)
+{
+    _backEndManager = input;
+    dManager = _backEndManager->_detDataManager;
+    _cameraManager = _backEndManager->_cameraManager;
+    _threadManager = _backEndManager->_threadManager;
+    _jsonConfiguration = _backEndManager->_jsonConfiguration;
+
+    triggerFileName = _jsonConfiguration->tcp.moduleName;
+    IpAndPort = _jsonConfiguration->tcp.finstcp_init;
+    //triggerInitStr = QByteArray("sleeptime_%1_readnum_%2_writetype_ushort");
+    QLibrary* m_lib = new QLibrary(triggerFileName);
+    bool flag = m_lib->load();
+    if (!m_lib->isLoaded())
+    {
+        //emit _backEndManager->sendErrorToMainwindow(dllNotFound);
+        emit _backEndManager->sendInitString("找不到" + triggerFileName);
+        return;
+    }
+
+    if (flag)
+    {
+        CreateFunction createFun = (CreateFunction)m_lib->resolve("create");
+        ReleaseFunction releaseFun = (ReleaseFunction)m_lib->resolve("destory");
+        bool initFailure = false;
+        if (createFun && releaseFun)
+        {
+            trigger = createFun();
+            destory_finstcp = releaseFun;
+            QByteArray initByte = QByteArray::fromStdString("sleeptime_20_readnum_300_writetype_ushort");
+            trigger->reciveData(vec_mat, QByteArray(IpAndPort.toUtf8()));
+            emit _backEndManager->sendInitString(triggerFileName + "连接到" + IpAndPort);
+            initFailure = trigger->initParas(initByte);
+        }
+
+        if (initFailure == false)
+        {
+            emit _backEndManager->sendErrorToMainwindow(triggerInitFailure);
+            delete m_lib;
+            m_lib = nullptr;
+            emit _backEndManager->sendInitString(triggerFileName + "初始化失败");
+            return;
+        }
+        else
+        {
+            initFlag = true;
+            emit _backEndManager->sendInitString(triggerFileName + "成功");
+        }
+    }
+}
 void triggerManager::decodeCameraCMD(QByteArray byte)
 {
 #if debugTesting
@@ -22,7 +72,7 @@ void triggerManager::decodeCameraCMD(QByteArray byte)
     {
         std::shared_ptr <detData> data = dManager->insertDetData("Camera1", "TEST", 1, 1);
         data->correctionData = correctionData;
-        data->oriImgs.push_back(cv::imread("C://Users//RCi//Downloads//20240526-202606.bmp",-1));
+        data->oriImgs.push_back(cv::imread("E://Cisco2-2024//TestImg//HFFGG6534_1_1_Battlestar20240326_180201.bmp",-1));
         _threadManager->addTask(data);//添加任务
         //auto camera = _cameraManager->getCamera("123");
         //if (camera != nullptr)
@@ -160,57 +210,6 @@ void triggerManager::decodeCameraCMD(QByteArray byte)
 
 #endif
 }
-
-void triggerManager::init(backEndManager* input)
-{
-    _backEndManager = input;
-    dManager = _backEndManager->_detDataManager;
-    _cameraManager = _backEndManager->_cameraManager;
-    _threadManager = _backEndManager->_threadManager;
-    _jsonConfiguration = _backEndManager->_jsonConfiguration;
-
-    triggerFileName = _jsonConfiguration->tcp.moduleName;
-    IpAndPort = _jsonConfiguration->tcp.finstcp_init;
-    //triggerInitStr = QByteArray("sleeptime_%1_readnum_%2_writetype_ushort");
-    QLibrary* m_lib = new QLibrary(triggerFileName);
-    bool flag = m_lib->load();
-    if (!m_lib->isLoaded())
-    {
-        //emit _backEndManager->sendErrorToMainwindow(dllNotFound);
-        emit _backEndManager->sendInitString("找不到"+triggerFileName);
-        return;
-    }
-
-    if (flag)
-    {
-        CreateFunction createFun = (CreateFunction)m_lib->resolve("create");
-        ReleaseFunction releaseFun = (ReleaseFunction)m_lib->resolve("destory");
-        bool initFailure = false;
-        if (createFun && releaseFun)
-        {
-            trigger = createFun();
-            destory_finstcp = releaseFun;
-            QByteArray initByte = QByteArray::fromStdString("sleeptime_20_readnum_300_writetype_ushort");
-            trigger->reciveData(vec_mat, QByteArray(IpAndPort.toUtf8()));
-            emit _backEndManager->sendInitString(triggerFileName + "连接到" + IpAndPort);
-            initFailure=trigger->initParas(initByte);
-        }
-
-        if(initFailure==false)
-        {
-            emit _backEndManager->sendErrorToMainwindow(triggerInitFailure);
-            delete m_lib;
-            m_lib = nullptr;
-            isInit = false;
-            emit _backEndManager->sendInitString(triggerFileName + "初始化失败");
-            return;
-        }
-        else
-            emit _backEndManager->sendInitString(triggerFileName + "成功");
-    }
-    this->start();
-}
-
 int triggerManager::getValue(int dmPos, QByteArray byte)
 {
     int triggerPos = (dmPos - _backEndManager->_jsonConfiguration->tcp.startPos) * 2;

HanddleAI/HandleAiUi-new/back/triggerManager.h

@@ -64,6 +64,7 @@ private:
 class triggerManager : public QThread
 {
 public:
+    bool initFlag = false;
     QString triggerFileName;
     QString IpAndPort;
     QString triggerInitStr;
@@ -74,7 +75,7 @@ public:
         this->terminate();
         delete trigger;
     }
-    void init(backEndManager* input);
+    void initialization(backEndManager* input);
     void run()
     {
         QThread::msleep(5000);
@@ -139,7 +140,6 @@ public:
     }
 
     int getValue(int dmPos, QByteArray byte);
-    bool isInit = true;
 private:
     threadManager* _threadManager;
     detDataManager* dManager;

HanddleAI/HandleAiUi-new/globalStruct.h

@@ -16,6 +16,8 @@
 
 #define sColor_Black "22, 22, 22"
 #define sColor_BlackWithWhite "45, 45, 45"
+
+#define disableBackEndCheck 1
 enum backEndError
 {
 	dllNotFound,

HanddleAI/HandleAiUi-new/handleAi/handleAiModel.h

@@ -4,59 +4,71 @@
 #include <future>
 #include <qobject.h>
 #include <backEndManager.h>
-
-#if 0 
-class handleAiModelBase
+#define handleAiModelSwitch 1
+#if handleAiModelSwitch 
+class handleAiModelSeg 
 {
 public:
     std::string path;
     int gpuIndex =0;
     std::mutex* gpuMutex;
-    virtual void init() {};
-    virtual bool destroy() { return true; };
-    virtual cv::Mat evalute() { return cv::Mat(); };
-};
-class handleAiModelSeg :public handleAiModelBase
-{
-public:
-    handleAiModelSeg(std::string pathIn, int gpuIndexIn)
+    handleAiModelSeg(std::string pathIn, int gpuIndexIn, std::mutex* mutex)
     {
         path = pathIn;
         gpuIndex = gpuIndexIn;
+        gpuMutex = mutex;
     };
-    void init() override
+    void init()
     {
         segPtr = handdleAI::CreateSegObj((char*)path.c_str(),gpuIndex);
     }
-    bool destroy() override
+    bool destroy()
     {
         if (segPtr == nullptr)
             return false;
         handdleAI::DestroySegObj(segPtr);
         return true;
     }
+    cv::Mat Evaluate(cv::Mat& in)
+    {
+        gpuMutex->lock();
+        cv::Mat res = segPtr->Evaluate(in);
+        gpuMutex->unlock();
+        return res;
+    }
 private:
     handdleAI::pSegmentation* segPtr = nullptr;
 };
-class handleAiModelCls :public handleAiModelBase
+class handleAiModelCls
 {
 public:
-    handleAiModelCls(std::string pathIn, int gpuIndexIn)
+    std::string path;
+    int gpuIndex = 0;
+    std::mutex* gpuMutex;
+    handleAiModelCls(std::string pathIn, int gpuIndexIn, std::mutex* mutex)
     {
         path = pathIn;
         gpuIndex = gpuIndexIn;
+        gpuMutex = mutex;
     };
-    void init() override
+    void init()
     {
-        clsPtr = handdleAI::CreateClsObjVT((char*)path.c_str(), gpuIndex);
+        clsPtr = handdleAI::CreateClsObjV3((char*)path.c_str(), gpuIndex,1);
     }
-    bool destroy() override
+    bool destroy()
     {
         if (clsPtr == nullptr)
             return false;
         handdleAI::DestroyClsObj(clsPtr);
         return true;
     }
+    int Evaluate(cv::Mat& in)
+    {
+        gpuMutex->lock();
+        int res = clsPtr->Evaluate(in);
+        gpuMutex->unlock();
+        return res;
+    }
 private:
     handdleAI::pClassification* clsPtr;
 };
@@ -64,6 +76,7 @@ private:
 class handleAiModelManager :public QObject
 {
 public:
+    bool initFlag = false;
     handleAiModelSeg* largeSeg;
     handleAiModelCls* largeCls;
 
@@ -76,56 +89,81 @@ public:
     ////////模型放这里///////
     handleAiModelManager()
     {
-        gpuMutex = std::vector<std::mutex*>(gpuCnt, new std::mutex);
+        gpuMutex = std::vector<std::mutex*>(gpuCnt, new std::mutex());
 
-        largeSeg = new handleAiModelSeg("./HandleAiModels/large-seg.BHD",0);
-        midSeg = new handleAiModelSeg("./HandleAiModels/mid-seg.BHD", 0);
-        smallSeg = new handleAiModelSeg("./HandleAiModels/small-seg.BHD", 0);
+        int gpu1 = 0;
+        largeSeg = new handleAiModelSeg("./HandleAiModels/large-seg.BHD", gpu1, gpuMutex[gpu1]);
+        midSeg = new handleAiModelSeg("./HandleAiModels/mid-seg.BHD", gpu1, gpuMutex[gpu1]);
+        smallSeg = new handleAiModelSeg("./HandleAiModels/small-seg.BHD", gpu1, gpuMutex[gpu1]);
 
-        largeCls = new handleAiModelCls("./HandleAiModels/large-cls.BHD", 0);
-        midCls = new handleAiModelCls("./HandleAiModels/mid-cls.BHD", 0);
-        smallCls = new handleAiModelCls("./HandleAiModels/small_cls.BHD", 0);
+        segModels.push_back(largeSeg);
+        segModels.push_back(midSeg);
+        segModels.push_back(smallSeg);
 
-        models.push_back(largeSeg);
-        models.push_back(midSeg);
-        models.push_back(smallSeg);
-        models.push_back(largeCls);
-        models.push_back(midCls);
-        models.push_back(smallCls);
+        largeCls = new handleAiModelCls("./HandleAiModels/large-cls.BHD", gpu1, gpuMutex[gpu1]);
+        midCls = new handleAiModelCls("./HandleAiModels/mid-cls.BHD", gpu1, gpuMutex[gpu1]);
+        smallCls = new handleAiModelCls("./HandleAiModels/small_cls.BHD", gpu1, gpuMutex[gpu1]);
+
+
+        clsModels.push_back(largeCls);
+        clsModels.push_back(midCls);
+        clsModels.push_back(smallCls);
     }
     ///////////END/////////
     
-    void init(backEndManager* _backEndManagerIn)
+    void initialization(backEndManager* _backEndManagerIn)
     {
-        return;
-        std::vector<std::future<void>> futures;//异步初始化
-        for(auto model: models)
+        //return;
+        std::vector<std::future<void>> futuresSeg;
+        std::vector<std::future<void>> futuresCls;
+        for(auto model: segModels)
         {
-            futures.push_back(std::async(std::launch::async, &handleAiModelBase::init, model));
+            futuresSeg.push_back(std::async(std::launch::async, &handleAiModelSeg::init, model));
             emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(model->path) + "初始化中..."));
         }
-        int cnt = 0;
-        for (auto& func : futures)
+        for (auto model : clsModels)
+        {
+            futuresCls.push_back(std::async(std::launch::async, &handleAiModelCls::init, model));
+            emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(model->path) + "初始化中..."));
+        }
+
+        int cntSeg = 0;
+        for (auto& func : futuresSeg)
         {
             func.wait();
-            emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(models[cnt]->path) + "成功"));
-            cnt++;
+            emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(segModels[cntSeg]->path) + "成功"));
+            cntSeg++;
+        }
+
+        int cntCls = 0;
+        for (auto& func : futuresCls)
+        {
+            func.wait();
+            emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(clsModels[cntCls]->path) + "成功"));
+            cntCls++;
         }
     }
     ~handleAiModelManager()
     {
-        for (auto model : models)
+        for (auto model : segModels)
+            model->destroy();
+        for (auto model : clsModels)
             model->destroy();
     }
 private:
-    std::vector<handleAiModelBase*> models;
+    std::vector<handleAiModelSeg*> segModels;
+    std::vector<handleAiModelCls*> clsModels;
     std::vector<std::mutex*>gpuMutex;
     int gpuCnt = 1;//gpu数量
 };
 #endif
+#if handleAiModelSwitch == 0
 class handleAiModelManager :public QObject
 {
 public:
+    std::vector<std::pair<handdleAI::pSegmentation*, std::string>> segModels;
+    std::vector < std::pair< handdleAI::pClassification*, std::string>> clsModels;
+
     handdleAI::pSegmentation* largeSeg;
     handdleAI::pClassification* largeCls;
 
@@ -138,20 +176,45 @@ public:
     ////////模型放这里///////
     handleAiModelManager()
     {
+        segModels.push_back({ largeSeg ,"./HandleAiModels/large-seg.BHD" });
+        segModels.push_back({ midSeg ,"./HandleAiModels/mid-seg.BHD" });
+        segModels.push_back({ smallSeg ,"./HandleAiModels/small-seg.BHD" });
 
+        clsModels.push_back({ largeCls ,"./HandleAiModels/large-cls.BHD" });
+        clsModels.push_back({ midCls ,"./HandleAiModels/mid-cls.BHD" });
+        clsModels.push_back({ smallCls ,"./HandleAiModels/small-cls.BHD" });
     }
     ///////////END/////////
 
+    void createSeg(handdleAI::pSegmentation* segPtr, std::string path, int gpuId)
+    {
+        segPtr = handdleAI::CreateSegObj((char*)path.c_str(), gpuId);
+    }
+    void createCls(handdleAI::pClassification* clsPtr, std::string path, int gpuId)
+    {
+        clsPtr = handdleAI::CreateClsObjV3((char*)path.c_str(), gpuId,1);
+    }
     void init(backEndManager* _backEndManagerIn)
     {
-        return;
-        largeSeg = handdleAI::CreateSegObj("./HandleAiModels/large-seg.BHD", 0);
-        midSeg = handdleAI::CreateSegObj("./HandleAiModels/mid-seg.BHD", 0);
-        smallSeg = handdleAI::CreateSegObj("./HandleAiModels/small-seg.BHD", 0);
 
-        largeCls = handdleAI::CreateClsObjVT("./HandleAiModels/large-cls.BHD", 0);
-        midCls = handdleAI::CreateClsObjVT("./HandleAiModels/mid-cls.BHD", 0);
-        smallCls = handdleAI::CreateClsObjVT("./HandleAiModels/small_cls.BHD", 0);
+        std::vector<std::future<void>> futures;//异步初始化
+        for (auto model : segModels)
+        {
+            futures.push_back(std::async(std::launch::async, &handleAiModelManager::createSeg,this, model.first,model.second,0));
+            emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(model.second) + "初始化中..."));
+        }
+        for (auto model : clsModels)
+        {
+            futures.push_back(std::async(std::launch::async, &handleAiModelManager::createCls, this, model.first, model.second, 0));
+            emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(model.second) + "初始化中..."));
+        }
+        int cnt = 0;
+        for (auto& func : futures)
+        {
+            func.wait();
+            //emit _backEndManagerIn->sendInitString(QString::fromStdString(getFileName(models[cnt]->path) + "成功"));
+            cnt++;
+        }
     }
     ~handleAiModelManager()
     {
@@ -165,4 +228,5 @@ public:
     }
 
 };
+#endif
 #pragma once

HanddleAI/HandleAiUi-new/main.cpp

@@ -19,11 +19,45 @@ void connectSignalAndSlots(MainWindow* front, backEndManager* back)
     QObject::connect(back, &backEndManager::sendInitString, front, &MainWindow::recvInitString);
     QObject::connect(back, &backEndManager::sendInitFinished, front, &MainWindow::recvInitFinished);
 
-    QObject::connect(front, &MainWindow::reInitSignal, back, &backEndManager::reInitSlot);
-    QObject::connect(front->_loadingWidget.retryBtn, &QPushButton::clicked, back, &backEndManager::reInitSlot);
+    QObject::connect(front, &MainWindow::reInitSignal, back, &backEndManager::initialization);
+    QObject::connect(front->_loadingWidget.retryBtn, &QPushButton::clicked, back, &backEndManager::initialization);
+}
+//exmple  860 168/144 1
+QByteArray createReadPlcQByteArray(int pos, int areaCode, int lenth)
+{
+    int pos1 = std::max(0, pos - 255);
+    int pos2 = pos - pos1;
+    QString str1 = QString("%1").arg(pos1, 2, 16, QLatin1Char('0')).toUpper();
+    QString str2 = QString("%1").arg(pos2, 2, 16, QLatin1Char('0')).toUpper();
+    QString str3 = QString("%1").arg(lenth, 2, 16, QLatin1Char('0')).toUpper();
+    QString str = QString("50 00 00 FF FF 03 00 0C 00 0A 00 01 04 00 00 %1 %2 00 %3 %4 00")
+        .arg(str1)
+        .arg(str2)
+        .arg(QString::number(areaCode, 16).toUpper())
+        .arg(str3);
+    return QByteArray::fromHex(str.toStdString().c_str());
+}
+//exmple  862 168/144 1 1
+QByteArray createwritePlcQByteArray(int pos, int areaCode, int lenth, int value)
+{
+    int pos1 = std::max(0, pos - 255);
+    int pos2 = pos - pos1;
+
+    QString str1 = QString("%1").arg(pos1, 2, 16, QLatin1Char('0')).toUpper();
+    QString str2 = QString("%1").arg(pos2, 2, 16, QLatin1Char('0')).toUpper();
+    QString str3 = QString("%1").arg(lenth, 2, 16, QLatin1Char('0')).toUpper();
+    QString str4 = QString("%1").arg(value, 2, 16, QLatin1Char('0')).toUpper();
+    QString str = QString("50 00 00 FF FF 03 00 0E 00 0A 00 01 14 00 00 %1 %2 00 %3 00 %4 00 %5 00")
+        .arg(str1)
+        .arg(str2)
+        .arg(QString::number(areaCode, 16).toUpper())
+        .arg(str3)
+        .arg(str4);
+    return QByteArray::fromHex(str.toStdString().c_str());
 }
 int main(int argc, char* argv[])
 {
+    QByteArray r = createReadPlcQByteArray(102, 168, 1);
     QApplication a(argc, argv);
     LogMsg::Create(LogMsg::LogMsgType::DebugMsg);
     //检测是否已运行
@@ -46,7 +80,7 @@ int main(int argc, char* argv[])
     w.show();
     backEndManager _backEnd;
     connectSignalAndSlots(&w,&_backEnd);
-    _backEnd.init();
+    _backEnd.initialization();
     return a.exec();
     
     

HanddleAI/HandleAiUi-new/mainwindow.h

@@ -25,7 +25,6 @@
 #include <pages/logPageWidget.h>
 #include <pages/sqlControlWidget.h>
 
-#define disableBackEndCheck 1
 #pragma execution_character_set("utf-8")
 
 QT_BEGIN_NAMESPACE

HanddleAI/HandleAiUi-new/sqlManager/sqlManager.cpp

@@ -81,7 +81,7 @@ sqlTableDatas sqlManager::selectAllData(std::string SN)
 		dbPtr->Select(getPreviousDate(), {}, "SN", SN, selectResult);
 	return selectResult;
 }
-void sqlManager::initPara(std::string dataBasePath, bool backup)
+void sqlManager::initialization(std::string dataBasePath, bool backup)
 {
 	std::cout << "SQL runing Init..." << std::endl;
 	dbPtr = new sqliteModule(dataBasePath);//初始化

HanddleAI/HandleAiUi-new/sqlManager/sqlManager.h

@@ -30,7 +30,7 @@ public:
     sqlTableDatas selectAllData(std::string SN);
 
     sqlError GetTables(std::vector<std::string>& input);//获取所有列名
-    void initPara(std::string dataBasePath = sqlDefaultDatabasePath,bool backUp=true);
+    void initialization(std::string dataBasePath = sqlDefaultDatabasePath,bool backUp=true);
     bool addData(std::string SN, std::vector<sqlData> data);
     int checktSn(std::string sn);
     void checkCol(sqlite3* db,std::string tableName,std::string columnName);

HanddleAI/HandleAiUi-new/uiModule/uiModule_imageView.h

@@ -451,12 +451,14 @@ public:
         {
         case imgWidgetOri:
             ImageWidgetList[index]->setOriImg(img);
+            return true;
             break;
         case imgWidgetRes:
             ImageWidgetList[index]->setResImg(img);
+            return true;
             break;
         }
-
+        return false;
     }
     bool showImg(QPixmap& img, imgWidgetShowType _type, QString nickName)
     {