#pragma once

#define		DEFECTIMAGE_WIDTH		1024
#define		DEFECTIMAGE_HEIGHT		500

enum DefectLocation 
{ 
	DefectLoc_Chip=0,
	DefectLoc_Crack, 
	DefectLoc_Burr,
	DefectLoc_Chamfer,
	DefectLoc_In_Chip, 
	DefectLoc_In_Crack,
	DefectLoc_In_Burr,
	DefectLoc_In_Chamfer,
	DefectLoc_Top_Corner,
	DefectLoc_Bot_Corner,

	DefectLoc_Corner_Chamfer,
	DefectLoc_Measure_Corner,
	DefectLoc_Measure_Dimension,
	DefectLoc_Measure_Chamfer,

	DefectLoc_Notch_Crack,
	DefectLoc_Notch_Dimension,
	DefectLoc_Notch_Chamfer,
	DefectLoc_Notch_Circle_Radius,

	DefectLoc_UserDefect,

	DefectLoc_Mark,

	DefectLoc_WS_Fail,

	DefectLoc_Exception,

	DefectLoc_License,

	DefectLoc_Unknown,

	DefectLoc_None
};

static CString g_strDefectType[DefectLoc_None] = 
{
	_T("Chip"),
	_T("Crack"), 
	_T("Burr"),
	_T("Chamfer"),
	_T("In_Chip"),
	_T("In_Crack"),
	_T("In_Burr"),
	_T("In_Chamfer"),
	_T("Top_Corner"),
	_T("Bot_Corner"),

	_T("Corner_Chamfer"),
	_T("Corner_Dimension"),
	_T("Dimension"),
	_T("Chamfer"),

	_T("Notch"),
	_T("Notch_Dimension"),
	_T("Notch_Chamfer"),
	_T("Notch_Radius"),

	_T("User_Defect"),

	_T("Mark"),

	_T("WS_Fail"),

	_T("Exception"),
	_T("License"),

	_T("Unknown")
};

class CDefect_Info
{
public:
	CDefect_Info()			{Reset();};
	virtual ~CDefect_Info()	{};

public:
	void Reset()
	{
		m_nIndex = -1;
		m_iFrameIdx = -1;
		m_nCamID = -1;
		m_nScanIdx = -1;
		m_nGlassStartLine = -1;

		m_nSideIdx = -1;
		m_DefectLoc = DefectLoc_None;

		m_ptDefectPos_pxl = CPoint(-1,-1);
		m_rtDefectPos_pxl = CRect(-1,-1,-1,-1);

		m_nMinSize = 0;
		m_nBlobDilation = 0;

		m_nBlobCount = 0;
		m_nGray_Max = 0;
		m_nGray_Min = 0;
		m_nGray_Sum = 0;
		m_dGray_Avg = 0;
		m_dRectArea_Ratio = 0.0;
	}

public:	
	int				m_nIndex;
	int				m_iFrameIdx;
	int				m_nCamID;
	int				m_nScanIdx;
	int				m_nGlassStartLine;
	int				m_nSideIdx;
	DefectLocation	m_DefectLoc;


	CPoint			m_ptDefectPos_pxl;
	CRect			m_rtDefectPos_pxl;

	int				m_nMinSize;
	int				m_nBlobDilation;

	// Image Info
	UINT			m_nBlobCount;
	UINT			m_nGray_Max;
	UINT			m_nGray_Min;
	UINT			m_nGray_Sum;
	double			m_dGray_Avg;

	double			m_dRectArea_Ratio;
};

class CDefect
{
public:
	CDefect()			{Reset();};
	virtual ~CDefect()	{};

public:
	void Reset()
	{
		m_nIdx = 0;
		m_DefectInfo.Reset();

		m_dSizeX_um = 0.0;
		m_dSizeY_um = 0.0;
		m_dChamfer_um = 0.0;
		m_dChamferOff_um = 0.0;

		m_nDefectMergeCount = 0;
		m_bDefectMergeRemoved = FALSE;

		m_bJudge_NG = 0;					// 0 : OK, 1 : NG
		m_nJudge_X_um = 0;
		m_nJudge_Y_um = 0;
		m_nJudge_Type = 0;

		m_nExceptionArea = 0;

		m_nUserDefectAreaIdx = 0;

		m_nNotchIdx = 0;

		m_nJudgeArea = 0;

		ZeroMemory(m_Image, sizeof(m_Image));
		m_strSaveImagePath = _T("");
	}
public:	
	int				m_nIdx;
	CDefect_Info	m_DefectInfo;

	double			m_dSizeX_um;
	double			m_dSizeY_um;
	double			m_dChamfer_um;
	double			m_dChamferOff_um;

	// Merge
	int				m_nDefectMergeCount;
	BOOL			m_bDefectMergeRemoved;

	// Judge
	BOOL			m_bJudge_NG;			// 0 : OK, 1 : NG
	int				m_nJudge_X_um;
	int				m_nJudge_Y_um;
	int				m_nJudge_Type;

	// Exception Area
	int				m_nExceptionArea;		// 0 : 固器窃, 1 : 混娄 吧魔, 2 : 肯傈 器窃

	// User Defect Idx
	int				m_nUserDefectAreaIdx;

	// Notch Defect Idx
	int             m_nNotchIdx;

	// Judge Area
	int				m_nJudgeArea;			// 0 : 1st, 1 : 2nd, 2 : 3rd

	// Image
	BYTE			m_Image[DEFECTIMAGE_WIDTH * DEFECTIMAGE_HEIGHT + 1];
	CString			m_strSaveImagePath;
};

typedef std::multimap<int, CDefect*>			MapDefect;
typedef std::multimap<int, CDefect*>::iterator	MapDefectIt;