handleaiuinew/HanddleAI/HandleAiUi-new/back/threadPoolManager.h

#include <iostream>
#include <qthread.h>
#include <qqueue.h>
#include <qmutex.h>
#include <iomanip>
#include <sstream>
#include <filesystem>
#include <opencv.hpp>
#include <string>
#include <handleAiModel.h>
#include <sqliteManager/sqlManager.h>  
#include <QtConcurrent/qtconcurrent>
#include <QMetaType>
#include <fileManager.h>
#include <qtcpserver.h>
#include <qtcpsocket.h>
#include <mutex>
#include <backStruct.h>
class threadManager;
class algoThread;
class subThread;
class detDataManager;
//class detData;
struct saveStruct
{
    std::string filePath;
    std::string fileName;
    cv::Mat file;
};
struct MatchResult {
    cv::Rect boundingRect;
    double confidence;
};

class cameraImages
{
public:
    struct imgData
    {
        size_t timCode;
        std::vector<cv::Mat>imgs;
    };
    QList< imgData*> imgList;
    imgData* getData(size_t timeCode)
    {
        for (int i = 0; i < imgList.size(); i++)
        {
            if (imgList[i]->timCode == timeCode)
            {
                imgData* ptr = imgList[i];
                imgList.removeAt(i);
                return ptr;
            }
        }
        return nullptr;
    }
    imgData* waitForImg(size_t timeCode,int timeOut=10000)
    {
        imgData* ptr=nullptr;
        int cnt = 0;
        while (cnt < timeOut)
        {
            ptr = getData(timeCode);
            if (ptr!=nullptr)
            {
                std::cout <<"cost Time"<< cnt << endl;
                return ptr;
            }
            cnt += 10;
            QThread::msleep(10);
        }
        qDebug() << "timeCode:" << timeCode << "no img,return nullptr";
        return nullptr;
    }
    void insertImg(size_t timeCode, std::vector<cv::Mat>*mats)
    {
        std::vector<cv::Mat>imgs;
        imgs.swap(*mats);
        imgData* _strcut = new imgData({ timeCode, imgs });
        imgList.push_back(_strcut);
    }
    
};
class detData
{
public:
    const unsigned long long timeCode = getTimeCode();//根据时间和随机数生成的值，唯一
    QMutex imgMutex;
    std::string SNcode;
   
    QString cameraKeyName;
    QString algoThreadName;
    std::string cameraNameStr;
    correctionStruct* correctionData=nullptr;
    double camera1Width = 0, camera1Height = 0;

    int algoThreadIndex = -1;//进入第几个算法线程
    int cameraIndex = -1;    //是第几次拍照 
    int imgAmountMin = 1;

    std::array<bool, 20>skip;
    std::vector<std::pair<std::string, double>> sqlVec;

    std::vector<cv::Mat> imgs;
    std::vector<cv::Mat> resultImgs;
    int oriShowIndex = -1;//原图在第几个框展示
    int resShowIndex = -1;//结果图在第几个框展示
    std::string snErrorsnError = std::string("snErrNoSn");
    detDataManager* dManager=nullptr;
    static unsigned long long getTimeCode() {
        auto now = std::chrono::high_resolution_clock::now();
        auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

        std::random_device rd;
        std::mt19937_64 gen(rd());
        std::uniform_int_distribution<unsigned long long> dis(0, std::numeric_limits<unsigned long long>::max());
        unsigned long long randomValue = dis(gen);

        unsigned long long uniqueNumber = (timestamp << 32) | randomValue;
        return uniqueNumber;
    }

    void Init(QString IN_cameraKeyName, QString IN_algoThreadName,
        std::string IN_SN, int IN_oriShowIndex)
    {


        cameraKeyName = IN_cameraKeyName;
        algoThreadName = IN_algoThreadName;
        oriShowIndex = IN_oriShowIndex;
        SNcode = IN_SN;
        //algoThreadCls::datastruct _struct = bridge.back.json.algoThreads.getData(IN_algoThreadName);
        //algoThreadIndex = _struct.threadIndex;
        //resShowIndex = _struct.showIndex;
    }
    static detData* CreateDetData(QString IN_cameraKeyName, QString IN_algoThreadName,
        std::string IN_SN, int IN_oriShowIndex)
    {
        detData* data = new detData(IN_cameraKeyName, IN_algoThreadName, IN_SN, IN_oriShowIndex);
        return data;
    }

    detData(QString IN_cameraKeyName, QString IN_algoThreadName,
        std::string IN_SN, int IN_oriShowIndex)
    {
        cameraKeyName = IN_cameraKeyName;
        algoThreadName = IN_algoThreadName;
        oriShowIndex = IN_oriShowIndex;
        SNcode = IN_SN;
        //imgMutex = new QMutex();
    }
    ~detData()
    {
        for (auto img : imgs)
            img.release();
        for (auto img : resultImgs)
            img.release();
        //delete cameraImgPtr;
    }

    void clear()
    {
        imgs.clear();
        //timeCode = -1;
        resShowIndex = -1;
        oriShowIndex = -1;
        algoThreadIndex = -1;
        cameraIndex = -1;
        //snCountIndex = -1;
        std::string SNcode = "";
    }
    bool isEmpty()
    {
        if (imgs.size() == 0)
            return true;
        else
            return false;
    }
};
class detDataManager
{
public:
    std::unordered_map<unsigned long long, detData*>map;

    //QLinkedList<detData> detDatas;
    QMutex dataMutex;
    detData* insertDetData(QString IN_cameraKeyName, QString IN_algoThreadName,
        std::string IN_SN, int IN_oriShowIndex)
    {
        dataMutex.lock();
        detData* data = new detData(IN_cameraKeyName, IN_algoThreadName, IN_SN, IN_oriShowIndex);
        data->dManager = this;
        //detDatas.push_back(data);
        map.insert({ data->timeCode,data });
        dataMutex.unlock();
        detData* dataPtr = getDetData(data->timeCode);
        
        if (dataPtr == nullptr)
            qDebug() << "创建新容器失败";
        return dataPtr;
    }
    detData* getDetData(unsigned long long timeCode)
    {
        dataMutex.lock();
        std::unordered_map<unsigned long long, detData*>::iterator
            it = map.find(timeCode);
        if (it != map.end())
        {
            dataMutex.unlock();
            return it->second;
        }
        dataMutex.unlock();
        return nullptr;
    }
    bool deleteDetData(unsigned long long timeCode)
    {
        dataMutex.lock();
        std::unordered_map<unsigned long long, detData*>::iterator it = map.find(timeCode);
        if (it != map.end())
        {
            it->second->imgMutex.lock();
            delete it->second;
            map.erase(it);
            dataMutex.unlock();
            return true;
        }
        dataMutex.unlock();
        return false;
    }

};
class sncodeCls
{
public:
    struct snPack
    {
        unsigned long long timecode;
        std::string sn;
        int startpos;
    };
    QList<snPack>snWaittingVec;
    QList<snPack>snResList;
    std::string snErrorsnError = "snErrNoSn";
    int tcpStartPos=0;
    bool clearSameSnRequestData();
    void checkSnFromWaittingVec(QByteArray byte);
    std::string readSnFromQByteArray(QByteArray byte, int dmPos,
        bool highLowConversion, bool clearAfterRead, long long timeCode, int Size = -1);
    QString snHex(QString sn);
    std::string getData(unsigned long long timeCode);
    std::string waitForSn(unsigned long long timeCode, int timeOut=1000);
    sncodeCls();
};

/// <summary>
/// 线程池管理
/// </summary>
class threadManager : public QThread
{
    Q_OBJECT
        
public:
    explicit threadManager(QObject* parent = nullptr);
    QMutex queueMutex;
    cameraImages cameraImgs;
    QQueue<detData*> detDataQueue;
    sqlManager* sql;
    handleAiModel models;//初始化模型
    autoDelete* autoDeleteThread;
    
    QMutex insertQueueMutex;
    QQueue<detData*>insertQueue;
    std::vector<algoThread*>algoThreadList;
    void run();
    void addTask(detData*);
    bool getFreeThread();
    bool addTaskFreeThread(detData*);
    sncodeCls snDatas;
    ~threadManager();
private:
    QList<detData*>imgWaitList;
};

#pragma once