277 lines
6.8 KiB
C++
277 lines
6.8 KiB
C++
#include <threadPoolManager.h>
|
|
#include <FrontendBackendBridge.h>
|
|
#include <sqlManager/sqlManager.h>
|
|
#include <imgSaveThreadManager.h>
|
|
|
|
#include <algo/ALGO_Test.h>
|
|
#include <algo/ALGO_Correction.h>
|
|
#include <algo/ALGO_Inspection.h>
|
|
|
|
using namespace std;
|
|
void createDirectoryIfNotExists_2(const std::string& path) {
|
|
// 检查路径是否存在
|
|
if (!std::filesystem::exists(path)) {
|
|
// 创建路径
|
|
|
|
std::filesystem::create_directories(path);
|
|
//std::cout << "已创建文件夹: " << path << std::endl;
|
|
}
|
|
else {/*
|
|
std::cout << "文件夹已存在: " << path << std::endl;*/
|
|
}
|
|
}
|
|
std::string getCurrentDateTime_2() {
|
|
// 获取当前时间点
|
|
std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
|
|
|
|
// 转换为字符串
|
|
std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
|
|
std::tm* localTime = std::localtime(¤tTime);
|
|
std::stringstream ss;
|
|
ss << std::put_time(localTime, "%H-%M-%S");
|
|
|
|
return ss.str();
|
|
}
|
|
|
|
////////////THREAD//Manager////////////////////////
|
|
threadManager::threadManager()
|
|
{
|
|
//sql初始化
|
|
//sql = new sqlManager;
|
|
//sql->initPara();
|
|
//辅助线程初始化
|
|
//oriSaveThread->oriThread = true;
|
|
//oriSaveThread->Init(this);
|
|
//this->start();
|
|
}
|
|
|
|
void threadManager::init(backEndManager* _backEndManagerIn)
|
|
{
|
|
_backEndManager = _backEndManagerIn;
|
|
sql = &_backEndManager->_sqlManager;
|
|
_imgSaveThreadManager = _backEndManagerIn->_imgSaveThreadManager;
|
|
this->start();
|
|
}
|
|
void threadManager::process()
|
|
{
|
|
|
|
#pragma region 检查队列是否有新的数据
|
|
queueMutex.lock();
|
|
while (insertQueue.size() > 0)
|
|
waitImgData.push_back(insertQueue.dequeue());
|
|
queueMutex.unlock();
|
|
#pragma endregion
|
|
#pragma region 等待图片满足要求后异步执行算法函数
|
|
for (auto it = waitImgData.begin(); it != waitImgData.end();)
|
|
{
|
|
std::shared_ptr<detData> ptr = *it;
|
|
if (ptr->oriImgs.size() >= ptr->imgAmountMin)
|
|
{
|
|
algoFutures.insert(std::make_pair(ptr->timeCode, std::async(std::launch::async, ALGO_Inspection, ptr)));
|
|
processData.push_back(ptr);
|
|
|
|
it = waitImgData.erase(it);
|
|
}
|
|
else
|
|
++it;
|
|
}
|
|
#pragma endregion
|
|
#pragma region 执行完毕后异步获取储存使用结果
|
|
for (auto it = processData.begin(); it != processData.end();)
|
|
{
|
|
std::shared_ptr<detData> ptr = *it;
|
|
futrueIte = algoFutures.find(ptr->timeCode);
|
|
if (futrueIte->second.wait_for(zeroSec)== std::future_status::ready)
|
|
{
|
|
resultData.push_back(ptr);
|
|
resultFutures.insert(std::make_pair(ptr->timeCode, std::async(std::launch::async, &threadManager::resultHandle, this, ptr)));
|
|
|
|
it = processData.erase(it);
|
|
algoFutures.erase(futrueIte);
|
|
}
|
|
else
|
|
++it;
|
|
}
|
|
#pragma endregion
|
|
#pragma region 等待结果并执行显示图片等操作
|
|
for (auto it = resultData.begin(); it != resultData.end();)
|
|
{
|
|
std::shared_ptr<detData> ptr = *it;
|
|
futrueIte = resultFutures.find(ptr->timeCode);
|
|
if (futrueIte->second.wait_for(zeroSec) == std::future_status::ready)
|
|
{
|
|
|
|
it = resultData.erase(it);
|
|
resultFutures.erase(futrueIte);
|
|
}
|
|
else
|
|
++it;
|
|
}
|
|
#pragma endregion
|
|
|
|
}
|
|
void threadManager::resultHandle(std::shared_ptr <detData> data)
|
|
{
|
|
//储存结果图
|
|
_imgSaveThreadManager->resSaveThread->imgDataQueue.append(data);
|
|
//发送图片
|
|
QPixmap pixmap;
|
|
cvMatToQPixMap(data->resultImgs[0], pixmap);
|
|
showImgPack* pack = new showImgPack();
|
|
pack->img = pixmap;
|
|
pack->type = imgWidgetRes;
|
|
pack->index = data->oriShowIndex;
|
|
emit _backEndManager->sendPixmapImageWidget(pack);
|
|
|
|
//SQL
|
|
std::vector<sqlData> sqlDatas;
|
|
for (auto sqlData : data->sqlVec)
|
|
sqlDatas.push_back({ sqlData.first, std::to_string(sqlData.second) });
|
|
sql->addData(data->SNcode, sqlDatas);
|
|
|
|
//提交清理申请
|
|
detDataManager* dManager = data->dManager;
|
|
data->dManager->deleteDetData(data->timeCode);
|
|
}
|
|
void threadManager::run()
|
|
{
|
|
while (runFlag == true)
|
|
{
|
|
process();
|
|
QThread::msleep(1);
|
|
}
|
|
}
|
|
void threadManager::addTask(std::shared_ptr <detData> data)
|
|
{
|
|
//{
|
|
// CameraListCls::datastruct _struct = bridge.back.json.camera.getData(data->cameraKeyName);
|
|
// data->oriShowIndex = _struct.showIndex;
|
|
//}
|
|
insertQueueMutex.lock();
|
|
insertQueue.enqueue(data);
|
|
insertQueueMutex.unlock();
|
|
//this->start();
|
|
}
|
|
threadManager::~threadManager()
|
|
{
|
|
runFlag = false;
|
|
this->stop();
|
|
this->terminate();
|
|
processData.clear();
|
|
algoFutures.clear();
|
|
}
|
|
////////////////DET//DATA//////////////////
|
|
sncodeCls::sncodeCls()
|
|
{
|
|
tcpStartPos = bridge.back.json.tcp.startPos;
|
|
}
|
|
bool sncodeCls::clearSameSnRequestData()
|
|
{
|
|
std::unordered_map< size_t, size_t >tempMap;
|
|
for (int i = snWaittingVec.size() - 1; i >= 0; i--)
|
|
{
|
|
auto it = tempMap.find(snWaittingVec[i].startpos);
|
|
if (it == tempMap.end()) {
|
|
tempMap.insert({ snWaittingVec[i].startpos,i });
|
|
}
|
|
else
|
|
{
|
|
snWaittingVec.removeAt(i);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
void sncodeCls::checkSnFromWaittingVec(QByteArray byte)
|
|
{
|
|
while (clearSameSnRequestData() == false);
|
|
for (int i = 0; i < snWaittingVec.size(); i++)
|
|
{//第一位是hash，第二位是index
|
|
string SN = readSnFromQByteArray(byte, snWaittingVec[i].startpos, false, true, 0);
|
|
if (SN.compare(snErrorsnError))//不为空
|
|
{
|
|
snResList.push_back({ snWaittingVec[i].timecode,SN,snWaittingVec[i].startpos });
|
|
while (snResList.size() > 100)
|
|
snResList.pop_front();
|
|
snWaittingVec.removeAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
//FINSEDIT
|
|
string sncodeCls::readSnFromQByteArray(QByteArray byte, int dmPos,
|
|
bool highLowConversion, bool clearAfterRead, long long timeCode, int Size)
|
|
{
|
|
int triggerPos = (dmPos - tcpStartPos) * 2;
|
|
if (triggerPos < 0)
|
|
{
|
|
cout << "Read SN error,trigger is DM:" << dmPos << ",but read start at DM:" << tcpStartPos << endl;
|
|
return snErrorsnError;
|
|
}
|
|
QString str;
|
|
if (byte.at(triggerPos + 1) == 0 && byte.at(triggerPos) == 0)
|
|
return snErrorsnError;
|
|
int snCount = 0;
|
|
while (byte.at(snCount + triggerPos) != 0 || byte.at(snCount + triggerPos + 1) != 0)
|
|
{
|
|
|
|
if (byte.at(snCount + triggerPos) == 0)
|
|
{
|
|
snCount++;
|
|
continue;
|
|
}
|
|
str += QChar(byte.at(snCount + triggerPos));
|
|
snCount++;
|
|
}
|
|
if (highLowConversion == true)
|
|
{
|
|
snHex(str);
|
|
}
|
|
if (str.size() < Size && Size != -1)
|
|
return snErrorsnError;
|
|
//if (clearAfterRead == true)
|
|
// //for(int i=0;i< snCount;i++)
|
|
// bridge.back.sendFinsMsg(
|
|
//QString::fromStdString("writeALL_DM" + to_string(dmPos) + "_" + to_string(snCount) + "_0"));
|
|
return str.toStdString();
|
|
}
|
|
QString sncodeCls::snHex(QString sn)
|
|
{
|
|
QString resultStr = "";
|
|
for (int i = 0; i < sn.size() - 1; i = i + 2)
|
|
{
|
|
resultStr = resultStr + sn.at(i + 1) + sn.at(i);
|
|
}
|
|
return resultStr;
|
|
}
|
|
string sncodeCls::getData(unsigned long long timeCode)
|
|
{
|
|
for (int i = snResList.size() - 1; i >= 0; i--)
|
|
{
|
|
if (snResList[i].timecode == timeCode)
|
|
return snResList[i].sn;
|
|
}
|
|
return snErrorsnError;
|
|
}
|
|
string sncodeCls::waitForSn(unsigned long long timeCode, int timeOut)
|
|
{
|
|
int cnt = 0;
|
|
string sn = getData(timeCode);
|
|
if (!sn.compare(snErrorsnError))
|
|
{
|
|
|
|
while (cnt < timeOut)
|
|
{
|
|
sn = getData(timeCode);
|
|
if (sn.compare(snErrorsnError))
|
|
{
|
|
return sn;
|
|
}
|
|
cnt += 10;
|
|
QThread::msleep(10);
|
|
}
|
|
}
|
|
else
|
|
return sn;
|
|
return snErrorsnError;
|
|
} |