eUi/src/Core/detProcess.hpp

#include <qthread.h>
#include <detData.h>
#include <imgSaveThreadManager.h>

#include <cameraManager.h>
#include <triggerManager.h>
#include <detThreadManager.h>
#include <sql/qSqlBase.h>
#include <missonLoader.h>
//#include <mission/952-15-H.h>

class detProcess : public QThread
{
public:
    detDataManager* _detDataManager;            // 检测数据管理器 需要初始化
    imgSaveThreadManager* _imgSaveThreadManager;// 保存图像线程 需要初始化
    triggerManager* _triggerManager;            // 触发管理器
    handleAiModelManager _handleAiModelManager;// 模型管理器
    detThreadManager* _threadManager;
    cameraManager* _cameraManager;
    bool initOnce = false;
    detProcess(){
        //_threadManager.initialization(this);
        //_manualDetThread.initialization(this);
        //_cameraManager.initialization();
        //_triggerManager.initialization(this);
    }

    void initConfig(nlohmann::json& jsonIn, qtFuncBridge* bridgeIn) {

        _imgSaveThreadManager = new imgSaveThreadManager(jsonIn["imgSaveBasePath"]);
        _cameraManager = new cameraManager(jsonIn, bridgeIn);
        _triggerManager = new triggerManager(this, bridgeIn, jsonIn["Triggers"]);
        _threadManager = new detThreadManager(this, bridgeIn);
        _detDataManager = new detDataManager(_triggerManager);
        if (initOnce == false) {
            initOnce = true;
            bridge = bridgeIn;
            json = jsonIn;
            connect(bridgeIn, &qtFuncBridge::reInitConfig, this, [=]() {reinitConfig(); });
        }

    }

    bool waitrForInitResult(serviceModule* ptr, int overtimeS = 999999) {
        int overTimeMs = overtimeS * 1000;
        int timecnt = 0;
        while (timecnt <= overTimeMs) {
            if (ptr->status != NotInit)
                break;
            QThread::msleep(100);
            timecnt += 100;
        }
        if (timecnt > overTimeMs)
            return false;
        if (ptr->status == InitFailure)
            return false;
        return true;
    }

    // 重新初始化配置
    void reinitConfig() {
        // 1. 释放已有资源
        if (_imgSaveThreadManager) { delete _imgSaveThreadManager; _imgSaveThreadManager = nullptr; }
        if (_cameraManager)        { delete _cameraManager;        _cameraManager = nullptr; }
        if (_triggerManager)       { delete _triggerManager;       _triggerManager = nullptr; }
        if (_threadManager)        { delete _threadManager;        _threadManager = nullptr; }
        if (_detDataManager)       { delete _detDataManager;       _detDataManager = nullptr; }
        // 2. 重新初始化
        initConfig(json, bridge);
        this->start();
    }

                  // 相机管理器
    // lightSourceManager _lightSourceManager; // 光源管理器
    SQLiteDB* dataBase;
    // hardwareMonitor _hardwareMonitor;       // 硬件监控，如CPU、内存
    // camera* _2dCamera = nullptr, *_3dCamera = nullptr;



    // 初始化并运行主流程
    void run() {
#if 1
        //dataBase = new SQLiteDB("generalDatabase");
        _cameraManager->start();
        _handleAiModelManager.start();
        //_lightSourceManager.start();
        _triggerManager->start();

        /*
        _summaryData = new summaryData(&_triggerManager);
        */

        bool res1 = waitrForInitResult(_cameraManager);
        //bool res2 = waitrForInitResult(&_handleAiModelManager);
        bool res3 = waitrForInitResult(_triggerManager);

        if (res1 == true && res3 == true) {
            _missionLoader.loadMission(json["missionDllPath"]);
            _missionLoader._misson->init(
                _cameraManager,
                _triggerManager,
                _detDataManager,
                _threadManager,
                json["missionSettings"],
                dataBase, bridge
            );
            _threadManager->registerResultHandleCallback(
                [this](std::shared_ptr<detData> data) {
                    detectionResultHandle(data); 
                });

            //_threadManager->registerProcessAlgoCallback(
            //    [this](std::shared_ptr<detData> data, handleAiModelManager* _handleAiModelManager) {
            //        return  _missionLoader._misson->processAlgo(data, _handleAiModelManager);
            //    });

            emit bridge->loginResult(InitOK);
        }
        else {
            emit bridge->loginResult(InitFailure);
        }
        
#endif
    }

    // 通用的检测结果处理
    void detectionResultHandle(std::shared_ptr<detData> data) {
        // 计算处理总耗时（CT）
        auto totalCt = std::chrono::duration_cast<std::chrono::milliseconds>(data->algoEndTime - data->algoStartTime).count();
        qDebug() << QString::fromStdString(data->cameraKeyName) << "CT<<<" << totalCt << "MS";
        std::cout << "CT->" << totalCt << "ms" << std::endl;
        // 将耗时数据保存入数据库或日志（伪代码）
        // data->sqlVec.push_back({ "SN", data->SNcode });
        // data->sqlVec.push_back({ "totalCt", std::to_string(totalCt.count()) + "ms" });

        // 异步保存检测图像
        std::async(std::launch::async, &imgSaveThreadManager::saveRes, _imgSaveThreadManager, data);

        // 删除数据释放资源
        detDataManager* dManager = data->dManager;
        data->dManager->deleteDetData(data->timeCode);
    }

private:
    nlohmann::json json;
    qtFuncBridge* bridge;
	MissionLoader _missionLoader; // 任务加载器，用于加载任务配置
};

#pragma once