upright
/
whellvalue
mirror of https://gitlab.hzleaper.com:81/bob.pan/whellvalue.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

1、engine模块接口调整，移除不需要的类型和接口（改动较大）

Browse Source 
2、lpmain模块中加入engine模块加载
master
bob.pan 5 years ago
parent 5867aba903
commit 3ff4f60aa5
44 changed files with 253 additions and 2189 deletions
Show Stats Download Patch File Download Diff File

2
3part/tadpole/include/tpBase/iAlgorithm.h
Unescape Escape View File

@ -175,7 +175,7 @@ protected:
#endif #endif
#endif #endif
ALGORITHM_API IAlgorithm* Algorithm_Create(class IDetectorEngine*); ALGORITHM_API IAlgorithm* Algorithm_Create();
ALGORITHM_API void Algorithm_Delete(IAlgorithm* pAlg); ALGORITHM_API void Algorithm_Delete(IAlgorithm* pAlg);
#endif #endif

2
3part/tadpole/include/tpBase/iCoreCtrl.h
Unescape Escape View File

@ -68,7 +68,7 @@ public:
virtual bool IRegisterResultCallBack(FuncCallBack_StrMap callback) = 0; //注册算法结果回调函数 可获取算法检测结果 virtual bool IRegisterResultCallBack(FuncCallBack_StrMap callback) = 0; //注册算法结果回调函数 可获取算法检测结果
virtual bool IRegisterCamEventCallBack(FuncCallBack_StrInt callback) = 0;//注册相机事件回调函数 可获取相机打开关闭等相关事件 virtual bool IRegisterCamEventCallBack(FuncCallBack_StrInt callback) = 0;//注册相机事件回调函数 可获取相机打开关闭等相关事件
public://private: //use private when the old main is discarded; public://private: //use private when the old main is discarded;
virtual int IInitCore(class IDetectorEngine* pDE = NULL) = 0; virtual int IInitCore() = 0;
virtual void IFreeCore() = 0; virtual void IFreeCore() = 0;
virtual void IStartImageProcess() = 0; virtual void IStartImageProcess() = 0;
virtual void IEndImageProcess() = 0; virtual void IEndImageProcess() = 0;

BIN
3part/tadpole/include/tpBase/lpbengine.h
View File

Binary file not shown.

1
3part/tadpole/include/tpBase/lpdesigner.h
Unescape Escape View File

@ -4,7 +4,6 @@
#include "lpdsgdefine.h" #include "lpdsgdefine.h"
#include "SystemStateInfo.h" #include "SystemStateInfo.h"
#include <QtCore> #include <QtCore>
//#include "vld.h"
class IDetectorEngine; class IDetectorEngine;
class IDetectorTask; class IDetectorTask;

13
src/algorithm/tpAlgorithm.cpp
Unescape Escape View File

@ -1,15 +1,6 @@
/****************************************************************************** #include "iAlgorithm.h"
Copyright(C):2015~2018 hzleaper
FileName:tpAlgorithm.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/15
History:15:5:2015 17:56
*******************************************************************************/
#include "iAlgorithm.h"
#include "AlgorithmFluorescence.h" #include "AlgorithmFluorescence.h"
ALGORITHM_API IAlgorithm* Algorithm_Create(class IDetectorEngine*) ALGORITHM_API IAlgorithm* Algorithm_Create()
{ {
return new CAlgorithmFluorescence(); return new CAlgorithmFluorescence();
} }

15
src/lpbdesigner/DsgRoiDlg.cpp
Unescape Escape View File

@ -94,9 +94,6 @@ bool CDsgRoiDlg::Initialize(IDetectorEngine* pDE, IDetectorAlgorithm* pAlgo, IDe
m_pDE = pDE; m_pDE = pDE;
m_pTask = pTask; m_pTask = pTask;
void* p;
m_pDE->GetDataInterface(DEVICEMGR, &p);
m_pDeviceMgr = (IDetectorDeviceMgr*)p;
if (!InitGraphView()) if (!InitGraphView())
return false; return false;
@ -212,12 +209,12 @@ void __stdcall RoiImageEventHandler(void * callBackOwner, QImage& img, int nDevi
void CDsgRoiDlg::OnSnapCameraImage() void CDsgRoiDlg::OnSnapCameraImage()
{ {
DeviceType type; // DeviceType type;
IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)m_pDeviceMgr->GetDevice(m_pTask->GetTaskInfo()->nCameraID, type); // IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)m_pDeviceMgr->GetDevice(m_pTask->GetTaskInfo()->nCameraID, type);
if (!pCamera && type != CAMERA) // if (!pCamera && type != CAMERA)
return; // return;
//
pCamera->SnapImage(this, RoiImageEventHandler); // pCamera->SnapImage(this, RoiImageEventHandler);
} }
void CDsgRoiDlg::OnSelectImage() void CDsgRoiDlg::OnSelectImage()

2
src/lpbdesigner/DsgRoiDlg.h
Unescape Escape View File

@ -52,10 +52,8 @@ private:
Ui::RoiDlg *ui; Ui::RoiDlg *ui;
IDetectorEngine* m_pDE{ nullptr }; IDetectorEngine* m_pDE{ nullptr };
IDetectorDeviceMgr* m_pDeviceMgr{ nullptr };
IDetectorTask* m_pTask{ nullptr }; IDetectorTask* m_pTask{ nullptr };
RoiScene* m_pRoiScene{ nullptr }; RoiScene* m_pRoiScene{ nullptr };
LP_DETECTOR_ROI_DATA m_tempRoiData; LP_DETECTOR_ROI_DATA m_tempRoiData;
}; };

87
src/lpbdesigner/MainFrame.cpp
Unescape Escape View File

@ -112,7 +112,6 @@ CMainFrame::CMainFrame(QWidget *parent)
{ {
m_pDE = NULL; m_pDE = NULL;
m_pSolutionMgr = NULL; m_pSolutionMgr = NULL;
m_pDeviceMgr = NULL;
m_pCurrentSolution = NULL; m_pCurrentSolution = NULL;
m_pCurrentTask = NULL; m_pCurrentTask = NULL;
m_pCurrentAlgo = NULL; m_pCurrentAlgo = NULL;
@ -196,11 +195,11 @@ bool CMainFrame::OnMainMenuTrigger(QAction* pAction)
if (!oldMat.empty()) if (!oldMat.empty())
_pOldTask->GetTaskInfo()->templateImg = oldMat; _pOldTask->GetTaskInfo()->templateImg = oldMat;
} }
if (m_pDE && m_pDE->SaveTasks(m_TaskChangeList)) // if (m_pDE && m_pDE->SaveTasks(m_TaskChangeList))
{ // {
m_TaskChangeList.clear(); // m_TaskChangeList.clear();
return true; // return true;
} // }
return false; return false;
} }
@ -218,28 +217,28 @@ void CMainFrame::OnTrigger()
if (!oldMat.empty()) if (!oldMat.empty())
_pOldTask->GetTaskInfo()->templateImg = oldMat; _pOldTask->GetTaskInfo()->templateImg = oldMat;
} }
if (m_pDE && m_pDE->SaveTasks(m_TaskChangeList)) // if (m_pDE && m_pDE->SaveTasks(m_TaskChangeList))
{ // {
if (_pSaveStatus) // if (_pSaveStatus)
{ // {
_pSaveStatus->setText(QObject::tr(" 标定数据保存完成！")); // _pSaveStatus->setText(QObject::tr(" 标定数据保存完成！"));
QTimer::singleShot(1500, [&](){ // QTimer::singleShot(1500, [&](){
_pSaveStatus->setText(""); // _pSaveStatus->setText("");
update(); // update();
}); // });
m_TaskChangeList.clear(); // m_TaskChangeList.clear();
SystemStateInfo::bParamStateFlag = false; // SystemStateInfo::bParamStateFlag = false;
} // }
} // }
else // else
{ // {
if (_pSaveStatus) // if (_pSaveStatus)
{ // {
_pSaveStatus->setText(QObject::tr(" 保存失败！")); // _pSaveStatus->setText(QObject::tr(" 保存失败！"));
QTimer::singleShot(2000, [&](){_pSaveStatus->setText(""); }); // QTimer::singleShot(2000, [&](){_pSaveStatus->setText(""); });
update(); // update();
} // }
} // }
} }
} }
@ -249,16 +248,9 @@ bool CMainFrame::Initialize(IDetectorEngine* lpDE)
return false; return false;
m_pDE = lpDE; m_pDE = lpDE;
void * p; m_pSolutionMgr = m_pDE->getSolutionMgr();
m_pDE->GetDataInterface(SOLUTIONMGR, &p);
m_pSolutionMgr = (IDetectorSolutionMgr*)p;
if (!m_pSolutionMgr) if (!m_pSolutionMgr)
return false; return false;
m_pDE->GetDataInterface(DEVICEMGR, &p);
m_pDeviceMgr = (IDetectorDeviceMgr*)p;
if (!m_pDeviceMgr)
return false;
return true; return true;
} }
@ -656,15 +648,15 @@ void __stdcall ImageEventHandler(void * callBackOwner, QImage& img, int nDeviceI
bool CMainFrame::OnSnapImage() bool CMainFrame::OnSnapImage()
{ {
if (!currentTask()) // if (!currentTask())
return false; // return false;
//
DeviceType type; // DeviceType type;
IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)m_pDeviceMgr->GetDevice(m_pCurrentTask->GetTaskInfo()->nCameraID, type); // IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)m_pDeviceMgr->GetDevice(m_pCurrentTask->GetTaskInfo()->nCameraID, type);
if (!pCamera && type != CAMERA) // if (!pCamera && type != CAMERA)
return false; // return false;
//
pCamera->SnapImage(this, ImageEventHandler); // pCamera->SnapImage(this, ImageEventHandler);
return true; return true;
} }
@ -1867,10 +1859,7 @@ void CMainFrame::closeEvent(QCloseEvent *event)
msgBox.addButton(QObject::tr("否"), QMessageBox::RejectRole); msgBox.addButton(QObject::tr("否"), QMessageBox::RejectRole);
if (msgBox.exec() == QMessageBox::AcceptRole) if (msgBox.exec() == QMessageBox::AcceptRole)
{ {
m_pDE->Save(); //m_pDE->Save();
}
else
{
} }
SystemStateInfo::bParamStateFlag = false; SystemStateInfo::bParamStateFlag = false;
} }

1
src/lpbdesigner/MainFrame.h
Unescape Escape View File

@ -103,7 +103,6 @@ private:
IDetectorEngine* m_pDE{ nullptr }; IDetectorEngine* m_pDE{ nullptr };
IDetectorSolutionMgr* m_pSolutionMgr{ nullptr }; IDetectorSolutionMgr* m_pSolutionMgr{ nullptr };
IDetectorDeviceMgr* m_pDeviceMgr{ nullptr };
IDetectorSolution* m_pCurrentSolution{ nullptr }; IDetectorSolution* m_pCurrentSolution{ nullptr };
IDetectorTask* m_pCurrentTask{ nullptr }; IDetectorTask* m_pCurrentTask{ nullptr };

123
src/lpbengine/Algorithm.cpp
Unescape Escape View File

@ -12,7 +12,6 @@ CDetectorAlgorithm::CDetectorAlgorithm() : m_mutex(QReadWriteLock::Recursive)
m_mapOutParams.clear(); m_mapOutParams.clear();
m_pAlgo = NULL; m_pAlgo = NULL;
m_pTask = NULL; m_pTask = NULL;
m_pAlgoShare = NULL;
m_bIsFinished = false; m_bIsFinished = false;
m_bIsExec = true; m_bIsExec = true;
m_dExecTime = 0.0; m_dExecTime = 0.0;
@ -23,13 +22,12 @@ CDetectorAlgorithm::~CDetectorAlgorithm()
CleanUp(); CleanUp();
} }
bool CDetectorAlgorithm::Initialize(IDetectorTask* pTask, IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr) bool CDetectorAlgorithm::Initialize(IDetectorTask* pTask, IAlgorithmLibMgr* pAlgoLibMgr)
{ {
if (!pTask) if (!pTask)
return false; return false;
m_pTask = pTask; m_pTask = pTask;
m_pAlgoShare = pAlgoShare;
m_pAlgoLibMgr = pAlgoLibMgr; m_pAlgoLibMgr = pAlgoLibMgr;
return true; return true;
@ -112,9 +110,6 @@ bool CDetectorAlgorithm::SetAlgorithmInfo(const PLP_DETECTOR_ALGORITHM pAlgorith
m_tAlgorithmInfo.strLibName = pAlgorithmInfo->strLibName; m_tAlgorithmInfo.strLibName = pAlgorithmInfo->strLibName;
m_tAlgorithmInfo.strFuncName = pAlgorithmInfo->strFuncName; m_tAlgorithmInfo.strFuncName = pAlgorithmInfo->strFuncName;
//if (!Load(m_tAlgorithmInfo.strName))
// return false;
return true; return true;
} }
@ -162,28 +157,6 @@ PLP_ALGORITHM_PARAM CDetectorAlgorithm::AddParam(const PLP_ALGORITHM_PARAM pPara
m_mapParams[pParam->strName] = (*its); m_mapParams[pParam->strName] = (*its);
return (*its); return (*its);
} }
//else
{
// LP_ALGORITHM_PARAM* p = new LP_ALGORITHM_PARAM;
//
// p->nID = ++m_nParamBaseID;
// p->nTaskID = pParam->nTaskID;
// p->nSrcAlgoID = pParam->nSrcAlgoID;
// p->nSrcParamID = pParam->nSrcParamID;
// p->strName = pParam->strName;
// p->type = pParam->type;
// p->value = pParam->value;
// p->strDescription = pParam->strDescription;
// p->bIsSave = pParam->bIsSave;
// p->bIsLock = pParam->bIsLock;
//
// //m_vecParams.push_back(p);
// m_mapParams.insert(p->strName, p);
// m_vecParams[p->strName] = p;
// return p;
}
} }
return NULL; return NULL;
} }
@ -204,7 +177,6 @@ bool CDetectorAlgorithm::DeleteParam(int nParamID)
delete *iter; delete *iter;
return true; return true;
} }
} }
} }
@ -222,9 +194,7 @@ PLP_ALGORITHM_PARAM CDetectorAlgorithm::GetParam(int nParamID)
if (p->nID == nParamID) if (p->nID == nParamID)
return p; return p;
} }
} }
return NULL; return NULL;
} }
@ -284,23 +254,6 @@ PLP_ALGORITHM_PARAM CDetectorAlgorithm::AddOutParam(const PLP_ALGORITHM_PARAM pP
m_mapOutParams[pParam->strName] = (*its); m_mapOutParams[pParam->strName] = (*its);
return (*its); return (*its);
} }
// else
// {
// PLP_ALGORITHM_PARAM p = new LP_ALGORITHM_PARAM;
//
// p->nID = ++m_nOutParamBaseID;
// p->nTaskID = pParam->nTaskID;
// p->nSrcAlgoID = pParam->nSrcAlgoID;
// p->nSrcParamID = pParam->nSrcParamID;
// p->strName = pParam->strName;
// p->type = pParam->type;
// p->value = pParam->value;
// p->strDescription = pParam->strDescription;
// p->bIsSave = pParam->bIsSave;
//
// m_vecOutParams[p->strName] = p;
// m_mapOutParams.insert(p->strName, p);
// }
} }
return NULL; return NULL;
} }
@ -409,7 +362,6 @@ bool CDetectorAlgorithm::SerializeParamPropertyToJson(QJsonObject* pJsonObject,
PropertyArray.push_back(propertys); PropertyArray.push_back(propertys);
} }
} }
pJsonObject->insert("property", PropertyArray); pJsonObject->insert("property", PropertyArray);
@ -1111,7 +1063,6 @@ bool CDetectorAlgorithm::SerializeFromJson(QJsonObject* pJsonObject)
{ {
LP_DETECTOR_ROI_DATA roiData; LP_DETECTOR_ROI_DATA roiData;
//roiData.img = m_pTask->GetTaskInfo()->templateImg;
QJsonArray recordArray = jsonObject.value("out_param_value").toArray(); QJsonArray recordArray = jsonObject.value("out_param_value").toArray();
int nRecordCount = recordArray.size(); int nRecordCount = recordArray.size();
@ -1633,16 +1584,6 @@ bool CDetectorAlgorithm::InitRoiInfo()
QVariant CDetectorAlgorithm::GetParamValue(QString strKey, AlgoParamType type) QVariant CDetectorAlgorithm::GetParamValue(QString strKey, AlgoParamType type)
{ {
//for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = m_vecParams.begin();
// iter != m_vecParams.end(); ++iter)
//{
// PLP_ALGORITHM_PARAM param = *iter;
// if (param && param->type ==type && param->strName == strKey)
// {
// return param->value;
// }
//}
if (m_mapParams.value(strKey)) if (m_mapParams.value(strKey))
{ {
return m_mapParams.value(strKey)->value; return m_mapParams.value(strKey)->value;
@ -1653,16 +1594,6 @@ QVariant CDetectorAlgorithm::GetParamValue(QString strKey, AlgoParamType type)
QVariant CDetectorAlgorithm::GetOutParamValue(QString strKey, AlgoParamType type) QVariant CDetectorAlgorithm::GetOutParamValue(QString strKey, AlgoParamType type)
{ {
//for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = m_vecOutParams.begin();
// iter != m_vecOutParams.end(); ++iter)
//{
// PLP_ALGORITHM_PARAM param = *iter;
// if (param && param->type == type && param->strName == strKey)
// {
// return param->value;
// }
//}
if (m_mapOutParams.value(strKey)) if (m_mapOutParams.value(strKey))
{ {
return m_mapOutParams.value(strKey)->value; return m_mapOutParams.value(strKey)->value;
@ -1673,26 +1604,6 @@ QVariant CDetectorAlgorithm::GetOutParamValue(QString strKey, AlgoParamType type
bool CDetectorAlgorithm::SetOutParamValue(QString strKey, QVariant value) bool CDetectorAlgorithm::SetOutParamValue(QString strKey, QVariant value)
{ {
//for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = m_vecOutParams.begin();
// iter != m_vecOutParams.end(); ++iter)
//{
// PLP_ALGORITHM_PARAM param = *iter;
// if (param && param->strName == strKey)
// {
// if (param->type == LP_IMAGE)
// {
// QImage img = value.value<QImage>();
// param->value = img;
// }
// else
// {
// param->value = value;
// }
// return true;
// }
//}
PLP_ALGORITHM_PARAM pParam = m_mapOutParams.value(strKey); PLP_ALGORITHM_PARAM pParam = m_mapOutParams.value(strKey);
if (pParam) if (pParam)
{ {
@ -1927,7 +1838,7 @@ bool CDetectorAlgorithm::ImportParam(QJsonArray paramArray)//导入参数
{ {
QString strFileName = jsonObject.value("param_value").toString(); QString strFileName = jsonObject.value("param_value").toString();
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
cv::Mat resultFile = cv::imread(strpath/*strFileName.toLatin1().data()*/, CV_LOAD_IMAGE_UNCHANGED); cv::Mat resultFile = cv::imread(strpath, CV_LOAD_IMAGE_UNCHANGED);
param.value.setValue(resultFile); param.value.setValue(resultFile);
if (m_pTask) if (m_pTask)
m_pTask->AppendOtherFile(QString(strpath.c_str())); m_pTask->AppendOtherFile(QString(strpath.c_str()));
@ -1942,7 +1853,7 @@ bool CDetectorAlgorithm::ImportParam(QJsonArray paramArray)//导入参数
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR; QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR;
QString strFileName = strFilePath + QString::number(param.nID) + ".bmp"; QString strFileName = strFilePath + QString::number(param.nID) + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
roiData.img = cv::imread(strpath/*strFileName.toLatin1().data()*/, CV_LOAD_IMAGE_UNCHANGED); roiData.img = cv::imread(strpath, CV_LOAD_IMAGE_UNCHANGED);
QJsonArray recordArray = jsonObject.value("param_value").toArray(); QJsonArray recordArray = jsonObject.value("param_value").toArray();
@ -2002,8 +1913,6 @@ bool CDetectorAlgorithm::ImportParam(QJsonArray paramArray)//导入参数
} }
param.value.setValue(roiData); param.value.setValue(roiData);
break; break;
} }
@ -2013,10 +1922,7 @@ bool CDetectorAlgorithm::ImportParam(QJsonArray paramArray)//导入参数
param.strDescription = jsonObject.value("param_description").toString(); param.strDescription = jsonObject.value("param_description").toString();
PLP_ALGORITHM_PARAM pParam = (PLP_ALGORITHM_PARAM)AddParam(&param,false); PLP_ALGORITHM_PARAM pParam = (PLP_ALGORITHM_PARAM)AddParam(&param,false);
} }
return true; return true;
} }
@ -2071,7 +1977,7 @@ QByteArray CDetectorAlgorithm::ExportParam()
QString strFilePath = strExePath + "/" + "paramfiles/"; QString strFilePath = strExePath + "/" + "paramfiles/";
QString strFileName = strFilePath + QString::number(p->nID) + ".bmp"; QString strFileName = strFilePath + QString::number(p->nID) + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
if (!matResult.empty() && !cv::imwrite(strpath/*strFileName.toLatin1().data()*/, matResult)) if (!matResult.empty() && !cv::imwrite(strpath, matResult))
return false; return false;
jsonParam.insert("param_value", strFileName); jsonParam.insert("param_value", strFileName);
@ -2086,7 +1992,7 @@ QByteArray CDetectorAlgorithm::ExportParam()
QString strFilePath = strExePath + "/" + "images/"; QString strFilePath = strExePath + "/" + "images/";
QString strFileName = strFilePath + QString::number(p->nID) + ".bmp"; QString strFileName = strFilePath + QString::number(p->nID) + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
if (!roiData.img.empty() && !cv::imwrite(strpath/*strFileName.toLatin1().data()*/, roiData.img)) if (!roiData.img.empty() && !cv::imwrite(strpath, roiData.img))
return false; return false;
int nCount = roiData.records.size(); int nCount = roiData.records.size();
@ -2219,7 +2125,7 @@ bool CDetectorAlgorithm::ImportOutParam(QJsonArray outParamArray)//导入参数
QString strFileName = jsonObject.value("param_value").toString(); QString strFileName = jsonObject.value("param_value").toString();
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
cv::Mat resultFile = cv::imread(strpath/*strFileName.toLatin1().data()*/); cv::Mat resultFile = cv::imread(strpath);
param.value.setValue(resultFile); param.value.setValue(resultFile);
if (m_pTask) if (m_pTask)
m_pTask->AppendOtherFile(QString(strpath.c_str())); m_pTask->AppendOtherFile(QString(strpath.c_str()));
@ -2234,7 +2140,7 @@ bool CDetectorAlgorithm::ImportOutParam(QJsonArray outParamArray)//导入参数
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR; QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR;
QString strFileName = strFilePath + QString::number(param.nID) + ".bmp"; QString strFileName = strFilePath + QString::number(param.nID) + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
roiData.img = cv::imread(strpath/*strFileName.toLatin1().data()*/, CV_LOAD_IMAGE_UNCHANGED); roiData.img = cv::imread(strpath, CV_LOAD_IMAGE_UNCHANGED);
QJsonArray recordArray = jsonObject.value("param_value").toArray(); QJsonArray recordArray = jsonObject.value("param_value").toArray();
@ -2361,7 +2267,7 @@ QByteArray CDetectorAlgorithm::ExportOutParam()//导出参数
QString strFilePath = strExePath + "/" + "paramfiles/"; QString strFilePath = strExePath + "/" + "paramfiles/";
QString strFileName = strFilePath + QString::number(p->nID) + ".bmp"; QString strFileName = strFilePath + QString::number(p->nID) + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
if (!matResult.empty() && !cv::imwrite(strpath/*strFileName.toLatin1().data()*/, matResult)) if (!matResult.empty() && !cv::imwrite(strpath, matResult))
return false; return false;
jsonParam.insert("param_value", strFileName); jsonParam.insert("param_value", strFileName);
@ -2376,7 +2282,7 @@ QByteArray CDetectorAlgorithm::ExportOutParam()//导出参数
QString strFilePath = strExePath + "/" + "images/"; QString strFilePath = strExePath + "/" + "images/";
QString strFileName = strFilePath + QString::number(p->nID) + ".bmp"; QString strFileName = strFilePath + QString::number(p->nID) + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString(); std::string strpath = strFileName.toLocal8Bit().toStdString();
if (!roiData.img.empty() && !cv::imwrite(strpath/*strFileName.toLatin1().data()*/, roiData.img)) if (!roiData.img.empty() && !cv::imwrite(strpath, roiData.img))
return false; return false;
int nCount = roiData.records.size(); int nCount = roiData.records.size();
@ -2546,14 +2452,6 @@ bool CDetectorAlgorithm::UpdateParamValueByName(QString strName, QVariant& value
return bRet; return bRet;
} }
PLP_ALGORITHM_PARAM CDetectorAlgorithm::GetShareParam(QString strName, int idx /* = -1 */)
{
if (!m_pAlgoShare || !m_pTask)
return NULL;
return m_pAlgoShare->GetParam(strName, m_pTask->GetTaskInfo()->nGroupParamID);
}
void CDetectorAlgorithm::LoadUserParamValue(int nParamID /*= LP_DETECTOR_INVALID_ID*/) void CDetectorAlgorithm::LoadUserParamValue(int nParamID /*= LP_DETECTOR_INVALID_ID*/)
{ {
if (!m_pAlgo) if (!m_pAlgo)
@ -2570,7 +2468,6 @@ void CDetectorAlgorithm::LoadUserParamValue(int nParamID /*= LP_DETECTOR_INVALID
if (p->type == LP_USER) if (p->type == LP_USER)
m_pAlgo->LoadUserParamValue(m_pTask, this, p->strName, p->value); m_pAlgo->LoadUserParamValue(m_pTask, this, p->strName, p->value);
} }
} }
} }
else else
@ -2631,7 +2528,6 @@ void CDetectorAlgorithm::ClearUserParamValue(int nParamID /*= LP_DETECTOR_INVALI
if (p->type == LP_USER) if (p->type == LP_USER)
p->value.clear(); p->value.clear();
} }
} }
} }
else else
@ -2655,3 +2551,4 @@ bool CDetectorAlgorithm::HandleEvent(QString strParamName /*= ""*/, int event/*
return false; return false;
} }

BIN
src/lpbengine/Algorithm.h
View File

Binary file not shown.

34
src/lpbengine/AlgorithmLib.cpp
Unescape Escape View File

@ -64,43 +64,9 @@ bool CAlgorithmLib::InitAlgo(IDetectorTask *lpTask, IDetectorAlgorithm* lpAlgori
{ {
lpAlgorithm->AddOutParam(&param); lpAlgorithm->AddOutParam(&param);
} }
//switch (descParam.type)
//{
//case LP_INT:
//case LP_BOOLEAN:
//case LP_STRING:
//case LP_DOUBLE:
//case LP_IMAGE:
//case LP_POINT:
//case LP_POINTF:
//case LP_RECT:
//case LP_RECTF:
//case LP_ROI:
//case LP_MAT:
//case LP_LIST_INT:
//case LP_LIST_BOOLEAN:
//case LP_LIST_STRING:
//case LP_LIST_DOUBLE:
//case LP_USER:
//case LP_LINE:
//case LP_LINEF:
//case LP_CIRCLE:
//case LP_CIRCLEF:
//case LP_POLYGON:
//case LP_POLYGONF:
//case LP_TRANSFORM:
//{
// break;
//}
//default:
// break;
//}
} }
return m_pAlgo->Init(lpTask, lpAlgorithm);; return m_pAlgo->Init(lpTask, lpAlgorithm);;
// return m_pAlgo->Init(lpTask, lpAlgorithm);
} }
bool CAlgorithmLib::Load(const QString& strPath) bool CAlgorithmLib::Load(const QString& strPath)

32
src/lpbengine/AlgorithmLibMgr.cpp
Unescape Escape View File

@ -5,7 +5,6 @@
CAlgorithmLibMgr::CAlgorithmLibMgr() CAlgorithmLibMgr::CAlgorithmLibMgr()
{ {
m_mapAlgoLib.clear(); m_mapAlgoLib.clear();
m_pSysInfo = NULL;
} }
CAlgorithmLibMgr::~CAlgorithmLibMgr() CAlgorithmLibMgr::~CAlgorithmLibMgr()
@ -13,20 +12,12 @@ CAlgorithmLibMgr::~CAlgorithmLibMgr()
CleanUp(); CleanUp();
} }
bool CAlgorithmLibMgr::Initialize(IDetectorSystemInfo* pSysInfo)
{
m_pSysInfo = pSysInfo;
return true;
}
void CAlgorithmLibMgr::CleanUp() void CAlgorithmLibMgr::CleanUp()
{ {
QMap<QString, IAlgorithmLib*>::Iterator it; QMap<QString, IAlgorithmLib*>::Iterator it;
for (it = m_mapAlgoLib.begin(); it != m_mapAlgoLib.end(); ++it) for (it = m_mapAlgoLib.begin(); it != m_mapAlgoLib.end(); ++it) {
{
IAlgorithmLib* p = it.value(); IAlgorithmLib* p = it.value();
if (p) if (p) {
{
delete p; delete p;
} }
} }
@ -40,8 +31,7 @@ bool CAlgorithmLibMgr::AddAlgorithmLib(const QString& strName, const QString& st
return false; return false;
CAlgorithmLib* pLib = new CAlgorithmLib(strName); CAlgorithmLib* pLib = new CAlgorithmLib(strName);
if (!pLib->Load(strPath)) if (!pLib->Load(strPath)) {
{
delete pLib; delete pLib;
return false; return false;
} }
@ -85,21 +75,5 @@ bool CAlgorithmLibMgr::Save()
bool CAlgorithmLibMgr::Load() bool CAlgorithmLibMgr::Load()
{ {
m_pSysInfo->BeginGroup("AlgoLibInfo");
QStringList libList = m_pSysInfo->allKeys();
for (int i = 0; i < libList.size(); i++)
{
QString strKey = libList.at(i);
if (!AddAlgorithmLib(strKey, m_pSysInfo->GetValue(strKey).toString()))
{
m_pSysInfo->EndGroup();
qErrnoWarning("load algorithmlib: %s fail", strKey.toLocal8Bit().data());
return false;
}
}
m_pSysInfo->EndGroup();
return true; return true;
} }

4
src/lpbengine/AlgorithmLibMgr.h
Unescape Escape View File

@ -9,8 +9,6 @@ public:
CAlgorithmLibMgr(); CAlgorithmLibMgr();
virtual ~CAlgorithmLibMgr(); virtual ~CAlgorithmLibMgr();
bool Initialize(IDetectorSystemInfo* pSysInfo);
virtual bool Save(); virtual bool Save();
virtual bool Load(); virtual bool Load();
@ -21,8 +19,6 @@ public:
virtual void CleanUp(); virtual void CleanUp();
private: private:
QMap<QString, IAlgorithmLib*> m_mapAlgoLib; QMap<QString, IAlgorithmLib*> m_mapAlgoLib;
IDetectorSystemInfo* m_pSysInfo;
}; };
#endif // ALGORITHMLIBMGR_H #endif // ALGORITHMLIBMGR_H

608
src/lpbengine/AlgorithmShare.cpp
Unescape Escape View File

@ -1,608 +0,0 @@
#include "AlgorithmShare.h"
CAlgorithmShare::CAlgorithmShare() : m_mutex(QMutex::Recursive)
{
m_mapParamGroup.clear();
}
CAlgorithmShare::~CAlgorithmShare()
{
// CleanUp();
}
bool CAlgorithmShare::Initialize()
{
return true;
}
PLP_ALGORITHM_PARAM CAlgorithmShare::AddParam(const PLP_ALGORITHM_PARAM pParam, int idx /* = -1 */)
{
if (NULL == pParam)
return NULL;
LP_ALGORITHM_PARAM* p = new LP_ALGORITHM_PARAM;
p->nID = LP_DETECTOR_INVALID_ID;
p->nSrcAlgoID = LP_DETECTOR_INVALID_ID;
p->nSrcParamID = LP_DETECTOR_INVALID_ID;
p->strName = pParam->strName;
p->type = pParam->type;
p->value = pParam->value;
p->strDescription = "";
p->bIsSave = false;
QVector<PLP_ALGORITHM_PARAM>* pGroup = m_mapParamGroup[idx];
if (!pGroup)
{
m_mapParamGroup.remove(idx);
pGroup = new QVector < PLP_ALGORITHM_PARAM >;
m_mapParamGroup.insert(idx, pGroup);
}
pGroup->push_back(p);
return p;
}
bool CAlgorithmShare::DeleteParam(QString strName, int idx /* = -1 */)
{
QVector<PLP_ALGORITHM_PARAM>* pGroup = m_mapParamGroup.value(idx);
if (!pGroup)
return false;
for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = pGroup->begin();
iter != pGroup->end(); ++iter)
{
PLP_ALGORITHM_PARAM p = *iter;
if (NULL != p)
{
if (p->strName == strName)
{
delete *iter;
iter = pGroup->erase(iter);
if (pGroup->empty())
{
delete pGroup;
m_mapParamGroup.remove(idx);
}
return true;
}
}
}
return false;
}
PLP_ALGORITHM_PARAM CAlgorithmShare::GetParam(QString strName, int idx /* = -1 */)
{
QVector<PLP_ALGORITHM_PARAM>* pGroup = m_mapParamGroup.value(idx);
if (!pGroup)
return NULL;
for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = pGroup->begin();
iter != pGroup->end(); ++iter)
{
if (NULL != *iter)
{
PLP_ALGORITHM_PARAM p = *iter;
if (p->strName == strName)
return p;
}
}
return NULL;
}
QStringList CAlgorithmShare::GroupList()
{
QStringList groupList;
groupList.clear();
QMap<int, QVector<PLP_ALGORITHM_PARAM>*>::Iterator it;
for (it = m_mapParamGroup.begin(); it != m_mapParamGroup.end(); ++it)
{
groupList.append(QString::number(it.key()));
}
return groupList;
}
QStringList CAlgorithmShare::ParamList(int idx /* = -1 */)
{
QStringList paramList;
paramList.clear();
QVector<PLP_ALGORITHM_PARAM>* pGroup = m_mapParamGroup.value(idx);
if (!pGroup)
return paramList;
for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = pGroup->begin();
iter != pGroup->end(); ++iter)
{
if (NULL != *iter)
{
PLP_ALGORITHM_PARAM p = *iter;
paramList.append(p->strName);
}
}
return paramList;
}
bool CAlgorithmShare::Save()
{
QJsonDocument document;
QJsonArray groupArray;
QMap<int, QVector<PLP_ALGORITHM_PARAM>*>::Iterator it;
for (it = m_mapParamGroup.begin(); it != m_mapParamGroup.end(); ++it)
{
int groupID = it.key();
QVector<PLP_ALGORITHM_PARAM>* pGroup = it.value();
if (!SerializeToJson(&groupArray, groupID, pGroup))
return false;
}
document.setArray(groupArray);
QByteArray byteArray = document.toJson();
if (byteArray.isNull())
return false;
QString strExePath = QCoreApplication::applicationDirPath();
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_PARAMSHARE_FILE;
QFile file(strFilePath);
if (file.open(QFile::WriteOnly | QFile::Text))
{
file.write(byteArray);
file.flush();
file.close();
return true;
}
return false;
}
bool CAlgorithmShare::Load()
{
QByteArray byteArray;
QString strExePath = QCoreApplication::applicationDirPath();
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_PARAMSHARE_FILE;
QFile file(strFilePath);
if (!file.exists())
{
file.open(QIODevice::ReadWrite);
file.close();
return true;
}
if (!file.open(QIODevice::ReadOnly))
{
qErrnoWarning("load algorithmshare: %s fail", strFilePath.toLocal8Bit().data());
return false;
}
byteArray = file.readAll();
if (byteArray.size() == 0)
return true;
QJsonParseError parse_error;
QJsonDocument document = QJsonDocument::fromJson(byteArray, &parse_error);
if (parse_error.error == QJsonParseError::NoError)
{
if (!document.isEmpty() && !document.isNull())
{
if (document.isArray())
{
QJsonArray groupArray = document.array();
for (int i = 0; i < groupArray.size(); i++)
{
QJsonObject jsonObject = groupArray[i].toObject();
if (!SerializeFromJson(&jsonObject))
{
qErrnoWarning("load algorithmshare: %s fail", strFilePath.toLocal8Bit().data());
return false;
}
}
return true;
}
}
}
return false;
}
bool CAlgorithmShare::SerializeToJson(QJsonArray* pGroupArray, int nGroupID, QVector<PLP_ALGORITHM_PARAM>* pGroup)
{
if (!pGroupArray || !pGroup)
return false;
QJsonObject jsonObject;
jsonObject.insert("group_id", nGroupID);
QJsonArray paramArray;
for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = pGroup->begin();
iter != pGroup->end(); ++iter)
{
if (*iter)
{
PLP_ALGORITHM_PARAM p = (PLP_ALGORITHM_PARAM)*iter;
QJsonObject jsonParam;
jsonParam.insert("param_id", p->nID);
jsonParam.insert("param_src_task_id", p->nTaskID);
jsonParam.insert("param_src_algo_id", p->nSrcAlgoID);
jsonParam.insert("param_src_param_id", p->nSrcParamID);
jsonParam.insert("param_name", p->strName);
jsonParam.insert("param_type", p->type);
switch (p->type)
{
case LP_INT:
{
jsonParam.insert("param_value", p->value.toInt());
break;
}
case LP_BOOLEAN:
{
jsonParam.insert("param_value", p->value.toBool());
break;
}
case LP_STRING:
{
jsonParam.insert("param_value", p->value.toString());
break;
}
case LP_DOUBLE:
{
jsonParam.insert("param_value", p->value.toDouble());
break;
}
case LP_IMAGE:
{
break;
}
case LP_MAT:
{
break;
}
case LP_ROI:
{
LP_DETECTOR_ROI_DATA roiData = p->value.value<LP_DETECTOR_ROI_DATA>();
QString strExePath = QCoreApplication::applicationDirPath();
QString strFilePath = strExePath + "/" + "images/";
QDir dir;
if (!dir.exists(strFilePath))
{
if (!dir.mkdir(strFilePath))
return false;
}
QString strName = QString("%1_%2").arg(QString::number(nGroupID)).arg(p->strName);
QString strFileName = strFilePath + strName + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString();
if (!roiData.img.empty() && !cv::imwrite(strpath/*strFileName.toLatin1().data()*/, roiData.img))
return false;
int nCount = roiData.records.size();
if (nCount > 0)
{
QJsonArray recordArray;
for (int i = 0; i < nCount; i++)
{
QJsonArray itemArray;
Item_List record = roiData.records.at(i);
int nItemCount = record.size();
for (int j = 0; j < nItemCount; j++)
{
QJsonObject itemJson;
Feature_List item = record.at(j);
itemJson.insert("roi_item_type", item.first);
switch (item.first)
{
case RECTANGLE:
case ELLIPSE:
{
itemJson.insert("roi_item_value1", item.second.at(0));
itemJson.insert("roi_item_value2", item.second.at(1));
itemJson.insert("roi_item_value3", item.second.at(2));
itemJson.insert("roi_item_value4", item.second.at(3));
break;
}
case CIRCLE:
{
itemJson.insert("roi_item_value1", item.second.at(0));
itemJson.insert("roi_item_value2", item.second.at(1));
itemJson.insert("roi_item_value3", item.second.at(2));
break;
}
case POLY:
{
break;
}
default:
break;
}
itemArray.push_back(itemJson);
}
recordArray.push_back(itemArray);
}
jsonParam.insert("param_value", recordArray);
}
break;
}
default:
break;
}
jsonParam.insert("param_description", p->strDescription);
paramArray.push_back(jsonParam);
}
}
if (paramArray.size() > 0)
jsonObject.insert("paramArray", paramArray);
pGroupArray->push_back(jsonObject);
return true;
}
bool CAlgorithmShare::SerializeFromJson(QJsonObject* pJsonObject)
{
int nGroupID = pJsonObject->value("group_id").toInt();
QJsonArray paramArray = pJsonObject->value("paramArray").toArray();
for (int i = 0; i < paramArray.size(); i++)
{
LP_ALGORITHM_PARAM param;
QJsonObject jsonObject = paramArray[i].toObject();
param.nTaskID = jsonObject.value("param_src_task_id").toInt(LP_DETECTOR_INVALID_ID);
param.nSrcAlgoID = jsonObject.value("param_src_algo_id").toInt();
param.nSrcParamID = jsonObject.value("param_src_param_id").toInt();
param.strName = jsonObject.value("param_name").toString();
param.type = (AlgoParamType)jsonObject.value("param_type").toInt();
switch (param.type)
{
case LP_INT:
{
param.value = jsonObject.value("param_value").toInt();
break;
}
case LP_BOOLEAN:
{
param.value = jsonObject.value("param_value").toBool();
break;
}
case LP_STRING:
{
param.value = jsonObject.value("param_value").toString();
break;
}
case LP_DOUBLE:
{
param.value = jsonObject.value("param_value").toDouble();
break;
}
case LP_IMAGE:
{
break;
}
case LP_MAT:
{
break;
}
case LP_ROI:
{
LP_DETECTOR_ROI_DATA roiData;
QString strExePath = QCoreApplication::applicationDirPath();
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR;
QString strName = QString("%1_%2").arg(QString::number(nGroupID)).arg(param.strName);
QString strFileName = strFilePath + strName + ".bmp";
std::string strpath = strFileName.toLocal8Bit().toStdString();
roiData.img = cv::imread(strpath/*strFileName.toLatin1().data()*/);
QJsonArray recordArray = jsonObject.value("param_value").toArray();
int nRecordCount = recordArray.size();
if (nRecordCount > 0)
{
Record_List recordList;
for (int i = 0; i < nRecordCount; i++)
{
QJsonArray itemArray = recordArray.at(i).toArray();
int nItemCount = itemArray.size();
if (nItemCount > 0)
{
Item_List itemList;
for (int j = 0; j < nItemCount; j++)
{
QJsonObject itemJson = itemArray.at(j).toObject();
Feature_List item;
item.first = itemJson.value("roi_item_type").toInt();
switch (item.first)
{
case RECTANGLE:
case ELLIPSE:
{
item.second.push_back(itemJson.value("roi_item_value1").toDouble());
item.second.push_back(itemJson.value("roi_item_value2").toDouble());
item.second.push_back(itemJson.value("roi_item_value3").toDouble());
item.second.push_back(itemJson.value("roi_item_value4").toDouble());
break;
}
case CIRCLE:
{
item.second.push_back(itemJson.value("roi_item_value1").toDouble());
item.second.push_back(itemJson.value("roi_item_value2").toDouble());
item.second.push_back(itemJson.value("roi_item_value3").toDouble());
break;
}
case POLY:
{
break;
}
default:
break;
}
itemList.push_back(item);
}
recordList.push_back(itemList);
}
roiData.records = recordList;
}
}
param.value.setValue(roiData);
break;
}
default:
break;
}
param.strDescription = jsonObject.value("param_description").toString();
PLP_ALGORITHM_PARAM pParam = (PLP_ALGORITHM_PARAM)AddParam(&param, nGroupID);
pParam->nID = jsonObject.value("param_id").toInt();
}
return true;
}
void CAlgorithmShare::CleanUp()
{
QMap<int, QVector<PLP_ALGORITHM_PARAM>*>::Iterator it;
for (it = m_mapParamGroup.begin(); it != m_mapParamGroup.end(); ++it)
{
QVector<PLP_ALGORITHM_PARAM>* pGroup = it.value();
for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = pGroup->begin();
iter != pGroup->end(); ++iter)
{
PLP_ALGORITHM_PARAM p = *iter;
if (p)
{
delete p;
}
}
pGroup->clear();
delete pGroup;
}
m_mapParamGroup.clear();
}
bool CAlgorithmShare::RegisterCoreCtrl(class ICoreCtrl* pCoreCtrl /* = NULL */)
{
if (!pCoreCtrl)
return false;
m_pCoreCtrl = pCoreCtrl;
return true;
}
bool CAlgorithmShare::GetIntValue(int nAlgorithm, const QString& skey, QString& value, int nDefault)
{
// IAlgorithmOption* p = m_pCoreCtrl->IGetAlgorithmOption(nAlgorithm);
// if (!p)
// return false;
//
// value = p->GetIntValue(skey, nDefault);
return true;
}
bool CAlgorithmShare::GetStringValue(int nAlgorithm, const QString& skey, QString& value, const QString& default)
{
// IAlgorithmOption* p = m_pCoreCtrl->IGetAlgorithmOption(nAlgorithm);
// if (!p)
// return false;
//
// value = p->GetStringValue(skey, default);
return true;
}
//void CAlgorithmShare::SetValue(const QString& key, const QVariant& value, AlgoParamType type, int idx /* = -1 */)
//{
// LP_ALGORITHM_PARAM* p = new LP_ALGORITHM_PARAM;
//
// p->nID = LP_DETECTOR_INVALID_ID;
// p->nSrcAlgoID = LP_DETECTOR_INVALID_ID;
// p->nSrcParamID = LP_DETECTOR_INVALID_ID;
// p->strName = key;
// p->type = type;
// p->value = value;
// p->strDescription = "";
// p->bIsSave = false;
//
//
// QVector<PLP_ALGORITHM_PARAM>* pGroup = m_mapParamGroup[idx];
// if (!p)
// {
// m_mapParamGroup.remove(idx);
// pGroup = new QVector < PLP_ALGORITHM_PARAM > ;
// m_mapParamGroup.insert(idx, pGroup);
// }
//
// pGroup->push_back(p);
//}
//
//QVariant CAlgorithmShare::GetValue(const QString& key, AlgoParamType& type, int idx /* = -1 */)
//{
// QVector<PLP_ALGORITHM_PARAM>* pGroup = m_mapParamGroup[idx];
// if (!pGroup)
// return false;
//
// for (QVector<PLP_ALGORITHM_PARAM>::iterator iter = pGroup->begin();
// iter != pGroup->end(); ++iter)
// {
// if (NULL != *iter)
// {
// PLP_ALGORITHM_PARAM p = *iter;
// if (p->strName == key)
// {
// type = p->type;
// return p->value;
// }
//
// }
//
// }
//
// return NULL;
//}

42
src/lpbengine/AlgorithmShare.h
Unescape Escape View File

@ -1,42 +0,0 @@
#ifndef ALGORITHMSHARE_H
#define ALGORITHMSHARE_H
#include "lpbengine.h"
#include "iCoreCtrl.h"
class CAlgorithmShare : public IAlgorithmShare
{
public:
CAlgorithmShare();
virtual ~CAlgorithmShare();
virtual bool Initialize();
virtual PLP_ALGORITHM_PARAM AddParam(const PLP_ALGORITHM_PARAM pParam, int idx = -1 );
virtual bool DeleteParam(QString strName, int idx = -1);
virtual PLP_ALGORITHM_PARAM GetParam(QString strName, int idx = -1);
virtual QStringList GroupList();
virtual QStringList ParamList(int idx = -1);
virtual bool RegisterCoreCtrl(class ICoreCtrl* pCoreCtrl = NULL);
virtual bool GetIntValue(int nAlgorithm, const QString& skey, QString& value, int nDefault);
virtual bool GetStringValue(int nAlgorithm, const QString& skey, QString& value, const QString& default = "");
//virtual void SetValue(const QString& key, const QVariant& value, AlgoParamType type, int idx = -1);
//virtual QVariant GetValue(const QString& key, AlgoParamType& type, int idx = -1);
bool SerializeToJson(QJsonArray* pGroupArray, int nGroupID, QVector<PLP_ALGORITHM_PARAM>* pGroup);
bool SerializeFromJson(QJsonObject* pJsonObject);
virtual bool Save();
virtual bool Load();
void CleanUp();
private:
QMutex m_mutex;
QMap<int, QVector<PLP_ALGORITHM_PARAM>*> m_mapParamGroup;
class ICoreCtrl* m_pCoreCtrl;
};
#endif // ALGORITHMSHARE_H

53
src/lpbengine/BEApp.cpp
Unescape Escape View File

@ -1,53 +0,0 @@
#include "BEApp.h"
CBEApp::CBEApp() : m_mutex(QMutex::Recursive), m_pEngine(NULL), m_pSink(NULL)
{
}
CBEApp::~CBEApp()
{
}
bool CBEApp::Initialize(IDetectorEngine** lppBE, IDetectorEngineSink* lpSink)
{
QMutexLocker locker(&m_mutex);
if (!lppBE)
return false;
if (m_pEngine)
{
*lppBE = (IDetectorEngine*)m_pEngine;
return true;
}
m_pEngine = new CDetectorEngine();
if (!m_pEngine)
return false;
if (!m_pEngine->Initialize())
return false;
*lppBE = (IDetectorEngine*)m_pEngine;
if (!m_pSink)
m_pSink = lpSink;
qWarning("load engine success");
return true;
}
bool CBEApp::Quit()
{
QMutexLocker locker(&m_mutex);
if (m_pEngine)
{
delete m_pEngine;
m_pEngine = NULL;
}
return true;
}

25
src/lpbengine/BEApp.h
Unescape Escape View File

@ -1,25 +0,0 @@
#ifndef BEAPP_H
#define BEAPP_H
#include "lpbengine.h"
#include "BusinessEngine.h"
class CBEApp
{
public:
CBEApp();
virtual ~CBEApp();
bool Initialize(IDetectorEngine** lppBE, IDetectorEngineSink* lpSink);
bool Quit();
const CDetectorEngine *GetEngine() const { return m_pEngine; }
private:
CDetectorEngine* m_pEngine;
QMutex m_mutex;
IDetectorEngineSink* m_pSink;
};
#endif // BEAPP_H

102
src/lpbengine/BusinessEngine.cpp → src/lpbengine/CDetectorEngine.cpp
Unescape Escape View File

@ -1,45 +1,42 @@
#include "BusinessEngine.h" #include "CDetectorEngine.h"
LP_GLOBAL_DETECTOR_ENGINE gpEngine; LPBENGINE_EXPORT IDetectorEngine* Lib_Engine_Init(void)
CDetectorEngine::CDetectorEngine()
{ {
CDetectorEngine* gpDetectEngine = nullptr;
} if (nullptr == gpDetectEngine)
CDetectorEngine::~CDetectorEngine()
{ {
gpDetectEngine = new CDetectorEngine();
}
return gpDetectEngine;
} }
bool CDetectorEngine::GetDataInterface(InterfaceType type, void **lppInterface) LPBENGINE_EXPORT void Lib_Engine_Free(IDetectorEngine* ptr)
{ {
if (!lppInterface) if (ptr != nullptr)
return false;
if (type == SOLUTIONMGR)
{ {
*lppInterface = (void**)&m_SolutionMgr; delete ptr;
ptr = nullptr;
} }
else if (type == DEVICEMGR)
{
*lppInterface = (void**)&m_DeviceMgr;
} }
else if (type == SYSTEMINFO)
CDetectorEngine::CDetectorEngine()
{ {
*lppInterface = (void**)&m_SystemInfo;
} }
else if (type == SHAREAPARAM)
CDetectorEngine::~CDetectorEngine()
{ {
*lppInterface = (void **)&m_AlgoShare;
} }
else if (type == ALGORITHMLIBMGR)
IAlgorithmLibMgr* CDetectorEngine::getAlgorithmLibMgr() const
{ {
*lppInterface = (void**)&m_AlgoLibMgr; return (IAlgorithmLibMgr*)&m_AlgoLibMgr;
} }
IDetectorSolutionMgr* CDetectorEngine::getSolutionMgr() const
return true; {
return (IDetectorSolutionMgr*)&m_SolutionMgr;
} }
bool CDetectorEngine::CheckConfigFolder() bool CDetectorEngine::CheckConfigFolder()
@ -47,10 +44,8 @@ bool CDetectorEngine::CheckConfigFolder()
QString strExePath = QCoreApplication::applicationDirPath(); QString strExePath = QCoreApplication::applicationDirPath();
QString strDirPath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_SOLUTION_DIR; QString strDirPath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_SOLUTION_DIR;
QDir dir(strDirPath); QDir dir(strDirPath);
if (!dir.exists()) if (!dir.exists()) {
{ if (!dir.mkdir(strDirPath)) {
if (!dir.mkdir(strDirPath))
{
qErrnoWarning("create solution dir fail"); qErrnoWarning("create solution dir fail");
return false; return false;
} }
@ -58,10 +53,8 @@ bool CDetectorEngine::CheckConfigFolder()
strDirPath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR; strDirPath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR;
dir.setPath(strDirPath); dir.setPath(strDirPath);
if (!dir.exists()) if (!dir.exists()) {
{ if (!dir.mkdir(strDirPath)) {
if (!dir.mkdir(strDirPath))
{
qErrnoWarning("create images dir fail"); qErrnoWarning("create images dir fail");
return false; return false;
} }
@ -69,10 +62,8 @@ bool CDetectorEngine::CheckConfigFolder()
strDirPath = strExePath + LP_DETECTOR_BUSSINESS_IN_PARAM_FILE_DIR; strDirPath = strExePath + LP_DETECTOR_BUSSINESS_IN_PARAM_FILE_DIR;
dir.setPath(strDirPath); dir.setPath(strDirPath);
if (!dir.exists()) if (!dir.exists()) {
{ if (!dir.mkdir(strDirPath)) {
if (!dir.mkdir(strDirPath))
{
qErrnoWarning("create paramfiles dir fail"); qErrnoWarning("create paramfiles dir fail");
return false; return false;
} }
@ -80,42 +71,24 @@ bool CDetectorEngine::CheckConfigFolder()
strDirPath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_ALGO_DIR; strDirPath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_ALGO_DIR;
dir.setPath(strDirPath); dir.setPath(strDirPath);
if (!dir.exists()) if (!dir.exists()) {
{ if (!dir.mkdir(strDirPath)) {
if (!dir.mkdir(strDirPath))
{
qErrnoWarning("create algorithmLib dir fail"); qErrnoWarning("create algorithmLib dir fail");
return false; return false;
} }
} }
return true; return true;
} }
bool CDetectorEngine::Initialize() bool CDetectorEngine::Initialize()
{ {
if (!m_AlgoLibMgr.Initialize(&m_SystemInfo)) if (!m_SolutionMgr.Initialize(&m_AlgoLibMgr))
return false;
if (!m_AlgoShare.Initialize())
return false;
if (!m_SolutionMgr.Initialize(&m_SystemInfo,&m_AlgoShare, &m_AlgoLibMgr))
return false;
if (!m_DeviceMgr.Initialize())
return false; return false;
if (!Load()) { if (!Load()) {
qWarning() << "Initialize, m_AlgoLibMgr load failed"; qWarning() << "Initialize, m_AlgoLibMgr load failed";
return false; return false;
} }
gpEngine.pSolutionMgr = &m_SolutionMgr;
gpEngine.pAlgoLibMgr = &m_AlgoLibMgr;
gpEngine.pAlgoShare = &m_AlgoShare;
gpEngine.pDeviceMgr = &m_DeviceMgr;
gpEngine.pSystemInfo = &m_SystemInfo;
return true; return true;
} }
@ -129,10 +102,6 @@ bool CDetectorEngine::Save()
if (!m_SolutionMgr.Save()) if (!m_SolutionMgr.Save())
return false; return false;
if (!m_AlgoShare.Save())
return false;
return true; return true;
} }
@ -145,15 +114,10 @@ bool CDetectorEngine::SaveTasks(QStringList strTaskNames)
bool CDetectorEngine::Load() bool CDetectorEngine::Load()
{ {
//临时通过camera.json加载设备信息
if (!m_AlgoLibMgr.Load()) if (!m_AlgoLibMgr.Load())
return false; return false;
if (!m_SolutionMgr.Load()) if (!m_SolutionMgr.Load())
return false; return false;
if (!m_AlgoShare.Load())
return false;
return true; return true;
} }

14
src/lpbengine/BusinessEngine.h → src/lpbengine/CDetectorEngine.h
Unescape Escape View File

@ -3,17 +3,15 @@
#include "lpbengine.h" #include "lpbengine.h"
#include "SolutionMgr.h" #include "SolutionMgr.h"
#include "DeviceMgr.h"
#include "SystemInfo.h"
#include "AlgorithmShare.h"
#include "AlgorithmLibMgr.h" #include "AlgorithmLibMgr.h"
class CDetectorEngine : IDetectorEngine class CDetectorEngine:public IDetectorEngine
{ {
public: public:
CDetectorEngine(); CDetectorEngine();
~CDetectorEngine(); ~CDetectorEngine();
virtual bool GetDataInterface(InterfaceType type, void **lppInterface); IAlgorithmLibMgr* getAlgorithmLibMgr() const;
IDetectorSolutionMgr* getSolutionMgr() const;
bool Initialize(); bool Initialize();
virtual bool Save(); virtual bool Save();
virtual bool SaveTasks(QStringList strTaskNames); virtual bool SaveTasks(QStringList strTaskNames);
@ -22,13 +20,7 @@ public:
bool CheckConfigFolder(); bool CheckConfigFolder();
private: private:
CDetectorSolutionMgr m_SolutionMgr; CDetectorSolutionMgr m_SolutionMgr;
CDetectorDeviceMgr m_DeviceMgr;
CDetectorSystemInfo m_SystemInfo;
CAlgorithmShare m_AlgoShare;
CAlgorithmLibMgr m_AlgoLibMgr; CAlgorithmLibMgr m_AlgoLibMgr;
ICoreCtrl* m_pCoreCtrl;
}; };
#endif // BUSINESSENGINE_H #endif // BUSINESSENGINE_H

187
src/lpbengine/Camera.cpp
Unescape Escape View File

@ -1,187 +0,0 @@
#include "Camera.h"
CDetectorCameraDevice::CDetectorCameraDevice() : m_mutexLocker(QMutex::Recursive)
{
m_pCoreCtrl = NULL;
m_callBackOwner = NULL;
m_pFunc = NULL;
}
CDetectorCameraDevice::~CDetectorCameraDevice()
{
}
bool CDetectorCameraDevice::Initialize(IDetectorEngineSink* lpSink)
{
m_pSink = lpSink;
return true;
}
bool CDetectorCameraDevice::RegisterCoreCtrl(class ICoreCtrl* pCoreCtrl)
{
if (!pCoreCtrl)
return false;
m_pCoreCtrl = pCoreCtrl;
return true;
}
void CDetectorCameraDevice::AddParam(const QString &key, const QVariant &value)
{
m_mapParam.insert(key, value);
}
bool CDetectorCameraDevice::DeleteParam(const QString &key)
{
m_mapParam.remove(key);
return true;
}
QMap<QString, QVariant> CDetectorCameraDevice::GetParamMap()
{
return m_mapParam;
}
bool CDetectorCameraDevice::SetID(int nID)
{
m_nID = nID;
return true;
}
int CDetectorCameraDevice::GetID()
{
return m_nID;
}
bool CDetectorCameraDevice::SetType(DeviceType type)
{
m_type = type;
return true;
}
DeviceType CDetectorCameraDevice::GetType()
{
return m_type;
}
bool CDetectorCameraDevice::SetName(QString strName)
{
m_strName = strName;
return true;
}
QString CDetectorCameraDevice::GetName()
{
return m_strName;
}
bool CDetectorCameraDevice::SetDescription(QString strDescription)
{
m_strDescription = strDescription;
return true;
}
QString CDetectorCameraDevice::GetDescription()
{
return m_strDescription;
}
void CDetectorCameraDevice::SnapImage(void* callBackOwner, NewImageHandler pFunc)
{
RegisterImageHandler(callBackOwner, pFunc);
QStringList strKeys;
strKeys.append(m_strName);
return m_pCoreCtrl->ISnapImage(strKeys);
}
void CDetectorCameraDevice::RegisterImageHandler(void* callBackOwner, NewImageHandler pFunc)
{
QMutexLocker locker(&m_mutexLocker);
m_callBackOwner = callBackOwner;
m_pFunc = pFunc;
}
void CDetectorCameraDevice::UnRegisterImageHandler()
{
m_callBackOwner = NULL;
m_pFunc = NULL;
}
bool CDetectorCameraDevice::HandleNewImage(cv::Mat& img, int nDeviceID)
{
QMutexLocker locker(&m_mutexLocker);
if (!m_pFunc)
return false;
m_pFunc(m_callBackOwner, EngineBase::convMat2QImage(img), nDeviceID);
UnRegisterImageHandler();
return true;
}
bool CDetectorCameraDevice::OpenDevice()
{
if (!m_pCoreCtrl)
return false;
return m_pCoreCtrl->IOpenCamera(m_strName);
}
bool CDetectorCameraDevice::CloseDevice()
{
if (!m_pCoreCtrl)
return false;
return m_pCoreCtrl->ICloseCamera(m_strName);
}
bool CDetectorCameraDevice::StartDevice()
{
if (!m_pCoreCtrl)
return false;
return m_pCoreCtrl->IStartCamera(m_strName);
}
bool CDetectorCameraDevice::StopDevice()
{
if (!m_pCoreCtrl)
return false;
return m_pCoreCtrl->IStopCamera(m_strName);
}
void CDetectorCameraDevice::Release()
{
delete this;
}
bool CDetectorCameraDevice::SerializeToJson(QJsonDocument* pJsonDocument, QJsonArray* pDeviceArray)
{
if (!pDeviceArray)
return false;
QJsonObject jsonObject;
jsonObject.insert("device_id", m_nID);
jsonObject.insert("device_type", m_type);
jsonObject.insert("device_name", m_strName);
jsonObject.insert("device_description", m_strDescription);
pDeviceArray->push_back(jsonObject);
return true;
}
bool CDetectorCameraDevice::SerializeFromJson(QJsonObject* pJsonObject)
{
if (!pJsonObject)
return false;
m_nID = pJsonObject->value("device_id").toInt();
m_type = (DeviceType)pJsonObject->value("device_type").toInt();
m_strName = pJsonObject->value("device_name").toString();
m_strDescription = pJsonObject->value("device_description").toString();
return true;
}

58
src/lpbengine/Camera.h
Unescape Escape View File

@ -1,58 +0,0 @@
#ifndef CAMERA_H
#define CAMERA_H
#include "lpbengine.h"
#include "iCoreCtrl.h"
class CDetectorCameraDevice : public IDetectorCameraDevice
{
public:
CDetectorCameraDevice();
virtual ~CDetectorCameraDevice();
bool Initialize(IDetectorEngineSink* lpSink);
virtual bool SetID(int nID);
virtual int GetID();
virtual bool SetType(DeviceType type);
virtual DeviceType GetType();
virtual bool SetName(QString strName);
virtual QString GetName();
virtual bool SetDescription(QString strDescription);
virtual QString GetDescription();
virtual void Release();
bool SerializeToJson(QJsonDocument* pJsonDocument, QJsonArray* pDeviceArray);
bool SerializeFromJson(QJsonObject* pJsonObject);
virtual void AddParam(const QString &key, const QVariant &value);
virtual bool DeleteParam(const QString &key);
virtual QMap<QString, QVariant> GetParamMap();
bool RegisterCoreCtrl(class ICoreCtrl* pCoreCtrl);
virtual void SnapImage(void* callBackOwner, NewImageHandler pFunc);
virtual void RegisterImageHandler(void* callBackOwner, NewImageHandler pFunc);
virtual void UnRegisterImageHandler();
virtual bool HandleNewImage(cv::Mat& img, int nDeviceID);
virtual bool OpenDevice();
virtual bool CloseDevice();
virtual bool StartDevice();
virtual bool StopDevice();
private:
int m_nID;
QString m_strName;
QString m_strDescription;
DeviceType m_type;
IDetectorEngineSink* m_pSink;
QMap<QString, QVariant> m_mapParam;
ICoreCtrl* m_pCoreCtrl;
NewImageHandler m_pFunc;
void* m_callBackOwner;
QMutex m_mutexLocker;
};
#endif // CAMERA_H

274
src/lpbengine/DeviceMgr.cpp
Unescape Escape View File

@ -1,274 +0,0 @@
#include "DeviceMgr.h"
#include "Camera.h"
CDetectorDeviceMgr::CDetectorDeviceMgr()
{
m_nBaseID = 0;
m_vecDevice.clear();
m_pCoreCtrl = NULL;
}
CDetectorDeviceMgr::~CDetectorDeviceMgr()
{
while (m_vecDevice.size()>0)
{
IDetectorDevice *pItem = m_vecDevice.takeFirst();
delete pItem;
pItem = NULL;
}
}
bool CDetectorDeviceMgr::Initialize()
{
return true;
}
bool CDetectorDeviceMgr::RegisterCoreCtrl(class ICoreCtrl* pCoreCtrl /* = NULL */)
{
if (!pCoreCtrl)
return false;
m_pCoreCtrl = pCoreCtrl;
return true;
}
IDetectorDevice* CDetectorDeviceMgr::AddDevice(DeviceType type)
{
switch (type)
{
case CAMERA:
{
CDetectorCameraDevice* p = new CDetectorCameraDevice();
p->SetID(NewID());
p->SetType(type);
p->RegisterCoreCtrl(m_pCoreCtrl);
m_vecDevice.push_back(p);
return p;
}
default:
break;
}
return NULL;
}
bool CDetectorDeviceMgr::DeleteDevice(int nDeviceID)
{
for (QVector<IDetectorDevice*>::iterator iter = m_vecDevice.begin(); iter != m_vecDevice.end(); ++iter)
{
if (iter)
{
IDetectorDevice* p = *iter;
if (p->GetID() == nDeviceID)
{
p->Release();
iter = m_vecDevice.erase(iter);
return true;
}
}
}
return false;
}
IDetectorDevice* CDetectorDeviceMgr::GetDevice(int nDeviceID, DeviceType &type)
{
for (QVector<IDetectorDevice*>::iterator iter = m_vecDevice.begin();
iter != m_vecDevice.end(); ++iter)
{
if (*iter)
{
IDetectorDevice *p = *iter;
if (p->GetID() == nDeviceID)
{
type = p->GetType();
return *iter;
}
}
}
return NULL;
}
IDetectorDevice* CDetectorDeviceMgr::GetDeviceByName(QString strName, DeviceType &type)
{
for (QVector<IDetectorDevice*>::iterator iter = m_vecDevice.begin();
iter != m_vecDevice.end(); ++iter)
{
if (*iter)
{
IDetectorDevice *p = *iter;
if (p->GetName() == strName)
{
type = p->GetType();
return *iter;
}
}
}
return NULL;
}
int CDetectorDeviceMgr::EnumDevice(IDetectorDevice** lppDevice, int nCount)
{
if (!lppDevice || nCount < m_vecDevice.size())
return m_vecDevice.size();
int nIndex = 0;
for (QVector<IDetectorDevice*>::iterator iter = m_vecDevice.begin();
iter != m_vecDevice.end(); ++iter)
{
if (NULL != *iter)
{
lppDevice[nIndex] = *iter;
nIndex++;
}
}
return nIndex;
}
void CDetectorDeviceMgr::CleanUp()
{
for (QVector<IDetectorDevice*>::iterator iter = m_vecDevice.begin();
iter != m_vecDevice.end(); ++iter)
{
if (*iter)
{
(*iter)->Release();
}
}
m_vecDevice.clear();
}
QByteArray CDetectorDeviceMgr::SerializeToJson()
{
QJsonDocument document;
QJsonObject jsonObject;
jsonObject.insert("device_base_id", m_nBaseID);
QJsonArray deviceArray;
for (QVector<IDetectorDevice*>::iterator iter = m_vecDevice.begin();
iter != m_vecDevice.end(); ++iter)
{
if (*iter)
{
IDetectorDevice* p = (IDetectorDevice*)*iter;
switch (p->GetType())
{
case CAMERA:
{
CDetectorCameraDevice* pCamera = (CDetectorCameraDevice*)p;
if (!pCamera->SerializeToJson(&document, &deviceArray))
return NULL;
break;
}
default:
break;
}
}
}
if (deviceArray.size() > 0)
{
jsonObject.insert("deviceArray", deviceArray);
}
document.setObject(jsonObject);
return document.toJson();
}
bool CDetectorDeviceMgr::SerializeFromJson(QByteArray byteArray)
{
if (byteArray.size() == 0)
return true;
QJsonParseError parse_error;
QJsonDocument document = QJsonDocument::fromJson(byteArray, &parse_error);
if (parse_error.error == QJsonParseError::NoError)
{
if (!document.isEmpty() && !document.isNull())
{
if (document.isObject())
{
QJsonObject deviceMgr = document.object();
QJsonArray deviceArray = deviceMgr.value("deviceArray").toArray();
for (int i = 0; i < deviceArray.size(); i++)
{
QJsonObject jsonObject = deviceArray[i].toObject();
DeviceType type = (DeviceType)jsonObject.value("device_type").toInt();
switch (type)
{
case CAMERA:
{
CDetectorCameraDevice* pCamera = (CDetectorCameraDevice*)AddDevice(type);
if (!pCamera->SerializeFromJson(&jsonObject))
{
return false;
}
break;
}
default:
break;
}
}
m_nBaseID = deviceMgr.value("device_base_id").toInt();
return true;
}
}
}
return false;
}
bool CDetectorDeviceMgr::Save()
{
QByteArray byteArray = SerializeToJson();
if (byteArray.isNull())
return false;
QString strExePath = QCoreApplication::applicationDirPath();
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_DEVICEMGR_FILE;
QFile file(strFilePath);
if (file.open(QFile::WriteOnly))
{
file.write(byteArray);
return true;
}
return false;
}
bool CDetectorDeviceMgr::Load()
{
QByteArray byteArray;
QString strExePath = QCoreApplication::applicationDirPath();
QString strFilePath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_DEVICEMGR_FILE;
QFile file(strFilePath);
if (!file.exists())
{
file.open(QIODevice::ReadWrite);
file.close();
return true;
}
if (!file.open(QIODevice::ReadOnly))
{
return false;
}
byteArray = file.readAll();
if (!SerializeFromJson(byteArray))
return false;
return true;
}

35
src/lpbengine/DeviceMgr.h
Unescape Escape View File

@ -1,35 +0,0 @@
#ifndef DEVICEMGR_H
#define DEVICEMGR_H
#include "lpbengine.h"
class CDetectorDeviceMgr : public IDetectorDeviceMgr
{
public:
CDetectorDeviceMgr();
virtual ~CDetectorDeviceMgr();
virtual IDetectorDevice* AddDevice(DeviceType type);
virtual bool DeleteDevice(int nDeviceID);
virtual IDetectorDevice* GetDevice(int nDeviceID, DeviceType &type);
virtual IDetectorDevice* GetDeviceByName(QString strName, DeviceType &type);
virtual int EnumDevice(IDetectorDevice** lppDevice, int nCount);
virtual bool Initialize();
void CleanUp();
int NewID(){return ++m_nBaseID; }
QByteArray SerializeToJson();
bool SerializeFromJson(QByteArray byteArray);
virtual bool Save();
virtual bool Load();
virtual bool RegisterCoreCtrl(class ICoreCtrl* pCoreCtrl = NULL);
private:
int m_nBaseID;
QVector<IDetectorDevice*> m_vecDevice;
class ICoreCtrl* m_pCoreCtrl;
};
#endif // DEVICEMGR_H

24
src/lpbengine/Solution.cpp
Unescape Escape View File

@ -7,8 +7,7 @@ CDetectorSolution::CDetectorSolution() : m_mutex(QMutex::Recursive)
m_nBaseID = 0; m_nBaseID = 0;
m_bIsRun = false; m_bIsRun = false;
m_bIsModify = false; m_bIsModify = false;
m_pAlgoShare = NULL;
//m_vecTask.clear();
} }
CDetectorSolution::~CDetectorSolution() CDetectorSolution::~CDetectorSolution()
@ -16,13 +15,11 @@ CDetectorSolution::~CDetectorSolution()
CleanUp(); CleanUp();
} }
bool CDetectorSolution::Initialize(IDetectorSystemInfo* pSystemInfo, bool CDetectorSolution::Initialize(IAlgorithmLibMgr* pAlgoLibMgr)
IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr)
{ {
if ( !pAlgoShare || !pAlgoLibMgr) if (!pAlgoLibMgr)
return false; return false;
m_pSystemInfo = pSystemInfo;
m_pAlgoShare = pAlgoShare;
m_pAlgoLibMgr = pAlgoLibMgr; m_pAlgoLibMgr = pAlgoLibMgr;
return true; return true;
@ -51,17 +48,18 @@ IDetectorTask* CDetectorSolution::AddTask(const PLP_DETECTOR_TASK pTask, QString
CDetectorTask* p = new CDetectorTask(); CDetectorTask* p = new CDetectorTask();
if (p->Initialize(this, m_pSystemInfo, m_pAlgoShare, m_pAlgoLibMgr) && p->SetTaskInfo(pTask)) if (p->Initialize(this, m_pAlgoLibMgr) && p->SetTaskInfo(pTask))
{ {
p->SetID(++m_nBaseID); p->SetID(++m_nBaseID);
p->LoadFile(strPath); p->LoadFile(strPath);
//m_vecTask.push_back(p);
m_TaskMapByID.insert(p->GetID(), p); m_TaskMapByID.insert(p->GetID(), p);
m_TaskMapByName.insert(p->GetTaskInfo()->strName, p); m_TaskMapByName.insert(p->GetTaskInfo()->strName, p);
return p; return p;
} }
else {
delete p; delete p;
}
return NULL; return NULL;
} }
@ -71,7 +69,7 @@ bool CDetectorSolution::AddTaskByCopy(IDetectorTask* pSrc)
return false; return false;
CDetectorTask* p = new CDetectorTask(); CDetectorTask* p = new CDetectorTask();
PLP_DETECTOR_TASK pTask = pSrc->GetTaskInfo(); PLP_DETECTOR_TASK pTask = pSrc->GetTaskInfo();
if (p->Initialize(this, m_pSystemInfo, m_pAlgoShare, m_pAlgoLibMgr) && p->SetTaskInfo(pTask)) if (p->Initialize(this, m_pAlgoLibMgr) && p->SetTaskInfo(pTask))
{ {
p->SetID(++m_nBaseID); p->SetID(++m_nBaseID);
p->Copy(pSrc); p->Copy(pSrc);
@ -91,7 +89,7 @@ IDetectorTask* CDetectorSolution::AddTask(const PLP_DETECTOR_TASK pTask, bool bR
CDetectorTask* p = new CDetectorTask(); CDetectorTask* p = new CDetectorTask();
if (p->Initialize(this, m_pSystemInfo, m_pAlgoShare, m_pAlgoLibMgr) && p->SetTaskInfo(pTask)) if (p->Initialize(this, m_pAlgoLibMgr) && p->SetTaskInfo(pTask))
{ {
p->SetID(++m_nBaseID); p->SetID(++m_nBaseID);
m_TaskMapByID.insert(p->GetID(), p); m_TaskMapByID.insert(p->GetID(), p);
@ -525,7 +523,7 @@ IDetectorSolution* CDetectorSolution::Copy()
{ {
QMutexLocker locker(&m_mutex); QMutexLocker locker(&m_mutex);
CDetectorSolution* pNewSolution = new CDetectorSolution(); CDetectorSolution* pNewSolution = new CDetectorSolution();
pNewSolution->Initialize(m_pSystemInfo,m_pAlgoShare, m_pAlgoLibMgr); pNewSolution->Initialize(m_pAlgoLibMgr);
pNewSolution->SetID(m_nID); pNewSolution->SetID(m_nID);
if (!pNewSolution->SetSolutionInfo(&m_tSolutionInfo)) if (!pNewSolution->SetSolutionInfo(&m_tSolutionInfo))

5
src/lpbengine/Solution.h
Unescape Escape View File

@ -30,7 +30,7 @@ public:
virtual void SetModifyFlag(bool bModify); virtual void SetModifyFlag(bool bModify);
virtual IDetectorTask* GetTaskByCameraID(int nCameraID); virtual IDetectorTask* GetTaskByCameraID(int nCameraID);
bool Initialize(IDetectorSystemInfo* pSystemInfo, IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr); bool Initialize(/*IAlgorithmShare* pAlgoShare,*/ IAlgorithmLibMgr* pAlgoLibMgr);
void CleanUp(); void CleanUp();
virtual IDetectorSolution* Copy(); virtual IDetectorSolution* Copy();
virtual bool Copy(IDetectorSolution* pSrcSolution, bool bRet = true); virtual bool Copy(IDetectorSolution* pSrcSolution, bool bRet = true);
@ -65,8 +65,7 @@ private:
QMap<int, IDetectorTask*> m_TaskMapByID; QMap<int, IDetectorTask*> m_TaskMapByID;
QMap<int, IDetectorTask*> m_CurRunTaskMap;//CamID(int),TaskPtr(IDetectorTask*) QMap<int, IDetectorTask*> m_CurRunTaskMap;//CamID(int),TaskPtr(IDetectorTask*)
IDetectorSystemInfo* m_pSystemInfo; // IAlgorithmShare* m_pAlgoShare;
IAlgorithmShare* m_pAlgoShare;
IAlgorithmLibMgr* m_pAlgoLibMgr; IAlgorithmLibMgr* m_pAlgoLibMgr;
QMutex m_mutex; QMutex m_mutex;

111
src/lpbengine/SolutionMgr.cpp
Unescape Escape View File

@ -1,13 +1,11 @@
#include "SolutionMgr.h" #include "SolutionMgr.h"
#include "Solution.h" #include "Solution.h"
CDetectorSolutionMgr::CDetectorSolutionMgr() : m_lock(QMutex::Recursive) CDetectorSolutionMgr::CDetectorSolutionMgr()
{ {
m_nBaseID = 0; m_nBaseID = 0;
m_nRunSolutionID = LP_DETECTOR_INVALID_ID; m_nRunSolutionID = LP_DETECTOR_INVALID_ID;
m_vecSolution.clear(); m_vecSolution.clear();
m_vecSink.clear();
m_pAlgoShare = NULL;
} }
CDetectorSolutionMgr::~CDetectorSolutionMgr() CDetectorSolutionMgr::~CDetectorSolutionMgr()
@ -15,13 +13,9 @@ CDetectorSolutionMgr::~CDetectorSolutionMgr()
CleanUp(); CleanUp();
} }
bool CDetectorSolutionMgr::Initialize(IDetectorSystemInfo* pSystemInfo, bool CDetectorSolutionMgr::Initialize(IAlgorithmLibMgr* pAlgoLibMgr)
IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr)
{ {
m_pSystemInfo = pSystemInfo;
m_pAlgoShare = pAlgoShare;
m_pAlgoLibMgr = pAlgoLibMgr; m_pAlgoLibMgr = pAlgoLibMgr;
return true; return true;
} }
@ -32,10 +26,10 @@ IDetectorSolution* CDetectorSolutionMgr::AddSolution(const PLP_DETECTOR_SOLUTION
CDetectorSolution* p = new CDetectorSolution(); CDetectorSolution* p = new CDetectorSolution();
if (p->Initialize(m_pSystemInfo, m_pAlgoShare, m_pAlgoLibMgr) && p->SetSolutionInfo(pSolution)) if (p->Initialize(m_pAlgoLibMgr) && p->SetSolutionInfo(pSolution))
{ {
p->SetID(++m_nBaseID); p->SetID(++m_nBaseID);
m_vecSolution.push_back(p); m_vecSolution.insert(m_nBaseID, p);
return p; return p;
} }
@ -48,59 +42,29 @@ bool CDetectorSolutionMgr::DeleteSolution(int nSolutionID)
if (m_nRunSolutionID == nSolutionID) if (m_nRunSolutionID == nSolutionID)
m_nRunSolutionID = LP_DETECTOR_INVALID_ID; m_nRunSolutionID = LP_DETECTOR_INVALID_ID;
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin(); QMap<int, IDetectorSolution *>::iterator it = m_vecSolution.find(nSolutionID);
iter != m_vecSolution.end(); ++iter) if (it != m_vecSolution.end())
{
IDetectorSolution *p = *iter;
if (NULL != p)
{
if (p->GetID() == nSolutionID)
{ {
delete *iter; m_vecSolution.erase(it);
iter = m_vecSolution.erase(iter);
if (nSolutionID == m_nRunSolutionID)
m_nRunSolutionID = LP_DETECTOR_INVALID_ID;
return true;
}
}
} }
return false; return false;
} }
IDetectorSolution* CDetectorSolutionMgr::GetSolution(int nSolutionID) IDetectorSolution* CDetectorSolutionMgr::GetSolution(int nSolutionID)
{ {
//只有一个solution且没设置启用的solution时，默认选择第一个solution QMap<int, IDetectorSolution *>::iterator it = m_vecSolution.find(nSolutionID);
if (m_vecSolution.size() == 1){ if (it != m_vecSolution.end())
QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin();
if (*iter != NULL)
{
IDetectorSolution *p = *iter;
p->SetRunState(true);
return p;
}
}
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin();
iter != m_vecSolution.end(); ++iter)
{
if (NULL != *iter)
{ {
IDetectorSolution *p = *iter; (*it)->SetRunState(true);
if (p->GetID() == nSolutionID) return (*it);
return p;
} }
}
return NULL; return NULL;
} }
bool CDetectorSolutionMgr::CheckSolution(int nSolutionID, QString strSolutionName) bool CDetectorSolutionMgr::CheckSolution(int nSolutionID, QString strSolutionName)
{ {
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin(); for (QMap<int, IDetectorSolution *>::iterator iter = m_vecSolution.begin();
iter != m_vecSolution.end(); ++iter) iter != m_vecSolution.end(); ++iter)
{ {
if (NULL != *iter) if (NULL != *iter)
@ -109,7 +73,6 @@ bool CDetectorSolutionMgr::CheckSolution(int nSolutionID, QString strSolutionNam
if (p->GetID() == nSolutionID && p->GetSolutionInfo()->strName == strSolutionName) if (p->GetID() == nSolutionID && p->GetSolutionInfo()->strName == strSolutionName)
return true; return true;
} }
} }
return false; return false;
@ -121,7 +84,7 @@ int CDetectorSolutionMgr::EnumSolution(IDetectorSolution** lppSolution, int nCou
return m_vecSolution.size(); return m_vecSolution.size();
int nIndex = 0; int nIndex = 0;
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin(); for (QMap<int, IDetectorSolution *>::iterator iter = m_vecSolution.begin();
iter != m_vecSolution.end(); ++iter) iter != m_vecSolution.end(); ++iter)
{ {
if (NULL != *iter) if (NULL != *iter)
@ -136,7 +99,7 @@ int CDetectorSolutionMgr::EnumSolution(IDetectorSolution** lppSolution, int nCou
void CDetectorSolutionMgr::CleanUp() void CDetectorSolutionMgr::CleanUp()
{ {
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin(); for (QMap<int, IDetectorSolution *>::iterator iter = m_vecSolution.begin();
iter != m_vecSolution.end(); ++iter) iter != m_vecSolution.end(); ++iter)
{ {
if (*iter) if (*iter)
@ -151,12 +114,9 @@ void CDetectorSolutionMgr::CleanUp()
bool CDetectorSolutionMgr::Save() bool CDetectorSolutionMgr::Save()
{ {
QJsonDocument document; QJsonDocument document;
m_pSystemInfo->SetValue("RunSolution", m_nRunSolutionID);
QString strExePath = QCoreApplication::applicationDirPath(); QString strExePath = QCoreApplication::applicationDirPath();
/*耗时过长*/ /*耗时过长*/
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin(); for (QMap<int, IDetectorSolution *>::iterator iter = m_vecSolution.begin();
iter != m_vecSolution.end(); ++iter) iter != m_vecSolution.end(); ++iter)
{ {
if (*iter) if (*iter)
@ -212,12 +172,9 @@ bool CDetectorSolutionMgr::Save()
bool CDetectorSolutionMgr::SaveByNames(QStringList strNames) bool CDetectorSolutionMgr::SaveByNames(QStringList strNames)
{ {
QJsonDocument document; QJsonDocument document;
m_pSystemInfo->SetValue("RunSolution", m_nRunSolutionID);
QString strExePath = QCoreApplication::applicationDirPath(); QString strExePath = QCoreApplication::applicationDirPath();
/*耗时过长*/ /*耗时过长*/
for (QVector<IDetectorSolution*>::iterator iter = m_vecSolution.begin(); for (QMap<int, IDetectorSolution *>::iterator iter = m_vecSolution.begin();
iter != m_vecSolution.end(); ++iter) iter != m_vecSolution.end(); ++iter)
{ {
if (*iter) if (*iter)
@ -271,7 +228,6 @@ bool CDetectorSolutionMgr::SaveByNames(QStringList strNames)
bool CDetectorSolutionMgr::Load() bool CDetectorSolutionMgr::Load()
{ {
QString strExePath = QCoreApplication::applicationDirPath(); QString strExePath = QCoreApplication::applicationDirPath();
QString strSolutionDirPath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_SOLUTION_DIR; QString strSolutionDirPath = strExePath + LP_DETECTOR_BUSSINESS_CONFIG_SOLUTION_DIR;
QDir solutionDir(strSolutionDirPath); QDir solutionDir(strSolutionDirPath);
@ -280,7 +236,7 @@ bool CDetectorSolutionMgr::Load()
solutionDir.mkdir(strSolutionDirPath); solutionDir.mkdir(strSolutionDirPath);
} }
m_nRunSolutionID = m_pSystemInfo->GetValue("RunSolution").toInt() > 0 ? m_pSystemInfo->GetValue("RunSolution").toInt() : LP_DETECTOR_INVALID_ID; m_nRunSolutionID = 1;
solutionDir.setFilter(QDir::Dirs | QDir::Hidden | QDir::NoSymLinks); solutionDir.setFilter(QDir::Dirs | QDir::Hidden | QDir::NoSymLinks);
solutionDir.setSorting(QDir::Size | QDir::Reversed); solutionDir.setSorting(QDir::Size | QDir::Reversed);
@ -328,7 +284,6 @@ bool CDetectorSolutionMgr::Load()
if (pSolution) if (pSolution)
nBaseID = pSolution->GetID() > nBaseID ? pSolution->GetID() : nBaseID; nBaseID = pSolution->GetID() > nBaseID ? pSolution->GetID() : nBaseID;
} }
/////
m_nBaseID = nBaseID; m_nBaseID = nBaseID;
@ -342,57 +297,27 @@ bool CDetectorSolutionMgr::LoadByNames(QStringList strNames)
bool CDetectorSolutionMgr::ReLoad() bool CDetectorSolutionMgr::ReLoad()
{ {
QMutexLocker locker(&m_lock);
CleanUp(); CleanUp();
m_nBaseID = 0; m_nBaseID = 0;
m_nRunSolutionID = LP_DETECTOR_INVALID_ID; m_nRunSolutionID = LP_DETECTOR_INVALID_ID;
m_vecSolution.clear(); m_vecSolution.clear();
//m_vecSink.clear();
return Load(); return Load();
} }
bool CDetectorSolutionMgr::SetRunSolution(int nSolutionID) bool CDetectorSolutionMgr::SetRunSolution(int nSolutionID)
{ {
QMutexLocker locker(&m_lock);
m_nRunSolutionID = nSolutionID; m_nRunSolutionID = nSolutionID;
IDetectorSolution* pRunSolution = GetSolution(nSolutionID); IDetectorSolution* pRunSolution = GetSolution(nSolutionID);
for (QVector<IDetectorEngineSink*>::iterator iter = m_vecSink.begin();
iter != m_vecSink.end(); ++iter)
{
if (*iter)
{
IDetectorEngineSink* p = *iter;
p->ResetRunSolution(pRunSolution);
}
}
//QWriteLocker locker(&m_lock);
//m_nRunSolutionID = nSolutionID;
return true; return true;
} }
IDetectorSolution* CDetectorSolutionMgr::GetRunSolution() IDetectorSolution* CDetectorSolutionMgr::GetRunSolution()
{ {
// QReadLocker locker(&m_lock);
return GetSolution(m_nRunSolutionID); return GetSolution(m_nRunSolutionID);
} }
void CDetectorSolutionMgr::RegistSink(IDetectorEngineSink* pSink)
{
QMutexLocker locker(&m_lock);
m_vecSink.push_back(pSink);
qWarning() << "Current Run Solution ID:" << m_nRunSolutionID;
IDetectorSolution* pRunSolution = GetRunSolution();
pSink->ResetRunSolution(pRunSolution);
}
IDetectorSolution* CDetectorSolutionMgr::AddAndCopySolution(IDetectorSolution* pSrcSolution) IDetectorSolution* CDetectorSolutionMgr::AddAndCopySolution(IDetectorSolution* pSrcSolution)
{ {
if (!pSrcSolution) if (!pSrcSolution)

13
src/lpbengine/SolutionMgr.h
Unescape Escape View File

@ -13,14 +13,11 @@ public:
IDetectorSolution* GetSolution(int nSolutionID); IDetectorSolution* GetSolution(int nSolutionID);
int EnumSolution(IDetectorSolution** lppSolution, int nCount); int EnumSolution(IDetectorSolution** lppSolution, int nCount);
void CleanUp(); void CleanUp();
bool Initialize(IDetectorSystemInfo* pSystemInfo, IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr); bool Initialize(IAlgorithmLibMgr* pAlgoLibMgr);
//QByteArray SerializeToJson();
//bool SerializeFromJson(QByteArray byteArray);
virtual bool SetRunSolution(int nSolutionID); virtual bool SetRunSolution(int nSolutionID);
virtual IDetectorSolution* GetRunSolution(); virtual IDetectorSolution* GetRunSolution();
virtual void RegistSink(IDetectorEngineSink* pSink);
virtual IDetectorSolution* AddAndCopySolution(IDetectorSolution* pSrcSolution); virtual IDetectorSolution* AddAndCopySolution(IDetectorSolution* pSrcSolution);
virtual bool CheckSolution(int nSolutionID, QString strSolutionName); virtual bool CheckSolution(int nSolutionID, QString strSolutionName);
@ -30,15 +27,9 @@ public:
virtual bool LoadByNames(QStringList strNames); virtual bool LoadByNames(QStringList strNames);
virtual bool ReLoad(); virtual bool ReLoad();
private: private:
// QReadWriteLock m_lock; QMap<int,IDetectorSolution*> m_vecSolution;
QMutex m_lock;
QVector<IDetectorSolution*> m_vecSolution;
int m_nBaseID; int m_nBaseID;
int m_nRunSolutionID; int m_nRunSolutionID;
QVector<IDetectorEngineSink*> m_vecSink;
IDetectorSystemInfo* m_pSystemInfo{ NULL };
IAlgorithmShare* m_pAlgoShare{ NULL };
IAlgorithmLibMgr* m_pAlgoLibMgr{ NULL }; IAlgorithmLibMgr* m_pAlgoLibMgr{ NULL };
}; };

10
src/lpbengine/SystemInfo.cpp
Unescape Escape View File

@ -1,10 +0,0 @@
#include "SystemInfo.h"
CDetectorSystemInfo::CDetectorSystemInfo() : systemSetIni(LP_DETECTOR_BUSSINESS_CONFIG_FILE_NAME, QSettings::IniFormat)
{
systemSetIni.setIniCodec(QTextCodec::codecForName("UTF-8"));
}
CDetectorSystemInfo::~CDetectorSystemInfo()
{
}

24
src/lpbengine/SystemInfo.h
Unescape Escape View File

@ -1,24 +0,0 @@
#ifndef SYSTEMINFO_H
#define SYSTEMINFO_H
#include "lpbengine.h"
class CDetectorSystemInfo : public IDetectorSystemInfo
{
public:
CDetectorSystemInfo();
virtual ~CDetectorSystemInfo();
virtual void SetValue(const QString &key, const QVariant &value){ systemSetIni.setValue(key, value); }
virtual QVariant GetValue(const QString &key, const QVariant &defaultValue = QVariant()){ return systemSetIni.value(key, defaultValue);}
virtual void BeginGroup(const QString &prefix) { return systemSetIni.beginGroup(prefix); }
virtual void EndGroup() { return systemSetIni.endGroup(); }
virtual QStringList allKeys() { return systemSetIni.allKeys(); }
private:
LP_DETECTOR_SYSTEM_INFO m_tSystemInfo;
QSettings systemSetIni;
};
#endif // SYSTEMINFO_H

88
src/lpbengine/Task.cpp
Unescape Escape View File

@ -9,7 +9,6 @@ CDetectorTask::CDetectorTask()
m_nAlgorithmBaseID = 0; m_nAlgorithmBaseID = 0;
m_nRunAlgoID = LP_DETECTOR_INVALID_ID; m_nRunAlgoID = LP_DETECTOR_INVALID_ID;
m_pSolution = NULL; m_pSolution = NULL;
m_pAlgoShare = NULL;
m_vecROI.clear(); m_vecROI.clear();
m_vecAlgorithm.clear(); m_vecAlgorithm.clear();
m_bRunning = false; m_bRunning = false;
@ -21,15 +20,11 @@ CDetectorTask::~CDetectorTask()
CleanUp(); CleanUp();
} }
bool CDetectorTask::Initialize(IDetectorSolution* pSolution, IDetectorSystemInfo* pSystemInfo, bool CDetectorTask::Initialize(IDetectorSolution* pSolution, IAlgorithmLibMgr* pAlgoLibMgr)
IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr)
{ {
if (!pSolution || !pAlgoShare) if (!pSolution )
return false; return false;
m_pSolution = pSolution; m_pSolution = pSolution;
m_pSystemInfo = pSystemInfo;
m_pAlgoShare = pAlgoShare;
m_pAlgoLibMgr = pAlgoLibMgr; m_pAlgoLibMgr = pAlgoLibMgr;
return true; return true;
} }
@ -134,7 +129,7 @@ IDetectorAlgorithm* CDetectorTask::AddAlgorithm(const PLP_DETECTOR_ALGORITHM pAl
return NULL; return NULL;
CDetectorAlgorithm* p = new CDetectorAlgorithm(); CDetectorAlgorithm* p = new CDetectorAlgorithm();
if (p->Initialize(this, m_pAlgoShare, m_pAlgoLibMgr) && p->SetAlgorithmInfo(pAlgorithm)) if (p->Initialize(this, m_pAlgoLibMgr) && p->SetAlgorithmInfo(pAlgorithm))
{ {
++m_nAlgorithmBaseID; ++m_nAlgorithmBaseID;
p->SetID(pAlgorithm->nID); p->SetID(pAlgorithm->nID);
@ -624,7 +619,7 @@ bool CDetectorTask::Copy(IDetectorTask* pSrcTask, bool bRet /* = true */)
{ {
CDetectorAlgorithm* pNewAlgo = (CDetectorAlgorithm*)AddAlgorithm(lppAlgo[i]->GetAlgorithmInfo()); CDetectorAlgorithm* pNewAlgo = (CDetectorAlgorithm*)AddAlgorithm(lppAlgo[i]->GetAlgorithmInfo());
IDetectorAlgorithm* p = lppAlgo[i]; IDetectorAlgorithm* p = lppAlgo[i];
if (pNewAlgo && pNewAlgo->Initialize(this, m_pAlgoShare, m_pAlgoLibMgr) && !pNewAlgo->Copy(lppAlgo[i])) if (pNewAlgo && pNewAlgo->Initialize(this, m_pAlgoLibMgr) && !pNewAlgo->Copy(lppAlgo[i]))
{ {
delete[] lppAlgo; delete[] lppAlgo;
return false; return false;
@ -656,20 +651,12 @@ bool CDetectorTask::Copy(IDetectorTask* pSrcTask, bool bRet /* = true */)
delete[] lppROI; delete[] lppROI;
} }
//QString strFileName = LP_DETECTOR_BUSSINESS_IMAGE_DIR + QString::number(m_pSolution->GetID()) + "_" + QString::number(m_nID) + ".bmp";
//IplImage* pImage = cvLoadImage(strFileName.toLatin1().data());
//m_tTask.pImg = pImage;
//m_tTask.pImg = NULL;
m_nAlgorithmBaseID = pSrcTask->GetAlgoBaseID(); m_nAlgorithmBaseID = pSrcTask->GetAlgoBaseID();
if (pSrcTask->GetRunAlgo()) if (pSrcTask->GetRunAlgo()) {
{
m_nRunAlgoID = pSrcTask->GetRunAlgo()->GetID(); m_nRunAlgoID = pSrcTask->GetRunAlgo()->GetID();
} }
else else
m_nRunAlgoID = LP_DETECTOR_INVALID_ID; m_nRunAlgoID = LP_DETECTOR_INVALID_ID;
return true; return true;
} }
@ -686,22 +673,13 @@ IDetectorAlgorithm* CDetectorTask::GetRunAlgo()
IDetectorSolution* CDetectorTask::GetParentSolution() IDetectorSolution* CDetectorTask::GetParentSolution()
{ {
//if (m_pSolution)
// return m_pSolution->GetID();
//return LP_DETECTOR_INVALID_ID;
return m_pSolution; return m_pSolution;
} }
int CDetectorTask::GetProductCount() int CDetectorTask::GetProductCount()
{ {
for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); iter != m_vecAlgorithm.end(); ++iter) {
iter != m_vecAlgorithm.end(); ++iter) if (*iter) {
{
if (*iter)
{
IDetectorAlgorithm* pAlgo = *iter; IDetectorAlgorithm* pAlgo = *iter;
int nParamCount = pAlgo->EnumOutParam(NULL, 0); int nParamCount = pAlgo->EnumOutParam(NULL, 0);
if (nParamCount > 0) if (nParamCount > 0)
@ -731,89 +709,57 @@ int CDetectorTask::GetProductCount()
} }
} }
} }
delete[] lppParam; delete[] lppParam;
} }
} }
} }
return 1; return 1;
} }
QVariant CDetectorTask::GetSystemInfoValue(const QString &key) QVariant CDetectorTask::GetSystemInfoValue(const QString &key)
{ {
if (m_pSystemInfo)
{
return m_pSystemInfo->GetValue(key);
}
return NULL; return NULL;
} }
bool CDetectorTask::PushImage(PLP_DETECTOR_IMAGE_CACHE_DATA pImageData) bool CDetectorTask::PushImage(PLP_DETECTOR_IMAGE_CACHE_DATA pImageData)
{ {
//if (!m_pImageSaveMgr)
return false; return false;
//return m_pImageSaveMgr->PushImage(pImageData);
} }
void CDetectorTask::LoadUserParamValue() void CDetectorTask::LoadUserParamValue()
{ {
for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); iter != m_vecAlgorithm.end(); ++iter) {
iter != m_vecAlgorithm.end(); ++iter) if (NULL != *iter) {
{
if (NULL != *iter)
{
CDetectorAlgorithm *p = (CDetectorAlgorithm*)*iter; CDetectorAlgorithm *p = (CDetectorAlgorithm*)*iter;
p->LoadUserParamValue(LP_DETECTOR_INVALID_ID); p->LoadUserParamValue(LP_DETECTOR_INVALID_ID);
} }
} }
} }
void CDetectorTask::SaveUserParamValue() void CDetectorTask::SaveUserParamValue()
{ {
for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); iter != m_vecAlgorithm.end(); ++iter) {
iter != m_vecAlgorithm.end(); ++iter) if (NULL != *iter) {
{
if (NULL != *iter)
{
CDetectorAlgorithm *p = (CDetectorAlgorithm*)*iter; CDetectorAlgorithm *p = (CDetectorAlgorithm*)*iter;
p->SaveUserParamValue(LP_DETECTOR_INVALID_ID); p->SaveUserParamValue(LP_DETECTOR_INVALID_ID);
} }
} }
} }
void CDetectorTask::ClearUserParamValue() void CDetectorTask::ClearUserParamValue()
{ {
for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); iter != m_vecAlgorithm.end(); ++iter) {
iter != m_vecAlgorithm.end(); ++iter) if (NULL != *iter) {
{
if (NULL != *iter)
{
CDetectorAlgorithm *p = (CDetectorAlgorithm*)*iter; CDetectorAlgorithm *p = (CDetectorAlgorithm*)*iter;
p->ClearUserParamValue(LP_DETECTOR_INVALID_ID); p->ClearUserParamValue(LP_DETECTOR_INVALID_ID);
} }
} }
} }
bool CDetectorTask::Exec() bool CDetectorTask::Exec()
{ {
int64 start = cv::getTickCount(); int64 start = cv::getTickCount();
//LARGE_INTEGER litmp;
//LONGLONG startTime, endTime;
//double dfMinus, dfFreq, dfTime;
//QueryPerformanceFrequency(&litmp);
//dfFreq = (double)litmp.QuadPart;
//QueryPerformanceCounter(&litmp);
//startTime = litmp.QuadPart;
//quint64 msec = QDateTime::currentMSecsSinceEpoch();
m_bRunning = true; m_bRunning = true;
for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin(); for (QVector<IDetectorAlgorithm*>::iterator iter = m_vecAlgorithm.begin();
iter != m_vecAlgorithm.end(); ++iter) iter != m_vecAlgorithm.end(); ++iter)
@ -823,9 +769,7 @@ bool CDetectorTask::Exec()
CDetectorAlgorithm *pAlgo = (CDetectorAlgorithm*)*iter; CDetectorAlgorithm *pAlgo = (CDetectorAlgorithm*)*iter;
if (pAlgo->IsEnabled()) if (pAlgo->IsEnabled())
pAlgo->ExecOnce(); pAlgo->ExecOnce();
} }
} }
m_bRunning = false; m_bRunning = false;
@ -841,12 +785,6 @@ bool CDetectorTask::Exec()
} }
//QueryPerformanceCounter(&litmp);
//endTime = litmp.QuadPart;
//dfMinus = (double)(endTime - startTime);
//dfTime = dfMinus / dfFreq;
m_dExecTime = (cv::getTickCount() - start) / cv::getTickFrequency() * 1000; m_dExecTime = (cv::getTickCount() - start) / cv::getTickFrequency() * 1000;
qDebug("task name:%s, task exec time: %.3f", m_tTask.strName.toLocal8Bit().data(), m_dExecTime); qDebug("task name:%s, task exec time: %.3f", m_tTask.strName.toLocal8Bit().data(), m_dExecTime);
return true; return true;

6
src/lpbengine/Task.h
Unescape Escape View File

@ -30,8 +30,7 @@ public:
virtual int GetID() const; virtual int GetID() const;
virtual int GetAlgoBaseID() const; virtual int GetAlgoBaseID() const;
virtual void Release(); virtual void Release();
bool Initialize(IDetectorSolution* pSolution, IDetectorSystemInfo* pSystemInfo, bool Initialize(IDetectorSolution* pSolution, /*IAlgorithmShare* pAlgoShare,*/ IAlgorithmLibMgr* pAlgoLibMgr);
IAlgorithmShare* pAlgoShare, IAlgorithmLibMgr* pAlgoLibMgr);
bool SerializePropertyToJson(QJsonObject* pJsonObject); bool SerializePropertyToJson(QJsonObject* pJsonObject);
bool SerializePropertyFromJson(QJsonObject* pJsonObject); bool SerializePropertyFromJson(QJsonObject* pJsonObject);
@ -82,8 +81,7 @@ private:
QVector<IDetectorAlgorithm*> m_vecAlgorithm; QVector<IDetectorAlgorithm*> m_vecAlgorithm;
IDetectorSolution* m_pSolution; IDetectorSolution* m_pSolution;
IDetectorSystemInfo* m_pSystemInfo; //IAlgorithmShare* m_pAlgoShare;
IAlgorithmShare* m_pAlgoShare;
IAlgorithmLibMgr* m_pAlgoLibMgr; IAlgorithmLibMgr* m_pAlgoLibMgr;
bool m_bRunning; bool m_bRunning;

13
src/lpbengine/lpbengine.cpp
Unescape Escape View File

@ -1,13 +0,0 @@
#include "lpbengine.h"
#include "BEApp.h"
CBEApp g_BEApp;
void LpNewEngineInstance(IDetectorEngine** lppBE, IDetectorEngineSink* lpSink)
{
g_BEApp.Initialize(lppBE, lpSink);
}
bool LpDeleteEngineInstance()
{
return g_BEApp.Quit();
}

1
src/tpMain/WheelModel.cpp
Unescape Escape View File

@ -68,7 +68,6 @@ bool WheelModel::initComModel(const QString&strBase)
m_pDetectModel = new ImageCompareModel; m_pDetectModel = new ImageCompareModel;
} }
QString str = strBase + "template\\" + m_strModelID + "\\model.yml"; QString str = strBase + "template\\" + m_strModelID + "\\model.yml";
//QString str = strBase + "模板\\" + m_strModelID + "\\model.yml";
std::string strs = str.toLocal8Bit().toStdString(); std::string strs = str.toLocal8Bit().toStdString();
bool bFlags = m_pDetectModel->readFromFile(strs/*str.toLatin1().data()*/); bool bFlags = m_pDetectModel->readFromFile(strs/*str.toLatin1().data()*/);
if (!bFlags) { if (!bFlags) {

160
tpvs17/lpbengine/lpbengine.vcxproj
Unescape Escape View File

@ -230,127 +230,7 @@
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs> </AdditionalInputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\AlgorithmShare.h"> <CustomBuild Include="..\..\src\lpbengine\CDetectorEngine.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</AdditionalInputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\BEApp.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</AdditionalInputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\BusinessEngine.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</AdditionalInputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\Camera.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</AdditionalInputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\DeviceMgr.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command> </Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@ -470,36 +350,6 @@
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs> </AdditionalInputs>
</CustomBuild> </CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\SystemInfo.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</AdditionalInputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Performing Custom Build Tools</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Performing Custom Build Tools</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</Outputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</AdditionalInputs>
<AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</AdditionalInputs>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\Task.h"> <CustomBuild Include="..\..\src\lpbengine\Task.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</Command> </Command>
@ -535,16 +385,10 @@
<ClCompile Include="..\..\src\lpbengine\Algorithm.cpp" /> <ClCompile Include="..\..\src\lpbengine\Algorithm.cpp" />
<ClCompile Include="..\..\src\lpbengine\AlgorithmLib.cpp" /> <ClCompile Include="..\..\src\lpbengine\AlgorithmLib.cpp" />
<ClCompile Include="..\..\src\lpbengine\AlgorithmLibMgr.cpp" /> <ClCompile Include="..\..\src\lpbengine\AlgorithmLibMgr.cpp" />
<ClCompile Include="..\..\src\lpbengine\AlgorithmShare.cpp" /> <ClCompile Include="..\..\src\lpbengine\CDetectorEngine.cpp" />
<ClCompile Include="..\..\src\lpbengine\BEApp.cpp" />
<ClCompile Include="..\..\src\lpbengine\BusinessEngine.cpp" />
<ClCompile Include="..\..\src\lpbengine\Camera.cpp" />
<ClCompile Include="..\..\src\lpbengine\DeviceMgr.cpp" />
<ClCompile Include="..\..\src\lpbengine\lpbengine.cpp" />
<ClCompile Include="..\..\src\lpbengine\Roi.cpp" /> <ClCompile Include="..\..\src\lpbengine\Roi.cpp" />
<ClCompile Include="..\..\src\lpbengine\Solution.cpp" /> <ClCompile Include="..\..\src\lpbengine\Solution.cpp" />
<ClCompile Include="..\..\src\lpbengine\SolutionMgr.cpp" /> <ClCompile Include="..\..\src\lpbengine\SolutionMgr.cpp" />
<ClCompile Include="..\..\src\lpbengine\SystemInfo.cpp" />
<ClCompile Include="..\..\src\lpbengine\Task.cpp" /> <ClCompile Include="..\..\src\lpbengine\Task.cpp" />
</ItemGroup> </ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

70
tpvs17/lpbengine/lpbengine.vcxproj.filters
Unescape Escape View File

@ -23,26 +23,11 @@
<Extensions>moc;h;cpp</Extensions> <Extensions>moc;h;cpp</Extensions>
<SourceControlFiles>False</SourceControlFiles> <SourceControlFiles>False</SourceControlFiles>
</Filter> </Filter>
<Filter Include="algo">
<UniqueIdentifier>{afe78acb-6e43-4d6a-aa42-5f92cb41a608}</UniqueIdentifier>
</Filter>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="..\..\src\lpbengine\Algorithm.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\BEApp.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\BusinessEngine.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\Camera.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\DeviceMgr.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\lpbengine.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\Roi.cpp"> <ClCompile Include="..\..\src\lpbengine\Roi.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
@ -52,47 +37,23 @@
<ClCompile Include="..\..\src\lpbengine\SolutionMgr.cpp"> <ClCompile Include="..\..\src\lpbengine\SolutionMgr.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpbengine\SystemInfo.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\Task.cpp"> <ClCompile Include="..\..\src\lpbengine\Task.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpbengine\AlgorithmShare.cpp"> <ClCompile Include="..\..\src\lpbengine\Algorithm.cpp">
<Filter>Source Files</Filter> <Filter>algo</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpbengine\AlgorithmLib.cpp"> <ClCompile Include="..\..\src\lpbengine\AlgorithmLib.cpp">
<Filter>Source Files</Filter> <Filter>algo</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpbengine\AlgorithmLibMgr.cpp"> <ClCompile Include="..\..\src\lpbengine\AlgorithmLibMgr.cpp">
<Filter>algo</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpbengine\CDetectorEngine.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<CustomBuild Include="..\..\src\lpbengine\Algorithm.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\AlgorithmLib.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\AlgorithmLibMgr.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\AlgorithmShare.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\BEApp.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\BusinessEngine.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\Camera.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\DeviceMgr.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\Roi.h"> <CustomBuild Include="..\..\src\lpbengine\Roi.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</CustomBuild> </CustomBuild>
@ -102,10 +63,19 @@
<CustomBuild Include="..\..\src\lpbengine\SolutionMgr.h"> <CustomBuild Include="..\..\src\lpbengine\SolutionMgr.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</CustomBuild> </CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\SystemInfo.h"> <CustomBuild Include="..\..\src\lpbengine\Task.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</CustomBuild> </CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\Task.h"> <CustomBuild Include="..\..\src\lpbengine\Algorithm.h">
<Filter>algo</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\AlgorithmLib.h">
<Filter>algo</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\AlgorithmLibMgr.h">
<Filter>algo</Filter>
</CustomBuild>
<CustomBuild Include="..\..\src\lpbengine\CDetectorEngine.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</CustomBuild> </CustomBuild>
</ItemGroup> </ItemGroup>

8
tpvs17/tpMain/CoreCtrl/CDllCoreCtrl.cpp
Unescape Escape View File

@ -9,7 +9,7 @@ extern "C" void Lib_CoreCtrl_Free(ICoreCtrl*);
#endif #endif
#include "QZkJsonParser.h" #include "QZkJsonParser.h"
CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths,class IDetectorEngine* pDE /*= NULL*/) CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths)
{ {
m_szDllPaths = szDllPaths; m_szDllPaths = szDllPaths;
#ifdef _USE_LIB_CORECTRL_DLL #ifdef _USE_LIB_CORECTRL_DLL
@ -19,7 +19,7 @@ CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths,class IDetectorEngine*
m_pCoreCtrl = (ICoreCtrl*)m_pLibCoreCtrl->ModuleInit(nullptr); m_pCoreCtrl = (ICoreCtrl*)m_pLibCoreCtrl->ModuleInit(nullptr);
if (NULL != m_pCoreCtrl) if (NULL != m_pCoreCtrl)
{ {
m_pCoreCtrl->IInitCore(pDE); m_pCoreCtrl->IInitCore();
} }
else else
{ {
@ -43,10 +43,6 @@ CDllCoreCtrl::~CDllCoreCtrl()
#ifdef _USE_LIB_CORECTRL_DLL #ifdef _USE_LIB_CORECTRL_DLL
m_pCoreCtrl->IFreeCore(); m_pCoreCtrl->IFreeCore();
delete m_pCoreCtrl; delete m_pCoreCtrl;
// if (NULL != m_pLibCoreCtrl)
// {
// m_pLibCoreCtrl->ModuleFree();
// }
#else #else
Lib_CoreCtrl_Free(m_pCoreCtrl); Lib_CoreCtrl_Free(m_pCoreCtrl);
#endif #endif

2
tpvs17/tpMain/CoreCtrl/CDllCoreCtrl.h
Unescape Escape View File

@ -7,7 +7,7 @@
class CDllCoreCtrl class CDllCoreCtrl
{ {
public: public:
CDllCoreCtrl(const ZStringList& szDllPaths, class IDetectorEngine* pDE /*= NULL*/); CDllCoreCtrl(const ZStringList& szDllPaths);
~CDllCoreCtrl(); ~CDllCoreCtrl();
public: public:
class CDllLoaderM* m_pLibCoreCtrl; class CDllLoaderM* m_pLibCoreCtrl;

74
tpvs17/tpMain/CoreCtrl/CDllDetectorEngine.cpp
Unescape Escape View File

@ -1,79 +1,33 @@
#include "CDllDetectorEngine.h" #include "CDllDetectorEngine.h"
#include "iCoreCtrl.h" #include "DllLoader.h"
CDllDetectorEngine::CDllDetectorEngine() CDllDetectorEngine::CDllDetectorEngine()
{ {
m_pDE = NULL; m_pLibEngineCtrl = new CDllLoaderM("lpbengine", "Lib_Engine_Init", "Lib_Engine_Free", QStringList());
#ifdef _DEBUG if (m_pLibEngineCtrl != nullptr)
m_lib.setFileName("lpbengined.dll");
#else
m_lib.setFileName("lpbengine.dll");
#endif
if (!m_lib.load())
{ {
qWarning("failed to load lpbengine"); m_pDE = (IDetectorEngine*)m_pLibEngineCtrl->ModuleInit(nullptr);
if (m_pDE){
m_pDE->Initialize();
} }
else {
FnLpNewEngineInstance pfnLpNewInstance = (FnLpNewEngineInstance)m_lib.resolve("LpNewEngineInstance");
if (pfnLpNewInstance)
pfnLpNewInstance(&m_pDE, NULL);
if (!m_pDE)
{
qWarning("failed to get instance from lpbengine"); qWarning("failed to get instance from lpbengine");
} }
} }
CDllDetectorEngine::~CDllDetectorEngine()
{
Quit();
} }
bool CDllDetectorEngine::Initialize(class ICoreCtrl* pCoreCtrl) CDllDetectorEngine::~CDllDetectorEngine()
{
if (m_pDE && pCoreCtrl)
{
void* p = NULL;
m_pDE->GetDataInterface(DEVICEMGR, &p);
IDetectorDeviceMgr* pDeviceMgr = (IDetectorDeviceMgr*)p;
if (pDeviceMgr)
{
pDeviceMgr->RegisterCoreCtrl(pCoreCtrl);
QList<QString> strCameraKeys = pCoreCtrl->ICameraKeys();
for (int i = 0; i < strCameraKeys.size(); i++)
{ {
if (nullptr != m_pDE)
IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)pDeviceMgr->AddDevice(CAMERA);
if (pCamera)
{ {
TP_CAMERA_OPTION option; delete m_pDE;
pCoreCtrl->IGetCameraOption(strCameraKeys.at(i), option); m_pDE = nullptr;
pCamera->SetName(strCameraKeys.at(i));
pCamera->SetID(option.id);
}
}
} }
if (nullptr != m_pLibEngineCtrl)
m_pDE->GetDataInterface(SHAREAPARAM, &p);
IAlgorithmShare* pAlgoShare = (IAlgorithmShare*)p;
if (pAlgoShare)
{ {
pAlgoShare->RegisterCoreCtrl(pCoreCtrl); delete m_pLibEngineCtrl;
} m_pLibEngineCtrl = nullptr;
return true;
} }
return false;
} }
void CDllDetectorEngine::Quit()
{
FnLpDeleteEngineInstance pfnLpDeleteInstance = (FnLpDeleteEngineInstance)m_lib.resolve("LpDeleteEngineInstance");
if (pfnLpDeleteInstance)
pfnLpDeleteInstance();
if (m_lib.isLoaded())
m_lib.unload();
}

8
tpvs17/tpMain/CoreCtrl/CDllDetectorEngine.h
Unescape Escape View File

@ -2,6 +2,7 @@
#define CDLLDETECTORENGINE_H #define CDLLDETECTORENGINE_H
#include "lpbengine.h" #include "lpbengine.h"
#include "zclasses.h"
class CDllDetectorEngine class CDllDetectorEngine
{ {
@ -9,11 +10,8 @@ public:
CDllDetectorEngine(); CDllDetectorEngine();
~CDllDetectorEngine(); ~CDllDetectorEngine();
public: public:
bool Initialize(class ICoreCtrl* pCoreCtrl); IDetectorEngine* m_pDE{ nullptr };
void Quit(); class CDllLoaderM* m_pLibEngineCtrl{ nullptr };
IDetectorEngine *m_pDE;
private:
QLibrary m_lib;
}; };
#endif // CDLLDETECTORENGINE_H #endif // CDLLDETECTORENGINE_H

56
tpvs17/tpMain/lpMainWin.cpp
Unescape Escape View File

@ -41,6 +41,7 @@ lpMainWin::lpMainWin(QWidget *parent)
qRegisterMetaType<TimeStruct>("TimeStruct"); qRegisterMetaType<TimeStruct>("TimeStruct");
m_screen.ShowMsg(tr("加载必要模块.....")); m_screen.ShowMsg(tr("加载必要模块....."));
onInitCoreCtrl(); onInitCoreCtrl();
onInitEngineCtrl();
ui.setupUi(this); ui.setupUi(this);
onInitAbout(); onInitAbout();
{ {
@ -376,7 +377,11 @@ lpMainWin::~lpMainWin()
delete m_pDllCoreCtrl; delete m_pDllCoreCtrl;
m_pDllCoreCtrl = nullptr; m_pDllCoreCtrl = nullptr;
} }
if (m_pDllEngineCtrl)
{
delete m_pDllEngineCtrl;
m_pDllEngineCtrl = nullptr;
}
} }
bool lpMainWin::onInitCoreCtrl() bool lpMainWin::onInitCoreCtrl()
@ -384,7 +389,7 @@ bool lpMainWin::onInitCoreCtrl()
//load coretrl //load coretrl
if (NULL == m_pDllCoreCtrl) if (NULL == m_pDllCoreCtrl)
{ {
m_pDllCoreCtrl = new CDllCoreCtrl(QStringList(), nullptr); m_pDllCoreCtrl = new CDllCoreCtrl(QStringList());
if (NULL == m_pDllCoreCtrl) if (NULL == m_pDllCoreCtrl)
{ {
return false; return false;
@ -407,6 +412,22 @@ bool lpMainWin::onInitCoreCtrl()
return false; return false;
} }
bool lpMainWin::onInitEngineCtrl()
{
if (m_pDllEngineCtrl == nullptr)
{
m_pDllEngineCtrl = new CDllDetectorEngine();
if (m_pDllEngineCtrl != nullptr)
{
m_pEngineCtrl = m_pDllEngineCtrl->m_pDE;
return true;
}
return false;
}
return false;
}
void lpMainWin::loadUserModel() void lpMainWin::loadUserModel()
{ {
//userctrel //userctrel
@ -1315,8 +1336,6 @@ Q_SLOT void lpMainWin::onGetImg()
Q_SLOT void lpMainWin::onShowMsg(QString str) Q_SLOT void lpMainWin::onShowMsg(QString str)
{ {
QPulpewidget *pw = new QPulpewidget(); QPulpewidget *pw = new QPulpewidget();
// m_pw = pw;
// QMainWindow *m_pDlgMain = nullptr;// GET_WIDGET_POINTER("MainWindow", QMainWindow);
pw->setParent(this); pw->setParent(this);
pw->showmessage(str); pw->showmessage(str);
connect(pw, SIGNAL(finished()), pw, SLOT(deleteLater())); connect(pw, SIGNAL(finished()), pw, SLOT(deleteLater()));
@ -1467,35 +1486,6 @@ void lpMainWin::onShowResult(Result2Ui* pRlt)
void lpMainWin::SendResultBee(emTypeBee m_Type, int num) void lpMainWin::SendResultBee(emTypeBee m_Type, int num)
{ {
//qDebug() << "sendResultBeeLight";
//SComframe frame;
//if (m_Type == LIGHT_REDBEE) {
// frame.data1 = 1;
// frame.data2 = num;
// SendDataToCom(0x46, frame);
//}
//else if (m_Type == LIGHT_GREENBEE) {
// frame.data1 = 2;
// frame.data2 = 0;
// frame.data3 = num;
// SendDataToCom(0x46, frame);
//}
//else if (m_Type == LIGHT_YELLOWBEE) {
// frame.data1 = 4;
// frame.data2 = 0;
// frame.data3 = 0;
// frame.data4 = num;
// SendDataToCom(0x46, frame);
//}
//else if (m_Type == LIGHT_BEE) {
// frame.data1 = 8;
// frame.data2 = 0;
// frame.data3 = 0;
// frame.data4 = 0;
// frame.data5 = num;
// SendDataToCom(0x46, frame);
//}
if (m_Type == LIGHT_REDBEE) { if (m_Type == LIGHT_REDBEE) {
m_pNet->sendLight(0, 1, 500, 500);//红灯 m_pNet->sendLight(0, 1, 500, 500);//红灯
} }

7
tpvs17/tpMain/lpMainWin.h
Unescape Escape View File

@ -21,6 +21,8 @@
#include "qpixmapbar.h" #include "qpixmapbar.h"
#include "QSystemSettingDlg.h" #include "QSystemSettingDlg.h"
#include "QCamSettingDlg.h" #include "QCamSettingDlg.h"
#include "lpbengine.h"
#include "CoreCtrl/CDllDetectorEngine.h"
class lpMainWin : public QMainWindow class lpMainWin : public QMainWindow
{ {
@ -70,6 +72,7 @@ private:
protected: protected:
bool onInitCoreCtrl(); bool onInitCoreCtrl();
bool onInitEngineCtrl();
void loadUserModel();//加载用户管理模块 void loadUserModel();//加载用户管理模块
//国际化 //国际化
@ -200,6 +203,10 @@ private:
bool readExposureTimeConfig(const QString& strPath); bool readExposureTimeConfig(const QString& strPath);
int getCurExposureTime(); int getCurExposureTime();
private:
CDllDetectorEngine* m_pDllEngineCtrl{ nullptr };
IDetectorEngine* m_pEngineCtrl{nullptr};
}; };
#endif #endif

6
tpvs17/tpMain/lpMainWin.ui
Unescape Escape View File

@ -860,6 +860,7 @@ background-color: rgb(170, 170, 127);</string>
<addaction name="action_modelmgr"/> <addaction name="action_modelmgr"/>
<addaction name="action_connect_mode"/> <addaction name="action_connect_mode"/>
<addaction name="action_checkdata"/> <addaction name="action_checkdata"/>
<addaction name="action"/>
<addaction name="separator"/> <addaction name="separator"/>
</widget> </widget>
<widget class="QStatusBar" name="statusBar"/> <widget class="QStatusBar" name="statusBar"/>
@ -1031,6 +1032,11 @@ background-color: rgb(170, 170, 127);</string>
</font> </font>
</property> </property>
</action> </action>
<action name="action">
<property name="text">
<string>设计</string>
</property>
</action>
</widget> </widget>
<layoutdefault spacing="6" margin="11"/> <layoutdefault spacing="6" margin="11"/>
<resources> <resources>

20
tpvs17/wheel.sln
Unescape Escape View File

@ -19,6 +19,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tpCamBaumer", "..\..\Valve\
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lpReport", "lpReport\lpReport.vcxproj", "{0E042214-1B06-40D6-9D20-C6D5FA3D7A51}" Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lpReport", "lpReport\lpReport.vcxproj", "{0E042214-1B06-40D6-9D20-C6D5FA3D7A51}"
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lpbengine", "lpbengine\lpbengine.vcxproj", "{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lpdesigner", "lpdesigner\lpdesigner.vcxproj", "{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}"
EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64 Debug|x64 = Debug|x64
@ -77,12 +81,26 @@ Global
{0E042214-1B06-40D6-9D20-C6D5FA3D7A51}.Release|x64.ActiveCfg = Release|x64 {0E042214-1B06-40D6-9D20-C6D5FA3D7A51}.Release|x64.ActiveCfg = Release|x64
{0E042214-1B06-40D6-9D20-C6D5FA3D7A51}.Release|x64.Build.0 = Release|x64 {0E042214-1B06-40D6-9D20-C6D5FA3D7A51}.Release|x64.Build.0 = Release|x64
{0E042214-1B06-40D6-9D20-C6D5FA3D7A51}.Release|x86.ActiveCfg = Release|x64 {0E042214-1B06-40D6-9D20-C6D5FA3D7A51}.Release|x86.ActiveCfg = Release|x64
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Debug|x64.ActiveCfg = Debug|x64
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Debug|x64.Build.0 = Debug|x64
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Debug|x86.ActiveCfg = Debug|Win32
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Debug|x86.Build.0 = Debug|Win32
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Release|x64.ActiveCfg = Release|x64
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Release|x64.Build.0 = Release|x64
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Release|x86.ActiveCfg = Release|Win32
{DC221ADF-9D25-40E0-90AD-CC2C497F6FB9}.Release|x86.Build.0 = Release|Win32
{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}.Debug|x64.ActiveCfg = Debug|x64
{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}.Debug|x64.Build.0 = Debug|x64
{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}.Debug|x86.ActiveCfg = Debug|x64
{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}.Release|x64.ActiveCfg = Release|x64
{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}.Release|x64.Build.0 = Release|x64
{616EB73F-66E3-46FF-B423-1A5B7E6AAB8B}.Release|x86.ActiveCfg = Release|x64
EndGlobalSection EndGlobalSection
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE
EndGlobalSection EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {CD365F32-5EAC-4A16-AD47-BFB1D8E5511A}
Qt5Version = qt5.9.4-msvc2017-x64 Qt5Version = qt5.9.4-msvc2017-x64
SolutionGuid = {CD365F32-5EAC-4A16-AD47-BFB1D8E5511A}
EndGlobalSection EndGlobalSection
EndGlobal EndGlobal

Write Preview
Loading…
Cancel
Save