#pragma once

#include "cv.h"
#include "highgui.h"
#include "opencv.hpp"
#include "core.hpp"
#include <vector>
#include <algorithm>//20140528
#include "HardwareSettings.h"

#define MAX_STRING_LENGTH			1024

typedef struct tagJUDGEEDGE
{
	BOOL bError;			// 错误与否…
	int  nRefernce;			// 标准 	
	int  nTolPlus;			// +容许误差
	int  nTolMinus;			// -容许误差
	int  nSlant;			// 斜线
}JUDGEEDGE, *PJUDGEEDGE;

typedef struct tagUserDefectArea
{
	int x;
	int y;
	int area_width;
	int area_height;
	int defect_threshold;
	int defect_dilation;
	int defect_width;
	int defect_height;

	void clear(void)
	{
		x = 0;
		y = 0;
		area_width = 0;
		area_height = 0;
		defect_threshold = 0;
		defect_dilation = 0;
		defect_width = 0;
		defect_height = 0;
	}

	tagUserDefectArea(void)
	{
		clear();
	}
}ST_USER_DEFECT_AREA;

typedef struct tagEXECPTION_AREA
{
	int		nAreaType;
	CRect	rc;			// 区域位置（Mark 原点）	
	SIZE	szErrSize;  // 在这个领域适用的Size    
	int		nAppDefect; // 适用的Defect种类
	int		nDetectLimitedArea;	// 是否使用自定义ROI

	void Init()
	{
		nAreaType  = 0;
		nAppDefect = 0;
		nDetectLimitedArea = 0;
		rc = CRect(0,0,0,0);
		szErrSize.cx = 0;
		szErrSize.cy = 0;		
	};

	void CopyData(tagEXECPTION_AREA *pExp)
	{
		nAreaType = pExp->nAreaType;
		rc = pExp->rc;
		szErrSize = pExp->szErrSize;
		nAppDefect = pExp->nAppDefect;
		nDetectLimitedArea = pExp->nDetectLimitedArea;	
	}

}EXECPTION_AREA;

typedef std::vector<EXECPTION_AREA*>  EXCEPTION_AREA_LIST;
typedef EXCEPTION_AREA_LIST::iterator itEXCEPTION_AREA_LIST;
typedef std::vector<ST_USER_DEFECT_AREA> USER_DEFECT_AREA_LIST;
typedef std::vector<ST_USER_DEFECT_AREA>::iterator itUSER_DEFECT_AREA_LIST;

typedef struct stLinkList
{
	CString m_strUpperName;
	CString m_strStepName;
	CString m_strInsName;

public:
	stLinkList()
	{
		reset();
	}
	void reset()
	{
		m_strUpperName = _T("");
		m_strStepName = _T("");
		m_strInsName = _T("");		
	}
} LinkList, *pLinkList;
typedef std::vector<LinkList*>				VectorLinkList;
typedef std::vector<LinkList*>::iterator	VectorLinkListIt;

class CRECIPE_INFO_PARM
{	
public:
	CRECIPE_INFO_PARM();
	virtual ~CRECIPE_INFO_PARM(void);
	CRECIPE_INFO_PARM& operator=(CRECIPE_INFO_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	void		SetRecipeName(CString strRecipe);
	void		SetRecipeFileName(CString strFile);

	void		SetRecipeFileNameBackUp(CString strFile);
	CString		GetRecipeName();
	CString		GetRecipeFileName();


public:
	TCHAR		m_strRecipeName[MAX_STRING_LENGTH];			  // 配方名称
	TCHAR		m_strRecipeFileName[MAX_STRING_LENGTH];		  // 配方文件名称

	TCHAR		m_strRecipeFileNameBackUp[MAX_STRING_LENGTH]; // 配方文件名备份
	int			m_nSoftRevision;			
};

typedef struct _STU_EXTRA_CHIP_REG
{
	DimensionDir	enSide;
	BOOL			bTB;
	int				nStartY;
	int				nYSize;			
	int				nSizeX;
	int				nChamferThres;
	int				nChipThres;
	int				nJudgeBase;
	int				nJudgeDiff;
	int				nChipWidth;
	int				nChipHeight;

	_STU_EXTRA_CHIP_REG()
	{
		Reset();
	}
	void Reset()
	{
		enSide = DIMENSION_NONE;
		nStartY = nYSize = 0;		
		nSizeX = nChamferThres = nChipThres = 0;
		nJudgeBase = nJudgeDiff = 0;
		nChipWidth = nChipHeight = 0;
	}

} STU_EXTRA_CHIP_REG, *pSTU_EXTRA_CHIP_REG;

typedef struct _STU_CUTAREA_EXP_POS
{
	DimensionDir	enSide;
	int				nPosY;
	int				nSize;	
	ExpRegionType	enERType;
	int				nPosX;
	int				nSizeX;

	_STU_CUTAREA_EXP_POS()
	{
		Reset();
	}
	void Reset()
	{
		enSide = DIMENSION_NONE;
		nPosY = nSize = 0;
		enERType = ER_NONE;
		nPosX = nSizeX = 0;
	}

} STU_CUTAREA_EXP_POS, *pSTU_CUTAREA_EXP_POS;

typedef struct _STU_CUTAREA_PARM
{
	BOOL		m_bCutArea;			
	int			m_nThresT,m_nThresB;	
	int			m_nSearchWidth;	
	int			m_nCalArea;	

	_STU_CUTAREA_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_bCutArea = FALSE;
		m_nThresT = m_nThresB = m_nSearchWidth = m_nCalArea = 0;		
	}

} STU_CUTAREA_PARM, *pSTU_CUTAREA_PARM;

typedef struct _STU_CUTAREA_ALIGN_MARK//20140611
{
	BOOL		m_bCutAreaAlignMark;		
	int			m_nMarkXPos[2];
	int			m_nMarkXSize[2];
	int			m_nMarkYPos[2];
	int			m_nMarkYSize[2];
	int			m_nAlign2GlassPos;

	_STU_CUTAREA_ALIGN_MARK()
	{
		Reset();
	}
	void Reset()
	{
		m_bCutAreaAlignMark = FALSE;
		for (int i=0; i<2; i++)
		{
			m_nMarkXPos[i] = 0;
			m_nMarkXSize[i] = 0;
			m_nMarkYPos[i] = 0;
			m_nMarkYSize[i] = 0;			
		}
		m_nAlign2GlassPos = 0;			
	}

} STU_CUTAREA_ALIGN_MARK, *pSTU_CUTAREA_ALIGN_MARK;

typedef struct _STU_CHIP_PARM
{
	BOOL		m_bChipping;
	int			m_nThresMode;		// 0:Fixed,1:First Line,2:Max Line
	int			m_nChippingInsArea;
	int			m_nCrackINsArea;
	int			m_nBrokenInsArea;
	int			m_nChippingThres_T;
	int			m_nChippingThres_T_White;
	int			m_nChipDiffThres;

	int			m_nChippingThres_B;
	int			m_nChippingThres_T_L;
	int			m_nChippingThres_B_L;
	int			m_nCrackThres;
	int			m_nBrokenThres;

	// 20.11.14 - Candidate Filtering..
	int			m_nChippingInsMinSize;
	int			m_nCrackInsMinSize;
	int			m_nBrokenInsMinSize;
	int			m_nBurrInsMinSize;

	int			m_nChippingInsSideFilterRange;
	int			m_nCrackInsSideFilterRange;
	int			m_nBrokenInsSideFilterRnage;
	int			m_nBurrInsSideFilterRange;

	_STU_CHIP_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_nThresMode = 0;
		m_bChipping = FALSE;		
		m_nChippingInsArea = m_nChippingThres_T = m_nChippingThres_B = 0;
		m_nChippingThres_T_White = 255;
		m_nCrackINsArea = m_nBrokenInsArea = 0;
		m_nChippingThres_T_L = m_nChippingThres_B_L = 0;		
		m_nCrackThres = m_nBrokenThres = 0;
		m_nChipDiffThres = 255;

		m_nChippingInsMinSize = m_nCrackInsMinSize = m_nBrokenInsMinSize = m_nBurrInsMinSize = 5;

		m_nChippingInsSideFilterRange = m_nCrackInsSideFilterRange = m_nBrokenInsSideFilterRnage = m_nBurrInsSideFilterRange = 10;
	}

} STU_CHIP_PARM, *pSTU_CHIP_PARM;

class CCUTAREA_PARM
{	
public:
	CCUTAREA_PARM();
	virtual ~CCUTAREA_PARM(void);
	CCUTAREA_PARM& operator=(CCUTAREA_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();	
	CString		GetFileString(void *pValue);
	BOOL		GetCutAreaUse(int iPos);	
	BOOL		GetChipUse(int iPos);		
	BOOL		GetCutAreaAlignMarkUse(int iPos);//20140611

	pSTU_CUTAREA_PARM	GetCutAreaParm(int iPos)
	{
		if(iPos>=0 && iPos<MAX_DIMENSION_COUNT)
			return &m_stuCutAreaParm[iPos];
		else
			return NULL;		
	}
	pSTU_CHIP_PARM		GetChipParm(int iPos)
	{		
		if(iPos>=0 && iPos<MAX_DIMENSION_COUNT)
			return &m_stuChipParm[iPos];
		else
			return NULL;						
	}
	std::vector<STU_CUTAREA_EXP_POS>	*GetExpArea(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecCutAreaExpPos[iPos]:NULL;}

	pSTU_CUTAREA_ALIGN_MARK		GetCutAreaAlignMark(int iPos)//20140611
	{		
		if(iPos>=0 && iPos<MAX_DIMENSION_COUNT)
			return &m_stuCutAreaAlignMark[iPos];
		else
			return NULL;						
	}

public:	
	STU_CUTAREA_PARM	m_stuCutAreaParm[MAX_DIMENSION_COUNT];
	STU_CHIP_PARM		m_stuChipParm[MAX_DIMENSION_COUNT];
	std::vector<STU_CUTAREA_EXP_POS> m_vecCutAreaExpPos[MAX_DIMENSION_COUNT];
	STU_CUTAREA_ALIGN_MARK m_stuCutAreaAlignMark[MAX_DIMENSION_COUNT];//20140611
};

class CCORNER_PARM
{	
public:
	CCORNER_PARM();
	virtual ~CCORNER_PARM(void);
	CCORNER_PARM& operator=(CCORNER_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	CString		GetFileString(void *pValue);

public:	
	BOOL		m_bSaveImage;	

	BOOL		m_bUse;
	int			m_Thres[MAX_DIMENSION_COUNT];	
};

enum DIMEN_FIND_TYPE{DIM_TYPE_PATTERN=0,DIM_TYPE_BMPOS,DIM_TYPE_NONE};
typedef struct _STU_DI_POS
{
	int			nBasePosX;
	int			nBasePosY;
	int			nSearchX;
	int			nSearchY;

	_STU_DI_POS()
	{
		nBasePosX = nBasePosY = nSearchX = nSearchY = 0;
	}	
} STU_DI_POS, *pSTU_DI_POS;

typedef struct _STU_DIMEN_INS_PRM
{
	BOOL		m_bUsePos;		
	int			m_nCamDir;
	int			m_nJudgeSetSize;
	int			m_nJudgeSizeRange;	
	int			m_nOffset;
	int			m_nDetThres;
	DIMEN_FIND_TYPE			m_enDimenType;

	_STU_DIMEN_INS_PRM()
	{
		Reset();
	}
	void Reset()
	{
		m_bUsePos = FALSE;
		m_nJudgeSetSize = m_nJudgeSizeRange = m_nOffset = m_nDetThres = m_nCamDir = 0;
		m_enDimenType = DIM_TYPE_NONE;
	}
} STU_DIMEN_INS_PRM, *pSTU_DIMEN_INS_PRM;

class CDIMENSION_PARM
{	
public:
	CDIMENSION_PARM();
	virtual ~CDIMENSION_PARM(void);
	CDIMENSION_PARM& operator=(CDIMENSION_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	CString		GetFileString(void *pValue);
	BOOL		GetDimenUse(int iPos);

	pSTU_DIMEN_INS_PRM		GetDimenIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_DimInsParm[iPos]:NULL;}
	std::vector<STU_DI_POS>	*GetDimenPos(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecDiPosition[iPos]:NULL;}

public:				
	BOOL					m_bSaveDimImage;
	STU_DIMEN_INS_PRM		m_DimInsParm[MAX_DIMENSION_COUNT];
	std::vector<STU_DI_POS> m_vecDiPosition[MAX_DIMENSION_COUNT];	
};

typedef struct _STU_SPLINE_CHIP_POS
{
	enum MAKE_IMAGE_METHOD{MAKE_METHOD_LINEAR=0,MAKE_METHOD_REGRESSION,MAKE_METHOD_NONE};
	enum MAKE_IMAGE_POS{MAKE_IMAGE_POS_CCUT=0,MAKE_IMAGE_POS_RCUT,MAKE_IMAGE_POS_NONE};
	enum SPLINE_INS_DIRECTION{SPLINE_INS_DIRECTION_X=0,SPLINE_INS_DIRECTION_Y,SPLINE_INS_DIRECTION_NONE};

	BOOL		bUse;	
	int			nStartX;
	int			nEndX;	
	int			nThres;
	int			nFindThres;	
	int			nInsRange;
	int			nSkipDist;
	MAKE_IMAGE_METHOD emMethod;
	MAKE_IMAGE_POS	emPos;
	SPLINE_INS_DIRECTION emDir;

	_STU_SPLINE_CHIP_POS()
	{
		Reset();
	}
	void Reset()
	{
		bUse = FALSE;
		nStartX = nEndX = nThres = nFindThres = nInsRange = nSkipDist = 0;
		emMethod = MAKE_METHOD_NONE;
		emPos = MAKE_IMAGE_POS_NONE;	
		emDir = SPLINE_INS_DIRECTION_NONE;
	}
} STU_SPLINE_CHIP_POS, *pSTU_SPLINE_CHIP_POS;

typedef struct _STU_SPLINE_CHIP_PARM
{	
	BOOL		m_bSplineChip;		
	int			m_nChipSize_Y;
	int			m_nChipSize_X;
	BOOL		m_bChipJudgeAnd;
	int			m_nChipInsArea;
	int			m_nChipThres;	
	BOOL		m_bCornerUse;
	int			m_nCornerThres;	
	int			m_nCornerRange;
	double		m_dChipStartTheta;
	double		m_dChipEndTheta;
	double		m_dChipDistTheta;

	_STU_SPLINE_CHIP_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_bSplineChip = FALSE;
		m_bChipJudgeAnd = FALSE;
		m_nChipSize_X = m_nChipSize_Y = 0;		
		m_nChipInsArea = m_nChipThres = 0;
		m_bCornerUse = m_nCornerThres = m_nCornerRange = 0;
		m_dChipDistTheta = m_dChipEndTheta = m_dChipDistTheta = 0;
	}
} STU_SPLINE_CHIP_PARM, *pSTU_SPLINE_CHIP_PARM;

enum	EM_SPLINE_TYPE{EM_SP_CCUT=0,EM_SP_RCUT,EM_SP_NONE};
typedef struct _STU_SPLINE_INS_PARM
{
	BOOL		m_bSpline;	
	BOOL		m_bSplinePointJudge;	
	int			m_DetMinPointDist;
	
	int			m_nStartCornerSize_Y;
	int			m_nStartCornerRadius_um;

	int			m_nEndCornerSize_Y;
	int			m_nEndCornerRadius_um;

	int			m_DetMinDist;
	int			m_nLineThres;
	EM_SPLINE_TYPE	m_emSPType;
	BOOL		m_bSplineCorner;

	int			m_nStartChamferSize;
	int			m_nEndChamferSize;

	_STU_SPLINE_INS_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_bSpline = FALSE;
		m_bSplinePointJudge = FALSE;
		m_DetMinPointDist = 50;

		m_nStartCornerSize_Y = 0;
		m_nStartCornerRadius_um = 0;

		m_nEndCornerSize_Y = 0;
		m_nEndCornerRadius_um = 0;

		m_nLineThres = 0;	
		m_DetMinDist = 50;
		m_emSPType = EM_SP_NONE;
		m_bSplineCorner = FALSE;

		m_nStartChamferSize = -1;
		m_nEndChamferSize = -1;
	}
} STU_SPLINE_INS_PARM, *pSTU_SPLINE_INS_PARM;

class CSPLINE_PARM
{	
public:
	CSPLINE_PARM();
	virtual ~CSPLINE_PARM(void);
	CSPLINE_PARM& operator=(CSPLINE_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	CString		GetFileString(void *pValue);
	BOOL		GetSplineUse(int iPos);
	BOOL		GetSplineUsePointJudge(int iPos);
	BOOL		GetSplineChipUse(int iPos);

	pSTU_SPLINE_INS_PARM	GetSplineIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_SP_InsParm[iPos]:NULL;}
	pSTU_SPLINE_CHIP_PARM	GetSplineChipIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_SP_ChipParm[iPos]:NULL;}
	std::vector<STU_SPLINE_CHIP_POS>	*GetSplineChipPos(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecSplineChip[iPos]:NULL;}

public:	
	BOOL						m_bSP_SaveImg;
	STU_SPLINE_INS_PARM			m_SP_InsParm[MAX_DIMENSION_COUNT];
	STU_SPLINE_CHIP_PARM		m_SP_ChipParm[MAX_DIMENSION_COUNT];
	std::vector<STU_SPLINE_CHIP_POS> m_vecSplineChip[MAX_DIMENSION_COUNT];	
};

typedef struct _STU_NOTCH_POS//20140528
{
	int			nPosX;
	int			nPosY;

	_STU_NOTCH_POS()
	{
		nPosX = nPosY = 0;
	}	
} STU_NOTCH_POS, *pSTU_NOTCH_POS;

enum EM_NOTCH_INS_DIR{INS_DIR_NORMAL = 0, INS_DIR_DY, INS_DIR_NONE};
typedef struct _STU_NOTCH_DATA
{
	BOOL		bChipIns;
	BOOL		bSizeIns;
	int			nChipDiff;	
	int			nSizeDiff;
	int			nDetThres;		
	int			nSizeThres;
	int			nChipThres;
	double		dBlank2EdgeRatio;
	int			nVStart;
	int			nVSize;
	int			nMarkXPos[2];
	int			nMarkXSize[2];
	int			nMarkYPos[2];
	int			nMarkYSize[2];
	int			nAlign2GlassPos;
	int			nJudgeBaseWidth;
	int			nJudgeDiffWidth;

	int			nSkipSize;
	BOOL		bSpChipIns[2];
	int			nSpChipSize[2];

	BOOL		bPointInsDimensionJudge;//20140528
	BOOL		bPointInsChamferJudge;//20140721
	int			nPointInsAveCount;//20140528

	_STU_NOTCH_DATA()
	{
		Reset();
	}
	void Reset()
	{
		bChipIns = bSizeIns = FALSE;
		nChipDiff = nSizeDiff = 0;
		nDetThres = nSizeThres = 0;
		nChipThres = nVStart = nVSize = 0;	
		ZeroMemory(nMarkXPos,sizeof(int)*2);
		ZeroMemory(nMarkXSize,sizeof(int)*2);
		ZeroMemory(nMarkYPos,sizeof(int)*2);
		ZeroMemory(nMarkYSize,sizeof(int)*2);				
		nJudgeBaseWidth = nJudgeDiffWidth = 0;
		nAlign2GlassPos = 0;
		nSkipSize = 0;
		dBlank2EdgeRatio = 0.;
		ZeroMemory(bSpChipIns,sizeof(BOOL)*2);
		ZeroMemory(nSpChipSize,sizeof(int)*2);
		bPointInsDimensionJudge = FALSE;//20140721
		bPointInsChamferJudge = FALSE;//20140721
		nPointInsAveCount = 5;
	}

} STU_NOTCH_DATA, *pSTU_NOTCH_DATA;

#define MAX_NOTCH_INS_POS_COUNT 100//20140528
class CNOTCH_PARM
{	
public:
	CNOTCH_PARM();
	virtual ~CNOTCH_PARM(void);
	CNOTCH_PARM& operator=(CNOTCH_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	CString		GetFileString(void *pValue);	
	BOOL		GetNotchSizeUse(int iPos);
	BOOL		GetNotchChipUse(int iPos);

	pSTU_NOTCH_DATA	GetNotchIns(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_NotchParm[iPos]:NULL;}	
	std::vector<CPoint>	*GetNotchPos(int iPos){return iPos>=0&&iPos<MAX_DIMENSION_COUNT?&m_vecNotchPosition[iPos]:NULL;}//20140528

public:
	STU_NOTCH_DATA m_NotchParm[MAX_DIMENSION_COUNT];
	std::vector<CPoint> m_vecNotchPosition[MAX_DIMENSION_COUNT];//20140528
};

typedef struct _SortCPointYPos {//20140528
	BOOL operator() (CPoint pt1, CPoint pt2) { return (pt1.y < pt2.y);}
} SortCPointYPos;


class CVCR_PARM
{	
public:
	CVCR_PARM();
	virtual ~CVCR_PARM(void);
	CVCR_PARM& operator=(CVCR_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	CString		GetFileString(void *pValue);
	CRect		GetRect();

public:
	BOOL		m_bVCR;	
	BOOL		m_bAlarm;
	BOOL		m_bSetResult;
	int			m_nVCPosY;
	int			m_nVCPosX;
	int			m_nHeight;
	int			m_nWidth;
	BOOL		m_nCamDir;
};

class CETC_PARM
{	
public:
	CETC_PARM();
	virtual ~CETC_PARM(void);
	CETC_PARM& operator=(CETC_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile,int nIdx);
	BOOL		WriteRecipe(CConfig *pFile,int nIdx);

public:
	void		Reset();
	CString		GetFileString(void *pValue,int nIdx);

public:	
	int			m_nGlassFindthres_Top;
	int			m_nGlassFindHeight_Top;
	int			m_nGlassFindthres_Left;
	int			m_nGlassFindWidth_Left;	
	int			m_nGlassLeftLineMargin[2];	
};
//park
enum LIGHT_CONTROL_METHOD{LIGHT_CONTROL_METHOD_AUTO=0,LIGHT_CONTROL_METHOD_MANUAL,LIGHT_CONTROL_METHOD_NONE};

#define		LIGHT_CONTROL_COUNT			2
#define		LIGHT_CONTROL_CH_COUNT		4

class CLIGHT_PARM
{	
public:
	CLIGHT_PARM();
	virtual ~CLIGHT_PARM(void);
	CLIGHT_PARM& operator=(CLIGHT_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();
	CString		GetFileString(void *pValue);

public:
	BOOL		m_bLightControl;			
	int			m_nContValue[LIGHT_CONTROL_COUNT][LIGHT_CONTROL_CH_COUNT];

	void		SetContValue(int nIdx, int nCh, int nContValue);		
};

enum EM_GLASSTYPE_COMP{GLASSTYPE_RCUT=0,GLASSTYPE_CCUT,GLASSTYPE_NCUT};
class CGLASS_INFO_PARM
{	
public:
	CGLASS_INFO_PARM();
	virtual ~CGLASS_INFO_PARM(void);
	CGLASS_INFO_PARM& operator=(CGLASS_INFO_PARM& rh);

public:
	void			Reset();
	BOOL			ReadRecipe(CConfig *pFile);
	BOOL			WriteRecipe(CConfig *pFile);	
	double			GetOneScanTime(){return m_dOneScanTime;}
	BOOL			GetOneSacnMode(){return m_bOneScanMode;}

protected:	
	CString			GetFileString(void *pValue);	

public:	
	int					m_nGlassSizeX;
	int					m_nGlassSizeY;
	int					m_nGlassImageSize;
	int					m_nGlassImageLeftMargin;	
	BOOL				m_bGlassFullImageSave;
	BOOL				m_bAllImageSave;
	GlassDirection		m_OriginDirection;
	CString				m_strDisp;	
	BOOL				m_bGlassDefaultImageSave;
	BOOL				m_bOneScanMode;
	BOOL				m_bPanelReverse;
	double				m_dOneScanTime;
	EM_GLASSTYPE_COMP	m_emGlassType;
	int					m_nFindGlassStartOffset[MAX_DIMENSION_COUNT];
	int					m_nGlassFindHorPos[MAX_DIMENSION_COUNT];
};

typedef struct stuDEFECT_CONDITION
{
	BOOL bError;						// 是否发生错误
	BOOL bConditionAND;					// TRUE: Width和Height都满足才会发生Error
	SIZE szDefect;						// Defect大小
	int  nMerge;						// 合并

	stuDEFECT_CONDITION(void)
	{
		bError = FALSE;
		bConditionAND = FALSE;
		szDefect.cx = 0;
		szDefect.cy = 0;
		nMerge = 0;
	}
}DEFECT_CONDITION;

typedef struct tagJUDGE_DEFECT
{

	DEFECT_CONDITION Chip_Side;				
	DEFECT_CONDITION Burr_Side;
	DEFECT_CONDITION Broken;
	DEFECT_CONDITION Bevel;
	DEFECT_CONDITION Chip_CF;				
	DEFECT_CONDITION Burr_CF;	
	DEFECT_CONDITION Crack;
	DEFECT_CONDITION Compare_Panel;

	int nRangeStart;
	int nRangeEnd;
}JUDGE_DEFECT, *PJUDGE_DEFECT;

typedef struct tagJUDGE_EDGE
{
	BOOL bError;			// 错误与否
	int  nRefernce;			// 标准 	
	int  nTolPlus;			// +容许误差
	int  nTolMinus;			// -容许误差
}JUDGE_EDGE, *PJUDGE_EDGE;

typedef struct tagJUDGE_AVG
{
	BOOL bUse;			
	int  nDiff;
}JUDGE_AVG, *PJUDGE_AVG;

#define		MAX_MARKER_COUNT		3
#define		MAX_POS_MARKER_COUNT	3
class CINSPECT_JUDGEMENT_PARM
{
public:
	CINSPECT_JUDGEMENT_PARM(void);
	virtual ~CINSPECT_JUDGEMENT_PARM(void);
	CINSPECT_JUDGEMENT_PARM& operator=(CINSPECT_JUDGEMENT_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();	

public:
	JUDGE_EDGE	corner_X[MAX_PANEL_SIDE];
	JUDGE_EDGE	corner_Y[MAX_PANEL_SIDE];
	JUDGE_EDGE	grind[2][MAX_PANEL_SIDE];
	JUDGE_EDGE	chamfer[2][MAX_PANEL_SIDE];
	JUDGE_EDGE	cutting[2][MAX_PANEL_SIDE]; // 截断量判定标准
	CPoint		ptAlign[MAX_MARKER_COUNT][MAX_DIMENSION_COUNT];
	JUDGE_EDGE	EdgeToSubMark[MAX_DIMENSION_COUNT];
	JUDGE_DEFECT defect[MAX_DIMENSION_COUNT][3];	
	JUDGE_EDGE	Dimension[MAX_DIMENSION_COUNT];	
	int			nCFGrind[MAX_PANEL_SIDE];
	BOOL		bUseLengthDepthComp;
	int			nCornerJugeLength;
	int			nCornerJugeDepth;
	BOOL		bCoordProUse;
	JUDGE_AVG	AvgProfile[MAX_DIMENSION_COUNT];
	JUDGE_AVG	AvgChamfer[MAX_DIMENSION_COUNT];

	int			nMinProfileNgCount[MAX_DIMENSION_COUNT];
	int			nMinProfileNgCount_MinDiff[MAX_DIMENSION_COUNT];
};

class CINSPECT_INFO_PARM
{
public:
	CINSPECT_INFO_PARM(void);
	virtual ~CINSPECT_INFO_PARM(void);
	CINSPECT_INFO_PARM& operator=(CINSPECT_INFO_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();	

	BOOL		GetCutAreaUse(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaUse((int)enDimen);}	
	BOOL		GetCutAreaAlignMarkUse(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaAlignMarkUse((int)enDimen);}
	BOOL		GetChipUse(DimensionDir enDimen){return m_CutAreaParm.GetChipUse((int)enDimen);}	
	BOOL		GetDimenUse(DimensionDir enDimen){return m_DimensionParm.GetDimenUse((int)enDimen);}
	BOOL		GetSplineUse(DimensionDir enDimen){return m_SplineParm.GetSplineUse((int)enDimen);}
	BOOL		GetSplineChipUse(DimensionDir enDimen){return m_SplineParm.GetSplineChipUse((int)enDimen);}
	BOOL		GetNotchSizeUse(DimensionDir enDimen){return m_NotchParm.GetNotchSizeUse((int)enDimen);}
	BOOL		GetNotchChipUse(DimensionDir enDimen){return m_NotchParm.GetNotchChipUse((int)enDimen);}
	BOOL		GetSplineUsePointJudge(int iPos){return m_SplineParm.GetSplineUsePointJudge(iPos);}

	CCUTAREA_PARM		*GetCutParm(){return &m_CutAreaParm;}
	pSTU_CUTAREA_PARM	GetCutAreaParm(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaParm((int)enDimen);}
	pSTU_CHIP_PARM		GetChipParm(DimensionDir enDimen){return m_CutAreaParm.GetChipParm((int)enDimen);}
	std::vector<STU_CUTAREA_EXP_POS>	*GetExpArea(DimensionDir enDimen){return m_CutAreaParm.GetExpArea((int)enDimen);}
	pSTU_CUTAREA_ALIGN_MARK	GetCutAreaAlignMark(DimensionDir enDimen){return m_CutAreaParm.GetCutAreaAlignMark((int)enDimen);}//20140611

	CCORNER_PARM		*GetCornerParm(){return &m_CornerParm;}

	CDIMENSION_PARM			*GetDimensionParm(){return &m_DimensionParm;}
	pSTU_DIMEN_INS_PRM		GetDimenIns(DimensionDir enDimen){return m_DimensionParm.GetDimenIns((int)enDimen);}
	std::vector<STU_DI_POS>	*GetDimenPos(DimensionDir enDimen){return m_DimensionParm.GetDimenPos((int)enDimen);}

	CSPLINE_PARM			*GetSplineParm(){return &m_SplineParm;}
	pSTU_SPLINE_INS_PARM	GetSplineIns(DimensionDir enDimen){return m_SplineParm.GetSplineIns((int)enDimen);}
	pSTU_SPLINE_CHIP_PARM	GetSplineChipIns(DimensionDir enDimen){return m_SplineParm.GetSplineChipIns((int)enDimen);}
	std::vector<STU_SPLINE_CHIP_POS>	*GetSplineChipPos(DimensionDir enDimen){return m_SplineParm.GetSplineChipPos((int)enDimen);}

	CNOTCH_PARM				*GetNotchParm(){return &m_NotchParm;}
	pSTU_NOTCH_DATA			GetNotchIns(DimensionDir enDimen){return m_NotchParm.GetNotchIns((int)enDimen);}	

public:	
	CVCR_PARM			m_VCRParm;
	CCUTAREA_PARM		m_CutAreaParm;
	CCORNER_PARM		m_CornerParm;
	CDIMENSION_PARM		m_DimensionParm;
	CSPLINE_PARM		m_SplineParm;	
	CNOTCH_PARM			m_NotchParm;
	std::vector<STU_EXTRA_CHIP_REG> m_vecExtraChipReg;	

	int					m_nRCutThresGlass[MAX_DIMENSION_COUNT][2];
	int					m_nRCutThresChamfer[MAX_DIMENSION_COUNT][2];
};


class CALIGNMARK_PARM
{	
public:
	CALIGNMARK_PARM();
	virtual ~CALIGNMARK_PARM(void);
	CALIGNMARK_PARM& operator=(CALIGNMARK_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile,int nIdx);
	BOOL		WriteRecipe(CConfig *pFile,int nIdx);

public:
	void		Reset();		
	void		MarkImgDelete();	

public:
	BOOL		m_bIsMark[MAX_MARKER_COUNT];	// 是否存在标志?
	int			m_nMarkType[MAX_MARKER_COUNT];
	double		m_dMarkMatchingRate[MAX_MARKER_COUNT][MAX_POS_MARKER_COUNT];		
	JUDGEEDGE	m_JudgeAlign;		
	IplImage	*IpMarkImg[MAX_MARKER_COUNT][MAX_POS_MARKER_COUNT];
};

enum	EM_INS_TYPE{EM_INS_EDGE=0,EM_INS_CORNER,EM_INS_DIMENSION,EM_INS_SPLINE,EM_INS_NOTCH,EM_INS_SPLINE_POINT_JUDGE};

// Hole Inspsect Parameter
struct HOLE_INS_PARM
{
	int		m_nSideIdx;
	CRect	m_rtArea;
	CRect	m_rtHoleArea;
	int		m_nThreshold;
	int		m_nOffset;
	int		m_nMinSize;
	double  m_dMatRate;
	CString m_strTemplatePath;
};

class CHOLEINSPECT_PARM
{	
public:
	CHOLEINSPECT_PARM()						{Reset();};
	virtual ~CHOLEINSPECT_PARM(void)		{Reset();};
	CHOLEINSPECT_PARM& operator=(CHOLEINSPECT_PARM& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();		

public:
	int						m_nTotalHoleCount;
	vector<HOLE_INS_PARM>	m_vecHoleInsParam;
};
// End of Hole Inspsect Parameter

typedef struct tagProfileSetting
{
	double x;
	double y;
	double radius;
	double plus;
	double minus;
	BOOL use;

	tagProfileSetting(void)
	{
		x = 0.0;
		y = 0.0;
		radius = 0.0;
		plus = 50.0;
		minus = 50.0;
		use = TRUE;
	}
}ST_PROFILE_SETTING;

typedef struct tagChamferSetting
{
	double reference;
	double plus;
	double minus;
	BOOL use;

	tagChamferSetting(void)
	{
		reference = 100.0;
		plus = 50.0;
		minus = 50.0;
		use = TRUE;
	}
}ST_CHAMFER_SETTING;



class CProfileInspect_Prm
{	
public:
	CProfileInspect_Prm()						{Reset();};
	virtual ~CProfileInspect_Prm(void)		{Reset();};
	CProfileInspect_Prm& operator=(CProfileInspect_Prm& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);

public:
	void		Reset();		

public:
	BOOL			m_bUseOriginAlignKey[MAX_DIMENSION_COUNT];
	int				m_nOriginAlignKeyOffsetX[MAX_DIMENSION_COUNT];
	int				m_nOriginAlignKeyOffsetY[MAX_DIMENSION_COUNT];
	int				m_nOriginAlignKeyOffsetDwX[MAX_DIMENSION_COUNT];
	int				m_nOriginAlignKeyOffsetDwY[MAX_DIMENSION_COUNT];

	int				m_nCADOffsetX[MAX_DIMENSION_COUNT];
	int				m_nCADOffsetY[MAX_DIMENSION_COUNT];
	ST_PROFILE_SETTING	m_stProfile[MAX_PROFILE_SETTING_COUNT];
	ST_CHAMFER_SETTING	m_stCamferUp[MAX_PROFILE_SETTING_COUNT];
	ST_CHAMFER_SETTING	m_stCamferDn[MAX_PROFILE_SETTING_COUNT];

	double			m_dConvResolution[MAX_DIMENSION_COUNT][MAX_STAGE_HAND_COUNT];
	double			m_dScanResolution[MAX_DIMENSION_COUNT][MAX_STAGE_HAND_COUNT];
};

class CGlassRecipe
{
public:
	CGlassRecipe(void);
	virtual ~CGlassRecipe(void);
	CGlassRecipe& operator=(CGlassRecipe& rh);

public:
	BOOL		ReadRecipe(CConfig *pFile);
	BOOL		WriteRecipe(CConfig *pFile);
	BOOL		WriteRecipeFile();	
	BOOL		WriteRecipeFileBackUp();
	BOOL		MakeRecipeFileName(CString strRecipe);	
	BOOL		MakeRecipeFileNameBackUp(CString strRecipe);
	BOOL		ReadRecipeFile();

	int			GetLightValue(int iCon,int iCh);
	CINSPECT_INFO_PARM	*GetInspectInfo(){return &m_InspectInfoParm;}
	CALIGNMARK_PARM	*GetAlignMarkPrm(DimensionDir eDim);
	BOOL		LoadAlignMark();
	BOOL		SaveAlignMark();

	pSTU_CUTAREA_PARM	GetCutAreaPrm(DimensionDir eDim);
	CCORNER_PARM		*GetCornerParm(){return m_InspectInfoParm.GetCornerParm();}

	CETC_PARM			*GetEtcPrm(DimensionDir eDim);

	CINSPECT_JUDGEMENT_PARM	*GetJudgePrm(){return &m_Judgement;}
	USER_DEFECT_AREA_LIST	*GetUserDefectList(DimensionDir eDim){return &m_UserDefectPrm[eDim];}
	EXCEPTION_AREA_LIST		*GetExpAreaList(DimensionDir eDim){return &m_ExpAreaPrm[eDim];}
	CHOLEINSPECT_PARM		*GetHolePrm(){return &m_HoleInspectParm;}

	CDIMENSION_PARM			*GetDimensionParm(){return m_InspectInfoParm.GetDimensionParm();}
	CProfileInspect_Prm		*GetProfileParm(){return &m_ProfilePrm;}
	CGLASS_INFO_PARM		*GetGlassInfo(){return &m_GlassParm;}

	CString		GetRecipeName();
	void		Reset();	

	BOOL		Save_Image(CString strPath,IplImage *IpImg);
	BOOL		Load_Image(CString strPath,IplImage **pIpImg);

	BOOL		LoadUserDefectList();
	BOOL		SaveUserDefectList();
	BOOL		LoadExpAreaList();
	BOOL		SaveExpAreaList();
	void		DeleteExpAreaList();

public:
	CRECIPE_INFO_PARM	m_RecieParm;
	CGLASS_INFO_PARM	m_GlassParm;
	CETC_PARM			m_ETCParm[MAX_DIMENSION_COUNT];
	CLIGHT_PARM			m_LightParm;
	CALIGNMARK_PARM		m_AlignMarkParm[MAX_DIMENSION_COUNT];
	USER_DEFECT_AREA_LIST	m_UserDefectPrm[MAX_DIMENSION_COUNT];
	EXCEPTION_AREA_LIST	m_ExpAreaPrm[MAX_DIMENSION_COUNT];

	CINSPECT_INFO_PARM	m_InspectInfoParm;

	CINSPECT_JUDGEMENT_PARM	m_Judgement;
	CHOLEINSPECT_PARM		m_HoleInspectParm;
	CProfileInspect_Prm		m_ProfilePrm;

protected:
	CConfig		m_RecipeFile;
};