新增lpCoretrl、lpmain等模块,初步根据原有业务逻辑调通

valve_lucas
bobpan 6 years ago
parent 40a78024c6
commit bbd891b243

@ -0,0 +1,19 @@
#ifndef SYSTEMSTATEINFO
#define SYSTEMSTATEINFO
#include <QtCore>
#include "lpdsgdefine.h"
class SystemStateInfo
{
public:
static bool bParamStateFlag;
static int rgb;
static QSettings setIni;
};
#endif // SYSTEMSTATEINFO

@ -0,0 +1,35 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:baseClass.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/08
History:8:4:2015 13:13
*******************************************************************************/
#ifndef __BASE_CLASS_H_20150408
#define __BASE_CLASS_H_20150408
//#include "baseDefine.h"
//#include "ZkImage.h"
#include <QtCore/QAtomicInt>
namespace QZK {
class QAtomicIntAdder{
public:
QAtomicIntAdder(QAtomicInt& ai)
: m_ai(ai) {
++m_ai;
}
~QAtomicIntAdder() {
--m_ai;
}
private:
QAtomicInt& m_ai;
};
};
namespace CZK {
}
#endif

@ -0,0 +1,20 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
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{
const char cszJsonSuffix[] = ".json";
const char cszDatSuffix[] = ".dat";
// const char cszCfgFolder[] = "config\\";
// const char cszMainCfg[] = "main";
}
#endif

@ -0,0 +1,72 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
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"
#ifndef BYTE
typedef unsigned char BYTE;
#endif
#ifndef WORD
typedef unsigned short WORD;
#endif
#ifndef DWORD
typedef unsigned long DWORD;
#endif
//#ifndef size_t
//typedef unsigned int size_t;
//#endif
#define MAX(a, b) (a) > (b) ? (a) : (b)
#define MIN(a, b) (a) > (b) ? (b) : (a)
#define ABS(a) (a) < 0 ? (-(a)) : (a)
#define SELF_ABS(a) if( a < 0 ) a = -a
#define ZStringA QByteArray
//#define USE_PIXMAP_AS_SHOW
#ifdef USE_PIXMAP_AS_SHOW
#define ZShowImage QPixmap
#else
#define ZShowImage QImage
#endif
//#define QT_NO_DEBUG_OUTPUT //open this remark to enable qDebug
#ifndef tpDebugOut
#define tpDebugOut(...) qDebug(__VA_ARGS__)
#endif
enum emTpColorFormat{
TP_COLOR_NONE = 0,
TP_COLOR_Y800 = 1,//"GRAY8"
TP_COLOR_RGB24 = 2,//"RGB24"
TP_COLOR_RGB32 = 3,//"RGB32"
TP_COLOR_Y16 = 4,//"GRAY16"
TP_COLOR_RGB48 = 5,
TP_COLOR_BGR24 = 11,//"BGR24"
TP_COLOR_BGR32 = 12,//"BGR32"
// UYVY = 5,
};
//#define _USE_SPIDER_LOG
enum emTpWarningCode {
WARNING_NO,
WARNING_COMM_CLOSED,
};
#ifndef PI
#define PI 3.1415927
#endif
#endif

@ -0,0 +1,31 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:baseFunction.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/08
History:8:4:2015 13:04
*******************************************************************************/
#ifndef __BASE_FUNCTION_H_20150408
#define __BASE_FUNCTION_H_20150408
#include "sysInclude.h"
namespace SYS_F {
int GetCpus() {
#if defined(Q_OS_WIN) || defined(WIN32) || defined(WIN64)
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
return sysInfo.dwNumberOfProcessors;
#else
return 0;
#endif
}
}
namespace TP_F {
}
#endif

@ -0,0 +1,20 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:baseInclude.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/07
History:7:4:2015 9:16
*******************************************************************************/
#ifndef __BASE_INCLUDE_H_20150407
#define __BASE_INCLUDE_H_20150407
#include "sysInclude.h"
#include "baseDefine.h"
#include "baseConstant.h"
#include "baseStruct.h"
#include "baseClass.h"
#endif

@ -0,0 +1,474 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:baseStruct.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/09
History:9:4:2015 10:33
*******************************************************************************/
#ifndef __BASE_STRUCT_H
#define __BASE_STRUCT_H
#include "baseDefine.h"
#include "baseConstant.h"
#include "iAlgorithm.h"
#define BASE_MAX_FILE_PATH 260
#define BASE_MAX_FOLDER_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];
// char tgdFileNames[TP_FILE_NAME_MAX_NUM][BASE_MAX_FILE_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{
int threadsCount;
int imageShowType;
}TP_CORE_SETTING;
enum emTpDeviceType {
DEV_CAM_NONE = 0,
DEV_CAM_VIRTUAL = 100,
DEV_CAM_VIRTUAL_FOLDER = 100,
DEV_CAM_BITFLOW = 110,
DEV_CAM_BITFLOW_BI = 110,
DEV_CAM_GIGE = 120,
DEV_CAM_USB = 130,
DEV_CAM_HIK = 140,
DEV_CAM_VIMBA = 150,
DEV_CAM_BAUMER = 160,
DEV_CAM_ADLINK = 170,
DEV_CAM_DAHUA = 180,
DEV_CAM_BASLER = 190,
DEV_CAM_PTGRAY = 200,
DEV_CAM_EURESYS = 220,
DEV_CAM_DALSA = 230,
};
static const QMap<emTpDeviceType, QString> gCameraNamesMap = {
{ DEV_CAM_NONE, "Unknown(0)" },
{ DEV_CAM_VIRTUAL, "Virtual Camera(100)" },
{ DEV_CAM_VIRTUAL_FOLDER, "Virtual Camera(100)" },
{ DEV_CAM_BITFLOW, "BitFlow(110)" },
{ DEV_CAM_BITFLOW_BI, "BitFlow(110)" },
{ DEV_CAM_GIGE, "Gige(120)" },
{ DEV_CAM_USB, "USB Camera(130)" },
{ DEV_CAM_HIK, "HIK(140)" },
{ DEV_CAM_VIMBA, "Vimba(150)" },
{ DEV_CAM_BAUMER, "Baumer(160)" },
{ DEV_CAM_ADLINK, "AdLink(170)" },
{ DEV_CAM_DAHUA, "DaHua(180)" },
{ DEV_CAM_BASLER, "Basler(190)" },
{ DEV_CAM_PTGRAY, "PtGray(200)" },
{ DEV_CAM_EURESYS, "Euresys(220)" },
{ DEV_CAM_DALSA, "Dalsa(230)" }
};
#define TP_STRING_MAX_SIZE 256
enum emTpCameraStatus{
TP_CAMERA_STATUS_UNINIT = 0, // 未初始化(刚从配置文件加载)
TP_CAMERA_STATUS_INITED = 1, // 已初始化即加载DLL成功
TP_CAMERA_STATUS_OPENED = 2, // 已打开
TP_CAMERA_STATUS_STARTED = 3, // 运行中
TP_CAMERA_STATUS_STOPPED = 4, // 暂停
TP_CAMERA_STATUS_CLOSED = 5, // 已关闭
};
static const QMap<emTpCameraStatus, QString> gCameraStatusMap = {
{ TP_CAMERA_STATUS_UNINIT, "Uninitialized" },
{ TP_CAMERA_STATUS_INITED, "Initialized" },
{ TP_CAMERA_STATUS_OPENED, "Opened" },
{ TP_CAMERA_STATUS_STARTED, "Running" },
{ TP_CAMERA_STATUS_STOPPED, "Paused" },
{ TP_CAMERA_STATUS_CLOSED, "Closed" }
};
typedef struct tagTP_CAMERA_OPTION {
tagTP_CAMERA_OPTION()
:id(0), deviceType(0), save(0), loop(0), width(0),
height(0), zoom(0), format(TP_COLOR_NONE), algorithm(0), exposure(0),
boardType(0), boardNum(0), gain(0), bIgnoreImage(false),
bNeedRgbSwapped(false), bAutoOpen(true), bAutoPush(true),
status(TP_CAMERA_STATUS_UNINIT)
{ }
int id;
int deviceType;
BYTE save;
BYTE loop;//
BYTE reserve[2];
QString showName;
QString uniqueName;
int width;
int height;
int zoom;
emTpColorFormat format;
QString folder;
QString saveImgSuffix;
int algorithm;
QString relyOnCamera;
long exposure;
int boardType;
int boardNum;
long gain;
QString dllsuffix;
QString sBoardName;
QString sBoardConfigFile;
// used inner
bool bIgnoreImage;
QStringList* pSerials;
bool bNeedRgbSwapped;
QString macAddress;
bool bAutoOpen;
QString cameraFilePath;
bool bAutoPush; // 默认一旦得到图片就直接push进pool。
// camera status - used for app inside
emTpCameraStatus status;
bool operator==(const tagTP_CAMERA_OPTION& rhs)
{
return (id == rhs.id) && (deviceType == rhs.deviceType) &&
(save == rhs.save) && (loop == rhs.loop) &&
(showName == rhs.showName) &&
(uniqueName == rhs.uniqueName) &&
(zoom == rhs.zoom) && (format == rhs.format) &&
(folder == rhs.folder) &&
(saveImgSuffix == rhs.saveImgSuffix) &&
(algorithm == rhs.algorithm) && (relyOnCamera == rhs.relyOnCamera) &&
(exposure == rhs.exposure) && (boardType == rhs.boardType) &&
(boardNum == rhs.boardNum) &&
(gain == rhs.gain) &&
(dllsuffix == rhs.dllsuffix) &&
(sBoardName == rhs.sBoardName) &&
(sBoardConfigFile == rhs.sBoardConfigFile) &&
(bAutoPush == rhs.bAutoPush) &&
(bNeedRgbSwapped == rhs.bNeedRgbSwapped);
}
}TP_CAMERA_OPTION;
enum emTpCommType {
TP_COMM_TYPE_NO = 0,
TP_COMM_TYPE_SERIAL = 1,
TP_COMM_TYPE_USB = 2,
TP_COMM_TYPE_TCP_CLIENT = 3, // 主机作为客户端
TP_COMM_TYPE_TCP_SERVER = 4, // 主机作为服务端
TP_COMM_TYPE_TCP_CLIENT_SESSION = 5, // 主机作为服务端,接受的客户端会话
};
static const QMap<emTpCommType, QString> gCommNamesMap = {
{ TP_COMM_TYPE_NO, "Unknown" },
{ TP_COMM_TYPE_SERIAL, "Serial Port" },
{ TP_COMM_TYPE_USB, "USB Port" },
{ TP_COMM_TYPE_TCP_CLIENT, "TCP Client" },
{ TP_COMM_TYPE_TCP_SERVER, "TCP Server" },
{ TP_COMM_TYPE_TCP_CLIENT_SESSION, "TCP Client Session" }
};
enum emTpCommStatus{
TP_COMM_STATUS_DISABLE = 0, // 禁用状态
TP_COMM_STATUS_OPENNING = 1, // 打开中或者连接建立中
TP_COMM_STATUS_CONNECTED = 2, // 已打开或者连接已建立
TP_COMM_STATUS_CLOSED = 3, // 已关闭
TP_COMM_STATUS_CLOSING = 4, // 正在关闭
};
typedef struct tagTP_COMM_SETTING_NODE {
tagTP_COMM_SETTING_NODE()
:type(TP_COMM_TYPE_NO), enable(0),
bound(115200), triggerInterval(0),
usb_pid(0), usb_vid(0), heartBeatInterval(5000),
strHostAddress("127.0.0.1"), hostPort(9040),
strListenIp("*"), listenPort(9040), nMaxClients(0),
nClientPort(0), status(TP_COMM_STATUS_DISABLE)
{}
emTpCommType type;
int enable;
QString strName;
//used for serial port
int bound;
int triggerInterval;
int meterDecodeInterval;
int usb_pid;
int usb_vid;
int heartBeatInterval;
// used for tcp client
QString strHostAddress;
int hostPort;
// used for tcp server
QString strListenIp;
int listenPort;
int nMaxClients;
// used for tcp server client session
int nClientPort;
// node status - used for app inside
emTpCommStatus status;
bool operator==(const tagTP_COMM_SETTING_NODE& rhs)
{
return (type == rhs.type) && (enable == rhs.enable) &&
(strName == rhs.strName) && (bound == rhs.bound) &&
(triggerInterval == rhs.triggerInterval) &&
(meterDecodeInterval == rhs.meterDecodeInterval) &&
(usb_pid == rhs.usb_pid) && (usb_vid == rhs.usb_vid) &&
(heartBeatInterval == rhs.heartBeatInterval) &&
(strHostAddress == rhs.strHostAddress) &&
(hostPort == rhs.hostPort) && (strListenIp == rhs.strListenIp) &&
(listenPort == rhs.listenPort) && (nMaxClients == rhs.nMaxClients) &&
(nClientPort == rhs.nClientPort);
}
}TP_COMM_SETTING_NODE;
enum emTpDeviceTriggerMode {
DEV_TRIGGER_MODE_STOP = 0,
DEV_TRIGGER_MODE_OUT = 1,
DEV_TRIGGER_MODE_AUTO = 2,
DEV_TRIGGER_MODE_FIXED_AUTO = 3,
DEV_TRIGGER_MODE_SOFT = 4,
// DEV_TRIGGER_MODE_MANUAL = 3,
};
enum emTpTriggerDirection {
TRIGGER_DIRECT_FOREWARD = 0,
TRIGGER_DIRECT_BACKWARD = 1,
TRIGGER_DIRECT_REPEAT = 2,
};
typedef struct tagTP_CAMERAPOOL_OPTION {
emTpDeviceTriggerMode triggerMode;
emTpTriggerDirection triggerDirection;
int frameRate;
int fixedFrames;
}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 = {
{ TP_COLOR_NONE, "None" },
{ TP_COLOR_Y800, "GRAY8" },
{ TP_COLOR_RGB24, "RGB24" },
{ TP_COLOR_RGB32, "RGB32" },
{ TP_COLOR_Y16, "GRAY16" },
{ TP_COLOR_RGB48, "RGB48" },
{ TP_COLOR_BGR24, "BGR24" },
{ TP_COLOR_BGR32, "BGR32" }
};
#define TP_LOG_TAIL " - " << __FUNCTION__
#define TP_DEBUG(msg) qDebug() << msg << TP_LOG_TAIL;
#define TP_WARN(msg) qWarning() << msg << TP_LOG_TAIL;
#define TP_ERROR(msg) qCritical() << msg << TP_LOG_TAIL;
//global functions
namespace TP_FUNCS
{
#define F_INLINE inline
F_INLINE QString ImageFileName(DWORD nFrameNumber, const TP_CAMERA_OPTION* pCamOpt, const char* szSuffix)
{
QStringList invaldcha = (QStringList() << "\\" << "/" << "*" << "?" << "<" << ">" << "|" << ":");
QDateTime dt = QDateTime::currentDateTime();
QString strCamName = pCamOpt->uniqueName;
foreach(const QString &str, invaldcha) {
strCamName.remove(str);
}
QString strName = pCamOpt->folder + strCamName
+ "_" + dt.toString("yyyy_MM_dd_hh_mm_ss_zzz") + "_"
+ QString::number(nFrameNumber) + szSuffix/*".BMP"*/;
return strName;
}
F_INLINE QString ImageFileName(DWORD nFrameNumber, const TP_CAMERA_OPTION* pCamOpt)
{
QStringList invaldcha = (QStringList() << "\\" << "/" << "*" << "?" << "<" << ">" << "|" << ":");
QDateTime dt = QDateTime::currentDateTime();
QString strCamName = pCamOpt->uniqueName;
//foreach(const QString &str, invaldcha) {
// strCamName.remove(str);
//}
strCamName.remove(":");
QString strName = pCamOpt->folder + strCamName
+ "_" + dt.toString("yyyy_MM_dd_hh_mm_ss_zzz") + "_"
+ QString::number(nFrameNumber) + pCamOpt->saveImgSuffix;
return strName;
}
F_INLINE emTpColorFormat FromQImageFormat(const QImage &image)
{
if (QImage::Format_RGB32 == image.format())
{
return TP_COLOR_RGB32;
}
else if (QImage::Format_RGB888 == image.format())
{
return TP_COLOR_RGB24;
}
else if (QImage::Format_Indexed8 == image.format())
{
return TP_COLOR_Y800;
}
else if (QImage::Format_RGB16 == image.format())
{
return TP_COLOR_Y16;
}
else if (QImage::Format_ARGB32 == image.format())
{
return TP_COLOR_RGB48;
}
else
{
return TP_COLOR_NONE;
}
}
F_INLINE QImage::Format ToQImageFormat(emTpColorFormat colorFormat)
{
if (TP_COLOR_RGB32 == colorFormat)
{
return QImage::Format_RGB32;
}
else if (TP_COLOR_RGB24 == colorFormat)
{
return QImage::Format_RGB888;
}
else if (TP_COLOR_Y800 == colorFormat)
{
return QImage::Format_Indexed8;
}
else if (TP_COLOR_Y16 == colorFormat)
{
return QImage::Format_RGB16;
}
else if (TP_COLOR_RGB48 == colorFormat)
{
return QImage::Format_ARGB32;
}
else
{
return QImage::Format_Invalid;
}
}
F_INLINE int BitsPerPixels(emTpColorFormat colorFormat)
{
if (TP_COLOR_RGB32 == colorFormat)
{
return 32;
}
else if (TP_COLOR_RGB24 == colorFormat)
{
return 24;
}
else if (TP_COLOR_Y800 == colorFormat)
{
return 8;
}
else if (TP_COLOR_Y16 == colorFormat)
{
return 16;
}
else
{
return 0;
}
}
F_INLINE bool isValidImgSuffix(const QString& str)
{
static QRegExp rx("(\\w*|\\w*\\*)\\.(?:bmp|jpeg|jpg|png)", Qt::CaseInsensitive);
return rx.exactMatch(str);
}
// IPV4 only
F_INLINE bool isValidIPAddress(const QString& str)
{
// [0,255].[0,255].[0,255].[0,255]
static QRegExp rx("((2[0-4]\\d|25[0-5]|[01]?\\d\\d?).){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)");
return rx.exactMatch(str);
}
}
#endif

@ -0,0 +1,185 @@
/******************************************************************************
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
#include "baseDefine.h"
#include <QtCore\qstring.h>
#include <QtGui\qimage.h>
#include <QtCore\qvariant.h>
#include <QtCore\qbuffer.h>
#include <QtCore\qstringlist.h>
//#include "baseStruct.h"
#define ALG_SHARED_GLOBAL_KEY_APP_STATUS "app_status"
#define ALG_SHARED_GLOBAL_KEY_APP_CHECKED "app_checked_status"
class IAlgorithmShared
{
public:
enum emAppStatus {
APP_STATUS_DEFAULT = 0,
APP_STATUS_SAMPLING = 1,
};
IAlgorithmShared() {}
virtual ~IAlgorithmShared() {}
virtual UINT64 ILastUpdateTime() = 0;
virtual QStringList IGetStringList(const QString& key) = 0;
virtual int IGetInt(const QString& key, int nDef = 0) = 0;
};
/////////////////////////////////////////////////////////////////////////////////////////////
#define ALG_OPTION_GLOBAL_KEY_SAMPLING_OBJECT "sampling_object"
class IAlgorithmOption
{
public:
IAlgorithmOption() {}
virtual ~IAlgorithmOption() {}
virtual int GetIntValue(const QString& skey, int nDefault) = 0;
virtual void SetIntValue(const QString& skey, int value) = 0;
virtual QString GetStringValue(const QString& skey, const QString& default = "") = 0;
virtual void SetStringValue(const QString& skey, const QString& value) = 0;
virtual bool Save(bool bWait = true) = 0;
virtual QVariantMap VariantMap() = 0;
virtual bool DbSetValue(const QString& key, int type, const QByteArray& data) = 0;
virtual bool DbGetValue(const QString& key, int type, QByteArray& data) = 0;
virtual bool DbDelValue(const QString& key) = 0;
virtual QStringList DbGetKeysByType(int type) = 0;
virtual QVariant GetValue(const QString& skey, const QVariant& def) = 0;
virtual void SetValue(const QString& skey, const QVariant& value) = 0;
};
typedef struct tagTP_ALGORITHM_OPTION {
int algorithm;
class IAlgorithmOption* pImagProcCb;
} TP_ALGORITHM_OPTION;
////////////////////////////////////////////////////////////////////////////////////////////
enum emTpCameraProperty{
TP_CAM_PROPERTY_NONE = 0,
TP_CAM_PROPERTY_EXPOSURE = 1,
TP_CAM_PROPERTY_BALANCE_RATIO_RED = 2,
TP_CAM_PROPERTY_BALANCE_RATIO_GREEN = 3,
TP_CAM_PROPERTY_BALANCE_RATIO_BLUE = 4,
TP_CAM_PROPERTY_FOLDER_NAME = 50,
TP_CAM_BITFLOW_BASE = 110,
TP_CAM_BITFLOE_SAVE_CFG = TP_CAM_BITFLOW_BASE,
TP_CAM_BITFLOW_ROW_RATE = TP_CAM_BITFLOW_BASE + 1,
TP_CAM_BITFLOW_COMMAND = TP_CAM_BITFLOW_BASE + 9,
TP_CAM_PROPERTY_FINISH = 0xFFFF
};
#define TP_MAX_STRING_SIZE 260
typedef struct tagTP_CAMERA_PROPERTY {
emTpCameraProperty property;
long value;
char szProperty[TP_MAX_STRING_SIZE];
int nErrorCode;//return by camera
} TP_CAMERA_PROPERTY;
class IImageObject
{
public:
IImageObject() { }
virtual ~IImageObject() { }
virtual emTpColorFormat IColorFormat() = 0;
//@nOutBytesPerLine: 0 means there is no valid value
virtual BYTE* IImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nOutBytesPerLine) = 0;
virtual int IGetId() = 0;
virtual int IGetAlgorithm() = 0;
virtual int IGetFrameNum() = 0;
virtual int IGetTriggerCount() = 0;
virtual void ISetCameroProperty(TP_CAMERA_PROPERTY& property) = 0;
virtual void ISendDataToUI(void* pData) = 0;
//////////////////////////////////////////////////////////
typedef void(*Comm_Callback_Func)(int cmd, BYTE* pData, int nDataLen, void* pContext);
typedef struct tagDATA_TO_COMM_HEAD {
char* commNames;
int cmd;
Comm_Callback_Func pfCallback;
void* pContext;
tagDATA_TO_COMM_HEAD() {
commNames = NULL;
cmd = 0;
pfCallback = NULL;
pContext = NULL;
}
}DATA_TO_COMM_HEAD;
virtual void IDataToComm(DATA_TO_COMM_HEAD& head, char* pData, int nLen) = 0;
enum emTpDefectType {
TP_DEF_CLEAN,
TP_DEF_RECT_F,//double for float, pData is Left, Top, Width, Height;nDataLen = sizeof(double) * 4;
TP_DEF_LINE_F,
TP_DEF_CIRCLE_F,
TP_DEF_ELLIPSE_F,
TP_DEF_POLYGON_F,
TP_DEF_POLYLINE_I,
};
virtual void IDrawDefect(const char* szWinName, emTpDefectType defectType, BYTE* pData, int nDataLen) = 0;
virtual void IDrawDefectOrg(emTpDefectType defectType, BYTE* pData, int nDataLen) = 0;
virtual void ISafeDataToUI(void* pData, int nDataLen) = 0;
virtual void ISafeDataToUI(WORD type, void* pData, int nDataLen) = 0;
virtual INT64 IMeterCode() = 0;
virtual const char* IGetImageUtf8String() = 0;
virtual void IDrawImage(QImage& image = QImage(), const char* szWinName = NULL) = 0;
virtual QImage IImage() = 0;
virtual const ZStringA& IDllSuffix() = 0;
virtual void ISetResult(const QString& key, QVariant& val) = 0;
virtual void IAccumulateResult(const QString& key, QVariant& val) = 0;
virtual void IMoveToFolder(const QString& szFolder) = 0;
virtual IAlgorithmShared* IGetShared() = 0;
virtual void IVariantMapToUI(const QVariantMap& vMap) = 0;
virtual const ZStringA& ICameraSerial() = 0;
virtual const QVariant& IVarFromUI() = 0;
virtual quint64 ITimeStamp() = 0;
};
//pColor is ARGB, eg 0xFF010101
inline void simple_draw_image_8(IImageObject* pImgObj, uint *pColor, int nNum) {
//pImgObj->IDrawImage(QImage(pBuffer, w, h, QImage::Format_ARGB32).copy());
QImage image = pImgObj->IImage();
if (QImage::Format_Indexed8 == image.format() && NULL != pColor) {
QVector<QRgb> corFmt;
for (int i = 0; i < nNum; ++i) {
corFmt.append(pColor[i]);
}
image.setColorTable(corFmt);
}
pImgObj->IDrawImage(image);
}
class IAlgorithm
{
public:
IAlgorithm() {}
virtual ~IAlgorithm() {}
virtual int IImageAnalysis(class IImageObject* pImgObj, TP_ALGORITHM_OPTION* pOpt, class IDetectorEngine* pDE) = 0;
protected:
};
//#define _LOAD_ALGORITHM_DLL_STATIC
#ifdef ALGORITHM_EXPORTS
#define ALGORITHM_API extern "C" __declspec(dllexport)
#else
#ifndef _LOAD_ALGORITHM_DLL_STATIC
#define ALGORITHM_API extern "C"
#else
#define ALGORITHM_API extern "C" __declspec(dllimport)
#endif
#endif
ALGORITHM_API IAlgorithm* Algorithm_Create(class IDetectorEngine*);
ALGORITHM_API void Algorithm_Delete(IAlgorithm* pAlg);
#endif

@ -0,0 +1,244 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:iCoreCtrl.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/23
History:23:3:2015 15:35
*******************************************************************************/
#ifndef __I_CORE_CTRL_H
#define __I_CORE_CTRL_H
//#include "icamera.h"
#include "baseStruct.h"
#include <QtCore/QString>
#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
{
public:
IAlgorithmResult(){}
virtual ~IAlgorithmResult(){}
virtual QVariantMap ToVariantMap() = 0;
};
//interface for gui
class ICoreCtrl
{
public:
ICoreCtrl() {}
virtual ~ICoreCtrl() {}
virtual QList<QString> ICameraKeys() = 0;
virtual QList<QString> ICameraKeysOrderByIds() = 0;
virtual bool ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt) = 0;
virtual bool ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt) = 0;
virtual QList<QString> IEnumAvailableCameras(emTpDeviceType camType) = 0;
virtual void ISetTriggerMode(emTpDeviceTriggerMode triggerMode, long nFrameRate) = 0;
virtual emTpDeviceTriggerMode IGetTriggerMode() = 0;
virtual void IManualTrigger(emTpTriggerDirection direct) = 0;
virtual void ISnapImage(const QStringList& camKeys) = 0;
virtual void ISendSoftTrigger(const QStringList& camKeys) = 0;
virtual void IDrawImage(const QString& sKey, QPainter& painter, QRect& rt) = 0;
virtual QImage IShowImage(const QString& sWinId, int& nFrameNum, QString& szExShow) = 0;
virtual QMap<QString, QString> IGetCamShowNames() = 0;
virtual IAlgorithmOption* IGetAlgorithmOption(int nAlgorithm) = 0;
virtual bool ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt) = 0;
virtual bool IReopenCameraes() = 0;
virtual void ISetVirtualImages(const QString& camera, const QStringList& szImages) = 0;
virtual QImage IOriginImage(const QString& sShowId) = 0;
virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property) = 0;
virtual void ISetAlgorithmShared(const QString& key, const QVariant& value) = 0;
virtual void IWriteIo(const TP_IO_OUT_CONTROL& state) = 0;
virtual void ISetResult(const QString& key, QVariant& val) = 0;
//operate camera
virtual bool ICreateCamera(const QString& strSerial, int nType) = 0;
virtual bool IOpenCamera(const QString& strSerial) = 0;
virtual bool ICloseCamera(const QString& strSerial) = 0;
virtual bool IStartCamera(const QString& strSerial) = 0;
virtual bool IStopCamera(const QString& strSerial) = 0;
virtual bool IDeleteCamera(const QString& strSerial) = 0;
virtual bool IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun = false) = 0;
//operate camera window
virtual QList<QString> ICamWinKeys() = 0;
virtual bool ICamWinOptionByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt) = 0;
virtual bool IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew) = 0;
virtual bool IDelCamWin(const QString& strKey) = 0;
//更新json配置文件
virtual bool updateCommJson(const QString& sJsonPath) = 0;
virtual bool updateCamJson(const QString& sJsonPath) = 0;
virtual bool ICamsStartPush() = 0;
virtual bool ICamsPausePush() = 0;
public://private: //use private when the old main is discarded;
virtual int IInitCore(class IDetectorEngine* pDE = NULL) = 0;
virtual void IFreeCore() = 0;
virtual void IStartImageProcess() = 0;
virtual void IEndImageProcess() = 0;
friend class QTpMain;
};
//callback interface from gui
class IGuiCallback
{
public:
IGuiCallback() {}
virtual ~IGuiCallback() {}
virtual void IOnReady() {}
virtual void IUpdateShow(const QString& skey) = 0;
virtual void INewCameraImage(const QVariantMap& vMap) = 0;
virtual void IAddWindows(const QString& sWinName, const QString& sShowId) {};
virtual void ISendDataToUI(emTpUiDataType dataType, const QString& camKey, void* pData) {}//弃用用IVariantMapToUI()替代
virtual void ICameraTrigger(bool bStartOrStop) = 0;//弃用用ICommInterval()替代
virtual void IDrawDefectToScene(const QString& szWinName, IImageObject::emTpDefectType defectType, QByteArray& data) = 0;
virtual void ISafeDataToUI(emTpUiDataType dataType, const QString& camKey, const QByteArray& data) = 0;
virtual void IWarning(int nWarningCode, void* data, int nDataLen) = 0;
virtual void ICommInterval(const char* szCom, int nCmd, BYTE* pData, int nDataLen) = 0;
virtual void IAlgorithmResult(const QVariantMap& varMap) = 0;
virtual void IVariantMapToUI(emTpUiDataType dataType, const QString& camKey, const QVariantMap& vMap) = 0;
virtual QVariant IGetVariantById(int id) = 0;
virtual void IIoStatesChanged(int nOldState, int nNewState) = 0;
virtual void ICommAchieved(const char* szCom, int nCmd, BYTE* pData, int nDataLen) = 0;
virtual WORD IGetWorkState() = 0;//心跳包中发送的用来控制是否触发的值返回0不触发返回1触发
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define TP_SIGNALS \
Q_SIGNALS:\
void sgAddWindows(const QString sWinName, const QString sShowId); \
void sgUpdateShow(const QString skey); \
void sgNewCameraImage(const QVariantMap& vMap); \
void sgSendDataToUI(emTpUiDataType dataType, const QString camKey, void* pData); \
void sgCameraTrigger(bool bStartOrStop); \
void sgDrawDefectToScene(const QString szWinName, IImageObject::emTpDefectType defectType, QByteArray data); \
void sgSafeDataToUI(emTpUiDataType dataType, const QString camKey, const QByteArray data); \
void sgWarning(int nWarningCode, const QByteArray data); \
void sgCommIntervale(const QString szCom, int nCmd, const QByteArray data); \
void sgAlgorithmResult(const QVariantMap varMap); \
void sgVariantMapToUI(emTpUiDataType dataType, const QString camKey, const QVariantMap vMap); \
void sgIoStatesChanged(int nOldState, int nNewState); \
void sgCommAchieved(const QString szCom, int nCmd, const QByteArray data);\
#define TP_SLOTS \
public Q_SLOTS: \
virtual void UpdateShow(const QString skey); \
virtual void NewCameraImage(const QVariantMap& vMap); \
virtual void AddWindows(const QString sWinName, const QString sShowId); \
virtual void SendDataToUI(emTpUiDataType dataType, const QString camKey, void* pData); \
virtual void CameraTrigger(bool bStartOrStop); \
virtual void DrawDefectToScene(const QString szWinName, IImageObject::emTpDefectType defectType, QByteArray data); \
virtual void SafeDataToUI(emTpUiDataType dataType, const QString camKey, const QByteArray data); \
virtual void Warning(int nWarningCode, const QByteArray data); \
virtual void CommIntervale(const QString szCom, int nCmd, const QByteArray data); \
virtual void AlgorithmResult(const QVariantMap varMap); \
virtual void VariantMapToUI(emTpUiDataType dataType, const QString camKey, const QVariantMap vMap); \
virtual void IoStatesChanged(int nOldState, int nNewState); \
virtual void CommAchieved(const QString szCom, int nCmd, const QByteArray data);\
#define TP_CONSTRUCTOR \
connectSignals();
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define TP_CALLBACKS_H \
virtual void IAddWindows(const QString& sWinName, const QString& sShowId); \
virtual void IUpdateShow(const QString& skey); \
virtual void INewCameraImage(const QVariantMap& vMap); \
virtual void ISendDataToUI(emTpUiDataType dataType, const QString& camKey, void* pData); \
virtual void ICameraTrigger(bool bStartOrStop); \
virtual void IDrawDefectToScene(const QString& szWinName, IImageObject::emTpDefectType defectType, QByteArray& data); \
virtual void ISafeDataToUI(emTpUiDataType dataType, const QString& camKey, const QByteArray& data); \
virtual void IWarning(int nWarningCode, void* data, int nDataLen); \
virtual void ICommInterval(const char* szCom, int nCmd, BYTE* pData, int nDataLen); \
virtual void IAlgorithmResult(const QVariantMap& varMap); \
virtual void IVariantMapToUI(emTpUiDataType dataType, const QString& camKey, const QVariantMap& vMap); \
virtual QVariant IGetVariantById(int id); \
virtual void IIoStatesChanged(int nOldState, int nNewState); \
virtual void ICommAchieved(const char* szCom, int nCmd, BYTE* pData, int nDataLen); \
virtual WORD IGetWorkState(); \
void connectSignals();
///
#define TP_CALLBACKS_CPP(cName) \
void cName##::IUpdateShow(const QString& skey) { \
emit sgUpdateShow(skey); \
} \
void cName##::INewCameraImage(const QVariantMap& vMap) { \
emit sgNewCameraImage(vMap); \
} \
void cName##::IAddWindows(const QString& sWinName, const QString& sShowId) { \
emit sgAddWindows(sWinName, sShowId); \
} \
void cName##::ISendDataToUI(emTpUiDataType dataType, const QString& camKey, void* pData) { \
emit sgSendDataToUI(dataType, camKey, pData); \
} \
void cName##::ICameraTrigger(bool bStartOrStop) { \
emit sgCameraTrigger(bStartOrStop); \
} \
void cName##::IDrawDefectToScene(const QString& szWinName, IImageObject::emTpDefectType defectType, QByteArray& data) { \
emit sgDrawDefectToScene(szWinName, defectType, data); \
} \
void cName##::ISafeDataToUI(emTpUiDataType dataType, const QString& camKey, const QByteArray& data) { \
emit sgSafeDataToUI(dataType, camKey, data); \
} \
void cName##::IWarning(int nWarningCode, void* data, int nDataLen) { \
emit sgWarning(nWarningCode, QByteArray((char*)data, nDataLen)); \
}\
void cName##::ICommInterval(const char* szCom, int nCmd, BYTE* pData, int nDataLen) { \
emit sgCommIntervale(QString(szCom), nCmd, QByteArray((char*)pData, nDataLen)); \
} \
void cName##::IAlgorithmResult(const QVariantMap& varMap) { \
emit sgAlgorithmResult(varMap); \
} \
void cName##::IVariantMapToUI(emTpUiDataType dataType, const QString& camKey, const QVariantMap& vMap) { \
emit sgVariantMapToUI(dataType, camKey, vMap); \
} \
void cName##::IIoStatesChanged(int nOldState, int nNewState) { \
emit sgIoStatesChanged(nOldState, nNewState); \
} \
void cName##::ICommAchieved(const char* szCom, int nCmd, BYTE* pData, int nDataLen) { \
emit sgCommAchieved(QString(szCom), nCmd, QByteArray((char*)pData, nDataLen)); \
} \
QVariant cName##::IGetVariantById(int id) { return QVariant(); } \
WORD cName##::IGetWorkState() { return 0; } \
void cName##::connectSignals() { \
QMetaObject::Connection error = connect(this, SIGNAL(sgAddWindows(const QString, const QString)) \
, this, SLOT(AddWindows(const QString, const QString))); \
error = connect(this, SIGNAL(sgUpdateShow(const QString)), this, SLOT(UpdateShow(const QString))); \
error = connect(this, SIGNAL(sgNewCameraImage(const QVariantMap)), this, SLOT(NewCameraImage(const QVariantMap))); \
qRegisterMetaType<emTpUiDataType>("emTpUiDataType"); \
error = connect(this, SIGNAL(sgSendDataToUI(emTpUiDataType, const QString, void*)) \
, this, SLOT(SendDataToUI(emTpUiDataType, const QString, void*))); \
error = connect(this, SIGNAL(sgCameraTrigger(bool)), this, SLOT(CameraTrigger(bool))); \
qRegisterMetaType<IImageObject::emTpDefectType>("IImageObject::emTpDefectType"); \
error = connect(this, SIGNAL(sgDrawDefectToScene(const QString, IImageObject::emTpDefectType, QByteArray)) \
, this, SLOT(DrawDefectToScene(const QString, IImageObject::emTpDefectType, QByteArray))); \
error = connect(this, SIGNAL(sgSafeDataToUI(emTpUiDataType, const QString, const QByteArray)) \
, this, SLOT(SafeDataToUI(emTpUiDataType, const QString, const QByteArray))); \
error = connect(this, SIGNAL(sgWarning(int, const QByteArray)), this, SLOT(Warning(int, const QByteArray))); \
error = connect(this, SIGNAL(sgCommIntervale(const QString, int, const QByteArray)) \
, this, SLOT(CommIntervale(const QString, int, const QByteArray))); \
error = connect(this, SIGNAL(sgAlgorithmResult(const QVariantMap)),this, SLOT(AlgorithmResult(const QVariantMap))); \
error = connect(this, SIGNAL(sgVariantMapToUI(emTpUiDataType, const QString, const QVariantMap)) \
, this, SLOT(VariantMapToUI(emTpUiDataType, const QString, const QVariantMap)));\
error = connect(this, SIGNAL(sgIoStatesChanged(int, int)), this, SLOT(IoStatesChanged(int, int))); \
error = connect(this, SIGNAL(sgCommAchieved(const QString, int, const QByteArray)) \
, this, SLOT(CommAchieved(const QString, int, const QByteArray))); \
} \
#endif

@ -0,0 +1,46 @@
/******************************************************************************
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
#include "baseDefine.h"
#include "baseStruct.h"
typedef struct tagIMGPROC_IN_PARAM{
TP_GLOBAL_DATA* pGlobalData;
}IMGPROC_IN_PARAM;
class IImgProc
{
public:
IImgProc() {}
virtual ~IImgProc() {}
virtual int IImageProcess(class IImageObject* pImgObj, class IDetectorEngine* pDE = NULL) = 0;
virtual class IAlgorithmOption* IGetAlgorithmOption(int nAlgorithm) = 0;
};
// class IImageObject
// {
// public:
// IImageObject() { }
// virtual ~IImageObject() { }
//
// virtual emTpColorFormat IColorFormat() = 0;
// //@nOutBytesPerLine: 0 means there is no valid value
// virtual BYTE* IImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nOutBytesPerLine) = 0;
// virtual int IGetId() = 0;
// virtual int IGetAlgorithm() = 0;
// virtual int IGetFrameNum() = 0;
// virtual int IGetTriggerCount() = 0;
// //////////////////////////////////////////////////////////
// virtual void IAddOverlay() { }
// };
#endif

@ -0,0 +1,63 @@
/******************************************************************************
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$
*******************************************************************************/
#include "zdefines.h"
#include <QtCore\qlibrary.h>
enum tpemIoType {
TP_IO_ADLINK = 1,
};
class IIoInterface
{
public:
IIoInterface() {}
virtual ~IIoInterface() {}
virtual int IIint() = 0;
virtual int IFree() = 0;
virtual int IReadI(qint32& state) = 0;
virtual int IReadO(qint32& state) = 0;
virtual int IWriteO(qint32& state) = 0;
};
#define TP_IOCTRL_DLL "tpIoCtrl"
class QLoadIoCtrl : public QLibrary
{
public:
typedef IIoInterface*(*func_io_create)(int);
typedef void(*func_io_delete)(IIoInterface*);
QLoadIoCtrl(const QString& path)
#ifdef _DEBUG
: QLibrary(path + TP_IOCTRL_DLL + "d")
#else
: QLibrary(path + TP_IOCTRL_DLL)
#endif
{
_ioCreate = (func_io_create)resolve("tp_io_create");
_ioDelete = (func_io_delete)resolve("tp_io_delete");
}
~QLoadIoCtrl(){}
IIoInterface* Create(int type) {
if (NULL == _ioCreate) {
return NULL;
}
return _ioCreate(type);
}
void Delete(IIoInterface* pio) {
if (NULL != _ioDelete) {
_ioDelete(pio);
}
}
private:
func_io_create _ioCreate;
func_io_delete _ioDelete;
};

@ -0,0 +1,105 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:TpICamera.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/20
History:20:3:2015 17:12
*******************************************************************************/
#ifndef __TP_I_CAMERA_H
#define __TP_I_CAMERA_H
//#include <Windows.h>
#include "baseInclude.h"
#include "ZkCameraImage.h"
typedef struct tagCAMERA_IN_PARAM {
class ICameraCallback* pCallback;
TP_GLOBAL_DATA* pGlobalData;
}CAMERA_IN_PARAM;
class ICameraPool
{
public:
ICameraPool() {}
virtual ~ICameraPool() {}
public:
// operation for camera.json
virtual QList<QString> ICameraKeys() = 0;
virtual QList<QString> ICameraKeysOrderByIds() = 0;
virtual bool ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt) = 0;
virtual bool ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt) = 0;
virtual bool ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt) = 0;
// try to get available (connected to the computer) by camera type(manufacturer)
virtual QList<QString> IEnumAvailableCameras(emTpDeviceType camType) = 0;
virtual int ICreateCameraes() = 0;
virtual void IDeleteDameraes() = 0;
virtual bool ICreateCamera(const QString&, int nType) = 0;
virtual bool IOpenCamera(const QString& strSerial, bool bReopen = true) = 0;
virtual bool ICloseCamera(const QString& strSerial) = 0;
virtual bool IStartCamera(const QString& strSerial) = 0;
virtual bool IStopCamera(const QString& strSerial) = 0;
virtual bool IDeleteCamera(const QString& strSerial) = 0;
virtual bool IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun = false) = 0;
virtual int IOpenDevices(bool bReopenAll = true) = 0;
virtual int IOpenDevicesEx(bool bReopenAll = true) = 0; //如果camera.json里面配置了auto_open 值为false则调用该函数不会打开对应相机
virtual void ICloseDevices() = 0;
virtual void IStartDevices() = 0;
virtual void IStopDevices(const QString& sDef = NULL) = 0;
virtual void ISetTriggerMode(emTpDeviceTriggerMode mode, emTpTriggerDirection nDirection = TRIGGER_DIRECT_FOREWARD, long nFrameRate = 0) = 0;
virtual emTpDeviceTriggerMode IGetTriggerMode() = 0;
virtual void IManualTrigger( emTpTriggerDirection nDirection = TRIGGER_DIRECT_FOREWARD) = 0;
virtual void ISnapImage(const QStringList& camKeys) = 0;
virtual void ISendSoftTrigger(const QStringList& camKeys) = 0;
virtual CZkCameraImage* IPopCameraImage() = 0;
virtual void IFreeCameraImage(CZkCameraImage *pCamImg) = 0;
//@camera: NULL means setting every camera
virtual void ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue) = 0;
virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property) = 0;
virtual QList<TP_CAMERA_WIN*> ICameraWins() = 0;
virtual QMap<QString, QString> IGetCamShowNames() = 0;
virtual void ISetCameraEncode(INT64 code, INT64 rate) = 0;
virtual void ISetVirtualImages(const QString& camera, const QStringList& szImages) = 0;
//operate camera window
virtual QList<QString> ICamWinKeys() = 0;
virtual bool ICamWinOptionByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt) = 0;
virtual bool IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew) = 0;
virtual bool IDelCamWin(const QString& strKey) = 0;
virtual bool ICamsStartPush() = 0;
virtual bool ICamsPausePush() = 0;
};
// class ICamera
// {
// public:
// ICamera() {}
// virtual ~ICamera() {}
// public:
// int m_nCameraCode;
// };
class ICameraCallback
{
public:
ICameraCallback() {}
virtual ~ICameraCallback() {}
virtual QVariant IGetVariantById(int nId) = 0;
virtual void INewCameraImage(const QVariantMap& vmap) = 0;
};
// class CTpICamera
// {
// public:
// CTpICamera(void);
// virtual ~CTpICamera(void);
// };
#endif

@ -0,0 +1,50 @@
#ifndef LPALGORITHM_H
#define LPALGORITHM_H
#include "lpbengine.h"
class IAlgo
{
public:
IAlgo(){}
virtual ~IAlgo(){}
virtual bool RegisterFunc(IAlgorithmLib* pAlgoLib) { return true; };
virtual bool Exec(IDetectorTask *lpTask, IDetectorAlgorithm* lpAlgorithm) = 0;
virtual bool Init(IDetectorTask *lpTask, IDetectorAlgorithm* lpAlgorithm) = 0;
virtual void SaveUserParamValue(IDetectorTask *lpTask, IDetectorAlgorithm* lpAlgorithm, QString& strParamName) {};
virtual void LoadUserParamValue(IDetectorTask *lpTask, IDetectorAlgorithm* lpAlgorithm, QString& strParamName, QVariant& value) {};
virtual bool HandleEvent(IDetectorTask *lpTask, IDetectorAlgorithm* lpAlgorithm, QString& strParaName, int event) { return true; };
};
#define REGISTER_FUNCTION_IMPLEMENT(NAME, FUNC) \
if (NULL != pAlgoLib) { \
if (!pAlgoLib->RegisterFunc(#NAME, FUNC)) \
return false; \
}
#define DEFINE_FUNCTION_PARAM_IMPLEMENT(FUNCNAME, PARAMNAME, TYPE, INITVAL, DIR) \
if (NULL != pAlgoLib) { \
LP_ALGORITHM_PARAM_DESC desc; \
desc.strName = PARAMNAME; \
desc.type = TYPE; \
desc.InitVal = INITVAL; \
desc.dir = DIR; \
if (!pAlgoLib->DefFuncParam(#FUNCNAME, desc)) \
return false; \
}
#ifdef ALGO_LIB
# define ALGO_EXPORT extern "C" __declspec(dllexport)
#else
# define ALGO_EXPORT extern "C" __declspec(dllimport)
#endif
typedef void(*FnLpAlgoNewInstance)(IAlgo** lppAlgo);
ALGO_EXPORT void LpAlgoNewInstance(IAlgo** lppAlgo);
ALGO_EXPORT bool LpAlgoDeleteInstance();
#endif // LPALGORITHM_H

@ -0,0 +1,389 @@
#ifndef __LPENGINE_METATYPE_DEFINE_H
#define __LPENGINE_METATYPE_DEFINE_H
#ifndef LPENGINE_SMART_CAMERA
#include "lpbengine.h"
#else
#include "lpbdefine.h"
#endif
namespace LpEngine
{
void task_out_param_save(QDataStream & ds, const void * p)
{
LP_DETECTOR_ALGO_OUT_DATA* d = (LP_DETECTOR_ALGO_OUT_DATA*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
LP_DETECTOR_TASK_OUT_PARAM param = d->at(i);
ds << param.name;
ds << param.type;
ds << param.value;
}
}
}
void task_out_param_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
LP_DETECTOR_ALGO_OUT_DATA* d = (LP_DETECTOR_ALGO_OUT_DATA*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
LP_DETECTOR_TASK_OUT_PARAM param;
ds >> param.name;
int type = 0;
ds >> type;
param.type = (AlgoParamType)type;
ds >> param.value;
d->append(param);
}
}
}
void double_list_save(QDataStream & ds, const void * p)
{
Double_List* d = (Double_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void double_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
Double_List* d = (Double_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
double dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void linef_list_save(QDataStream & ds, const void * p)
{
LineF_List* d = (LineF_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void linef_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
LineF_List* d = (LineF_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
QLineF dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void line_list_save(QDataStream & ds, const void * p)
{
Line_List* d = (Line_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void line_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
Line_List* d = (Line_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
QLine dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void cv_mat_save(QDataStream & ds, const void * p)
{
cv::Mat* d = (cv::Mat*)p;
if (d)
{
int rows = d->rows;
int cols = d->cols;
int type = d->type();
int step = d->step;
ds << (int)rows;
ds << (int)cols;
ds << (int)type;
ds << (int)step;
ds.writeRawData((const char*)d->data, step*rows);
}
}
void cv_mat_load(QDataStream & ds, void * p)
{
cv::Mat* d = (cv::Mat*)p;
if (d)
{
int rows, cols, type;
int step;
ds >> rows;
ds >> cols;
ds >> type;
ds >> step;
if (rows > 0 && step > 0)
{
uchar* pdata = new uchar[rows * step];
ds.readRawData((char*)pdata, rows * step);
*d = cv::Mat(rows, cols, type, (void*)pdata, step);
}
}
}
void point_list_save(QDataStream & ds, const void * p)
{
Point_List* d = (Point_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void point_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
Point_List* d = (Point_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
QPoint dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void pointf_list_save(QDataStream & ds, const void * p)
{
PointF_List* d = (PointF_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void pointf_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
PointF_List* d = (PointF_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
QPointF dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void ploygon_list_save(QDataStream & ds, const void * p)
{
Ploygon_List* d = (Ploygon_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void ploygon_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
Ploygon_List* d = (Ploygon_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
QPolygon dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void ploygonf_list_save(QDataStream & ds, const void * p)
{
PloygonF_List* d = (PloygonF_List*)p;
if (d)
{
ds << d->size();
for (int i = 0; i < d->size(); i++)
{
ds << d->at(i);
}
}
}
void ploygonf_list_load(QDataStream & ds, void * p)
{
int nCount = 0;
ds >> nCount;
PloygonF_List* d = (PloygonF_List*)p;
if (d)
{
for (int i = 0; i < nCount; i++)
{
QPolygonF dVal;
ds >> dVal;
d->append(dVal);
}
}
}
void mat_polygonf_save(QDataStream & ds, const void * p)
{
MatEx* d = (MatEx*)p;
if (d)
{
QVariant var;
var.setValue(d->first);
ds << var;
ds << d->second;
}
}
void mat_polygonf_load(QDataStream & ds, void * p)
{
MatEx* d = (MatEx*)p;
if (d)
{
QVariant var;
ds >> var;
d->first = var.value<cv::Mat>();
ds >> d->second;
}
}
void algo_exec_result_save(QDataStream & ds, const void * p)
{
AlgoExecResult* d = (AlgoExecResult*)p;
if (d)
{
ds << d->code;
ds << d->errMsg;
}
}
void algo_exec_result_load(QDataStream & ds, void * p)
{
AlgoExecResult* d = (AlgoExecResult*)p;
if (d)
{
ds >> d->code;
ds >> d->errMsg;
}
}
void initUserTypeDefine()
{
qRegisterMetaType<LP_DETECTOR_ALGO_OUT_DATA>("task_out_param");
QMetaType::registerStreamOperators("task_out_param", task_out_param_save, task_out_param_load);
qRegisterMetaType<Double_List>("double_list");
QMetaType::registerStreamOperators("double_list", double_list_save, double_list_load);
qRegisterMetaType<LineF_List>("linef_list");
QMetaType::registerStreamOperators("linef_list", linef_list_save, linef_list_load);
qRegisterMetaType<Line_List>("line_list");
QMetaType::registerStreamOperators("line_list", line_list_save, line_list_load);
qRegisterMetaType<cv::Mat>("cv_mat");
QMetaType::registerStreamOperators("cv_mat", cv_mat_save, cv_mat_load);
qRegisterMetaType<Ploygon_List>("ploygon_list");
QMetaType::registerStreamOperators("ploygon_list", ploygon_list_save, ploygon_list_load);
qRegisterMetaType<PloygonF_List>("ploygonf_list");
QMetaType::registerStreamOperators("ploygonf_list", ploygonf_list_save, ploygonf_list_load);
qRegisterMetaType<Point_List>("point_list");
QMetaType::registerStreamOperators("point_list", point_list_save, point_list_load);
qRegisterMetaType<PointF_List>("pointf_list");
QMetaType::registerStreamOperators("pointf_list", pointf_list_save, pointf_list_load);
qRegisterMetaType<MatEx>("mat_polygonf");
QMetaType::registerStreamOperators("mat_polygonf", mat_polygonf_save, mat_polygonf_load);
qRegisterMetaType<AlgoExecResult>("algo_exec_result");
QMetaType::registerStreamOperators("algo_exec_result", algo_exec_result_save, algo_exec_result_load);
}
}
#endif // __LPENGINE_METATYPE_DEFINE_H

@ -0,0 +1,184 @@
#ifndef LPBDEFINE_H
#define LPBDEFINE_H
#include "cv.h"
#include "highgui.h"
#include <QtCore>
#include <QtGui\QImage>
#include "QJsonDocument"
#include "QJsonArray"
#include "QJsonObject"
#include <opencv2/opencv.hpp>
#include <opencv2/opencv_modules.hpp>
#ifndef BYTE
typedef unsigned char BYTE;
#endif
#ifndef WORD
typedef unsigned short WORD;
#endif
#ifndef DWORD
typedef unsigned long DWORD;
#endif
//#ifndef size_t
//typedef unsigned int size_t;
//#endif
#ifndef LPWORD
typedef WORD *LPWORD;
#endif
#ifndef LPDWORD
typedef DWORD *LPDWORD;
#endif
#define BASE_MAX_FOLDER_NAME_SIZE 64
#define BASE_MAX_FILE_NAME_SIZE 64
#define LP_DETECTOR_BUSSINESS_CONFIG_DIR "./config/"
#define LP_DETECTOR_BUSSINESS_IMAGE_DIR "./images/"
#define LP_DETECTOR_BUSSINESS_IN_PARAM_FILE_DIR "./paramfiles/"
#define LP_DETECTOR_BUSSINESS_CONFIG_SOLUTIONMGR_FILE "./config/solutionmgr.json"
#define LP_DETECTOR_BUSSINESS_CONFIG_DEVICEMGR_FILE "./config/devicemgr.json"
#define LP_DETECTOR_BUSSINESS_DB "info.db"
#define LP_DETECTOR_BUSSINESS_CONFIG_FILE_NAME "systemInfo.ini"
#define LP_DETECTOR_BUSSINESS_CONFIG_SOLUTIONMGR_INFO_FILE "./solutions/info.json"
#define LP_DETECTOR_BUSSINESS_CONFIG_SOLUTION_DIR "./solutions/"
#define LP_DETECTOR_BUSSINESS_CONFIG_ALGO_DIR "./algorithmLib/"
#define LP_DETECTOR_BUSSINESS_CONFIG_PARAMSHARE_FILE "./config/paramshare.json"
#define LP_DETECTOR_INVALID_ID 0xffffffff
#define LP_DETECTOR_ALGO_PARAM_INPUT_ROI "roi"
#define LP_DETECTOR_ALGO_PARAM_RELY_COORDINATE "rely_coordinate"
#define LP_DETECTOR_ALGO_PARAM_RELATIVE_ROI "relative_roi"
const DWORD LP_DETECTOR_DEVICE_SERIALPORT_BASE = 0x0210FFFF;
namespace EngineBase
{
static cv::Mat QImage2cvMat(QImage image)
{
cv::Mat mat;
switch (image.format())
{
case QImage::Format_ARGB32:
case QImage::Format_RGB32:
case QImage::Format_ARGB32_Premultiplied:
mat = cv::Mat(image.height(), image.width(), CV_8UC4, (void*)image.constBits(), image.bytesPerLine());
break;
case QImage::Format_RGB888:
mat = cv::Mat(image.height(), image.width(), CV_8UC3, (void*)image.constBits(), image.bytesPerLine());
cv::cvtColor(mat, mat, CV_BGR2RGB);
break;
case QImage::Format_Indexed8:
mat = cv::Mat(image.height(), image.width(), CV_8UC1, (void*)image.constBits(), image.bytesPerLine());
break;
}
return mat;
}
static QImage convMat2QImage(cv::Mat & mat)
{
//qDebug() << "ERROR: Mat could not be converted to QImage.";
// 8-bits unsigned, NO. OF CHANNELS = 1
if (mat.type() == CV_8UC1)
{
QImage image(mat.cols, mat.rows, QImage::Format_Indexed8);
// Set the color table (used to translate colour indexes to qRgb values)
image.setColorCount(256);
for (int i = 0; i < 256; i++)
{
image.setColor(i, qRgb(i, i, i));
}
// Copy input Mat
uchar *pSrc = mat.data;
for (int row = 0; row < mat.rows; row++)
{
uchar *pDest = image.scanLine(row);
memcpy(pDest, pSrc, mat.cols);
pSrc += mat.step;
}
return image;
}
// 8-bits unsigned, NO. OF CHANNELS = 3
else if (mat.type() == CV_8UC3)
{
// Copy input Mat
const uchar *pSrc = (const uchar*)mat.data;
// Create QImage with same dimensions as input Mat
QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
return image.rgbSwapped();
}
else if (mat.type() == CV_8UC4)
{
qDebug() << "CV_8UC4";
// Copy input Mat
const uchar *pSrc = (const uchar*)mat.data;
// Create QImage with same dimensions as input Mat
QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_ARGB32);
return image.copy();
}
else
{
qDebug() << "ERROR: Mat could not be converted to QImage.";
return QImage();
}
}
static bool DeleteDir(const QString &dirName)
{
if (dirName.isEmpty())
{
return false;
}
QDir dir(dirName);
if (!dir.exists())
{
return true;
}
QString srcPath = QDir::toNativeSeparators(dirName);
if (!srcPath.endsWith(QDir::separator()))
srcPath += QDir::separator();
QStringList fileNames = dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot | QDir::Hidden);
bool error = false;
for (QStringList::size_type i = 0; i != fileNames.size(); ++i)
{
QString filePath = srcPath + fileNames.at(i);
QFileInfo fileInfo(filePath);
if (fileInfo.isFile() || fileInfo.isSymLink())
{
QFile::setPermissions(filePath, QFile::WriteOwner);
if (!QFile::remove(filePath))
{
error = true;
}
}
else if (fileInfo.isDir())
{
if (!DeleteDir(filePath))
{
error = true;
}
}
}
if (!dir.rmdir(QDir::toNativeSeparators(dir.path())))
{
qWarning() << "remove dir" << dir.path() << " faild!";
error = true;
}
return !error;
}
}
#endif // LPBDEFINE_H

Binary file not shown.

@ -0,0 +1,41 @@
#ifndef LPDESIGNER_H
#define LPDESIGNER_H
#include "lpdsgdefine.h"
#include "SystemStateInfo.h"
#include <QtCore>
//#include "vld.h"
class IDetectorEngine;
class IDetectorTask;
class IDetectorUISink
{
public:
virtual void OnManualTrigger() = 0;
virtual void ResetItem(QPoint pos, QRect size) = 0;
virtual void OnSetParam(IDetectorTask* pTask) = 0;
};
class IDetectorUI
{
public:
virtual bool ShowDeviceMgrDlg() = 0;
virtual bool ShowSolutionMgrDlg() = 0;
virtual bool ShowMainFrame() = 0;
virtual bool ShowReportView(QMap<QString, QVariant> statInfo) = 0;
};
#ifdef LPDESIGNER_LIB
# define LPDESIGNER_EXPORT extern "C" __declspec(dllexport)
#else
# define LPDESIGNER_EXPORT extern "C" __declspec(dllimport)
#endif
typedef void(*FnLpDesignerNewInstance)(IDetectorUI **lppDetectorUI, IDetectorEngine *lpDE, IDetectorUISink* lpSink);
LPDESIGNER_EXPORT void LpDesignerNewInstance(IDetectorUI **lppDetectorUI, IDetectorEngine *lpDE, IDetectorUISink* lpSink);
LPDESIGNER_EXPORT bool LpDesignerDeleteInstance();
#endif // LPDESIGNER_H

@ -0,0 +1,9 @@
#ifndef LPDSGDEFINE_H
#define LPDSGDEFINE_H
#define LP_DETECTOR_DSG_TASK_ITEM_LOAD "Load"
#define LP_DETECTOR_UI_CONFIG_FILE_NAME "set.ini"
#define LP_DETECTOR_UI_REPORT_FOLDER "./report/"
#endif // LPDSGDEFINE_H

@ -0,0 +1,26 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:sysInclude.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/08
History:8:4:2015 13:36
*******************************************************************************/
#ifndef __SYS_INCLUDE_H_20150408
#define __SYS_INCLUDE_H_20150408
#ifdef QT_CORE_LIB
#include <QtCore/QString>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtGui/QImage>
#include <QtCore/QTime>
#include <QtGui/QPixmap>
#endif
#if defined(Q_OS_WIN) || defined(WIN32) || defined(WIN64)
#include <Windows.h>
#endif
#endif

@ -0,0 +1,48 @@
#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;
}

@ -0,0 +1,22 @@
#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

@ -0,0 +1,45 @@
#include "AlgorithmShared.h"
CAlgorithmShared::CAlgorithmShared()
: m_stamp(0)
{
SetValue(ALG_SHARED_GLOBAL_KEY_APP_STATUS, APP_STATUS_DEFAULT);
}
CAlgorithmShared::~CAlgorithmShared()
{
}
void CAlgorithmShared::SetValue(const QString& key, const QVariant& value)
{
m_values.insert(key, value);
updateStamp();
}
QStringList CAlgorithmShared::IGetStringList(const QString& key)
{
if (!m_values.contains(key))
{
return QStringList();
}
return m_values[key].toStringList();
}
int CAlgorithmShared::IGetInt(const QString& key, int nDef/* = 0*/)
{
if (!m_values.contains(key))
{
return nDef;
}
bool bOk;
int nRet = m_values[key].toInt(&bOk);
if (bOk)
{
return nRet;
}
else
{
return nDef;
}
}

@ -0,0 +1,29 @@
#ifndef ALGORITHMSHARED_H
#define ALGORITHMSHARED_H
#include "iAlgorithm.h"
#include <QtCore\qvariant.h>
#include <QtCore\qdatetime.h>
class CAlgorithmShared : public IAlgorithmShared
{
public:
CAlgorithmShared();
~CAlgorithmShared();
virtual UINT64 ILastUpdateTime() {
return m_stamp;
}
virtual QStringList IGetStringList(const QString& key);
virtual int IGetInt(const QString& key, int nDef = 0);
void SetValue(const QString& key, const QVariant& value);
private:
void updateStamp() {
m_stamp = QDateTime::currentDateTime().toTime_t();
}
private:
QVariantMap m_values;
uint m_stamp;
};
#endif // ALGORITHMSHARED_H

@ -0,0 +1,479 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:CoreCtrl.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/24
History:24:3:2015 17:22
*******************************************************************************/
#include "CoreCtrl.h"
#include "globalCoreCtrl.h"
#include "baseFunction.h"
#include "QZkJsonParser.h"
#include <QDebug>
#include <QThreadPool>
CCoreCtrl::CCoreCtrl(void)
{
}
CCoreCtrl::~CCoreCtrl(void)
{
IFreeCore();
}
int CCoreCtrl::IInitCore(class IDetectorEngine* pDE /*= NULL*/)
{
int nRet = 0;
nRet = createShowWindows();//根据camera.json中的"windows"创建显示窗口内存,
//create threads
int nCount = gCoreSetting.threadsCount;
if (nCount <= 0)
{
nCount = SYS_F::GetCpus();//获取系统cpu线程数量
}
/*创建图片处理线程*/
for (int i = 0; i < nCount; ++i)
{
QTpThreadImage *pThd = new QTpThreadImage(this, pDE);
if( NULL == pThd )
{
break;
}
// pThd->StartThread();
// pThd->setPriority(QThread::TimeCriticalPriority);
m_imgThdPool.append(pThd);
++nRet;
}
//
IStartImageProcess();
//create cameraes...
glpCameralPool->ICreateCameraes();//更加camera.json 创建相机对象
glpCameralPool->IOpenDevicesEx();//打开相机
glpCameralPool->ISetTriggerMode(DEV_TRIGGER_MODE_OUT);//设置默认的触发模式
glpCameralPool->IStartDevices();//设置相机开始工作
return nRet;
}
void CCoreCtrl::IFreeCore()
{
glpCameralPool->IStopDevices();//设置相机停止工作
glpCameralPool->ICloseDevices();//关闭相机
glpCameralPool->IDeleteDameraes();//删除相机
//删除图片处理线程
while( !m_imgThdPool.isEmpty() )
{
QTpThreadImage* pThd = m_imgThdPool.takeLast();
pThd->EndThread();
delete pThd;
}
//m_showImages.clear(releaseShowImage);
m_showWindows.clear(releaseShowWindow);//删除用用图像显示窗口内存
// 这里等待所有线程完成工作虽然用clear也可以
// 但是程序在退出的时候会跳出来错误。不够友好
QThreadPool::globalInstance()->waitForDone();
//QThreadPool::globalInstance()->clear();
}
void CCoreCtrl::IStartImageProcess()
{
for (int i = 0; i < m_imgThdPool.size(); i++)
{
m_imgThdPool.at(i)->StartThread();
m_imgThdPool.at(i)->setPriority(QThread::TimeCriticalPriority);
}
}
void CCoreCtrl::IEndImageProcess()
{
for (int i = 0; i < m_imgThdPool.size(); i++)
{
m_imgThdPool.at(i)->EndThread();
}
}
//void CCoreCtrl::releaseShowImage(const QString& k, QZkShowImage*& v, void* pData)
//{
// delete v;
//}
bool CCoreCtrl::ShowCameraImage(const ZStringA& serial, UINT nFrameNum, QImage& image, INT64 nStamp, int nIndex/* = 0*/, const QString& szExtend /*= NULL*/)
{
QVariantMap map;
map.clear();
map.insert("camera", serial);
map.insert("frame", nFrameNum);
QVariant vimg;
vimg.setValue(image);
map.insert("image", vimg);
glpGuiCallback->INewCameraImage(map);
QString sWinId = serial + "_" + QString::number(nIndex);
CShowWindow* pWin = m_showWindows.value(sWinId, NULL);
if (NULL != pWin && pWin->AddCameraImage(image, nFrameNum, nStamp, szExtend)/*pWin->SetCameraImage(pCamImage)*/)
{
glpGuiCallback->IUpdateShow(pWin->CameraWin().key);
return true;
}
else
{
return false;
}
}
void CCoreCtrl::DrawDefectOrg(IImageObject::emTpDefectType defectType, BYTE* pData, int nDataLen, CZkCameraImage* pCamImage)
{
QString sWinId = QString::fromUtf8(pCamImage->Serial()) + "_" + QString::number(0);
CShowWindow* pWin = m_showWindows.value(sWinId, NULL);
if (NULL != pWin && pWin->DrawDefect(defectType, pData, nDataLen, pCamImage))
{
glpGuiCallback->IUpdateShow(pWin->CameraWin().key);
}
}
void CCoreCtrl::DrawImageOrg(QImage& srcImg, CZkCameraImage* pCamImage)
{
if (!ShowCameraImage(pCamImage->Serial(), pCamImage->FrameNumber(), srcImg, pCamImage->Stamp(), 1, QString::fromUtf8(pCamImage->FileName())))
{
QString sWinId = QString::fromUtf8(pCamImage->Serial()) + "_" + QString::number(0);
CShowWindow* pWin = m_showWindows.value(sWinId, NULL);
if (NULL != pWin && pWin->DrawImage(srcImg, pCamImage->FrameNumber(), QString::fromUtf8(pCamImage->FileName())))
{
glpGuiCallback->IUpdateShow(pWin->CameraWin().key);
}
}
}
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());
}
}
/*
void CCoreCtrl::setShowWindow(CShowWindow*& pWin, void* pData)
{
;
}
*/
//void CCoreCtrl::setShowImage(const QString& k, QZkShowImage*& v, void* pData)
//{
// v->SetShowImage((CZkCameraImage*)pData);
//}
QList<QString> CCoreCtrl::ICameraKeys()
{
return glpCameralPool->ICameraKeys();
}
QList<QString> CCoreCtrl::ICameraKeysOrderByIds()
{
return glpCameralPool->ICameraKeysOrderByIds();
}
bool CCoreCtrl::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{
return glpCameralPool->ICameraOption(strSerial, camOpt);
}
bool CCoreCtrl::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{
return glpCameralPool->ICameraOptionByKey(strSerial, camOpt);
}
QList<QString> CCoreCtrl::IEnumAvailableCameras(emTpDeviceType camType)
{
return glpCameralPool->IEnumAvailableCameras(camType);
}
void CCoreCtrl::ISetTriggerMode(emTpDeviceTriggerMode triggerMode, long nFrameRate)
{
glpCameralPool->ISetTriggerMode(triggerMode, TRIGGER_DIRECT_FOREWARD, nFrameRate);
}
void CCoreCtrl::IManualTrigger(emTpTriggerDirection direct)
{
glpCameralPool->IManualTrigger(direct);
}
void CCoreCtrl::ISnapImage(const QStringList& camKeys)
{
glpCameralPool->ISnapImage(camKeys);
}
void CCoreCtrl::ISendSoftTrigger(const QStringList& camKeys)
{
glpCameralPool->ISendSoftTrigger(camKeys);
}
void CCoreCtrl::IDrawImage(const QString& sKey, QPainter& painter, QRect& rt)
{
/*
tagDrawShowImageParam param;
param.painter = &painter;
param.rt = &rt;
m_showImages.valueCall(sKey, drawShowImage, &param);*/
}
//void CCoreCtrl::drawShowImage(const QString& key, QZkShowImage*& v, void* pData)
//{
// tagDrawShowImageParam* param = (tagDrawShowImageParam*)pData;
// v->DrawToPainter(param->painter, param->rt);
//// param->painter->drawPixmap()
//}
int CCoreCtrl::createShowWindows()
{
int nCount = 0;
// QList<TP_CAMERA_WIN*> camWins = glpCameralPool->ICameraWins();
// for (int i = 0; i < camWins.size(); ++i)
// {
// CShowWindow* pShow = new CShowWindow(camWins[i]);
// if (NULL == pShow)
// {
// continue;
// }
// if (m_showWindows.contains(pShow->WindowId()))
// {
// delete pShow;
// continue;
// }
// m_showWindows.insert(pShow->WindowId(), pShow);
// gGuiCallback_FuncCall(IAddWindows, camWins[i]->key, pShow->WindowId());
// ++nCount;
// }
return nCount;
}
void CCoreCtrl::releaseShowWindow(CShowWindow*& pWin, void* pData)
{
delete pWin;
pWin = NULL;
}
bool CCoreCtrl::IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew)
{
if (glpCameralPool->IAddCamWin(strKey, camwinOpt, bNew))
{
if (bNew){
QList<TP_CAMERA_WIN*> camWins = glpCameralPool->ICameraWins();
for (int i = 0; i < camWins.size(); ++i)
{
if (camWins[i]->key.compare(strKey, Qt::CaseInsensitive) == 0){
CShowWindow* pShow = new CShowWindow(camWins[i]);
if (!pShow) return false;
if (m_showWindows.contains(pShow->WindowId()))
{
delete pShow;
return false;
}
m_showWindows.insert(pShow->WindowId(), pShow);
gGuiCallback_FuncCall(IAddWindows, camWins[i]->key, pShow->WindowId());
return true;
}
}
}
return true;
}
return false;
}
bool CCoreCtrl::IDelCamWin(const QString& strKey)
{
TP_CAMERA_WIN optCamWin;
if (ICamWinOptionByKey(strKey, optCamWin)){
QString strWinId = QString(optCamWin.device) + "_" + QString::number(optCamWin.index);
CShowWindow* pShow = m_showWindows.value(strWinId);
if (pShow){
m_showWindows.remove(strWinId);
delete pShow;
pShow = NULL;
}
}
return glpCameralPool->IDelCamWin(strKey);
}
QImage CCoreCtrl::IShowImage(const QString& sShowId, int& nFrameNum, QString& szExShow)
{
CShowWindow* pWin = m_showWindows.value(sShowId, NULL);
if (NULL == pWin)
{
nFrameNum = -1;
return QImage();
}
else
{
nFrameNum = pWin->FrameNum();
szExShow = pWin->ExtendString();
return pWin->ShowImage();
}
}
QMap<QString, QString> CCoreCtrl::IGetCamShowNames()
{
return glpCameralPool->IGetCamShowNames();
}
IAlgorithmOption* CCoreCtrl::IGetAlgorithmOption(int nAlgorithm)
{
return glpImgProc->IGetAlgorithmOption(nAlgorithm);
}
bool CCoreCtrl::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
{
return glpCameralPool->ISetCameraOption(strSerial, camOpt);
}
bool CCoreCtrl::IReopenCameraes()
{
return glpCameralPool->IOpenDevices();
}
void CCoreCtrl::ISetVirtualImages(const QString& camera, const QStringList& szImages)
{
glpCameralPool->ISetVirtualImages(camera, szImages);
}
QImage CCoreCtrl::IOriginImage(const QString& sShowId)
{
CShowWindow* pWin = m_showWindows.value(sShowId, NULL);
if (NULL == pWin)
{
return QImage();
}
else
{
return pWin->OriginImage();
}
}
void CCoreCtrl::ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
{
return glpCameralPool->ISetCameraProperty(camera, property);
}
void CCoreCtrl::ISetAlgorithmShared(const QString& key, const QVariant& value)
{
m_algShared.SetValue(key, value);
}
void CCoreCtrl::IWriteIo(const TP_IO_OUT_CONTROL& state)
{
}
bool CCoreCtrl::updateCommJson(const QString& sJsonPath)
{
return false;
}
bool CCoreCtrl::updateCamJson(const QString& sJsonPath)
{
int nError;
QJsonObject originObjJson = QZkJsonParser::ReadJsonObject(sJsonPath, &nError);
QJsonObject cameraRoot;
QJsonObject cameraDevs;
QList<QString> cameralist = ICameraKeys();
foreach(const QString& strCameraName, cameralist)
{
TP_CAMERA_OPTION camopt;
if (ICameraOptionByKey(strCameraName, camopt))
{
QJsonObject camObj;
camObj["id"] = camopt.id;
camObj["type"] = camopt.deviceType;
camObj["showname"] = camopt.showName;
camObj["format"] = "None";
QMap<emTpColorFormat, QString>::const_iterator iter = gColorNameMap.find(camopt.format);
if (iter != gColorNameMap.constEnd())
{
camObj["format"] = iter.value();
}
camObj["folder"] = camopt.folder;
camObj["zoom"] = camopt.zoom;
camObj["save"] = camopt.save;
camObj["save_img_suffix"] = camopt.saveImgSuffix;
camObj["algorithm"] = camopt.algorithm;
camObj["rely_on_camera"] = camopt.relyOnCamera;
camObj["board_type"] = camopt.boardType;
camObj["board_num"] = camopt.boardNum;
camObj["loop"] = camopt.loop;
camObj["algorithm_dll"] = camopt.dllsuffix.toInt();
camObj["exposure"] = camopt.exposure;
camObj["gain"] = camopt.gain;
camObj["savefile_rgb_swapped"] = camopt.bNeedRgbSwapped;
camObj["board_name"] = camopt.sBoardName;
camObj["board_config_file"] = camopt.sBoardConfigFile;
cameraDevs[camopt.uniqueName] = camObj;
}
}
cameraRoot["devices"] = cameraDevs;
cameraRoot["pool"] = originObjJson["pool"].toObject();
QJsonObject cameraWins;
QList<QString> camwinlist = ICamWinKeys();
foreach(const QString& strCamWinName, camwinlist)
{
TP_CAMERA_WIN camwinOpt;
if (ICamWinOptionByKey(strCamWinName, camwinOpt))
{
QJsonObject camwinObj;
camwinObj["bitsperpixel"] = camwinOpt.bitsPerPixel;
camwinObj["buffer_h"] = camwinOpt.bufferH;
camwinObj["buffer_w"] = camwinOpt.bufferW;
camwinObj["buffers"] = camwinOpt.buffers;
camwinObj["cache_origin"] = camwinOpt.bCacheOriginImage;
camwinObj["device"] = camwinOpt.device;
camwinObj["images"] = camwinOpt.images;
camwinObj["index"] = camwinOpt.index;
camwinObj["mirror"] = camwinOpt.mirror;
camwinObj["rgb_swapped"] = camwinOpt.bNeedRgbSwapped;
cameraWins[camwinOpt.key] = camwinObj;
}
}
cameraRoot["windows"] = cameraWins;
return saveJsonToFile(cameraRoot, sJsonPath);
}
bool CCoreCtrl::saveJsonToFile(const QJsonObject& json, const QString& fileFullName)
{
QFile saveFile(fileFullName);
if (!saveFile.open(QIODevice::WriteOnly)) {
qWarning() << "Couldn't open save file - " << fileFullName
<< " - " << __FUNCTION__;
return false;
}
QJsonDocument saveDoc(json);
saveFile.write(saveDoc.toJson());
return true;
}

@ -0,0 +1,100 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:CoreCtrl.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/24
History:24:3:2015 17:21
*******************************************************************************/
#ifndef __CORE_CTRL_H
#define __CORE_CTRL_H
#include "iCoreCtrl.h"
#include "qtpthreadimage.h"
#include "QZkMutexMap.h"
//#include "QZkShowImage.h"
#include "ShowWindow.h"
#include "AlgorithmResult.h"
#include "AlgorithmShared.h"
class CCoreCtrl : public ICoreCtrl
{
public:
CCoreCtrl(void);
virtual ~CCoreCtrl(void);
//初始化CoreCtrl
virtual int IInitCore(class IDetectorEngine* pDE = NULL);
//释放CoreCtrl
virtual void IFreeCore();
//开始执行算法处理
virtual void IStartImageProcess();
virtual void IEndImageProcess();
bool ShowCameraImage(const ZStringA& serial, UINT nFrameNum, QImage& image, INT64 nStamp, int nIndex = 0, const QString& szExtend = NULL);
void DrawDefectOrg(IImageObject::emTpDefectType defectType, BYTE* pData, int nDataLen, CZkCameraImage* pCamImage);
void DrawImageOrg(QImage& srcImg, CZkCameraImage* pCamImage);
void AccumulateResult(const QString& key, QVariant& val);
virtual void ISetResult(const QString& key, QVariant& val);
private:
virtual QList<QString> ICameraKeys();
virtual QList<QString> ICameraKeysOrderByIds();
virtual bool ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt);
virtual bool ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt);
virtual QList<QString> IEnumAvailableCameras(emTpDeviceType camType); // try to get available (connected to the computer) by camera type(manufacturer)
virtual void ISetTriggerMode(emTpDeviceTriggerMode triggerMode, long nFrameRate);
virtual emTpDeviceTriggerMode IGetTriggerMode() { return glpCameralPool->IGetTriggerMode(); }
virtual void IManualTrigger(emTpTriggerDirection direct);
virtual void ISnapImage(const QStringList& camKeys);
virtual void ISendSoftTrigger(const QStringList& camKeys);
virtual void IDrawImage(const QString& sKey, QPainter& painter, QRect& rt);
virtual QImage IShowImage(const QString& sShowId, int& nFrameNum, QString& szExShow);
virtual QMap<QString, QString> IGetCamShowNames();
virtual IAlgorithmOption* IGetAlgorithmOption(int nAlgorithm);
virtual bool ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt);
virtual bool IReopenCameraes();
virtual void ISetVirtualImages(const QString& camera, const QStringList& szImages);
virtual QImage IOriginImage(const QString& sShowId);
virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property);
virtual void ISetAlgorithmShared(const QString& key, const QVariant& value);
virtual void IWriteIo(const TP_IO_OUT_CONTROL& state);
//camera operate
virtual bool ICreateCamera(const QString& strSerial, int nType) { return glpCameralPool->ICreateCamera(strSerial, nType); }
virtual bool IOpenCamera(const QString& strSerial) { return glpCameralPool->IOpenCamera(strSerial); }
virtual bool ICloseCamera(const QString& strSerial) { return glpCameralPool->ICloseCamera(strSerial); }
virtual bool IStartCamera(const QString& strSerial) { return glpCameralPool->IStartCamera(strSerial); }
virtual bool IStopCamera(const QString& strSerial) { return glpCameralPool->IStopCamera(strSerial); }
virtual bool IDeleteCamera(const QString& strSerial) { return glpCameralPool->IDeleteCamera(strSerial); }
virtual bool IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun = false) { return glpCameralPool->IAddCamera(strName, camOpt, bNew, bAutoRun); }
//operate camera window
virtual QList<QString> ICamWinKeys() { return glpCameralPool->ICamWinKeys(); }
virtual bool ICamWinOptionByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt) { return glpCameralPool->ICamWinOptionByKey(strKey, camwinOpt); }
virtual bool IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew);
virtual bool IDelCamWin(const QString& strKey);
//更新json配置文件
virtual bool updateCommJson(const QString& sJsonPath);
virtual bool updateCamJson(const QString& sJsonPath);
bool saveJsonToFile(const QJsonObject& json, const QString& fileFullName);
virtual bool ICamsStartPush() { return glpCameralPool->ICamsStartPush(); }
virtual bool ICamsPausePush() { return glpCameralPool->ICamsPausePush(); }
private:
int createShowWindows();
static void releaseShowWindow(CShowWindow*& pWin, void* pData);
private:
QList<QTpThreadImage*> m_imgThdPool;
//QZkMutexMap<QString, QZkShowImage*> m_showImages;
QZkMutexMap<QString, CShowWindow*> m_showWindows;
CAlgorithmResult m_algResult;
CAlgorithmShared m_algShared;
int m_nCoreCount;
friend class CImageObject;
};
#endif

@ -0,0 +1,53 @@
#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;
}

@ -0,0 +1,20 @@
#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

@ -0,0 +1,249 @@
#include "ImageObject.h"
#include "CoreCtrl.h"
#include "zfunctions.h"
CImageObject::CImageObject(class CCoreCtrl* pCoreCtrl)
: m_pCoreCtrl(pCoreCtrl)
{
m_pCamImg = NULL;
}
CImageObject::~CImageObject()
{
}
bool CImageObject::SetCameraImage(CZkCameraImage* pCamImage)
{
m_pCamImg = pCamImage;
return true;
}
emTpColorFormat CImageObject::IColorFormat()
{
if( NULL == m_pCamImg )
{
return TP_COLOR_NONE;
}
else
{
return m_pCamImg->ColorFormat();
}
}
BYTE* CImageObject::IImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nBytesPerLine)
{
if( NULL == m_pCamImg )
{
return NULL;
}
else
{
return m_pCamImg->ImageData(nOutW, nOutH, nOutBitsPerPixel, nBytesPerLine);
}
}
int CImageObject::IGetId()
{
if( NULL == m_pCamImg )
{
return 0;
}
else
{
return m_pCamImg->GetId();
}
}
int CImageObject::IGetAlgorithm()
{
if( NULL == m_pCamImg )
{
return 0;
}
else
{
return m_pCamImg->Algorithm();
}
}
int CImageObject::IGetFrameNum()
{
if( NULL == m_pCamImg )
{
return 0;
}
else
{
return m_pCamImg->FrameNumber();
}
}
int CImageObject::IGetTriggerCount()
{
if( NULL == m_pCamImg )
{
return 0;
}
else
{
return m_pCamImg->TriggerCount();
}
}
void CImageObject::ISetCameroProperty(TP_CAMERA_PROPERTY& property)
{
if( NULL != m_pCamImg )
{
glpCameralPool->ISetCameraProperty(m_pCamImg->Serial(), property);
}
}
void CImageObject::ISendDataToUI(void* pData)
{
if (NULL != m_pCamImg)
{
gGuiCallback_FuncCall(ISendDataToUI, TP_UI_DATA_FROM_ALGORITHM, m_pCamImg->Serial(), pData);
}
}
void CImageObject::ISafeDataToUI(void* pData, int nDataLen)
{
QByteArray data((char*)pData, nDataLen);
if (NULL != m_pCamImg)
{
gGuiCallback_FuncCall(ISafeDataToUI, TP_UI_DATA_FROM_ALGORITHM, m_pCamImg->Serial(), data);
}
else
{
gGuiCallback_FuncCall(ISafeDataToUI, TP_UI_DATA_FROM_ALGORITHM, NULL, data);
}
}
void CImageObject::ISafeDataToUI(WORD type, void* pData, int nDataLen)
{
QByteArray data((char*)pData, nDataLen);
emTpUiDataType emType = (emTpUiDataType)(TP_UI_DATA_FROM_ALGORITHM | type);
if (NULL != m_pCamImg)
{
gGuiCallback_FuncCall(ISafeDataToUI, emType, m_pCamImg->Serial(), data);
}
else
{
gGuiCallback_FuncCall(ISafeDataToUI, emType, NULL, data);
}
}
void CImageObject::IDrawDefect(const char* szWinName, emTpDefectType defectType, BYTE* pData, int nDataLen)
{
QByteArray data((char*)pData, nDataLen);
gGuiCallback_FuncCall(IDrawDefectToScene, szWinName, defectType, data);
}
void CImageObject::IDrawDefectOrg(emTpDefectType defectType, BYTE* pData, int nDataLen)
{
if (NULL != m_pCoreCtrl && NULL != m_pCamImg)
{
m_pCoreCtrl->DrawDefectOrg(defectType, pData, nDataLen, m_pCamImg);
}
}
INT64 CImageObject::IMeterCode()
{
if (NULL == m_pCamImg)
{
return 0;
}
return m_pCamImg->MeterCode();
}
const char* CImageObject::IGetImageUtf8String()
{
if (NULL == m_pCamImg)
{
return 0;
}
return m_pCamImg->FileName().data();
}
void CImageObject::IDrawImage(QImage& image/* = QImage()*/, const char* szWinName/* = NULL*/)
{
if (NULL != m_pCoreCtrl && NULL != m_pCamImg)
{
if (image.isNull())
{
image = m_pCamImg->ToQImage();
}
m_pCoreCtrl->DrawImageOrg(image, m_pCamImg);
}
}
QImage CImageObject::IImage()
{
if (NULL == m_pCamImg)
{
return QImage();
}
else
{
return m_pCamImg->ToQImage();
}
}
const ZStringA& CImageObject::IDllSuffix()
{
return m_pCamImg->DllSuffix();
}
void CImageObject::ISetResult(const QString& key, QVariant& val)
{
if (NULL != m_pCoreCtrl)
{
m_pCoreCtrl->ISetResult(key, val);
}
}
void CImageObject::IAccumulateResult(const QString& key, QVariant& val)
{
if (NULL != m_pCoreCtrl)
{
m_pCoreCtrl->AccumulateResult(key, val);
}
}
void CImageObject::IMoveToFolder(const QString& szFolder)
{
if (QFile::exists(QString::fromUtf8(IGetImageUtf8String())))
{
ZKF::qtCopyFile(IGetImageUtf8String(), szFolder.toUtf8().data());
}
else
{
if (NULL == m_pCamImg)
{
return;
}
}
}
IAlgorithmShared* CImageObject::IGetShared()
{
if (NULL == m_pCoreCtrl)
{
return NULL;
}
return &m_pCoreCtrl->m_algShared;
}
void CImageObject::IVariantMapToUI(const QVariantMap& vMap)
{
glpGuiCallback->IVariantMapToUI(TP_UI_DATA_FROM_ALGORITHM, m_pCamImg->Serial(), vMap);
}
const ZStringA& CImageObject::ICameraSerial()
{
return m_pCamImg->Serial();
}
const QVariant& CImageObject::IVarFromUI()
{
return m_pCamImg->VarFromUI();
}

@ -0,0 +1,51 @@
#ifndef IMAGEOBJECT_H
#define IMAGEOBJECT_H
#include "globalCoreCtrl.h"
#include <QtGui/QPixmap>
#include "iAlgorithm.h"
class CImageObject : public IImageObject
{
public:
CImageObject(class CCoreCtrl* pCoreCtrl);
~CImageObject();
bool SetCameraImage(CZkCameraImage* pCamImage);
private:
// virtual const TP_IMAGE_NODE& ImageNode() { return m_imgNode; }
virtual emTpColorFormat IColorFormat();
//@nBytesPerLine: 0 means there is no valid value
virtual BYTE* IImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nBytesPerLine);
virtual int IGetId();
virtual int IGetAlgorithm();
virtual int IGetFrameNum();
virtual int IGetTriggerCount();
virtual void ISetCameroProperty(TP_CAMERA_PROPERTY& property);
virtual void ISendDataToUI(void* pData);
virtual void IDrawDefect(const char* szWinName, emTpDefectType defectType, BYTE* pData, int nDataLen);
virtual void IDrawDefectOrg(emTpDefectType defectType, BYTE* pData, int nDataLen);
virtual void ISafeDataToUI(void* pData, int nDataLen);
virtual void ISafeDataToUI(WORD type, void* pData, int nDataLen);
virtual INT64 IMeterCode();
virtual const char* IGetImageUtf8String();
virtual void IDrawImage(QImage& image = QImage(), const char* szWinName = NULL);
virtual QImage IImage();
virtual const ZStringA& IDllSuffix();
virtual void ISetResult(const QString& key, QVariant& val);
virtual void IAccumulateResult(const QString& key, QVariant& val);
virtual void IMoveToFolder(const QString& szFolder);
virtual IAlgorithmShared* IGetShared();
virtual void IVariantMapToUI(const QVariantMap& vMap);
virtual const ZStringA& ICameraSerial();
virtual const QVariant& IVarFromUI();
virtual quint64 ITimeStamp() {
return m_pCamImg->Stamp();
}
virtual void IDataToComm(DATA_TO_COMM_HEAD& head, char* pData, int nLen) {};
private:
// TP_IMAGE_NODE m_imgNode;
CZkCameraImage* m_pCamImg;
class CCoreCtrl* m_pCoreCtrl;
};
#endif // IMAGEOBJECT_H

@ -0,0 +1,55 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:LoadModule.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/23
History:23:3:2015 17:48
*******************************************************************************/
#include "LoadModule.h"
CLoadModule::CLoadModule(const char *szLibName, const char *szFuncInit, const char *szFuncFree, const char* szPath /* = NULL */)
// :m_lib(szLibName)
{
QString dllFile;
if( NULL != szPath )
{
dllFile = QString(szPath) + szLibName;
}
else
{
dllFile = szLibName;
}
#ifdef _DEBUG
dllFile.append('d');
#endif
m_lib.setFileName(dllFile);
m_fpInit = (Func_Lib_Init)m_lib.resolve(szFuncInit);
m_fpFree = (Func_Lib_Free)m_lib.resolve(szFuncFree);
}
CLoadModule::~CLoadModule(void)
{
ModuleFree();
}
void* CLoadModule::ModuleInit(void* inParam /* = NULL */)
{
if( NULL == m_fpInit )
{
return NULL;
}
return m_fpInit(inParam);
}
void CLoadModule::ModuleFree()
{
if( NULL != m_fpFree )
{
m_fpFree();
m_fpFree = NULL;
m_lib.unload();
}
}

@ -0,0 +1,32 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:LoadModule.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/23
History:23:3:2015 17:48
*******************************************************************************/
#ifndef __LOAD_MODULE_H
#define __LOAD_MODULE_H
#include <QtCore/QLibrary>
typedef void* (*Func_Lib_Init)(void *);
typedef void (*Func_Lib_Free)();
class CLoadModule
{
public:
CLoadModule(const char *szLibName, const char *szFuncInit, const char *szFuncFree, const char* szPath = NULL);
~CLoadModule(void);
void* ModuleInit(void* inParam = NULL);
void ModuleFree();
private:
QLibrary m_lib;
Func_Lib_Init m_fpInit;
Func_Lib_Free m_fpFree;
};
#endif

@ -0,0 +1,109 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ModulesManager.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/23
History:23:3:2015 16:20
*******************************************************************************/
#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;
#ifdef MDL_CAMERA_USE_DLL
pReturn = getModule("tpCamera", "Lib_Camera_Init", "Lib_Camera_Free", &camInParam);
#else
pReturn = Lib_Camera_Init(&camInParam);
#endif
if( NULL == pReturn )
{
return (-nRet);
}
glpCameralPool = (ICameraPool*)pReturn;
++nRet;
//Load imgproc library
IMGPROC_IN_PARAM imgprocInParam;
imgprocInParam.pGlobalData = gpGlobalData;
#ifdef MDL_IMGPROC_USE_DLL
pReturn = getModule("tpImgProc", "Lib_ImgProc_Init", "Lib_ImpProc_Free", &imgprocInParam);
#else
pReturn = Lib_ImgProc_Init(&imgprocInParam);
#endif
if( NULL == pReturn )
{
return (-nRet);
}
glpImgProc = (IImgProc*)pReturn;
++nRet;
//load communicate library
++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
}

@ -0,0 +1,38 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ModulesManager.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/23
History:23:3:2015 16:20
*******************************************************************************/
#ifndef __MODULES_MANAGER_H
#define __MODULES_MANAGER_H
//modues controls
//#define MDL_CAMERA_USE_DLL //open it if using camera's module as a dll
//#define MDL_IMGPROC_USE_DLL
//#define MDL_COMMUNICATE_USE_DLL
/////////////////////////////////////////
#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

@ -0,0 +1,40 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:QZkShowImage.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/17
History:17:4:2015 15:10
*******************************************************************************/
#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));
}

@ -0,0 +1,31 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:QZkShowImage.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/17
History:17:4:2015 15:10
*******************************************************************************/
#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

@ -0,0 +1,332 @@
#include "ShowWindow.h"
#include "qtpthreadimage.h"
#include <QtGui\qpainter.h>
CShowWindow::CShowWindow(const TP_CAMERA_WIN* pCamWin)
: m_nLastStamp(0)
{
m_winId = QString(pCamWin->device) + "_" + QString::number(pCamWin->index);
m_camWin = *pCamWin;
if (m_camWin.buffers > SHOW_MAX_BUFFERS)
{
m_camWin.buffers = SHOW_MAX_BUFFERS;
}
if (m_camWin.images <= 0)
{
m_camWin.images = 1;
}
if (m_camWin.bitsPerPixel > 32)
{
m_camWin.bitsPerPixel = 32;
}
m_bytesPerPexel = (m_camWin.bitsPerPixel + 7) / 8;
m_oneBufferSize = m_bytesPerPexel * m_camWin.bufferW * m_camWin.bufferH;
for (int i = 0; i < m_camWin.buffers; ++i)
{
m_ppBuffers[i] = new BYTE[m_oneBufferSize];
if (NULL == m_ppBuffers[i])
{
m_camWin.buffers = i;
break;
}
// memset(m_ppBuffers[i], 0xFF, m_oneBufferSize);
QImage(m_ppBuffers[i], m_camWin.bufferW, m_camWin.bufferH, bufferFormat()).fill(QColor(0, 0, 0));
}
m_nBuffIdxWrite = 0;
m_nBuffIdxShow = 0;
// m_nBuffIdxLashShow = 0;
// m_nWriteImages = 0;
// m_nLastFrameNum = 0;
//...2015.08.31
m_lastFrameNum = 0;
m_firstFrameNum = 0;
m_nowFrames = 0;
m_lastFrameFirst = 0;
// m_nLastTriggers = 0;
}
CShowWindow::~CShowWindow()
{
for (int i = 0; i < m_camWin.buffers; ++i)
{
if (NULL != m_ppBuffers[i])
{
delete m_ppBuffers[i];
}
}
}
bool CShowWindow::AddCameraImage(QImage srcImg, UINT nFrameNum, UINT nStamp/* = 0*/, const QString& szExtend/* = NULL*/)
{
bool bUpdate = false;
//UINT nFrameNum = pCamImage->FrameNumber();
if (nFrameNum < m_firstFrameNum || 0 == nFrameNum)
{
return bUpdate;
}
if (1 == nFrameNum)
{
bUpdate = switchBuffers();
}
else if (nFrameNum > m_lastFrameNum + 1)//wait for the first Frames
{
int nW = 0;
while (nFrameNum > m_lastFrameNum + 1 && nW < SHOW_MAX_WAIT_TIMES)//保证显示的时候图片的顺序
{
QThread::msleep(25);
++nW;
}
}
QMutexLocker locker(&m_mutexWrite);
//cache image
if (m_camWin.bCacheOriginImage && m_nLastStamp < nStamp)
{
m_nLastStamp = nStamp;
if (srcImg.text(QIMAGE_FUNC_KEY) == QIMAGE_FUNC_VALUE)
{
m_imgCache = srcImg.copy();
}
else
{
m_imgCache = srcImg.copy();
}
}
//判断图像是否有新的一组到来
if (nFrameNum >= m_firstFrameNum + m_camWin.images)
{
bUpdate |= switchBuffers();
}
//
//
if (0 == m_nowFrames)//set the first Frame
{
if (1 == nFrameNum)
{
m_firstFrameNum = nFrameNum;
m_lastFrameNum = nFrameNum;
}
else
{
m_firstFrameNum = (nFrameNum - 1) / m_camWin.images * m_camWin.images + 1;//
}
bUpdate = true;
}
//
if (nFrameNum > m_lastFrameNum)
{
m_lastFrameNum = nFrameNum;
}
++m_nowFrames;
int nIdx = nFrameNum - m_firstFrameNum;
BYTE* pBuffer = m_ppBuffers[m_nBuffIdxWrite];
if (NULL == pBuffer)
{
return bUpdate;
}
int nImageH = m_camWin.bufferH / m_camWin.images;
pBuffer += nIdx * nImageH * m_camWin.bufferW * m_bytesPerPexel;
QImage imgDest(pBuffer, m_camWin.bufferW, nImageH, bufferFormat());
QPainter painter(&imgDest);
//QImage srcImg = pCamImage->ToQImage();
//scale to width
if (m_camWin.bufferW < srcImg.width())
{
srcImg = srcImg.scaledToWidth(m_camWin.bufferW);
}
//mirror the picture
if (m_camWin.mirror)
{
srcImg = srcImg.mirrored(m_camWin.mirror & 1, m_camWin.mirror & 2);
}
//mirror
if (m_camWin.bNeedRgbSwapped)
{
srcImg = srcImg.rgbSwapped();
}
painter.drawImage(QPoint(0, 0), srcImg);
// painter.setPen(QColor(0, 150, 10));
// painter.drawText(5, 15, QString::number(nFrameNum));
//keep for drawing defects
if (m_bufferFrameNum.contains(pBuffer))
{
m_frameNumBuffer.remove(m_bufferFrameNum.value(pBuffer));
}
m_bufferFrameNum.insert(pBuffer, nFrameNum);
m_frameNumBuffer.insert(nFrameNum, pBuffer);
//
if (m_nowFrames == m_camWin.images)
{
bUpdate |= switchBuffers();
}
m_szExtend = szExtend;
return bUpdate;
}
QImage CShowWindow::ShowImage()
{
return QImage(m_ppBuffers[m_nBuffIdxShow], m_camWin.bufferW, m_camWin.bufferH, bufferFormat());
}
QImage::Format CShowWindow::bufferFormat()
{
if (1 == m_bytesPerPexel)
{
return QImage::Format_Indexed8;
}
else if (2 == m_bytesPerPexel)
{
return QImage::Format_RGB16;
}
else if (3 == m_bytesPerPexel)
{
return QImage::Format_RGB888;
}
else
{
return QImage::Format_ARGB32_Premultiplied;
}
}
bool CShowWindow::DrawDefect(IImageObject::emTpDefectType defectType, BYTE* pData, int nDataLen, CZkCameraImage* pCamImage)
{
if (NULL == pCamImage || NULL == pData)
{
return false;
}
UINT nFrameNum = pCamImage->FrameNumber();
//
QMutexLocker locker(&m_mutexWrite);
BYTE* pBuffer = m_frameNumBuffer.value(nFrameNum, NULL);
if (NULL == pBuffer)
{
return false;
}
int nImageH = m_camWin.bufferH / m_camWin.images;
QImage image(pBuffer, m_camWin.bufferW, nImageH, bufferFormat());
if (image.isNull())
{
return false;
}
//scale
double xScale = image.width() * 1.0 / pCamImage->Width();
double yScale = image.height() * 1.0 / pCamImage->Height();
//test
//uchar* bits = image.bits();
//test
QRectF rtf;
switch (defectType)
{
case IImageObject::TP_DEF_RECT_F:
case IImageObject::TP_DEF_ELLIPSE_F:
if (nDataLen < 32)
{
break;
}
else
{
qreal* pfData = (qreal*)pData;
rtf.setRect(pfData[0] * xScale, pfData[1] * yScale, pfData[2] * xScale, pfData[3] * yScale);
}
break;
case IImageObject::TP_DEF_CIRCLE_F:
if (nDataLen < 24)
{
break;
}
else
{
qreal* pfData = (qreal*)pData;
rtf.setRect(pfData[0] * xScale, pfData[1] * yScale, pfData[2] * xScale, pfData[2] * yScale);
}
break;
case IImageObject::TP_DEF_POLYLINE_I:
break;
default:
return false;
}
//
QPainter painter(&image);
QPen pen(QColor(200, 10, 10));
pen.setWidth(2);
painter.setPen(pen);
switch (defectType)
{
case IImageObject::TP_DEF_RECT_F:
painter.drawRect(rtf);
break;
case IImageObject::TP_DEF_CIRCLE_F:
case IImageObject::TP_DEF_ELLIPSE_F:
painter.drawEllipse(rtf);
break;
case IImageObject::TP_DEF_POLYLINE_I:
if (nDataLen < 16)
{
return false;
}
else
{
QPolygon polygon(nDataLen);
polygon.setPoints(nDataLen / 8, (int*)pData);
painter.drawPolyline(polygon);
}
break;
default:
return false;
}
if (pBuffer >= m_ppBuffers[m_nBuffIdxShow] && pBuffer < m_ppBuffers[m_nBuffIdxShow] + m_oneBufferSize)
{
return true;
}
else
{
return false;
}
}
bool CShowWindow::DrawImage(QImage& srcImg, UINT nFrameNum, const QString& szExtend/* = NULL*/)
{
// QMutexLocker locker(&m_mutexWrite);
BYTE* pBuffer = m_frameNumBuffer.value(nFrameNum, NULL);
if (NULL == pBuffer)
{
return false;
}
int nImageH = m_camWin.bufferH / m_camWin.images;
QImage image(pBuffer, m_camWin.bufferW, nImageH, bufferFormat());
if (image.isNull())
{
return false;
}
//scale
if (m_camWin.bufferW < srcImg.width())
{
srcImg = srcImg.scaledToWidth(m_camWin.bufferW);
}
//mirror the picture
if (m_camWin.mirror)
{
srcImg = srcImg.mirrored(m_camWin.mirror & 1, m_camWin.mirror & 2);
}
QPainter painter(&image);
painter.drawImage(QPoint(0, 0), srcImg);
m_szExtend = szExtend;
return true;
}
bool CShowWindow::switchBuffers()
{
if (m_nowFrames > 0)
{
m_nBuffIdxShow = m_nBuffIdxWrite;
m_nBuffIdxWrite = (m_nBuffIdxWrite + 1) % m_camWin.buffers;
m_lastFrameFirst = m_firstFrameNum;
m_firstFrameNum = 0;
m_nowFrames = 0;
return true;
}
else
{
return false;
}
}

@ -0,0 +1,63 @@
#ifndef SHOWWINDOW_H
#define SHOWWINDOW_H
#include "globalCoreCtrl.h"
#include "ZkCameraImage.h"
#include <QtCore\qmutex.h>
#include "QZkMutexMap.h"
//#include "iAlgorithm.h"
#define SHOW_MAX_BUFFERS 2
#define SHOW_MAX_WAIT_TIMES gCoreSetting.threadsCount//4
class CShowWindow
{
public:
CShowWindow(const TP_CAMERA_WIN* pCamWin);
~CShowWindow();
const QString& WindowId() {
return m_winId;
}
const TP_CAMERA_WIN& CameraWin() {
return m_camWin;
}
// bool SetCameraImage(CZkCameraImage* pCamImage);
bool AddCameraImage(QImage srcImg, UINT nFrameNum, UINT nStamp = 0, const QString& szExtend = NULL);
QImage ShowImage();
int FrameNum() {
return m_lastFrameNum;
}
bool DrawDefect(IImageObject::emTpDefectType defectType, BYTE* pData, int nDataLen, CZkCameraImage* pCamImage);
bool DrawImage(QImage& srcImg, UINT nFrameNum, const QString& szExtend = NULL);
QImage& OriginImage() {
return m_imgCache;
}
const QString ExtendString() {
return m_szExtend;
}
private:
QImage::Format bufferFormat();
bool switchBuffers();
private:
TP_CAMERA_WIN m_camWin;
QString m_winId;
int m_bytesPerPexel;
BYTE* m_ppBuffers[SHOW_MAX_BUFFERS];
int m_oneBufferSize;
int m_nBuffIdxWrite;
int m_nBuffIdxShow;
QMutex m_mutexWrite;
//
QMap<UINT, BYTE*> m_frameNumBuffer;//frame
QMap<BYTE*, UINT> m_bufferFrameNum;
/*QAtomicInteger<UINT>*/UINT m_lastFrameNum;
/*QAtomicInteger<UINT>*/UINT m_firstFrameNum;
UINT m_lastFrameFirst;
QAtomicInteger<UINT> m_nowFrames;
//
QImage m_imgCache;
INT64 m_nLastStamp;
QString m_szExtend;
};
#endif // SHOWWINDOW_H

@ -0,0 +1,31 @@
#include "XmlConfigParser.h"
#include <QtCore/QDir>
#include <QtCore/QXmlStreamReader>
CXmlConfigParser::CXmlConfigParser(void)
{
}
CXmlConfigParser::~CXmlConfigParser(void)
{
}
QList<QVariant> CXmlConfigParser::Read2DList(const QString& sFileName, const QString& nameTag)
{
QList<QVariant> retList;
QFile file(QDir::currentPath() + sFileName);
QXmlStreamReader xmlReader(&file);
xmlReader.readNext();
bool bNameTag = false;
while( !xmlReader.atEnd() )
{
if( xmlReader.isStartElement() && xmlReader.name() == nameTag )//find a tag
{
;//....
}
xmlReader.readNext();
}
return retList;
}

@ -0,0 +1,25 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:XmlConfigParser.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/25
History:25:3:2015 13:23
*******************************************************************************/
#ifndef __XML_CONFIG_PARSER_H_20150325
#define __XML_CONFIG_PARSER_H_20150325
#include <QtCore/QList>
#include <QtCore/QVariant>
class CXmlConfigParser
{
public:
CXmlConfigParser(void);
~CXmlConfigParser(void);
//Qvariant is a QList<QVariant>, so the returned value is a 2-dimension list
QList<QVariant> Read2DList(const QString& sFileName, const QString& nameTag);
};
#endif

@ -0,0 +1,338 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ZkCameraImage.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/16
History:16:4:2015 15:40
*******************************************************************************/
#include "ZkCameraImage.h"
CZkCameraImage::CZkCameraImage()
{
m_nId = 0;
m_nFrameNum = 0;
m_colorFormat = TP_COLOR_NONE;
m_nTriggerCount = 0;
m_pImage = NULL;
m_nCopiedLines = 0;
m_nMeterCode = 0;
m_nTimeStamp = QDateTime::currentDateTime().toMSecsSinceEpoch();
}
CZkCameraImage::~CZkCameraImage()
{
if (NULL != m_pImage)
{
delete m_pImage;
}
}
int CZkCameraImage::CopyCameraObject(ICameraObject* pCamObj)
{
// SetColorFormat(pCamObj->ColorFormat());
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
{
return -1;
}
// TP_CAMERA_OPTION* pOpt = pCamObj->CameraOption();
//if (NULL == pOpt)
//{
// return -1;
//}
if (NULL == m_pImage)
{
int nW = pCamObj->m_nImageWidth;
int nH = pCamObj->m_nImageHeight;
if (pCamObj->m_pCamOpt->height > 0)
{
nH = pCamObj->m_pCamOpt->height;
}
m_pImage = new QImage(nW, nH, ToQImageFormat(pCamObj->m_nColorFormat));
if (NULL == m_pImage)
{
return -1;
}
m_nCopiedLines = 0;
copyOption(pCamObj);
//SetFrameNum(pCamObj->FrameNumber());
//SetTriggerCount(pCamObj->StartCount());
//SetSerial(pOpt->uniqueName.toUtf8().data());
//SetId(pOpt->id);
//SetAlgorithm(pOpt->algorithm);
//SetDllSuffix(pOpt->dllsuffix.toUtf8());
}
int nLines = m_pImage->height() - m_nCopiedLines;
if (nLines > pCamObj->m_nImageHeight)
{
nLines = pCamObj->m_nImageHeight;
}
int nSizes = nLines * pCamObj->m_nImageWidth*((pCamObj->m_nBitsPerPixel + 7) / 8);
memcpy(m_pImage->scanLine(m_nCopiedLines), pCamObj->m_pCameraData, nSizes);
m_nCopiedLines += nLines;
//SetFileName(pCamObj->Utf8FileName());
if (m_nCopiedLines == m_pImage->height())
{
return 1;
}
else
{
return 0;
}
}
int CZkCameraImage::CopyCameraObject2(ICameraObject* pCamObj)
{
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
{
return 0;
}
if (NULL == pCamObj->m_funcFreeBuffer)
{
m_pImage = new QImage();
*m_pImage = QImage(pCamObj->m_pCameraData, pCamObj->m_nImageWidth, pCamObj->m_nImageHeight, ToQImageFormat(pCamObj->m_nColorFormat)).copy();
//m_pImage = new QImage(pCamObj->m_nImageWidth, pCamObj->m_nImageHeight, ToQImageFormat(pCamObj->m_nColorFormat));
}
else
{
m_pImage = new QImage(pCamObj->m_pCameraData, pCamObj->m_nImageWidth, pCamObj->m_nImageHeight, ToQImageFormat(pCamObj->m_nColorFormat)
, pCamObj->m_funcFreeBuffer, pCamObj->m_pCameraData);
m_pImage->setText(QIMAGE_FUNC_KEY, QIMAGE_FUNC_VALUE);
}
if (NULL == m_pImage)
{
return 0;
}
copyOption(pCamObj);
return 1;
}
/*
bool CZkCameraImage::CopyImageData(const BYTE* pData, int nW, int nH, int nBits, emTpColorFormat nColorFormat)
{
SetColorFormat(nColorFormat);
if( ZIMAGE == m_imageType )
{
return m_image.zk->Copy(pData, nW, nH, nBits);
}
else
{
*(m_image.q) = QImage(pData, nW, nH, ToQImageFormat()).copy();
if( m_image.q->isNull() )
{
return false;
}
else
{
return true;
}
}
}
bool CZkCameraImage::CopyQImage(const QImage& image)
{
if( ZIMAGE == m_imageType )
{
delete m_image.zk;
m_image.q = new QImage();
m_imageType = QIMAGE;
}
*(m_image.q) = image;//no copy
m_colorFormat = FromQImageFormat(image);
return true;
}
*/
ZShowImage CZkCameraImage::ToShowImage(int nShowW /* = 0 */, int nShowH /* = 0 */)
{
if (NULL == m_pImage)
{
return QImage();
}
#ifdef USE_PIXMAP_AS_SHOW
if (ZIMAGE == m_imageType)
{
QImage image = QImage(m_zimage.bits(), m_zimage.width(), m_zimage.height(), ToQImageFormat());
return QPixmap::fromImage(image).copy();
}
else
{
return QPixmap::fromImage(*(m_image.q)).copy();
}
#else
/*
QImage image;
if( ZIMAGE == m_imageType )
{
image = QImage(m_image.zk->bits(), m_image.zk->width(), m_image.zk->height(), ToQImageFormat());
}
else
{
image = *(m_image.q);
}*/
if (QImage::Format_Indexed8 == m_pImage->format())
{
//
QVector<QRgb> colorFmt;
for (int i = 0; i < 256; ++i)
{
QColor clr1(i, i, i);
colorFmt.append(clr1.rgb());
}
m_pImage->setColorTable(colorFmt);
return m_pImage->convertToFormat(QImage::Format_RGB32);
}
else
{
return m_pImage->copy();
}
#endif
}
QImage CZkCameraImage::ToQImage()
{
if (NULL == m_pImage)
{
return QImage();
}
//...
QImage::Format fmt = m_pImage->format();
if (QImage::Format_Indexed8 == m_pImage->format() && m_pImage->colorTable().isEmpty())
{
QVector<QRgb> colorFmt;
for (int i = 0; i < 256; ++i)
{
QColor clr1(i, i, i);
colorFmt.append(clr1.rgb());
}
m_pImage->setColorTable(colorFmt);
}
return *m_pImage;
}
QImage::Format CZkCameraImage::ToQImageFormat(emTpColorFormat colorFormat)
{
if (TP_COLOR_RGB32 == colorFormat ||
TP_COLOR_BGR32 == colorFormat)
{
return QImage::Format_RGB32;
}
else if (TP_COLOR_RGB24 == colorFormat ||
TP_COLOR_BGR24 == colorFormat)
{
return QImage::Format_RGB888;
}
else if (TP_COLOR_Y800 == colorFormat)
{
return QImage::Format_Indexed8;
}
else if (TP_COLOR_Y16 == colorFormat)
{
return QImage::Format_RGB555;// QImage::Format_RGB16;
}
else if (TP_COLOR_RGB48 == colorFormat)
{
return QImage::Format_ARGB32;
}
else
{
return QImage::Format_Invalid;
}
}
emTpColorFormat CZkCameraImage::FromQImageFormat(const QImage &image)
{
if (QImage::Format_RGB32 == image.format())
{
return TP_COLOR_RGB32;
}
else if (QImage::Format_RGB888 == image.format())
{
return TP_COLOR_RGB24;
}
else if (QImage::Format_Indexed8 == image.format())
{
return TP_COLOR_Y800;
}
else if (QImage::Format_RGB16 == image.format())
{
return TP_COLOR_Y16;
}
else
{
return TP_COLOR_NONE;
}
}
emTpColorFormat CZkCameraImage::FromString(const QString& strColor)
{
if ("RGB32" == strColor)
{
return TP_COLOR_RGB32;
}
else if ("RGB24" == strColor)
{
return TP_COLOR_RGB24;
}
else if ("GRAY8" == strColor)
{
return TP_COLOR_Y800;
}
else if ("GRAY16" == strColor)
{
return TP_COLOR_Y16;
}
else if ("BGR24" == strColor)
{
return TP_COLOR_BGR24;
}
else if ("BGR32" == strColor)
{
return TP_COLOR_BGR32;
}
else
{
return TP_COLOR_NONE;
}
}
BYTE* CZkCameraImage::ImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nOutBytesPerLine)
{
if (!m_pImage || m_pImage->isNull()) {
return NULL;
}
nOutW = m_pImage->width();
nOutH = m_pImage->height();
if (nOutW <= 0) {
qWarning() << "Invalid image data. - " << __FUNCTION__;
return NULL;
}
nOutBitsPerPixel = m_pImage->bytesPerLine() * 8 / nOutW;
nOutBytesPerLine = m_pImage->bytesPerLine();
return m_pImage->bits();
}
bool CZkCameraImage::SaveToFile()
{
if (NULL != m_pImage)
{
if (QImage::Format_Indexed8 == m_pImage->format())
{
QVector<QRgb> colorFmt;
for (int i = 0; i < 256; ++i)
{
QColor clr1(i, i, i);
colorFmt.append(clr1.rgb());
}
m_pImage->setColorTable(colorFmt);
}
}
return m_pImage->save(m_fileName, ".BMP");
}

@ -0,0 +1,148 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ZkCameraImage.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/16
History:16:4:2015 15:39
*******************************************************************************/
#ifndef ZKCAMERAIMAGE_H
#define ZKCAMERAIMAGE_H
#include "baseDefine.h"
#include "baseStruct.h"
#include "ZkImage.h"
#include "iCameraObject.h"
#define QIMAGE_FUNC_KEY "bool_func"
#define QIMAGE_FUNC_VALUE "func_true"
class CZkCameraImage
{
public:
CZkCameraImage();
~CZkCameraImage();
int CopyCameraObject(ICameraObject* pCamObj);
int CopyCameraObject2(ICameraObject* pCamObj);//no combine and maybe use QImage
// bool CopyImageData(const BYTE* pData, int nW, int nH, int nBits, emTpColorFormat nColorFormat);
// bool CopyQImage(const QImage& image);
//void SetSerial(const char* szSerial) {
// m_strSerial = szSerial;
//}
const ZStringA& Serial() {
return m_strSerial;
}
uint GetId() {
return m_nId;
}
//void SetId(long nId) {
// m_nId = nId;
//}
//void SetFrameNum(long nFrameNum) {
// m_nFrameNum = nFrameNum;
//}
ULONG FrameNumber() {
return m_nFrameNum;
}
//void SetColorFormat(emTpColorFormat nColorFormat) {
// m_colorFormat = nColorFormat;
//}
emTpColorFormat ColorFormat() {
return m_colorFormat;
}
//void SetTriggerCount(long nTriggers) {
// m_nTriggerCount = nTriggers;
//}
long TriggerCount() {
return m_nTriggerCount;
}
ZShowImage ToShowImage(int nShowW = 0, int nShowH = 0);
QImage ToQImage();
QImage::Format ToQImageFormat(emTpColorFormat colorFormat);
static emTpColorFormat FromQImageFormat(const QImage &image);
static emTpColorFormat FromString(const QString& strColor);
bool SaveToFile(const QString& strFile);
bool SaveToFile();
BYTE* ImageData(int& nOutW, int& nOutH, int& nOutBitsPerPixel, int& nOutBytesPerLine);
void SetAlgorithm(long nAlgorithm) {
m_nAlgorithm = nAlgorithm;
}
long Algorithm() {
return m_nAlgorithm;
}
//void SetFileName(const ZStringA& strName) {
// m_fileName = strName;
//}
const ZStringA& FileName() {
return m_fileName;
}
void SetMeterCode(INT64 code) {
m_nMeterCode = code;
}
INT64 MeterCode() {
return m_nMeterCode;
}
int Width() {
return m_pImage->width();
}
int Height() {
return m_pImage->height();
}
INT64 Stamp() {
return m_nTimeStamp;
}
//void SetDllSuffix(const ZStringA& strName) {
// m_dllSuffix = strName;
//}
const ZStringA& DllSuffix() {
return m_dllSuffix;
}
void SetVarFromUI(const QVariant& v){
m_varFromUI = v;
}
const QVariant& VarFromUI() {
return m_varFromUI;
}
void Mirror(bool horizontally, bool vertically)
{
if (!m_pImage)
{
return;
}
if (m_pImage->isNull())
{
return;
}
*m_pImage = m_pImage->mirrored(
horizontally, vertically);
}
private:
void copyOption(ICameraObject* pCamObj) {
m_nFrameNum = pCamObj->m_nFrameNum;
m_nTriggerCount = pCamObj->m_nStartCount;
m_strSerial = pCamObj->m_pCamOpt->uniqueName.toUtf8();
m_nId = pCamObj->m_pCamOpt->id;
m_nAlgorithm = pCamObj->m_pCamOpt->algorithm;
m_dllSuffix = pCamObj->m_pCamOpt->dllsuffix.toUtf8();
m_fileName = pCamObj->m_szFileName;
m_colorFormat = pCamObj->m_nColorFormat;
}
private:
QImage* m_pImage;
int m_nCopiedLines;
//////////////////////////////////////////////////
ZStringA m_strSerial;
long m_nId;
long m_nAlgorithm;
emTpColorFormat m_colorFormat;
ZStringA m_fileName;
ULONG m_nFrameNum;
long m_nTriggerCount;
INT64 m_nMeterCode;
INT64 m_nTimeStamp;
ZStringA m_dllSuffix;
QVariant m_varFromUI;
};
#endif // ZKCAMERAIMAGE_H

@ -0,0 +1,74 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ZkImage.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/16
History:16:4:2015 11:06
*******************************************************************************/
#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;
}

@ -0,0 +1,42 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ZkImage.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/16
History:16:4:2015 11:06
*******************************************************************************/
#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

@ -0,0 +1,36 @@
#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);
}

@ -0,0 +1,73 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:globalCoreCtrl.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/24
History:24:3:2015 17:30
*******************************************************************************/
#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_pGuiCallback = pParam->pGuiCb;
m_pGlobalData = pParam->pGlobalData;
// m_pCoreSetting = pParam->pCoreSetting;
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;
IGuiCallback* m_pGuiCallback;
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 glpMainPath NULL != gpData ? gpData->tgdMainPath : ".\\"
// #define gcallCameraPool(fc) if( NULL != glpCameralPool ) glpCameralPool->##fc##()
// #define gcallCameraPoolParam(fc, ...) if( NULL != glpCameralPool) glpCameralPool->##fc##(__VA_VRGS__)
#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

@ -0,0 +1,11 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:iCameraObject.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/26
History:26:5:2015 15:35
*******************************************************************************/
#include "iCameraObject.h"

@ -0,0 +1,313 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:iCameraObject.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/25
History:25:5:2015 15:52
*******************************************************************************/
#ifndef _I_CAMERA_OBJECT_H
#define _I_CAMERA_OBJECT_H
#include <QRunnable>
#include <QThreadPool>
#include <QDebug>
#include <exception>
#include "baseStruct.h"
#include "QZkMutexList.h"
#include <QFileInfo>
#include <QDir>
//#define _USE_CAMERA_SERIAL_ENCRYPTO
class CSaveImgTask : public QRunnable
{
public:
CSaveImgTask(const QString& path, BYTE* pdata, int BitsPerPixel, long imgwd = 0,
long imght = 0, emTpColorFormat fmt = TP_COLOR_NONE, bool brgbswp = false)
: msPath(path)
, mpData(0)
, mnImageWidth(imgwd)
, mnImageHeight(imght)
, mColorFormat(fmt)
, mbNeedRgbSwapped(brgbswp)
{
qint64 nSizes = mnImageHeight*mnImageWidth*((BitsPerPixel + 7) / 8);
QFileInfo srcInfo(path);
QDir dstDir = srcInfo.dir();
if (nSizes > 0 && dstDir.exists()){
try
{
mpData = new BYTE[nSizes];
memcpy(mpData, pdata, nSizes);
}
catch (const std::bad_alloc& e)
{
qCritical() << "alloc error:" << e.what();
}
catch (const std::exception& e)
{
qCritical() << "other exception:" << e.what();
}
}
}
~CSaveImgTask(){
if (mpData){
delete mpData;
mpData = 0;
}
}
void run()
{
if (!mpData) return;
QImage image(mpData, mnImageWidth, mnImageHeight,
TP_FUNCS::ToQImageFormat(mColorFormat));
if (image.isNull()){
qWarning() << "Could save image in CSaveImgTask : " << msPath;
return;
}
if (QImage::Format_Indexed8 == image.format()) {
QVector<QRgb> colorFmt;
for (int i = 0; i < 256; ++i) {
QColor clr1(i, i, i);
colorFmt.append(clr1.rgb());
}
image.setColorTable(colorFmt);
}
if (mbNeedRgbSwapped)
{
image = image.rgbSwapped();
}
image.save(msPath);
}
private:
QString msPath;
BYTE* mpData;
long mnImageWidth;
long mnImageHeight;
emTpColorFormat mColorFormat;
bool mbNeedRgbSwapped;
};
typedef void(*func_free_image_buffer)(void*);
class ICameraObject
{
public:
ICameraObject(TP_CAMERA_OPTION* pCamOpt, class IPoolCallback* pCb)
: m_pCamOpt(pCamOpt)
, m_pCb(pCb)
, m_funcFreeBuffer(NULL)
, m_bEnableCallBack(true) {
m_bHasOpened = false;
m_bHasStarted = false;
m_nImageWidth = 0;
m_nImageHeight = 0;
m_nBitsPerPixel = TP_FUNCS::BitsPerPixels((emTpColorFormat)pCamOpt->format);// 0;
m_nImageSize = m_nImageWidth * m_nImageHeight * ((m_nBitsPerPixel + 7) / 8);
m_nColorFormat = TP_COLOR_NONE;
m_nFixedFrames = 0;
m_nFrameNum = 0;
m_nStartCount = 0;
m_oldTriggerMode = DEV_TRIGGER_MODE_STOP;
m_newTriggerMode = DEV_TRIGGER_MODE_OUT;
m_pRelyOnCam = NULL;
m_pCameraData = NULL;
m_bIsCallback = false;
}
virtual ~ICameraObject() {
}
virtual int IOpenCamera() = 0;
virtual void ICloseCamera() = 0;
virtual int IStartCamera() = 0;
virtual void IStopCamera() = 0;
virtual void IStartPush() = 0;
virtual void IPausePush() = 0;
virtual QList<QString> IEnumAvailableCameras(){
QList<QString> ret;
return ret;
}
virtual int ISnapCamera(emTpTriggerDirection direct) {
if( !m_bHasStarted || NULL == m_pCamOpt || m_pCamOpt->bIgnoreImage) {
return 0;
}
if( DEV_TRIGGER_MODE_FIXED_AUTO == m_oldTriggerMode && m_nFrameNum >= m_nFixedFrames ) {
return 0;
}
return 1;
}
virtual int ISendSoftTrigger() {
return ISnapCamera(TRIGGER_DIRECT_FOREWARD);
}
virtual int IAutoCapture() { return 0; }
virtual void ISetProperty(TP_CAMERA_PROPERTY* pCamProperty) {}
virtual const char* Utf8FileName() {
return m_szFileName.data();//TP_FUNCS::ImageFileName(m_nFrameNum, m_pCamOpt).toUtf8().data();
}
virtual void ISetVirtualImages(const QStringList& szImages) {}
/////////////////////////////////////////////////////////
void SetTriggerMode(emTpDeviceTriggerMode mode) {
m_newTriggerMode = mode;
}
void SetFixedFrames(int nFrames) {
m_nFixedFrames = nFrames;
}
void SetRelyOnCamera(ICameraObject* pCam) {
m_pRelyOnCam = pCam;
}
void SetReliedByCamera(ICameraObject* pCam) {
m_listReliedBy.appendOnce(pCam);
}
void setCallback(bool b) {
m_bIsCallback = b;
}
void enableCallback(bool b) {
m_bEnableCallBack = b;
}
ICameraObject* RelyOnCamera() {
return m_pRelyOnCam;
}
//int DeviceType() {
// return m_pCamOpt->deviceType;
//}
bool IsCallback() {
return m_bIsCallback;
}
bool IsCallbackEnabled() {
return m_bEnableCallBack;
}
bool SaveToFile() {
if (DEV_CAM_VIRTUAL != m_pCamOpt->deviceType) {
m_szFileName = TP_FUNCS::ImageFileName(m_nFrameNum, m_pCamOpt).toUtf8();
}
if (1 != m_pCamOpt->save || DEV_CAM_VIRTUAL == m_pCamOpt->deviceType) {
return false;
}
//int curTaskCnt = QThreadPool::globalInstance()->activeThreadCount();
//if (curTaskCnt > 5){
// return false;
//}
//QString imgPath = TP_FUNCS::ImageFileName(m_nFrameNum, m_pCamOpt);
//CSaveImgTask *imgSavtsk = new CSaveImgTask(imgPath, m_pCameraData, m_nBitsPerPixel, m_nImageWidth,
// m_nImageHeight, m_nColorFormat);
//QThreadPool::globalInstance()->start(imgSavtsk);
//return true;
QImage image(m_pCameraData, m_nImageWidth, m_nImageHeight, TP_FUNCS::ToQImageFormat(m_nColorFormat));
if (QImage::Format_Indexed8 == image.format()) {
QVector<QRgb> colorFmt;
for (int i = 0; i < 256; ++i) {
QColor clr1(i, i, i);
colorFmt.append(clr1.rgb());
}
image.setColorTable(colorFmt);
}
if (m_pCamOpt->bNeedRgbSwapped)
{
image = image.rgbSwapped();
}
//qDebug() << TP_FUNCS::ImageFileName(m_nFrameNum, m_pCamOpt).toUtf8();
return image.save(TP_FUNCS::ImageFileName(m_nFrameNum, m_pCamOpt).toUtf8());
}
bool NeedStopping() {
if (DEV_TRIGGER_MODE_FIXED_AUTO == m_oldTriggerMode && m_nFrameNum >= m_nFixedFrames) {
return true;
}
else {
return false;
}
}
virtual int GetCameraStatus(int nType)
{
return 0;
}
protected:
QString getSerial(const QString& serialNumber) {
if (NULL == m_pCamOpt || NULL == m_pCamOpt->pSerials) {
return NULL;
}
for (QStringList::iterator it = m_pCamOpt->pSerials->begin(); it != m_pCamOpt->pSerials->end(); ++it) {
if (serialNumber == *it) {
return *it;
}
}
return NULL;
}
public:
TP_CAMERA_OPTION* m_pCamOpt;
protected:
bool m_bHasOpened;
bool m_bHasStarted;
bool m_bEnableCallBack;
long m_nImageWidth;
long m_nImageHeight;
long m_nImageSize;//bytes of the images
int m_nBitsPerPixel;
emTpColorFormat m_nColorFormat;
int m_nFixedFrames;
UINT m_nFrameNum;
long m_nStartCount;
emTpDeviceTriggerMode m_oldTriggerMode;
emTpDeviceTriggerMode m_newTriggerMode;
//emCameraDataType m_dataType;
BYTE* m_pCameraData;
ZStringA m_szFileName;
class IPoolCallback* m_pCb;
func_free_image_buffer m_funcFreeBuffer;
private:
ICameraObject* m_pRelyOnCam;
QZkMutexList<ICameraObject*> m_listReliedBy;
bool m_bIsCallback;
friend class CZkCameraImage;
friend class CCameraPool;
friend class CLibCameraes;
};
class IPoolCallback
{
public:
IPoolCallback() {}
virtual ~IPoolCallback() {}
virtual int IPushCameraData(ICameraObject* pCamObj) = 0;
virtual int IPushCameraData2(ICameraObject* pCamObj) = 0;
virtual char* IGetMainPath() = 0;
};
#define _USE_CAMERA_DLL
#define _USE_BITFLOW
#define _USE_VIRTUAL
#define _USE_GIGE
/*****************prefix list***************************
# DEV_DLL_BITFLOW_BI Bitflow_
# DEV_DLL_VIRTUAL_FOLDER Virtual_
# DEV_DLL_GIGE Gige_
*/
#ifdef _USE_CAMERA_DLL
#define API_DLL_EXPORT extern "C" __declspec(dllexport)
#define API_NAME_PREFIX(pfix, fname) fname
#else
#defien API_DLL_EXPORT extern "C"
#define API_NAME_PREFIX(pfix, fname) pfix##fname
#endif
#endif

@ -0,0 +1,56 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:qtpthreadbase.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 17:06
*******************************************************************************/
#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;
}

@ -0,0 +1,33 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:qtpthreadbase.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 17:06
*******************************************************************************/
#ifndef QTPTHREADBASE_H
#define QTPTHREADBASE_H
#include "baseInclude.h"
#include <QtCore/QThread>
class QTpThreadBase : public QThread
{
public:
QTpThreadBase(QObject *parent);
~QTpThreadBase();
void StartThread();
void EndThread();
protected:
virtual bool loop() { msleep(25); return false; }
private:
virtual void run();
private:
bool m_bRunSignal;
bool m_bIsRunning;
};
#endif // QTPTHREADBASE_H

@ -0,0 +1,77 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:qtpthreadimage.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 17:10
*******************************************************************************/
#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)
{
// LOG_SPIDER::InitLog("", "log.txt");
}
QTpThreadImage::~QTpThreadImage()
{
LOG_SPIDER::FreeLog();
}
bool QTpThreadImage::loop()
{
QTime timespan;
timespan.start();
CZkCameraImage* pCamImage = glpCameralPool->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();
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);
glpImgProc->IImageProcess(&m_objImage, m_pDE);
qDebug() << "Process Image(ID:" << pCamImage->FrameNumber()
<< ") cost " << timespan.elapsed() << " MSecs"
<< " - " __FUNCTION__;
}
//release CameraImage
m_objImage.SetCameraImage(NULL);
glpCameralPool->IFreeCameraImage(pCamImage);
}
else
{
QTpThreadBase::loop();
}
return true;
}

@ -0,0 +1,30 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:qtpthreadimage.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 17:10
*******************************************************************************/
#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

@ -0,0 +1,57 @@
/******************************************************************************
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 __TADPOLE_GUI_HEADER_H
#define __TADPOLE_GUI_HEADER_H
#define TP_OBJ_NAME_ACTION_START "tp_action_start"//开始自动触发的Action名称
#define TP_OBJ_NAME_ACTION_STOP "tp_action_stop"//停止自动触发的Action名称
#define TP_OBJ_NAME_ACTION_SHILFT "tp_action_shift"//开始/停止自动触发的Action名称
#define TP_OBJ_NAME_ACTION_NEXT "tp_action_next"//手动获取一张图片的Action名称
#define TP_OBJ_NAME_ACTION_LAST "tp_action_last"
#define TP_OBJ_CUR_TRIGMODE_LBL "tp_cam_cur_trigger_mode_lbl"
#define TP_OBJ_NAME_PUSHBUTTON_NEXT "tp_button_next"
#define TP_OBJ_NAME_PUSHBUTTON_LAST "tp_button_last"
#define TP_OBJ_NAME_PUSHBUTTON_SHIFT "tp_button_shift"
#define TP_OBJ_NAME_PUSHBUTTON_START "tp_button_start"
#define TP_OBJ_NAME_PUSHBUTTON_STOP "tp_button_stop"
#define TP_OBJ_NAME_PUSHBUTTON_GHOST_APP "tp_button_ghost_app"
#define TP_OBJ_NAME_PUSHBUTTON_SAVE_ALGORITHM "tp_button_save_algorithm"
#define TP_OBJ_NAME_PUSHBUTTON_SAVE_CAMERAES "tp_button_save_cameraes"
#define TP_OBJ_NAME_PUSHBUTTON_FIX_AUTO "tp_button_fix_auto"
#define TP_OBJ_NAME_PUSHBUTTON_INNER_TRIGGER_SHILFT "tp_button_inner_trigger_shilft"
#define TP_OBJ_NAME_COMBOBOX_SELECT_CAMERAES "tp_combox_select_cameraes"
#define TP_OBJ_NAME_COMBOBOX_SELECT_ALGORITHMS "tp_combox_select_algorithms"
#define TP_OBJ_NAME_EDIT_CAM_OPT_FOLDER "tp_edit_cam_opt_folder"
#define TP_OBJ_NAME_EDIT_CAM_OPT_ALGORITHM "tp_edit_cam_opt_algorithm"
#define TP_OBJ_NAME_EDIT_CAM_OPT_BOARD_TYPE "tp_edit_cam_opt_board_type"
#define TP_OBJ_NAME_EDIT_CAM_OPT_BOARD_NUM "tp_edit_cam_opt_board_num"
#define TP_OBJ_NAME_CHECKBOX_CAM_OPT_SAVE "tp_checkbox_cam_opt_save"
#define TP_OBJ_NAME_EDIT_FIX_FRAMES "tp_edit_fix_frames"
#define TP_OBJ_NAME_EDIT_MSECPERFRAME "tp_edit_msecperframe"
#define TP_OBJ_NAME_WIDGET_ALGORITHM "tp_widget_algorithm"
#define TP_OBJ_NAME_WIDGET_ALGORITHM_RESULT "tp_widget_algorithm_result"
//#define TP_OBJ_WIDGET_DRAW_CURVE_ "tp_obj_widget_draw_curve_"
#define TP_PROP_BOOL_NEED_REPEAT_MANUL "tp_prop_bool_need_repeat_manul"
#define TP_OBJ_NAME_CHECKBOX_SHILT_IMAGES "tp_checkbox_shilt_images"
#define TP_OBJ_NAME_CHECKBOX_TRIGGER_SOFT "tp_checkbox_trigger_soft"
#define TP_OBJ_NAME_CHECKBOX_TRIGGER_AUTO "tp_checkbox_trigger_auto"
#define TP_OBJ_NAME_EDIT_TRIGGER_INTERVAL "tp_edit_trigger_interval"
#define TP_OBJ_NAME_PUSHBUTTON_SEND_TRIGGER "tp_button_send_trigger"
#define TP_OBJ_NAME_CHECKBOX_APP_STATUS "tp_app_checked_status"
#endif //__TADPOLE_GUI_HEADER_H

@ -0,0 +1,883 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:CameraPool.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/25
History:25:3:2015 11:28
*******************************************************************************/
#include "CameraPool.h"
#include <QDebug>
CCameraPool::CCameraPool(void)
: m_thdTrigger(this)
, m_libs(gpGlobalData->tgdDllPath)
// :m_mutexImgQueue(QMutex::Recursive)
{
m_nTriggerMode = DEV_TRIGGER_MODE_STOP;
m_nFrameRate = 0;
m_nCameraEncode = 0;
}
CCameraPool::~CCameraPool(void)
{
releaseImagesList();
}
int CCameraPool::InitPool()
{
int nRet = 0;//IOpenDevices(true);
m_thdTrigger.StartTrigger();
return nRet;
}
void CCameraPool::FreePool()
{
m_thdTrigger.EndTrigger();
ICloseDevices();
IDeleteDameraes();
}
int CCameraPool::ICreateCameraes()
{
QList<QString> keys = gpGlobalCamera->CameraKeys();//cameraes.keys();
for (int i = 0; i < keys.size(); ++i)
{
if (m_cameraes.contains(keys[i]))
{
continue;
}
ICameraObject* pObject = m_libs.Create(gpGlobalCamera->CameraOption(keys[i]), this);
if (NULL == pObject)
{
continue;
}
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
m_cameraes.insert(keys[i], pObject);
}
return m_cameraes.size();
}
bool CCameraPool::ICreateCamera(const QString& strSerial, int nType)
{
if (m_cameraes.contains(strSerial))
{
return false;
}
TP_CAMERA_OPTION camOpt;
camOpt.deviceType = nType;
camOpt.uniqueName = strSerial;
ICameraObject* pObject = m_libs.Create(&camOpt, this);
if (NULL == pObject)
{
return false;
}
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
m_cameraes.insert(strSerial, pObject);
return true;
}
bool CCameraPool::IOpenCamera(const QString& strSerial, bool bReopen)
{
ICameraObject* pCamera = m_cameraes.value(strSerial);
if (!pCamera)
return false;
//if (pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_INITED &&
// pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_CLOSED){
// return false;
//}
if (bReopen)
{
pCamera->ICloseCamera();
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
}
int nret = pCamera->IOpenCamera();
if (nret == 1){
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
return true;
}
return false;
}
bool CCameraPool::ICloseCamera(const QString& strSerial)
{
ICameraObject* pCamera = m_cameraes.value(strSerial);
if (!pCamera)
return false;
pCamera->ICloseCamera();
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
return true;
}
bool CCameraPool::IDeleteCamera(const QString& strSerial)
{
ICameraObject* pCamera = m_cameraes.value(strSerial);
if (pCamera){
pCamera->IStopCamera();
pCamera->ICloseCamera();
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
m_libs.Delete(pCamera);
}
m_cameraes.remove(strSerial);
gpGlobalCamera->delCameraOption(strSerial);
return true;
}
bool CCameraPool::IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun/* = false */)
{
bool bret = false;
if (!bNew){
bret = ICloseCamera(strName);
if (!bret) return bret;
}
gpGlobalCamera->updateCameraOption(strName, camOpt);
if (bNew){
ICameraObject* pCamObj = m_libs.Create(gpGlobalCamera->CameraOption(strName), this);
if (pCamObj)
{
pCamObj->m_pCamOpt->status = TP_CAMERA_STATUS_INITED;
m_cameraes.insert(strName, pCamObj);
}
else{
return false;
}
}
bret = IOpenCamera(strName, true);
if (!bret) return bret;
if (bAutoRun){
bret = IStartCamera(strName);
}
return bret;
}
bool CCameraPool::IStartCamera(const QString& strSerial)
{
ICameraObject* pCamera = m_cameraes.value(strSerial);
if (!pCamera)
return false;
//if (pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_OPENED &&
// pCamera->m_pCamOpt->status != TP_CAMERA_STATUS_STOPPED )
//{
// return false;
//}
int nret = pCamera->IStartCamera();
if (nret == 1){
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STARTED;
return true;
}
return false;
}
bool CCameraPool::IStopCamera(const QString& strSerial)
{
ICameraObject* pCamera = m_cameraes.value(strSerial);
if (!pCamera)
return false;
pCamera->IStopCamera();
pCamera->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
return true;
}
void CCameraPool::IDeleteDameraes()
{
IStopDevices();
ICloseDevices();
m_cameraes.clear(cameraErased, &m_libs);
}
void CCameraPool::cameraOpen(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
if (pCam->IOpenCamera() == 1)
{
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
}
}
void CCameraPool::cameraOpenEx(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
if (pCam->m_pCamOpt->bAutoOpen)
{
if (pCam->IOpenCamera() == 1)
{
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
}
}
}
int CCameraPool::IOpenDevices(bool bReopenAll)
{
if( bReopenAll )
{
ICloseDevices();
}
m_cameraes.iterateCall(cameraOpen, NULL);
m_cameraes.iterateCall(cameraCalRelyOn, &m_cameraes);
//calRelyOn();
//ISetTriggerMode(DEV_TRIGGER_MODE_AUTO, TRIGGER_DIRECT_FOREWARD, gGlobalPoolOption.frameRate);
return 1;
}
int CCameraPool::IOpenDevicesEx(bool bReopenAll)
{
if (bReopenAll)
{
ICloseDevices();
}
m_cameraes.iterateCall(cameraOpenEx, NULL);
m_cameraes.iterateCall(cameraCalRelyOnEx, &m_cameraes);
//calRelyOn();
//ISetTriggerMode(DEV_TRIGGER_MODE_AUTO, TRIGGER_DIRECT_FOREWARD, gGlobalPoolOption.frameRate);
return 1;
}
void CCameraPool::cameraClose(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
pCam->ICloseCamera();
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_CLOSED;
}
void CCameraPool::ICloseDevices()
{
m_cameraes.iterateCall(cameraClose, NULL);
// m_devVessel.Erase(NULL, deviceErased, false);
//m_cameraes.clear(cameraErased, &m_libs);
}
void CCameraPool::IStartDevices()
{
m_cameraes.iterateCall(cameraStartDevices, NULL);
}
void CCameraPool::IStopDevices(const QString& sDef/* = NULL*/)
{
if (sDef.isEmpty())
{
m_cameraes.iterateCall(cameraStopDevices, NULL);
}
else
{
m_cameraes.valueCall(sDef, cameraStopDevices, NULL);
}
}
bool CCameraPool::ICamsStartPush()
{
m_cameraes.iterateCall(camerasStartPush, NULL);
return true;
}
void CCameraPool::camerasStartPush(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
//if (pCam->m_pCamOpt->deviceType != 110) return;
pCam->IStartPush();
}
bool CCameraPool::ICamsPausePush()
{
m_cameraes.iterateCall(camerasPausePush, NULL);
return true;
}
void CCameraPool::camerasPausePush(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
//if (pCam->m_pCamOpt->deviceType != 110) return;
pCam->IPausePush();
}
void CCameraPool::fixedFramesStopCamera(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
if (pCam->NeedStopping())
{
pCam->IStopCamera();
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
}
}
void CCameraPool::DeviceLost(const QString& strName)
{
ICameraObject* pObj = m_cameraes.take(strName);
if (NULL != pObj)
{
m_libs.Delete(pObj);
}
// m_devVessel.Erase(strName, deviceErased, false);
// m_virVessel.Erase(strName, deviceErased, false);
}
QList<QString> CCameraPool::ICameraKeys()
{
return gpGlobalCamera->CameraKeys();
}
QList<QString> CCameraPool::ICameraKeysOrderByIds()
{
return gpGlobalCamera->CameraKeysOrderByIds();
}
bool CCameraPool::ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{
return gpGlobalCamera->CameraOption(strSerial, camOpt);
}
bool CCameraPool::ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt)
{
return gpGlobalCamera->CameraOptionByKey(strSerial, camOpt);
}
bool CCameraPool::ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt)
{
bool bRet = gpGlobalCamera->SetCameraOption(strSerial, camOpt);
if (bRet)
{
ICameraObject* pCam = m_cameraes.value(strSerial, NULL);
if (NULL != pCam)
{
pCam->ISetProperty(NULL);
}
}
return bRet;
}
QList<QString> CCameraPool::IEnumAvailableCameras(emTpDeviceType camType)
{
QList<QString> ret;
// if the camera dll has been loaded
QZkMutexMap<QString, class ICameraObject*>::const_iterator iter = m_cameraes.constBegin();
while (iter != m_cameraes.constEnd())
{
ICameraObject* pCam = iter.value();
if (pCam && pCam->m_pCamOpt->deviceType == camType){
ret = pCam->IEnumAvailableCameras();
return ret;
}
iter++;
}
// the camera dll has not been loaded
TP_CAMERA_OPTION camOpt;
camOpt.deviceType = camType;
ret = m_libs.enumAvailableCameras(&camOpt, this);
return ret;
}
void CCameraPool::ISetTriggerMode(emTpDeviceTriggerMode mode, emTpTriggerDirection nDirection /* = TRIGGER_DIRECT_FOREWARD */, long nFrameRate /* = 0 */)
{
gGlobalPoolOption.triggerMode = mode;
gGlobalPoolOption.triggerDirection = nDirection;
gGlobalPoolOption.frameRate = nFrameRate;
gGlobalPoolOption.fixedFrames = nFrameRate;
m_nTriggerMode = mode;
m_nFrameRate = nFrameRate;
//set every device's trigger
m_thdTrigger.LockWorked();
m_cameraes.iterateCall(cameraSetTriggerMode, &gGlobalPoolOption);
IStartDevices();
m_thdTrigger.UnlockWorked();
//begin or end trigger's thread
if( DEV_TRIGGER_MODE_AUTO != mode &&
DEV_TRIGGER_MODE_FIXED_AUTO != mode )
{
//m_thdTrigger.EndThread();
m_thdTrigger.SetAutoTrigger(false);
}
else
{
m_thdTrigger.SetFrame(nFrameRate);
//m_thdTrigger.StartTrigger();
m_thdTrigger.SetAutoTrigger(true);
}
}
void CCameraPool::IManualTrigger(emTpTriggerDirection nDirection /* = TRIGGER_DIRECT_FOREWARD */)
{
if( DEV_TRIGGER_MODE_OUT != m_nTriggerMode )
{
ISetTriggerMode(DEV_TRIGGER_MODE_OUT);
}
tagCOMMIT_TRIGGER_PARAM prm;
prm.direct = nDirection;
prm.count = 0;
prm.bFromMenual = true;
m_cameraes.iterateCall(cameraSnaps, &prm);
// SnapImages(prm);
}
void gfunc_snap_camera_image(const QString& key, class ICameraObject*& pCam, void* pData)
{
if (!pCam)
return;
if (NULL != pCam->RelyOnCamera())
{
return;
}
QStringList* pKeys = (QStringList*)pData;
if (!pKeys->contains(key))
{
return;
}
pCam->ISnapCamera(TRIGGER_DIRECT_FOREWARD);
}
void CCameraPool::ISnapImage(const QStringList& camKeys)
{
m_cameraes.iterateCall2(gfunc_snap_camera_image, (void*)(&camKeys));
}
void gfunc_send_soft_trigger(const QString& key, class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
if (NULL != pCam->RelyOnCamera())
{
return;
}
if (NULL != pData)
{
QStringList* pKeys = (QStringList*)pData;
if (!pKeys->contains(key))
{
return;
}
}
pCam->ISendSoftTrigger();
}
void CCameraPool::ISendSoftTrigger(const QStringList& camKeys)
{
if (camKeys.isEmpty())
{
m_cameraes.iterateCall2(gfunc_send_soft_trigger, NULL);
}
else
{
m_cameraes.iterateCall2(gfunc_send_soft_trigger, (void*)(&camKeys));
}
}
void CCameraPool::IntervalCaptureImages(tagCOMMIT_TRIGGER_PARAM& prm)
{
m_cameraes.iterateCall(cameraIntervalCaptures, &prm);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
//**difficult to understand**
//iterate the virtual camera's vessel and the device's vessel as the parameter
void CCameraPool::calRelyOn()
{
m_cameraes.iterateCall(cameraCalRelyOn, &m_cameraes);
}
void CCameraPool::ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue)
{
}
void CCameraPool::ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property)
{
if( camera.isNull() )
{
m_cameraes.iterateCall(cameraSetProperty, &property);
}
else
{
m_cameraes.valueCall(camera, cameraSetProperty, &property);
}
}
void CCameraPool::cameraSetProperty(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
pCam->ISetProperty((TP_CAMERA_PROPERTY*)pData);
}
//ICameraObject* CCameraPool::CreateCamera(TP_CAMERA_OPTION* pCamOpt)
//{
// if( NULL == pCamOpt )
// {
// return NULL;
// }
// ICameraObject* pObj = NULL;
// if( DEV_CAMERA == pCamOpt->deviceType )
// {
// //pObj = new CGigeCamera(pCamOpt, this);
// }
// else if( DEV_VIRTUAL == pCamOpt->deviceType )
// {
// //pObj = new CVirtualCamera(pCamOpt, this);
// }
// else if( DEV_BITFLOW == pCamOpt->deviceType )
// {
// //pObj = new CBitflowCameraBi(pCamOpt, this);
// }
// return pObj;
//}
QList<TP_CAMERA_WIN*> CCameraPool::ICameraWins()
{
return gpGlobalCamera->CameraWins();
}
CZkCameraImage* CCameraPool::IPopCameraImage()
{
return m_imagesList.takeFirst(NULL);
/*CZkCameraImage *pCamImg = m_imagesList.takeFirst(NULL);
if (NULL != pCamImg)
{
}
return pCamImg;*/
}
//////////////////////////////////////////////////////////////////////////////////////////////
int CCameraPool::createDeviceByOptiones()
{
QList<QString> keys = gpGlobalCamera->CameraKeys();//cameraes.keys();
for( int i = 0; i < keys.size(); ++i )
{
if( m_cameraes.contains(keys[i]) )
{
continue;
}
ICameraObject* pObject = m_libs.Create(gpGlobalCamera->CameraOption(keys[i]), this);
if( NULL == pObject )
{
continue;
}
if( 0 == pObject->IOpenCamera() )
{
m_libs.Delete(pObject);
continue;
}
pObject->m_pCamOpt->status = TP_CAMERA_STATUS_OPENED;
m_cameraes.insert(keys[i], pObject);
}
return m_cameraes.size();
}
void CCameraPool::cameraErased(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
CLibCameraes* pLibs = (CLibCameraes*)pData;
pCam->IStopCamera();
pCam->ICloseCamera();
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
pLibs->Delete(pCam);
}
void CCameraPool::cameraStartDevices(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
//if (pCam->m_pCamOpt->status != TP_CAMERA_STATUS_OPENED &&
// pCam->m_pCamOpt->status != TP_CAMERA_STATUS_STOPPED)
//{
// return;
//}
if (pCam->IStartCamera() == 1){
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STARTED;
}
}
void CCameraPool::cameraStopDevices(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
pCam->IStopCamera();
pCam->m_pCamOpt->status = TP_CAMERA_STATUS_STOPPED;
}
void CCameraPool::cameraSetTriggerMode(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
TP_CAMERAPOOL_OPTION* pOpt = (TP_CAMERAPOOL_OPTION*)pData;
pCam->SetFixedFrames(pOpt->fixedFrames);
pCam->SetTriggerMode(pOpt->triggerMode);
}
void CCameraPool::cameraSnaps(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
tagCOMMIT_TRIGGER_PARAM* pParam = (tagCOMMIT_TRIGGER_PARAM*)pData;
if( NULL != pCam->RelyOnCamera() )
{
return;
}
pCam->ISnapCamera(pParam->direct);
}
void CCameraPool::cameraIntervalCaptures(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
//tagCOMMIT_TRIGGER_PARAM* pParam = (tagCOMMIT_TRIGGER_PARAM*)pData;
if (NULL != pCam->RelyOnCamera())
{
return;
}
//pCam->ISnapCamera(pParam->direct);
pCam->IAutoCapture();
}
void CCameraPool::cameraCalRelyOn(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
QZkMutexMap<QString, class ICameraObject*>* pCameraes = (QZkMutexMap<QString, class ICameraObject*>*)pData;
TP_CAMERA_OPTION* pOpt = pCam->m_pCamOpt;
if( DEV_CAM_VIRTUAL_FOLDER == pOpt->deviceType && NULL == pCam->RelyOnCamera() && pCameraes->contains(pOpt->relyOnCamera) )
{
ICameraObject* pCamRelyOn = pCameraes->value(pOpt->relyOnCamera, NULL);
if( NULL != pCamRelyOn )
{
pCam->SetRelyOnCamera(pCamRelyOn);
pCamRelyOn->SetReliedByCamera(pCam);
}
}
}
void CCameraPool::cameraCalRelyOnEx(class ICameraObject*& pCam, void* pData)
{
if (!pCam) return;
QZkMutexMap<QString, class ICameraObject*>* pCameraes = (QZkMutexMap<QString, class ICameraObject*>*)pData;
TP_CAMERA_OPTION* pOpt = pCam->m_pCamOpt;
if (DEV_CAM_VIRTUAL_FOLDER == pOpt->deviceType && pOpt->bAutoOpen && NULL == pCam->RelyOnCamera() && pCameraes->contains(pOpt->relyOnCamera))
{
ICameraObject* pCamRelyOn = pCameraes->value(pOpt->relyOnCamera, NULL);
if (NULL != pCamRelyOn)
{
pCam->SetRelyOnCamera(pCamRelyOn);
pCamRelyOn->SetReliedByCamera(pCam);
}
}
}
int CCameraPool::IPushCameraData(ICameraObject* pCamObj)
{
if (m_imagesList.size() >= 32)
{
qWarning("Cache OverFlow, Camera Image Count:%d", m_imagesList.size());
if (pCamObj->m_nFrameNum > 0)
{
pCamObj->m_nFrameNum--;
}
return 0;
}
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt )
{
return 0;
}
if (pCamObj->m_pCamOpt->bIgnoreImage)
{
if (pCamObj->m_nFrameNum > 0)
{
pCamObj->m_nFrameNum--;
}
return 0;
}
//
pCamObj->SaveToFile();
CZkCameraImage *pImage = m_imagesMerging.value(pCamObj->m_pCamOpt->uniqueName, NULL);
if (NULL == pImage)
{
pImage = new CZkCameraImage();
}
int nRet = 0;
if (NULL != pImage)
{
//
if (!gpGlobalCamCallback){
delete pImage;
return 0;
}
try{
pImage->SetVarFromUI(gpGlobalCamCallback->IGetVariantById(pCamObj->m_pCamOpt->id));
//QVariantMap map;
//map.clear();
//map.insert("width", pCamObj->m_nImageWidth);
//map.insert("height", pCamObj->m_nImageHeight);
//map.insert("size", pCamObj->m_nImageSize);
//map.insert("frame", pCamObj->m_nFrameNum);
//qint64 nSizes = pCamObj->m_nImageHeight*pCamObj->m_nImageWidth*((pCamObj->m_nBitsPerPixel + 7) / 8);
////QByteArray baimgdat = QByteArray::fromRawData((const char*)(pCamObj->m_pCameraData), nSizes);
//QByteArray baimgdat = QByteArray((const char*)(pCamObj->m_pCameraData));
//map.insert("imgdata", baimgdat);
//std::string imgb64 = base64_encode(pCamObj->m_pCameraData, nSizes);
//int b64len = imgb64.length();
//QString qsimgb64(imgb64.c_str());
//map.insert("imgb64", qsimgb64);
//gpGlobalCamCallback->INewCameraImage(map);
}
catch (...){
qCritical() << "Critical error." << __FUNCTION__;
return 0;
}
//
int nRet = pImage->CopyCameraObject(pCamObj);
if (-1 == nRet)
{
delete pImage;
pImage = NULL;
}
else if (1 == nRet)
{
pImage->SetMeterCode(m_nCameraEncode);
m_imagesList.append(pImage);
pImage = NULL;
}
m_imagesMerging.insert(pCamObj->m_pCamOpt->uniqueName, pImage);
nRet = 1;
}
//checks to stop trigger in fixed_auto
if (pCamObj->NeedStopping())
{
//IStopDevices(pCamObj->CameraOption()->uniqueName);//不是好方法如果正在SetTriggerStart这里可能会立刻Stop这次Start
//pCamObj->IStopCamera();//不是好方法如果正在SetTriggerStart这里可能会立刻Stop这次Start
m_cameraes.valueCall(pCamObj->m_pCamOpt->uniqueName, fixedFramesStopCamera, NULL);
}
return nRet;
}
//don't combine image
int CCameraPool::IPushCameraData2(ICameraObject* pCamObj)
{
if (m_imagesList.size() >= 32)
{
qWarning("Cache OverFlow, Camera Image Count:%d", m_imagesList.size());
}
quint64 msec = QDateTime::currentMSecsSinceEpoch();
if (NULL == pCamObj || NULL == pCamObj->m_pCamOpt)
{
return 0;
}
if (pCamObj->m_pCamOpt->bIgnoreImage)
{
if (pCamObj->m_nFrameNum > 0)
{
pCamObj->m_nFrameNum--;
}
return 0;
}
//
pCamObj->SaveToFile();
//
CZkCameraImage* pImage = new CZkCameraImage();
if (NULL == pImage)
{
return 0;
}
if (0 == pImage->CopyCameraObject2(pCamObj))
{
delete pImage;
return 0;
}
pImage->SetVarFromUI(gpGlobalCamCallback->IGetVariantById(pCamObj->m_pCamOpt->id));
m_imagesList.append(pImage);
//
if (pCamObj->NeedStopping())
{
m_cameraes.valueCall(pCamObj->m_pCamOpt->uniqueName, fixedFramesStopCamera, NULL);
}
return 1;
}
char* CCameraPool::IGetMainPath()
{
return gpGlobalCamera->m_pGlobalData->tgdMainPath;
}
void CCameraPool::IFreeCameraImage(CZkCameraImage *pCamImg)
{
delete pCamImg;
}
QMap<QString, QString> CCameraPool::IGetCamShowNames()
{
return gpGlobalCamera->GetCamShowNames();
}
void CCameraPool::ISetCameraEncode(INT64 code, INT64 rate)
{
m_nCameraEncode = code;
m_nEncoderRate = rate;
}
void CCameraPool::ISetVirtualImages(const QString& camera, const QStringList& szImages)
{
if (camera.isEmpty())
{
m_cameraes.iterateCall(cameraSetVirtuleImages, (void*)&szImages);
}
else
{
m_cameraes.valueCall(camera, cameraSetVirtuleImages, (void*)&szImages);
}
}
void CCameraPool::cameraSetVirtuleImages(class ICameraObject*& pCam, void* pData)
{
QStringList* pszImages = (QStringList*)pData;
if (pCam->m_pCamOpt->deviceType / 10 == DEV_CAM_VIRTUAL / 10)
{
pCam->ISetVirtualImages(*pszImages);
}
}
QList<QString> CCameraPool::ICamWinKeys()
{
return gpGlobalCamera->camWinKeys();
}
bool CCameraPool::ICamWinOptionByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt)
{
return gpGlobalCamera->camWinByKey(strKey, camwinOpt);
}
bool CCameraPool::IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew)
{
return gpGlobalCamera->addCamWin(strKey, camwinOpt, bNew);
}
bool CCameraPool::IDelCamWin(const QString& strKey)
{
return gpGlobalCamera->delCamWin(strKey);
}

@ -0,0 +1,150 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:CameraPool.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/25
History:25:3:2015 11:26
*******************************************************************************/
#ifndef __CAMERA_POOL_H_20150325
#define __CAMERA_POOL_H_20150325
#include "icamera.h"
#include <QtCore/QMap>
#include <QtCore/QQueue>
//#include <QtCore/QMutexLocker>
#include <QtCore/QString>
#include "triggerthread.h"
#include "QZkMutexList.h"
#include "QZkMutexMap.h"
#include "iCameraObject.h"
#include "LibCameraes.h"
class CCameraPool : public ICameraPool, public IPoolCallback
{
public:
CCameraPool(void);
virtual ~CCameraPool(void);
int InitPool();
void FreePool();
int ImagesSize() {
return m_imagesList.size();
}
void DeviceLost(const QString& strName);
//called by "CTriggerThread"
struct tagCOMMIT_TRIGGER_PARAM{
emTpTriggerDirection direct;
DWORD count;
bool bFromMenual;
};
void IntervalCaptureImages(tagCOMMIT_TRIGGER_PARAM& prm);
private:
virtual QList<QString> ICameraKeys();//获取相机的keys在camera.json中配置
virtual QList<QString> ICameraKeysOrderByIds();//获取相机的keys但根据id排序
virtual bool ICameraOption(const QString& strSerial, TP_CAMERA_OPTION& camOpt);//根据相机key获取相机的配置属性
virtual bool ICameraOptionByKey(const QString& strSerial, TP_CAMERA_OPTION& camOpt);//根据相机key获取相机的配置属性
virtual bool ISetCameraOption(const QString& strSerial, const TP_CAMERA_OPTION& camOpt);
//
virtual int ICreateCameraes();
virtual void IDeleteDameraes();
virtual QList<QString> IEnumAvailableCameras(emTpDeviceType camType); // try to get available (connected to the computer) by camera type(manufacturer)
virtual bool ICreateCamera(const QString& strSerial, int nType);
virtual bool IOpenCamera(const QString& strSerial, bool bReopen);
virtual bool ICloseCamera(const QString& strSerial);
virtual bool IStartCamera(const QString& strSerial);
virtual bool IStopCamera(const QString& strSerial);
virtual bool IDeleteCamera(const QString& strSerial);
virtual bool IAddCamera(const QString& strName, const TP_CAMERA_OPTION& camOpt, bool bNew, bool bAutoRun = false);
//
virtual int IOpenDevices(bool bReopenAll);
virtual int IOpenDevicesEx(bool bReopenAll);
virtual void ICloseDevices();
virtual void IStartDevices();
virtual void IStopDevices(const QString& sDef = NULL);
virtual void ISetTriggerMode(emTpDeviceTriggerMode mode, emTpTriggerDirection nDirection = TRIGGER_DIRECT_FOREWARD, long nFrameRate = 0);
virtual emTpDeviceTriggerMode IGetTriggerMode(){
return m_nTriggerMode;
}
virtual void IManualTrigger( emTpTriggerDirection nDirection = TRIGGER_DIRECT_FOREWARD);
virtual void ISnapImage(const QStringList& camKeys);
virtual void ISendSoftTrigger(const QStringList& camKeys);
virtual QList<TP_CAMERA_WIN*> ICameraWins();
virtual CZkCameraImage* IPopCameraImage();
virtual int ICameraImages() {
return m_imagesList.size();
}
virtual void IFreeCameraImage(CZkCameraImage *pCamImg);
///////////////////////////////////////////////////////////////////////////////////////
virtual void ISetCameraProperty(const QString& camera, emTpCameraProperty property, long nValue);
virtual void ISetCameraProperty(const QString& camera, TP_CAMERA_PROPERTY& property);
virtual QMap<QString, QString> IGetCamShowNames();
virtual void ISetCameraEncode(INT64 code, INT64 rate);
virtual void ISetVirtualImages(const QString& camera, const QStringList& szImages);
//operate camera window
virtual QList<QString> ICamWinKeys();
virtual bool ICamWinOptionByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt);
virtual bool IAddCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew);
virtual bool IDelCamWin(const QString& strKey);
virtual bool ICamsStartPush();
virtual bool ICamsPausePush();
///////////////////////////////////////////////////////////////////////////////////////////
// ICameraObject* CreateCamera(TP_CAMERA_OPTION* pCamOpt);
void calRelyOn();
///////////////////////////////////////////////////////////////////////////////////////////////
void releaseImagesList() {
//m_imagesList.iterateCall(iterateCallImageErase, NULL);
m_imagesList.clear(iterateCallImageErase, NULL);
m_imagesMerging.clear(iterateCallImageErase, NULL);
//m_imagesCache.clear(iterateCallImageErase, NULL);
}
static void iterateCallImageErase(class CZkCameraImage*& pImage, void* pData) {
delete pImage;
}
//using class ICameraObject
int createDeviceByOptiones();
static void cameraOpen(class ICameraObject*& pCam, void* pData);
static void cameraOpenEx(class ICameraObject*& pCam, void* pData);
static void cameraClose(class ICameraObject*& pCam, void* pData);
static void cameraErased(class ICameraObject*& pCam, void* pData);
static void cameraStartDevices(class ICameraObject*& pCam, void* pData);
static void cameraStopDevices(class ICameraObject*& pCam, void* pData);
static void cameraSetTriggerMode(class ICameraObject*& pCam, void* pData);
static void cameraSnaps(class ICameraObject*& pCam, void* pData);
static void cameraIntervalCaptures(class ICameraObject*& pCam, void* pData);
static void cameraCalRelyOn(class ICameraObject*& pCam, void* pData);
static void cameraCalRelyOnEx(class ICameraObject*& pCam, void* pData);
static void cameraSetProperty(class ICameraObject*& pCam, void* pData);
static void fixedFramesStopCamera(class ICameraObject*& pCam, void* pData);
static void cameraSetVirtuleImages(class ICameraObject*& pCam, void* pData);
//IPoolCallback interface
virtual int IPushCameraData(ICameraObject* pCamObj);
virtual int IPushCameraData2(ICameraObject* pCamObj);
virtual char* IGetMainPath();
static void camerasStartPush(class ICameraObject*& pCam, void* pData);
static void camerasPausePush(class ICameraObject*& pCam, void* pData);
private:
//**the key is unique name, not serial number**
QZkMutexMap<QString, CZkCameraImage*> m_imagesMerging;
QZkMutexList<CZkCameraImage*> m_imagesList;
//QZkMutexMap<QString, CZkCameraImage*> m_imagesCache;
CTriggerThread m_thdTrigger;
emTpDeviceTriggerMode m_nTriggerMode;
long m_nFrameRate;
//////////////////////////////////////////////////////////////
QZkMutexMap<QString, class ICameraObject*> m_cameraes;
CLibCameraes m_libs;
INT64 m_nCameraEncode;
INT64 m_nEncoderRate;
};
#endif

@ -0,0 +1,203 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:LibCameraes.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/26
History:26:5:2015 16:34
*******************************************************************************/
#include "LibCameraes.h"
#include <QtCore\qfile.h>
#include <QDebug>
#define PREFIX_API(pfx) \
extern "C" ICameraObject* pfx##Camera_Create(TP_CAMERA_OPTION* pCamOpt, IPoolCallback* pCb);\
extern "C" void pfx##Camera_Delete(ICameraObject*);
#ifndef _USE_CAMERA_DLL
#ifdef _USE_BITFLOW
PREFIX_API(Bitflow_)
#endif
#ifdef _USE_VIRTUAL
PREFIX(Virtual_)
#endif
#ifdef _USE_GIGE
PREFIX(Gige_)
#endif
#endif
CLibCameraes::CLibCameraes(char* szPath)
: m_szPath(szPath)
{
}
CLibCameraes::~CLibCameraes()
{
m_camApiMap.clear(clearCall);
}
ICameraObject* CLibCameraes::Create(TP_CAMERA_OPTION* pCamOpt, IPoolCallback* pCb)
{
if( NULL == pCamOpt || NULL == pCb )
{
return NULL;
}
if( !LoadCameraApi((emTpDeviceType)pCamOpt->deviceType) )
{
return NULL;
}
CAMERA_API* pApi = m_camApiMap.value(pCamOpt->deviceType, NULL);
if( NULL == pApi || NULL == pApi->fpCreate )
{
return NULL;
}
ICameraObject* pCam = pApi->fpCreate(pCamOpt, pCb);
if (NULL != pCam)
{
pApi->cameraes++;
}
return pCam;
}
bool CLibCameraes::Delete(ICameraObject* pCam)
{
if( NULL == pCam )
{
return false;
}
int nKey = pCam->m_pCamOpt->deviceType;
CAMERA_API* pApi = m_camApiMap.value(nKey, NULL);
if( NULL == pApi || NULL == pApi->fpDelete )
{
return false;
}
pApi->fpDelete(pCam);
pApi->cameraes--;
/*
if (0 == pApi->cameraes)//release the dll
{
clearCall(pApi, NULL);
m_camApiMap.remove(nKey);
}
*/
return true;
}
bool CLibCameraes::LoadCameraApi(emTpDeviceType devType)
{
if( m_camApiMap.contains(devType) )
{
return true;
}
CAMERA_API* pApi = new CAMERA_API;
if( NULL == pApi )
{
return false;
}
#ifdef _USE_CAMERA_DLL
QString fileName(m_szPath);
// if( !fileName.endsWith('\\') && !fileName.endsWith('/') )
// {
// fileName.append('\\');
// }
int nType = devType/10 * 10;
QString strAlias;
strAlias = "tpCam_" + QString::number(nType);
fileName.append(strAlias);
#ifdef _DEBUG
fileName.append('d');
#endif
//
pApi->pLib = new QLibrary(fileName);
if( NULL == pApi->pLib )
{
delete pApi;
return false;
}
pApi->fpCreate = (Func_Create)pApi->pLib->resolve("Camera_Create");
pApi->fpDelete = (Func_Delete)pApi->pLib->resolve("Camera_Delete");
if( NULL == pApi->fpCreate || NULL == pApi->fpDelete )
{
QString strErr = QString("Failed to Load camera's dll: %1; ERROR: %2")
.arg(fileName.toLocal8Bit().data())
.arg(pApi->pLib->errorString().toLocal8Bit().data());
qCritical() << strErr << " - " << __FUNCTION__;
delete pApi->pLib;
delete pApi;
return false;
}
#else
switch(devType)
{
case DEV_CAM_BITFLOW:
pApi->fpCreate = API_NAME_PREFIX(Bitflow_, Camera_Create);
pApi->fpDelete = API_NAME_PREFIX(Bitflow_, Camera_Delete);
break;
case DEV_CAM_VIRTUAL:
pApi->fpCreate = API_NAME_PREFIX(Virtual_, Camera_Create);
pApi->fpDelete = API_NAME_PREFIX(Virtual_, Camera_Delete);
break;
case DEV_CAM_GIGE:
pApi->fpCreate = API_NAME_PREFIX(Gige_, Camera_Create);
pApi->fpDelete = API_NAME_PREFIX(Gige_, Camera_Delete);
break;
case DEV_CAM_USB:
pApi->fpCreate = API_NAME_PREFIX(Usb_, Camera_Create);
pApi->fpDelete = API_NAME_PREFIX(Usb_, Camera_Delete);
break;
default:
delete pApi;
return false;
}
#endif
pApi->cameraes = 0;
m_camApiMap.insert(devType, pApi);
return true;
}
void CLibCameraes::clearCall(CAMERA_API*& pCamApi, void* pData)
{
#ifdef _USE_CAMERA_DLL
delete pCamApi->pLib;
#endif
delete pCamApi;
}
QList<QString> CLibCameraes::enumAvailableCameras(TP_CAMERA_OPTION* pCamOpt, IPoolCallback* pCb)
{
QList<QString> ret;
if (!LoadCameraApi((emTpDeviceType)pCamOpt->deviceType))
{
return ret;
}
CAMERA_API* pApi = m_camApiMap.value(pCamOpt->deviceType, NULL);
if (NULL == pApi || NULL == pApi->fpCreate)
{
return ret;
}
ICameraObject* pCam = pApi->fpCreate(pCamOpt, pCb);
if (NULL != pCam)
{
ret = pCam->IEnumAvailableCameras();
int nKey = pCam->m_pCamOpt->deviceType;
pApi->fpDelete(pCam);
if (0 == pApi->cameraes)//release the dll
{
clearCall(pApi, NULL);
m_camApiMap.remove(nKey);
}
}
return ret;
}

@ -0,0 +1,54 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:LibCameraes.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/26
History:26:5:2015 16:34
*******************************************************************************/
#ifndef LIBCAMERAES_H
#define LIBCAMERAES_H
#include "iCameraObject.h"
#include "QZkMutexMap.h"
#include <QtCore\qlibrary.h>
#include <QtCore\qfile.h>
class CLibCameraes
{
public:
CLibCameraes(char* szPath);
~CLibCameraes();
ICameraObject* Create(TP_CAMERA_OPTION* pCamOpt, IPoolCallback* pCb);
bool Delete(ICameraObject* pCam);
QList<QString> enumAvailableCameras(TP_CAMERA_OPTION* pCamOpt, IPoolCallback* pCb);
private:
typedef ICameraObject*(*Func_Create)(TP_CAMERA_OPTION* pCamOpt, IPoolCallback* pCb);
typedef void(*Func_Delete)(ICameraObject* pCam);
typedef struct tagCAMERA_API {
Func_Create fpCreate;
Func_Delete fpDelete;
#ifdef _USE_CAMERA_DLL
QLibrary* pLib;
#endif
int cameraes;
} CAMERA_API;
bool LoadCameraApi(emTpDeviceType devType);
static void clearCall(CAMERA_API*& pCamApi, void* pData);
private:
QZkMutexMap<int, CAMERA_API*> m_camApiMap;
char* m_szPath;
};
inline bool is_dll_library(const QString& name)
{
#ifdef _DEBUG
return QFile::exists(name + "d.dll");
#else
return QFile::exists(name + ".dll");
#endif
}
#endif // LIBCAMERAES_H

@ -0,0 +1,460 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:globalCamera.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/09
History:9:4:2015 13:23
*******************************************************************************/
#include <QDir>
#include "globalCamera.h"
#include "ZkCameraImage.h"
#include <QReadWriteLock>
#include <QCoreApplication>
#ifdef _USE_CAMERA_SERIAL_ENCRYPTO
#include "QZkSerialNumbers.h"
#endif
const char CGlobalCamera::cs_szCfgName[] = "camera";
CGlobalCamera::CGlobalCamera(const CAMERA_IN_PARAM* pInParam)
:m_mtxCam(QMutex::Recursive)
{
m_pCallback = pInParam->pCallback;
m_pGlobalData = pInParam->pGlobalData;
readConfig();
readSerials();
}
CGlobalCamera::~CGlobalCamera()
{
releaseConfig();
}
bool CGlobalCamera::CameraOption(const QString& serials, TP_CAMERA_OPTION& camOpt)
{
// camOpt.serials = serials;
return m_cameraesOption.iterateCall(copyCameraOptionBySerial, &camOpt);
}
bool CGlobalCamera::copyCameraOptionBySerial(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData)
{
TP_CAMERA_OPTION* pDes = (TP_CAMERA_OPTION*)pData;
if (pCamOpt->uniqueName == pDes->uniqueName)
{
*pDes = *pCamOpt;
return true;
}
return false;
}
bool CGlobalCamera::CameraOptionByKey(const QString& sKey, TP_CAMERA_OPTION& camOpt)
{
return m_cameraesOption.valueCall(sKey, copyCameraOptionByKey, &camOpt);
}
void CGlobalCamera::copyCameraOptionByKey(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData)
{
TP_CAMERA_OPTION* pDes = (TP_CAMERA_OPTION*)pData;
*pDes = *pCamOpt;
}
bool CGlobalCamera::SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION& camOpt)
{
TP_CAMERA_OPTION* pOpt = m_cameraesOption.value(sKey, NULL);
if (NULL == pOpt)
{
return false;
}
pOpt->save = camOpt.save;
pOpt->algorithm = camOpt.algorithm;
pOpt->exposure = camOpt.exposure;
pOpt->folder = camOpt.folder;
checkFolder(pOpt->folder);
pOpt->gain = camOpt.gain;
pOpt->bIgnoreImage = camOpt.bIgnoreImage;
// m_jsonCamera.value("devices").toObject().value(pOpt->uniqueName)
return true;
}
bool CGlobalCamera::SaveCameraOption(const TP_CAMERA_OPTION& camOpt)
{
QJsonObject jsonDevices = m_jsonCamera.value("devices").toObject();
if (jsonDevices.isEmpty())
{
return false;
}
//TODO:... here
QJsonObject jsonCam = jsonDevices.value(camOpt.uniqueName).toObject();
if (jsonCam.isEmpty())
{
return false;
}
jsonCam.insert("folder", camOpt.folder);
jsonDevices.insert(camOpt.uniqueName, jsonCam);
m_jsonCamera.insert("devices", jsonDevices);
return true;
}
void CGlobalCamera::readConfig()
{
int nError;
//read config from ".json" file
QString szFileName(m_pGlobalData->tgdMainPath);
szFileName.append(m_pGlobalData->tgdFolderNames[TP_FOLDER_NAME_CONFIG]).append(cs_szCfgName).append(TP_STR::cszJsonSuffix);
// szFileName.append(TP_STR::cszCfgFolder)
QMutexLocker locker(&m_mtxCam);
QJsonObject objJson = m_jsonCamera = QZkJsonParser::ReadJsonObject(szFileName, &nError);
tpDebugOut("camera.json paths: %s", szFileName.toLocal8Bit().data());
tpDebugOut("read camera.json result: %d", nError);
if (objJson.isEmpty())
{
tpDebugOut("fail to read camera.json");
return;
}
QJsonObject objTmp = objJson["pool"].toObject();
m_optPool.triggerMode = (emTpDeviceTriggerMode)objTmp.value("triggermode").toInt(0);
m_optPool.triggerDirection = (emTpTriggerDirection)objTmp.value("triggerdirection").toInt(0);
m_optPool.frameRate = objTmp.value("framerate").toInt(0);
m_optPool.fixedFrames = objTmp.value("fixedframes").toInt(0);
//
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())
{
QJsonObject objDevices = value.toObject();
for (QJsonObject::Iterator it = objDevices.begin(); it != objDevices.end(); ++it)
{
tpDebugOut("Camera key:%s", it.key().toLocal8Bit().data());
if (!it.value().isObject() ||
m_cameraesOption.contains(it.key()))
{
continue;
}
QJsonObject objCam = it.value().toObject();
TP_CAMERA_OPTION* pCamOpt = new TP_CAMERA_OPTION;
if (NULL == pCamOpt)
{
continue;
}
//inner
pCamOpt->bIgnoreImage = false;
pCamOpt->pSerials = &m_serialsList;
//
pCamOpt->uniqueName = it.key();
pCamOpt->id = objCam.value("id").toInt(0);
pCamOpt->deviceType = objCam.value("type").toInt(0);
pCamOpt->showName = objCam.value("showname").toString("");
pCamOpt->width = objCam.value("width").toInt(0);
pCamOpt->height = objCam.value("height").toInt(0);
QJsonValue tempV = objCam.value("format");
if (tempV.isString())
{
pCamOpt->format = CZkCameraImage::FromString(tempV.toString());
}
else
{
pCamOpt->format = TP_COLOR_NONE;
}
pCamOpt->zoom = objCam.value("zoom").toInt(0);
pCamOpt->folder = objCam.value("folder").toString(".\\");
////check if folder valid
//QDir camDir(pCamOpt->folder);
//if (!camDir.exists())
//{
// // maybe a relative path, try add app path
// QString strCamFolder = QString(m_pGlobalData->tgdMainPath) + "/" + pCamOpt->folder;
// camDir.setPath(strCamFolder);
// if (camDir.exists())
// {
// pCamOpt->folder = camDir.absolutePath() + "/";
// }
//}
pCamOpt->save = objCam.value("save").toInt(0);
pCamOpt->saveImgSuffix = objCam.value("save_img_suffix").toString(".BMP");
if (!TP_FUNCS::isValidImgSuffix(pCamOpt->saveImgSuffix))
{
pCamOpt->saveImgSuffix = ".BMP";
}
pCamOpt->algorithm = objCam.value("algorithm").toInt(pCamOpt->id);
pCamOpt->relyOnCamera = objCam.value("rely_on_camera").toString();
pCamOpt->exposure = objCam.value("exposure").toInt(0);
pCamOpt->boardType = objCam.value("board_type").toInt(64);
pCamOpt->boardNum = objCam.value("board_num").toInt(0);
pCamOpt->sBoardName = objCam.value("board_name").toString();
pCamOpt->sBoardConfigFile = objCam.value("board_config_file").toString();
pCamOpt->gain = objCam.value("gain").toInt(0);
pCamOpt->loop = objCam.value("loop").toInt(0);
pCamOpt->bNeedRgbSwapped = objCam.value("savefile_rgb_swapped").toInt(0);
pCamOpt->macAddress = objCam.value("mac_address").toString();
pCamOpt->bAutoPush = objCam.value("auto_push").toInt(1);
pCamOpt->bAutoOpen = objCam.value("auto_open").toBool(true);
if (!enableCamList.contains(it.key())){
pCamOpt->bAutoOpen = false;
}
pCamOpt->cameraFilePath = objCam.value("camera_file").toString();
if (objCam.value("algorithm_dll").toDouble())
{
pCamOpt->dllsuffix = QString::number(objCam.value("algorithm_dll").toInt(pCamOpt->algorithm));
}
else
{
pCamOpt->dllsuffix = objCam.value("algorithm_dll").toString(QString::number(pCamOpt->algorithm));
}
//m_cfgCameraes[pCamOpt->uniqueName] = pCamOpt;
checkFolder(pCamOpt->folder);
pCamOpt->status = TP_CAMERA_STATUS_UNINIT;
m_cameraesOption.insert(pCamOpt->uniqueName, pCamOpt);
}
}
objTmp = objJson["windows"].toObject();
if (!objTmp.isEmpty())
{
for (QJsonObject::Iterator it = objTmp.begin(); it != objTmp.end(); ++it)
{
QJsonObject objWin = it.value().toObject();
if (objWin.isEmpty())
{
continue;
}
TP_CAMERA_WIN* pWin = new TP_CAMERA_WIN;
if (NULL == pWin)
{
continue;
}
pWin->key = it.key();
pWin->device = objWin.value("device").toString();
pWin->images = objWin.value("images").toInt(1);
pWin->buffers = objWin.value("buffers").toInt(2);
pWin->bitsPerPixel = objWin.value("bitsperpixel").toInt(32);
pWin->index = objWin.value("index").toInt(0);
pWin->bufferW = objWin.value("buffer_w").toInt(0);
pWin->bufferH = objWin.value("buffer_h").toInt(0);
pWin->mirror = objWin.value("mirror").toInt(0);
pWin->bCacheOriginImage = objWin.value("cache_origin").toBool();
pWin->bNeedRgbSwapped = objWin.value("rgb_swapped").toBool();
m_cameraWins.append(pWin);
}
}
}
void CGlobalCamera::checkFolder(QString& sFolder)
{
if (sFolder.startsWith(".\\"))
{
sFolder.replace(".\\", m_pGlobalData->tgdMainPath);
}
if (!sFolder.endsWith('\\'))
{
sFolder.append('\\');
}
}
void CGlobalCamera::releaseConfig(const QString& key /* = NULL */)
{
m_cameraesOption.clear(releaseCameraOption);
m_cameraWins.clear(releaseCameraWin, NULL);
}
void CGlobalCamera::releaseCameraOption(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData)
{
delete pCamOpt;
}
void CGlobalCamera::releaseCameraWin(tagTP_CAMERA_WIN*& pWin, void* pData)
{
delete pWin;
}
QList<QString> CGlobalCamera::CameraKeysOrderByIds()
{
QList<TP_CAMERA_OPTION*> options = m_cameraesOption.values();
qSort(options.begin(), options.end(), optionCompare);
QList<QString> strList;
for (QList<TP_CAMERA_OPTION*>::Iterator it = options.begin(); it != options.end(); ++it)
{
strList.append((*it)->uniqueName);
}
return strList;
}
bool CGlobalCamera::optionCompare(TP_CAMERA_OPTION* op1, TP_CAMERA_OPTION* op2)
{
return (op1->id < op2->id);
}
QMap<QString, QString> CGlobalCamera::GetCamShowNames()
{
QMap<QString, QString> knMap;
for (QZkMutexMap<QString, TP_CAMERA_OPTION*>::iterator it = m_cameraesOption.begin(); it != m_cameraesOption.end(); ++it)
{
knMap.insert(it.key(), it.value()->showName);
}
//for (QZkMutexList<TP_CAMERA_WIN*>::Iterator it = m_cameraWins.begin(); it != m_cameraWins.end(); ++it)
//{
// if (0 == (*it)->index && m_cameraesOption.contains((*it)->device))
// {
// knMap.insert((*it)->device, (*it)->key);
// }
//}
return knMap;
}
void CGlobalCamera::readSerials()
{
#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);
if (pcamOpt){
m_cameraesOption.remove(serials);
delete pcamOpt;
pcamOpt = NULL;
}
}
void CGlobalCamera::updateCameraOption(const QString& serials, const TP_CAMERA_OPTION& camOpt)
{
QMutexLocker locker(&m_mtxCam);
// update if exist, otherwise new one.
if (m_cameraesOption.contains(serials))
{
TP_CAMERA_OPTION* pCamOpt = m_cameraesOption.value(serials);
emTpCameraStatus oldStatus = pCamOpt->status;
*pCamOpt = camOpt;
pCamOpt->status = oldStatus;
pCamOpt->pSerials = &m_serialsList;
return;
}
TP_CAMERA_OPTION* pCamOpt = new TP_CAMERA_OPTION;
if (NULL == pCamOpt) return;
*pCamOpt = camOpt;
pCamOpt->pSerials = &m_serialsList;
m_cameraesOption.insert(pCamOpt->uniqueName, pCamOpt);
}
QList<QString> CGlobalCamera::camWinKeys()
{
QMutexLocker locker(&m_mtxCam);
QList<QString> ret;
QZkMutexList<TP_CAMERA_WIN*>::const_iterator it = m_cameraWins.constBegin();
for (; it != m_cameraWins.constEnd(); ++it)
{
ret.append((*it)->key);
}
return ret;
}
bool CGlobalCamera::camWinByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt)
{
QMutexLocker locker(&m_mtxCam);
QZkMutexList<TP_CAMERA_WIN*>::const_iterator it = m_cameraWins.constBegin();
for (; it != m_cameraWins.constEnd(); ++it)
{
TP_CAMERA_WIN* pOpt = *it;
if (pOpt->key.compare(strKey, Qt::CaseInsensitive) == 0){
camwinOpt = *pOpt;
return true;
}
}
return false;
}
bool CGlobalCamera::addCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew)
{
QMutexLocker locker(&m_mtxCam);
// update if exist, otherwise new one.
QZkMutexList<TP_CAMERA_WIN*>::iterator it = m_cameraWins.begin();
for (; it != m_cameraWins.end(); ++it)
{
TP_CAMERA_WIN* pOpt = *it;
if (pOpt->key.compare(strKey, Qt::CaseInsensitive) == 0){
*pOpt = camwinOpt;
return true;
}
}
TP_CAMERA_WIN* pOpt = new TP_CAMERA_WIN;
if (NULL == pOpt) return false;
*pOpt = camwinOpt;
m_cameraWins.append(pOpt);
return true;
}
bool CGlobalCamera::delCamWin(const QString& strKey)
{
QMutexLocker locker(&m_mtxCam);
QZkMutexList<TP_CAMERA_WIN*>::iterator it = m_cameraWins.begin();
for (; it != m_cameraWins.end(); ++it)
{
TP_CAMERA_WIN* pOpt = *it;
if (pOpt->key.compare(strKey, Qt::CaseInsensitive) == 0){
m_cameraWins.removeOne(pOpt);
delete pOpt;
pOpt = NULL;
return true;
}
}
return true;
}
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;
}

@ -0,0 +1,97 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:globalCamera.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/07
History:7:4:2015 8:53
*******************************************************************************/
#ifndef __GLOBAL_CAMERA_H_20150407
#define __GLOBAL_CAMERA_H_20150407
#include "icamera.h"
#include "iCameraObject.h"
#include "QZkJsonParser.h"
#include <QtCore/QHash>
#include <QtCore/QJsonArray>
#include <QtCore/QMutexLocker>
#include "QZkMutexMap.h"
#include "QZkMutexList.h"
class CGlobalCamera
{
public:
CGlobalCamera(const CAMERA_IN_PARAM* pInParam);
~CGlobalCamera();
bool CameraOption(const QString& serials, TP_CAMERA_OPTION& camOpt);
bool CameraOptionByKey(const QString& sKey, TP_CAMERA_OPTION& camOpt);
bool SetCameraOption(const QString& sKey, const TP_CAMERA_OPTION& camOpt);
TP_CAMERA_OPTION* CameraOption(const QString& serials) {
return m_cameraesOption.value(serials, NULL);
}
QList<QString> CameraKeys() {
return m_cameraesOption.keys();
}
QList<QString> CameraKeysOrderByIds();
QList<TP_CAMERA_WIN*> CameraWins() {
return m_cameraWins;
}
QMap<QString, QString> GetCamShowNames();
bool SaveCameraOption(const TP_CAMERA_OPTION& camOpt);
void delCameraOption(const QString& serials);
void updateCameraOption(const QString& serials, const TP_CAMERA_OPTION& camOpt);
QList<QString> camWinKeys();
bool camWinByKey(const QString& strKey, TP_CAMERA_WIN& camwinOpt);
bool addCamWin(const QString& strKey, const TP_CAMERA_WIN& camwinOpt, bool bNew);
bool delCamWin(const QString& strKey);
public:
TP_GLOBAL_DATA* m_pGlobalData;
ICameraCallback* m_pCallback;
// QHash<QString, TP_CAMERA_OPTION*> m_cfgCameraes;
TP_CAMERAPOOL_OPTION m_optPool;
private:
void readConfig();
void releaseConfig(const QString& key = NULL);
void checkFolder(QString& sFolder);
void readSerials();
QJsonObject getAppJsonUser();
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 void copyCameraOptionByKey(const QString& key, TP_CAMERA_OPTION*& pCamOpt, void* pData);
static bool optionCompare(TP_CAMERA_OPTION* op1, TP_CAMERA_OPTION* op2);
static void releaseCameraWin(tagTP_CAMERA_WIN*& pWin, void* pData);
private:
QMutex m_mtxCam;
const static char cs_szCfgName[];
QZkMutexMap<QString, TP_CAMERA_OPTION*> m_cameraesOption;
QZkMutexList<TP_CAMERA_WIN*> m_cameraWins;
QJsonObject m_jsonCamera;
QStringList m_serialsList;
};
//const char CGlobalCamera::m_szCfgFile[] = "camera";
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//***inline functions***
extern class CGlobalCamera* gpGlobalCameraZZZ;
#define gpGlobalCamera gpGlobalCameraZZZ
//#define gpMainPath gpGlobalCamera->m_pszMainPath
#define gpGlobalData gpGlobalCamera->m_pGlobalData
#define gpGlobalCamCallback gpGlobalCamera->m_pCallback
#define callCamCallback(fc, defaultReturn, ...) (NULL != gpGlobalCamCallback) ? gpGlobalCamCallback->##fc##(__VA_ARGS__) : defaultReturn
// #define callGlobalCamera(fc, dValue, ...) (NULL != gpGlobalCamera ) ? gpGlobalCamera->##fc##(__VA_ARGS__) : dValue
// #define callGlobalCameraNoP(fc, dValue) (NULL != gpGlobalCamera ) ? gpGlobalCamera->##fc##() : dValue
//#define gpCameraesHash() (NULL != gpGlobalCamera) ? gpGlobalCamera->m_cfgCameraes : QHash<QString, TP_CAMERA_OPTION*>()
#define gGlobalPoolOption gpGlobalCamera->m_optPool
#endif

@ -0,0 +1,60 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:tpCamera.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/23
History:23:3:2015 16:31
*******************************************************************************/
#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;
}
}

@ -0,0 +1,61 @@
#include "triggerthread.h"
#include "CameraPool.h"
#include "globalCamera.h"
CTriggerThread::CTriggerThread(class CCameraPool* pPool, QObject *parent /* = NULL */)
: QTpThreadBase(parent)
, m_pPool(pPool)
{
m_msecOfInterval = 0;
m_nTriggerCount = 0;
m_bAutoTrigger = false;
}
CTriggerThread::~CTriggerThread()
{
EndTrigger();
}
void CTriggerThread::SetFrame(long nFrameRate)
{
if( nFrameRate <= 0 )
{
m_msecOfInterval = 0;
}
else
{
m_msecOfInterval = 1000 / nFrameRate;
}
}
void CTriggerThread::StartTrigger()
{
EndThread();
m_LastTriggerTime = QTime::currentTime();
StartThread();
}
void CTriggerThread::EndTrigger()
{
EndThread();
}
bool CTriggerThread::loop()
{
if( m_bAutoTrigger && m_pPool->ImagesSize() < 32)
{
QMutexLocker locker(&m_mutexWorked);
QTime nowTime = QTime::currentTime();
int nIntervals = m_LastTriggerTime.msecsTo(nowTime);
if (nIntervals >= m_msecOfInterval)
{
CCameraPool::tagCOMMIT_TRIGGER_PARAM prm;
prm.direct = gGlobalPoolOption.triggerDirection;
prm.count = ++m_nTriggerCount;
prm.bFromMenual = false;
m_pPool->IntervalCaptureImages(prm);
m_LastTriggerTime = nowTime;
}
}
msleep(5);
return true;
}

@ -0,0 +1,37 @@
#ifndef TRIGGERTHREAD_H
#define TRIGGERTHREAD_H
#include "qtpthreadbase.h"
#include <Qtcore\QTime>
#include <QtCore\QMutex>
#include "globalCamera.h"
class CTriggerThread : public QTpThreadBase
{
public:
CTriggerThread(class CCameraPool* pPool, QObject *parent = NULL);
~CTriggerThread();
void SetFrame(long nFrameRate);
void StartTrigger();
void EndTrigger();
void LockWorked() {
m_mutexWorked.lock();
}
void UnlockWorked() {
m_mutexWorked.unlock();
}
void SetAutoTrigger(bool bAuto) {
m_bAutoTrigger = bAuto;
}
private:
virtual bool loop();
private:
class CCameraPool* m_pPool;
DWORD m_msecOfInterval;
QTime m_LastTriggerTime;
DWORD m_nTriggerCount;
QMutex m_mutexWorked;
bool m_bAutoTrigger;
};
#endif // TRIGGERTHREAD_H

@ -0,0 +1,75 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:tpCoreCtrl.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/24
History:24:3:2015 12:46
*******************************************************************************/
#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_LOG("Lib_CoreCtrl_Init start!");
//create and initialize the global data(class CGlobalCoreCtrl's object)
CORE_CTRL_IN_PARAM* pCciParam = (CORE_CTRL_IN_PARAM*)inParam;
gpData = new CGlobalCoreCtrl(pCciParam);
if( NULL == gpData )
{
return NULL;
}
//
CORE_CTRL_INIT(gpGlobalData->tgdMainPath, gpGlobalData->tgdMainPath);
//
if( gMdlesMgr.LoadModules() <= 0 )
{
return NULL;
}
//////////////////////////////////////////////////////////////////
if( NULL == gpCoreCtrl )
{
gpCoreCtrl = new CCoreCtrl();
}
/*
if( NULL != gpCoreCtrl )
{
gpCoreCtrl->IInitCore();
}
*/
CORE_CTRL_LOG("Lib_CoreCtrl_Init finished!");
return gpCoreCtrl;
}
TPCORECTRL_API void Lib_CoreCtrl_Free()
{
if( NULL != gpCoreCtrl )
{
gpCoreCtrl->IFreeCore();
delete gpCoreCtrl;
gpCoreCtrl = NULL;
}
/////////////////////////////////////////////////
gMdlesMgr.FreeModules();
CORE_CTRL_FREE();
if( NULL != gpData )
{
delete gpData;
gpData = NULL;
}
}

@ -0,0 +1,178 @@
#include "AlgorithmOption.h"
#include "baseConstant.h"
const char CAlgorithmOption::cs_szSuffix[] = ".dat";
CAlgorithmOption::CAlgorithmOption(const QString& strFile, int nAlgorithm, QSqliteAlgorithm* pDbAlg)
: m_pDbAlg(pDbAlg)
{
m_fileName = strFile;
m_nAlgorithm = nAlgorithm;
QString szFileName = strFile + "_" + QString::number(nAlgorithm);
szFileName.append(TP_STR::cszJsonSuffix).append(cs_szSuffix);
int error = -1;
m_objJson = QZkJsonParser::ReadJsonObject(szFileName, &error);
if (0 != error)
{
szFileName = strFile + "_" + QString::number(nAlgorithm);
szFileName.append(TP_STR::cszJsonSuffix);
m_objJson = QZkJsonParser::ReadJsonObject(szFileName, &error);
}
m_bNeedSave = false;
m_nAlgorithmsUsings = 0;
m_pDbAlg->CreateTable(nAlgorithm);
}
CAlgorithmOption::~CAlgorithmOption()
{
}
int CAlgorithmOption::GetIntValue(const QString& skey, int nDefault)
{
QJsonValue v = m_objJson.value(skey);
if (v.isUndefined() || !v.isDouble())
{
Insert(skey, QJsonValue(nDefault));
return nDefault;
}
else
{
return v.toInt(nDefault);
}
}
void CAlgorithmOption::SetIntValue(const QString& skey, int value)
{
Insert(skey, QJsonValue(value));
}
QString CAlgorithmOption::GetStringValue(const QString& skey, const QString& default/* = ""*/)
{
QJsonValue v = m_objJson.value(skey);
if (v.isUndefined() || !v.isString())
{
Insert(skey, QJsonValue(default));
return default;
}
else
{
return v.toString();
}
}
void CAlgorithmOption::SetStringValue(const QString& skey, const QString& value)
{
Insert(skey, QJsonValue(value));
}
QJsonObject CAlgorithmOption::GetObjectValue(const QString& skey)
{
QJsonValue v = m_objJson.value(skey);
if (v.isUndefined() || !v.isString())
{
return QJsonObject();
}
else
{
return v.toObject();
}
}
bool CAlgorithmOption::Save(bool bWait/* = true*/)
{
if (!m_bNeedSave)
{
return true;
}
if (!bWait)
{
if (!m_wLock.tryLockForWrite())
{
return false;
}
}
else
{
m_wLock.lockForWrite();
}
//if (!m_bNeedSave || !m_wLock.tryLockForWrite())
//{
// return;
//}
QString szFileName = m_fileName + "_" + QString::number(m_nAlgorithm);
szFileName.append(TP_STR::cszJsonSuffix).append(cs_szSuffix);
bool b = QZkJsonParser::WriteJsonObject(szFileName, m_objJson);
m_bNeedSave = !b;
m_wLock.unlock();
return b;
}
QVariantMap CAlgorithmOption::VariantMap()
{
return m_objJson.toVariantMap();
}
bool CAlgorithmOption::DbSetValue(const QString& key, int type, const QBuffer& data)
{
if (NULL == m_pDbAlg)
{
return false;
}
return m_pDbAlg->ReplaceRecord(m_nAlgorithm, key, type, data.buffer());
}
bool CAlgorithmOption::DbSetValue(const QString& key, int type, const QByteArray& data)
{
if (NULL == m_pDbAlg)
{
return false;
}
return m_pDbAlg->ReplaceRecord(m_nAlgorithm, key, type, data);
}
bool CAlgorithmOption::DbDelValue(const QString& key)
{
if (NULL == m_pDbAlg)
{
return false;
}
return m_pDbAlg->DeleteRecord(m_nAlgorithm, key);
}
bool CAlgorithmOption::DbGetValue(const QString& key, int type, QByteArray& data)
{
if (NULL == m_pDbAlg)
{
return false;
}
return m_pDbAlg->ReadRecord(m_nAlgorithm, key, type, data);
//m_pDbAlg->ReplaceRecord(m_nAlgorithm, key, type, data);
}
QStringList CAlgorithmOption::DbGetKeysByType(int type)
{
if (NULL == m_pDbAlg)
{
return QStringList();
}
return m_pDbAlg->KeysByType(m_nAlgorithm, type);
}
QVariant CAlgorithmOption::GetValue(const QString& skey, const QVariant& def)
{
QJsonValue v = m_objJson.value(skey);
if (v.isUndefined())
{
Insert(skey, QJsonValue::fromVariant(def));
return def;
}
else
{
return v.toVariant();
}
}
void CAlgorithmOption::SetValue(const QString& skey, const QVariant& value)
{
Insert(skey, QJsonValue::fromVariant(value));
}

@ -0,0 +1,47 @@
#ifndef CALGORITHMOPTION_H
#define CALGORITHMOPTION_H
#include "iAlgorithm.h"
#include <QtCore\qjsonobject.h>
#include "QZkJsonParser.h"
#include <QtCore\qreadwritelock.h>
#include "QSqliteAlgorithm.h"
class CAlgorithmOption : public IAlgorithmOption
{
public:
CAlgorithmOption(const QString& strFile, int nAlgorithm, QSqliteAlgorithm* pDbAlg);
~CAlgorithmOption();
virtual int GetIntValue(const QString& skey, int nDefault);
virtual void SetIntValue(const QString& skey, int value);
virtual QString GetStringValue(const QString& skey, const QString& default = "");
virtual void SetStringValue(const QString& skey, const QString& value);
virtual QJsonObject GetObjectValue(const QString& skey);
virtual bool Save(bool bWait = true);
virtual QVariantMap VariantMap();
virtual bool DbSetValue(const QString& key, int type, const QBuffer& data);
virtual bool DbSetValue(const QString& key, int type, const QByteArray& data);
virtual bool DbDelValue(const QString& key);
virtual bool DbGetValue(const QString& key, int type, QByteArray& data);
virtual QStringList DbGetKeysByType(int type);
virtual QVariant GetValue(const QString& skey, const QVariant& def);
virtual void SetValue(const QString& skey, const QVariant& value);
private:
void Insert(const QString& skey, const QJsonValue& v) {
QWriteLocker locker(&m_wLock);
m_objJson.insert(skey, v);
m_bNeedSave = true;
tpDebugOut("Insert value in algorithm_%d.json;key=%s, value=%s", m_nAlgorithm, skey.toLocal8Bit().data(), v.toString("NULL").toLocal8Bit().data());
}
private:
QJsonObject m_objJson;
int m_nAlgorithm;
QString m_fileName;
int m_nAlgorithmsUsings;
bool m_bNeedSave;
QReadWriteLock m_wLock;
const static char cs_szSuffix[];
QSqliteAlgorithm* m_pDbAlg;
};
#endif // CALGORITHMOPTION_H

@ -0,0 +1,28 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:IImageAlgorithm.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/22
History:22:4:2015 13:34
*******************************************************************************/
#include "IImageAlgorithm.h"
#include "ImgProc.h"
IImageAlgorithm::IImageAlgorithm(class CImgProc* pImgProc)
: m_pImgProc(pImgProc)
{
}
IImageAlgorithm::~IImageAlgorithm()
{
}
int IImageAlgorithm::ImageAnalysis(class IImageObject* pImgObj, TP_ALGORITHM_OPTION* pOpt)
{
int nRet = IaImageAnalysis(pImgObj, pOpt);
return nRet;
}

@ -0,0 +1,30 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:IImageAlgorithm.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/22
History:22:4:2015 13:34
*******************************************************************************/
#ifndef IIMAGEALGORITHM_H
#define IIMAGEALGORITHM_H
#include "iImgProc.h"
class IImageAlgorithm
{
public:
IImageAlgorithm(class CImgProc* pImgProc);
virtual ~IImageAlgorithm();
virtual int ImageAnalysis(class IImageObject* pImgObj, TP_ALGORITHM_OPTION* pOpt);
protected:
private:
virtual int IaImageAnalysis(class IImageObject* pImgObj, const TP_ALGORITHM_OPTION* pAlgOpt) = 0;
private:
class CImgProc* m_pImgProc;
};
#endif // IIMAGEALGORITHM_H

@ -0,0 +1,23 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ImageAlgorithm.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/21
History:21:4:2015 9:58
*******************************************************************************/
#include "ImageAlgorithm.h"
// CImageAlgorithm::CImageAlgorithm(class CImgProc* pImgProc)
// : IImageAlgorithm(pImgProc)
// , m_pThis(this)
// {
// m_pSelfData = new tagIMAGE_DATA;//NULL;
// std::memset(m_pSelfData, 0, sizeof(tagIMAGE_DATA));
// }
//
// CImageAlgorithm::~CImageAlgorithm()
// {
// delete m_pSelfData;
// }

@ -0,0 +1,34 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ImageAlgorithm.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/04/21
History:21:4:2015 9:58
*******************************************************************************/
#ifndef IMAGEALGORITHM_H
#define IMAGEALGORITHM_H
#include "baseDefine.h"
#include "baseStruct.h"
#include "iImgProc.h"
#include "IImageAlgorithm.h"
#define THIS (class IImageAlgorithm*)
class CImageAlgorithm : public IImageAlgorithm
{
public:
CImageAlgorithm(class CImgProc* pImgProc);
virtual ~CImageAlgorithm();
private:
virtual int IaImageAnalysis(class IImageObject* pImgObj, const TP_ALGORITHM_OPTION* pAlgOpt);
void* m_pSelfData;
class IImageAlgorithm* m_pThis;
};
#endif // IMAGEALGORITHM_H

@ -0,0 +1,217 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ImgProc.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 18:03
*******************************************************************************/
#include "ImgProc.h"
#include "baseConstant.h"
#include <QtCore/QThread>
#include <QDebug>
#include "QZkJsonParser.h"
#include "zfunctions.h"
///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
const char CImgProc::cs_strCfgName[] = "algorithm";
TP_GLOBAL_DATA* CImgProc::s_pGlobalData = NULL;
CImgProc::CImgProc(IMGPROC_IN_PARAM* pParam)
: m_dbAlg(pParam->pGlobalData->tgdUserPath)
{
s_pGlobalData = pParam->pGlobalData;
m_bIsInited = false;
m_nAlgorithmsUsings = 0;
m_pDefAlgorithmDll = NULL;
}
CImgProc::~CImgProc(void)
{
FreeProc();
}
int CImgProc::InitProc()
{
m_pDefAlgorithmDll = createAlgorithmDll("0", NULL);
//if (NULL == m_pDefAlgorithmDll)
//{
// return 0;
//}
m_bIsInited = true;
return 1;
}
void CImgProc::FreeProc()
{
m_bIsInited = false;
while( m_nAlgorithmsUsings > 0 )
{
QThread::msleep(25);
}
// m_algorithms.clear(releaseAlgorithm);
m_threadAlgorithms.clear(releaseAlgorithmApis);
m_algorithmOptions.clear(releaseAlgorithmOption);
m_algorithmDlls.clear(releaseAlgorithmDlls);
if (NULL != m_pDefAlgorithmDll)
{
delete m_pDefAlgorithmDll;
m_pDefAlgorithmDll = NULL;
}
}
void CImgProc::releaseAlgorithm(const Qt::HANDLE& k, IAlgorithm*& v, void* pData)
{
//Algorithm_Delete(v);
//FREE_ALGORITHM(v);
}
void CImgProc::releaseAlgorithmOption(const int& k, CAlgorithmOption*& v, void* pData)
{
delete v;
}
CAlgorithmOption* CImgProc::createAlgorithmOption(const int& k, void* pData)
{
CImgProc* pThis = (CImgProc*)pData;
QString szFileName(s_pGlobalData->tgdMainPath);
szFileName.append(s_pGlobalData->tgdFolderNames[TP_FOLDER_NAME_CONFIG]).append(cs_strCfgName);
CAlgorithmOption* pv = new CAlgorithmOption(szFileName, k, &pThis->m_dbAlg);
return pv;
}
int CImgProc::IImageProcess(class IImageObject* pImgObj, class IDetectorEngine* pDE /*= NULL*/)
{
if (NULL == pImgObj || !m_bIsInited)
{
return 0;
}
QZK::QAtomicIntAdder adder(m_nAlgorithmsUsings);//Img退出删除AlgorithmOption有用需要等所有的算法都用完了才可以删除
//获取算法相关的参数
TP_ALGORITHM_OPTION algOption;
algOption.algorithm = pImgObj->IGetAlgorithm();//获取算法数值camera.json中的设置
CAlgorithmOption* pAlgOpt = m_algorithmOptions.value2(algOption.algorithm, createAlgorithmOption, this);//列表中不包含相关参数就创建一个参数相关的Option对象
algOption.pImagProcCb = pAlgOpt;
/////////////////////////////////////////////////////////////////////////
Qt::HANDLE h = QThread::currentThreadId();//或取当前线程的ID
QString dllSuffix = QString::fromUtf8(pImgObj->IDllSuffix());
//
tagALGORITHM_API* pApiNode = m_threadAlgorithms[h].value(dllSuffix);//获取当前线程的算法对象,
if (NULL == pApiNode)//若获取算法对象不成功,则需要创建一个
{
CLoadAlgorithm* pDll = NULL;
if (0 == algOption.algorithm || (pDll = m_algorithmDlls.value2(dllSuffix, createAlgorithmDll, NULL)) == NULL)//根据算法库的后缀加载相应的tpAlgorithm_*.dll
{
pDll = m_pDefAlgorithmDll;//如果带后缀的算法库加载失败则用默认的tpAlgorithm.dll算法库
}
if (NULL == pDll)
{
//qWarning() << "Failed to "
return 0;
}
pApiNode = new tagALGORITHM_API;
if (NULL == pApiNode)
{
return 0;
}
pApiNode->pApi = pDll->m_fAlgCreata(pDE);//获取算法库中的类对象
if (NULL == pApiNode->pApi)
{
delete pApiNode;
return 0;
}
pApiNode->pDll = pDll;
m_threadAlgorithms[h].insert(dllSuffix, pApiNode);//存储当前线程用到的类对象
}
//qWarning() << "ImageAnalysis Start: " << QDateTime::currentMSecsSinceEpoch()
// << " Image ID : " << pImgObj->IGetFrameNum()
// << " Thread ID : " << QThread::currentThreadId()
// << endl;
int nRet = pApiNode->pApi->IImageAnalysis(pImgObj, &algOption, pDE);
try
{
// nRet = pApiNode->pApi->IImageAnalysis(pImgObj, &algOption, pDE);
}
catch (...)
{
qWarning() << "ERROR: Algorithm Crash!!! "
<< "Image URL:"
<< QString(pImgObj->IGetImageUtf8String())
<< endl;
QVariantMap vMap;
vMap.insert("ui_error", "ERROR: Algorithm Crash!!! Image URL:" + QString(pImgObj->IGetImageUtf8String()));
pImgObj->IVariantMapToUI(vMap);
}
//qWarning() << "ImageAnalysis Over: " << QDateTime::currentMSecsSinceEpoch()
// << " Image ID : " << pImgObj->IGetFrameNum()
// << " Thread ID : " << QThread::currentThreadId()
// << endl;
pAlgOpt->Save();
return nRet;
}
class IAlgorithmOption* CImgProc::IGetAlgorithmOption(int nAlgorithm)
{
return m_algorithmOptions.value2(nAlgorithm, createAlgorithmOption, this);
}
CLoadAlgorithm* CImgProc::createAlgorithmDll(const QString& k, void* pData)
{
CLoadAlgorithm *pAlgDll = new CLoadAlgorithm();
if (NULL == pAlgDll)
{
return NULL;
}
//TP_ALGORITHM_OPTION* pAlgOpt = (TP_ALGORITHM_OPTION*)pData;
QString dllFileName;
#ifdef _DEBUG
dllFileName.append("tpAlgorithmd");
#else
dllFileName.append("tpAlgorithm");
#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))
{
delete pAlgDll;
return NULL;
}
return pAlgDll;
}
void CImgProc::releaseAlgorithmApis(QMap<QString, tagALGORITHM_API*>& v, void* pData)
{
for (QMap<QString, tagALGORITHM_API*>::Iterator it = v.begin(); it != v.end(); ++it)
{
tagALGORITHM_API* pNode = it.value();
if (NULL != pNode)
{
if (NULL != pNode->pApi && NULL != pNode->pDll)
{
pNode->pDll->m_fAlgDelete(pNode->pApi);
}
delete pNode;
}
}
v.clear();
}
void CImgProc::releaseAlgorithmDlls(CLoadAlgorithm*& v, void* pData)
{
delete v;
}

@ -0,0 +1,56 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:ImgProc.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 18:03
*******************************************************************************/
#include "iImgProc.h"
/*#include "ImageAlgorithm.h"*/
#include "QZkMutexMap.h"
#include "baseClass.h"
#include <QtCore/QAtomicInt>
#include <QtCore/QReadWriteLock>
#include "LoadAlgorithm.h"
#include "AlgorithmOption.h"
#include "LoadAlgorithm.h"
class CImgProc : public IImgProc
{
public:
CImgProc(IMGPROC_IN_PARAM* pParam);
virtual ~CImgProc(void);
int InitProc();
void FreeProc();
private:
virtual int IImageProcess(class IImageObject* pImgObj, class IDetectorEngine* pDE = NULL);
virtual class IAlgorithmOption* IGetAlgorithmOption(int nAlgorithm);
private:
static CAlgorithmOption* createAlgorithmOption(const int& k, 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:
static TP_GLOBAL_DATA* s_pGlobalData;
const static char cs_strCfgName[];
private:
bool m_bIsInited;
QSqliteAlgorithm m_dbAlg;
//QZkMutexMap<Qt::HANDLE, class IAlgorithm*> m_algorithms;
QAtomicInt m_nAlgorithmsUsings;
QZkMutexMap<int, CAlgorithmOption*> m_algorithmOptions;
//class CLoadAlgorithm* m_pLibAlgorithm;
QZkMutexMap<QString, CLoadAlgorithm*> m_algorithmDlls;
CLoadAlgorithm* m_pDefAlgorithmDll;//nAlgorithm = 0; tpAlgorithm.dll
struct tagALGORITHM_API{
class IAlgorithm* pApi;
class CLoadAlgorithm* pDll;
};
QZkMutexMap<Qt::HANDLE, QMap<QString, tagALGORITHM_API*>> m_threadAlgorithms;
static CLoadAlgorithm* createAlgorithmDll(const QString& k, void* pData);
static void releaseAlgorithmApis(QMap<QString, tagALGORITHM_API*>& v, void* pData);
static void releaseAlgorithmDlls(CLoadAlgorithm*& v, void* pData);
};

@ -0,0 +1,72 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:LoadAlgorithm.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/21
History:21:5:2015 14:33
*******************************************************************************/
#include "LoadAlgorithm.h"
#include <QtCore/QLibrary>
//CLoadAlgorithm::Func_Alg_Create CLoadAlgorithm::sf_AlgCreata = NULL;
//CLoadAlgorithm::Func_Alg_Delete CLoadAlgorithm::sf_AlgDelete = NULL;
//class QLibrary* CLoadAlgorithm::s_pLib = NULL;
CLoadAlgorithm::CLoadAlgorithm()
{
m_pLib = NULL;
m_fAlgCreata = NULL;
m_fAlgDelete = NULL;
}
CLoadAlgorithm::~CLoadAlgorithm()
{
FreeAlg();
}
bool CLoadAlgorithm::LoadAlg(const QString &szDllName)
{
#ifdef _USE_ALGORITHM_STATIC
m_fAlgCreata = Algorithm_Create;
m_fAlgDelete = Algorithm_Delete;
#else
if (NULL == m_pLib)
{
m_pLib = new QLibrary(szDllName);
if (NULL == m_pLib)
{
return false;
}
}
if (!m_pLib->load())
{
tpDebugOut("Failed to Load dll: %s", szDllName.toLocal8Bit().data());
return false;
}
m_fAlgCreata = (Func_Alg_Create)m_pLib->resolve("Algorithm_Create");
m_fAlgDelete = (Func_Alg_Delete)m_pLib->resolve("Algorithm_Delete");
#endif
if (NULL == m_fAlgCreata || NULL == m_fAlgDelete)
{
tpDebugOut("Failed to get functions from %s", szDllName.toLocal8Bit().data());
return false;
}
return true;
}
void CLoadAlgorithm::FreeAlg()
{
m_fAlgCreata = NULL;
m_fAlgDelete = NULL;
#ifdef _USE_ALGORITHM_STATIC
#else
if (NULL != m_pLib)
{
delete m_pLib;
m_pLib = NULL;
}
#endif
}

@ -0,0 +1,35 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:LoadAlgorithm.h
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/05/21
History:21:5:2015 14:33
*******************************************************************************/
#ifndef LOADALGORITHM_H
#define LOADALGORITHM_H
#include "iAlgorithm.h"
class CLoadAlgorithm
{
public:
CLoadAlgorithm();
~CLoadAlgorithm();
public:
bool LoadAlg(const QString &szDllName);
void FreeAlg();
public:
typedef IAlgorithm* (*Func_Alg_Create)(class IDetectorEngine* pDE);
typedef void(*Func_Alg_Delete)(IAlgorithm*);
Func_Alg_Create m_fAlgCreata;
Func_Alg_Delete m_fAlgDelete;
private:
class QLibrary* m_pLib;
};
//#define ALLOC_ALGORITHM() (NULL == CLoadAlgorithm::sf_AlgCreata) ? NULL : CLoadAlgorithm::sf_AlgCreata()
//#define FREE_ALGORITHM(obj) if ( NULL != CLoadAlgorithm::sf_AlgDelete) CLoadAlgorithm::sf_AlgDelete(obj)
#endif // LOADALGORITHM_H

@ -0,0 +1,95 @@
#include "QSqliteAlgorithm.h"
#define _TP_SQLITE_ALGORITHM_DB "algorithm.db"
#define _TP_SQLITE_CRETAE_ALGORITHM \
"CREATE TABLE IF NOT EXISTS e_algorithm_%1(alg_key VARCHAR(255) \
, alg_type INT(32) \
, alg_data BLOB \
, alg_stamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP \
, PRIMARY KEY(alg_key, alg_type))"
#define _TP_SQLITE_REPLACE_ALGORITHM \
"REPLACE INTO e_algorithm_%1(alg_key, alg_type, alg_data) VALUES('%2', '%3', :data_buffer)"
#define _TP_SQLITE_SELECT_RECORD_DATA \
"SELECT alg_key, alg_type, alg_data FROM e_algorithm_%1 WHERE alg_key='%2' AND alg_type='%3'"
#define _TP_SQLITE_SELECT_KEYS_BY_TYPE \
"SELECT alg_key, alg_type FROM e_algorithm_%1 WHERE alg_type = '%2'"
#define _TP_SQLITE_DELETE_RECORD \
"DELETE FROM e_algorithm_%1 WHERE alg_key='%2'"
QSqliteAlgorithm::QSqliteAlgorithm(const QString& dbPath)
: QZkDbSqlite(dbPath+_TP_SQLITE_ALGORITHM_DB)
{
}
QSqliteAlgorithm::~QSqliteAlgorithm()
{
}
bool QSqliteAlgorithm::CreateTable(int nAlgorithm)
{
if (!isOpen() && !open())
{
return false;
}
QString strSql = QString(_TP_SQLITE_CRETAE_ALGORITHM).arg(QString::number(nAlgorithm));
QSqlQuery sql = exec(strSql);
if (QSqlError::NoError != lastError().type())
{
return false;
}
return true;
}
bool QSqliteAlgorithm::ReplaceRecord(int nAlgorithm, const QString& key, int type, const QByteArray& data)
{
QString strCmd(_TP_SQLITE_REPLACE_ALGORITHM);
strCmd = strCmd.arg(QString::number(nAlgorithm), key, QString::number(type));
QSqlQuery sql(*this);
sql.prepare(strCmd);
sql.bindValue(":data_buffer", data, QSql::In);
return sql.exec();
}
bool QSqliteAlgorithm::DeleteRecord(int nAlgorithm, const QString& key)
{
QString strCmd = QString(_TP_SQLITE_DELETE_RECORD).arg(QString::number(nAlgorithm), key);
QSqlQuery sql = exec(strCmd);
if (QSqlError::NoError != sql.lastError().type())
{
return false;
}
return true;
}
bool QSqliteAlgorithm::ReadRecord(int nAlgorithm, const QString& key, int type, QByteArray& data)
{
QString strCmd = QString(_TP_SQLITE_SELECT_RECORD_DATA).arg(QString::number(nAlgorithm), key, QString::number(type));
QSqlQuery sql = exec(strCmd);
if (QSqlError::NoError != lastError().type())
{
return false;
}
if (!sql.next())
{
return false;
}
QSqlRecord record = sql.record();
data = record.value("alg_data").toByteArray();
return true;
}
QStringList QSqliteAlgorithm::KeysByType(int nAlgorithm, int type)
{
QStringList strList;
QString strCmd = QString(_TP_SQLITE_SELECT_KEYS_BY_TYPE).arg(QString::number(nAlgorithm), QString::number(type));
QSqlQuery sql = exec(strCmd);
while (sql.next())
{
strList.append(sql.record().value("alg_key").toString());
}
return strList;
}

@ -0,0 +1,21 @@
#ifndef QSQLITEALGORITHM_H
#define QSQLITEALGORITHM_H
#include "QZkDbSqlite.h"
class QSqliteAlgorithm : public QZkDbSqlite
{
public:
QSqliteAlgorithm(const QString& dbPath);
~QSqliteAlgorithm();
bool CreateTable(int nAlgorithm);
bool ReplaceRecord(int nAlgorithm, const QString& key, int type, const QByteArray& data);
bool DeleteRecord(int nAlgorithm, const QString& key);
bool ReadRecord(int nAlgorithm, const QString& key, int type, QByteArray& data);
QStringList KeysByType(int nAlgorithm, int type);
private:
};
#endif // QSQLITEALGORITHM_H

@ -0,0 +1,54 @@
/******************************************************************************
Copyright(C):2015~2018 hzleaper
FileName:tpImgProc.cpp
Author:zhikun wu
Email:zk.wu@hzleaper.com
Tools:vs2010 pc on company
Created:2015/03/26
History:26:3:2015 17:56
*******************************************************************************/
#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;
/*
char szDllName[260];
strcpy(szDllName, pParam->pGlobalData->tgdDllPath);
#ifdef _DEBUG
strcat(szDllName, "tpAlgorithmd");
#else
strcat(szDllName, "tpAlgorithm");
#endif
CLoadAlgorithm::LoadAlg(szDllName);
*/
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();
}

@ -0,0 +1,29 @@
/******************************************************************************
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

@ -0,0 +1,29 @@
#include "AutoTrigger.h"
#include "qtimer.h"
AutoTrigger::AutoTrigger()
{
m_pTimer = new QTimer(this);
connect(m_pTimer, SIGNAL(timeout()), this, SIGNAL(sgTrig()));
}
AutoTrigger::~AutoTrigger()
{
stop();
delete m_pTimer;
}
bool AutoTrigger::start(int nInterval)
{
m_pTimer->stop();
m_pTimer->start(nInterval);
return true;
}
bool AutoTrigger::stop()
{
m_pTimer->stop();
return true;
}

@ -0,0 +1,21 @@
#ifndef _AUTOTRIGGER_H_
#define _AUTOTRIGGER_H_
#include <QObject>
class AutoTrigger : public QObject
{
Q_OBJECT
public:
AutoTrigger();
~AutoTrigger();
bool start(int nInterval = 1000);
bool stop();
signals :
void sgTrig();
private:
class QTimer *m_pTimer{ nullptr };
};
#endif

@ -0,0 +1,79 @@
#include "CDllCoreCtrl.h"
#define _USE_LIB_CORECTRL_DLL
#ifdef _USE_LIB_CORECTRL_DLL
#include "DllLoader.h"
#else
extern "C" void* Lib_CoreCtrl_Init(void* inParam);
extern "C" void Lib_CoreCtrl_Free();
#endif
#include "QZkJsonParser.h"
CDllCoreCtrl::CDllCoreCtrl(const ZStringList& szDllPaths, IGuiCallback* pGuiCb,class IDetectorEngine* pDE /*= NULL*/)
{
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
m_pLibCoreCtrl = new CDllLoaderM("lpCoreCtrl", "Lib_CoreCtrl_Init", "Lib_CoreCtrl_Free", m_szDllPaths);
if (NULL != m_pLibCoreCtrl)
{
m_pCoreCtrl = (ICoreCtrl*)m_pLibCoreCtrl->ModuleInit(&inParam);
if (NULL != m_pCoreCtrl)
{
m_pCoreCtrl->IInitCore(pDE);
}
else
{
tpDebugOut("failed to get instance from tpCoreCtrl.dll");
}
}
else
{
tpDebugOut("failed to load tpCoreCtrl.dll");
}
#else
m_pLibCoreCtrl = NULL;
m_pCoreCtrl = (ICoreCtrl*)Lib_CoreCtrl_Init(&inParam);
#endif
}
CDllCoreCtrl::~CDllCoreCtrl()
{
if (NULL != m_pCoreCtrl)
{
m_pCoreCtrl->IFreeCore();
#ifdef _USE_LIB_CORECTRL_DLL
if (NULL != m_pLibCoreCtrl)
{
m_pLibCoreCtrl->ModuleFree();
}
#else
Lib_CoreCtrl_Free();
#endif
m_pCoreCtrl = NULL;
}
if (NULL != m_pLibCoreCtrl)
{
delete m_pLibCoreCtrl;
m_pLibCoreCtrl = NULL;
}
}

@ -0,0 +1,21 @@
#ifndef CDLLCORECTRL_H
#define CDLLCORECTRL_H
#include "iCoreCtrl.h"
#include "zclasses.h"
class CDllCoreCtrl
{
public:
CDllCoreCtrl(const ZStringList& szDllPaths, IGuiCallback* pGuiCb, class IDetectorEngine* pDE /*= NULL*/);
~CDllCoreCtrl();
public:
TP_GLOBAL_DATA m_tpGlobal;
class CDllLoaderM* m_pLibCoreCtrl;
ICoreCtrl* m_pCoreCtrl;
ZStringList m_szDllPaths;
};
#endif // CDLLCORECTRL_H

@ -0,0 +1,79 @@
#include "CDllDetectorEngine.h"
#include "iCoreCtrl.h"
CDllDetectorEngine::CDllDetectorEngine()
{
m_pDE = NULL;
#ifdef _DEBUG
m_lib.setFileName("lpbengined.dll");
#else
m_lib.setFileName("lpbengine.dll");
#endif
if (!m_lib.load())
{
qWarning("failed to load lpbengine");
}
FnLpNewEngineInstance pfnLpNewInstance = (FnLpNewEngineInstance)m_lib.resolve("LpNewEngineInstance");
if (pfnLpNewInstance)
pfnLpNewInstance(&m_pDE, NULL);
if (!m_pDE)
{
qWarning("failed to get instance from lpbengine");
}
}
CDllDetectorEngine::~CDllDetectorEngine()
{
Quit();
}
bool CDllDetectorEngine::Initialize(class ICoreCtrl* pCoreCtrl)
{
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++)
{
IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)pDeviceMgr->AddDevice(CAMERA);
if (pCamera)
{
TP_CAMERA_OPTION option;
pCoreCtrl->ICameraOptionByKey(strCameraKeys.at(i), option);
pCamera->SetName(strCameraKeys.at(i));
pCamera->SetID(option.id);
}
}
}
m_pDE->GetDataInterface(SHAREAPARAM, &p);
IAlgorithmShare* pAlgoShare = (IAlgorithmShare*)p;
if (pAlgoShare)
{
pAlgoShare->RegisterCoreCtrl(pCoreCtrl);
}
return true;
}
return false;
}
void CDllDetectorEngine::Quit()
{
FnLpDeleteEngineInstance pfnLpDeleteInstance = (FnLpDeleteEngineInstance)m_lib.resolve("LpDeleteEngineInstance");
if (pfnLpDeleteInstance)
pfnLpDeleteInstance();
if (m_lib.isLoaded())
m_lib.unload();
}

@ -0,0 +1,19 @@
#ifndef CDLLDETECTORENGINE_H
#define CDLLDETECTORENGINE_H
#include "lpbengine.h"
class CDllDetectorEngine
{
public:
CDllDetectorEngine();
~CDllDetectorEngine();
public:
bool Initialize(class ICoreCtrl* pCoreCtrl);
void Quit();
IDetectorEngine *m_pDE;
private:
QLibrary m_lib;
};
#endif // CDLLDETECTORENGINE_H

@ -0,0 +1,64 @@
#include "QDetectorDesignerMgr.h"
QDetectorDesignerMgr::QDetectorDesignerMgr()
{
m_pDesigner = NULL;
m_pDE = NULL;
}
QDetectorDesignerMgr::~QDetectorDesignerMgr()
{
// Quit();
}
bool QDetectorDesignerMgr::Initialize(IDetectorEngine* lpDE)
{
if (!lpDE)
return false;
m_pDE = lpDE;
#ifdef _DEBUG
m_lib.setFileName("lpdesignerd.dll");
#else
m_lib.setFileName("lpdesigner.dll");
#endif
if (!m_lib.load()) {
qDebug() << "lpdesigner lib load failed";
return false;
}
qDebug() << "lib load ok";
FnLpDesignerNewInstance pfnLpNewInstance = (FnLpDesignerNewInstance)m_lib.resolve("LpDesignerNewInstance");
if (pfnLpNewInstance)
pfnLpNewInstance(&m_pDesigner, m_pDE, this);
if (!m_pDesigner)
return false;
return true;
}
IDetectorUI* QDetectorDesignerMgr::GetDesignerInterface() const
{
return m_pDesigner;
}
void QDetectorDesignerMgr::Quit()
{
if (m_lib.isLoaded())
m_lib.unload();
if (m_pDesigner)
{
delete m_pDesigner;
m_pDesigner = NULL;
}
}
void QDetectorDesignerMgr::OnManualTrigger()
{
emit sgCloseWindow();
}
void QDetectorDesignerMgr::OnSetParam(IDetectorTask* pTask)
{
//return m_pApp->SetParam(pTask);
}

@ -0,0 +1,31 @@
#ifndef QDETECTORDESIGNERMGR_H
#define QDETECTORDESIGNERMGR_H
#include ".\lpbengine.h"
#include ".\lpdesigner.h"
#include "qobject.h"
class QDetectorDesignerMgr : public QObject, public IDetectorUISink
{
Q_OBJECT
public:
QDetectorDesignerMgr();
virtual ~QDetectorDesignerMgr();
bool Initialize(IDetectorEngine* lpDE);
void Quit();
IDetectorUI * GetDesignerInterface() const;
virtual void OnManualTrigger();
virtual void ResetItem(QPoint pos, QRect size){}
virtual void OnSetParam(IDetectorTask* pTask);
signals:
void sgCloseWindow();
private:
private:
QLibrary m_lib;
IDetectorUI *m_pDesigner;
IDetectorEngine *m_pDE;
};
#endif // QDETECTORDESIGNERMGR_H

@ -0,0 +1,56 @@
#ifndef _ISTATION_H_
#define _ISTATION_H_
#include <QVariant>
#include <QObject>
#include "Serialport_global.h"
#define _WF_UNIQUE_SPLIT "_-_"
enum EM_WIDGET_TYPE {
emListModel, emLableImageShow, emLabelStationName
};
class WfModel;
class IStation : public QObject
{
Q_OBJECT
public:
IStation(){};
virtual ~IStation(){};
virtual int stationId() = 0;
virtual QString stationKey() = 0;
virtual QString stationShowName() = 0;
virtual void setCamInfo(int nId, int alg, QString uniqueName, QString showName) = 0;
virtual void setComInfo(QString strName, int nCmd) = 0;
virtual QVariant getVariant(){ return QVariant(); }
virtual void revResult() = 0;
virtual bool trigImage(const QString folder = QString()) = 0;
virtual bool isWorkingOk() = 0;
virtual QString currentRunningModel() const = 0;
virtual void setCurrentModel(QString strModel) = 0;
virtual void setCurrentModel(int index) = 0;
virtual QString currentSelectModel() = 0;
virtual int modelCount() { return 0; }
virtual QStringList modelList() { return QStringList(); }
virtual QString model(int index) { return QString(); }
virtual QString modelByPlcCmd(int nIndex) { return QString(); }
virtual WfModel *wfModel(QString) = 0;
virtual bool addModel(QString strModel) = 0;
virtual bool delModel(QString strModel) = 0;
virtual QString uniqueModel(const QString &model){ return QString(); }
virtual bool sendResult(double ) = 0;
virtual bool setWidget(QString str, QWidget *pWgt) = 0;
virtual bool startBatchTest(QString) = 0;
virtual bool IStandard(QString) = 0;
void setSerialPortPtr(ISerialPortTool *ptr){ m_pPort = ptr; }
signals:
void sgPrint2Window(QString &);
void sgUpdateLable();
void sgShowImage(const QImage &img);
protected:
ISerialPortTool *m_pPort{ nullptr };
};
#endif

@ -0,0 +1,36 @@
#ifndef _IWFCTRL_H_
#define _IWFCTRL_H_
#include <QObject>
#include <QMap>
class IStation;
class WfModel;
class IWfCtrl :public QObject
{
Q_OBJECT
public:
IWfCtrl(){};
virtual~IWfCtrl(){};
virtual bool IOnlineMode() { return false; }
virtual void ISetOnlineModel(bool) {};
virtual bool IBatchModel() = 0;
virtual bool IConnectStatus() = 0;
virtual QString IGetCommName() = 0;
virtual QString IGetCurrentRuningModel(int) = 0;
virtual void ISetUserInfo(QString& user, int& level)=0;
virtual bool IGetUserInfo(QString& user, int& level) = 0;
virtual void registerConnect() =0;
virtual QStringList IGetStationKeys() = 0;
virtual IStation* IGetStationById(int) = 0;
virtual IStation* IGetStationByKey(QString) = 0;
virtual WfModel *IGetModelInfo(int, QString) = 0;
virtual bool IUpdateModelInfo() = 0;
virtual QMap<QString, class WfModel*> IGetModelInfos() = 0;
virtual bool IAddModel(int, QString) = 0;
virtual bool IDeleteModel(int, QString) = 0;
virtual bool ISelModel(int, QString) = 0;
virtual void ISetModifyModel(bool) = 0;
virtual bool IStandard(int nIndex ,QString strModel)=0;
};
#endif

@ -0,0 +1,122 @@
#include "ModelTable.h"
#include "IStation.h"
#include "QDebug"
#include "qtableview.h"
#include "qabstractitemview.h"
#include "WfModel.h"
#pragma execution_character_set("utf-8")
QVariant ModelModel::data(const QModelIndex &index, int role /*= Qt::DisplayRole*/) const
{
if (role == Qt::DisplayRole) {
int nCol = index.column();
int nRow = index.row();
//qDebug() << index.row();
if (0 == nCol) {
if (nRow != 0) {
int a = 1;
}
return m_pStation->model(nRow);
}
else if (1== nCol) {
return m_pStation->wfModel(m_pStation->model(nRow))->nIndex;
}
else if (2==nCol) {
//return m_pStation->wfModel(m_pStation->model(nRow))->bCaliState == true ? "已标定" : "未标定";
return m_pStation->IStandard(m_pStation->model(nRow)) == true ? QObject::tr("已标定") : QObject::tr("未标定");
}
}
else if (role == Qt::BackgroundRole) {
QString str1 = m_pStation->currentRunningModel();
QString str2 = m_pStation->model(index.row());
if (str1 == str2) {
return QColor(255, 0, 0);
}
else {
return QColor(255, 255, 255);
}
// int nCol = index.column();
// int nRow = index.row();
// if (2 == nCol) {
// return m_pStation->IStandard(m_pStation->model(nRow)) == true ? QColor(255, 255, 255) : QColor(255, 0, 255);
// }
}
return QVariant();
}
int ModelModel::columnCount(const QModelIndex &parent /*= QModelIndex()*/) const
{
return 3;
}
int ModelModel::rowCount(const QModelIndex &parent /*= QModelIndex()*/) const
{
return m_pStation->modelCount();
}
QVariant ModelModel::headerData(int section, Qt::Orientation orientation, int role /*= Qt::DisplayRole*/) const
{
if (Qt::DisplayRole == role ) {
if (Qt::Horizontal == orientation) {
if (section < m_lstHeader.size()) {
return m_lstHeader.at(section);
}
else {
return QVariant();
}
}
else {
return section + 1;
}
}
return QVariant();
}
ModelModel::ModelModel(IStation *pStation)
: m_pStation(pStation)
{
m_lstHeader = QStringList() << QObject::tr("模型号") << QObject::tr("PLC索引值") << QObject::tr("标定情况");
}
void ModelModel::resetModel()
{
beginResetModel();
endResetModel();
}
ModelView::ModelView(QTableView *pView, IStation *pStation)
{
m_pView = pView;
m_pView->setSelectionBehavior(QAbstractItemView::SelectRows);
//QObject::connect(pView, SIGNAL(clicked(const QModelIndex &)), this, SLOT(onSelectItem(const QModelIndex&)));
m_pModel = new ModelModel(pStation);
m_pView->setModel(m_pModel);
}
ModelView::~ModelView()
{
delete m_pModel;
delete m_pView;
m_pView = NULL;
m_pModel = NULL;
}
void ModelView::resetModel()
{
m_pModel->resetModel();
}
void ModelView::scroll2Bottom()
{
m_pView->scrollToBottom();
}
int ModelView::currentRow()
{
if (m_pView) {
return m_pView->currentIndex().row();
}
return -1;
}

@ -0,0 +1,37 @@
#pragma once
#include "qabstractitemmodel.h"
#include "qtableview.h"
#include "qmap.h"
#include "qstring.h"
#include "qobject.h"
class IStation;
class ModelModel : public QAbstractTableModel
{
public:
ModelModel(IStation *);
virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
virtual QVariant headerData(int section, Qt::Orientation orientation,
int role = Qt::DisplayRole) const;
void resetModel();
private:
IStation *m_pStation;
QStringList m_lstHeader;
};
class ModelView : public QObject
{
Q_OBJECT
public:
ModelView(QTableView *, IStation *);
~ModelView();
void resetModel();
void scroll2Bottom();
int currentRow();
ModelModel *m_pModel;
QTableView * m_pView;
};

@ -0,0 +1,184 @@
#include <QDebug>
#include <QDateTime>
#include <QDir>
#include "QDiskCleanThread.h"
#include "solarCellHelper.h"
bool compareFileCreatTime(const QFileInfo &fileInfo1, const QFileInfo &fileInfo2)
{
if (fileInfo1.created() < fileInfo2.created())
{
return true;
}
return false;
}
QDiskCleanThread::QDiskCleanThread(QObject * parent)
: QThread(parent)
, m_bExit(false)
, m_strImgStorageFolder(QString())
, isUse(false)
, m_nDay(7)
, m_DelFile(false)
, nMiniSize(10)
{
bModel = CleanFile;
nSleepTime = 300;
}
QDiskCleanThread::~QDiskCleanThread()
{
ExitThread();
}
void QDiskCleanThread::run()
{
while (!m_bExit)
{
qWarning() << "Start Scan Disk ...";
QString strDisk = m_strImgStorageFolder.left(2);
int space = solarCell::SolarCellHelper::GetDiskFreeSpace(strDisk);
if (space < 1024 * 10)
{
isUse = true;
m_nDay = 3;
}
qWarning() << "spacesize =" << space;
if (bModel == CleanFile)//清空图片数据的操作
{
if (isUse)
{
QFileInfoList fileInfoList;
fileInfoList.clear();
solarCell::SolarCellHelper::GetFileInfoList(fileInfoList, m_strImgStorageFolder);
QDateTime timedate = QDateTime::currentDateTime();
//timedate.setTime(QTime(0, 0, 0));//以零点时间为准 开始比较时间
int nDay = 0;
if (m_nDay <= 0)
nDay = 3;//限制天数 不能低于3天
else
nDay = m_nDay;
timedate = timedate.addDays(-nDay);
GetFileListByTime(fileInfoList, timedate);
if (fileInfoList.size() > 10 &&
!m_strImgStorageFolder.isEmpty())
{
for (int nIndex = 0; nIndex < fileInfoList.size(); nIndex++)
{
QFileInfo qFileInfo = fileInfoList.at(nIndex);
qFileInfo.dir().remove(qFileInfo.fileName());
}
}
space = solarCell::SolarCellHelper::GetDiskFreeSpace(strDisk);
qWarning() << "Delete Imgs ...";
}
if (space < 1024 * nMiniSize)
{
m_DelFile = true;
}
if (m_DelFile)
{
QFileInfoList fileInfoList;
fileInfoList.clear();
solarCell::SolarCellHelper::GetFileInfoList(fileInfoList, m_strImgStorageFolder);
qSort(fileInfoList.begin(), fileInfoList.end(), compareFileCreatTime);
//删除时间最老的300张图片
int delNum = 600;
if (delNum > fileInfoList.size())
{
delNum = fileInfoList.size();
}
for (int i = 0; i < delNum; i++)
{
QString filePath = fileInfoList.at(i).absolutePath();
QString fileName = fileInfoList.at(i).fileName();
QString createTIme = fileInfoList.at(i).created().toString("yyyy-MM-dd hh:mm:ss zzz");
if (fileName.right(4).toLower() == ".jpg" ||
fileName.right(4).toLower() == ".bmp" ||
fileName.right(4).toLower() == ".png")
{
QFile::remove(fileInfoList.at(i).absolutePath() + "/" + fileInfoList.at(i).fileName());
}
}
m_DelFile = false;
qWarning() << "Delete Imgs Finish...";
}
}
else if (bModel == CleanDir)//清空图片文件夹测操作
{
if (isUse)
{
QFileInfoList fileInfoList;
fileInfoList.clear();
solarCell::SolarCellHelper::GetDirInfoList_root(fileInfoList, m_strImgStorageFolder);
QDateTime timedate = QDateTime::currentDateTime();
if (m_nDay <= 0)
m_nDay = 3;//限制天数 不能低于3天
timedate = timedate.addDays(-m_nDay);
GetDirListByTime(fileInfoList, timedate);
if (fileInfoList.size() > 0 &&
!m_strImgStorageFolder.isEmpty())
{
for (int nIndex = 0; nIndex < fileInfoList.size(); nIndex++)
solarCell::SolarCellHelper::DelDiretory(fileInfoList.at(nIndex).absoluteFilePath());
}
}
}
qWarning() << "End Scan Disk ...";
//三十秒判断一次
if (nSleepTime <= 2)
nSleepTime = 2;
int sleeptime = nSleepTime * 1000;
msleep(10);
}
}
void QDiskCleanThread::ExitThread()
{
m_bExit = true;
}
void QDiskCleanThread::SetImgStorageFolder(QString strFolder)
{
m_strImgStorageFolder = strFolder;
}
void QDiskCleanThread::GetDirListByTime(QFileInfoList &qDirList, QDateTime &qDateTime)
{
QFileInfoList tmpList;
tmpList.clear();
for (int nIndex = 0; nIndex < qDirList.size(); nIndex++){
QFileInfo nFileInfo = qDirList.at(nIndex);
if (nFileInfo.fileName() == "." || nFileInfo.fileName() == "..")
continue;
if (nFileInfo.created()<qDateTime)
tmpList.append(nFileInfo);
}
qDirList = tmpList;
}
void QDiskCleanThread::GetFileListByTime(QFileInfoList &qFileList, QDateTime &qDateTime)
{
QString strDate = qDateTime.toString("yyyy-MM-dd hh:mm:ss zzz");
QFileInfoList tmpList;
tmpList.clear();
for (int nIndex = 0; nIndex < qFileList.size(); nIndex++){
QFileInfo nFileInfo = qFileList.at(nIndex);
if (nFileInfo.fileName() == "." || nFileInfo.fileName() == "..")
continue;
//QString strTime = nFileInfo.created().toString("yyyy-MM-dd hh:mm:ss zzz");
if (nFileInfo.created() < qDateTime)
tmpList.append(nFileInfo);
}
qFileList = tmpList;
}

@ -0,0 +1,50 @@
#ifndef _QDISK_CLEAN_THREAD_H__
#define _QDISK_CLEAN_THREAD_H__
#include <QThread>
#include <QFileInfoList>
enum CleanModel
{
CleanFile = 0,
CleanDir
};
class QDiskCleanThread : public QThread
{
Q_OBJECT;
public:
QDiskCleanThread(QObject * parent = 0);
virtual ~QDiskCleanThread();
void setModel(CleanModel nModel = CleanFile){ bModel = nModel; };
void setSleepS(int nTime){ nSleepTime = nTime; };
void setUseFlag(bool bFalg = false){//是否开启轮询监控
isUse = bFalg;
};
void setMiniSize(int minsize){
nMiniSize = minsize;
if (nMiniSize <= 0)
nMiniSize = 0;
};
void setDays(int nday = 7){ m_nDay = nday; };//超期天数
void ExitThread();
void SetImgStorageFolder(QString strFolder);
void GetDirListByTime(QFileInfoList &qDirList, QDateTime &qDateTime);
void GetFileListByTime(QFileInfoList &qFileList, QDateTime &qDateTime);
protected:
void run();
signals:
void sgDiskSpace(int nSpace, bool nFlag);
private:
bool m_bExit{ false };
QString m_strImgStorageFolder;//监控的文件夹
bool isUse{ false };
int m_nDay{ 30 };
bool m_DelFile{ false };//重复删除标志位 用于判断硬盘数据是否是过大 如果过大 会删除两次
int nMiniSize{ 10 };//监控硬盘最小的内存大小 G单位计算 小于该数量 删除数据
CleanModel bModel{ CleanFile };//线程工作模式选择
int nSleepTime{ 30 };//线程挂起时间 单位 秒
};
#endif//_QDISK_CLEAN_THREAD_H__

@ -0,0 +1,51 @@
#include "WorkChecker.h"
#include <QTimer>
#include <QDateTime>
WorkChecker::WorkChecker()
{
m_bWorking = true;
m_lLastTime = QDateTime::currentDateTime().toMSecsSinceEpoch();
m_nCheckInterval = 300;
m_pTimer = new QTimer(this);
connect(m_pTimer, SIGNAL(timeout()), this, SLOT(onChecker()));
start();
}
WorkChecker::~WorkChecker()
{
}
void WorkChecker::registerWorking()
{
m_lLastTime = QDateTime::currentDateTime().toMSecsSinceEpoch();
m_bWorking = true;
}
bool WorkChecker::isWorking() const
{
return m_bWorking;
}
void WorkChecker::onChecker()
{
long long l = QDateTime::currentDateTime().toMSecsSinceEpoch();
long long l1 = l - m_lLastTime;
//m_lLastTime = l;
if (l1 > 3000) {
m_bWorking = false;
}
}
void WorkChecker::start()
{
stop();
m_pTimer->start(m_nCheckInterval);
}
void WorkChecker::stop()
{
m_pTimer->stop();
}

@ -0,0 +1,23 @@
#ifndef _WORKCHECKER_H_
#define _WORKCHECKER_H_
#include <QObject>
class WorkChecker : public QObject
{
Q_OBJECT
public:
WorkChecker();
~WorkChecker();
void registerWorking();
bool isWorking() const ;
void start();
void stop();
public slots:
void onChecker();
private:
class QTimer *m_pTimer{ nullptr };
int m_nCheckInterval{ 300 };
bool m_bWorking{ true };
long long m_lLastTime{ 0 };
};
#endif

@ -0,0 +1,90 @@
#ifndef _SOLAR_CELL_HELPER_H__
#define _SOLAR_CELL_HELPER_H__
#include <QDebug>
#include <windows.h>
#include <QImage>
#include <QFileInfo>
#include <QFileInfoList>
#include <QDir>
namespace solarCell
{
class SolarCellHelper
{
public:
static inline qint64 GetDiskFreeSpace(QString strDriver)
{
LPCWSTR lpcwstrDriver = (LPCWSTR)strDriver.utf16();
ULARGE_INTEGER liFreeBytesAvailable, liTotalBytes, liTotalFreeBytes;
if (!GetDiskFreeSpaceEx(lpcwstrDriver, &liFreeBytesAvailable, &liTotalBytes, &liTotalFreeBytes))
{
qWarning() << "ERROR: Call to GetDiskFreeSpaceEx() failed.";
return 0;
}
//返回MB
return (quint64)liTotalFreeBytes.QuadPart / 1024 / 1024;
}
static inline void GetFileInfoList(QFileInfoList& fileInfoList, QString strFolder)
{
QDir qDir(strFolder);
QFileInfoList filesListTmp = qDir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot, QDir::Time);
fileInfoList += filesListTmp;
QStringList dirList = qDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
for (int i = 0; i < dirList.size(); i++)
{
GetFileInfoList(fileInfoList, strFolder + "/" + dirList.at(i));
}
}
static inline void GetDirInfoList_child(QFileInfoList& dirInfoList, QString strFolder)
{
QDir qDir(strFolder);
QFileInfoList filesListTmp = qDir.entryInfoList(QDir::Dirs, QDir::Time);
dirInfoList += filesListTmp;
QStringList dirList = qDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
for (int i = 0; i < dirList.size(); i++)
{
GetDirInfoList_child(dirInfoList, strFolder + "/" + dirList.at(i));
}
}
static inline void GetDirInfoList_root(QFileInfoList& dirInfoList, QString strFolder)
{
QDir qDir(strFolder);
QFileInfoList filesListTmp = qDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Time);
dirInfoList += filesListTmp;
}
static inline bool DelDiretory(const QString &dirPath)
{
if (dirPath.isEmpty())
return false;
QDir qDir(dirPath);
if (!qDir.exists())
return true;
qDir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
QFileInfoList qFileList = qDir.entryInfoList();
foreach(QFileInfo qFileInfo, qFileList)
{
if (qFileInfo.isFile())
qFileInfo.dir().remove(qFileInfo.fileName());
else
DelDiretory(qFileInfo.absoluteFilePath());
}
return qDir.rmpath(qDir.absolutePath());
}
};//Class SolarCellHelper
}
#endif//_SOLAR_CELL_HELPER_H__

Binary file not shown.

After

Width:  |  Height:  |  Size: 5.7 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 48 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.0 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 92 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 17 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 17 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 13 KiB

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save