#pragma once

#include <map>
#include <list>
#include <vector>
#include <functional>
using namespace std;

#define WM_USER_SYSTEM_CLOSE						(WM_USER + 1)
#define UM_LIST_SELECTDEFECT						(WM_USER + 2)
#define WM_POCESS_STATUS							(WM_USER + 3)
#define WM_LIVE_IMG_UPDATE							(WM_USER + 4)
#define UM_UPDATE_RECIPE							(WM_USER + 5)
#define	UM_SEND_MESSAGE_MAIN_DLG					(WM_USER + 6)
#define WM_BATCH_PROCESS_NEXT						(WM_USER + 7)

#define	MAX_CAMERA_COUNT			4
#define MAX_SCAN_COUNT				2
#define MAX_DIMENSION_COUNT			8
#define MAX_STAGE_HAND_COUNT		2
#define MAX_FRAM_COUNT				1024

#define SHARD_MEMORY_STRING_FRAMEBUFFER _T("SHARD_MEMORY_FRAMEBUFFER")

#define RECIPE_PATH					_T("C:\\RCutProject\\Recipe")
#define RECIPE_ALIGN_PATH			_T("C:\\RCutProject\\Align")
#define	LINK_FILE_NAME				_T("C:\\RCutProject\\Recipe\\PPIDLink.lst")
#define GLASSTYPE_IMAGE_PATH		_T("C:\\RcutProject\\Recipe\\GlassType")
#define PATH_LOGIMAGE				_T("D:\\Image\\Log\\")
#define PATH_DEBUGFULLIMAGE			_T("D:\\Image\\Log\\DebugFullImage\\")
#define	PATH_INSPECTOR				_T("C:\\RCutProject")
#define PATH_INSPECTION_DATA		_T("D:\\InspectionData\\")
#define RECIPE_HOLE_TEMPLATE_PATH	_T("C:\\RCutProject\\HoleIns")

#define CHKMAX(a,b)    (((a) > (b)) ? (a) : (b))
#define CHKMIN(a,b)    (((a) < (b)) ? (a) : (b))

#define MAX_PANEL_SIDE					4			// ¸é ¼ö 
#define	UPDN_TYPE						2			// »óÇÏ °°ÀÌ Àִ°æ¿ì 2 Çϳª¸¸ Àִ°æ¿ì 1

#define MAX_VIEWINFO_GRD_CNT		7
#define MAX_PROFILE_SETTING_COUNT	79
#define PROFILE_INSPECT_SIZE_A_C	13
#define PROFILE_INSPECT_SIZE_B_D	10
#define PROFILE_RCUT_SIZE			5
#define PROFILE_INSPECT_INDEX_A		33
#define PROFILE_INSPECT_INDEX_B		0
#define PROFILE_INSPECT_INDEX_C		10
#define PROFILE_INSPECT_INDEX_D		23
#define PROFILE_INSPECT_INDEX_CF	46
#define PROFILE_RCUT_INSPECT_INDEX_A	59
#define PROFILE_RCUT_INSPECT_INDEX_B	64
#define PROFILE_RCUT_INSPECT_INDEX_C	69
#define PROFILE_RCUT_INSPECT_INDEX_D	74

#define SHORT_SIDE_INSPECTION_POINT_OFFSET		1420
#define LONG_SIDE_INSPECTION_POINT_OFFSET		4770

namespace GLOBAL_DEFINE
{
	enum	ENTRY_VIEW {EV_VIEW_INFO=0, EV_VIEW_DEFECT, EV_VIEW_IMAGE, EV_VIEW_RECIPE, EV_VIEW_LIVE, EV_VIEW_HW, EV_EXIT, EV_VIEW_End};

	enum	LIGHT_TYPE{LIGHT_TYPE_TRANS=0,LIGHT_TYPE_REF,LIGHT_TYPE_NONE};
	enum	LIGHT_MAKER{MAKER_LCP=0,MAKER_AKP,MAKER_NONE};

	enum	CAMERA_DIR{CAMDIR_TOP=0,CAMDIR_BOTTOM,CAMDIR_NONE};	
	enum	CAMERA_INSPECTION_DIR{INSPECTDIR_FORWARD=0,INSPECTDIR_BACKWARD,INSPECTDIR_NONE};
	enum	CAMERA_SCANDIR	{SCANGLASS_X=0,SCANGLASS_Y,SCANGLASS_NONE};	
	enum	BOARD_TYPE{GRAB_LINK_BOARD=0,RADIENT_BOARD,SAP_BOARD,BOARDTYPE_NONE};

	enum	EmSplashCmd {emShow=0, emHide, emText};

	enum	ScanDirectionIns	{ SD_Forward = 0, SD_Backward, SD_Unknown };	// Glass ±âÁØ Scan ¹æÇâ.
	enum	DimensionDir		{ DIMENSION_A=0, DIMENSION_B, DIMENSION_C, DIMENSION_D,DIMENSION_A_DN, DIMENSION_B_DN, DIMENSION_C_DN, DIMENSION_D_DN, DIMENSION_NONE};
	enum	EM_CHIPPING_COMP{CHIP_AND=0,CHIP_OR,CHIP_NONE};
	enum	EM_CORNER_JUDGE{A_ZONE_CRACK=0,B_ZONE_CRACK,B_ZONE_BURR,C_ZONE_CRACK,C_ZONE_BURR, D_ZONE_CRACK, EDGE_THINCRACK, CHIP_WHITE};

	enum	UPDATE_SETTING_RCP{EM_GLASSINFO_RCP=0,EM_CUTAREA_RCP,EM_DIMEN_RCP,EM_SPLINE_RCP,EM_CORNER_RCP,EM_NOTCH_RCP,EM_VCR_RCP};

	enum	GlassDirection		{ GD_LeftTop = 0, GD_RightTop = 1, GD_LeftBottom = 10, GD_RightBottom = 11 };
	enum	ExpRegionType		{ ER_ALL=0, ER_AREA, ER_NONE};//130115

	enum	Procee_Mode			{PROC_MODE_AUTO=0,PROC_MODE_SIMULATION_ONESIDE,PROC_MODE_SIMULATION_SIDESHORT,PROC_MODE_SIMULATION_SIDELONG,PROC_MODE_SIMULATION_ALL};

	enum	Init_View_Command	{VIEW_RECIPE=0,VIEW_SCANIMAGE};
};
using namespace GLOBAL_DEFINE;

class CProfileOption
{
public:
	int				m_nProfileOff_C_X;
	int				m_nProfileOff_C_Y;
	int				m_nProfileOff_C_DN_X;
	int				m_nProfileOff_C_DN_Y;
	int				m_nProfileOff_A_X;
	int				m_nProfileOff_A_Y;
	int				m_nProfileOff_A_DN_X;
	int				m_nProfileOff_A_DN_Y;
	double			m_dProfileRadius[MAX_STAGE_HAND_COUNT][MAX_PROFILE_SETTING_COUNT];

	CProfileOption()
	{
		Reset();
	}
	void Reset()
	{
		m_nProfileOff_C_X = m_nProfileOff_C_Y = m_nProfileOff_C_DN_X = m_nProfileOff_C_DN_Y = 0;
		m_nProfileOff_A_X = m_nProfileOff_A_Y = m_nProfileOff_A_DN_X = m_nProfileOff_A_DN_Y = 0;
		ZeroMemory(m_dProfileRadius,sizeof(double)*MAX_STAGE_HAND_COUNT*MAX_PROFILE_SETTING_COUNT);
	}
};

class CRandomData
{
public:
	double		dMin;
	double		dMax;
	double		dLimit;

	CRandomData()
	{
		Reset();
	}
	void Reset()
	{
		dMin = dMax = dLimit = 0;
	}
};

class CRandomDataSet
{
public:
	CRandomData		Profile;
	CRandomData		ChamferUp;
	CRandomData		ChamferDn;

	CRandomDataSet()
	{
		Reset();
	}
	void Reset()
	{
		Profile.Reset();
		ChamferUp.Reset();
		ChamferDn.Reset();
	}
};

class CInspectOption
{
public:
	BOOL			bSaveNotchi;
	BOOL			bSaveCornerChip;
	BOOL			bSaveCornerSP;
	BOOL			bSaveSpline;
	BOOL			bSaveEdge;
	BOOL			bSaveDimension;
	BOOL			bSaveSplineChip;
	BOOL			bSaveCutArea;//20140611	
	BOOL			bSaveChipDefectImg;	
	int				nNotchNoDetSkip;		// Pixel
	int				nNotchDetSkip;		// Pixel
	int				nChamferInsHeight;
	int				nChamferSearchWidth;
	int				nChippingInsArea;	
	int				nCrackINsArea;
	int				nBrokenInsArea;

	// 20.11.14 - Candidate Filtering..
	int				nChippingInsMinSize;
	int				nCrackInsMinSize;
	int				nBrokenInsMinSize;
	int				nBurrInsMinSize;

	int				nChippingInsSideFilterRange;
	int				nCrackInsSideFilterRange;
	int				nBrokenInsSideFilterRnage;
	int				nBurrInsSideFilterRange;

	BOOL			bUseRandomData;
	CRandomDataSet	B_GrindLine;
	CRandomDataSet	C_GrindLine;
	CRandomDataSet	D_GrindLine;
	CRandomDataSet	A1_GrindLine;
	CRandomDataSet	A2_GrindLine;
	CRandomDataSet	A1_Rcut;
	CRandomDataSet	A2_Rcut;
	CRandomDataSet	C1_Rcut;
	CRandomDataSet	C2_Rcut;

	int				nAlignMarkRange;
	int				nAlignMarkRangeY;

	CInspectOption()
	{
		Reset();
	}
	void Reset()
	{
		bSaveNotchi = bSaveCornerChip = bSaveCornerSP = bSaveSpline = bSaveEdge = bSaveDimension = bSaveSplineChip = bSaveCutArea = FALSE;//20140611		
		bSaveChipDefectImg = FALSE;
		nNotchNoDetSkip = 10;
		nNotchDetSkip = 4;
		nChamferInsHeight = 100;
		nChamferSearchWidth = 30;
		nChippingInsArea = 100;
		nCrackINsArea = 200;
		nBrokenInsArea = 300;		
		nChippingInsMinSize = nCrackInsMinSize = nBrokenInsMinSize = nBurrInsMinSize = 5;
		nChippingInsSideFilterRange = nCrackInsSideFilterRange = nBrokenInsSideFilterRnage = nBurrInsSideFilterRange = 10;

		bUseRandomData = FALSE;
		B_GrindLine.Reset();
		C_GrindLine.Reset();
		D_GrindLine.Reset();
		A1_GrindLine.Reset();
		A2_GrindLine.Reset();
		A1_Rcut.Reset();
		A2_Rcut.Reset();
		C1_Rcut.Reset();
		C2_Rcut.Reset();		

		nAlignMarkRange = 100;
	}
};

typedef struct tagPROG_MSG
{
	int nJobIndex;
	int nSide; 
	int nState;
	int nDispLine;
}PROG_MSG;

struct _ST_MAPSETTINGS_INDEX
{
	int			m_nIndex[5][4];
};

struct _ST_MAPSETTINGS
{
	_ST_MAPSETTINGS_INDEX			m_nMapIndex[2];
};


class CInspectDefect;
class CDefect;
class CGlass_Data;
interface	IViewInterface2Parent
{
	virtual void		CommandExitButtonClick() = 0;
	virtual void		MapDefect_ReqDefectImage(CInspectDefect* pDefect,int nGlassDefectIdx) = 0;
	virtual CDefect		*ListDefect_ReqDefectImage(CInspectDefect* pDefect,int nGlassDefectIdx) = 0;

	virtual LPBYTE		IV2M_GetGrabBufferByDimension(DimensionDir eDim,int iVline) = 0;
	virtual BOOL		IV2M_SetLiveGrabCommand(DimensionDir eDim,BOOL bStop) = 0;
	virtual void		IV2M_InitView(Init_View_Command eVew) = 0;

	virtual void		IV2M_LoadImageFullFile(int iSide, CGlass_Data *pGlassData = NULL, std::function<void(BYTE)> _Func = nullptr) = 0;
	virtual void		IV2M_LoadImageFromFolder(int iSide, const CString& strFolderPath, CGlass_Data* pGlassData = NULL, std::function<void(BYTE)> _Func = nullptr) = 0;
	virtual BOOL		IV2M_SaveFullImage(CString strPath,int iSide,CPoint ptStart,int nLength) = 0;

	virtual BOOL		IV2M_RecipeChange(CString strRecipe) = 0;

	virtual	BOOL		MLight_SetLightControlValue(int iCon,int iCh, int nValue, BOOL bRef, int nScanIdx = 0, BOOL bAdjLight = TRUE) = 0;
	virtual void		MLight_OnOff(int iCon,int iCh,BOOL bValue) = 0;
	virtual int			MLight_GetLightControlValue(int iCon,int iCh, BOOL bRef) = 0;

	virtual BOOL		IV2M_InspectionProcess(DimensionDir eDim) = 0;
	virtual BOOL		IV2M_InspectionProcessAll(int iProceMode) = 0;

	virtual std::multimap<int, CPoint *> *IF2M_GetCADProfileLine(int iSide,int vStart,int vEnd)= 0;

};

interface	IUserDefectInterface2Parent
{
	virtual void		IU2P_DrawRect(BOOL bSet) = 0;
	virtual CRect		IU2P_GetCompareRect() = 0;
	virtual void		IU2P_DrawRefresh() = 0;

	virtual void		IE2P_SetExpArea(int iSide) = 0;
	virtual POINT		IE2P_GetFrameViewBasepoint() = 0;
	virtual void		IE2P_SetExpAreaTrackerReset() = 0;	
	virtual void		IE2P_SetExpAreaDlgClose() = 0;
};

#define IMAGE_WIDTH						8192//2048
#define IMAGE_HEIGHT					1024	
#define MAX_IMAGE_FRAME					100
#define MAX_IMAGE_FRAME_SHORT			100			// ÃÖ´ë ÇÁ·¹ÀÓ ¼ö 
#define MAX_IMAGE_FRAME_LONG			100			// ÃÖ´ë ÇÁ·¹ÀÓ ¼ö 

#define MAX_IMAGE_LINE_SHORT	MAX_IMAGE_FRAME_SHORT		  * IMAGE_HEIGHT // ÃÖ´ë ¶óÀμö 
#define MAX_IMAGE_LINE_LONG		MAX_IMAGE_FRAME_LONG		  * IMAGE_HEIGHT // ÃÖ´ë ¶óÀμö 
#define MAX_IMAGE_LINE			MAX_IMAGE_LINE_LONG
#define MAX_LIMIT_LINE			(MAX_IMAGE_FRAME - 1) * IMAGE_HEIGHT

#define MAX_IMAGE_LINE_MARGIN		(150 * IMAGE_HEIGHT) // ÃÖ´ë ¶óÀμö 

struct _ST_GDI_ITEM
{

	COLORREF	colorWhite;
	COLORREF	colorRed;
	COLORREF	colorYellow;
	COLORREF	colorGreen;
	COLORREF	colorBlue;
	COLORREF	colorBlack;
	COLORREF	colorLightGray;
	COLORREF	colorDarkGray;
	COLORREF	colorGray;
	COLORREF	colorTitle;
	COLORREF	colorLightBlue;
	COLORREF	colorViolet;
	COLORREF	colorLightYellow;
	COLORREF	colorOrange;
	COLORREF	colorLightRed;
	COLORREF	colorLightGreen;
	COLORREF	colorBrown;
	COLORREF    colorSky;


	CBrush		brushBk;
	CBrush		brushDarkGray;
	CBrush		brushWhite;
	CBrush		brushBlue;
	CBrush		brushLightBlue;
	CBrush		brushBlack;
	CBrush		brushRed;

	CBitmap		BkBitmap;
	CBrush		BrushBkPattern;
};

enum THICK_INS_METHOD{THICK_METHOD_NORMAL=0,THICK_METHOD_EXTRA};
enum THICKPOS_DIRECTION{THICKPOS_LEFT=0,THICKPOS_RIGHT,THICKPOS_TOP,THICKPOS_BOTTOM};
typedef struct STU_THICKPOS_
{	
	CRect			rect;
	int				iScan;
	int				iFrame;
	double			dThick;
	double			xCoordi;
	double			yCoordi;
	int				nLeftLine;
	int				nRightLine;
	int				nTopLine;
	int				nIndex;
	THICKPOS_DIRECTION	nDir;
	THICK_INS_METHOD	Insmethod;
	int				nChamferThres;
	int				nChipThres;
	int				nJudgeBase;
	int				nJudgeDiff_Plus;
	int				nJudgeDiff_Minus;
	int				nChipWidth;
	int				nChipHeight;

public:
	STU_THICKPOS_()
	{
		Reset();
	}	
	STU_THICKPOS_(STU_THICKPOS_ *pPos)
	{
		*this = *pPos;
	}	
	void Reset()
	{
		nDir = THICKPOS_LEFT;
		iFrame = 0;
		dThick = 0;
		iScan = 0;
		nLeftLine = nRightLine = nTopLine = 0;
		rect = CRect(0,0,0,0);
		xCoordi = yCoordi = 0.;
		nIndex = 0;
		Insmethod = THICK_METHOD_NORMAL;
		nChamferThres = nChipThres = nJudgeBase = nJudgeDiff_Plus = nJudgeDiff_Minus = 0;
		nChipWidth = nChipHeight = 0;
	}
}STU_THICKPOS, *pSTU_THICKPOS;

typedef struct STU_DIMENSIONPOS_
{	
	CRect			rect;	
	int				iFrame;
	int				nPixelTop;
	double			dSize;
	double			xCoordi;
	double			yCoordi;
	double			dPixelLeft;
	double			dPixelRight;
	double			dImageRight;
	int				iIndex;

public:
	STU_DIMENSIONPOS_()
	{		
		iFrame = iIndex = 0;				
		rect = CRect(0,0,0,0);
		xCoordi = yCoordi = dSize = 0.;		
		dPixelLeft = dPixelRight = dImageRight = 0.;
		nPixelTop = 0;
	}	
}STU_DIMENSIONPOS, *pSTU_DIMENSIONPOS;

typedef struct _INSPECTDIMENSION_BUFFER
{	
	int				iCam;
	int				iScan;	
	int				iIndex;
	int				iFrame;
	BOOL			bSuccess;
	DimensionDir	enSide;
	double			dLeft;
	double			dRight;
	double			dSize;
	LPBYTE			pOrg;
	CSize			szOrg;

	_INSPECTDIMENSION_BUFFER()
	{
		pOrg = NULL;
		Reset();
	}
	void Reset()
	{
		iCam = iScan = iIndex = iFrame = -1;
		enSide = DIMENSION_NONE;
		dLeft = dRight = dSize = 0;
		bSuccess = FALSE;
		if(pOrg != NULL)
			delete[] pOrg;
		pOrg=NULL;
		szOrg = CSize(0,0);
	}
	void Clear()
	{
		if(pOrg == NULL || szOrg.cx <= 0 || szOrg.cy <= 0)
			return;
		ZeroMemory(pOrg,sizeof(BYTE)*szOrg.cx*szOrg.cy);		
	}	
	void SetSize(CSize szRe)
	{
		if(pOrg != NULL && szRe.cx <= szOrg.cx && szRe.cy <= szOrg.cy)
			return;

		if(pOrg != NULL) delete[] pOrg,pOrg=NULL;
		szOrg = szRe;
		pOrg = new BYTE[szOrg.cx*szOrg.cy];		
		Clear();
	}
	void CopyBuffer(_INSPECTDIMENSION_BUFFER *pBuffer)
	{
		Reset();
		iCam = pBuffer->iCam;
		iScan = pBuffer->iScan;
		iFrame = pBuffer->iFrame;
		iIndex = pBuffer->iIndex;
		bSuccess = pBuffer->bSuccess;
		enSide = pBuffer->enSide;
		dLeft = pBuffer->dLeft;
		dRight = pBuffer->dRight;
		dSize = pBuffer->dSize;	
		szOrg = pBuffer->szOrg;

		if(pBuffer->pOrg != NULL && pBuffer->szOrg.cx > 0 && pBuffer->szOrg.cy > 0)
		{
			pOrg = new BYTE[szOrg.cx*szOrg.cy];
			CopyMemory(pOrg,pBuffer->pOrg,szOrg.cx*szOrg.cy);
		}		
	}
} INSPECTDIMENSION_BUFFER, *pINSPECTDIMENSION_BUFFER;

#define 	RANGE_VAL_COUNT  9
typedef struct STU_SPLINE_RESULT_
{	
	enum	EN_SPLINE_TYPE{SPLINE_RCUT=0,SPLINE_CCUT,SPLINE_NONE};		

	int				iCam;
	int				iScan;
	EN_SPLINE_TYPE	enType;		
	BOOL			bPos;
	double			dMinData;
	double			dMaxData;
	double			dAvg;
	double			dRangeVal[RANGE_VAL_COUNT];

public:
	STU_SPLINE_RESULT_()
	{				
		enType = SPLINE_NONE;
		bPos = TRUE;		
		dMinData = dMaxData = dAvg = 0.;
		iCam = iScan = 0;
		ZeroMemory(dRangeVal,sizeof(double)*RANGE_VAL_COUNT);//20140528
	}	
}STU_SPLINE_RESULT, *pSTU_SPLINE_RESULT;

typedef struct _INSPECTSPLINE_BUFFER
{	
	enum	SPLINE_SAVE_TYPE{SPLINE_TYPE_ORG=0,SPLINE_TYPE_RES};
	enum	EN_SPLINE_POSITION{SPLINE_TOPLEFT=0,SPLINE_TOPRIGHT,SPLINE_BOTTOMLEFT,SPLINE_BOTTOMRIGHT,SPLINE_POS_NONE};	

	int				iCam;
	int				iScan;	
	int				iFrame;
	int				iType;
	EN_SPLINE_POSITION	ePosition;
	BOOL			bPos;	
	double			dMinVal;
	double			dMaxVal;
	double			dAvgVal;
	double			dAvgThick;
	BOOL			bSuccess;

	LPBYTE			pOrg;	
	LPBYTE			pRes;
	CSize			szOrg;	
	CSize			szRes;

	_INSPECTSPLINE_BUFFER()
	{
		pOrg = pRes = NULL;
		Reset();
	}
	void Reset()
	{
		ePosition = SPLINE_POS_NONE;
		iCam = iScan = iType = iFrame = -1;
		bSuccess = bPos = FALSE;
		dMinVal = dMaxVal = dAvgVal = dAvgThick = 0.;
		if(pOrg != NULL)
			delete[] pOrg;
		pOrg=NULL;		
		if(pRes != NULL)
			delete[] pRes;
		pRes=NULL;
		szOrg = szRes = CSize(0,0);
	}
	void Clear(SPLINE_SAVE_TYPE nOpt)
	{
		switch(nOpt)
		{
		case SPLINE_TYPE_ORG:	
			if(pOrg != NULL && szOrg.cx > 0 && szOrg.cy > 0)
				ZeroMemory(pOrg,sizeof(BYTE)*szOrg.cx*szOrg.cy);
			break;
		case SPLINE_TYPE_RES:
			if(pRes != NULL && szRes.cx > 0 && szRes.cy > 0)
				ZeroMemory(pRes,sizeof(BYTE)*szRes.cx*szRes.cy);					
			break;
		}		
	}
	void SetBuffer(LPBYTE pBuf,CSize szImg,SPLINE_SAVE_TYPE nOpt)
	{
		if(pBuf == NULL || szImg.cx <= 0 || szImg.cy <= 0)
			return;		

		SetSize(szImg,nOpt);

		switch(nOpt)
		{
		case SPLINE_TYPE_ORG:
			if(pOrg != NULL && szOrg.cx > 0 && szOrg.cy > 0)			
				CopyMemory(pOrg,pBuf,sizeof(BYTE)*szOrg.cx*szOrg.cy);	
			break;
		case SPLINE_TYPE_RES:
			if(pRes != NULL && szRes.cx > 0 && szRes.cy > 0)			
				CopyMemory(pRes,pBuf,sizeof(BYTE)*szRes.cx*szRes.cy);		
			break;
		}		
	}
	void SetSize(CSize szRe,SPLINE_SAVE_TYPE nOpt)
	{
		switch(nOpt)
		{
		case SPLINE_TYPE_ORG:
			if(pOrg != NULL && szRe.cx <= szOrg.cx && szRe.cy <= szOrg.cy)
				return;
			if(pOrg != NULL) delete[] pOrg,pOrg=NULL;
			szOrg = szRe;
			pOrg = new BYTE[szOrg.cx*szOrg.cy];	
			break;
		case SPLINE_TYPE_RES:
			if(pRes != NULL && szRe.cx <= szRes.cx && szRe.cy <= szRes.cy)
				return;
			if(pRes != NULL) delete[] pRes,pRes=NULL;
			szRes = szRe;
			pRes = new BYTE[szRes.cx*szRes.cy];
			break;
		}
		Clear(nOpt);
	}
	void CopyBuffer(_INSPECTSPLINE_BUFFER *pBuffer)
	{
		Reset();

		if(pBuffer == NULL)
			return;

		ePosition = pBuffer->ePosition;
		iCam = pBuffer->iCam;
		iScan = pBuffer->iScan;
		iFrame = pBuffer->iFrame;
		iType = pBuffer->iType;
		bSuccess = pBuffer->bSuccess;
		bPos = pBuffer->bPos;
		dMinVal = pBuffer->dMinVal;
		dMaxVal = pBuffer->dMaxVal;
		dAvgVal = pBuffer->dAvgVal;
		dAvgThick = pBuffer->dAvgThick;
		szOrg = pBuffer->szOrg;	
		szRes = pBuffer->szRes;

		if(pBuffer->pOrg != NULL && pBuffer->szOrg.cx > 0 && pBuffer->szOrg.cy > 0)
		{
			pOrg = new BYTE[szOrg.cx*szOrg.cy];
			CopyMemory(pOrg,pBuffer->pOrg,szOrg.cx*szOrg.cy);
		}		
		if(pBuffer->pRes != NULL && pBuffer->szRes.cx > 0 && pBuffer->szRes.cy > 0)
		{
			pRes = new BYTE[szRes.cx*szRes.cy];
			CopyMemory(pRes,pBuffer->pRes,szRes.cx*szRes.cy);
		}		
	}
} INSPECTSPLINE_BUFFER, *pINSPECTSPLINE_BUFFER;

#define 	NOTCH_RANGE_VAL_MAX_COUNT  100//20140528
typedef struct STU_NOTCH_RESULT_
{	
	int				iCam;
	int				iScan;		
	double			dMaxData;
	double			dAvg;
	double			dRangeVal[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	CPoint			pointCAD[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	CPoint			pointIMG[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	double			dRangeVal_Dy[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	CPoint			pointCAD_Dy[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	CPoint			pointIMG_Dy[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	double			dRangeVal_Cham[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	CPoint			pointCAD_Cham[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	CPoint			pointIMG_Cham[NOTCH_RANGE_VAL_MAX_COUNT];//20140528
	double			dAvgThick;
	double			dDx;
	double			dDy;
	double			dAlignX;
	double			dAlignY;
	double			dNotchX;
	double			dNotchY;
	int				nNotchInsCount;//20140528

public:
	STU_NOTCH_RESULT_()
	{			
		dMaxData = dAvg = dAvgThick = 0.;
		iCam = iScan = 0;
		ZeroMemory(dRangeVal,sizeof(double)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(pointCAD,sizeof(CPoint)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(pointIMG,sizeof(CPoint)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(dRangeVal_Dy,sizeof(double)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(pointCAD_Dy,sizeof(CPoint)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(pointIMG_Dy,sizeof(CPoint)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(dRangeVal_Cham,sizeof(double)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(pointCAD_Cham,sizeof(CPoint)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		ZeroMemory(pointIMG_Cham,sizeof(CPoint)*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
		dDx = dDy = 0.;
		dAlignX = dAlignY = dNotchX = dNotchY = 0.;	
		nNotchInsCount = NOTCH_RANGE_VAL_MAX_COUNT;//20140528
	}	
}STU_NOTCH_RESULT, *pSTU_NOTCH_RESULT;

typedef struct _INSPECTNOTCH_BUFFER
{	
	int				iCamIdx;
	int				iScanIdx;
	int				iFrame;	
	BOOL			bSuccess;
	DimensionDir	enSide;
	double			dAvg;
	double			dMax;

	LPBYTE			pOrg;
	CSize			szOrg;
	LPBYTE			pOrg_Dy;
	CSize			szOrg_Dy;

	_INSPECTNOTCH_BUFFER()
	{
		pOrg = NULL;
		pOrg_Dy = NULL;
		Reset();
	}
	void Reset()
	{
		iCamIdx = iScanIdx = iFrame = -1;
		enSide = DIMENSION_NONE;
		dAvg = dMax = 0;
		bSuccess = FALSE;
		if(pOrg != NULL)
			delete[] pOrg;
		pOrg=NULL;
		szOrg = CSize(0,0);
		if(pOrg_Dy != NULL)
			delete[] pOrg_Dy;
		pOrg_Dy=NULL;
		szOrg_Dy = CSize(0,0);
	}
	void Clear()
	{
		if(pOrg == NULL || szOrg.cx <= 0 || szOrg.cy <= 0)
			return;
		ZeroMemory(pOrg,sizeof(BYTE)*szOrg.cx*szOrg.cy);		
	}	
	void Clear_Dy()
	{
		if(pOrg_Dy == NULL || szOrg_Dy.cx <= 0 || szOrg_Dy.cy <= 0)
			return;
		ZeroMemory(pOrg_Dy,sizeof(BYTE)*szOrg_Dy.cx*szOrg_Dy.cy);		
	}
	void SetSize(CSize szRe)
	{
		if(szRe.cx <= 0 || szRe.cy <=0)
			return;

		if(pOrg != NULL) delete[] pOrg,pOrg=NULL;
		szOrg = szRe;
		pOrg = new BYTE[szOrg.cx*szOrg.cy];		
		Clear();
	}
	void SetSize_Dy(CSize szRe)
	{
		if(szRe.cx <= 0 || szRe.cy <=0)
			return;

		if(pOrg_Dy != NULL) delete[] pOrg_Dy,pOrg_Dy=NULL;
		szOrg_Dy = szRe;
		pOrg_Dy = new BYTE[szOrg_Dy.cx*szOrg_Dy.cy];		
		Clear_Dy();
	}
	void CopyBuffer(_INSPECTNOTCH_BUFFER *pBuffer)
	{
		Reset();
		iCamIdx = pBuffer->iCamIdx;
		iScanIdx = pBuffer->iScanIdx;
		iFrame = pBuffer->iFrame;		
		bSuccess = pBuffer->bSuccess;
		enSide = pBuffer->enSide;
		dAvg = pBuffer->dAvg;
		dMax = pBuffer->dMax;		
		szOrg = pBuffer->szOrg;

		if(pBuffer->pOrg != NULL && pBuffer->szOrg.cx > 0 && pBuffer->szOrg.cy > 0)
		{
			pOrg = new BYTE[szOrg.cx*szOrg.cy];
			CopyMemory(pOrg,pBuffer->pOrg,szOrg.cx*szOrg.cy);
		}				
	}
	void CopyBuffer_Dy(_INSPECTNOTCH_BUFFER *pBuffer)
	{
		Reset();
		iCamIdx = pBuffer->iCamIdx;
		iScanIdx = pBuffer->iScanIdx;
		iFrame = pBuffer->iFrame;		
		bSuccess = pBuffer->bSuccess;
		enSide = pBuffer->enSide;
		dAvg = pBuffer->dAvg;
		dMax = pBuffer->dMax;		
		szOrg_Dy = pBuffer->szOrg_Dy;

		if(pBuffer->pOrg_Dy != NULL && pBuffer->szOrg_Dy.cx > 0 && pBuffer->szOrg_Dy.cy > 0)
		{
			pOrg_Dy = new BYTE[szOrg_Dy.cx*szOrg_Dy.cy];
			CopyMemory(pOrg_Dy,pBuffer->pOrg_Dy,szOrg_Dy.cx*szOrg_Dy.cy);
		}				
	}
} INSPECTNOTCH_BUFFER, *pINSPECTNOTCH_BUFFER;

typedef struct STU_CORNER_RESULT_
{	
	enum	EN_CORNER_TYPE{CORNER_RCUT=0,CORNER_CCUT,CORNER_NONE};

	int				iCam;
	int				iScan;
	EN_CORNER_TYPE	enType;	
	BOOL			bPos;
	double			dResultWidth;
	double			dResultHeight;

public:
	STU_CORNER_RESULT_()
	{		
		enType = CORNER_NONE;
		bPos = TRUE;		
		dResultWidth = dResultHeight = 0.;
		iCam = iScan = 0;
	}	
}STU_CORNER_RESULT, *pSTU_CORNER_RESULT;

typedef struct _INSPECTFULLIMAGE_BUFFER
{	
	int				iCamIdx;
	int				iScanIdx;		
	LPBYTE			pImage;
	CSize			szImage;

	_INSPECTFULLIMAGE_BUFFER()
	{
		pImage = NULL;
		Reset();
	}
	void Reset()
	{		
		iCamIdx = iScanIdx = -1;
		if(pImage != NULL)
			delete[] pImage;
		pImage=NULL;
		szImage = CSize(0,0);		
	}
	void Clear()
	{
		if(pImage == NULL || szImage.cx <= 0 || szImage.cy <= 0)
			return;
		ZeroMemory(pImage,sizeof(BYTE)*szImage.cx*szImage.cy);		
	}	
	void SetSize(CSize szRe)
	{
		if(pImage != NULL && szRe.cx <= szImage.cx && szRe.cy <= szImage.cy)
		{
			Clear();
			return;
		}

		if(pImage != NULL) delete[] pImage,pImage=NULL;
		szImage = szRe;
		pImage = new BYTE[szImage.cx*szImage.cy];		
		Clear();
	}
} INSPECTFULLIMAGE_BUFFER, *pINSPECTFULLIMAGE_BUFFER;