// CFRecipeJudge.h: interface for the CCFRecipeJudge class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CFRECIPEJUDGE_H__19D17C40_D748_433F_B0C7_66E6CE8DCB37__INCLUDED_)
#define AFX_CFRECIPEJUDGE_H__19D17C40_D748_433F_B0C7_66E6CE8DCB37__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <vector>
using namespace std;

class CHMRegiConfig;
#define MAX_STEP_COUNT 20

enum CompOperator	{ COp_None = 0, COp_Greater, COp_GreaterEqual, COp_Lesser, COp_LesserEqual, COp_Equal, COp_NotEqual };
enum LogicOperator	{ LOp_And = 0, LOp_Or };
enum CompResult		{ Op_Fail = -1, Op_False = 0, Op_True = 1};
template <typename T> class CComparison
{
public:
	CComparison()
	{
		ResetComparison();
	}
	CComparison(T tL, CompOperator COpL, T tR, CompOperator COpR, LogicOperator LOp = LOp_And)
		: m_tLeft(tL), m_COpLeft(COpL), m_tRight(tR), m_COpRight(COpR), m_LOperator(LOp)	{}
	void			ResetComparison()
	{
		m_COpLeft	= COp_None;
		m_COpRight	= COp_None;
		m_LOperator	= LOp_And;
	}
	void			SetLeft(T t)					{ m_tLeft = t; }
	void			SetRight(T t)					{ m_tRight = t; }
	void			SetLeft(T t, CompOperator COp)	{ m_tLeft = t;	m_COpLeft = COp; }
	void			SetRight(T t, CompOperator COp)	{ m_tRight = t;	m_COpRight = COp; }
	void			SetLeftRight(T tL, T tR)		{ m_tLeft = tL;	m_tRight = tR; }
	void			SetLeftOp(CompOperator COp)		{ m_COpLeft = COp; }
	void			SetRightOp(CompOperator COp)	{ m_COpRight = COp; }
	void			SetLeftRightOp(CompOperator COpL, CompOperator COpR)	{ m_COpLeft = COpL;	m_COpRight = COpR; }
	void			SetLOperator(LogicOperator LOp)	{ m_LOperator = LOp; }
	void			SetAll(T tL, CompOperator COpL, T tR, CompOperator COpR, LogicOperator LOp = LOp_And)
	{
		m_tLeft			= tL;
		m_tRight		= tR;
		m_COpLeft		= COpL;
		m_COpRight		= COpR;
		m_LOperator		= LOp;
	}
	
	T				GetLeft() const			{ return m_tLeft; }
	T				GetRight() const		{ return m_tRight; }
	CompOperator	GetLeftOp() const		{ return m_COpLeft; }
	CompOperator	GetRightOp() const		{ return m_COpRight; }
	LogicOperator	GetLOperator() const	{ return m_LOperator; }

	BOOL			CompLeft(T t) const
	{
		if (m_COpLeft == Op_None)
			return Op_Fail;

		CompResult CR = Op_False;
		switch (m_COpLeft)
		{
		case COp_Greater:		if (t > m_tLeft)	CR = Op_True;	break;
		case COp_GreaterEqual:	if (t >= m_tLeft)	CR = Op_True;	break;
		case COp_Lesser:			if (t < m_tLeft)	CR = Op_True;	break;
		case COp_LesserEqual:	if (t <= m_tLeft)	CR = Op_True;	break;
		case COp_Equal:			if (t == m_tLeft)	CR = Op_True;	break;
		case COp_NotEqual:		if (t != m_tLeft)	CR = Op_True;	break;
		}
		return CR;
	}
	BOOL			CompRight(T t) const
	{
		if (m_COpRight == COp_None)
			return Op_Fail;
		
		CompResult CR = Op_False;
		switch (m_COpRight)
		{
		case COp_Greater:		if (t > m_tRight)	CR = Op_True;	break;
		case COp_GreaterEqual:	if (t >= m_tRight)	CR = Op_True;	break;
		case COp_Lesser:			if (t < m_tRight)	CR = Op_True;	break;
		case COp_LesserEqual:	if (t <= m_tRight)	CR = Op_True;	break;
		case COp_Equal:			if (t == m_tRight)	CR = Op_True;	break;
		case COp_NotEqual:		if (t != m_tRight)	CR = Op_True;	break;
		}
		return CR;
	}
	BOOL			CompBoth(T t) const
	{
		if (m_COpLeft == COp_None && m_COpRight == COp_None)
			return Op_Fail;
		
		CompResult CR = Op_False;
		CompResult CL = Op_False;
		if (m_COpLeft != COp_None)
		{
			switch (m_COpLeft)
			{
			case COp_Greater:		if (t > m_tLeft)	CL = Op_True;	break;
			case COp_GreaterEqual:	if (t >= m_tLeft)	CL = Op_True;	break;
			case COp_Lesser:			if (t < m_tLeft)	CL = Op_True;	break;
			case COp_LesserEqual:	if (t <= m_tLeft)	CL = Op_True;	break;
			case COp_Equal:			if (t == m_tLeft)	CL = Op_True;	break;
			case COp_NotEqual:		if (t != m_tLeft)	CL = Op_True;	break;
			}
			if(m_COpRight == COp_None)
				return CL;
		}
		if (m_COpRight != COp_None)
		{
			switch (m_COpRight)
			{
			case COp_Greater:		if (t > m_tRight)	CR = Op_True;	break;
			case COp_GreaterEqual:	if (t >= m_tRight)	CR = Op_True;	break;
			case COp_Lesser:		if (t < m_tRight)	CR = Op_True;	break;
			case COp_LesserEqual:	if (t <= m_tRight)	CR = Op_True;	break;
			case COp_Equal:			if (t == m_tRight)	CR = Op_True;	break;
			case COp_NotEqual:		if (t != m_tRight)	CR = Op_True;	break;
			}
			if(m_COpLeft == COp_None)
				return CR;
		}

		if(m_LOperator == LOp_And)
			return CL&CR;
		return CL|CL;
	}
	CComparison& operator=(const CComparison& rhs)
	{
		if (this != &rhs)
		{
			m_tLeft = rhs.m_tLeft;
			m_tRight = rhs.m_tRight;
			m_COpLeft = rhs.m_COpLeft;
			m_COpRight = rhs.m_COpRight;
			m_LOperator = rhs.m_LOperator;
		}
		
		return *this;
	}
	CComparison(const CComparison& rhs)
	{
		if (this != &rhs)
		{
			m_tLeft = rhs.m_tLeft;
			m_tRight = rhs.m_tRight;
			m_COpLeft = rhs.m_COpLeft;
			m_COpRight = rhs.m_COpRight;
			m_LOperator = rhs.m_LOperator;
		}
	}
protected:
	T				m_tLeft;
	T				m_tRight;
	CompOperator	m_COpLeft;
	CompOperator	m_COpRight;
	LogicOperator	m_LOperator;
};

template <typename T> class CComparisonEx : public CComparison<typename T>
{
public:
	CComparisonEx()
	{
		ResetComparison();
	}
	CComparisonEx(BOOL bUse, T tL, CompOperator COpL, T tR, CompOperator COpR, LogicOperator LOp = LOp_And)
		: m_bCompareUse(bUse)
	{
		m_tLeft = tL;
		m_COpLeft = COpL;
		m_tRight = tR;
		m_COpRight = COpR;
		m_LOperator = LOp;
	}
	CComparisonEx(BOOL bUse, const CComparison& rhs)
	{
		if (this != &rhs)
		{
			*this = rhs;
			m_bCompareUse = bUse;
		}
	}
	CComparisonEx(const CComparisonEx& rhs)
	{
		if (this != &rhs)
		{
			CComparison(rhs);
			m_bCompareUse	= rhs.m_bCompareUse;
		}
	}
	CComparisonEx& operator=(const CComparisonEx& rhs)
	{
		if (this != &rhs)
		{
			static_cast<CComparison<T>&>(*this) = static_cast<const CComparison<T>&>(rhs);
			m_bCompareUse	= rhs.m_bCompareUse;
		}
		
		return *this;
	}
	void			ResetComparison()
	{
		CComparison<T>::ResetComparison();
		m_bCompareUse = FALSE;
	}

	void			SetCompareUse(BOOL bUse)	{ m_bCompareUse = bUse; }
	BOOL			GetCompareUse() const		{ return m_bCompareUse; }

	BOOL			CompLeft(T t) const			{ return m_bCompareUse ? CComparison<T>::CompLeft(t) : TRUE; }
	BOOL			CompRight(T t) const		{ return m_bCompareUse ? CComparison<T>::CompRight(t) : TRUE; }
	BOOL			CompBoth(T t) const			{ return m_bCompareUse ? CComparison<T>::CompBoth(t) : TRUE; }
protected:
	BOOL			m_bCompareUse;
};

class AFX_EXT_CLASS CSelectionItem
{
public:
	CSelectionItem()
	{
		m_nItemCount = 0;
		m_pItem = NULL;
	}
	virtual ~CSelectionItem()
	{
		m_nItemCount = 0;
		if (m_pItem)
			delete [] m_pItem;
		m_pItem = NULL;
	}

	//±èÀºÈ£(STEP)
	void			ResetStep()
	{
		int i;
		for(i = 0 ; i < m_nItemCount ; i++)
		{
			m_pItem[i] = 0;

		}
		for(i =0; i < MAX_STEP_COUNT; i++)
			m_strItem[i] = _T("");
	}			

	//±èÀºÈ£(STEP) (»ç¿ë ¾ÈÇÔ)
	void			DeleteItemValue(int nIndex)
	{
		m_pItem[nIndex] = 0;
		m_strItem[nIndex] = _T("");
		for(int i = nIndex ; i < GetTrueStringCount() ; i++)
		{
			m_strItem[nIndex] = m_strItem[i + 1];
		}
	}

	void			SetItemStringCount(int nCount)
	{
		if (nCount < 0)
			return;
		
		m_nItemCount = nCount;
		if (m_pItem)
			delete [] m_pItem;
		

		m_pItem = NULL;

		if (m_nItemCount > 0)
		{
			m_pItem = new BOOL[m_nItemCount];
		
			for (int i = 0; i < m_nItemCount; i++)
				m_pItem[i] = FALSE;

		}
		
	}

	void			SetItemCount(int nCount)
	{
		if (nCount < 0)
			return;

		m_nItemCount = nCount;
		if (m_pItem)
			delete [] m_pItem;
		m_pItem = NULL;
		if (m_nItemCount > 0)
		{
			m_pItem = new BOOL[m_nItemCount];
			for (int i = 0; i < m_nItemCount; i++)
				m_pItem[i] = FALSE;
		}
	}
	int				GetItemCount() const		{ return m_nItemCount; }
	void			SetItemValue(int nIdx, BOOL bValue)
	{
		if (!m_pItem || nIdx < 0 || nIdx >= m_nItemCount)
			return;
		m_pItem[nIdx] = bValue;
	}

	//±èÀºÈ£(STEP)
	void			SetItemValueString(int nIdx, BOOL nCheck, CString strValue)
	{
		if (!m_pItem || nIdx < 0 || nIdx >= m_nItemCount)
			return;
		m_pItem[nIdx] = nCheck;
		m_strItem[nIdx] = strValue;
	}

	BOOL			GetItemValue(int nIdx) const
	{
		if (!m_pItem || nIdx < 0 || nIdx >= m_nItemCount)
			return FALSE;
		return m_pItem[nIdx];
	}

	CString			GetItemValueString(int nIdx) const
	{
		return m_strItem[nIdx];
	}

	int				GetTrueCount() const
	{
		int nCount = 0;
		for (int i = 0; i < m_nItemCount; i++)
		{
			if (m_pItem[i])
				nCount++;
		}
		return nCount;
	}
	//±èÀºÈ£(STEP)
	int				GetTrueStringCount() const
	{
		int nCount = 0;
		for (int i = 0; i < MAX_STEP_COUNT; i++)
		{
			if (m_strItem[i].GetLength() > 0)
				nCount++;
		}
		return nCount;
	}

	CSelectionItem& operator=(const CSelectionItem& rhs)
	{
		if (this != &rhs)
		{
			m_nItemCount = rhs.m_nItemCount;
			if (m_pItem)
				delete [] m_pItem;
			m_pItem = NULL;
			if (m_nItemCount > 0)
			{
				m_pItem = new BOOL[m_nItemCount];
				for (int i = 0; i < m_nItemCount; i++)
					m_pItem[i] = rhs.m_pItem[i];
				for(int j = 0 ; j < MAX_STEP_COUNT; j++)
					m_strItem[j] = rhs.m_strItem[j];
			}
		}

		return *this;
	}
	CSelectionItem(const CSelectionItem& rhs)
	{
		if (this != &rhs)
		{
			m_pItem = NULL;
			m_nItemCount = rhs.m_nItemCount;
			if (m_nItemCount > 0)
			{
				m_pItem = new BOOL[m_nItemCount];
				for (int i = 0; i < m_nItemCount; i++)
					m_pItem[i] = rhs.m_pItem[i];
				for(int j = 0 ; j < MAX_STEP_COUNT; j++)
					m_strItem[j] = rhs.m_strItem[j];
			}
		}
	}
protected:
	int				m_nItemCount;
	BOOL*			m_pItem;
	CString			m_strItem[MAX_STEP_COUNT];
};

class AFX_EXT_CLASS CSelectionItemEx : public CSelectionItem
{
public:
	CSelectionItemEx()
	{
		m_bCompareUse = FALSE;
	}
	virtual ~CSelectionItemEx()
	{
	}
	CSelectionItemEx& operator=(const CSelectionItemEx& rhs)
	{
		if (this != &rhs)
		{
			static_cast<CSelectionItem&>(*this) = static_cast<const CSelectionItem&>(rhs);
			m_bCompareUse = rhs.m_bCompareUse;
		}
		
		return *this;
	}
	CSelectionItemEx(const CSelectionItemEx& rhs)
	{
		if (this != &rhs)
		{
			*this = rhs;
			m_bCompareUse = rhs.m_bCompareUse;
		}
	}
	
	void			SetCompareUse(BOOL bUse)		{ m_bCompareUse = bUse; }
	BOOL			GetCompareUse() const			{ return m_bCompareUse; }

protected:
	BOOL			m_bCompareUse;
};



class AFX_EXT_CLASS CCFDefectJudgeItem
{
public:
	CCFDefectJudgeItem(int nCamNo, int nScanNo);
	virtual ~CCFDefectJudgeItem();
	CCFDefectJudgeItem(const CCFDefectJudgeItem& rhs);
	CCFDefectJudgeItem& operator=(const CCFDefectJudgeItem& rhs);

	BOOL				ReadDefectJudgeItem(CString strType, int nIdx, CHMRegiConfig* pCfg);
	BOOL				WriteDefectJudgeItem(CString strType, int nIdx, CHMRegiConfig* pCfg) const;

	// Set
	void				SetUseCamType(BOOL bValue)					{ m_SelCamType.SetCompareUse(bValue); }
	void				SetUseStackFlag(BOOL bValue)				{ m_SelStackFlag.SetCompareUse(bValue); }
	void				SetUseProcType(BOOL bValue)					{ m_SelProcType.SetCompareUse(bValue); }
	void				SetUseBeforeJudge(BOOL bValue)				{ m_SelBeforeJudge.SetCompareUse(bValue); }
	void				SetUseZone(BOOL bValue)						{ m_SelZone.SetCompareUse(bValue); }
	void				SetUseCamNScan(BOOL bValue)					{ m_SelCamNScan.SetCompareUse(bValue); }
	void				SetUseStep(BOOL bValue)						{ m_SelStep.SetCompareUse(bValue); }

	void				SetSelCamType(int nIdx, BOOL bValue)		{ m_SelCamType.SetItemValue(nIdx, bValue); }
	void				SetSelStackFlag(int nIdx, BOOL bValue)		{ m_SelStackFlag.SetItemValue(nIdx, bValue); }
	void				SetSelProcType(int nIdx, BOOL bValue)		{ m_SelProcType.SetItemValue(nIdx, bValue); }
	void				SetSelBeforeJudge(int nIdx, BOOL bValue)	{ m_SelBeforeJudge.SetItemValue(nIdx, bValue); }
	void				SetSelZone(int nIdx, BOOL bValue)			{ m_SelZone.SetItemValue(nIdx, bValue); }
	void				SetSelCamNScan(int nIdx, BOOL bValue)		{ m_SelCamNScan.SetItemValue(nIdx, bValue); }
	void				SetSelStep(int nIdx, BOOL bValue)			{ m_SelStep.SetItemValue(nIdx, bValue); } //±èÀºÈ£(STEP)

	void				SetCompRScale(CComparisonEx<int>& Cmp)		{ m_CompRScale = Cmp; }
	void				SetCompSizeW(CComparisonEx<int>& Cmp)		{ m_CompSizeW = Cmp; }
	void				SetCompSizeL(CComparisonEx<int>& Cmp)		{ m_CompSizeL = Cmp; }
	void				SetCompPixelSize(CComparisonEx<int>& Cmp)	{ m_CompPixelSize = Cmp; }
	void				SetCompPeak(CComparisonEx<int>& Cmp)		{ m_CompPeak = Cmp; }
	void				SetCompSrcMin(CComparisonEx<int>& Cmp)		{ m_CompSrcMin = Cmp; }
	void				SetCompSrcMax(CComparisonEx<int>& Cmp)		{ m_CompSrcMax = Cmp; }
	void				SetCompSrcAvg(CComparisonEx<int>& Cmp)		{ m_CompSrcAvg = Cmp; }
	void				SetCompRefMin(CComparisonEx<int>& Cmp)		{ m_CompRefMin = Cmp; }
	void				SetCompRefMax(CComparisonEx<int>& Cmp)		{ m_CompRefMax = Cmp; }
	void				SetCompRefAvg(CComparisonEx<int>& Cmp)		{ m_CompRefAvg = Cmp; }

	void				SetCompSrcMinCM(CComparisonEx<int>& Cmp)		{ m_CompSrcMinCM = Cmp; }
	void				SetCompSrcMaxCM(CComparisonEx<int>& Cmp)		{ m_CompSrcMaxCM = Cmp; }
	void				SetCompSrcAvgCM(CComparisonEx<int>& Cmp)		{ m_CompSrcAvgCM = Cmp; }
	void				SetCompRefMinCM(CComparisonEx<int>& Cmp)		{ m_CompRefMinCM = Cmp; }
	void				SetCompRefMaxCM(CComparisonEx<int>& Cmp)		{ m_CompRefMaxCM = Cmp; }
	void				SetCompRefAvgCM(CComparisonEx<int>& Cmp)		{ m_CompRefAvgCM = Cmp; }

	void				SetCompRTDC(CComparisonEx<CString>& Cmp)	{ m_CompRTDC = Cmp; }

	void				SetnMaxNRCount(int nValue)					{ m_nMaxNRCount = nValue; }
	void				SetnSameDefectMargin(int nValue)			{ m_nSameDefectMargin = nValue; }
	void				SetZoneAndOr(BOOL bValue)					{ m_bSelZoneAndOr = bValue; }


	void				SetJudgement(Judgement Judge)				{ m_Judgement = Judge; }
	void				SetJudgeComment(CString str)				{ m_strJudgeComment = str; }

	// Compare
	BOOL				CompareRScale(int nValue) const			{ return m_CompRScale.CompBoth(nValue); }
	BOOL				CompareSizeW(int nValue) const			{ return m_CompSizeW.CompBoth(nValue); }
	BOOL				CompareSizeL(int nValue) const			{ return m_CompSizeL.CompBoth(nValue); }
	BOOL				ComparePixelSize(int nValue) const		{ return m_CompPixelSize.CompBoth(nValue); }
	BOOL				ComparePeak(int nValue) const			{ return m_CompPeak.CompBoth(nValue); }
	BOOL				CompareSrcMin(int nValue) const			{ return m_CompSrcMin.CompBoth(nValue); }
	BOOL				CompareSrcMax(int nValue) const			{ return m_CompSrcMax.CompBoth(nValue); }
	BOOL				CompareSrcAvg(int nValue) const			{ return m_CompSrcAvg.CompBoth(nValue); }
	BOOL				CompareRefMin(int nValue) const			{ return m_CompRefMin.CompBoth(nValue); }
	BOOL				CompareRefMax(int nValue) const			{ return m_CompRefMax.CompBoth(nValue); }
	BOOL				CompareRefAvg(int nValue) const			{ return m_CompRefAvg.CompBoth(nValue); }

	BOOL				CompareSrcMinCM(int nValue) const			{ return m_CompSrcMinCM.CompBoth(nValue); }
	BOOL				CompareSrcMaxCM(int nValue) const			{ return m_CompSrcMaxCM.CompBoth(nValue); }
	BOOL				CompareSrcAvgCM(int nValue) const			{ return m_CompSrcAvgCM.CompBoth(nValue); }
	BOOL				CompareRefMinCM(int nValue) const			{ return m_CompRefMinCM.CompBoth(nValue); }
	BOOL				CompareRefMaxCM(int nValue) const			{ return m_CompRefMaxCM.CompBoth(nValue); }
	BOOL				CompareRefAvgCM(int nValue) const			{ return m_CompRefAvgCM.CompBoth(nValue); }

	BOOL				CompareRTDC(CString str) const			{ return m_CompRTDC.CompBoth(str); }
	
	// Get
	const CSelectionItemEx&		GetSelCamType() const		{ return m_SelCamType; }
	const CSelectionItemEx&		GetSelStackFlag() const		{ return m_SelStackFlag; }
	const CSelectionItemEx&		GetSelProcType() const		{ return m_SelProcType; }
	const CSelectionItemEx&		GetSelBeforeJudge() const	{ return m_SelBeforeJudge; }
	const CSelectionItemEx&		GetSelZone() const			{ return m_SelZone; }
	const CSelectionItemEx&		GetSelCamNScan() const		{ return m_SelCamNScan; }
	const CSelectionItemEx&		GetSelStep() const		{ return m_SelStep; } //±èÀºÈ£(STEP) 
	
	BOOL						GetSelCamType(int nIdx) const		{ return m_SelCamType.GetItemValue(nIdx); }
	BOOL						GetSelStackFlag(int nIdx) const		{ return m_SelStackFlag.GetItemValue(nIdx); }
	BOOL						GetSelProcType(int nIdx) const		{ return m_SelProcType.GetItemValue(nIdx); }
	BOOL						GetSelBeforeJudge(int nIdx) const	{ return m_SelBeforeJudge.GetItemValue(nIdx); }
	BOOL						GetSelZone(int nIdx) const			{ return m_SelZone.GetItemValue(nIdx); }
	BOOL						GetSelCamNScan(int nIdx) const		{ return m_SelCamNScan.GetItemValue(nIdx); }
	BOOL						GetSelStep(int nIdx) const		{ return m_SelStep.GetItemValue(nIdx); } //±èÀºÈ£(STEP)
	
	const CComparisonEx<int>&	GetCompRScale() const			{ return m_CompRScale; }
	const CComparisonEx<int>&	GetCompSizeW() const			{ return m_CompSizeW; }
	const CComparisonEx<int>&	GetCompSizeL() const			{ return m_CompSizeL; }
	const CComparisonEx<int>&	GetCompPixelSize() const		{ return m_CompPixelSize; }
	const CComparisonEx<int>&	GetCompPeak() const				{ return m_CompPeak; }
	const CComparisonEx<int>&	GetCompSrcMin() const			{ return m_CompSrcMin; }
	const CComparisonEx<int>&	GetCompSrcMax() const			{ return m_CompSrcMax; }
	const CComparisonEx<int>&	GetCompSrcAvg() const			{ return m_CompSrcAvg; }
	const CComparisonEx<int>&	GetCompRefMin() const			{ return m_CompRefMin; }
	const CComparisonEx<int>&	GetCompRefMax() const			{ return m_CompRefMax; }
	const CComparisonEx<int>&	GetCompRefAvg() const			{ return m_CompRefAvg; }
	const CComparisonEx<int>&	GetCompSrcMinCM() const			{ return m_CompSrcMinCM; }
	const CComparisonEx<int>&	GetCompSrcMaxCM() const			{ return m_CompSrcMaxCM; }
	const CComparisonEx<int>&	GetCompSrcAvgCM() const			{ return m_CompSrcAvgCM; }
	const CComparisonEx<int>&	GetCompRefMinCM() const			{ return m_CompRefMinCM; }
	const CComparisonEx<int>&	GetCompRefMaxCM() const			{ return m_CompRefMaxCM; }
	const CComparisonEx<int>&	GetCompRefAvgCM() const			{ return m_CompRefAvgCM; }
	const CComparisonEx<CString>&	GetCompRTDC() const			{ return m_CompRTDC; }
	
	int						GetnMaxNRCount() const				{ return m_nMaxNRCount; }
	int						GetnSameDefectMargin() const		{ return m_nSameDefectMargin; }
	BOOL					GetZoneAndOr() const				{ return m_bSelZoneAndOr; }

	
	Judgement				GetJudgement() const				{ return m_Judgement; }
	CString					GetJudgeComment() const				{ return m_strJudgeComment; }
	int						GetUseItemCount() const;
protected:
	CCFDefectJudgeItem();	// CamNo, ScanNo°¡ ¾ø´Â °æ¿ì¸¦ ¸·±â À§ÇÔ.
	int						m_nCameraNum;
	int						m_nScanNum;
	
	BOOL					ReadComparisonInt(CComparisonEx<int>& Cmp, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg);
	BOOL					ReadComparisonString(CComparisonEx<CString>& Cmp, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg);
	BOOL					WriteComparisonInt(const CComparisonEx<int>& Cmp, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg) const;
	BOOL					WriteComparisonString(const CComparisonEx<CString>& Cmp, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg) const;
	BOOL					ReadSelectionItem(CSelectionItemEx& Sel, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg);
	BOOL					ReadSelectionItemStep(CSelectionItemEx& Sel, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg); //±èÀºÈ£(STEP)
	BOOL					WriteSelectionItem(const CSelectionItemEx& Cmp, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg) const;
	BOOL					WriteSelectionItemStep(const CSelectionItemEx& Cmp, CString strType, CString strSubType, int nIdx, CHMRegiConfig* pCfg) const; //±èÀºÈ£(STEP)

	//////////////////////////////////////////////////////////////////////////
	// Á¶°Ç
	CSelectionItemEx		m_SelCamType;
	CSelectionItemEx		m_SelStackFlag;
	CSelectionItemEx		m_SelProcType;
	CSelectionItemEx		m_SelBeforeJudge; //À±Á¤¹Î ÀÌÀü°øÁ¤ ÆÇÁ¤ °¡Á®¿À±â
	CSelectionItemEx		m_SelZone;
	CSelectionItemEx		m_SelCamNScan;
	CSelectionItemEx		m_SelStep; //±èÀºÈ£(STEP)

	CComparisonEx<int>		m_CompRScale;
	CComparisonEx<int>		m_CompSizeW;
	CComparisonEx<int>		m_CompSizeL;
	CComparisonEx<int>		m_CompPixelSize;
	CComparisonEx<int>		m_CompPeak;
	CComparisonEx<int>		m_CompSrcMin;
	CComparisonEx<int>		m_CompSrcMax;
	CComparisonEx<int>		m_CompSrcAvg;
	CComparisonEx<int>		m_CompRefMin;
	CComparisonEx<int>		m_CompRefMax;
	CComparisonEx<int>		m_CompRefAvg;

	CComparisonEx<int>		m_CompSrcMinCM;
	CComparisonEx<int>		m_CompSrcMaxCM;
	CComparisonEx<int>		m_CompSrcAvgCM;
	CComparisonEx<int>		m_CompRefMinCM;
	CComparisonEx<int>		m_CompRefMaxCM;
	CComparisonEx<int>		m_CompRefAvgCM;

	CComparisonEx<CString>	m_CompRTDC;

	int						m_nMaxNRCount;
	int						m_nSameDefectMargin;

	BOOL					m_bSelZoneAndOr;

	// ÆÇÁ¤°ª
	Judgement				m_Judgement;	// 0 : OK, 2 : TR, 3 : PR
	CString					m_strJudgeComment;
};
typedef std::vector<CCFDefectJudgeItem>				VDefectJudgeItem;
typedef std::vector<CCFDefectJudgeItem>::iterator	VDefectJudgeItemIt;

class AFX_EXT_CLASS CCFPanelJudgeItem
{
public:
	CCFPanelJudgeItem()
	{
		m_nConditionType = 0;
		m_JudgeConditionF = Judge_OK;
		m_nConditionCountF = 0;
		m_JudgeConditionS = Judge_OK;
		m_nConditionCountS = 0;
		m_Judgement = Judge_OK;
		m_strJudgement = _T("");
	}
	CCFPanelJudgeItem(const CCFPanelJudgeItem& rhs)
	{
		if (this != &rhs)
		{
			m_nConditionType	= rhs.m_nConditionType;
			m_JudgeConditionF	= rhs.m_JudgeConditionF;
			m_nConditionCountF	= rhs.m_nConditionCountF;
			m_JudgeConditionS	= rhs.m_JudgeConditionS;
			m_nConditionCountS	= rhs.m_nConditionCountS;
			m_Judgement			= rhs.m_Judgement;
			m_strJudgement		= rhs.m_strJudgement;
		}
	}
	CCFPanelJudgeItem& operator=(const CCFPanelJudgeItem& rhs)
	{
		if (this != &rhs)
		{
			m_nConditionType	= rhs.m_nConditionType;
			m_JudgeConditionF	= rhs.m_JudgeConditionF;
			m_nConditionCountF	= rhs.m_nConditionCountF;
			m_JudgeConditionS	= rhs.m_JudgeConditionS;
			m_nConditionCountS	= rhs.m_nConditionCountS;
			m_Judgement			= rhs.m_Judgement;
			m_strJudgement		= rhs.m_strJudgement;
		}

		return *this;
	}

	BOOL				ReadPanelJudgeItem(CString strType, int nIdx, CHMRegiConfig* pCfg);
	BOOL				WritePanelJudgeItem(CString strType, int nIdx, CHMRegiConfig* pCfg) const;
	
	void				SetConditionType(int nType)		{ m_nConditionType = nType; }
	void				SetJudgeConditionF(Judgement DJ){ m_JudgeConditionF = DJ; }
	void				SetConditionCountF(int nCount)	{ m_nConditionCountF = nCount; }
	void				SetJudgeConditionS(Judgement DJ){ m_JudgeConditionS = DJ; }
	void				SetConditionCountS(int nCount)	{ m_nConditionCountS = nCount; }
	void				SetJudgement(Judgement Judge)	{ m_Judgement = Judge; }
	void				SetJudgement(CString str)		{ m_strJudgement = str; }

	int					GetConditionType() const		{ return m_nConditionType; }
	Judgement			GetJudgeConditionF() const		{ return m_JudgeConditionF; }
	int					GetConditionCountF() const		{ return m_nConditionCountF; }
	Judgement			GetJudgeConditionS() const		{ return m_JudgeConditionS; }
	int					GetConditionCountS() const		{ return m_nConditionCountS; }
	Judgement			GetJudgement() const			{ return m_Judgement; }
	CString				GetJudgementString() const		{ return m_strJudgement; }

protected:
	int					m_nConditionType;	// 0 : Cell Judge, 1 : Defect Judge
	Judgement			m_JudgeConditionF;
	int					m_nConditionCountF;
	Judgement			m_JudgeConditionS;
	int					m_nConditionCountS;
	Judgement			m_Judgement;		// Subpanel¿¡ »ç¿ë
	CString				m_strJudgement;		// Panel¿¡ »ç¿ë
};
typedef std::vector<CCFPanelJudgeItem>				VPanelJudgeItem;
typedef std::vector<CCFPanelJudgeItem>::iterator	VPanelJudgeItemIt;

//////////////////////////////////////////////////////////////////////////
// Recipº° ÆÇÁ¤ Á¶°Ç
class AFX_EXT_CLASS CCFRecipeJudge
{
public:
	CCFRecipeJudge(int nCamNo, int nScanNo);
	virtual ~CCFRecipeJudge();
	CCFRecipeJudge(const CCFRecipeJudge& rhs);
	CCFRecipeJudge& operator=(const CCFRecipeJudge& rhs);

	void						ResetRecipeJudge();
	
	BOOL						ReadRecipeJudge(int iModelID, CHMRegiConfig* pCfg);
	BOOL						WriteRecipeJudge(int iModelID, CHMRegiConfig* pCfg);

	void						SetCutoffCondition(const CCFDefectJudgeItem& DJudge)	{ m_VDefectCutoff.push_back(DJudge); }
	void						SetTDCondition(const CCFDefectJudgeItem& DJudge)		{ m_VDefectTD.push_back(DJudge); }
	void						SetPDCondition(const CCFDefectJudgeItem& DJudge)		{ m_VDefectPD.push_back(DJudge); }
	void						SetSICondition(const CCFDefectJudgeItem& DJudge)		{ m_VDefectSI.push_back(DJudge); }
	void						SetNRCondition(const CCFDefectJudgeItem& DJudge)		{ m_VDefectNR.push_back(DJudge); }
	void						SetSubpanelCondition(const CCFPanelJudgeItem& PJudge)	{ m_VSubPanel.push_back(PJudge); }
	void						SetPanelCondition(const CCFPanelJudgeItem& PJudge)		{ m_VPanel.push_back(PJudge); }
	
	void						RemoveCutoffCondition(int nIdx)			{ m_VDefectCutoff.erase(m_VDefectCutoff.begin() + nIdx); }
	void						RemoveTDCondition(int nIdx)				{ m_VDefectTD.erase(m_VDefectTD.begin() + nIdx); }
	void						RemovePDCondition(int nIdx)				{ m_VDefectPD.erase(m_VDefectPD.begin() + nIdx); }
	void						RemoveSICondition(int nIdx)				{ m_VDefectSI.erase(m_VDefectSI.begin() + nIdx); }
	void						RemoveNRCondition(int nIdx)				{ m_VDefectNR.erase(m_VDefectNR.begin() + nIdx); }
	void						RemoveSubpanelCondition(int nIdx)		{ m_VSubPanel.erase(m_VSubPanel.begin() + nIdx); }
	void						RemovePanelCondition(int nIdx)			{ m_VPanel.erase(m_VPanel.begin() + nIdx); }
	
	int							GetCutoffConditionCount() const			{ return static_cast<int>(m_VDefectCutoff.size()); }
	int							GetTDConditionCount() const				{ return static_cast<int>(m_VDefectTD.size()); }
	int							GetPDConditionCount() const				{ return static_cast<int>(m_VDefectPD.size()); }
	int							GetSIConditionCount() const				{ return static_cast<int>(m_VDefectSI.size()); }
	int							GetNRConditionCount() const				{ return static_cast<int>(m_VDefectNR.size()); }
	int							GetSubpanelConditionCount() const		{ return static_cast<int>(m_VSubPanel.size()); }
	int							GetPanelConditionCount() const			{ return static_cast<int>(m_VPanel.size()); }
	
	const CCFDefectJudgeItem&	GetCutoffCondition(int nIdx) const		{ return m_VDefectCutoff[nIdx]; }
	const CCFDefectJudgeItem&	GetTDCondition(int nIdx) const			{ return m_VDefectTD[nIdx]; }
	const CCFDefectJudgeItem&	GetPDCondition(int nIdx) const			{ return m_VDefectPD[nIdx]; }
	const CCFDefectJudgeItem&	GetSICondition(int nIdx) const			{ return m_VDefectSI[nIdx]; }
	const CCFDefectJudgeItem&	GetNRCondition(int nIdx) const			{ return m_VDefectNR[nIdx]; }
	const CCFPanelJudgeItem&	GetSubpanelCondition(int nIdx) const	{ return m_VSubPanel[nIdx]; }
	const CCFPanelJudgeItem&	GetPanelCondition(int nIdx) const		{ return m_VPanel[nIdx]; }
	
	BOOL						SwapCutoffCondition(int nFirst, int nSecond);
	BOOL						SwapTDCondition(int nFirst, int nSecond);
	BOOL						SwapPDCondition(int nFirst, int nSecond);
	BOOL						SwapSICondition(int nFirst, int nSecond);
	BOOL						SwapNRCondition(int nFirst, int nSecond);
// minion't,2009-11-08
public:
	int						GetCameraNumber(void) { return m_nCameraNum; }
	int						GetScanNumber(void) { return m_nScanNum; }

protected:
	CCFRecipeJudge();	// CamNo, ScanNo°¡ ¾ø´Â °æ¿ì¸¦ ¸·±â À§ÇÔ.
	int						m_nCameraNum;
	int						m_nScanNum;
	
	//////////////////////////////////////////////////////////////////////////
	// Cutoff Á¶°Ç
	VDefectJudgeItem		m_VDefectCutoff;

	//////////////////////////////////////////////////////////////////////////
	// TD ÆÇÁ¤ Á¶°Ç
	VDefectJudgeItem		m_VDefectTD;

	//////////////////////////////////////////////////////////////////////////
	// PD ÆÇÁ¤ Á¶°Ç
	VDefectJudgeItem		m_VDefectPD;

	//////////////////////////////////////////////////////////////////////////
	// SaveImage ÆÇÁ¤ Á¶°Ç
	VDefectJudgeItem		m_VDefectSI;

	//////////////////////////////////////////////////////////////////////////
	// Defect ÆÇÁ¤ Á¶°Ç
	VDefectJudgeItem		m_VDefectNR;

	//////////////////////////////////////////////////////////////////////////
	// Cell ÆÇÁ¤ Á¶°Ç
	VPanelJudgeItem			m_VSubPanel;

	//////////////////////////////////////////////////////////////////////////
	// Glass ÆÇÁ¤ Á¶°Ç
	VPanelJudgeItem			m_VPanel;
};

#endif // !defined(AFX_CFRECIPEJUDGE_H__19D17C40_D748_433F_B0C7_66E6CE8DCB37__INCLUDED_)