valvedetect/3part/tadpole/include/tpBase/iCoreCtrl.h

/******************************************************************************
 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 void IDataToComm(IImageObject::DATA_TO_COMM_HEAD& head, char* pData, int nLen) = 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;
    virtual void IEnableComm(const QString& strName, bool bEnable = true) = 0;

	//operate comm
	virtual QList<QString> ICommKeys() = 0;
	virtual bool ICommOptionByKey(const QString& strName, TP_COMM_SETTING_NODE& commOpt) = 0;
	virtual bool IOpenComm(const QString& strName) = 0;
	virtual bool ICloseComm(const QString& strName) = 0;
    virtual bool IAddComm(const QString& strName, const TP_COMM_SETTING_NODE& commOpt, bool bNew) = 0;
    virtual bool IDelComm(const QString& strName) = 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 IUpdateCamShow(const QString& uniqueName) {}
//    virtual void IUpdateAlgShow(const QString& uniqueName, int index) {}
    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触发
    //callback functions using by overlapped directly...
};


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