优化lpcorectrl代码,移除大部分不需要的接口和逻辑

master
bobpan 6 years ago
parent 0b135eb9c9
commit 7b041596f9

@ -1,20 +1,9 @@
/****************************************************************************** #ifndef __BASE_CONSTNAT_H_
Copyright(C):2015~2018 hzleaper #define __BASE_CONSTNAT_H_
FileName:baseConstant.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/08
History:8:4:2015 12:55
*******************************************************************************/
#ifndef __BASE_CONSTNAT_H_20150608
#define __BASE_CONSTNAT_H_20150608
namespace TP_STR{ namespace TP_STR{
const char cszJsonSuffix[] = ".json"; const char cszJsonSuffix[] = ".json";
const char cszDatSuffix[] = ".dat"; const char cszDatSuffix[] = ".dat";
// const char cszCfgFolder[] = "config\\";
// const char cszMainCfg[] = "main";
} }
#endif #endif

@ -1,14 +1,5 @@
/****************************************************************************** #ifndef __BASE_DEFINE_H_
Copyright(C):2015~2018 hzleaper #define __BASE_DEFINE_H_
FileName:baseDefine.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/07
History:7:4:2015 9:13
*******************************************************************************/
#ifndef __BASE_DEFINE_H_20150407
#define __BASE_DEFINE_H_20150407
#include "sysInclude.h" #include "sysInclude.h"
@ -21,9 +12,6 @@ typedef unsigned short WORD;
#ifndef DWORD #ifndef DWORD
typedef unsigned long DWORD; typedef unsigned long DWORD;
#endif #endif
//#ifndef size_t
//typedef unsigned int size_t;
//#endif
#define MAX(a, b) (a) > (b) ? (a) : (b) #define MAX(a, b) (a) > (b) ? (a) : (b)
#define MIN(a, b) (a) > (b) ? (b) : (a) #define MIN(a, b) (a) > (b) ? (b) : (a)

@ -9,32 +9,6 @@
#define BASE_MAX_FOLDER_NAME_SIZE 64 #define BASE_MAX_FOLDER_NAME_SIZE 64
#define BASE_MAX_FILE_NAME_SIZE 64 #define BASE_MAX_FILE_NAME_SIZE 64
enum emTpFolderNameList {
TP_FOLDER_NAME_CONFIG = 0,
TP_FOLDER_NAME_PICTURE = 1,
TP_FOLDER_NAME_UI = 2,
TP_FOLDER_NAME_MAX_NUM = 32,
};
typedef struct tagTP_GLOBAL_DATA{
char tgdMainPath[BASE_MAX_FILE_PATH];
char tgdUserPath[BASE_MAX_FILE_PATH];
char tgdDllPath[BASE_MAX_FILE_PATH];
char tgdFolderNames[TP_FOLDER_NAME_MAX_NUM][BASE_MAX_FOLDER_NAME_SIZE];
void* tgdpDllPaths;//pointer to a stringlist
}TP_GLOBAL_DATA;
inline ZStringA TPConfigFileWholePath(const TP_GLOBAL_DATA* pGlobal, const char* szFile) {
ZStringA szFileName(pGlobal->tgdMainPath);
szFileName.append(pGlobal->tgdFolderNames[TP_FOLDER_NAME_CONFIG]).append(szFile).append(TP_STR::cszJsonSuffix);
return szFileName;
}
enum emTpImageShowType {
TP_IMAGE_SHOW_NO = 0,
TP_IMAGE_SHOW_EVERY = 1,
TP_IMAGE_SHOW_NEW = 2,
};
typedef struct tagTP_CORE_SETTING{ typedef struct tagTP_CORE_SETTING{
int threadsCount; int threadsCount;
int imageShowType; int imageShowType;
@ -193,53 +167,6 @@ typedef struct tagTP_CAMERAPOOL_OPTION {
int fixedFrames; int fixedFrames;
}TP_CAMERAPOOL_OPTION; }TP_CAMERAPOOL_OPTION;
// typedef struct tagTP_CAMERA_WIN {
// tagTP_CAMERA_WIN()
// :images(1), buffers(2),
// bitsPerPixel(32), index(0),
// bufferW(0), bufferH(0), mirror(0),
// bCacheOriginImage(false), bNeedRgbSwapped(false)
// {}
// QString key;//widget name
// QString device;//camera key
// quint8 images;
// quint8 buffers;
// quint8 bitsPerPixel;
// quint8 index;
// int bufferW;
// int bufferH;
// int mirror;//0:no, 1:horizontal, 2:vertical, 3: both
// bool bCacheOriginImage;
// bool bNeedRgbSwapped;
//
// bool operator==(const tagTP_CAMERA_WIN& rhs)
// {
// return (key == rhs.key) && (device == rhs.device) &&
// (images == rhs.images) && (buffers == rhs.buffers) &&
// (bitsPerPixel == rhs.bitsPerPixel) &&
// (index == rhs.index) &&
// (bufferW == rhs.bufferW) && (bufferH == rhs.bufferH) &&
// (mirror == rhs.mirror) &&
// (bCacheOriginImage == rhs.bCacheOriginImage) &&
// (bNeedRgbSwapped == rhs.bNeedRgbSwapped);
// }
// }TP_CAMERA_WIN;
// enum emTpUiDataType {
// TP_UI_DATA_FROM_CORECTRL = 0,
// TP_UI_DATA_FROM_ALGORITHM = 0x10000,
// TP_UI_DATA_FROM_CAMERA = 0x20000,
// TP_UI_DATA_FROM_COMMUNICATE = 0x30000,
// };
//Q_DECLARE_METATYPE(emTpUiDataType)
// typedef struct tagTP_IO_OUT_CONTROL {
// BYTE index;
// BYTE state;//0 or 1
// WORD mSecToSwitch;//0 for no Switch;
// }TP_IO_OUT_CONTROL;
static const QMap<emTpColorFormat, QString> gColorNameMap = { static const QMap<emTpColorFormat, QString> gColorNameMap = {
{ TP_COLOR_NONE, "None" }, { TP_COLOR_NONE, "None" },
{ TP_COLOR_Y800, "GRAY8" }, { TP_COLOR_Y800, "GRAY8" },

@ -1,13 +1,4 @@
/****************************************************************************** #ifndef __TP_ALGORITHM_H
Copyright(C):2015~2018 hzleaper
FileName:tpAlgorithm.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/15
History:15:5:2015 17:51
*******************************************************************************/
#ifndef __TP_ALGORITHM_H
#define __TP_ALGORITHM_H #define __TP_ALGORITHM_H
#include "baseDefine.h" #include "baseDefine.h"
@ -16,7 +7,6 @@
#include <QtCore\qvariant.h> #include <QtCore\qvariant.h>
#include <QtCore\qbuffer.h> #include <QtCore\qbuffer.h>
#include <QtCore\qstringlist.h> #include <QtCore\qstringlist.h>
//#include "baseStruct.h"
#define ALG_SHARED_GLOBAL_KEY_APP_STATUS "app_status" #define ALG_SHARED_GLOBAL_KEY_APP_STATUS "app_status"
#define ALG_SHARED_GLOBAL_KEY_APP_CHECKED "app_checked_status" #define ALG_SHARED_GLOBAL_KEY_APP_CHECKED "app_checked_status"
@ -35,7 +25,6 @@ public:
virtual int IGetInt(const QString& key, int nDef = 0) = 0; virtual int IGetInt(const QString& key, int nDef = 0) = 0;
}; };
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
#define ALG_OPTION_GLOBAL_KEY_SAMPLING_OBJECT "sampling_object" #define ALG_OPTION_GLOBAL_KEY_SAMPLING_OBJECT "sampling_object"

@ -5,15 +5,6 @@
#include <QtCore/QString> #include <QtCore/QString>
#include <QtGui/QImage> #include <QtGui/QImage>
//the parameter for the CoreCtrl module
typedef struct tagCORE_CTRL_IN_PARAM
{
class IGuiCallback* pGuiCb;
TP_GLOBAL_DATA* pGlobalData;
TP_CORE_SETTING* pCoreSetting;
}CORE_CTRL_IN_PARAM;
/**/
class IAlgorithmResult class IAlgorithmResult
{ {
public: public:
@ -73,16 +64,13 @@ public://private: //use private when the old main is discarded;
virtual void IEndImageProcess() = 0; virtual void IEndImageProcess() = 0;
}; };
//callback interface from gui #ifdef TPCORECTRL_EXPORTS
class IGuiCallback #define TPCORECTRL_API extern "C" __declspec(dllexport)
{ #else
public: #define TPCORECTRL_API extern "C"
IGuiCallback() {} #endif
virtual ~IGuiCallback() {}
virtual void INewCameraImage(const QVariantMap& vMap) = 0;
virtual void IVariantMapToUI(const QString& camKey, const QVariantMap& vMap) = 0;
virtual QVariant IGetVariantById(int id) = 0;
};
extern "C" TPCORECTRL_API ICoreCtrl* Lib_CoreCtrl_Init(void);
extern "C" TPCORECTRL_API void Lib_CoreCtrl_Free(ICoreCtrl* ptr);
#endif #endif

@ -1,21 +1,12 @@
/****************************************************************************** #ifndef __I_IMG_PROC_H_20150326
Copyright(C):2015~2018 hzleaper
FileName:iImgProc.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 17:58
*******************************************************************************/
#ifndef __I_IMG_PROC_H_20150326
#define __I_IMG_PROC_H_20150326 #define __I_IMG_PROC_H_20150326
#include "baseDefine.h" #include "baseDefine.h"
#include "baseStruct.h" #include "baseStruct.h"
typedef struct tagIMGPROC_IN_PARAM{ // typedef struct tagIMGPROC_IN_PARAM{
TP_GLOBAL_DATA* pGlobalData; // TP_GLOBAL_DATA* pGlobalData;
}IMGPROC_IN_PARAM; // }IMGPROC_IN_PARAM;
class IImgProc class IImgProc
{ {

@ -2,12 +2,11 @@
#define __TP_I_CAMERA_H #define __TP_I_CAMERA_H
#include "baseInclude.h" #include "baseInclude.h"
#include "ZkCameraImage.h" #include "lpCameraImage.h"
typedef struct tagCAMERA_IN_PARAM { // typedef struct tagCAMERA_IN_PARAM {
class ICameraCallback* pCallback; // class ICameraCallback* pCallback;
TP_GLOBAL_DATA* pGlobalData; // }CAMERA_IN_PARAM;
}CAMERA_IN_PARAM;
class ICameraPool class ICameraPool
@ -47,8 +46,8 @@ public:
virtual void IManualTrigger( emTpTriggerDirection nDirection = TRIGGER_DIRECT_FOREWARD) = 0; virtual void IManualTrigger( emTpTriggerDirection nDirection = TRIGGER_DIRECT_FOREWARD) = 0;
virtual void ISnapImage(const QStringList& camKeys) = 0; virtual void ISnapImage(const QStringList& camKeys) = 0;
virtual void ISendSoftTrigger(const QStringList& camKeys) = 0; virtual void ISendSoftTrigger(const QStringList& camKeys) = 0;
virtual CZkCameraImage* IPopCameraImage() = 0; virtual lpCameraImage* IPopCameraImage() = 0;
virtual void IFreeCameraImage(CZkCameraImage *pCamImg) = 0; virtual void IFreeCameraImage(lpCameraImage *pCamImg) = 0;
//@camera: NULL means setting every camera //@camera: NULL means setting every camera
virtual void ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue) = 0; virtual void ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue) = 0;
virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property) = 0; virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property) = 0;
@ -67,13 +66,13 @@ public:
virtual bool ICamsPausePush() = 0; virtual bool ICamsPausePush() = 0;
}; };
class ICameraCallback // class ICameraCallback
{ // {
public: // public:
ICameraCallback() {} // ICameraCallback() {}
virtual ~ICameraCallback() {} // virtual ~ICameraCallback() {}
virtual QVariant IGetVariantById(int nId) = 0; // virtual QVariant IGetVariantById(int nId) = 0;
virtual void INewCameraImage(const QVariantMap& vmap) = 0; // virtual void INewCameraImage(const QVariantMap& vmap) = 0;
}; // };
#endif #endif

@ -1,48 +0,0 @@
#include "AlgorithmResult.h"
CAlgorithmResult::CAlgorithmResult()
{
}
CAlgorithmResult::~CAlgorithmResult()
{
}
QVariantMap CAlgorithmResult::ToVariantMap()
{
QReadLocker locker(&m_lock);
return m_json.toVariantMap();
}
void CAlgorithmResult::SetResult(const QString& key, QVariant& val)
{
QWriteLocker locker(&m_lock);
m_json.insert(key, QJsonValue::fromVariant(val));
}
bool CAlgorithmResult::AccumulateResult(const QString& key, QVariant& val)
{
QWriteLocker locker(&m_lock);
QJsonValue jval = m_json.value(key);
if (jval.isUndefined())
{
m_json.insert(key, QJsonValue::fromVariant(val));
}
else
{
if (!jval.isDouble())
{
return false;
}
bool bOk;
double fv = val.toDouble(&bOk);
if (!bOk)
{
return false;
}
fv += jval.toDouble();
m_json.insert(key, fv);
}
return true;
}

@ -1,22 +0,0 @@
#ifndef CALGORITHMRESULT_H
#define CALGORITHMRESULT_H
#include "iCoreCtrl.h"
#include <QtCore\qjsonobject.h>
#include <QtCore\qreadwritelock.h>
class CAlgorithmResult : public IAlgorithmResult
{
public:
CAlgorithmResult();
virtual ~CAlgorithmResult();
virtual QVariantMap ToVariantMap();
void SetResult(const QString& key, QVariant& val);
bool AccumulateResult(const QString& key, QVariant& val);
private:
QJsonObject m_json;
QReadWriteLock m_lock;
//friend class CImageObject;
};
#endif // CALGORITHMRESULT_H

@ -1,43 +1,50 @@
#include "CoreCtrl.h" #include "CoreCtrl.h"
#include "globalCoreCtrl.h"
#include "baseFunction.h" #include "baseFunction.h"
#include "QZkJsonParser.h" #include "QZkJsonParser.h"
#include <QDebug> #include <QDebug>
#include <QThreadPool> #include <QThreadPool>
#include "callbackFunc.h" #include "callbackFunc.h"
#include "CameraPool.h" #include "CameraPool.h"
#include "globalCamera.h" #include "lpCameraConfig.h"
#include "lpCoreConfig.h"
#include "ImageObject.h"
CCoreCtrl::CCoreCtrl(void) TPCORECTRL_API ICoreCtrl* Lib_CoreCtrl_Init(void)
{ {
CCoreCtrl* gpCoreCtrl = nullptr;
if (NULL == gpCoreCtrl)
{
gpCoreCtrl = new CCoreCtrl();
}
return gpCoreCtrl;
} }
CCoreCtrl::CCoreCtrl(void* inParam) TPCORECTRL_API void Lib_CoreCtrl_Free(ICoreCtrl* ptr)
{ {
CORE_CTRL_IN_PARAM* pCciParam = (CORE_CTRL_IN_PARAM*)inParam; if (NULL != ptr)
m_gpData = new CGlobalCoreCtrl(pCciParam);
{ {
CAMERA_IN_PARAM camInParam; ptr->IFreeCore();
camInParam.pCallback = m_gpData; delete ptr;
camInParam.pGlobalData = nullptr; ptr = nullptr;
}
}
m_gpGlobalCameraZZZ = new CGlobalCamera(&camInParam);
m_gpCameraPool = new CCameraPool(); CCoreCtrl::CCoreCtrl(void)
((CCameraPool*)m_gpCameraPool)->InitPool(); {
lpCoreConfig::instance()->readConfig();
lpCameraConfig::instance();
IMGPROC_IN_PARAM imgprocInParam; m_gpCameraPool = new CCameraPool();
imgprocInParam.pGlobalData = m_gpGlobalCameraZZZ->m_pGlobalData; ((CCameraPool*)m_gpCameraPool)->InitPool();
m_gpImgProc = new CImgProc(&imgprocInParam);
((CImgProc*)m_gpImgProc)->InitProc();
} m_gpImgProc = new CImgProc();
((CImgProc*)m_gpImgProc)->InitProc();
} }
CCoreCtrl::~CCoreCtrl(void) CCoreCtrl::~CCoreCtrl(void)
{ {
IFreeCore();
if (m_gpImgProc) if (m_gpImgProc)
{ {
((CImgProc*)m_gpImgProc)->FreeProc(); ((CImgProc*)m_gpImgProc)->FreeProc();
@ -51,26 +58,14 @@ CCoreCtrl::~CCoreCtrl(void)
delete m_gpCameraPool; delete m_gpCameraPool;
m_gpCameraPool = nullptr; m_gpCameraPool = nullptr;
} }
if (m_gpData)
{
delete m_gpData;
m_gpData = nullptr;
}
if (m_gpGlobalCameraZZZ)
{
delete m_gpGlobalCameraZZZ;
m_gpGlobalCameraZZZ = nullptr;
}
IFreeCore();
} }
int CCoreCtrl::IInitCore(class IDetectorEngine* pDE /*= NULL*/) int CCoreCtrl::IInitCore(class IDetectorEngine* pDE /*= NULL*/)
{ {
m_pDE = pDE;
int nRet = 0; int nRet = 0;
//create threads //create threads
int nCount = 4;// gCoreSetting.threadsCount; int nCount = lpCoreConfig::instance()->m_CoreSetting.threadsCount;
if (nCount <= 0) if (nCount <= 0)
{ {
nCount = SYS_F::GetCpus();//获取系统cpu线程数量 nCount = SYS_F::GetCpus();//获取系统cpu线程数量
@ -78,7 +73,8 @@ int CCoreCtrl::IInitCore(class IDetectorEngine* pDE /*= NULL*/)
/*创建图片处理线程*/ /*创建图片处理线程*/
for (int i = 0; i < nCount; ++i) for (int i = 0; i < nCount; ++i)
{ {
QTpThreadImage *pThd = new QTpThreadImage(this, pDE); TaskFunc func = std::bind(&CCoreCtrl::onTaskFunc, this);
lpThread *pThd = new lpThread(func);
if( NULL == pThd ) if( NULL == pThd )
{ {
break; break;
@ -105,7 +101,7 @@ void CCoreCtrl::IFreeCore()
//删除图片处理线程 //删除图片处理线程
while( !m_imgThdPool.isEmpty() ) while( !m_imgThdPool.isEmpty() )
{ {
QTpThreadImage* pThd = m_imgThdPool.takeLast(); lpThread* pThd = m_imgThdPool.takeLast();
pThd->EndThread(); pThd->EndThread();
delete pThd; delete pThd;
} }
@ -132,21 +128,6 @@ void CCoreCtrl::IEndImageProcess()
} }
} }
void CCoreCtrl::ISetResult(const QString& key, QVariant& val)
{
m_algResult.SetResult(key, val);
//callback to ui
//glpGuiCallback->IAlgorithmResult(m_algResult.ToVariantMap());
}
void CCoreCtrl::AccumulateResult(const QString& key, QVariant& val)
{
if (m_algResult.AccumulateResult(key, val))
{
//glpGuiCallback->IAlgorithmResult(m_algResult.ToVariantMap());
}
}
QList<QString> CCoreCtrl::ICameraKeys() QList<QString> CCoreCtrl::ICameraKeys()
{ {
return m_gpCameraPool->ICameraKeys(); return m_gpCameraPool->ICameraKeys();
@ -311,3 +292,49 @@ bool CCoreCtrl::IRegisterResultCallBack(FuncCallBack_StrMap callback)
else else
return false; return false;
} }
bool CCoreCtrl::onTaskFunc()
{
QTime timespan;
timespan.start();
lpCameraImage* pCamImage = m_gpCameraPool->IPopCameraImage();
int span = timespan.elapsed();
if (span > 100)
{
qWarning() << "Pop image from poll cost " << span << " MSecs"
<< " - " __FUNCTION__;
}
if (NULL != pCamImage)
{
{
// send image to UI
timespan.restart();
//TODO show Image
// m_pCoreCtrl->ShowCameraImage(pCamImage->Serial()
// , pCamImage->FrameNumber()
// , pCamImage->ToQImage()
// , pCamImage->Stamp()
// , 0
// , QString::fromUtf8(pCamImage->FileName()));//(pCamImage);
//
// qDebug() << "Show camera image to UI cost " << timespan.elapsed() << " MSecs"
// << " - " __FUNCTION__;
}
CImageObject m_objImage(this);
{
// Algorithm process image
timespan.restart();
m_objImage.SetCameraImage(pCamImage);
m_gpImgProc->IImageProcess(&m_objImage, m_pDE);
qDebug() << "Process Image(ID:" << pCamImage->FrameNumber()
<< ") cost " << timespan.elapsed() << " MSecs"
<< " - " __FUNCTION__;
}
//release CameraImage
m_objImage.SetCameraImage(NULL);
m_gpCameraPool->IFreeCameraImage(pCamImage);
return true;
}
return false;
}

@ -2,18 +2,15 @@
#define __CORE_CTRL_H #define __CORE_CTRL_H
#include "iCoreCtrl.h" #include "iCoreCtrl.h"
#include "qtpthreadimage.h" #include "lpThread.h"
#include "QZkMutexMap.h" #include "QZkMutexMap.h"
#include "AlgorithmResult.h"
#include "ImgProc.h" #include "ImgProc.h"
#include "globalCamera.h"
#include "CameraPool.h" #include "CameraPool.h"
class CCoreCtrl : public ICoreCtrl class CCoreCtrl : public ICoreCtrl
{ {
public: public:
CCoreCtrl(void); CCoreCtrl(void);
CCoreCtrl(void* inParam);
virtual ~CCoreCtrl(void); virtual ~CCoreCtrl(void);
//初始化CoreCtrl //初始化CoreCtrl
virtual int IInitCore(class IDetectorEngine* pDE = NULL); virtual int IInitCore(class IDetectorEngine* pDE = NULL);
@ -22,8 +19,6 @@ public:
//开始执行算法处理 //开始执行算法处理
virtual void IStartImageProcess(); virtual void IStartImageProcess();
virtual void IEndImageProcess(); virtual void IEndImageProcess();
void AccumulateResult(const QString& key, QVariant& val);
virtual void ISetResult(const QString& key, QVariant& val);
private: private:
virtual QList<QString> ICameraKeys(); virtual QList<QString> ICameraKeys();
virtual QList<QString> ICameraKeysOrderByIds(); virtual QList<QString> ICameraKeysOrderByIds();
@ -59,17 +54,16 @@ private:
virtual bool IRegisterGetVariant(FuncCallBack_VarInt func); virtual bool IRegisterGetVariant(FuncCallBack_VarInt func);
virtual bool IRegisterImageCallBack(FuncCallBack_VarMap callback); //获取相机图像回调接口 virtual bool IRegisterImageCallBack(FuncCallBack_VarMap callback); //获取相机图像回调接口
virtual bool IRegisterResultCallBack(FuncCallBack_StrMap callback); //获取算法结果回调接口 virtual bool IRegisterResultCallBack(FuncCallBack_StrMap callback); //获取算法结果回调接口
bool onTaskFunc();
private: private:
QList<QTpThreadImage*> m_imgThdPool; QList<lpThread*> m_imgThdPool;
CAlgorithmResult m_algResult;
int m_nCoreCount; int m_nCoreCount;
friend class CImageObject; friend class CImageObject;
friend class QTpThreadImage; friend class QTpThreadImage;
private: private:
CGlobalCoreCtrl* m_gpData{ nullptr };
CGlobalCamera* m_gpGlobalCameraZZZ{ nullptr };
ICameraPool* m_gpCameraPool{ nullptr }; ICameraPool* m_gpCameraPool{ nullptr };
IImgProc* m_gpImgProc{nullptr}; IImgProc* m_gpImgProc{nullptr};
class IDetectorEngine* m_pDE{ nullptr };
}; };
#endif #endif

@ -1,53 +0,0 @@
#include "GlobalDataBase.h"
CGlobalDataBase::CGlobalDataBase(char *szExePath)
{
int i = 0;
if( NULL != szExePath )
{
i = std::strlen(szExePath);
if( i >= BASE_MAX_FILE_PATH )
{
i = BASE_MAX_FILE_PATH - 1;
}
}
--i;
while( i > 0 )
{
if( szExePath[i] == '\\' )
{
break;
}
--i;
}
if ( i >= 0 )
{
std::strncpy(tgdMainPath, szExePath, i+1);
tgdMainPath[i+1] = '\0';
}
else
{
std::strcpy(tgdMainPath, ".\\");
}
std::strcpy(tgdUserPath, tgdMainPath);
std::strcpy(tgdFolderNames[TP_FOLDER_NAME_CONFIG], "config\\");
std::strcpy(tgdFolderNames[TP_FOLDER_NAME_PICTURE], "pic\\");
std::memset(&m_coreSetting, 0, sizeof(m_coreSetting));
}
CGlobalDataBase::~CGlobalDataBase()
{
}
bool CGlobalDataBase::CoreSettingFromJson(QJsonObject& jsonObj)
{
if( jsonObj.isEmpty() )
{
return false;
}
m_coreSetting.threadsCount = jsonObj.value("image_threads").toInt(0);
m_coreSetting.imageShowType = jsonObj.value("show_type").toInt(TP_IMAGE_SHOW_NEW);
return true;
}

@ -1,20 +0,0 @@
#ifndef GLOBALDATABASE_H
#define GLOBALDATABASE_H
#include "baseInclude.h"
#include <QtCore/QJsonObject>
class CGlobalDataBase : public TP_GLOBAL_DATA
{
public:
CGlobalDataBase(char *szExePath);
~CGlobalDataBase();
bool CoreSettingFromJson(QJsonObject& jsonObj);
public:
tagTP_CORE_SETTING m_coreSetting;
private:
};
#endif // GLOBALDATABASE_H

@ -14,7 +14,7 @@ CImageObject::~CImageObject()
} }
bool CImageObject::SetCameraImage(CZkCameraImage* pCamImage) bool CImageObject::SetCameraImage(lpCameraImage* pCamImage)
{ {
m_pCamImg = pCamImage; m_pCamImg = pCamImage;
return true; return true;
@ -197,18 +197,18 @@ const ZStringA& CImageObject::IDllSuffix()
void CImageObject::ISetResult(const QString& key, QVariant& val) void CImageObject::ISetResult(const QString& key, QVariant& val)
{ {
if (NULL != m_pCoreCtrl) // if (NULL != m_pCoreCtrl)
{ // {
m_pCoreCtrl->ISetResult(key, val); // m_pCoreCtrl->ISetResult(key, val);
} // }
} }
void CImageObject::IAccumulateResult(const QString& key, QVariant& val) void CImageObject::IAccumulateResult(const QString& key, QVariant& val)
{ {
if (NULL != m_pCoreCtrl) // if (NULL != m_pCoreCtrl)
{ // {
m_pCoreCtrl->AccumulateResult(key, val); // m_pCoreCtrl->AccumulateResult(key, val);
} // }
} }
void CImageObject::IMoveToFolder(const QString& szFolder) void CImageObject::IMoveToFolder(const QString& szFolder)
@ -242,7 +242,6 @@ void CImageObject::IVariantMapToUI(const QVariantMap& vMap)
{ {
lpCallBackFunc::instance()->m_ResultCallBackFunc(m_pCamImg->Serial(), vMap); lpCallBackFunc::instance()->m_ResultCallBackFunc(m_pCamImg->Serial(), vMap);
} }
//glpGuiCallback->IVariantMapToUI(m_pCamImg->Serial(), vMap);
} }
const ZStringA& CImageObject::ICameraSerial() const ZStringA& CImageObject::ICameraSerial()

@ -1,16 +1,16 @@
#ifndef IMAGEOBJECT_H #ifndef IMAGEOBJECT_H
#define IMAGEOBJECT_H #define IMAGEOBJECT_H
#include "globalCoreCtrl.h"
#include <QtGui/QPixmap> #include <QtGui/QPixmap>
#include "iAlgorithm.h" #include "iAlgorithm.h"
#include "lpCameraImage.h"
class CImageObject : public IImageObject class CImageObject : public IImageObject
{ {
public: public:
CImageObject(class CCoreCtrl* pCoreCtrl); CImageObject(class CCoreCtrl* pCoreCtrl);
~CImageObject(); ~CImageObject();
bool SetCameraImage(CZkCameraImage* pCamImage); bool SetCameraImage(lpCameraImage* pCamImage);
private: private:
virtual emTpColorFormat IColorFormat(); virtual emTpColorFormat IColorFormat();
//@nBytesPerLine: 0 means there is no valid value //@nBytesPerLine: 0 means there is no valid value
@ -42,7 +42,7 @@ private:
} }
virtual void IDataToComm(DATA_TO_COMM_HEAD& head, char* pData, int nLen) {}; virtual void IDataToComm(DATA_TO_COMM_HEAD& head, char* pData, int nLen) {};
private: private:
CZkCameraImage* m_pCamImg; lpCameraImage* m_pCamImg;
class CCoreCtrl* m_pCoreCtrl; class CCoreCtrl* m_pCoreCtrl;
}; };

@ -1,95 +0,0 @@
// #include "ModulesManager.h"
// #include "LoadModule.h"
// #include "globalCoreCtrl.h"
//
// #define EXTERN_LIB_FUNC(lib_name) \
// extern "C" void* lib_name##_Init(void* inParam);\
// extern "C" void lib_name##_Free();
//
// #ifndef MDL_CAMERA_USE_DLL
// EXTERN_LIB_FUNC(Lib_Camera)
// #endif
//
// #ifndef MDL_IMGPROC_USE_DLL
// EXTERN_LIB_FUNC(Lib_ImgProc)
// #endif
//
// #ifndef MDL_COMMUNICATE_USE_DLL
// EXTERN_LIB_FUNC(Lib_Communicate)
// #endif
//
// inline void* CModulesManager::getModule(const char* szLib, const char* szInit, const char* szFree, void* pInitParam /* = NULL */)
// {
// delModule(szLib);
// CLoadModule* pLib = new CLoadModule(szLib, szInit, szFree, gpGlobalData->tgdDllPath);
// return pLib->ModuleInit(pInitParam);
// }
//
// inline void CModulesManager::delModule(const char* szLib)
// {
// CLoadModule* pLib = m_mapLibs.value(szLib, NULL);
// if( NULL != pLib )
// {
// pLib->ModuleFree();
// delete pLib;
// m_mapLibs.remove(szLib);
// }
// }
//
// CModulesManager::CModulesManager(void)
// {
// }
//
//
// CModulesManager::~CModulesManager(void)
// {
// }
//
// int CModulesManager::LoadModules()
// {
// int nRet = 0;
// //load "tpCamera" modules
// void *pReturn = NULL;
// //Load camera library
// CAMERA_IN_PARAM camInParam;
// camInParam.pCallback = gpCoreCtrlGlobal;
// camInParam.pGlobalData = gpGlobalData;
//
// pReturn = Lib_Camera_Init(&camInParam);
//
// if( NULL == pReturn )
// {
// return (-nRet);
// }
//
// glpCameralPool = (ICameraPool*)pReturn;
// ++nRet;
// //Load imgproc library
// IMGPROC_IN_PARAM imgprocInParam;
// imgprocInParam.pGlobalData = gpGlobalData;
//
// pReturn = Lib_ImgProc_Init(&imgprocInParam);
//
// if( NULL == pReturn )
// {
// return (-nRet);
// }
// glpImgProc = (IImgProc*)pReturn;
// ++nRet;
//
// return nRet;
// }
//
// void CModulesManager::FreeModules()
// {
// #ifdef MDL_IMGPROC_USE_DLL
// delModule("tpImgProc");
// #else
// Lib_ImgProc_Free();
// #endif
// #ifdef MDL_CAMERA_USE_DLL
// delModule("tpCamera");
// #else
// Lib_Camera_Free();
// #endif
// }

@ -1,22 +0,0 @@
// #ifndef __MODULES_MANAGER_H
// #define __MODULES_MANAGER_H
//
// #include "icamera.h"
// #include "iCoreCtrl.h"
// #include <QtCore/QMap>
//
// class CModulesManager
// {
// public:
// CModulesManager(void);
// ~CModulesManager(void);
// int LoadModules();
// void FreeModules();
// private:
// inline void* getModule(const char* szLib, const char* szInit, const char* szFree, void* pInitParam = NULL);
// inline void delModule(const char* szLib);
// private:
// QMap<QString, class CLoadModule*> m_mapLibs;
// };
//
// #endif

@ -1,31 +0,0 @@
#include "QZkShowImage.h"
#include "ZkCameraImage.h"
QZkShowImage::QZkShowImage()
{
}
QZkShowImage::~QZkShowImage()
{
}
void QZkShowImage::SetShowImage(class CZkCameraImage* pImg)
{
m_showImage = pImg->ToShowImage();
//test
// int depts = m_showImage.depth();
//
m_nFrameNum = pImg->FrameNumber();
}
void QZkShowImage::DrawToPainter(QPainter *painter, QRect* rt)
{
#ifdef USE_PIXMAP_AS_SHOW
painter->drawPixmap(*rt, m_showImage);
#else ZShowImage == QImage
painter->drawImage(*rt, m_showImage);
#endif
painter->drawText(25, 25, QString::number(m_nFrameNum));
}

@ -1,22 +0,0 @@
#ifndef QZKSHOWIMAGE_H
#define QZKSHOWIMAGE_H
#include <QtGui/QPixmap>
#include <QtGui/QPainter>
#include "baseDefine.h"
class QZkShowImage
{
public:
QZkShowImage();
~QZkShowImage();
void SetShowImage(class CZkCameraImage* pImg);
void DrawToPainter(QPainter *painter, QRect* rt);
private:
ZShowImage m_showImage;
long m_nFrameNum;
};
#endif // QZKSHOWIMAGE_H

@ -1,65 +0,0 @@
#include "ZkImage.h"
CZkImage::CZkImage()
{
m_pColorBuffer = NULL;
m_nbuffLen = 0;
m_nWidth = 0;
m_nHeight = 0;
}
CZkImage::CZkImage(int nW, int nH, int nBits)
{
CZkImage();
allocBuffer(nW, nH, nBits);
}
CZkImage::~CZkImage()
{
freeBuffer();
}
bool CZkImage::allocBuffer(int nW, int nH, int nBits)
{
SELF_ABS(nW);
SELF_ABS(nH);
SELF_ABS(nBits);
int nLen = (nW * nH * nBits + 7) / 8;
if( 0 == nLen )
{
return false;
}
if( NULL == m_pColorBuffer || nLen != m_nbuffLen )
{
freeBuffer();
m_pColorBuffer = new BYTE[nLen];
if( NULL == m_pColorBuffer )
{
return false;
}
m_nbuffLen = nLen;
}
m_nWidth = nW;
m_nHeight = nH;
m_nBitsPerPixel = nBits;
return true;
}
void CZkImage::freeBuffer()
{
if( NULL != m_pColorBuffer )
{
delete m_pColorBuffer;
m_pColorBuffer = NULL;
}
}
bool CZkImage::Copy(const BYTE* pData, int nW, int nH, int nBits)
{
if( !allocBuffer(nW, nH, nBits) )
{
return false;
}
std::memcpy(m_pColorBuffer, pData, m_nbuffLen);
return true;
}

@ -1,33 +0,0 @@
#ifndef ZKIMAGE_H
#define ZKIMAGE_H
#include "baseDefine.h"
class CZkImage
{
public:
CZkImage();
CZkImage(int nW, int nH, int nBits);
virtual ~CZkImage();
bool Copy(const BYTE* pData, int nW, int nH, int nBits);
int width() { return m_nWidth; }
int height() { return m_nHeight; }
int bitsPerPixle() {
return m_nBitsPerPixel;
}
BYTE* bits() { return m_pColorBuffer; }
int buffLen() { return m_nbuffLen; }
private:
bool allocBuffer(int nW, int nH, int nBits);
void freeBuffer();
private:
BYTE* m_pColorBuffer;
int m_nbuffLen;
int m_nWidth;
int m_nHeight;
int m_nBitsPerPixel;
};
#endif // ZKIMAGE_H

@ -1,36 +0,0 @@
#include "globalCoreCtrl.h"
#include "QZkJsonParser.h"
void CGlobalCoreCtrl::readCoreCtrlCfg()
{
//read config from ".json" file
QString szFileName(m_pGlobalData->tgdMainPath);
szFileName.append(m_pGlobalData->tgdFolderNames[TP_FOLDER_NAME_CONFIG]).append("corectrl").append(TP_STR::cszJsonSuffix);
QJsonObject objJson = QZkJsonParser::ReadJsonObject(szFileName);
if (objJson.isEmpty())
{
return;
}
//core_setting
QJsonObject objTmp = objJson["core_setting"].toObject();
m_coreSetting.threadsCount = objTmp.value("image_threads").toInt(0);
m_coreSetting.imageShowType = objTmp.value("show_type").toInt(TP_IMAGE_SHOW_NO);
}
QVariant CGlobalCoreCtrl::IGetVariantById(int nId)
{
if (!m_pGuiCallback){
qCritical("m_pGuiCallback is null in CGlobalCoreCtrl::IGetVariantById.");
return QVariant();
}
return m_pGuiCallback->IGetVariantById(nId);
}
void CGlobalCoreCtrl::INewCameraImage(const QVariantMap& vmap)
{
if (!m_pGuiCallback){
qCritical("m_pGuiCallback is null in CGlobalCoreCtrl::IGetVariantById.");
return;
}
m_pGuiCallback->INewCameraImage(vmap);
}

@ -1,58 +0,0 @@
#ifndef __GLOBAL_CORE_CTRL_H
#define __GLOBAL_CORE_CTRL_H
#include "baseInclude.h"
#include "icamera.h"
#include "iCoreCtrl.h"
#include "iImgProc.h"
#include "GlobalDataBase.h"
#ifdef _USE_SPIDER_LOG
#include "logSpider.h"
#define CORE_CTRL_INIT(a, b) SPIDER_LOG_INIT(a, b)
#define CORE_CTRL_LOG(value) SPIDER_LOG_STRING("corectrl", value)
#define CORE_CTRL_FREE() SPIDER_LOG_FREE()
#else
#define CORE_CTRL_INIT(a, b)
#define CORE_CTRL_LOG(value) tpDebugOut(value)
#define CORE_CTRL_FREE()
#endif
class CGlobalCoreCtrl : public ICameraCallback
{
public:
CGlobalCoreCtrl(const CORE_CTRL_IN_PARAM* pParam){
m_pCameraPool = NULL;
m_pImageProc = NULL;
m_pGlobalData = pParam->pGlobalData;
readCoreCtrlCfg();
}
~CGlobalCoreCtrl() {}
void AddCameraPool(ICameraPool* pCameraPool) { m_pCameraPool = pCameraPool; }
private:
void readCoreCtrlCfg();
virtual QVariant IGetVariantById(int nId);
virtual void INewCameraImage(const QVariantMap& vmap);
public:
TP_GLOBAL_DATA* m_pGlobalData;
TP_CORE_SETTING m_coreSetting;
ICameraPool* m_pCameraPool;
IImgProc* m_pImageProc;
};
// extern CGlobalCoreCtrl* gpData;
//
// #define gpCoreCtrlGlobal gpData
//
// #define gpGlobalData ((TP_GLOBAL_DATA*)(gpData->m_pGlobalData))
// #define gCoreSetting gpData->m_coreSetting
// #define glpCameralPool gpData->m_pCameraPool
// #define glpGuiCallback gpData->m_pGuiCallback
// #define gfcbGuiSetImage(...) if( NULL != glpGuiCallback ) glpGuiCallback->ISetCameraImage(__VA_ARGS__)
// #define gGuiCallback_FuncCall(fun, ...) if( NULL != glpGuiCallback ) glpGuiCallback->##fun##(__VA_ARGS__)
//
// #define glpImgProc gpData->m_pImageProc
#endif

@ -266,7 +266,7 @@ private:
ICameraObject* m_pRelyOnCam; ICameraObject* m_pRelyOnCam;
QZkMutexList<ICameraObject*> m_listReliedBy; QZkMutexList<ICameraObject*> m_listReliedBy;
bool m_bIsCallback; bool m_bIsCallback;
friend class CZkCameraImage; friend class lpCameraImage;
friend class CCameraPool; friend class CCameraPool;
friend class CLibCameraes; friend class CLibCameraes;
}; };

@ -1,6 +1,6 @@
#include "ZkCameraImage.h" #include "lpCameraImage.h"
CZkCameraImage::CZkCameraImage() lpCameraImage::lpCameraImage()
{ {
m_nId = 0; m_nId = 0;
m_nFrameNum = 0; m_nFrameNum = 0;
@ -12,7 +12,7 @@ CZkCameraImage::CZkCameraImage()
m_nTimeStamp = QDateTime::currentDateTime().toMSecsSinceEpoch(); m_nTimeStamp = QDateTime::currentDateTime().toMSecsSinceEpoch();
} }
CZkCameraImage::~CZkCameraImage() lpCameraImage::~lpCameraImage()
{ {
if (NULL != m_pImage) if (NULL != m_pImage)
{ {
@ -20,7 +20,7 @@ CZkCameraImage::~CZkCameraImage()
} }
} }
int CZkCameraImage::CopyCameraObject(ICameraObject* pCamObj) int lpCameraImage::CopyCameraObject(ICameraObject* pCamObj)
{ {
// SetColorFormat(pCamObj->ColorFormat()); // SetColorFormat(pCamObj->ColorFormat());
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt) if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
@ -73,7 +73,7 @@ int CZkCameraImage::CopyCameraObject(ICameraObject* pCamObj)
} }
} }
int CZkCameraImage::CopyCameraObject2(ICameraObject* pCamObj) int lpCameraImage::CopyCameraObject2(ICameraObject* pCamObj)
{ {
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt) if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
{ {
@ -135,7 +135,7 @@ bool CZkCameraImage::CopyQImage(const QImage& image)
} }
*/ */
ZShowImage CZkCameraImage::ToShowImage(int nShowW /* = 0 */, int nShowH /* = 0 */) ZShowImage lpCameraImage::ToShowImage(int nShowW /* = 0 */, int nShowH /* = 0 */)
{ {
if (NULL == m_pImage) if (NULL == m_pImage)
{ {
@ -181,7 +181,7 @@ ZShowImage CZkCameraImage::ToShowImage(int nShowW /* = 0 */, int nShowH /* = 0 *
#endif #endif
} }
QImage CZkCameraImage::ToQImage() QImage lpCameraImage::ToQImage()
{ {
if (NULL == m_pImage) if (NULL == m_pImage)
{ {
@ -202,7 +202,7 @@ colorFmt.append(clr1.rgb());
return *m_pImage; return *m_pImage;
} }
QImage::Format CZkCameraImage::ToQImageFormat(emTpColorFormat colorFormat) QImage::Format lpCameraImage::ToQImageFormat(emTpColorFormat colorFormat)
{ {
if (TP_COLOR_RGB32 == colorFormat || if (TP_COLOR_RGB32 == colorFormat ||
TP_COLOR_BGR32 == colorFormat) TP_COLOR_BGR32 == colorFormat)
@ -232,7 +232,7 @@ QImage::Format CZkCameraImage::ToQImageFormat(emTpColorFormat colorFormat)
} }
} }
emTpColorFormat CZkCameraImage::FromQImageFormat(const QImage &image) emTpColorFormat lpCameraImage::FromQImageFormat(const QImage &image)
{ {
if (QImage::Format_RGB32 == image.format()) if (QImage::Format_RGB32 == image.format())
{ {
@ -256,7 +256,7 @@ emTpColorFormat CZkCameraImage::FromQImageFormat(const QImage &image)
} }
} }
emTpColorFormat CZkCameraImage::FromString(const QString& strColor) emTpColorFormat lpCameraImage::FromString(const QString& strColor)
{ {
if ("RGB32" == strColor) if ("RGB32" == strColor)
{ {
@ -289,7 +289,7 @@ emTpColorFormat CZkCameraImage::FromString(const QString& strColor)
} }
BYTE* CZkCameraImage::ImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nOutBytesPerLine) BYTE* lpCameraImage::ImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nOutBytesPerLine)
{ {
if (!m_pImage || m_pImage->isNull()) { if (!m_pImage || m_pImage->isNull()) {
return NULL; return NULL;
@ -309,7 +309,7 @@ BYTE* CZkCameraImage::ImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, i
return m_pImage->bits(); return m_pImage->bits();
} }
bool CZkCameraImage::SaveToFile() bool lpCameraImage::SaveToFile()
{ {
if (NULL != m_pImage) if (NULL != m_pImage)
{ {

@ -3,17 +3,16 @@
#include "baseDefine.h" #include "baseDefine.h"
#include "baseStruct.h" #include "baseStruct.h"
#include "ZkImage.h"
#include "iCameraObject.h" #include "iCameraObject.h"
#define QIMAGE_FUNC_KEY "bool_func" #define QIMAGE_FUNC_KEY "bool_func"
#define QIMAGE_FUNC_VALUE "func_true" #define QIMAGE_FUNC_VALUE "func_true"
class CZkCameraImage class lpCameraImage
{ {
public: public:
CZkCameraImage(); lpCameraImage();
~CZkCameraImage(); ~lpCameraImage();
int CopyCameraObject(ICameraObject* pCamObj); int CopyCameraObject(ICameraObject* pCamObj);
int CopyCameraObject2(ICameraObject* pCamObj);//no combine and maybe use QImage int CopyCameraObject2(ICameraObject* pCamObj);//no combine and maybe use QImage

@ -0,0 +1,54 @@
#include "lpThread.h"
lpThread::lpThread(QObject *parent) : QThread(parent)
{
}
lpThread::lpThread(TaskFunc func, QObject *parent /*= nullptr*/): QThread(parent)
{
_func = func;
m_bIsRunning = false;
m_bRunSignal = false;
}
lpThread::~lpThread()
{
}
void lpThread::StartThread()
{
if( !m_bIsRunning )
{
m_bRunSignal = true;
m_bIsRunning = true;
start();
}
}
void lpThread::EndThread()
{
m_bRunSignal = false;
wait();
// quit();
// while(m_bIsRunning )
// {
// QThread::msleep(25);
// }
}
void lpThread::run()
{
m_bIsRunning = true;
while( m_bRunSignal )
{
bool bFlag = false;
if (_func)
bFlag = _func();
if (bFlag == false)
msleep(25);
//... wait signal or condition
}
m_bIsRunning = false;
}

@ -4,11 +4,14 @@
#include "baseInclude.h" #include "baseInclude.h"
#include <QtCore/QThread> #include <QtCore/QThread>
class QTpThreadBase : public QThread #include <functional>
typedef std::function<bool(void)> TaskFunc;
class lpThread : public QThread
{ {
public: public:
QTpThreadBase(QObject *parent); lpThread(QObject *parent = nullptr);
~QTpThreadBase(); lpThread(TaskFunc func,QObject *parent = nullptr);
~lpThread();
void StartThread(); void StartThread();
void EndThread(); void EndThread();
@ -19,6 +22,8 @@ private:
private: private:
bool m_bRunSignal; bool m_bRunSignal;
bool m_bIsRunning; bool m_bIsRunning;
private:
TaskFunc _func;
}; };
#endif // QTPTHREADBASE_H #endif // QTPTHREADBASE_H

@ -1,47 +0,0 @@
#include "qtpthreadbase.h"
QTpThreadBase::QTpThreadBase(QObject *parent)
: QThread(parent)
{
m_bIsRunning = false;
m_bRunSignal = false;
}
QTpThreadBase::~QTpThreadBase()
{
}
void QTpThreadBase::StartThread()
{
if( !m_bIsRunning )
{
m_bRunSignal = true;
m_bIsRunning = true;
start();
}
}
void QTpThreadBase::EndThread()
{
m_bRunSignal = false;
while(m_bIsRunning )
{
QThread::msleep(25);
}
}
void QTpThreadBase::run()
{
m_bIsRunning = true;
while( m_bRunSignal )
{
if( !loop() )
{
break;
}
//... wait signal or condition
}
m_bIsRunning = false;
}

@ -1,69 +0,0 @@
#include "qtpthreadimage.h"
#include "globalCoreCtrl.h"
#include "CoreCtrl.h"
#include <QDebug>
QTpThreadImage::QTpThreadImage(class CCoreCtrl* pCtrl, class IDetectorEngine* pDE /*= NULL*/,QObject *parent /* = NULL */)
: QTpThreadBase(parent)
, m_pCoreCtrl(pCtrl)
, m_objImage(pCtrl)
, m_pDE(pDE)
{
}
QTpThreadImage::~QTpThreadImage()
{
LOG_SPIDER::FreeLog();
}
bool QTpThreadImage::loop()
{
QTime timespan;
timespan.start();
CZkCameraImage* pCamImage = m_pCoreCtrl->m_gpCameraPool->IPopCameraImage();
int span = timespan.elapsed();
if (span > 100)
{
qWarning() << "Pop image from poll cost " << span << " MSecs"
<< " - " __FUNCTION__;
}
if( NULL != pCamImage )
{
{
// send image to UI
timespan.restart();
//TODO show Image
// m_pCoreCtrl->ShowCameraImage(pCamImage->Serial()
// , pCamImage->FrameNumber()
// , pCamImage->ToQImage()
// , pCamImage->Stamp()
// , 0
// , QString::fromUtf8(pCamImage->FileName()));//(pCamImage);
//
// qDebug() << "Show camera image to UI cost " << timespan.elapsed() << " MSecs"
// << " - " __FUNCTION__;
}
{
// Algorithm process image
timespan.restart();
m_objImage.SetCameraImage(pCamImage);
m_pCoreCtrl->m_gpImgProc->IImageProcess(&m_objImage, m_pDE);
qDebug() << "Process Image(ID:" << pCamImage->FrameNumber()
<< ") cost " << timespan.elapsed() << " MSecs"
<< " - " __FUNCTION__;
}
//release CameraImage
m_objImage.SetCameraImage(NULL);
m_pCoreCtrl->m_gpCameraPool->IFreeCameraImage(pCamImage);
}
else
{
QTpThreadBase::loop();
}
return true;
}

@ -1,21 +0,0 @@
#ifndef QTPTHREADIMAGE_H
#define QTPTHREADIMAGE_H
#include "qtpthreadbase.h"
#include "ImageObject.h"
#include "LogBySpider.h"
class QTpThreadImage : public QTpThreadBase
{
public:
QTpThreadImage(class CCoreCtrl* pCtrl, class IDetectorEngine* pDE = NULL ,QObject *parent = NULL);
~QTpThreadImage();
private:
virtual bool loop();
private:
class CCoreCtrl* m_pCoreCtrl;
class IDetectorEngine* m_pDE;
CImageObject m_objImage;
};
#endif // QTPTHREADIMAGE_H

@ -1,10 +1,10 @@
#include "CameraPool.h" #include "CameraPool.h"
#include <QDebug> #include <QDebug>
#include "callbackFunc.h" #include "callbackFunc.h"
#include "lpCameraConfig.h"
CCameraPool::CCameraPool(void) CCameraPool::CCameraPool(void)
: m_thdTrigger(this) : m_libs("")
, m_libs("")
{ {
m_nTriggerMode = DEV_TRIGGER_MODE_STOP; m_nTriggerMode = DEV_TRIGGER_MODE_STOP;
m_nFrameRate = 0; m_nFrameRate = 0;
@ -19,27 +19,27 @@ CCameraPool::~CCameraPool(void)
int CCameraPool::InitPool() int CCameraPool::InitPool()
{ {
int nRet = 0;//IOpenDevices(true); int nRet = 0;//IOpenDevices(true);
m_thdTrigger.StartTrigger(); // m_thdTrigger.StartTrigger();
return nRet; return nRet;
} }
void CCameraPool::FreePool() void CCameraPool::FreePool()
{ {
m_thdTrigger.EndTrigger(); // m_thdTrigger.EndTrigger();
ICloseDevices(); ICloseDevices();
IDeleteDameraes(); IDeleteDameraes();
} }
int CCameraPool::ICreateCameraes() int CCameraPool::ICreateCameraes()
{ {
QList<QString> keys;// = gpGlobalCamera->CameraKeys();//cameraes.keys(); QList<QString> keys = lpCameraConfig::instance()->CameraKeys();
for (int i = 0; i < keys.size(); ++i) for (int i = 0; i < keys.size(); ++i)
{ {
if (m_cameraes.contains(keys[i])) if (m_cameraes.contains(keys[i]))
{ {
continue; continue;
} }
ICameraObject* pObject;// = m_libs.Create(gpGlobalCamera->CameraOption(keys[i]), this); ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->CameraOption(keys[i]), this);
if (NULL == pObject) if (NULL == pObject)
{ {
continue; continue;
@ -119,7 +119,7 @@ bool CCameraPool::IDeleteCamera(const QString& strSerial)
m_libs.Delete(pCamera); m_libs.Delete(pCamera);
} }
m_cameraes.remove(strSerial); m_cameraes.remove(strSerial);
// gpGlobalCamera->delCameraOption(strSerial); lpCameraConfig::instance()->delCameraOption(strSerial);
return true; return true;
} }
@ -132,10 +132,10 @@ bool CCameraPool::IAddCamera(const QString& strName, const TP_CAMERA_OPTION& cam
if (!bret) return bret; if (!bret) return bret;
} }
//gpGlobalCamera->updateCameraOption(strName, camOpt); lpCameraConfig::instance()->updateCameraOption(strName, camOpt);
if (bNew){ if (bNew){
ICameraObject* pCamObj;// = m_libs.Create(gpGlobalCamera->CameraOption(strName), this); ICameraObject* pCamObj = m_libs.Create(lpCameraConfig::instance()->CameraOption(strName), this);
if (pCamObj) if (pCamObj)
{ {
pCamObj->m_pCamOpt->status = TP_CAMERA_STATUS_INITED; pCamObj->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
@ -329,27 +329,27 @@ void CCameraPool::DeviceLost(const QString& strName)
QList<QString> CCameraPool::ICameraKeys() QList<QString> CCameraPool::ICameraKeys()
{ {
return QList<QString>();// gpGlobalCamera->CameraKeys(); return lpCameraConfig::instance()->CameraKeys();
} }
QList<QString> CCameraPool::ICameraKeysOrderByIds() QList<QString> CCameraPool::ICameraKeysOrderByIds()
{ {
return QList<QString>();// gpGlobalCamera->CameraKeysOrderByIds(); return lpCameraConfig::instance()->CameraKeysOrderByIds();
} }
bool CCameraPool::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt) bool CCameraPool::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{ {
return false;// gpGlobalCamera->CameraOption(strSerial, camOpt); return lpCameraConfig::instance()->CameraOption(strSerial, camOpt);
} }
bool CCameraPool::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt) bool CCameraPool::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{ {
return false;//gpGlobalCamera->CameraOptionByKey(strSerial, camOpt); return lpCameraConfig::instance()->CameraOptionByKey(strSerial, camOpt);
} }
bool CCameraPool::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt) bool CCameraPool::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
{ {
bool bRet = false;//gpGlobalCamera->SetCameraOption(strSerial, camOpt); bool bRet = lpCameraConfig::instance()->SetCameraOption(strSerial, camOpt);
if (bRet) if (bRet)
{ {
ICameraObject* pCam = m_cameraes.value(strSerial, NULL); ICameraObject* pCam = m_cameraes.value(strSerial, NULL);
@ -397,19 +397,19 @@ void CCameraPool::ISetTriggerMode(emTpDeviceTriggerMode mode, emTpTriggerDirecti
// m_thdTrigger.LockWorked(); // m_thdTrigger.LockWorked();
// m_cameraes.iterateCall(cameraSetTriggerMode, &gGlobalPoolOption); // m_cameraes.iterateCall(cameraSetTriggerMode, &gGlobalPoolOption);
IStartDevices(); IStartDevices();
m_thdTrigger.UnlockWorked(); // m_thdTrigger.UnlockWorked();
//begin or end trigger's thread //begin or end trigger's thread
if( DEV_TRIGGER_MODE_AUTO != mode && if( DEV_TRIGGER_MODE_AUTO != mode &&
DEV_TRIGGER_MODE_FIXED_AUTO != mode ) DEV_TRIGGER_MODE_FIXED_AUTO != mode )
{ {
//m_thdTrigger.EndThread(); //m_thdTrigger.EndThread();
m_thdTrigger.SetAutoTrigger(false); // m_thdTrigger.SetAutoTrigger(false);
} }
else else
{ {
m_thdTrigger.SetFrame(nFrameRate); // m_thdTrigger.SetFrame(nFrameRate);
//m_thdTrigger.StartTrigger(); //m_thdTrigger.StartTrigger();
m_thdTrigger.SetAutoTrigger(true); // m_thdTrigger.SetAutoTrigger(true);
} }
} }
@ -515,7 +515,7 @@ void CCameraPool::cameraSetProperty(class ICameraObject*& pCam, void* pData)
pCam->ISetProperty((TP_CAMERA_PROPERTY*)pData); pCam->ISetProperty((TP_CAMERA_PROPERTY*)pData);
} }
CZkCameraImage* CCameraPool::IPopCameraImage() lpCameraImage* CCameraPool::IPopCameraImage()
{ {
return m_imagesList.takeFirst(NULL); return m_imagesList.takeFirst(NULL);
} }
@ -523,14 +523,14 @@ CZkCameraImage* CCameraPool::IPopCameraImage()
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
int CCameraPool::createDeviceByOptiones() int CCameraPool::createDeviceByOptiones()
{ {
QList<QString> keys;// = gpGlobalCamera->CameraKeys();//cameraes.keys(); QList<QString> keys = lpCameraConfig::instance()->CameraKeys();
for( int i = 0; i < keys.size(); ++i ) for( int i = 0; i < keys.size(); ++i )
{ {
if( m_cameraes.contains(keys[i]) ) if( m_cameraes.contains(keys[i]) )
{ {
continue; continue;
} }
ICameraObject* pObject;// = m_libs.Create(gpGlobalCamera->CameraOption(keys[i]), this); ICameraObject* pObject = m_libs.Create(lpCameraConfig::instance()->CameraOption(keys[i]), this);
if( NULL == pObject ) if( NULL == pObject )
{ {
continue; continue;
@ -669,10 +669,10 @@ int CCameraPool::IPushCameraData(ICameraObject* pCamObj)
// //
pCamObj->SaveToFile(); pCamObj->SaveToFile();
CZkCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL); lpCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL);
if (NULL == pImage) if (NULL == pImage)
{ {
pImage = new CZkCameraImage(); pImage = new lpCameraImage();
} }
int nRet = 0; int nRet = 0;
if (NULL != pImage) if (NULL != pImage)
@ -764,7 +764,7 @@ int CCameraPool::IPushCameraData2(ICameraObject* pCamObj)
// //
pCamObj->SaveToFile(); pCamObj->SaveToFile();
// //
CZkCameraImage* pImage = new CZkCameraImage(); lpCameraImage* pImage = new lpCameraImage();
if (NULL == pImage) if (NULL == pImage)
{ {
return 0; return 0;
@ -794,14 +794,14 @@ char* CCameraPool::IGetMainPath()
{ {
return nullptr;// gpGlobalCamera->m_pGlobalData->tgdMainPath; return nullptr;// gpGlobalCamera->m_pGlobalData->tgdMainPath;
} }
void CCameraPool::IFreeCameraImage(CZkCameraImage *pCamImg) void CCameraPool::IFreeCameraImage(lpCameraImage *pCamImg)
{ {
delete pCamImg; delete pCamImg;
} }
QMap<QString, QString> CCameraPool::IGetCamShowNames() QMap<QString, QString> CCameraPool::IGetCamShowNames()
{ {
return QMap<QString, QString>();// gpGlobalCamera->GetCamShowNames(); return lpCameraConfig::instance()->GetCamShowNames();
} }
void CCameraPool::ISetCameraEncode(INT64 code, INT64 rate) void CCameraPool::ISetCameraEncode(INT64 code, INT64 rate)

@ -64,11 +64,11 @@ private:
virtual void ISnapImage(const QStringList& camKeys); virtual void ISnapImage(const QStringList& camKeys);
virtual void ISendSoftTrigger(const QStringList& camKeys); virtual void ISendSoftTrigger(const QStringList& camKeys);
// virtual QList<TP_CAMERA_WIN*> ICameraWins(); // virtual QList<TP_CAMERA_WIN*> ICameraWins();
virtual CZkCameraImage* IPopCameraImage(); virtual lpCameraImage* IPopCameraImage();
virtual int ICameraImages() { virtual int ICameraImages() {
return m_imagesList.size(); return m_imagesList.size();
} }
virtual void IFreeCameraImage(CZkCameraImage *pCamImg); virtual void IFreeCameraImage(lpCameraImage *pCamImg);
/////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////
virtual void ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue); virtual void ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue);
virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property); virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property);
@ -86,7 +86,7 @@ private:
m_imagesList.clear(iterateCallImageErase, NULL); m_imagesList.clear(iterateCallImageErase, NULL);
m_imagesMerging.clear(iterateCallImageErase, NULL); m_imagesMerging.clear(iterateCallImageErase, NULL);
} }
static void iterateCallImageErase(class CZkCameraImage*& pImage, void* pData) { static void iterateCallImageErase(class lpCameraImage*& pImage, void* pData) {
delete pImage; delete pImage;
} }
//using class ICameraObject //using class ICameraObject
@ -114,9 +114,9 @@ private:
static void camerasPausePush(class ICameraObject*& pCam, void* pData); static void camerasPausePush(class ICameraObject*& pCam, void* pData);
private: private:
//**the key is unique name, not serial number** //**the key is unique name, not serial number**
QZkMutexMap<QString, CZkCameraImage*> m_imagesMerging; QZkMutexMap<QString, lpCameraImage*> m_imagesMerging;
QZkMutexList<CZkCameraImage*> m_imagesList; QZkMutexList<lpCameraImage*> m_imagesList;
CTriggerThread m_thdTrigger; //CTriggerThread m_thdTrigger;
emTpDeviceTriggerMode m_nTriggerMode; emTpDeviceTriggerMode m_nTriggerMode;
long m_nFrameRate; long m_nFrameRate;
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////

@ -1,29 +1,23 @@
#include <QDir> #include <QDir>
#include "globalCamera.h" #include "lpCameraConfig.h"
#include "ZkCameraImage.h"
#include <QReadWriteLock> #include <QReadWriteLock>
#include <QCoreApplication> #include <QCoreApplication>
const char lpCameraConfig::cs_szCfgName[] = "camera";
const char CGlobalCamera::cs_szCfgName[] = "camera"; lpCameraConfig::lpCameraConfig()
CGlobalCamera::CGlobalCamera(const CAMERA_IN_PARAM* pInParam)
:m_mtxCam(QMutex::Recursive)
{ {
m_pCallback = pInParam->pCallback;
m_pGlobalData = pInParam->pGlobalData;
readConfig(); readConfig();
readSerials();
} }
CGlobalCamera::~CGlobalCamera() lpCameraConfig::~lpCameraConfig()
{ {
releaseConfig(); releaseConfig();
} }
bool CGlobalCamera::CameraOption(const QString& serials, TP_CAMERA_OPTION& camOpt) bool lpCameraConfig::CameraOption(const QString& serials, TP_CAMERA_OPTION& camOpt)
{ {
// camOpt.serials = serials; // camOpt.serials = serials;
return m_cameraesOption.iterateCall(copyCameraOptionBySerial, &camOpt); return m_cameraesOption.iterateCall(copyCameraOptionBySerial, &camOpt);
} }
bool CGlobalCamera::copyCameraOptionBySerial(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData) bool lpCameraConfig::copyCameraOptionBySerial(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData)
{ {
TP_CAMERA_OPTION* pDes = (TP_CAMERA_OPTION*)pData; TP_CAMERA_OPTION* pDes = (TP_CAMERA_OPTION*)pData;
if (pCamOpt->uniqueName == pDes->uniqueName) if (pCamOpt->uniqueName == pDes->uniqueName)
@ -34,18 +28,18 @@ bool CGlobalCamera::copyCameraOptionBySerial(const QString& key, TP_CAMERA_OPTIO
return false; return false;
} }
bool CGlobalCamera::CameraOptionByKey(const QString& sKey, TP_CAMERA_OPTION& camOpt) bool lpCameraConfig::CameraOptionByKey(const QString& sKey, TP_CAMERA_OPTION& camOpt)
{ {
return m_cameraesOption.valueCall(sKey, copyCameraOptionByKey, &camOpt); return m_cameraesOption.valueCall(sKey, copyCameraOptionByKey, &camOpt);
} }
void CGlobalCamera::copyCameraOptionByKey(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData) void lpCameraConfig::copyCameraOptionByKey(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData)
{ {
TP_CAMERA_OPTION* pDes = (TP_CAMERA_OPTION*)pData; TP_CAMERA_OPTION* pDes = (TP_CAMERA_OPTION*)pData;
*pDes = *pCamOpt; *pDes = *pCamOpt;
} }
bool CGlobalCamera::SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION& camOpt) bool lpCameraConfig::SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION& camOpt)
{ {
TP_CAMERA_OPTION* pOpt = m_cameraesOption.value(sKey, NULL); TP_CAMERA_OPTION* pOpt = m_cameraesOption.value(sKey, NULL);
if (NULL == pOpt) if (NULL == pOpt)
@ -64,7 +58,7 @@ bool CGlobalCamera::SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION&
return true; return true;
} }
bool CGlobalCamera::SaveCameraOption(const TP_CAMERA_OPTION& camOpt) bool lpCameraConfig::SaveCameraOption(const TP_CAMERA_OPTION& camOpt)
{ {
QJsonObject jsonDevices = m_jsonCamera.value("devices").toObject(); QJsonObject jsonDevices = m_jsonCamera.value("devices").toObject();
if (jsonDevices.isEmpty()) if (jsonDevices.isEmpty())
@ -84,14 +78,13 @@ bool CGlobalCamera::SaveCameraOption(const TP_CAMERA_OPTION& camOpt)
return true; return true;
} }
void CGlobalCamera::readConfig() void lpCameraConfig::readConfig()
{ {
int nError; int nError;
//read config from ".json" file //read config from ".json" file
QString szFileName(""/*m_pGlobalData->tgdMainPath*/); QString szFileName(""/*m_pGlobalData->tgdMainPath*/);
szFileName.append("./config/"/*m_pGlobalData->tgdFolderNames[TP_FOLDER_NAME_CONFIG]*/).append(cs_szCfgName).append(TP_STR::cszJsonSuffix); szFileName.append("./config/"/*m_pGlobalData->tgdFolderNames[TP_FOLDER_NAME_CONFIG]*/).append(cs_szCfgName).append(TP_STR::cszJsonSuffix);
// szFileName.append(TP_STR::cszCfgFolder) // szFileName.append(TP_STR::cszCfgFolder)
QMutexLocker locker(&m_mtxCam);
QJsonObject objJson = m_jsonCamera = QZkJsonParser::ReadJsonObject(szFileName, &nError); QJsonObject objJson = m_jsonCamera = QZkJsonParser::ReadJsonObject(szFileName, &nError);
tpDebugOut("camera.json paths: %s", szFileName.toLocal8Bit().data()); tpDebugOut("camera.json paths: %s", szFileName.toLocal8Bit().data());
tpDebugOut("read camera.json result: %d", nError); tpDebugOut("read camera.json result: %d", nError);
@ -108,13 +101,7 @@ void CGlobalCamera::readConfig()
// //
QJsonValue value = objJson["devices"]; QJsonValue value = objJson["devices"];
QJsonObject userJson = getAppJsonUser();
QJsonArray objEnableCameras = userJson["enable_cameras"].toArray();
QStringList enableCamList;
for (int i = 0; i < objEnableCameras.size(); ++i)
{
enableCamList.append(objEnableCameras[i].toString());
}
if (!value.isUndefined() && value.isObject()) if (!value.isUndefined() && value.isObject())
{ {
QJsonObject objDevices = value.toObject(); QJsonObject objDevices = value.toObject();
@ -145,7 +132,7 @@ void CGlobalCamera::readConfig()
QJsonValue tempV = objCam.value("format"); QJsonValue tempV = objCam.value("format");
if (tempV.isString()) if (tempV.isString())
{ {
pCamOpt->format = CZkCameraImage::FromString(tempV.toString()); pCamOpt->format = lpCameraImage::FromString(tempV.toString());
} }
else else
{ {
@ -188,9 +175,6 @@ void CGlobalCamera::readConfig()
pCamOpt->macAddress = objCam.value("mac_address").toString(); pCamOpt->macAddress = objCam.value("mac_address").toString();
pCamOpt->bAutoPush = objCam.value("auto_push").toInt(1); pCamOpt->bAutoPush = objCam.value("auto_push").toInt(1);
pCamOpt->bAutoOpen = objCam.value("auto_open").toBool(true); pCamOpt->bAutoOpen = objCam.value("auto_open").toBool(true);
if (!enableCamList.contains(it.key())){
pCamOpt->bAutoOpen = false;
}
pCamOpt->cameraFilePath = objCam.value("camera_file").toString(); pCamOpt->cameraFilePath = objCam.value("camera_file").toString();
if (objCam.value("algorithm_dll").toDouble()) if (objCam.value("algorithm_dll").toDouble())
@ -209,11 +193,11 @@ void CGlobalCamera::readConfig()
} }
} }
void CGlobalCamera::checkFolder(QString& sFolder) void lpCameraConfig::checkFolder(QString& sFolder)
{ {
if (sFolder.startsWith(".\\")) if (sFolder.startsWith(".\\"))
{ {
sFolder.replace(".\\", m_pGlobalData->tgdMainPath); //sFolder.replace(".\\", m_pGlobalData->tgdMainPath);
} }
if (!sFolder.endsWith('\\')) if (!sFolder.endsWith('\\'))
{ {
@ -221,18 +205,18 @@ void CGlobalCamera::checkFolder(QString& sFolder)
} }
} }
void CGlobalCamera::releaseConfig(const QString& key /* = NULL */) void lpCameraConfig::releaseConfig(const QString& key /* = NULL */)
{ {
m_cameraesOption.clear(releaseCameraOption); m_cameraesOption.clear(releaseCameraOption);
} }
void CGlobalCamera::releaseCameraOption(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData) void lpCameraConfig::releaseCameraOption(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData)
{ {
delete pCamOpt; delete pCamOpt;
} }
QList<QString> CGlobalCamera::CameraKeysOrderByIds() QList<QString> lpCameraConfig::CameraKeysOrderByIds()
{ {
QList<TP_CAMERA_OPTION*> options = m_cameraesOption.values(); QList<TP_CAMERA_OPTION*> options = m_cameraesOption.values();
qSort(options.begin(), options.end(), optionCompare); qSort(options.begin(), options.end(), optionCompare);
@ -244,12 +228,12 @@ QList<QString> CGlobalCamera::CameraKeysOrderByIds()
return strList; return strList;
} }
bool CGlobalCamera::optionCompare(TP_CAMERA_OPTION* op1, TP_CAMERA_OPTION* op2) bool lpCameraConfig::optionCompare(TP_CAMERA_OPTION* op1, TP_CAMERA_OPTION* op2)
{ {
return (op1->id < op2->id); return (op1->id < op2->id);
} }
QMap<QString, QString> CGlobalCamera::GetCamShowNames() QMap<QString, QString> lpCameraConfig::GetCamShowNames()
{ {
QMap<QString, QString> knMap; QMap<QString, QString> knMap;
for (QZkMutexMap<QString, TP_CAMERA_OPTION*>::iterator it = m_cameraesOption.begin(); it != m_cameraesOption.end(); ++it) for (QZkMutexMap<QString, TP_CAMERA_OPTION*>::iterator it = m_cameraesOption.begin(); it != m_cameraesOption.end(); ++it)
@ -259,24 +243,8 @@ QMap<QString, QString> CGlobalCamera::GetCamShowNames()
return knMap; return knMap;
} }
void CGlobalCamera::readSerials() void lpCameraConfig::delCameraOption(const QString& serials)
{
#ifdef _USE_CAMERA_SERIAL_ENCRYPTO
QString szFileName(m_pGlobalData->tgdMainPath);
szFileName.append("serials.dat");
QZkSerialNumbers serials;
QList<QByteArray> bytes = serials.AddFileName(szFileName);
for (QList<QByteArray>::iterator it = bytes.begin(); it != bytes.end(); ++it)
{
m_serialsList.append(QString::fromUtf8(*it));
}
#endif
}
void CGlobalCamera::delCameraOption(const QString& serials)
{ {
QMutexLocker locker(&m_mtxCam);
TP_CAMERA_OPTION* pcamOpt = m_cameraesOption.value(serials); TP_CAMERA_OPTION* pcamOpt = m_cameraesOption.value(serials);
if (pcamOpt){ if (pcamOpt){
m_cameraesOption.remove(serials); m_cameraesOption.remove(serials);
@ -285,11 +253,8 @@ void CGlobalCamera::delCameraOption(const QString& serials)
} }
} }
void CGlobalCamera::updateCameraOption(const QString& serials, const TP_CAMERA_OPTION& camOpt) void lpCameraConfig::updateCameraOption(const QString& serials, const TP_CAMERA_OPTION& camOpt)
{ {
QMutexLocker locker(&m_mtxCam);
// update if exist, otherwise new one.
if (m_cameraesOption.contains(serials)) if (m_cameraesOption.contains(serials))
{ {
TP_CAMERA_OPTION* pCamOpt = m_cameraesOption.value(serials); TP_CAMERA_OPTION* pCamOpt = m_cameraesOption.value(serials);
@ -307,31 +272,3 @@ void CGlobalCamera::updateCameraOption(const QString& serials, const TP_CAMERA_O
pCamOpt->pSerials = &m_serialsList; pCamOpt->pSerials = &m_serialsList;
m_cameraesOption.insert(pCamOpt->uniqueName, pCamOpt); m_cameraesOption.insert(pCamOpt->uniqueName, pCamOpt);
} }
QJsonObject CGlobalCamera::getAppJsonUser()
{
QJsonObject userJson;
QString strUiPath(m_pGlobalData->tgdMainPath);
strUiPath.append(m_pGlobalData->tgdFolderNames[TP_FOLDER_NAME_UI]);
QString strAppJsonPath(strUiPath);
strAppJsonPath.append(QCoreApplication::applicationName());
#ifdef _DEBUG
if (strAppJsonPath.endsWith('d'))
{
strAppJsonPath.chop(1);
}
#endif
strAppJsonPath.append(".json");
if (!QFile::exists(strAppJsonPath))
{
strAppJsonPath = strUiPath + "app.json";
}
int nerr;
QJsonObject objJson = QZkJsonParser::ReadJsonObject(strAppJsonPath, &nerr);
userJson = objJson["user"].toObject();
return userJson;
}

@ -9,12 +9,14 @@
#include <QtCore/QMutexLocker> #include <QtCore/QMutexLocker>
#include "QZkMutexMap.h" #include "QZkMutexMap.h"
#include "QZkMutexList.h" #include "QZkMutexList.h"
#include "lp_singleton_base.h"
class CGlobalCamera /*配置相机 及相机的相关属性*/
class lpCameraConfig:public lp_singleton_base<lpCameraConfig>
{ {
public: public:
CGlobalCamera(const CAMERA_IN_PARAM* pInParam); lpCameraConfig();
~CGlobalCamera(); ~lpCameraConfig();
bool CameraOption(const QString& serials, TP_CAMERA_OPTION& camOpt); bool CameraOption(const QString& serials, TP_CAMERA_OPTION& camOpt);
bool CameraOptionByKey(const QString& sKey, TP_CAMERA_OPTION& camOpt); bool CameraOptionByKey(const QString& sKey, TP_CAMERA_OPTION& camOpt);
bool SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION& camOpt); bool SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION& camOpt);
@ -30,34 +32,21 @@ public:
void delCameraOption(const QString& serials); void delCameraOption(const QString& serials);
void updateCameraOption(const QString& serials, const TP_CAMERA_OPTION& camOpt); void updateCameraOption(const QString& serials, const TP_CAMERA_OPTION& camOpt);
public: public:
// TP_GLOBAL_DATA* m_pGlobalData;
ICameraCallback* m_pCallback;
TP_CAMERAPOOL_OPTION m_optPool; TP_CAMERAPOOL_OPTION m_optPool;
private: private:
void readConfig(); void readConfig();
void releaseConfig(const QString& key = NULL); void releaseConfig(const QString& key = NULL);
void checkFolder(QString& sFolder); void checkFolder(QString& sFolder);
void readSerials();
QJsonObject getAppJsonUser();
static void releaseCameraOption(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData); static void releaseCameraOption(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData);
static bool copyCameraOptionBySerial(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData); static bool copyCameraOptionBySerial(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData);
static void copyCameraOptionByKey(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData); static void copyCameraOptionByKey(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData);
static bool optionCompare(TP_CAMERA_OPTION* op1, TP_CAMERA_OPTION* op2); static bool optionCompare(TP_CAMERA_OPTION* op1, TP_CAMERA_OPTION* op2);
private: private:
QMutex m_mtxCam;
const static char cs_szCfgName[]; const static char cs_szCfgName[];
QZkMutexMap<QString, TP_CAMERA_OPTION*> m_cameraesOption; QZkMutexMap<QString, TP_CAMERA_OPTION*> m_cameraesOption;
QJsonObject m_jsonCamera; QJsonObject m_jsonCamera;
QStringList m_serialsList; QStringList m_serialsList;
}; };
// extern class CGlobalCamera* gpGlobalCameraZZZ;
//
// #define gpGlobalCamera gpGlobalCameraZZZ
//
// #define gpGlobalData gpGlobalCamera->m_pGlobalData
// #define gpGlobalCamCallback gpGlobalCamera->m_pCallback
// #define callCamCallback(fc, defaultReturn, ...) (NULL != gpGlobalCamCallback) ? gpGlobalCamCallback->##fc##(__VA_ARGS__) : defaultReturn
// #define gGlobalPoolOption gpGlobalCamera->m_optPool
#endif #endif

@ -1,51 +0,0 @@
// #include "CameraPool.h"
// #include "globalCamera.h"
//
// #ifdef TPCAMERA_EXPORTS
// #define TPCAMERA_API extern "C" __declspec(dllexport)
// #else
// #define TPCAMERA_API extern "C"
// #endif
//
// CGlobalCamera* gpGlobalCameraZZZ = NULL;
// CCameraPool *gpCameraPool = NULL;
//
//
// //don't change the names of these global functions
// TPCAMERA_API void* Lib_Camera_Init(void* inParam)
// {
// CAMERA_IN_PARAM cinParam = {0};
// if( NULL != inParam )
// {
// std::memcpy(&cinParam, inParam, sizeof(CAMERA_IN_PARAM));
// }
// if( NULL == gpGlobalCamera )
// {
// gpGlobalCamera = new CGlobalCamera(&cinParam);
// }
// //
// if( NULL == gpCameraPool )
// {
// gpCameraPool = new CCameraPool();
// }
// if( NULL != gpCameraPool )
// {
// gpCameraPool->InitPool();
// }
// return gpCameraPool;
// }
//
// TPCAMERA_API void Lib_Camera_Free()
// {
// if( NULL != gpCameraPool )
// {
// gpCameraPool->FreePool();
// delete gpCameraPool;
// gpCameraPool = NULL;
// }
// if( NULL != gpGlobalCamera )
// {
// delete gpGlobalCamera;
// gpGlobalCamera = NULL;
// }
// }

@ -1,9 +1,9 @@
#include "triggerthread.h" #include "triggerthread.h"
#include "CameraPool.h" #include "CameraPool.h"
#include "globalCamera.h"
CTriggerThread::CTriggerThread(class CCameraPool* pPool, QObject *parent /* = NULL */) CTriggerThread::CTriggerThread(class CCameraPool* pPool, QObject *parent /* = NULL */)
: QTpThreadBase(parent) : lpThread(parent)
, m_pPool(pPool) , m_pPool(pPool)
{ {
m_msecOfInterval = 0; m_msecOfInterval = 0;
@ -29,9 +29,8 @@ void CTriggerThread::SetFrame(long nFrameRate)
} }
void CTriggerThread::StartTrigger() void CTriggerThread::StartTrigger()
{ {
EndThread();
m_LastTriggerTime = QTime::currentTime(); m_LastTriggerTime = QTime::currentTime();
StartThread();
} }
void CTriggerThread::EndTrigger() void CTriggerThread::EndTrigger()

@ -1,12 +1,10 @@
#ifndef TRIGGERTHREAD_H #ifndef TRIGGERTHREAD_H
#define TRIGGERTHREAD_H #define TRIGGERTHREAD_H
#include "qtpthreadbase.h"
#include <Qtcore\QTime> #include <Qtcore\QTime>
#include <QtCore\QMutex> #include <QtCore\QMutex>
#include "globalCamera.h" #include "lpThread.h"
class CTriggerThread : public lpThread
class CTriggerThread : public QTpThreadBase
{ {
public: public:
CTriggerThread(class CCameraPool* pPool, QObject *parent = NULL); CTriggerThread(class CCameraPool* pPool, QObject *parent = NULL);

@ -1,54 +0,0 @@
#include "CoreCtrl.h"
#ifdef TPCORECTRL_EXPORTS
#define TPCORECTRL_API extern "C" __declspec(dllexport)
#else
#define TPCORECTRL_API extern "C"
#endif
#include "ModulesManager.h"
#include "globalCoreCtrl.h"
#include <QtCore/QDir>
//CModulesManager gMdlesMgr;
//CGlobalCoreCtrl* gpData = NULL;
class CCoreCtrl* gpCoreCtrl = NULL;
TPCORECTRL_API void* Lib_CoreCtrl_Init(void* inParam)
{
// CORE_CTRL_IN_PARAM* pCciParam = (CORE_CTRL_IN_PARAM*)inParam;
// gpData = new CGlobalCoreCtrl(pCciParam);
// if( NULL == gpData )
// {
// return NULL;
// }
// if( gMdlesMgr.LoadModules() <= 0 )
// {
// return NULL;
// }
//////////////////////////////////////////////////////////////////
if( NULL == gpCoreCtrl )
{
gpCoreCtrl = new CCoreCtrl(inParam);
}
return gpCoreCtrl;
}
TPCORECTRL_API void Lib_CoreCtrl_Free()
{
if( NULL != gpCoreCtrl )
{
gpCoreCtrl->IFreeCore();
delete gpCoreCtrl;
gpCoreCtrl = NULL;
}
/////////////////////////////////////////////////
// gMdlesMgr.FreeModules();
// if( NULL != gpData )
// {
// delete gpData;
// gpData = NULL;
// }
}

@ -6,11 +6,9 @@
#include "zfunctions.h" #include "zfunctions.h"
const char CImgProc::cs_strCfgName[] = "algorithm"; const char CImgProc::cs_strCfgName[] = "algorithm";
TP_GLOBAL_DATA* CImgProc::s_pGlobalData = NULL;
CImgProc::CImgProc(IMGPROC_IN_PARAM* pParam) CImgProc::CImgProc()
{ {
s_pGlobalData = pParam->pGlobalData;
m_bIsInited = false; m_bIsInited = false;
m_nAlgorithmsUsings = 0; m_nAlgorithmsUsings = 0;
m_pDefAlgorithmDll = NULL; m_pDefAlgorithmDll = NULL;
@ -137,23 +135,12 @@ CLoadAlgorithm* CImgProc::createAlgorithmDll(const QString& k, void* pData)
{ {
return NULL; return NULL;
} }
//TP_ALGORITHM_OPTION* pAlgOpt = (TP_ALGORITHM_OPTION*)pData;
QString dllFileName; QString dllFileName;
#ifdef _DEBUG #ifdef _DEBUG
dllFileName.append("tpAlgorithmd"); dllFileName.append("tpAlgorithmd");
#else #else
dllFileName.append("tpAlgorithm"); dllFileName.append("tpAlgorithm");
#endif #endif
if (k != "0")
{
dllFileName.append("_").append(k);
}
QString dllPath(s_pGlobalData->tgdDllPath);
if (!ZKF::qtDllExit(dllPath, dllFileName))
{
dllPath = s_pGlobalData->tgdMainPath;
}
dllFileName = dllPath + dllFileName;
if (!pAlgDll->LoadAlg(dllFileName)) if (!pAlgDll->LoadAlg(dllFileName))
{ {
delete pAlgDll; delete pAlgDll;

@ -8,31 +8,22 @@
class CImgProc : public IImgProc class CImgProc : public IImgProc
{ {
public: public:
CImgProc(IMGPROC_IN_PARAM* pParam); CImgProc();
virtual ~CImgProc(void); virtual ~CImgProc(void);
int InitProc(); int InitProc();
void FreeProc(); void FreeProc();
private: private:
virtual int IImageProcess(class IImageObject* pImgObj, class IDetectorEngine* pDE = NULL); virtual int IImageProcess(class IImageObject* pImgObj, class IDetectorEngine* pDE = NULL);
virtual class IAlgorithmOption* IGetAlgorithmOption(int nAlgorithm); virtual class IAlgorithmOption* IGetAlgorithmOption(int nAlgorithm);
private: private:
//static CAlgorithmOption* createAlgorithmOption(const int& k, void* pData);
static void releaseAlgorithm(const Qt::HANDLE& k, class IAlgorithm*& v, void* pData); static void releaseAlgorithm(const Qt::HANDLE& k, class IAlgorithm*& v, void* pData);
// static void releaseAlgorithmOption(const int& k, CAlgorithmOption*& v, void* pData);
//class IImageProc* m_pImgProc;
public: public:
static TP_GLOBAL_DATA* s_pGlobalData;
const static char cs_strCfgName[]; const static char cs_strCfgName[];
private: private:
bool m_bIsInited; bool m_bIsInited;
//QSqliteAlgorithm m_dbAlg;
//QZkMutexMap<Qt::HANDLE, class IAlgorithm*> m_algorithms;
QAtomicInt m_nAlgorithmsUsings; QAtomicInt m_nAlgorithmsUsings;
// QZkMutexMap<int, CAlgorithmOption*> m_algorithmOptions;
//class CLoadAlgorithm* m_pLibAlgorithm;
QZkMutexMap<QString, CLoadAlgorithm*> m_algorithmDlls; QZkMutexMap<QString, CLoadAlgorithm*> m_algorithmDlls;
CLoadAlgorithm* m_pDefAlgorithmDll;//nAlgorithm = 0; tpAlgorithm.dll CLoadAlgorithm* m_pDefAlgorithmDll;//nAlgorithm = 0; tpAlgorithm.dll
struct tagALGORITHM_API{ struct tagALGORITHM_API{
class IAlgorithm* pApi; class IAlgorithm* pApi;
class CLoadAlgorithm* pDll; class CLoadAlgorithm* pDll;

@ -1,35 +0,0 @@
#include "ImgProc.h"
#include "LoadAlgorithm.h"
#ifdef TPIMGPROC_EXPORTS
#define TPIMGPROC_API extern "C" __declspec(dllexport)
#else
#define TPIMGPROC_API extern "C"
#endif
CImgProc* gpImgProc = NULL;
TPIMGPROC_API void* Lib_ImgProc_Init(void* inParam)
{
IMGPROC_IN_PARAM* pParam = (IMGPROC_IN_PARAM*)inParam;
if( NULL == gpImgProc )
{
gpImgProc = new CImgProc((IMGPROC_IN_PARAM*)pParam);
if( NULL != gpImgProc )
{
gpImgProc->InitProc();
}
}
return gpImgProc;
}
TPIMGPROC_API void Lib_ImgProc_Free()
{
if( NULL != gpImgProc )
{
gpImgProc->FreeProc();
delete gpImgProc;
gpImgProc = NULL;
}
//CLoadAlgorithm::FreeAlg();
}

@ -1,29 +0,0 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:$FILE_BASE$.$FILE_EXT$
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:$DATE$
History:$DAY$:$MONTH$:$YEAR$ $HOUR$:$MINUTE$
*******************************************************************************/
#ifndef __TP_JSON_CONFIG_H
#define __TP_JSON_CONFIG_H
namespace CAMERA_JSON //camera.json
{
namespace DEVICES //"devices"
{
}
namespace POOL //"pool"
{
}
namespace WINDOWS //"windows"
{
}
}
#endif//__TP_JSON_CONFIG_H

@ -4,39 +4,19 @@
#ifdef _USE_LIB_CORECTRL_DLL #ifdef _USE_LIB_CORECTRL_DLL
#include "DllLoader.h" #include "DllLoader.h"
#else #else
extern "C" void* Lib_CoreCtrl_Init(void* inParam); extern "C" ICoreCtrl* Lib_CoreCtrl_Init();
extern "C" void Lib_CoreCtrl_Free(); extern "C" void Lib_CoreCtrl_Free(ICoreCtrl*);
#endif #endif
#include "QZkJsonParser.h" #include "QZkJsonParser.h"
CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths, IGuiCallback* pGuiCb,class IDetectorEngine* pDE /*= NULL*/) CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths,class IDetectorEngine* pDE /*= NULL*/)
{ {
m_szDllPaths = szDllPaths; m_szDllPaths = szDllPaths;
memset(&m_tpGlobal, 0, sizeof(m_tpGlobal));
m_tpGlobal.tgdpDllPaths = &m_szDllPaths;
if (m_szDllPaths.size() > 0)
{
strncpy(m_tpGlobal.tgdMainPath, m_szDllPaths.last().toUtf8().data(), BASE_MAX_FILE_PATH - 1);
strncpy(m_tpGlobal.tgdUserPath, m_szDllPaths.first().toUtf8().data(), BASE_MAX_FILE_PATH - 1);
strcpy(m_tpGlobal.tgdDllPath, m_tpGlobal.tgdMainPath);
}
QJsonObject jsonUser;
int nerr;
QJsonObject rootBoj = QZkJsonParser::ReadJsonObject(".\\ui\\app.json", &nerr);
QString folderStr = jsonUser.value("config").toString("config\\");
strcpy(m_tpGlobal.tgdFolderNames[TP_FOLDER_NAME_CONFIG], folderStr.toUtf8().data());
folderStr = jsonUser.value("pic").toString("pic\\");
strcpy(m_tpGlobal.tgdFolderNames[TP_FOLDER_NAME_PICTURE], folderStr.toUtf8().data());
strcpy(m_tpGlobal.tgdFolderNames[TP_FOLDER_NAME_UI], "ui\\");
CORE_CTRL_IN_PARAM inParam;
inParam.pGlobalData = &m_tpGlobal;
inParam.pCoreSetting = NULL;
inParam.pGuiCb = pGuiCb;
#ifdef _USE_LIB_CORECTRL_DLL #ifdef _USE_LIB_CORECTRL_DLL
m_pLibCoreCtrl = new CDllLoaderM("lpCoreCtrl", "Lib_CoreCtrl_Init", "Lib_CoreCtrl_Free", m_szDllPaths); m_pLibCoreCtrl = new CDllLoaderM("lpCoreCtrl", "Lib_CoreCtrl_Init", "Lib_CoreCtrl_Free", m_szDllPaths);
if (NULL != m_pLibCoreCtrl) if (NULL != m_pLibCoreCtrl)
{ {
m_pCoreCtrl = (ICoreCtrl*)m_pLibCoreCtrl->ModuleInit(&inParam); m_pCoreCtrl = (ICoreCtrl*)m_pLibCoreCtrl->ModuleInit(nullptr);
if (NULL != m_pCoreCtrl) if (NULL != m_pCoreCtrl)
{ {
m_pCoreCtrl->IInitCore(pDE); m_pCoreCtrl->IInitCore(pDE);
@ -52,7 +32,7 @@ CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths, IGuiCallback* pGuiCb,c
} }
#else #else
m_pLibCoreCtrl = NULL; m_pLibCoreCtrl = NULL;
m_pCoreCtrl = (ICoreCtrl*)Lib_CoreCtrl_Init(&inParam); m_pCoreCtrl = (ICoreCtrl*)Lib_CoreCtrl_Init();
#endif #endif
} }
@ -60,14 +40,15 @@ CDllCoreCtrl::~CDllCoreCtrl()
{ {
if (NULL != m_pCoreCtrl) if (NULL != m_pCoreCtrl)
{ {
m_pCoreCtrl->IFreeCore();
#ifdef _USE_LIB_CORECTRL_DLL #ifdef _USE_LIB_CORECTRL_DLL
if (NULL != m_pLibCoreCtrl) m_pCoreCtrl->IFreeCore();
{ delete m_pCoreCtrl;
m_pLibCoreCtrl->ModuleFree(); // if (NULL != m_pLibCoreCtrl)
} // {
// m_pLibCoreCtrl->ModuleFree();
// }
#else #else
Lib_CoreCtrl_Free(); Lib_CoreCtrl_Free(m_pCoreCtrl);
#endif #endif
m_pCoreCtrl = NULL; m_pCoreCtrl = NULL;
} }

@ -7,10 +7,9 @@
class CDllCoreCtrl class CDllCoreCtrl
{ {
public: public:
CDllCoreCtrl(const ZStringList& szDllPaths, IGuiCallback* pGuiCb, class IDetectorEngine* pDE /*= NULL*/); CDllCoreCtrl(const ZStringList& szDllPaths, class IDetectorEngine* pDE /*= NULL*/);
~CDllCoreCtrl(); ~CDllCoreCtrl();
public: public:
TP_GLOBAL_DATA m_tpGlobal;
class CDllLoaderM* m_pLibCoreCtrl; class CDllLoaderM* m_pLibCoreCtrl;
ICoreCtrl* m_pCoreCtrl; ICoreCtrl* m_pCoreCtrl;
ZStringList m_szDllPaths; ZStringList m_szDllPaths;

@ -0,0 +1,16 @@
#include "lpCoreConfig.h"
#include "QZkJsonParser.h"
void lpCoreConfig::readConfig()
{
QString strCorePath = "./config/corectrl.json";
QJsonObject objJson = QZkJsonParser::ReadJsonObject(strCorePath);
QJsonObject objTmp = objJson["core_setting"].toObject();
m_CoreSetting.threadsCount = objTmp.value("image_threads").toInt(0);
m_CoreSetting.imageShowType = objTmp.value("show_type").toInt(0);
}
void lpCoreConfig::writeConfig()
{
}

@ -0,0 +1,25 @@
#ifndef _H_LPCORECONFIG_H_
#define _H_LPCORECONFIG_H_
#include "lp_singleton_base.h"
#include <string>
#include "baseStruct.h"
class lpCoreConfig:public lp_singleton_base<lpCoreConfig>
{
public:
lpCoreConfig() {};
~lpCoreConfig() {};
public:
void readConfig();
void writeConfig();
public:
std::string m_MainPath;
TP_CORE_SETTING m_CoreSetting;
};
#endif

@ -11,49 +11,34 @@
</ProjectConfiguration> </ProjectConfiguration>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="..\..\src\lpCoreCtrl\AlgorithmResult.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\CoreCtrl.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\CoreCtrl.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\globalCoreCtrl.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\GlobalDataBase.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\ImageObject.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\ImageObject.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\LoadModule.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\LoadModule.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\ModulesManager.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\lpThread.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\qtpthreadbase.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\qtpthreadimage.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\QZkShowImage.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\globalCamera.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\lpCameraConfig.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\tpCamera.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\triggerthread.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\triggerthread.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpCoreCtrl.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\ImgProc.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\ImgProc.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\tpImgProc.cpp" /> <ClCompile Include="..\..\src\lpCoreCtrl\lpCameraImage.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\ZkCameraImage.cpp" /> <ClCompile Include="lpCoreConfig.cpp" />
<ClCompile Include="..\..\src\lpCoreCtrl\ZkImage.cpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="..\..\src\lpCoreCtrl\AlgorithmResult.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\callbackFunc.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\callbackFunc.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\CoreCtrl.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\CoreCtrl.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\globalCoreCtrl.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\GlobalDataBase.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\iCameraObject.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\iCameraObject.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\ImageObject.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\ImageObject.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\LoadModule.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\LoadModule.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\ModulesManager.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\lpThread.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\qtpthreadbase.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\qtpthreadimage.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\QZkShowImage.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\globalCamera.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\lpCameraConfig.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\triggerthread.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\triggerthread.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\ImgProc.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\ImgProc.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\ZkCameraImage.h" /> <ClInclude Include="..\..\src\lpCoreCtrl\lpCameraImage.h" />
<ClInclude Include="..\..\src\lpCoreCtrl\ZkImage.h" /> <ClInclude Include="lpCoreConfig.h" />
</ItemGroup> </ItemGroup>
<PropertyGroup Label="Globals"> <PropertyGroup Label="Globals">
<ProjectGuid>{784071A9-BF94-4D27-B62E-588ACD7E0633}</ProjectGuid> <ProjectGuid>{784071A9-BF94-4D27-B62E-588ACD7E0633}</ProjectGuid>

@ -41,63 +41,36 @@
<ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.cpp">
<Filter>tpImgProc</Filter> <Filter>tpImgProc</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpImgProc\tpImgProc.cpp">
<Filter>tpImgProc</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\AlgorithmResult.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\CoreCtrl.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\CoreCtrl.cpp">
<Filter>tpCoreCtrl</Filter> <Filter>tpCoreCtrl</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\globalCoreCtrl.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\GlobalDataBase.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\ImageObject.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\ImageObject.cpp">
<Filter>tpCoreCtrl</Filter> <Filter>tpCoreCtrl</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\LoadModule.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\LoadModule.cpp">
<Filter>tpCoreCtrl</Filter> <Filter>tpCoreCtrl</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\ModulesManager.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\qtpthreadbase.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\qtpthreadimage.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\QZkShowImage.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCoreCtrl.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\ZkCameraImage.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\ZkImage.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.cpp">
<Filter>tpCamera</Filter> <Filter>tpCamera</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\globalCamera.cpp">
<Filter>tpCamera</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.cpp">
<Filter>tpCamera</Filter> <Filter>tpCamera</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\tpCamera.cpp">
<Filter>tpCamera</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\triggerthread.cpp"> <ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\triggerthread.cpp">
<Filter>tpCamera</Filter> <Filter>tpCamera</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="lpCoreConfig.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\tpCamera\lpCameraConfig.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\lpCameraImage.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
<ClCompile Include="..\..\src\lpCoreCtrl\lpThread.cpp">
<Filter>tpCoreCtrl</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\ImgProc.h"> <ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\ImgProc.h">
@ -106,18 +79,9 @@
<ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.h"> <ClInclude Include="..\..\src\lpCoreCtrl\tpImgProc\LoadAlgorithm.h">
<Filter>tpImgProc</Filter> <Filter>tpImgProc</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\AlgorithmResult.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\CoreCtrl.h"> <ClInclude Include="..\..\src\lpCoreCtrl\CoreCtrl.h">
<Filter>tpCoreCtrl</Filter> <Filter>tpCoreCtrl</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\globalCoreCtrl.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\GlobalDataBase.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\iCameraObject.h"> <ClInclude Include="..\..\src\lpCoreCtrl\iCameraObject.h">
<Filter>tpCoreCtrl</Filter> <Filter>tpCoreCtrl</Filter>
</ClInclude> </ClInclude>
@ -127,30 +91,9 @@
<ClInclude Include="..\..\src\lpCoreCtrl\LoadModule.h"> <ClInclude Include="..\..\src\lpCoreCtrl\LoadModule.h">
<Filter>tpCoreCtrl</Filter> <Filter>tpCoreCtrl</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\ModulesManager.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\qtpthreadbase.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\qtpthreadimage.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\QZkShowImage.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\ZkCameraImage.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\ZkImage.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.h"> <ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\CameraPool.h">
<Filter>tpCamera</Filter> <Filter>tpCamera</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\globalCamera.h">
<Filter>tpCamera</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.h"> <ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\LibCameraes.h">
<Filter>tpCamera</Filter> <Filter>tpCamera</Filter>
</ClInclude> </ClInclude>
@ -160,5 +103,17 @@
<ClInclude Include="..\..\src\lpCoreCtrl\callbackFunc.h"> <ClInclude Include="..\..\src\lpCoreCtrl\callbackFunc.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="lpCoreConfig.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\tpCamera\lpCameraConfig.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\lpCameraImage.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
<ClInclude Include="..\..\src\lpCoreCtrl\lpThread.h">
<Filter>tpCoreCtrl</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>

@ -710,7 +710,7 @@ bool CMainWin::onInitCoreCtrl()
//load coretrl //load coretrl
if (NULL == m_pDllCoreCtrl) if (NULL == m_pDllCoreCtrl)
{ {
m_pDllCoreCtrl = new CDllCoreCtrl(QStringList(), nullptr, m_pDetectorEngine); m_pDllCoreCtrl = new CDllCoreCtrl(QStringList(), m_pDetectorEngine);
if (NULL == m_pDllCoreCtrl) if (NULL == m_pDllCoreCtrl)
{ {
return false; return false;

Loading…
Cancel
Save