|
|
/******************************************************************************
|
|
|
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 |