|
|
#pragma execution_character_set("utf-8")
|
|
|
#include "SmokeBoxIdentification.h"
|
|
|
|
|
|
SmokeBoxIdentification::SmokeBoxIdentification(QWidget *parent)
|
|
|
: QMainWindow(parent)
|
|
|
{
|
|
|
qRegisterMetaType<QVector<ImageInfo> >("QVector<ImageInfo>");
|
|
|
qRegisterMetaType<QMap<QString, int> >("QMap<QString,int>");
|
|
|
qRegisterMetaType<QMap<QString, int> >("QMap<QString,int>");
|
|
|
ui.setupUi(this);
|
|
|
this->setWindowTitle(tr("ÑÌÏä¼ì²âϵͳ"));
|
|
|
//m_pShowRltImgLabel = ui.label_showImg;
|
|
|
|
|
|
moduleLoading();
|
|
|
|
|
|
//connect(this, &SmokeBoxIdentification::sgCapture, CameraControl::instance(), &CameraControl::onCapture);
|
|
|
//connect(CameraControl::instance(), &CameraControl::sgCapturedImage, this, &SmokeBoxIdentification::onCapturedImage);
|
|
|
|
|
|
QString applicationDirPath = QCoreApplication::applicationDirPath();
|
|
|
QtConcurrent::run([=]()
|
|
|
{
|
|
|
//if (decodeSmokeInfoCsv(applicationDirPath + SMOKEINFO_XLSX_CONFIG))
|
|
|
// matchSmokeNameAndTemplateFolderName(applicationDirPath + NUM_TEMPLATE_PATH);
|
|
|
m_pDataProcess = std::make_shared<dataPreProcessing>();
|
|
|
|
|
|
if (m_pDataProcess)
|
|
|
{
|
|
|
//dataPreProcessing * t = (dataPreProcessing*)m_pDataProcess.get();
|
|
|
m_pDataProcess->getFileDir(applicationDirPath + NUM_TEMPLATE_PATH);
|
|
|
m_pDataProcess->transmitFilePathForSampleWithItsCorresLabel();
|
|
|
m_pDataProcess->setWinSize(170);
|
|
|
//ADModule::instance()->setDataProcessObj(m_pDataProcess);
|
|
|
}
|
|
|
});
|
|
|
|
|
|
m_pNumTemplateBuild = new QNumTemplateBuild();
|
|
|
if (m_pDataProcess)
|
|
|
{
|
|
|
m_pNumTemplateBuild->setDataProcessObj(m_pDataProcess);
|
|
|
}
|
|
|
QString filePath = applicationDirPath + NET_CONFIG;
|
|
|
m_pNetControl = new NetControl(filePath, true, this);
|
|
|
m_pTcpClientThread = new QThread();
|
|
|
m_pNetControl->moveToThread(m_pTcpClientThread);
|
|
|
connect(m_pTcpClientThread, &QThread::started,
|
|
|
m_pNetControl, &NetControl::onInitNet);
|
|
|
connect(m_pTcpClientThread, &QThread::finished,
|
|
|
this, &QObject::deleteLater);
|
|
|
m_pTcpClientThread->start();
|
|
|
connect(m_pNetControl, &NetControl::sgReceiveData, this, &SmokeBoxIdentification::onDecodeMsg, Qt::QueuedConnection);
|
|
|
connect(this, &SmokeBoxIdentification::sgSendMsg, m_pNetControl, &NetControl::onSendMsg, Qt::QueuedConnection);
|
|
|
|
|
|
|
|
|
if (m_moduleParam.CodeScan != 0)
|
|
|
{
|
|
|
QString codeFilePath = applicationDirPath + COM_CONFIG;
|
|
|
CodeScanStation::instance()->loadParameters(filePath);
|
|
|
CodeScanStation::instance()->openComs();
|
|
|
}
|
|
|
|
|
|
if (m_moduleParam.Sensor != 0)
|
|
|
{
|
|
|
ADModule::instance()->loadParameters(filePath);
|
|
|
filePath = applicationDirPath + COM_CONFIG;
|
|
|
lpSerialStation::instance()->loadParameters(filePath);
|
|
|
lpSerialStation::instance()->openComs();
|
|
|
|
|
|
connect(lpSerialStation::instance(), &lpSerialStation::sgMonitorSensorTriggerStart, this
|
|
|
, &SmokeBoxIdentification::onMonitorSensorTriggerStart);
|
|
|
connect(lpSerialStation::instance(), &lpSerialStation::sgMonitorSensorTriggerStop, this
|
|
|
, &SmokeBoxIdentification::onMonitorSensorTriggerStop);
|
|
|
connect(lpSerialStation::instance(), &lpSerialStation::sgNewEmptyCheckResults, this
|
|
|
, &SmokeBoxIdentification::onSendEmptyCheckResults);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
m_pCategoryMatcher = new CategoryMatcher();
|
|
|
m_pHeightCalculate = new HeightCalculate();
|
|
|
|
|
|
|
|
|
connect(CodeScanStation::instance(), &CodeScanStation::sgNewCodeScanData, lpSerialStation::instance()
|
|
|
, &lpSerialStation::onNewCodeScanResults);
|
|
|
connect(this, &SmokeBoxIdentification::sgCategoryMatchFinished, this, &SmokeBoxIdentification::onNumStatistic);
|
|
|
|
|
|
|
|
|
connect(this, &SmokeBoxIdentification::sgCapture, CameraControl::instance(), &CameraControl::onCapture);
|
|
|
connect(CameraControl::instance(), &CameraControl::sgCapturedImage, this, &SmokeBoxIdentification::onCapturedImage);
|
|
|
|
|
|
|
|
|
connect(this, &SmokeBoxIdentification::sgControlSideLight, lpSerialStation::instance()
|
|
|
, &lpSerialStation::onControlSideLight);
|
|
|
connect(this, &SmokeBoxIdentification::sgStartEmptyPlaceCheck, lpSerialStation::instance()
|
|
|
, &lpSerialStation::onStartEmptyPlaceCheck);
|
|
|
connect(this, &SmokeBoxIdentification::sgStopEmptyPlaceCheck, lpSerialStation::instance()
|
|
|
, &lpSerialStation::onStopEmptyPlaceCheck);
|
|
|
connect(this, &SmokeBoxIdentification::sgNumDataCollectStart, ADModule::instance()
|
|
|
, &ADModule::onDataRequestStart);
|
|
|
connect(this, &SmokeBoxIdentification::sgNumDataCollectStop, ADModule::instance()
|
|
|
, &ADModule::onDataRequestStop);
|
|
|
connect(ADModule::instance(), &ADModule::sgNewNumData, this, &SmokeBoxIdentification::onNewNumData);
|
|
|
//connect(this, &SmokeBoxIdentification::sgSendData2AndAlgo, ADModule::instance(), &ADModule::onSendData2Algo);
|
|
|
//connect(this, &SmokeBoxIdentification::sgSaveSensorData2Local, ADModule::instance(), &ADModule::onSaveData2File);
|
|
|
//connect(this, &SmokeBoxIdentification::sgSendResults, this, &SmokeBoxIdentification::onSendResults);
|
|
|
connect(ui.action_templateNum, SIGNAL(triggered()), this, SLOT(onActionClicked()));
|
|
|
emit sgControlSideLight(lightCtrl::emTurnOnLight);
|
|
|
}
|
|
|
|
|
|
SmokeBoxIdentification::~SmokeBoxIdentification()
|
|
|
{
|
|
|
//emit sgControlSideLight(lightCtrl::emTurnOffLight);
|
|
|
DELETE_POINTER(m_pCategoryMatcher);
|
|
|
DELETE_POINTER(m_pHeightCalculate);
|
|
|
DELETE_POINTER(m_pNetControl);
|
|
|
if (m_pTcpClientThread)
|
|
|
{
|
|
|
m_pTcpClientThread->quit();
|
|
|
m_pTcpClientThread->wait();
|
|
|
m_pTcpClientThread = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onActionClicked()
|
|
|
{
|
|
|
QString strObj = sender()->objectName();
|
|
|
if (strObj == "action_templateNum")
|
|
|
{
|
|
|
m_pNumTemplateBuild->setParent(this);
|
|
|
m_pNumTemplateBuild->setWindowTitle(tr("½¨Á¢ÊýÁ¿Ä£°å"));
|
|
|
m_pNumTemplateBuild->setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
|
|
|
m_pNumTemplateBuild->setWindowModality(Qt::ApplicationModal);
|
|
|
m_pNumTemplateBuild->setAttribute(Qt::WA_ShowModal, true);
|
|
|
m_pNumTemplateBuild->show();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::captureTop(int cameraID)
|
|
|
{
|
|
|
emit sgCapture(eCameraLocation::emTop, cameraID);
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::captureSide(int cameraID)
|
|
|
{
|
|
|
emit sgCapture(eCameraLocation::emSide, cameraID);
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::saveImage(const cv::Mat& imgMat, const QString& filePath)
|
|
|
{
|
|
|
if (imgMat.empty())
|
|
|
{
|
|
|
qWarning() << "Image is empty";
|
|
|
return;
|
|
|
}
|
|
|
cv::imwrite(filePath.toStdString(), imgMat);
|
|
|
qDebug() << "Save image: " << filePath;
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::saveImage(ILImagePtr image, const cv::Mat& imgMat3D, const QString& filePath)
|
|
|
{
|
|
|
if (image->Void())
|
|
|
{
|
|
|
qWarning() << "Image is empty";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
std::wstring path = filePath.toStdWString();
|
|
|
if (!imgMat3D.empty())// 3DÏà»úÊý¾Ý
|
|
|
{
|
|
|
cv::imwrite(filePath.toStdString(), imgMat3D);
|
|
|
int lastPos = filePath.lastIndexOf('.');
|
|
|
QString pclPath = filePath.left(lastPos);
|
|
|
pclPath.append(".pcd");
|
|
|
if (QFile(pclPath).exists())
|
|
|
{
|
|
|
QFile::remove(pclPath);
|
|
|
}
|
|
|
|
|
|
//QFile::copy("C:\\Users\\LENOVO\\Downloads\\30t.pcd",pclPath);
|
|
|
QFile::rename(".\\Cache\\1.pcd", pclPath);
|
|
|
|
|
|
qDebug() << "Save 3D image: " << filePath;
|
|
|
}
|
|
|
else // 2DÏà»úÊý¾Ý
|
|
|
{
|
|
|
image->Save(path.c_str(), nullptr);
|
|
|
qDebug() << "Save 2D image: " << filePath;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (!imgMat3D.empty())
|
|
|
{
|
|
|
int lastPos = filePath.lastIndexOf('.');
|
|
|
QString pclPath = filePath.left(lastPos);
|
|
|
pclPath.append(".pcd");
|
|
|
cv::imwrite(filePath.toStdString(), imgMat3D);
|
|
|
qDebug() << "Save PointCould: " << filePath;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::saveImage(const QVector<ImageInfo>& vecImageInfo, int workMode)
|
|
|
{
|
|
|
QString dataSaveFolderPath;
|
|
|
|
|
|
#if IMAGEDRAWING==LPV
|
|
|
dataSaveFolderPath = QString("%1\\%2\\%3").arg(FILE_STORAGE_PATH)/*.arg(ORIGIN_IMAGE_FOLDER)*/
|
|
|
.arg(m_currtIntoStockInfo.taskNum).arg(m_currtIntoStockInfo.id);
|
|
|
#elif IMAGEDRAWING==OPENCV
|
|
|
switch (workMode)
|
|
|
{
|
|
|
case WorkMode::StockCheck:
|
|
|
dataSaveFolderPath = QString("%1\\%2\\%3").arg(FILE_STORAGE_PATH).arg(m_currtStockCheckInfo.stockNum)
|
|
|
.arg(m_currtStockCheckInfo.taskNum);
|
|
|
break;
|
|
|
case WorkMode::IntoStock:
|
|
|
dataSaveFolderPath = QString("%1\\%2\\%3\\%4").arg(FILE_STORAGE_PATH).arg(INTOSTOCK_IMAGE_FOLDER)
|
|
|
.arg(m_currtIntoStockInfo.stockNum).arg(m_currtIntoStockInfo.taskNum);
|
|
|
break;
|
|
|
default:
|
|
|
qDebug() << "Mode: " << workMode << "do not save Image";
|
|
|
return;
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
QDir folder(dataSaveFolderPath);
|
|
|
if (!folder.exists())
|
|
|
{
|
|
|
QDir dir;
|
|
|
if (dir.mkpath(dataSaveFolderPath))
|
|
|
{
|
|
|
qDebug() << "Create folder: " << dataSaveFolderPath << " successfully.";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
qDebug() << "Create folder:" << dataSaveFolderPath << " failed.";
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
for (int i = 0; i < vecImageInfo.size(); ++i)
|
|
|
{
|
|
|
FileInfo fileInfo = vecImageInfo.at(i).saveImgInfo;
|
|
|
|
|
|
#if IMAGEDRAWING == LPV
|
|
|
QString filePath = QString("%1\\%2").arg(dataSaveFolderPath).arg(fileInfo.name);
|
|
|
saveImage(vecImageInfo.at(i).imageOrigin, vecImageInfo.at(i).image3D, filePath);
|
|
|
|
|
|
#elif IMAGEDRAWING == OPENCV
|
|
|
if (workMode == WorkMode::IntoStock)
|
|
|
{
|
|
|
QString filePathSend = QString("%1/%2/%3/%4").arg(INTOSTOCK_IMAGE_FOLDER)
|
|
|
.arg(m_currtIntoStockInfo.stockNum).arg(m_currtIntoStockInfo.taskNum).arg(fileInfo.name);
|
|
|
m_currtIntoStockInfo.imagesPathList.push_back(filePathSend);
|
|
|
}
|
|
|
|
|
|
saveImage(vecImageInfo.at(i).image, filePath);
|
|
|
#endif
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onCapturedImage(const QVector<ImageInfo>& vecImageInfo, int cameraLocation)
|
|
|
{
|
|
|
if (vecImageInfo.length() <= 0)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
QString serialNumber = vecImageInfo.last().cameraSn;
|
|
|
if (cameraLocation == eCameraLocation::emTop)
|
|
|
{
|
|
|
qDebug() << "top captured";
|
|
|
QtConcurrent::run([=] {
|
|
|
saveImage(vecImageInfo, m_workMode);
|
|
|
if (m_workMode == WorkMode::StockCheck)
|
|
|
{
|
|
|
sendResults(MsgType::DataCollectionEndSC);
|
|
|
}
|
|
|
else if (m_workMode == WorkMode::IntoStock)
|
|
|
{
|
|
|
sendResults(MsgType::IntoStockResult);
|
|
|
}
|
|
|
m_workMode = WorkMode::Idle;
|
|
|
});
|
|
|
}
|
|
|
else if (cameraLocation == eCameraLocation::emSide)
|
|
|
{
|
|
|
qDebug() << "[Camera{" << m_currtIntoStockInfo.stockLocation << "}]: Captured.";
|
|
|
saveImage(vecImageInfo, m_workMode);
|
|
|
|
|
|
m_imageList.insert(m_currtIntoStockInfo.id.toInt(), vecImageInfo);
|
|
|
sendResults(MsgType::IntoStockResult);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onDecodeMsg(const QString& msg)
|
|
|
{
|
|
|
QString msgContent = msg;
|
|
|
if (msgContent.right(1) == END_SYMBOL)
|
|
|
{
|
|
|
msgContent.chop(1);
|
|
|
}
|
|
|
qDebug() << "msg: " << msg << " content: " << msgContent;
|
|
|
|
|
|
switch (m_moduleParam.COMMRules)
|
|
|
{
|
|
|
case eCommunicationRules::emNJ:
|
|
|
{
|
|
|
QStringList strList = msgContent.split(SPLIT_RULE);
|
|
|
qDebug() << "strlist length: " << strList.length() << " head: " << strList.at(0);
|
|
|
|
|
|
if (strList[0] == EMPTY_CHECK_HEAD)
|
|
|
{
|
|
|
if (strList.length() == 4)
|
|
|
{
|
|
|
EmptyCheckInfo emptyCheckInfo;
|
|
|
emptyCheckInfo.streetName = strList[1];
|
|
|
emptyCheckInfo.taskNum = strList[2];
|
|
|
m_currtEmptyCheckInfo = emptyCheckInfo;
|
|
|
if (strList[3] == "START")
|
|
|
{
|
|
|
m_workMode = WorkMode::EmptyCheck;
|
|
|
emit sgStartEmptyPlaceCheck(m_currtEmptyCheckInfo.streetName);
|
|
|
}
|
|
|
else if (strList[3] == "END")
|
|
|
{
|
|
|
if (m_workMode == WorkMode::EmptyCheck)
|
|
|
{
|
|
|
emit sgStopEmptyPlaceCheck();
|
|
|
m_workMode = WorkMode::Idle;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (strList.at(0) == STOCK_CHECK_HEAD)
|
|
|
{
|
|
|
if (strList.length() == 7)
|
|
|
{
|
|
|
qDebug() << "¿ªÊ¼»õλÅ̵ã";
|
|
|
m_workMode = WorkMode::StockCheck;
|
|
|
StockCheckInfo stockCheckInfo;
|
|
|
stockCheckInfo.streetName = strList.at(1);
|
|
|
stockCheckInfo.stockNum = strList.at(2);
|
|
|
stockCheckInfo.taskNum = strList.at(3);
|
|
|
stockCheckInfo.smokeTypeNum = strList.at(4);
|
|
|
stockCheckInfo.smokeQuantity = strList.at(5);
|
|
|
m_currtStockCheckInfo = stockCheckInfo;
|
|
|
}
|
|
|
else if (strList.length() == 3)
|
|
|
{
|
|
|
qDebug() << "È¡»õµ½Î»";
|
|
|
QString taskNum = strList.at(2);
|
|
|
QString currentTaskNum = m_currtStockCheckInfo.taskNum;
|
|
|
if (m_workMode == WorkMode::StockCheck)
|
|
|
{
|
|
|
captureSide(1);
|
|
|
captureTop(1);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (strList.at(0) == INTO_STOCK_HEAD)
|
|
|
{
|
|
|
if (strList.length() == 4)
|
|
|
{
|
|
|
qDebug() << "Èë¿â¶¥²¿ÅÄÕÕ";
|
|
|
m_workMode = WorkMode::IntoStock;
|
|
|
IntoStockInfo intoStockInfo;
|
|
|
intoStockInfo.streetName = strList.at(1);
|
|
|
intoStockInfo.taskNum = strList.at(2);
|
|
|
intoStockInfo.stockNum = strList.at(3);
|
|
|
m_currtIntoStockInfo = intoStockInfo;
|
|
|
captureTop(1);
|
|
|
}
|
|
|
}
|
|
|
else if (strList.at(0) == LIGHT_CONTROL_HEAD)
|
|
|
{
|
|
|
if (strList.length() == 3)
|
|
|
{
|
|
|
qDebug() << "¿ª¹ØµÆ";
|
|
|
if (strList.at(2) == "0")
|
|
|
{
|
|
|
emit sgControlSideLight(lightCtrl::emTurnOffLight);
|
|
|
}
|
|
|
else if (strList.at(2) == "1")
|
|
|
{
|
|
|
emit sgControlSideLight(lightCtrl::emTurnOnLight);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case eCommunicationRules::emSJZ:
|
|
|
{
|
|
|
QStringList msgList = msgContent.split(END_SYMBOL);
|
|
|
for (int i = 0; i < msgList.length(); i++)
|
|
|
{
|
|
|
QStringList strList = msgList[i].split(SPLIT_RULE);
|
|
|
qDebug() << "strlist length: " << strList.length() << " head: " << strList.at(0);
|
|
|
if (strList.at(0) == START_CAPTURE && strList.length() == 7)
|
|
|
{
|
|
|
qDebug() << "µ½Î»È¡Í¼¿ªÊ¼";
|
|
|
//m_workMode = WorkMode::Capture;
|
|
|
m_currtIntoStockInfo.streetName = strList.at(1);
|
|
|
m_currtIntoStockInfo.id = strList.at(2);
|
|
|
m_currtIntoStockInfo.taskNum = strList.at(3);
|
|
|
m_currtIntoStockInfo.stockLocation = strList.at(4);
|
|
|
m_currtIntoStockInfo.smokeTypeNum = strList.at(5);
|
|
|
m_currtIntoStockInfo.smokeQuantity = strList.at(6);
|
|
|
captureSide(m_currtIntoStockInfo.stockLocation.toInt());
|
|
|
}
|
|
|
else if (strList.at(0) == START_CALCULATE && strList.length() == 7)
|
|
|
{
|
|
|
qDebug() << "Æ·¹æ¼ÆÊý¿ªÊ¼";
|
|
|
//m_workMode = WorkMode::StockCheck;
|
|
|
m_currtStockCheckInfo.streetName = strList.at(1);
|
|
|
m_currtStockCheckInfo.id = strList.at(2);
|
|
|
m_currtStockCheckInfo.taskNum = strList.at(3);
|
|
|
m_currtStockCheckInfo.stockLocation = strList.at(4);
|
|
|
m_currtStockCheckInfo.smokeTypeNum = strList.at(5);
|
|
|
m_currtStockCheckInfo.smokeQuantity = strList.at(6);
|
|
|
m_stocketList.insert(m_currtStockCheckInfo.id.toInt(), m_currtStockCheckInfo);
|
|
|
calculate(m_currtStockCheckInfo.id.toInt());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::calculate(int stocketID)
|
|
|
{
|
|
|
QtConcurrent::run([=] {
|
|
|
|
|
|
bool bRlt = false;
|
|
|
StockCheckInfo stocket = m_stocketList.value(stocketID);
|
|
|
if (!m_stocketList.contains(stocketID))
|
|
|
{
|
|
|
qCritical() << "Don't Save stocketID[" << stocketID << "] Message!";
|
|
|
return;
|
|
|
}
|
|
|
QString typeNum = stocket.smokeTypeNum;
|
|
|
cv::Mat imgRltMat;
|
|
|
|
|
|
QString dataSaveFolder = QString("%1\\%2\\%3").arg(FILE_STORAGE_PATH)
|
|
|
.arg(stocket.taskNum).arg(stocket.id);
|
|
|
|
|
|
|
|
|
QVector<ImageInfo> vecImageInfo = m_imageList.value(stocket.id.toInt());
|
|
|
|
|
|
// ÓÉÓÚ֮ǰÊǶà¸öÏà»úÅÄÒ»¸ö¿â£¬ÈôÇ°Ò»¸öÏà»úµÄͼÏñΪOK£¬Ôò²»ÔËÐÐÏÂÒ»¸ö
|
|
|
for each (const ImageInfo& imgInfo in vecImageInfo)
|
|
|
{
|
|
|
QString str = QString("[%1]:Camera %2 Match Start ...").arg(stocket.id).arg(imgInfo.cameraSn);
|
|
|
qDebug() << str;
|
|
|
|
|
|
if (!imgInfo.imageFixed->Void())
|
|
|
{
|
|
|
if (m_pCategoryMatcher->smokeMatch(typeNum, imgInfo.imageFixed,stocket.id.toInt()))
|
|
|
{
|
|
|
str = QString("[%1]:Camera %2 Match successful!").arg(stocket.id).arg(imgInfo.cameraSn);
|
|
|
qDebug() << str;
|
|
|
bRlt = true;
|
|
|
m_stocketList[stocketID].smokeTypeNumRlt = typeNum;
|
|
|
FileInfo fileInfo = imgInfo.saveImgInfo;
|
|
|
QString fileName = QString("%1_%2_rlt%3").arg(fileInfo.strId)
|
|
|
.arg(m_currtStockCheckInfo.smokeTypeNum).arg(fileInfo.suffix);
|
|
|
QString filePath = QString("%1\\%2").arg(dataSaveFolder).arg(fileName);
|
|
|
m_pCategoryMatcher->saveResultsImage(filePath);
|
|
|
|
|
|
|
|
|
m_stocketList[stocketID].imagesPathList.append(filePath.right(filePath.length()-1));
|
|
|
|
|
|
|
|
|
//¸ù¾ÝÏà»ú±àºÅ£¬¶ÔÓ¦ÕÒµ½3D»ù×¼ÎļþÈ¥¼ÆËã²ã¸ß
|
|
|
QString pclPath = dataSaveFolder;
|
|
|
pclPath.append(QString("*.pcd").arg(fileInfo.strId));
|
|
|
|
|
|
QDir dir(pclPath);
|
|
|
QFileInfoList fileList = dir.entryInfoList(QStringList() << "*.pcd", QDir::Files | QDir::NoDotAndDotDot);
|
|
|
|
|
|
if (fileList.length() > 0)
|
|
|
{
|
|
|
pclPath = fileList[0].absolutePath();
|
|
|
m_pHeightCalculate->LoadPointCould(fileList[0].absolutePath());
|
|
|
str = QString("[%1]:Camera %2 -- PointCould = %3").arg(stocket.id)
|
|
|
.arg(imgInfo.cameraSn).arg(pclPath);
|
|
|
qInfo() << str;
|
|
|
|
|
|
int lastPos = pclPath.lastIndexOf('.');
|
|
|
QString depthImagePath = pclPath.left(lastPos);
|
|
|
depthImagePath.append(".PNG");
|
|
|
m_stocketList[stocketID].imagesPathList.append(depthImagePath.right(depthImagePath.length() - 1));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
str = QString("[%1]:Camera %2 -- PointCould[%3] can't Find!").arg(stocket.id)
|
|
|
.arg(imgInfo.cameraSn).arg(pclPath);
|
|
|
qWarning() << str;
|
|
|
}
|
|
|
|
|
|
QString basicFile = QString("\\config\\%1.ini").arg(fileInfo.strId);
|
|
|
if (!QFile(basicFile).exists())
|
|
|
{
|
|
|
str = QString("[%1]:Camera %2 -- BasicFile[%3] can't Find!").arg(stocket.id)
|
|
|
.arg(imgInfo.cameraSn).arg(basicFile);
|
|
|
qWarning() << str;
|
|
|
}
|
|
|
m_pHeightCalculate->LoadBasicFile(QString{});
|
|
|
|
|
|
//ÊýÁ¿¼ÆËã
|
|
|
m_stocketList[stocketID].smokeQuantityRlt = QString::number(m_pHeightCalculate->SmokeHeight());
|
|
|
|
|
|
//QFile::copy("C:\\Users\\LENOVO\\Downloads\\30t.pcd",pclPath);
|
|
|
QFile::rename(".\\Cache\\1.pcd", pclPath);
|
|
|
|
|
|
break;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
str = QString("[%1]:Camera %2 Match Failed!").arg(stocket.id).arg(imgInfo.cameraSn);
|
|
|
qWarning() << str;
|
|
|
QString filePath = dataSaveFolder + QString("\\%1_error.PNG")
|
|
|
.arg(stocket.smokeTypeNum);
|
|
|
m_pCategoryMatcher->saveResultsImage(filePath);
|
|
|
m_stocketList[stocketID].imagesPathList.append(filePath.right(filePath.length()-1));
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
str = QString("[%1]:imgInfo.image is Empty!").arg(stocket.id);
|
|
|
qDebug() << str;
|
|
|
}
|
|
|
}
|
|
|
if (!bRlt)
|
|
|
{
|
|
|
m_stocketList[stocketID].smokeTypeNumRlt = "0";
|
|
|
m_stocketList[stocketID].smokeQuantityRlt = "0";
|
|
|
}
|
|
|
|
|
|
if (!bRlt || m_stocketList[stocketID].smokeQuantity!= m_stocketList[stocketID].smokeQuantityRlt)
|
|
|
{
|
|
|
m_stocketList[stocketID].correctness = false;
|
|
|
}
|
|
|
sendResults(MsgType::StockCheckResult,stocketID);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onNumStatistic(QString typeNum)
|
|
|
{
|
|
|
qDebug() << "start num statistic";
|
|
|
if (!m_bDataCollection)
|
|
|
{
|
|
|
qDebug() << "typeNum: " << typeNum;
|
|
|
if (typeNum == "0")
|
|
|
{
|
|
|
m_currtStockCheckInfo.smokeQuantityRlt = "0";
|
|
|
m_currtStockCheckInfo.correctness = false;
|
|
|
sendResults(MsgType::StockCheckResult);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
QString smokeCnName = m_mapSmokeCode2Name.value(typeNum);
|
|
|
QString templateName;
|
|
|
if (m_mapSmokeName2TemplateFolderName.contains(smokeCnName))
|
|
|
{
|
|
|
templateName = m_mapSmokeName2TemplateFolderName.value(smokeCnName);
|
|
|
QtConcurrent::run([=]() {
|
|
|
dataPreProcessing::QStandardnormFileMapLabelSample m = m_pDataProcess->getDataStructure();
|
|
|
int matchLabel = -2;
|
|
|
if (m.contains(templateName))
|
|
|
{
|
|
|
qDebug() << "template find " << templateName;
|
|
|
matchLabel = m_pDataProcess->dataRepeatMatch(templateName);
|
|
|
qDebug() << "match label: " << matchLabel;
|
|
|
m_pDataProcess->clearComData();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
qWarning() << "template not find " << templateName;
|
|
|
m_pDataProcess->clearComData();
|
|
|
matchLabel = -1;
|
|
|
}
|
|
|
int quantityReceive = m_currtStockCheckInfo.smokeQuantity.toInt();
|
|
|
if (matchLabel < 0 /*|| matchLabel != quantityReceive*/)
|
|
|
{
|
|
|
m_currtStockCheckInfo.smokeQuantityRlt = "0";
|
|
|
m_currtStockCheckInfo.correctness = false;
|
|
|
}
|
|
|
else if (matchLabel != quantityReceive)
|
|
|
{
|
|
|
m_currtStockCheckInfo.smokeQuantityRlt = QString::number(matchLabel);
|
|
|
m_currtStockCheckInfo.correctness = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_currtStockCheckInfo.smokeQuantityRlt = QString::number(matchLabel);
|
|
|
m_currtStockCheckInfo.correctness = true;
|
|
|
}
|
|
|
sendResults(MsgType::StockCheckResult);
|
|
|
});
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
qWarning() << "Template folder not find: " << smokeCnName;
|
|
|
m_currtStockCheckInfo.smokeQuantityRlt = "0";
|
|
|
m_currtStockCheckInfo.correctness = false;
|
|
|
sendResults(MsgType::StockCheckResult);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::sendResults(int mode, int id)
|
|
|
{
|
|
|
QString resultInfoMsg;
|
|
|
switch (mode)
|
|
|
{
|
|
|
case EmptyCheckResult:
|
|
|
break;
|
|
|
case DataCollectionEndSC:
|
|
|
resultInfoMsg.append(STOCK_CHECK_HEAD).append(SPLIT_RULE).append(m_currtStockCheckInfo.streetName)
|
|
|
.append(SPLIT_RULE).append(m_currtStockCheckInfo.taskNum).append(END_SYMBOL);
|
|
|
break;
|
|
|
case StockCheckResult:
|
|
|
switch (m_moduleParam.COMMRules)
|
|
|
{
|
|
|
case eCommunicationRules::emNJ:
|
|
|
if (QString::compare(m_currtStockCheckInfo.smokeTypeNum, m_currtStockCheckInfo.smokeTypeNumRlt) < 0
|
|
|
&& QString::compare("0", m_currtStockCheckInfo.smokeTypeNumRlt) < 0)
|
|
|
{
|
|
|
resultInfoMsg.append(STOCK_CHECK_HEAD).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.streetName).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.stockNum).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.taskNum).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.smokeTypeNumRlt).append(SPLIT_RULE)
|
|
|
.append(QString::number(0)).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.smokeTypeNumRlt).append(SPLIT_RULE)
|
|
|
.append(QString::number(0)).append(SPLIT_RULE)
|
|
|
.append(QString::number(0)).append(END_SYMBOL);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
resultInfoMsg.append(STOCK_CHECK_HEAD).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.streetName).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.stockNum).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.taskNum).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.smokeTypeNum).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.smokeQuantity).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.smokeTypeNumRlt).append(SPLIT_RULE)
|
|
|
.append(m_currtStockCheckInfo.smokeQuantityRlt).append(SPLIT_RULE)
|
|
|
.append(QString::number(m_currtStockCheckInfo.correctness)).append(END_SYMBOL);
|
|
|
}
|
|
|
break;
|
|
|
case eCommunicationRules::emSJZ:
|
|
|
resultInfoMsg.append(RETURN_CALCULATE).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).streetName).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).id).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).taskNum).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).stockLocation).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).smokeTypeNumRlt).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).smokeQuantityRlt).append(SPLIT_RULE)
|
|
|
.append(QString::number(m_stocketList.value(id).correctness)).append(SPLIT_RULE)
|
|
|
.append(m_stocketList.value(id).imagesPathList.join(";")).append(END_SYMBOL);
|
|
|
m_stocketList.remove(id);
|
|
|
qInfo() << "m_stocketList.remove(id) = " << id <<"; Next ="<<m_stocketList.size();
|
|
|
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
case IntoStockResult:
|
|
|
switch (m_moduleParam.COMMRules)
|
|
|
{
|
|
|
case eCommunicationRules::emNJ:
|
|
|
{
|
|
|
resultInfoMsg.append(INTO_STOCK_HEAD).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.streetName).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.taskNum).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.stockNum).append(SPLIT_RULE);
|
|
|
QStringList imagesPathList = m_currtIntoStockInfo.imagesPathList;
|
|
|
for (int i = 0; i < imagesPathList.length() - 1; ++i)
|
|
|
{
|
|
|
resultInfoMsg.append(imagesPathList.at(i)).append(CONTENT_SPLIT);
|
|
|
}
|
|
|
resultInfoMsg.append(imagesPathList.last()).append(END_SYMBOL);
|
|
|
break;
|
|
|
}
|
|
|
case eCommunicationRules::emSJZ:
|
|
|
{
|
|
|
resultInfoMsg.append(END_CAPTURE).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.streetName).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.id).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.taskNum).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.stockLocation).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.smokeTypeNum).append(SPLIT_RULE)
|
|
|
.append(m_currtIntoStockInfo.smokeQuantity).append(END_SYMBOL);
|
|
|
break;
|
|
|
}
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
emit sgSendMsg(resultInfoMsg);
|
|
|
qDebug() << "send msg: " << resultInfoMsg;
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onShowImage(QLabel* labelPtr, const QImage& qImage)
|
|
|
{
|
|
|
qDebug() << "Showing image";;
|
|
|
QRect rect = labelPtr->rect();
|
|
|
if (qImage.isNull())
|
|
|
{
|
|
|
qWarning() << "QImage is empty";
|
|
|
return;
|
|
|
}
|
|
|
QImage imgShow = qImage.scaled(QSize(rect.size()));
|
|
|
labelPtr->setPixmap(QPixmap::fromImage(imgShow));
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onMonitorSensorTriggerStart(int sideId)
|
|
|
{
|
|
|
if (m_workMode == WorkMode::StockCheck)
|
|
|
{
|
|
|
qDebug() << "start collect data";
|
|
|
emit sgNumDataCollectStart(sideId);
|
|
|
m_bDataCollection = true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onMonitorSensorTriggerStop(int sideId)
|
|
|
{
|
|
|
if (m_workMode == WorkMode::StockCheck)
|
|
|
{
|
|
|
qDebug() << "stop collect data";
|
|
|
emit sgNumDataCollectStop();
|
|
|
m_bDataCollection = false;
|
|
|
//emit sgSendData2AndAlgo();
|
|
|
//QString dataSaveFolder = QString("%1\\%2\\%3\\%4").arg(FILE_STORAGE_PATH)
|
|
|
// .arg(m_currtStockCheckInfo.stockNum).arg(m_currtStockCheckInfo.taskNum)
|
|
|
// .arg(m_currtStockCheckInfo.smokeQuantity);
|
|
|
//dataPreProcessing::mkDir(dataSaveFolder);
|
|
|
//emit sgSaveSensorData2Local(dataSaveFolder);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool SmokeBoxIdentification::decodeSmokeInfoCsv(const QString& filePath)
|
|
|
{
|
|
|
m_mapSmokeCode2Name.clear();
|
|
|
QXlsx::Document* pXlsxDoc = new QXlsx::Document(filePath);
|
|
|
if (pXlsxDoc == NULL)
|
|
|
{
|
|
|
qWarning() << "Load " << filePath << " error";
|
|
|
return false;
|
|
|
}
|
|
|
QString currentSheetName;
|
|
|
QStringList sheetNames = pXlsxDoc->sheetNames();
|
|
|
if (sheetNames.length() == 0)
|
|
|
{
|
|
|
qWarning() << "The quantity of xlsx's sheet is 0";
|
|
|
return false;
|
|
|
}
|
|
|
QXlsx::AbstractSheet* currentSheet = pXlsxDoc->sheet(sheetNames.at(0));
|
|
|
if (currentSheet == NULL)
|
|
|
return false;
|
|
|
|
|
|
// get full cells of current sheet
|
|
|
currentSheet->workbook()->setActiveSheet(0);
|
|
|
QXlsx::Worksheet* wsheet = (QXlsx::Worksheet*)currentSheet->workbook()->activeSheet();
|
|
|
if (wsheet == NULL)
|
|
|
return false;
|
|
|
|
|
|
QXlsx::CellRange cellRange = wsheet->dimension();
|
|
|
int rowStart = cellRange.firstRow();
|
|
|
int colStart = cellRange.firstColumn();
|
|
|
|
|
|
int rowEnd = cellRange.lastRow();
|
|
|
int colEnd = cellRange.lastColumn();
|
|
|
for (int i = rowStart + 1; i <= rowEnd; ++i)
|
|
|
{
|
|
|
QString smokeCode = wsheet->read(i, colStart).toString();
|
|
|
QString smokeName = wsheet->read(i, colStart + 1).toString();
|
|
|
if (smokeCode.isEmpty() || smokeName.isEmpty())
|
|
|
continue;
|
|
|
m_mapSmokeCode2Name.insert(smokeCode, smokeName);
|
|
|
//qDebug() << "insert: " << smokeCode << " and " << smokeName;
|
|
|
}
|
|
|
qDebug() << "Decode smokeInfo from " << filePath << " successed";
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool SmokeBoxIdentification::matchSmokeNameAndTemplateFolderName(const QString& folderPath)
|
|
|
{
|
|
|
m_mapSmokeName2TemplateFolderName.clear();
|
|
|
QDir fileDir(folderPath);
|
|
|
if (!fileDir.exists())
|
|
|
{
|
|
|
qWarning() << folderPath << " is not exist";
|
|
|
return false;
|
|
|
}
|
|
|
if (m_mapSmokeCode2Name.empty())
|
|
|
{
|
|
|
qWarning() << "Decode smokeInfo csv first!";
|
|
|
return false;
|
|
|
}
|
|
|
QStringList smokeCNNameList = m_mapSmokeCode2Name.values();
|
|
|
QFileInfoList listInfoList = fileDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
|
|
|
if (listInfoList.empty())
|
|
|
{
|
|
|
qDebug() << folderPath << " has not folder";
|
|
|
return false;
|
|
|
}
|
|
|
for each (QFileInfo typeFolder in listInfoList)
|
|
|
{
|
|
|
QString typeFolderName = typeFolder.fileName();
|
|
|
bool bFind = false;
|
|
|
for (int i = 0; i < smokeCNNameList.length(); ++i)
|
|
|
{
|
|
|
QString smokeCNName = smokeCNNameList.at(i);
|
|
|
if (typeFolderName.contains(smokeCNName))
|
|
|
{
|
|
|
m_mapSmokeName2TemplateFolderName.insert(smokeCNName, typeFolderName);
|
|
|
//qDebug() << "find " << typeFolderName << " in excel";
|
|
|
//qDebug() << "insert " << smokeCNName << " and " << typeFolderName;
|
|
|
smokeCNNameList.removeAt(i);
|
|
|
bFind = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (!bFind)
|
|
|
{
|
|
|
qDebug() << "Not find: " << typeFolderName << " in excel";
|
|
|
}
|
|
|
}
|
|
|
qDebug() << "match smokeName and templateFolderName successed";
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onSendEmptyCheckResults(const QMap<QString, int>& mapEmptyCheckResults)
|
|
|
{
|
|
|
QString emptyAll;
|
|
|
for each (QString code in mapEmptyCheckResults.keys())
|
|
|
{
|
|
|
int emptyStatus = mapEmptyCheckResults[code];
|
|
|
emptyAll.append(code).append(CODE_CONTENT_SPLIT).append(QString::number(emptyStatus))
|
|
|
.append(CONTENT_SPLIT);
|
|
|
}
|
|
|
QString emptyResult;
|
|
|
emptyResult.append(EMPTY_CHECK_HEAD).append(SPLIT_RULE).append(m_currtEmptyCheckInfo.streetName)
|
|
|
.append(SPLIT_RULE).append(m_currtEmptyCheckInfo.taskNum).append(SPLIT_RULE).append(emptyAll)
|
|
|
.append(END_SYMBOL);
|
|
|
emit sgSendMsg(emptyResult);
|
|
|
qDebug() << "send msg: " << emptyResult;
|
|
|
}
|
|
|
|
|
|
Q_SLOT void SmokeBoxIdentification::onNewNumData(const QVector<QVector<double>>& vec, const QVector<QString>& strVec, int side)
|
|
|
{
|
|
|
if (vec[0].size() <= 0)
|
|
|
{
|
|
|
qWarning() << "signal stopped but i didnt get data";
|
|
|
return;
|
|
|
}
|
|
|
QString szSide = side == emTopLeft ? "left" : "right";
|
|
|
m_pDataProcess->sensorValTransformationTemp(vec, szSide);
|
|
|
QString dataSaveFolder = QString("%1\\%2\\%3\\%4").arg(FILE_STORAGE_PATH)
|
|
|
.arg(m_currtStockCheckInfo.stockNum).arg(m_currtStockCheckInfo.taskNum)
|
|
|
.arg(m_currtStockCheckInfo.smokeQuantity);
|
|
|
dataPreProcessing::mkDir(dataSaveFolder);
|
|
|
saveData2File(strVec, dataSaveFolder, side);
|
|
|
}
|
|
|
|
|
|
void SmokeBoxIdentification::saveData2File(const QVector<QString>& strVec, QString folderPath, int side)
|
|
|
{
|
|
|
if (!QDir(folderPath).exists())
|
|
|
{
|
|
|
qWarning() << folderPath << " is not exist";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QString timeStr = QDateTime::currentDateTime().toString("yyyy-MM-dd_hh-mm-ss");
|
|
|
if (strVec.size() <= 0)
|
|
|
{
|
|
|
qWarning() << "sensor raw data is empty";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto savefile = [&](const QString& path, QVector<QString>& vec)->bool
|
|
|
{
|
|
|
ofstream mfile;
|
|
|
mfile.open(path.toStdString(), std::ios::out | std::ios::app | std::ios::ate);
|
|
|
if (!mfile.is_open()) return false;
|
|
|
for (int i = 0; i < vec.size(); ++i)
|
|
|
{
|
|
|
const QString& ls = vec[i];
|
|
|
std::string ss = ls.toStdString() + "\n";
|
|
|
//std::string ss = ls.toStdString();
|
|
|
mfile << ss;
|
|
|
}
|
|
|
mfile.flush();
|
|
|
mfile.close();
|
|
|
};
|
|
|
|
|
|
QString strSide = side == emTopLeft ? "left" : "right";
|
|
|
QString filePath = QString("%1\\%2_%3.txt").arg(folderPath).arg(timeStr).arg(strSide);
|
|
|
qDebug() << "find path" << filePath;
|
|
|
|
|
|
if (strVec.size() >= mimumDataSize)
|
|
|
{
|
|
|
QVector<QString> vec;
|
|
|
m_pDataProcess->sensorValTransformationTemp(strVec, vec, strSide);
|
|
|
savefile(filePath, vec);
|
|
|
qDebug() << "save " << strSide << " data to txt successfully";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
void SmokeBoxIdentification::moduleLoading()
|
|
|
{
|
|
|
QString fileMyself = QCoreApplication::applicationDirPath() + MODULE_CONFIG;
|
|
|
QFile file(fileMyself);
|
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
|
|
|
{
|
|
|
qWarning() << "´ò¿ªÎļþʧ°Ü£¡";
|
|
|
return;
|
|
|
}
|
|
|
QByteArray arr = file.readAll();
|
|
|
file.close();
|
|
|
if (arr.isEmpty())
|
|
|
{
|
|
|
qWarning() << "ÄÚÈÝΪ¿Õ";
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QJsonParseError err;
|
|
|
QJsonDocument doc = QJsonDocument::fromJson(arr, &err);
|
|
|
if (doc.isEmpty())
|
|
|
{
|
|
|
qWarning() << err.errorString(); //´òӡʧ°ÜÐÅÏ¢
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
QJsonObject jsMyself = doc.object();
|
|
|
QJsonObject ModuleParamObj = jsMyself.value("ModuleParam").toObject();
|
|
|
if (!ModuleParamObj.isEmpty()) {
|
|
|
m_moduleParam.CodeScan = ModuleParamObj.value("CodeScan").toInt();
|
|
|
m_moduleParam.Sensor = ModuleParamObj.value("Sensor").toInt();
|
|
|
m_moduleParam.Camera2D = ModuleParamObj.value("Camera2D").toInt();
|
|
|
m_moduleParam.Camera3D = ModuleParamObj.value("Camera3D").toInt();
|
|
|
m_moduleParam.COMMRules = (eCommunicationRules)ModuleParamObj.value("COMMRules").toInt();
|
|
|
}
|
|
|
} |