Deliver/include/ImproModeCalAndCor.h

#pragma once
#include <time.h>
#include <string>
#include <map>
#include <deque>
//#include<vld.h>
using namespace std;

#ifndef FPDCalibration_DLL_EXPORTS
#ifdef _WIN64
#ifdef _DEBUG
#pragma comment(lib, "FPDCalibrationX64D.lib")
#else
#pragma comment(lib, "FPDCalibrationX64.lib")
#endif
#else
#ifdef _DEBUG
#pragma comment(lib, "FPDCalibrationD.lib")
#else
#pragma comment(lib, "FPDCalibration.lib")
#endif
#endif
#endif

#ifdef FPDCalibration_DLL_EXPORTS
#define FPDCalibration_API __declspec(dllexport)
#define FPDCalibration_C_API extern "C" __declspec(dllexport)
#else
#define FPDCalibration_API __declspec(dllimport)
#define FPDCalibration_C_API extern "C" __declspec(dllimport)
#endif

typedef unsigned short WORD;
typedef unsigned long DWORD;
typedef void * LPVOID;


#define	IMG_STATUS_NONE	        0
#define	IMG_STATUS_OFFSET	    1			
#define	IMG_STATUS_GAIN         2
#define	IMG_STATUS_DEFECT       4
#define	IMG_STATUS_FISRTLINE    8
#define	IMG_STATUS_GRID         16
#define	IMG_STATUS_TWICELINE    32
#define	IMG_STATUS_GATELINE     64
#define IMG_STATUS_ALL          -1

#define	CORRTYPE_NONE          0
#define	CORRTYPE_OFFSET	       1			
#define	CORRTYPE_GAIN          2
#define	CORRTYPE_DEFECT        4
#define	CORRTYPE_FISRTLINE     8
#define	CORRTYPE_TWICELINE     16
#define	CORRTYPE_ALL           -1

#define	CALIBRATE_NONE          0
#define	CALIBRATE_OFFSET	    1			
#define	CALIBRATE_GAIN          2
#define	CALIBRATE_DEFECT        4
#define	CALIBRATE_FISRTLINE     8
#define	CALIBRATE_TWICELINE     16
#define	CALIBRATE_ALL           -1


//公共定义--------------------------------------------------------------------begin
typedef enum _Img_Type
{
    IMGTYPE_EMPTY,                //无效图
    IMGTYPE_PREIEW,               //Preview图
    IMGTYPE_FULL,                 //Full图
    IMGTYPE_MAX
}IMG_TYPE;

typedef enum _Img_XrayOrDark
{
    IMG_EMPTY,
    IMG_XRAY,
    IMG_DARK,
    IMG_ANY,//dark or xray
    IMG_MAX
}IMG_XRAYORDARK;

typedef struct _ImageSizeInfo
{
    size_t Width;
    size_t Height;
    int Bit;
}IMAGESIZEINFO;

typedef struct _ImageDeadLineInfo
{
    size_t TopClip;
    size_t BottomClip;
    size_t LeftClip;
    size_t RightClip;
}IMAGEDEADLINEINFO;

typedef enum _XwindowReqType
{
    XWINDOWREQ_NONE,//no dose request
    XWINDOWREQ_YES,
    XWINDOWREQ_MAX
}XWINDOWREQTYPE;

typedef struct _XwinowReq
{
    XWINDOWREQTYPE Req;
	float FrameRate;
    float XwindowSize;//
}XWINDOWREQ;

typedef enum _ImgDoseReqType
{
    IMGREQNONE,//no dose request
    IMGREQDOSE,
    IMGREQEXI,
    IMGREQMAX
}IMGDOSEREQTYPE;

typedef struct _DoseReq
{
    IMGDOSEREQTYPE Req;
    size_t TargetVal;//exi or dose
}DOSEREQ;

typedef enum _ImgProcessType
{
    IMGPROCESSNONE,
    IMGPROCESSCORRECTION,
    IMGPROCESSCALIBRATION,
    IMGPROCESSMAX,
}IMGPROCESSTYPE;

typedef enum _Expose_Mode
{
    EXPOSE_PULSE,
    EXPOSE_CONTINUE,
    EXPOSE_AED,
    EXPOSE_MAX
}EXPOSE_MODE;

typedef enum _Syn_Type
{
    SYNTYPE_NONE,             //无同步              
    SYNTYPE_SOFT,             //软同步              
    SYNTYPE_HARD,             //硬同步           
    SYNTYPE_SOFT_AND_HARD,    //软影同步
    SYNTYPE_MAX,
}SYN_TYPE;

//坐标系统为(Y下X右)为正向
typedef struct _Dios_2D_Position
{
    int X;
    int Y;
}DIOS_2D_POSITION;



//公共定义--------------------------------------------------------------------end

//xwindow&framerate的匹配关系,此类作为xwindowmap的基类，只提供访问方法，至于匹配2维矩阵的实现由继承类来实现.
//class __declspec(dllexport) CXwindowMap
//{
//public:
//    CXwindowMap();
//    ~CXwindowMap();
//
//    virtual bool SetFrameRate(size_t Rate) = 0;
//    virtual void GetFrameRate(size_t &Rate) = 0;
//    virtual void GetFrameRateMax(size_t &Rate) = 0;
//    virtual void GetFrameRateMin(size_t &Rate) = 0;
//
//    virtual bool SetXwindow(size_t xwindow) = 0;
//    virtual void GetXwindow(size_t &xwindow) = 0;
//    virtual void GetXwindowMax(size_t &xwindow) = 0;
//    virtual void GetXwindowMin(size_t &xwindow) = 0;
//};


//保存单帧相关的所有信息
//图像大小，图像校正情况，图像类型，计量需求()
class FPDCalibration_API CImgFrame
{
    //内含变量内容
    //1.图像尺寸信息
    IMAGESIZEINFO m_stImageSizeInfo;
    IMAGEDEADLINEINFO m_stImageDeadLineInfo;
    //2.缓存信息
    void *m_pImgbuffer;
    int m_nPerPixSize;
    size_t m_nBuffSize;//(in byte)
	size_t m_nFrameID;   //Frame ID
	size_t m_nSeqID;     //Seq ID

    //3.图像的状态信息
    //3.1校正的信息
    DWORD m_ImageStatus;//已经校正后的结果放在这里,用BIT位or区分,IMG_STATUS_XXX

    //3.2图像的类型信息
    IMG_TYPE m_ImageType;//Prev,Full,无效
    IMG_XRAYORDARK m_XrayOrDark;//暗场图or射线图or空图

    //Xray图像情况下，需要判断此变量
    //0:不需要计量，1：需要Dose,2:需要Exi
    DOSEREQ m_DoseReq;
    XWINDOWREQ m_XwindowReq;
	float m_uGy;

    size_t m_CurrentExi;
    //是否为有效数据
    //可以把FrameIn函数执行当做有数据copy in ，添加一个函数
    bool m_bEffective;    
	

public:
    //void *m_pImgbuffer;
    CImgFrame();
    virtual~CImgFrame();

    CImgFrame(IMAGESIZEINFO stImageSizeInfo, IMAGEDEADLINEINFO stImageDeadLineInfo, DWORD m_ImageStatus, 
        IMG_TYPE ImageType, IMG_XRAYORDARK XrayOrDark, DOSEREQ DoseReq, XWINDOWREQ XwindowReq, 
        size_t CurrentExi, bool Effective);

    //copy constructor
    CImgFrame(const CImgFrame &tValue);
    CImgFrame& operator = (const CImgFrame &tValue);

    //init
    void ResetFrameEffective();//重新清除数据的有效性,只有在FrameIn成功后才能Effective
    bool GetFrameEffective();

    //Set&Get FrameInfo
    void SetImgType(IMG_TYPE nType);//prev full ...
    void GetImgType(IMG_TYPE &nType);//prev full ...
    void SetImgKind(IMG_XRAYORDARK XrayOrDark);//dark xray ...
    void GetImgKind(IMG_XRAYORDARK &XrayOrDark);//dark xray ...

    //由此函数内部进行内存释放和申请
	bool SetImgSizeInfo(IMAGESIZEINFO *pImgInfo, IMAGEDEADLINEINFO *pDeadLineInfo);
    void GetImgSizeInfo(IMAGESIZEINFO &ImgSizeInfo, IMAGEDEADLINEINFO &DeadLineInfo);
	bool SetImgSizeInfoNoBuf(IMAGESIZEINFO *pImgInfo, IMAGEDEADLINEINFO *pDeadLineInfo);

    void SetImageStatus(DWORD Status);//校正结果
    void AddImageStatus(DWORD Status);//校正结果,内部进行or处理
    void GetImageStatus(DWORD &Status);
	void ClearImageStatus();

    void SetDoseRequest(DOSEREQ Req);
    void GetDoseRequest(DOSEREQ &Req);
	void SetuGyRequest(float Req);
	void GetuGyRequest(float &Req);

	void SetXwindowReq( XWINDOWREQ XwindowReq);
	void GetXwindowReq( XWINDOWREQ &XwindowReq);

    size_t GetImgBuffSize();//获取缓存大小(in byte)
	bool GetID(size_t &nFrameID, size_t &nSeqID);

    //copy image to(from) Frame,内部进行判断尺寸大小
	bool FrameIn(WORD *pImgBuff, size_t BuffSize );//返回成功或失败
	size_t FrameOut(WORD *pOutBuff, size_t BuffSize);//返回复制的长度，失败返回0.

	void GetFrameID(size_t &nFrameID, size_t &nSeqID);
	void SetFrameID(size_t nFrameID, size_t nSeqID);
	
	bool ReleaseBufAndSize(); //清除内存及size信息。其它不变。

    bool GetCurrentExi(size_t &Exi);
    WORD* GetFrameBuf();
};

//保存一系列的时序图像
class FPDCalibration_API CImgFrameSeq
{
    IMGPROCESSTYPE m_ProcessType;//for correction or calibration
    CImgFrame *m_1pFrameList;//Frame List
	size_t m_FrameListSize;//Frame Total Count，
    size_t m_FrameSeqSize;//Frame Seq Count
    size_t m_CurrentFrameSeqIdx;//Frame Seq Idx,当前Idx指向的是未处理过的Frame.
	XWINDOWREQ m_XwindowReq;

public:
    CImgFrameSeq();
    ~CImgFrameSeq();

    //init
    void ClearSeqIdx();//保持序列不动，只更新SeqIdx为0
    void ResetFrameSeq(int SeqSize);//序列长度同步，若有必要内存也得申请更新
    bool CreateSeq(IMGPROCESSTYPE PrcessType, CImgFrame *pImgFrameTemplate, size_t size);
	bool ReleaseSeq();
    void GetProcessType(IMGPROCESSTYPE &PrcessType);

	void SetXwindowReq(XWINDOWREQ XwindowReq);
	void GetXwindowReq(XWINDOWREQ &XwindowReq);

    //Access methods
	size_t size();//Total Frame Count
    size_t idx();//Current Frame Idx
    size_t PlusSeqIdx();// seqidx++	

    //校正模块创建Seq以后，要loop更新Frame的属性
    //使用者是基于Frame属性，更新Frame数据
    CImgFrame &operator [](size_t idx);//反馈ImgFrame引用
};

typedef enum _Offset_Mode
{
    PRE_OFFSET,
    POST_OFFSET,
    PRE_POST_OFFSET,
    MAX_OFFSET
}OFFSET_MODE;


class FPDCalibration_API OffsetInfo
{
    OFFSET_MODE m_eOffsetMode; //offset mode
    //int *m_pFrameRate;         //帧频率，
    //comment by cjy:XwindowSize!!
    //float* m_pExposureWindow;    //曝光窗口毫秒
    IMAGESIZEINFO m_stMapSizeInfo;
    unsigned int m_nOffsetLSB;	           //暗场图灰度均值
    deque <time_t> *m_pDequeMapCreatTime;   //offsetmap创建时间
    deque <float> *m_pDequeTemp;
	deque <float> *m_pDequeExpWindow;
	deque <float> *m_pDequeMaxRate;
    //map <float, WORD* > *m_pMapOffset;      //<曝光窗口， offset buffer>
    unsigned int m_n_ListNum;
	unsigned int m_nAvgImgNum;
	unsigned int m_nInvalidNum;


    IMAGESIZEINFO m_stSizeInfo;

    //void *m_pOffsetMatrix;

public:
    OffsetInfo();
    OffsetInfo( IMAGESIZEINFO stSizeInfo);
    ~OffsetInfo();


    bool SetOffsetMode( OFFSET_MODE eOffsetMode );
    //bool SetFrameRate( int nFrameRate );
    bool SetOffsetLSB( int nOffsetLSB);
	bool SetExposureWindow(float nExpWindow);
	bool SetMaxFrameRate(float fMaxFrameRate);
	bool GetMaxFrameRate(float &fMaxFrameRate, unsigned int nIndex);

    bool SetOffsetMapCreatTime(time_t tOffsetMapCreatTime);
    bool SetMapTemp(float fMapTemp);
/*    bool AddedOffsetMap(float fExpWindow, WORD* pBuf, 
        float fMapTemp,  time_t tOffsetMapCreat); */ 

    bool GetOffsetMode(OFFSET_MODE  &eOffsetMode);
    //bool GetFrameRate(int &nFrameRate);
    bool GetExposureWindow(float &nExposureWindow, unsigned int nIndex);
    bool GetOffsetLSB( unsigned int & nOffsetLSB);
    bool GetOffsetMapCreatTime( time_t &tOffsetMapCreatTime, unsigned  int nIndex );
    bool GetMapTemp( float &nMapTemp, unsigned int nIndex );
	bool GetListNum(unsigned int & nListNum);

    bool ClearOffsetMapList();

	bool SetOffsetImgNum( unsigned int nNum);
	bool GetOffsetImgNum(unsigned int &nNum); 

	bool SetOffsetInvalidNum( unsigned int nNum);
	bool GetOffsetInvalidNum(unsigned int &nNum);

	float m_fGateLineDXL[10];
	int m_nGateLineRef_R;
	int m_nGateLineRef_L;

};

class FPDCalibration_API GainInfo
{
    float m_fGainValue;            //设置的增益值   
    int m_nMaxPv;                //饱和值  
    int m_nRefrencePointNum;     //校正节点数量
	unsigned int m_nRefrenceImgNum;       //每个校正节点曝光数量
    //comment by cjy:如何选择？Dose or LSB?
    deque<int>  *m_pDeqTargetLsb;
	deque<float>  *m_pDeqTargetDose;
	time_t m_tGainMapCreatTime;
    float m_fMapTemp;
    IMAGESIZEINFO m_stSizeInfo;
    //void  *m_pGainMatrix;

	unsigned int m_nInvalidNum;

public:
    bool setGainValue( float fGainValue);
    bool getGainValue(float& fGainValue);
    bool setMaxPv(int nMaxPv);
    bool getMaxPv(int &nMaxPv);
    bool setRefrencePointNum(int nRefrencePointNum);
    bool getRefrencePointNum(int &nRefrencePointNum);
	bool setPointImgNum(unsigned int nRefrenceImgNum);
	bool getPointImgNum(unsigned int &nRefrenceImgNum);

    bool setTargetLsb(int nTargetLsb);
    bool getTargetLsb(int &nTargetLsb, unsigned int nIndex);
	bool setTargetDose(float fTargetDose);
	bool getTargetDose(float &fTargetDose, unsigned int nIndex);

    bool setGainMapCreatTime( time_t tGainMapCreatTime);
    bool getGainMapCreatTime(time_t &tGainMapCreatTime);

    bool setMapTemp(float  fMapTemp);
    bool getMapTemp(float  &fMapTemp);

    bool InGainBuf( WORD * pGainBuf, int nListSize, int nBufsize);

    GainInfo( int nRefrencePointNum,  IMAGESIZEINFO stSizeInfo);
    GainInfo();
    ~GainInfo();

	bool SetGainInvalidNum(unsigned int nNum);
	bool GetGainInvalidNum(unsigned int &nNum);

};

class FPDCalibration_API DefectMapInfo
{
	deque<int>  *m_pDeqTargetLsb;
	deque<float>  *m_pDeqTargetDose;
    //WORD *pPixBuf;
public:
    DefectMapInfo();
    ~DefectMapInfo();
	bool setTargetLsb(int nTargetLsb);
	bool getTargetLsb(int &nTargetLsb, unsigned int nIndex);
	bool getSize(size_t &nCount);
	bool setTargetDose(float fTargetDose);
	bool getTargetDose(float &fTargetDose, unsigned int nIndex);
};

class FPDCalibration_API PreviewInfo   //preview信息
{
    bool m_bEnalbeOutput;      //Preview图是否输出
    int m_nPreWidth;          //Preview图宽
    int m_nPreHeight;
    int m_nPreBit;
	IMAGESIZEINFO m_stSizeInfo;
    int m_nPreBinary; 	    //Bining模式

public:
    PreviewInfo();
    ~PreviewInfo();

	bool setEnalbeOutput(bool bEnalbeOutput);
	bool setSize(IMAGESIZEINFO stSizeInfo);
	bool setBinary(int nPreBinary);

	bool getEnalbeOutput(bool &bEnalbeOutput);
	bool getSize(IMAGESIZEINFO &stSizeInfo);
	bool getBinary(int &nPreBinary);
};

//typedef struct _FILE_HEADER
//{
//    unsigned short  PhySizeWidth;
//    unsigned short  PhySizeHeight;
//    unsigned short  PhySizeBit;
//
//    unsigned short dwPhyCenterX;
//    unsigned short dwPhyCenterY;
//
//    unsigned short  OrgSizeWidth;
//    unsigned short  OrgSizeHeight;
//    unsigned short  OrgSizeBit;
//
//    unsigned short  OrgImgDeadLineTop;
//    unsigned short  OrgImgDeadLineBottom;
//    unsigned short  OrgImgDeadLineLeft;
//    unsigned short  OrgImgDeadLineRight;
//
//    unsigned short m_BinningDx;
//    unsigned short m_BinningDy;
//
//    unsigned short  FullImgSizeWidth;
//    unsigned short  FullImgSizeHeght;
//    unsigned short  FullImgSizeBit;
//
//    bool m_SupportPrevImage;
//
//    unsigned short  PrevImgSizeWidth;
//    unsigned short  PrevImgSizeHeght;
//    unsigned short  PrevImgSizeBit;
//
//    unsigned short  ExpMode;
//
//    unsigned short  OffsetFrameRateCount;
//    unsigned short OffsetXwindowCount;
//
//    unsigned short offsetMode;
//
//    unsigned short  nGainValue;
//    unsigned short  MaxPv;
//    unsigned short nRefrencePointNum;     //校正节点数量
//    unsigned short nRefrenceImgNum;       //每个校正节点曝光数量
//
//    unsigned short  * GainTargetLsb;
//    float *   GainTargetDoes;
//
//    unsigned short  * LowTargetLsb;
//    float *   LowTargetDoes;
//    unsigned short  * HighTargetLsb;
//    float *   HighTargetDoes;
//
//  
//} stFileHeader;


class FPDCalibration_API DetectorModeInfo
{
    //图像相关----------------------------------------------------------------------------------------
    //物理尺寸
    IMAGESIZEINFO m_stPhySizeInfo;
    DIOS_2D_POSITION m_stPhyCenterPosition;

    //原始采集图像信息
    //original image in pixel
    IMAGESIZEINFO m_stOrgImgSizeInfo;
    IMAGEDEADLINEINFO m_stOrgImgDeadLineInfo;

    //binning mode
    size_t m_BinningDx;
    size_t m_BinningDy;


    //输出图像大小信息
    //要由原始图像信息和Binning模式进行匹配
    //特例：
    /*
    org图像为1000*1000,binning为2*2
    输出Ful图像不一定是500*500，研发者可以自定义，如300*300.当然图像的转换要由内部进行.
    */
    //full image
    IMAGESIZEINFO m_stFullImgSizeInfo;
    //IMAGEDEADLINEINFO m_FullImgDeadLineInfo;//上层不需要这个DeadLine的信息

    //prev image
    bool m_SupportPrevImage;
    IMAGESIZEINFO m_stPrevImgSizeInfo;
    //IMAGEDEADLINEINFO m_PrevImgDeadLineInfo;//上层不需要这个DeadLine的信息

    //采集相关----------------------------------------------------------------------------------------
    //SYN_TYPE m_SyncMode;校正模块不需要此参数
    EXPOSE_MODE m_ExpMode;//continue,pulse,aed...

    float m_fStandardEXICoef;
    //曝光模式(pulse)中，采集帧率和xwindow大小是有一定的关系的(需要內建表or建立公式).
    //分辨率和FrameRate也有一定的关系
    //每选择一个FrameRate,会有一套Xwindow的size,峰值，最低值
    //采集帧率
    //Ex.在Correction中校正模块基于当前的（FrameRate，Xwindow大小，原始图像大小)找到对应的OffsetMap,进行Correction.
    //2维矩阵横向是xwindow的min和max，纵向为framerate.
    //至于颗粒度，由配置设定来决定.
    //CXwindowMap	*m_pXwindowmap;

    //校正对象列表
    //Offset校正对象，这个得是2维数组！！！
    //一维用于FrameRate,一维用于Xwindow(数组中的[0]为最低xwindow值，最高位为最高值)
    //每个OffsetInfo指定特定的FrameRate和Xwindow,由采集模块基于要求进行采集.
    //访问方法为 m_pOffset[FrameRateIdx][XwindowIdx]

    /*检讨点：基于Xwindow建立线性Offsetmap呢？还是基于各个FrameRate+Xwindow建立二维Offsetmap呢？由吕工决定*/

    size_t m_OffsetFrameRateCount;
    size_t m_OffsetXwindowCount;

public:
    DetectorModeInfo();
    ~DetectorModeInfo();

    bool setPhySizeInfo( IMAGESIZEINFO PhySizeInfo );
    bool setPhyCenterPosition( DIOS_2D_POSITION PhyCenterPosition);
    bool setOrgImgSizeInfo(IMAGESIZEINFO OrgImgSizeInfo);
    bool setOrgImgDeadLineInfo(IMAGEDEADLINEINFO OrgImgDeadLineInfo);
    bool setBinning( int nX ,int nY);
    bool setFullImgSizeInfo(IMAGESIZEINFO FullImgSizeInfo);
    //bool setSupportPrevImage(bool m_SupportPrevImage);
    //bool setPrevImgSizeInfo(IMAGESIZEINFO PrevImgSizeInfo);
    bool setEXPOSE_MODE(EXPOSE_MODE ExpMode);
    bool setStandardEXICoef(float fValue);

    bool getPhySizeInfo(IMAGESIZEINFO &PhySizeInfo);
    bool getPhyCenterPosition(DIOS_2D_POSITION &PhyCenterPosition);
    bool getOrgImgSizeInfo(IMAGESIZEINFO &OrgImgSizeInfo);
    bool getOrgImgDeadLineInfo(IMAGEDEADLINEINFO &OrgImgDeadLineInfo);
	bool getBinning(size_t &nX, size_t &nY);
    bool getFullImgSizeInfo(IMAGESIZEINFO &FullImgSizeInfo);
    //bool getSupportPrevImage(bool &SupportPrevImage);
    //bool getPrevImgSizeInfo(IMAGESIZEINFO &PrevImgSizeInfo);
    bool getEXPOSE_MODE(EXPOSE_MODE &ExpMode);
    bool getStandardEXICoef(float &fValue);
    bool saveModeFile();
	int ReduceImg(WORD* pSrcImg, WORD* pDstImg, int nSrcWidth, int nSrcHeight, int nDstWidth, int nDstHeight);

	OffsetInfo *m_pOffsetInfo;
	GainInfo *m_pGainInfo;
	DefectMapInfo *m_pDefectInfo;
	PreviewInfo* m_pPreviewInfo;

};

FPDCalibration_C_API DetectorModeInfo*  MallocMode();
FPDCalibration_C_API void FreeMode(DetectorModeInfo* pMode);