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

#include <threadPoolManager.h>
#include <FrontendBackendBridge.h>
#include <sqlManager/sqlManager.h>
#include <imgSaveThreadManager.h>
#include <triggerManager.h>
#include <algo/ALGO_MAIN.h>

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(&currentTime);
	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::initialization(backEndManager* _backEndManagerIn)
{
	_backEndManager = _backEndManagerIn;
	sql = &_backEndManager->_sqlManager;
	_imgSaveThreadManager = _backEndManagerIn->_imgSaveThreadManager;
	_triggerManager = _backEndManagerIn->_triggerManager;
	_handleAiModelManager = _backEndManager->_handleAiModelManager;
	initFlag = true;
}

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)
		{
			_imgSaveThreadManager->oriSaveThread->imgDataQueue.append(ptr);

			algoFutures.insert(std::make_pair(ptr->timeCode, std::async(std::launch::async, processAlgo, ptr,_handleAiModelManager)));
			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)
		{
			bool res= futrueIte->second.get();
			//resultData.push_back(ptr);
			//resultFutures.insert(std::make_pair(ptr->timeCode, std::async(std::launch::async, &threadManager::resultHandle, this, ptr)));
			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);
	//发送图片
	if (data->resultImgs.size() > 0)
	{
		QPixmap pixmap;
		cvMatToQPixMap(data->resultImgs[0], pixmap);
		showImgPack* pack = new showImgPack();
		pack->img = pixmap;
		pack->type = imgWidgetRes;
		pack->index = data->resShowIndex;
		emit _backEndManager->sendPixmapImageWidget(pack);
		
	}
	if (data->resultImgs.size() > 1)
	{
		QPixmap pixmap;
		cvMatToQPixMap(data->resultImgs[1], pixmap);
		showImgPack* pack = new showImgPack();
		pack->img = pixmap;
		pack->type = imgWidgetRes;
		pack->index = data->resShowIndex+1;
		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);

	//写入plc
	for (auto writeBackStr : data->writeBackData)
		_triggerManager->sendFinsMsg(writeBackStr);

	//提交清理申请
	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)
{
	insertQueueMutex.lock();
	insertQueue.enqueue(data);
	insertQueueMutex.unlock();
}
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 plcByte)
{
	while (clearSameSnRequestData() == false);
	for (int i = 0; i < snWaittingVec.size(); i++)
	{//第一位是hash，第二位是index
		std::string SN = readSnFromQByteArray(plcByte, 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
std::string sncodeCls::readSnFromQByteArray(QByteArray plcByte, int dmPos,
	bool highLowConversion, bool clearAfterRead, long long timeCode, int Size)
{
	int triggerPos = (dmPos - tcpStartPos) * 2;
	if (triggerPos < 0)
	{
		std::cout << "Read SN error,trigger is DM:" << dmPos << ",but read start at DM:" << tcpStartPos << endl;
		return snErrorsnError;
	}
	QString str;
	if (plcByte.at(triggerPos + 1) == 0 && plcByte.at(triggerPos) == 0)
		return snErrorsnError;
	int snCount = 0;
	while (plcByte.at(snCount + triggerPos) != 0 || plcByte.at(snCount + triggerPos + 1) != 0)
	{
		
		if (plcByte.at(snCount + triggerPos) == 0)
		{
			snCount++;
			continue;
		}
		str += QChar(plcByte.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;
}
std::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;
}
std::string sncodeCls::waitForSn(unsigned long long timeCode, int timeOut)
{
	int cnt = 0;
	std::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;
}