#if !defined(__GLASS_RECIPE_HEADER_INCLUDED__)
#define __GLASS_RECIPE_HEADER_INCLUDED__

#include "HMRegiConfig.h"
#include "ModelRecipeHeader.h"

#define MAX_ZONE_NUM			16
#define MAX_MASKDATA			20
#define MAX_STRING_LENGTH		100

class AFX_EXT_CLASS CMaskShot
{
public:
	int			m_nStartX;
	int			m_nStartY;
	int			m_nEndX;
	int			m_nEndY;

	CMaskShot()
	{
		m_nStartX	= 0;
		m_nStartY	= 0;
		m_nEndX	= 0;
		m_nEndY	= 0;
	}
	BOOL		InsideOfX(int nX)
	{
		if (m_nStartX < m_nEndX)
			return (nX >= m_nStartX && nX < m_nEndX) ? TRUE : FALSE;
		else
			return (nX >= m_nEndX && nX < m_nStartX) ? TRUE : FALSE;
	}
	BOOL		InsideOfY(int nY)
	{
		if (m_nStartY < m_nEndY)
			return (nY >= m_nStartY && nY < m_nEndY) ? TRUE : FALSE;
		else
			return (nY >= m_nEndY && nY < m_nStartY) ? TRUE : FALSE;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile,int iIndex)
	{
		CString			strSection;

		strSection.Format("GLASS_MASKSHOT_SHOTX_%d",iIndex);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nStartX);
		strSection.Format("GLASS_MASKSHOT_SHOTY_%d",iIndex);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nStartY);
		strSection.Format("GLASS_MASKSHOT_ACTIVEX_%d",iIndex);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nEndX);
		strSection.Format("GLASS_MASKSHOT_ACTIVEY_%d",iIndex);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nEndY);
		
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile,int iIndex)
	{
		CString			strSection;

		strSection.Format("GLASS_MASKSHOT_SHOTX_%d",iIndex);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nStartX);
		strSection.Format("GLASS_MASKSHOT_SHOTY_%d",iIndex);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nStartY);
		strSection.Format("GLASS_MASKSHOT_ACTIVEX_%d",iIndex);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nEndX);
		strSection.Format("GLASS_MASKSHOT_ACTIVEY_%d",iIndex);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nEndY);

		return TRUE;
	}	
};

class AFX_EXT_CLASS CGLASS_MASKING_CAMTYPE_PARM
{
public:
	BOOL				m_bCDB;
	BOOL				m_bCDW;
	BOOL				m_bMDB;
	BOOL				m_bMDW;
	int					m_nCDSizeB;
	int					m_nCDSizeW;
	int					m_nCDAlarmB;
	int					m_nCDAlarmW;
	int					m_nMDSizeB;
	int					m_nMDSizeW;
	int					m_nMDAlarmB;
	int					m_nMDAlarmW;

	CGLASS_MASKING_CAMTYPE_PARM()
	{		
		Reset();
	}
	void Reset()
	{		
		m_bCDB = m_bCDW = m_bMDB = m_bMDW = FALSE;
		m_nCDSizeB = m_nCDSizeW = m_nCDAlarmB = m_nCDAlarmW = m_nMDSizeB = 0;
		m_nMDSizeW = m_nMDAlarmB = m_nMDAlarmW = 0;
	}	
	CGLASS_MASKING_CAMTYPE_PARM& operator=(const CGLASS_MASKING_CAMTYPE_PARM &rh)
	{
		m_bCDB = rh.m_bCDB;
		m_bCDW = rh.m_bCDW;
		m_bMDB = rh.m_bMDB;
		m_bMDW = rh.m_bMDW;
		m_nCDSizeB = rh.m_nCDSizeB;		
		m_nCDSizeW = rh.m_nCDSizeW;	
		m_nCDAlarmB = rh.m_nCDAlarmB;
		m_nCDAlarmW = rh.m_nCDAlarmW;
		m_nMDSizeB = rh.m_nMDSizeB;
		m_nMDSizeW = rh.m_nMDSizeW;
		m_nMDAlarmB = rh.m_nMDAlarmB;
		m_nMDAlarmW = rh.m_nMDAlarmW;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile,CameraType CamType)
	{
		CString			strSection,strTmp;

		switch(CamType)
		{
		case CamType_Reflex: strTmp = "R"; break;
		case CamType_Transfer: strTmp = "T"; break;
		default:
			return FALSE;
		}		
		strSection.Format("GLASS_CDB_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_bCDB);
		strSection.Format("GLASS_CDW_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_bCDW);
		strSection.Format("GLASS_MDB_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_bMDB);
		strSection.Format("GLASS_MDW_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_bMDW);
		strSection.Format("GLASS_CDSizeB_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDSizeB);
		strSection.Format("GLASS_CDSizeW_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDSizeW);
		strSection.Format("GLASS_CDAlarmB_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDAlarmB);
		strSection.Format("GLASS_CDAlarmW_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDAlarmW);
		strSection.Format("GLASS_MDSizeB_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDSizeB);
		strSection.Format("GLASS_MDSizeW_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDSizeW);
		strSection.Format("GLASS_MDAlarmB_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDAlarmB);
		strSection.Format("GLASS_MDAlarmW_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDAlarmW);

		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile,CameraType CamType)
	{
		CString			strSection,strTmp;

		switch(CamType)
		{
		case CamType_Reflex: strTmp = "R"; break;
		case CamType_Transfer: strTmp = "T"; break;
		default:
			return FALSE;
		}		
		strSection.Format("GLASS_CDB_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_bCDB);
		strSection.Format("GLASS_CDW_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_bCDW);
		strSection.Format("GLASS_MDB_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_bMDB);
		strSection.Format("GLASS_MDW_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_bMDW);
		strSection.Format("GLASS_CDSizeB_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDSizeB);
		strSection.Format("GLASS_CDSizeW_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDSizeW);
		strSection.Format("GLASS_CDAlarmB_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDAlarmB);
		strSection.Format("GLASS_CDAlarmW_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nCDAlarmW);
		strSection.Format("GLASS_MDSizeB_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDSizeB);
		strSection.Format("GLASS_MDSizeW_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDSizeW);
		strSection.Format("GLASS_MDAlarmB_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDAlarmB);
		strSection.Format("GLASS_MDAlarmW_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nMDAlarmW);
		return TRUE;
	}	
};

class AFX_EXT_CLASS CGLASS_MASKING_PARM
{
public:
	BOOL				m_bFindCommonRP;
	BOOL				m_bFindMaskRP;
	int					m_nMaskRPCount;
	int					m_nCommonRPGlass;
	int					m_nCommonRPCount;
	int					m_nMaskShotCount;
	CMaskShot			*m_MaskShot;

	BOOL				m_bUseCDFilter;	
	BOOL				m_bUseMDFilter;	
	int					m_nCDFilter;	// 0 : Pixel, 1 : RScale
	int					m_nMDFilter;	// 0 : Pixel, 1 : RScale

	CGLASS_MASKING_CAMTYPE_PARM	m_pRefMaskParm;
	CGLASS_MASKING_CAMTYPE_PARM	m_pTransMaskParm;

	CGLASS_MASKING_PARM()
	{
		m_MaskShot = NULL;
		Reset();
	}
	~CGLASS_MASKING_PARM()
	{
		if(m_MaskShot != NULL)
			delete[] m_MaskShot, m_MaskShot=NULL;
	}
	void SetMaskShot(int nShotCnt)
	{
		if(m_MaskShot != NULL)
			delete[] m_MaskShot, m_MaskShot=NULL;
		if(nShotCnt <= 0)
			return;
		m_nMaskShotCount = nShotCnt;
		m_MaskShot = new CMaskShot[nShotCnt];
	}
	void Reset()
	{		
		m_bFindCommonRP = m_bFindMaskRP = m_bUseCDFilter = m_bUseMDFilter = FALSE;
		m_nMaskRPCount = m_nCommonRPGlass = m_nCommonRPCount = m_nMaskShotCount = m_nCDFilter = m_nMDFilter = 0;
		if(m_MaskShot != NULL)
			delete[] m_MaskShot, m_MaskShot=NULL;
		m_pRefMaskParm.Reset();
		m_pTransMaskParm.Reset();
	}	
	CGLASS_MASKING_PARM& operator=(const CGLASS_MASKING_PARM &rh)
	{
		m_bFindCommonRP = rh.m_bFindCommonRP;
		m_bFindMaskRP = rh.m_bFindMaskRP;
		m_bUseCDFilter = rh.m_bUseCDFilter;
		m_bUseMDFilter = rh.m_bUseMDFilter;
		m_nMaskRPCount = rh.m_nMaskRPCount;		
		m_nCommonRPGlass = rh.m_nCommonRPGlass;	
		m_nCommonRPCount = rh.m_nCommonRPCount;		
		m_nCDFilter = rh.m_nCDFilter;
		m_nMDFilter = rh.m_nMDFilter;

		SetMaskShot(rh.m_nMaskShotCount);
		int		iLoop;
		for(iLoop=0;iLoop<m_nMaskShotCount;iLoop++)
		{
			m_MaskShot[iLoop] = rh.m_MaskShot[iLoop];
		}

		m_pRefMaskParm = m_pRefMaskParm;
		m_pTransMaskParm = m_pTransMaskParm;

		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		pFile->GetItemValue("GLASS_FINDCOMMONRP", m_bFindCommonRP);
		pFile->GetItemValue("GLASS_FINDMASKRP", m_bFindMaskRP);
		pFile->GetItemValue("GLASS_CDFLTUSE", m_bUseCDFilter);
		pFile->GetItemValue("GLASS_MDFLTUSE", m_bUseMDFilter);
		pFile->GetItemValue("GLASS_MASKRPCOUNT", m_nMaskRPCount);		
		pFile->GetItemValue("GLASS_COMMONRPGLASS", m_nCommonRPGlass);
		pFile->GetItemValue("GLASS_COMMONRPCOUNT", m_nCommonRPCount);
		pFile->GetItemValue("GLASS_CDFLT", m_nCDFilter);
		pFile->GetItemValue("GLASS_MDFLT", m_nMDFilter);
		pFile->GetItemValue("GLASS_MASKSHOTCOUNT", m_nMaskShotCount);

		SetMaskShot(m_nMaskShotCount);
		int		iLoop;
		for(iLoop=0;iLoop<m_nMaskShotCount;iLoop++)
		{
			m_MaskShot[iLoop].ReadRecipe(pFile,iLoop);
		}
		m_pRefMaskParm.ReadRecipe(pFile,CamType_Reflex);
		m_pTransMaskParm.ReadRecipe(pFile,CamType_Transfer);
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("GLASS_FINDCOMMONRP", m_bFindCommonRP);
		pFile->SetItemValue("GLASS_FINDMASKRP", m_bFindMaskRP);
		pFile->SetItemValue("GLASS_CDFLTUSE", m_bUseCDFilter);
		pFile->SetItemValue("GLASS_MDFLTUSE", m_bUseMDFilter);
		pFile->SetItemValue("GLASS_MASKRPCOUNT", m_nMaskRPCount);		
		pFile->SetItemValue("GLASS_COMMONRPGLASS", m_nCommonRPGlass);
		pFile->SetItemValue("GLASS_COMMONRPCOUNT", m_nCommonRPCount);
		pFile->SetItemValue("GLASS_CDFLT", m_nCDFilter);
		pFile->SetItemValue("GLASS_MDFLT", m_nMDFilter);	
		pFile->SetItemValue("GLASS_MASKSHOTCOUNT", m_nMaskShotCount);	

		int		iLoop;
		for(iLoop=0;iLoop<m_nMaskShotCount;iLoop++)
		{
			m_MaskShot[iLoop].WriteRecipe(pFile,iLoop);
		}
		m_pRefMaskParm.WriteRecipe(pFile,CamType_Reflex);
		m_pTransMaskParm.WriteRecipe(pFile,CamType_Transfer);
		return TRUE;
	}	
};

//////////////////////////////////////////////////////////////////////////
// Edge Crack 
class AFX_EXT_CLASS CEDGECRACK_RECIPE_PARM
{
public:
	BOOL				m_bEdgeCrack;
	int					m_nEdgeCrackInspRange;		// °Ë»ç Æø
	int					m_nEdgeCrackInspThreshold;	// °Ë»ç ¹®Åΰª
	int					m_nEdgeCrackMarginX;		// XÃà ¸¶Áø
	int					m_nEdgeCrackMarginY;		// YÃà ¸¶Áø
	int					m_nEdgeCrackInspThresPixel;
	int					m_bEdgeCrackUseConv;

	CEDGECRACK_RECIPE_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_bEdgeCrack = FALSE;
		m_nEdgeCrackInspRange = 0;
		m_nEdgeCrackInspThreshold = 0;
		m_nEdgeCrackMarginX = 0;
		m_nEdgeCrackMarginY = 0;
		m_nEdgeCrackInspThresPixel = 0;
		m_bEdgeCrackUseConv = 0;
	}
	CEDGECRACK_RECIPE_PARM& operator=(const CEDGECRACK_RECIPE_PARM &rh)
	{
		m_bEdgeCrack = rh.m_bEdgeCrack;
		m_nEdgeCrackInspRange = rh.m_nEdgeCrackInspRange;
		m_nEdgeCrackInspThreshold = rh.m_nEdgeCrackInspThreshold;
		m_nEdgeCrackMarginX = rh.m_nEdgeCrackMarginX;
		m_nEdgeCrackMarginY = rh.m_nEdgeCrackMarginY;
		m_nEdgeCrackInspThresPixel = rh.m_nEdgeCrackInspThresPixel;
		m_bEdgeCrackUseConv = rh.m_bEdgeCrackUseConv;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		pFile->GetItemValue("GLASS_EDGECRACK", m_bEdgeCrack);
		pFile->GetItemValue("GLASS_EDGECRACKINSPRANGE", m_nEdgeCrackInspRange, 1000);
		pFile->GetItemValue("GLASS_EDGECRACKINSPTHRESHOLD", m_nEdgeCrackInspThreshold, 30);
		pFile->GetItemValue("GLASS_EDGECRACKMARGINX", m_nEdgeCrackMarginX, 5000);
		pFile->GetItemValue("GLASS_EDGECRACKMARGINY", m_nEdgeCrackMarginY, 5000);
		pFile->GetItemValue("GLASS_EDGECRACKTHRESPIXEL", m_nEdgeCrackInspThresPixel, 20);
		pFile->GetItemValue("GLASS_EDGECRACKUSECONV", m_bEdgeCrackUseConv, FALSE);

		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("GLASS_EDGECRACK", m_bEdgeCrack);
		pFile->SetItemValue("GLASS_EDGECRACKINSPRANGE", m_nEdgeCrackInspRange);
		pFile->SetItemValue("GLASS_EDGECRACKINSPTHRESHOLD", m_nEdgeCrackInspThreshold);
		pFile->SetItemValue("GLASS_EDGECRACKMARGINX", m_nEdgeCrackMarginX);
		pFile->SetItemValue("GLASS_EDGECRACKMARGINY", m_nEdgeCrackMarginY);
		pFile->SetItemValue("GLASS_EDGECRACKTHRESPIXEL", m_nEdgeCrackInspThresPixel);
		pFile->SetItemValue("GLASS_EDGECRACKUSECONV", m_bEdgeCrackUseConv);
		return TRUE;
	}
	BOOL ReadRecipe(CMosisPacket *pPacket)
	{			
		pPacket->ReadValue(m_bEdgeCrack);	
		pPacket->ReadValue(m_nEdgeCrackInspRange);
		pPacket->ReadValue(m_nEdgeCrackInspThreshold);
		pPacket->ReadValue(m_nEdgeCrackMarginX);
		pPacket->ReadValue(m_nEdgeCrackMarginY);
		pPacket->ReadValue(m_nEdgeCrackInspThresPixel);
		pPacket->ReadValue(m_bEdgeCrackUseConv);
		return TRUE;
	}
	BOOL WriteRecipe(CMosisPacket *pPacket)
	{
		pPacket->WriteValue(m_bEdgeCrack);	
		pPacket->WriteValue(m_nEdgeCrackInspRange);
		pPacket->WriteValue(m_nEdgeCrackInspThreshold);
		pPacket->WriteValue(m_nEdgeCrackMarginX);
		pPacket->WriteValue(m_nEdgeCrackMarginY);
		pPacket->WriteValue(m_nEdgeCrackInspThresPixel);
		pPacket->WriteValue(m_bEdgeCrackUseConv);
		return TRUE;
	}
};

class AFX_EXT_CLASS CRECIPE_INFO_PARM
{	
public:
	char				m_strRecipeName[MAX_STRING_LENGTH];			// ·¹½ÃÇÇ À̸§.
	char				m_strDelegateRecipe[MAX_STRING_LENGTH];		// ·¹½ÃÇÇ À̸§.
	char				m_strRecipeFileName[MAX_STRING_LENGTH];		// ·¹Çǽà ÆÄÀϸí
	char				m_strRecipeComment[MAX_STRING_LENGTH];			// Recipe ¼³¸í
	int					m_nSoftRevision;			

	CRECIPE_INFO_PARM()
	{
		Reset();
	}
	void Reset()
	{
		ZeroMemory(m_strRecipeName,sizeof(char)*MAX_STRING_LENGTH);
		ZeroMemory(m_strDelegateRecipe,sizeof(char)*MAX_STRING_LENGTH);
		ZeroMemory(m_strRecipeFileName,sizeof(char)*MAX_STRING_LENGTH);
		ZeroMemory(m_strRecipeComment,sizeof(char)*MAX_STRING_LENGTH);		
		m_nSoftRevision = 0;
	}
	CRECIPE_INFO_PARM& operator=(const CRECIPE_INFO_PARM &rh)
	{
		CopyMemory(m_strRecipeName,rh.m_strRecipeName,sizeof(char)*MAX_STRING_LENGTH);
		CopyMemory(m_strDelegateRecipe,rh.m_strDelegateRecipe,sizeof(char)*MAX_STRING_LENGTH);
		CopyMemory(m_strRecipeFileName,rh.m_strRecipeFileName,sizeof(char)*MAX_STRING_LENGTH);
		CopyMemory(m_strRecipeComment,rh.m_strRecipeComment,sizeof(char)*MAX_STRING_LENGTH);
		m_nSoftRevision = rh.m_nSoftRevision;
		return *this;
	}
	void SetRecipeName(CString strRecipe)
	{
		CopyMemory(m_strRecipeName,strRecipe.GetBuffer(0),strRecipe.GetLength());
	}
	void SetRecipeFileName(CString strFile)
	{
		CopyMemory(m_strRecipeFileName,strFile.GetBuffer(0),strFile.GetLength());
	}
	void SetDelegateRecipe(CString strDele)
	{
		CopyMemory(m_strDelegateRecipe,strDele.GetBuffer(0),strDele.GetLength());
	}
	void SetRecipeComment(CString strComment)
	{
		CopyMemory(m_strRecipeComment,strComment.GetBuffer(0),strComment.GetLength());
	}
	CString GetRecipeName()
	{
		CString		strRecipe;		
		strRecipe.Format("%s",m_strRecipeName);
		return strRecipe;
	}
	CString GetRecipeFileName()
	{
		CString		strFile;		
		strFile.Format("%s",m_strRecipeFileName);
		return strFile;
	}
	CString GetDelegateRecipe()
	{
		CString		str;		
		str.Format("%s",m_strDelegateRecipe);
		return str;
	}
	CString GetRecipeComment()
	{
		CString		str;		
		str.Format("%s",m_strRecipeComment);
		return str;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		CString			str;
		pFile->GetItemValue("SOFTREV", m_nSoftRevision);
		pFile->GetItemValue("GLASS_DELEGATERECIPE", str);	// À§ÀÓµÈ Recipe
		CopyMemory(m_strDelegateRecipe,str.GetBuffer(0),str.GetLength());		
		pFile->GetItemValue("GLASS_RECIPECOMMENT", str);	// Glass ¸ðµ¨¸í.
		if (str.IsEmpty())
			pFile->GetItemValue("GLASS_MODELNAME", str);	// Glass ¸ðµ¨¸í.
		CopyMemory(m_strRecipeComment,str.GetBuffer(0),str.GetLength());
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("SOFTREV", m_nSoftRevision);
		pFile->SetItemValue("GLASS_DELEGATERECIPE", m_strDelegateRecipe);	// À§ÀÓµÈ Recipe
		pFile->SetItemValue("GLASS_RECIPECOMMENT", m_strRecipeComment);	// Glass ¸ðµ¨¸í.
		return TRUE;
	}
	BOOL ReadRecipe(CMosisPacket *pPacket)
	{			
		pPacket->ReadArray(m_strRecipeName,MAX_STRING_LENGTH);
		return TRUE;
	}
	BOOL WriteRecipe(CMosisPacket *pPacket)
	{
		pPacket->WriteArray(m_strRecipeName,MAX_STRING_LENGTH);
		return TRUE;
	}
};

class AFX_EXT_CLASS CLIGHT_RECIPE_PARM
{		
public:
	int					m_nLightMax;	// ¾Ë¶÷ »óÇÑ
	int					m_nLightMin;	// ¾Ë¶÷ ÇÏÇÑ
	int					m_nLightAdjMax;	// Á¶Àý »óÇÑ
	int					m_nLightAdjMin;	// Á¶Àý ÇÏÇÑ
	int					m_nLightSet;	// ¼³Á¤
	int					m_nLightAlarm;	// ¾Ë¶÷ ¹ß»ý Á¶°Ç
	int					m_nLightDefault; // ±âº» º¼·ý

	CLIGHT_RECIPE_PARM()
	{	
		Reset();
	}	
	void Reset()
	{		
		m_nLightMax = m_nLightMin = m_nLightAdjMax = m_nLightAdjMin = 0;
		m_nLightSet = m_nLightAlarm = m_nLightDefault = 0;				
	}
	
	CLIGHT_RECIPE_PARM& operator=(const CLIGHT_RECIPE_PARM &rh)
	{		
		m_nLightMax = rh.m_nLightMax;
		m_nLightMin = rh.m_nLightMin;
		m_nLightAdjMax = rh.m_nLightAdjMax;
		m_nLightAdjMin = rh.m_nLightAdjMin;
		m_nLightSet = rh.m_nLightSet;
		m_nLightAlarm = rh.m_nLightAlarm;
		m_nLightDefault = rh.m_nLightDefault;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile,CameraType Camtype)
	{
		CString			strSection,strTmp;
		
		switch (Camtype)
		{
		case CamType_Reflex: strTmp = "R"; break;
		case CamType_Transfer: strTmp = "T"; break;
		default:
			return FALSE;
		}
		strSection.Format("GLASS_LIGHTMAX_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightMax);
		strSection.Format("GLASS_LIGHTMIN_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightMin);
		strSection.Format("GLASS_LIGHTADJMAX_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightAdjMax);
		strSection.Format("GLASS_LIGHTADJMIN_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightAdjMin);
		strSection.Format("GLASS_LIGHTSET_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightSet);
		strSection.Format("GLASS_LIGHTALARM_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightAlarm,2);
		strSection.Format("GLASS_LIGHTDEFAULT_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightDefault,50);		
		
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile,CameraType Camtype)
	{
		CString			strSection,strTmp;

		switch (Camtype)
		{
		case CamType_Reflex: strTmp = "R"; break;
		case CamType_Transfer: strTmp = "T"; break;
		default:
			return FALSE;
		}
		strSection.Format("GLASS_LIGHTMAX_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightMax);
		strSection.Format("GLASS_LIGHTMIN_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightMin);
		strSection.Format("GLASS_LIGHTADJMAX_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightAdjMax);
		strSection.Format("GLASS_LIGHTADJMIN_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightAdjMin);
		strSection.Format("GLASS_LIGHTSET_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightSet);
		strSection.Format("GLASS_LIGHTALARM_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightAlarm);
		strSection.Format("GLASS_LIGHTDEFAULT_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nLightDefault);

		return TRUE;
	}
};

class AFX_EXT_CLASS CCAMERA_INSPECT_PARM
{
public:
	int			m_nCamNum;
	int			m_nConvMode;
	int			m_nThresFindGlass;
	BOOL		m_bIsZone;
	BOOL		m_bUseZoneData;		
	BOOL		m_bZoneFailUsePich;
	int			m_nZonFailPitchCycleConv;
	int			m_nZonFailPitchCycleScan;
	int			m_nZoneFailConvMode;
	
	CCAMERA_INSPECT_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_nConvMode = 0;
		m_nCamNum = 0;
		m_nThresFindGlass = 0;
		m_bIsZone = m_bUseZoneData = m_bZoneFailUsePich = FALSE;
		m_nZonFailPitchCycleConv = m_nZonFailPitchCycleScan = m_nZonFailPitchCycleScan = m_nZoneFailConvMode = 0;
	}
	CCAMERA_INSPECT_PARM& operator=(const CCAMERA_INSPECT_PARM &rh)
	{
		m_nCamNum = rh.m_nCamNum;
		m_nConvMode = rh.m_nConvMode;
		m_nThresFindGlass = rh.m_nThresFindGlass;
		m_bIsZone = rh.m_bIsZone;
		m_bUseZoneData = rh.m_bUseZoneData;
		m_bZoneFailUsePich = rh.m_bZoneFailUsePich;
		m_nZonFailPitchCycleConv = rh.m_nZonFailPitchCycleConv;
		m_nZonFailPitchCycleScan = rh.m_nZonFailPitchCycleScan;
		m_nZonFailPitchCycleScan = rh.m_nZonFailPitchCycleScan;
		m_nZoneFailConvMode = rh.m_nZoneFailConvMode;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile,CameraType Camtype)
	{
		CString			strSection,strTmp;

		switch (Camtype)
		{
		case CamType_Reflex: strTmp = "R"; break;
		case CamType_Transfer: strTmp = "T"; break;
		default:
			return FALSE;
		}

		strSection.Format("INSPECT_MODE_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nConvMode);
		strSection.Format("INSPECT_FINDGLASS_THRES_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_nThresFindGlass);		
		strSection.Format("INSPECT_GLASS_ZONEDATA_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection, m_bUseZoneData);	
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_USE_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection,m_bZoneFailUsePich, FALSE);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_CYCLECONV_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection,m_nZonFailPitchCycleConv, 2);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_CYCLESCAN_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection,m_nZonFailPitchCycleScan, 2);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_CONVMODE_%s",strTmp);
		pFile->GetItemValue((LPSTR)(LPCTSTR)strSection,m_nZoneFailConvMode, 0);
		return TRUE;			
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile,CameraType Camtype)
	{
		CString			strSection,strTmp;

		switch (Camtype)
		{
		case CamType_Reflex: strTmp = "R"; break;
		case CamType_Transfer: strTmp = "T"; break;
		default:
			return FALSE;
		}
		strSection.Format("INSPECT_MODE_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nConvMode);
		strSection.Format("INSPECT_FINDGLASS_THRES_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_nThresFindGlass);
		strSection.Format("INSPECT_GLASS_ZONEDATA_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection, m_bUseZoneData);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_USE_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection,m_bZoneFailUsePich);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_CYCLECONV_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection,m_nZonFailPitchCycleConv);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_CYCLESCAN_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection,m_nZonFailPitchCycleScan);
		strSection.Format("INSPECT_GLASS_INSPECTORZONEFAIL_CONVMODE_%s",strTmp);
		pFile->SetItemValue((LPSTR)(LPCTSTR)strSection,m_nZoneFailConvMode);
		return TRUE;
	}
	BOOL ReadRecipe(CMosisPacket *pPacket)
	{			
		pPacket->ReadValue(m_nCamNum);
		pPacket->ReadValue(m_nConvMode);
		pPacket->ReadValue(m_nThresFindGlass);
		pPacket->ReadValue(m_bUseZoneData);
		pPacket->ReadValue(m_bZoneFailUsePich);
		pPacket->ReadValue(m_nZonFailPitchCycleConv);
		pPacket->ReadValue(m_nZonFailPitchCycleScan);
		pPacket->ReadValue(m_nZoneFailConvMode);
		return TRUE;
	}
	BOOL WriteRecipe(CMosisPacket *pPacket)
	{
		pPacket->WriteValue(m_nCamNum);
		pPacket->WriteValue(m_nConvMode);
		pPacket->WriteValue(m_nThresFindGlass);
		pPacket->WriteValue(m_bUseZoneData);
		pPacket->WriteValue(m_bZoneFailUsePich);
		pPacket->WriteValue(m_nZonFailPitchCycleConv);
		pPacket->WriteValue(m_nZonFailPitchCycleScan);
		pPacket->WriteValue(m_nZoneFailConvMode);
		return TRUE;
	}
};

class AFX_EXT_CLASS CGLASS_ALIGN_PARM
{
public:
	BOOL				m_bUsePreAlign;//µµ¼®
	BOOL				m_bDetectAlign;	
	BOOL				m_bAlignUseTM;
	BOOL				m_bAlignTempAutoSave;
	int					m_nAlignTH;
	int					m_nAlignMergeRange;
	int					m_nAlignMatchRate;

	BOOL				m_bEdgeAlign;
	int					m_nEdgeAlignTH;
	int					m_nEdgeAlignFindLine;

	CGLASS_ALIGN_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_nAlignTH = m_nAlignMergeRange = m_nAlignMatchRate = m_nEdgeAlignTH = m_nEdgeAlignFindLine = 0;
		m_bDetectAlign = m_bAlignUseTM = m_bAlignTempAutoSave = m_bEdgeAlign = FALSE;
	}	
	CGLASS_ALIGN_PARM& operator=(const CGLASS_ALIGN_PARM &rh)
	{
		m_bUsePreAlign = rh.m_bUsePreAlign;
		m_nAlignTH = rh.m_nAlignTH;
		m_nAlignMergeRange = rh.m_nAlignMergeRange;
		m_nAlignMatchRate = rh.m_nAlignMatchRate;
		m_bDetectAlign = rh.m_bDetectAlign;
		m_bAlignUseTM = rh.m_bAlignUseTM;		
		m_bAlignTempAutoSave = rh.m_bAlignTempAutoSave;	
		m_bEdgeAlign = rh.m_bEdgeAlign;
		m_nEdgeAlignTH = rh.m_nEdgeAlignTH;
		m_nEdgeAlignFindLine = rh.m_nEdgeAlignFindLine;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		pFile->GetItemValue("GLASS_PRE_ALIGN", m_bUsePreAlign);
		pFile->GetItemValue("GLASS_ALIGNTH", m_nAlignTH);
		pFile->GetItemValue("GLASS_ALIGNMERGERANGE", m_nAlignMergeRange);
		pFile->GetItemValue("GLASS_ALIGNMATCHRATE", m_nAlignMatchRate);
		pFile->GetItemValue("GLASS_DETECTALIGN", m_bDetectAlign);
		pFile->GetItemValue("GLASS_ALIGNTM", m_bAlignUseTM);		
		pFile->GetItemValue("GLASS_ALIGNTEMP_AUTOSAVE", m_bAlignTempAutoSave);
		pFile->GetItemValue("GLASS_EDGEALIGN", m_bEdgeAlign);
		pFile->GetItemValue("GLASS_EDGEALIGNTH", m_nEdgeAlignTH);
		pFile->GetItemValue("GLASS_EDGEALIGNFINDLINE", m_nEdgeAlignFindLine);
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("GLASS_PRE_ALIGN", m_bUsePreAlign);
		pFile->SetItemValue("GLASS_ALIGNTH", m_nAlignTH);
		pFile->SetItemValue("GLASS_ALIGNMERGERANGE", m_nAlignMergeRange);
		pFile->SetItemValue("GLASS_ALIGNMATCHRATE", m_nAlignMatchRate);
		pFile->SetItemValue("GLASS_DETECTALIGN", m_bDetectAlign);
		pFile->SetItemValue("GLASS_ALIGNTM", m_bAlignUseTM);		
		pFile->SetItemValue("GLASS_ALIGNTEMP_AUTOSAVE", m_bAlignTempAutoSave);
		pFile->SetItemValue("GLASS_EDGEALIGN", m_bEdgeAlign);
		pFile->SetItemValue("GLASS_EDGEALIGNTH", m_nEdgeAlignTH);
		pFile->SetItemValue("GLASS_EDGEALIGNFINDLINE", m_nEdgeAlignFindLine);	
		return TRUE;
	}
	BOOL ReadRecipe(CMosisPacket *pPacket)
	{	
		pPacket->ReadValue(m_bUsePreAlign);
		pPacket->ReadValue(m_nAlignTH);
		pPacket->ReadValue(m_nAlignMergeRange);
		pPacket->ReadValue(m_nAlignMatchRate);
		pPacket->ReadValue(m_bDetectAlign);
		pPacket->ReadValue(m_bAlignUseTM);
		pPacket->ReadValue(m_bAlignTempAutoSave);
		pPacket->ReadValue(m_bEdgeAlign);
		pPacket->ReadValue(m_nEdgeAlignTH);
		pPacket->ReadValue(m_nEdgeAlignFindLine);
		return TRUE;
	}
	BOOL WriteRecipe(CMosisPacket *pPacket)
	{
		pPacket->WriteValue(m_bUsePreAlign);
		pPacket->WriteValue(m_nAlignTH);
		pPacket->WriteValue(m_nAlignMergeRange);
		pPacket->WriteValue(m_nAlignMatchRate);
		pPacket->WriteValue(m_bDetectAlign);
		pPacket->WriteValue(m_bAlignUseTM);
		pPacket->WriteValue(m_bAlignTempAutoSave);
		pPacket->WriteValue(m_bEdgeAlign);
		pPacket->WriteValue(m_nEdgeAlignTH);
		pPacket->WriteValue(m_nEdgeAlignFindLine);
		return TRUE;
	}
};

class AFX_EXT_CLASS CGLASS_RECIPE_ETC_PARM
{	
public:
	int					m_nCellNumDir;      //¿øÁ¡ ´ëºñ cell index°¡ ¾î´À ¹æÇâÀ¸·Î Áõ°¡ÇÏ´À³Ä.	
	BOOL				m_bDontStopMask;
	BOOL				m_bUseTrimmer;
	int					m_nTrimmerWidth;
	CRect				m_rectMasking[2];
	int					m_nUseSize;
	BOOL				m_bUseInspectorSizeTh;
	int					m_nInspectorMergeSize;
	int					m_nInspectorSizeThOffset;
	int					m_nOffsetType;
	BOOL				m_bSamsungJudge;
	int					m_nLightMethod;
	BOOL				m_bSaveZoneMatchingImg;

	CGLASS_RECIPE_ETC_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_nCellNumDir = m_nTrimmerWidth = 0;
		m_bDontStopMask = m_bUseTrimmer = m_nUseSize = m_bUseInspectorSizeTh = m_bSamsungJudge = FALSE;
		m_rectMasking[0] = m_rectMasking[1] = CRect(0,0,0,0);
		m_nInspectorMergeSize = m_nInspectorSizeThOffset = m_nOffsetType = m_nLightMethod = 0;
		m_bSaveZoneMatchingImg = FALSE;
	}	
	CGLASS_RECIPE_ETC_PARM& operator=(const CGLASS_RECIPE_ETC_PARM &rh)
	{
		m_nCellNumDir = rh.m_nCellNumDir;
		m_nTrimmerWidth = rh.m_nTrimmerWidth;		
		m_bDontStopMask = rh.m_bDontStopMask;
		m_bUseTrimmer = rh.m_bUseTrimmer;		
		m_rectMasking[0] = rh.m_rectMasking[0];
		m_rectMasking[1] = rh.m_rectMasking[1];
		m_nUseSize = rh.m_nUseSize;
		m_bUseInspectorSizeTh = rh.m_bUseInspectorSizeTh;
		m_nInspectorMergeSize = rh.m_nInspectorMergeSize;
		m_nInspectorSizeThOffset = rh.m_nInspectorSizeThOffset;
		m_nOffsetType = rh.m_nOffsetType;
		m_bSamsungJudge = rh.m_bSamsungJudge;
		m_nLightMethod = rh.m_nLightMethod;
		m_bSaveZoneMatchingImg = rh.m_bSaveZoneMatchingImg;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		pFile->GetItemValue("GLASS_CELLNUMDIR", m_nCellNumDir);
		pFile->GetItemValue("GLASS_TRIMMER_WIDTH", m_nTrimmerWidth);		
		pFile->GetItemValue("GLASS_DONTSTOPMASK", m_bDontStopMask);
		pFile->GetItemValue("GLASS_TRIMMER", m_bUseTrimmer);		

		int			nValue;		
		pFile->GetItemValue("GLASS_MASKING_LEFT_FIRST", nValue);
		m_rectMasking[0].left = nValue;		
		pFile->GetItemValue("GLASS_MASKING_TOP_FIRST", nValue);
		m_rectMasking[0].top = nValue;		
		pFile->GetItemValue("GLASS_MASKING_RIGHT_FIRST", nValue);
		m_rectMasking[0].right = nValue;		
		pFile->GetItemValue("GLASS_MASKING_BOTTOM_FIRST", nValue);
		m_rectMasking[0].bottom = nValue;		
		pFile->GetItemValue("GLASS_MASKING_LEFT_SECOND", nValue);
		m_rectMasking[1].left = nValue;		
		pFile->GetItemValue("GLASS_MASKING_TOP_SECOND", nValue);
		m_rectMasking[1].top = nValue;		
		pFile->GetItemValue("GLASS_MASKING_RIGHT_SECOND", nValue);
		m_rectMasking[1].right = nValue;		
		pFile->GetItemValue("GLASS_MASKING_BOTTOM_SECOND", nValue);
		m_rectMasking[1].bottom = nValue;

		pFile->GetItemValue("GLASS_INSPECTORSIZE_USE",m_nUseSize,FALSE);
		pFile->GetItemValue("GLASS_INSPECTORSIZETH_USE",m_bUseInspectorSizeTh,FALSE);
		pFile->GetItemValue("GLASS_INSPECTORMERGE_SIZE",m_nInspectorMergeSize,10);
		pFile->GetItemValue("GLASS_INSPECTORSIZETH_OFFSET",m_nInspectorSizeThOffset,3);
		pFile->GetItemValue("GLASS_INSPECTOROFFSET_TYPE",m_nOffsetType,3);
		pFile->GetItemValue("GLASS_SAMSUNG_JUDGE", m_bSamsungJudge, 0);
		pFile->GetItemValue("GLASS_LIGHTMETHOD", m_nLightMethod, 2);
		pFile->GetItemValue("GLASS_SAVEZONEMATCHING_IMG", m_bSaveZoneMatchingImg, FALSE);		

		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("GLASS_CELLNUMDIR", m_nCellNumDir);
		pFile->SetItemValue("GLASS_TRIMMER_WIDTH", m_nTrimmerWidth);		
		pFile->SetItemValue("GLASS_DONTSTOPMASK", m_bDontStopMask);
		pFile->SetItemValue("GLASS_TRIMMER", m_bUseTrimmer);		

		int			nValue;
		nValue = m_rectMasking[0].left;
		pFile->SetItemValue("GLASS_MASKING_LEFT_FIRST", nValue);
		nValue = m_rectMasking[0].top;
		pFile->SetItemValue("GLASS_MASKING_TOP_FIRST", nValue);
		nValue = m_rectMasking[0].right;
		pFile->SetItemValue("GLASS_MASKING_RIGHT_FIRST", nValue);
		nValue = m_rectMasking[0].bottom;
		pFile->SetItemValue("GLASS_MASKING_BOTTOM_FIRST", nValue);
		nValue = m_rectMasking[1].left;
		pFile->SetItemValue("GLASS_MASKING_LEFT_SECOND", nValue);
		nValue = m_rectMasking[1].top;
		pFile->SetItemValue("GLASS_MASKING_TOP_SECOND", nValue);
		nValue = m_rectMasking[1].right;
		pFile->SetItemValue("GLASS_MASKING_RIGHT_SECOND", nValue);
		nValue = m_rectMasking[1].bottom;
		pFile->SetItemValue("GLASS_MASKING_BOTTOM_SECOND", nValue);

		pFile->SetItemValue("GLASS_INSPECTORSIZE_USE",m_nUseSize);
		pFile->SetItemValue("GLASS_INSPECTORSIZETH_USE",m_bUseInspectorSizeTh);
		pFile->SetItemValue("GLASS_INSPECTORMERGE_SIZE",m_nInspectorMergeSize);
		pFile->SetItemValue("GLASS_INSPECTORSIZETH_OFFSET",m_nInspectorSizeThOffset);
		pFile->SetItemValue("GLASS_INSPECTOROFFSET_TYPE",m_nOffsetType);
		pFile->SetItemValue("GLASS_SAMSUNG_JUDGE", m_bSamsungJudge);
		pFile->SetItemValue("GLASS_LIGHTMETHOD", m_nLightMethod);
		pFile->SetItemValue("GLASS_SAVEZONEMATCHING_IMG", m_bSaveZoneMatchingImg);

		return TRUE;
	}
	BOOL ReadRecipe(CMosisPacket *pPacket)
	{			
		pPacket->ReadValue(m_rectMasking[0].left);
		pPacket->ReadValue(m_rectMasking[0].top);
		pPacket->ReadValue(m_rectMasking[0].right);
		pPacket->ReadValue(m_rectMasking[0].bottom);
		pPacket->ReadValue(m_rectMasking[1].left);
		pPacket->ReadValue(m_rectMasking[1].top);
		pPacket->ReadValue(m_rectMasking[1].right);
		pPacket->ReadValue(m_rectMasking[1].bottom);
		pPacket->ReadValue(m_nUseSize);
		pPacket->ReadValue(m_bUseInspectorSizeTh);
		pPacket->ReadValue(m_nInspectorMergeSize);
		pPacket->ReadValue(m_nInspectorSizeThOffset);
		pPacket->ReadValue(m_nOffsetType);
		pPacket->ReadValue(m_bSaveZoneMatchingImg);
		return TRUE;
	}
	BOOL WriteRecipe(CMosisPacket *pPacket)
	{		
		pPacket->WriteValue(m_rectMasking[0].left);
		pPacket->WriteValue(m_rectMasking[0].top);
		pPacket->WriteValue(m_rectMasking[0].right);
		pPacket->WriteValue(m_rectMasking[0].bottom);
		pPacket->WriteValue(m_rectMasking[1].left);
		pPacket->WriteValue(m_rectMasking[1].top);
		pPacket->WriteValue(m_rectMasking[1].right);
		pPacket->WriteValue(m_rectMasking[1].bottom);
		pPacket->WriteValue(m_nUseSize);
		pPacket->WriteValue(m_bUseInspectorSizeTh);
		pPacket->WriteValue(m_nInspectorMergeSize);
		pPacket->WriteValue(m_nInspectorSizeThOffset);
		pPacket->WriteValue(m_nOffsetType);
		pPacket->WriteValue(m_bSaveZoneMatchingImg);
		return TRUE;
	}
};

class AFX_EXT_CLASS CGLASS_STACK_PARM
{
public:
	BOOL		m_bStackFileMergeOnOff;	
	int			m_nStackFileMergeSize;
	int			m_nStackFileMergeCount;	
	BOOL		m_bCheckCameraType;
	BOOL		m_bCheckJudeType;
	BOOL		m_bCheckJugeOK;
	BOOL		m_bCheckJugePR;
	BOOL		m_bCheckCameraTypeRB;
	BOOL		m_bCheckCameraTypeRW;
	BOOL		m_bCheckStackStep;
	BOOL		m_bCheckCameraTypeTB;
	BOOL		m_bCheckJudeTR;
	BOOL		m_bCheckCameraTypeTW;	
	int			m_nEditRBCutSize;
	int			m_nEditRWCutSize;
	int			m_nEditTBCutSize;
	int			m_nEditTWCutSize;
	CString		m_strStackStep[CFDEFECT_STACKCOUNT];
	int			m_nStackStepCount;

	CGLASS_STACK_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_bStackFileMergeOnOff = m_bCheckCameraType = m_bCheckJudeType = m_bCheckJugeOK = FALSE;
		m_bCheckJugePR = m_bCheckCameraTypeRB = m_bCheckCameraTypeRW = m_bCheckStackStep = m_bCheckCameraTypeTB = FALSE;
		m_bCheckJudeTR = m_bCheckCameraTypeTW = FALSE;
		m_nStackFileMergeSize =m_nStackFileMergeCount =m_nEditRBCutSize =  m_nEditRWCutSize = m_nEditTBCutSize = 0;
		m_nEditTWCutSize =  m_nStackStepCount = 0;
		int		iLoop;
		for(iLoop=0;iLoop<CFDEFECT_STACKCOUNT;iLoop++)
			m_strStackStep[iLoop].Empty();
	}	
	CGLASS_STACK_PARM& operator=(const CGLASS_STACK_PARM &rh)
	{
		m_bStackFileMergeOnOff = rh.m_bStackFileMergeOnOff;
		m_bCheckCameraType = rh.m_bCheckCameraType;
		m_bCheckJudeType = rh.m_bCheckJudeType;
		m_bCheckJugeOK = rh.m_bCheckJugeOK;
		m_bCheckJugePR = rh.m_bCheckJugePR;
		m_bCheckCameraTypeRB = rh.m_bCheckCameraTypeRB;
		m_bCheckCameraTypeRW = rh.m_bCheckCameraTypeRW;
		m_bCheckStackStep = rh.m_bCheckStackStep;
		m_bCheckCameraTypeTB = rh.m_bCheckCameraTypeTB;
		m_bCheckJudeTR = rh.m_bCheckJudeTR;
		m_bCheckCameraTypeTW = rh.m_bCheckCameraTypeTW;
		m_nStackFileMergeSize = rh.m_nStackFileMergeSize;
		m_nStackFileMergeCount = rh.m_nStackFileMergeCount;
		m_nEditRBCutSize = rh.m_nEditRBCutSize;
		m_nEditRWCutSize = rh.m_nEditRWCutSize;
		m_nEditTBCutSize = rh.m_nEditTBCutSize;
		m_nEditTWCutSize = rh.m_nEditTWCutSize;
		m_nStackStepCount = rh.m_nStackStepCount;
		int		iLoop;
		for(iLoop=0;iLoop<CFDEFECT_STACKCOUNT;iLoop++)
			m_strStackStep[iLoop] = rh.m_strStackStep[iLoop];
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		pFile->GetItemValue("GLASS_STACKFILEMERGE_ONOFF", m_bStackFileMergeOnOff,FALSE);
		pFile->GetItemValue("GLASS_STACKFILEMERGE_SIZE", m_nStackFileMergeSize,0);
		pFile->GetItemValue("GALSS_STACKFILEMERGE_COUNT",m_nStackFileMergeCount,2000);	

		pFile->GetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE",m_bCheckCameraType);
		pFile->GetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_TB",m_bCheckCameraTypeTB);
		pFile->GetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_TW",m_bCheckCameraTypeTW);
		pFile->GetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_RB",m_bCheckCameraTypeRB);
		pFile->GetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_RW",m_bCheckCameraTypeRW);


		pFile->GetItemValue("GLASS_STACK_MERGE_JUDE_TYPE",m_bCheckJudeType);
		pFile->GetItemValue("GLASS_STACK_MERGE_JUDE_TYPE_OK",m_bCheckJugeOK);
		pFile->GetItemValue("GLASS_STACK_MERGE_JUDE_TYPE_PR",m_bCheckJugePR);
		pFile->GetItemValue("GLASS_STACK_MERGE_JUDE_TYPE_TR",m_bCheckJudeTR);

		pFile->GetItemValue("GLASS_STACK_MERGE_STACK_STEP",m_bCheckStackStep);
		pFile->GetItemValue("GLASS_STACK_MERGE_STACK_STEP_COUNT",m_nStackStepCount);
		//20100506 Stack File Cut Off Size ¼³Á¤
		pFile->GetItemValue("GLASS_STACK_MERGE_CUTOFF_RB",m_nEditRBCutSize,0);
		pFile->GetItemValue("GLASS_STACK_MERGE_CUTOFF_RW",m_nEditRWCutSize,0);
		pFile->GetItemValue("GLASS_STACK_MERGE_CUTOFF_TB",m_nEditTBCutSize,0);
		pFile->GetItemValue("GLASS_STACK_MERGE_CUTOFF_TW",m_nEditTWCutSize,0);

		int		i;
		for(i = 0; i <CFDEFECT_STACKCOUNT; i++ )
		{
			pFile->GetItemValue(i,"GLASS_STACK_MERGE_STACK_STEP_NAME",m_strStackStep[i]);
		}
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("GLASS_STACKFILEMERGE_ONOFF", m_bStackFileMergeOnOff);
		pFile->SetItemValue("GLASS_STACKFILEMERGE_SIZE", m_nStackFileMergeSize);
		pFile->SetItemValue("GALSS_STACKFILEMERGE_COUNT",m_nStackFileMergeCount);

		pFile->SetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE",m_bCheckCameraType);
		pFile->SetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_TB",m_bCheckCameraTypeTB);
		pFile->SetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_TW",m_bCheckCameraTypeTW);
		pFile->SetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_RB",m_bCheckCameraTypeRB);
		pFile->SetItemValue("GLASS_STACK_MERGE_CAMERA_TYPE_RW",m_bCheckCameraTypeRW);

		pFile->SetItemValue("GLASS_STACK_MERGE_JUDE_TYPE",m_bCheckJudeType);
		pFile->SetItemValue("GLASS_STACK_MERGE_JUDE_TYPE_OK",m_bCheckJugeOK);
		pFile->SetItemValue("GLASS_STACK_MERGE_JUDE_TYPE_PR",m_bCheckJugePR);
		pFile->SetItemValue("GLASS_STACK_MERGE_JUDE_TYPE_TR",m_bCheckJudeTR);

		pFile->SetItemValue("GLASS_STACK_MERGE_STACK_STEP",m_bCheckStackStep);
		pFile->SetItemValue("GLASS_STACK_MERGE_STACK_STEP_COUNT",m_nStackStepCount);
		//20100506 Stack File Cut Off Size ¼³Á¤
		pFile->SetItemValue("GLASS_STACK_MERGE_CUTOFF_RB",m_nEditRBCutSize);
		pFile->SetItemValue("GLASS_STACK_MERGE_CUTOFF_RW",m_nEditRWCutSize);
		pFile->SetItemValue("GLASS_STACK_MERGE_CUTOFF_TB",m_nEditTBCutSize);
		pFile->SetItemValue("GLASS_STACK_MERGE_CUTOFF_TW",m_nEditTWCutSize);

		int		i;
		for(i = 0; i <CFDEFECT_STACKCOUNT; i++ )
		{
			pFile->SetItemValue(i,"GLASS_STACK_MERGE_STACK_STEP_NAME",(LPSTR)(LPCTSTR)m_strStackStep[i]);
		}
		return TRUE;
	}
};

class AFX_EXT_CLASS CGLASS_DEFECT_JUDG_PARM
{
public:
	int					m_nSizeJudgeS;
	int					m_nSizeJudgeM;
	int					m_nSizeJudgeL;
	int					m_nPeakJudgeS;
	int					m_nPeakJudgeM;

	CGLASS_DEFECT_JUDG_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_nSizeJudgeS = 0;
		m_nSizeJudgeM = 0;		
		m_nSizeJudgeL = 0;
		m_nPeakJudgeS = 0;
		m_nPeakJudgeM = 0;
	}	
	CGLASS_DEFECT_JUDG_PARM& operator=(const CGLASS_DEFECT_JUDG_PARM &rh)
	{
		m_nSizeJudgeS = rh.m_nSizeJudgeS;
		m_nSizeJudgeM = rh.m_nSizeJudgeM;
		m_nSizeJudgeL = rh.m_nSizeJudgeL;
		m_nPeakJudgeS = rh.m_nPeakJudgeS;
		m_nPeakJudgeM = rh.m_nPeakJudgeM;
		return *this;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		pFile->GetItemValue("GLASS_SSIZE_JUDGE", m_nSizeJudgeS, 5);
		pFile->GetItemValue("GLASS_MSIZE_JUDGE", m_nSizeJudgeM, 10);
		pFile->GetItemValue("GLASS_LSIZE_JUDGE", m_nSizeJudgeL, 15);
		pFile->GetItemValue("GLASS_SHEIGHT_JUDGE", m_nPeakJudgeS, 10);
		pFile->GetItemValue("GLASS_MHEIGHT_JUDGE", m_nPeakJudgeM, 20);	
		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		pFile->SetItemValue("GLASS_SSIZE_JUDGE", m_nSizeJudgeS);
		pFile->SetItemValue("GLASS_MSIZE_JUDGE", m_nSizeJudgeM);
		pFile->SetItemValue("GLASS_LSIZE_JUDGE", m_nSizeJudgeL);
		pFile->SetItemValue("GLASS_SHEIGHT_JUDGE", m_nPeakJudgeS);
		pFile->SetItemValue("GLASS_MHEIGHT_JUDGE", m_nPeakJudgeM);
		return TRUE;
	}
};

class AFX_EXT_CLASS CGLASS_RECIPE_PARM
{	
public:
	int					m_nCameraNum;	
	int					m_nScanNum;	
	GlassType			m_GlassType;				// ÇöÀç GlassÀÇ Á¾·ù
	double				m_dGlassThickness;			// Glass µÎ²².
	int					m_nSelectCellOri;		
	
	CRECIPE_INFO_PARM			m_pRcpInfoPrm;
	CCAMERA_INSPECT_PARM		m_pRefInspectPrm;
	CCAMERA_INSPECT_PARM		m_pTransInspectPrm;
	CEDGECRACK_RECIPE_PARM		m_pEdgeCrack;			// Edge Crack
	CLIGHT_RECIPE_PARM			m_pTransLightParm;		// Åõ°ú ±¤·® Parm
	CLIGHT_RECIPE_PARM			m_pRefLightParm;		// ¹Ý»ç ±¤·® Parm
	CGLASS_ALIGN_PARM			m_pGlassAlignParm;	
	CGLASS_MASKING_PARM			m_pGlassMaskParm;
	CGLASS_DEFECT_JUDG_PARM		m_pDefectJudge;
	CGLASS_STACK_PARM			m_pStackParm;
	CGLASS_RECIPE_ETC_PARM		m_pGlassEtcParm;

	CGLASS_RECIPE_PARM()
	{
		Reset();
	}
	void Reset()
	{
		m_nCameraNum = 0;
		m_nScanNum = 0;		
		m_GlassType.Reset();
		m_dGlassThickness = 0.;
		m_nSelectCellOri = 0;
		m_pRcpInfoPrm.Reset();
		m_pRefInspectPrm.Reset();
		m_pTransInspectPrm.Reset();
		m_pEdgeCrack.Reset();
		m_pTransLightParm.Reset();
		m_pRefLightParm.Reset();
		m_pGlassEtcParm.Reset();
		m_pGlassAlignParm.Reset();
		m_pGlassMaskParm.Reset();
		m_pDefectJudge.Reset();
		m_pStackParm.Reset();
	}
	void SetCamNum(int nTransCnt,int nRefCnt)
	{
		m_nCameraNum = nTransCnt+nRefCnt;
		m_pRefInspectPrm.m_nCamNum = nRefCnt;
		m_pTransInspectPrm.m_nCamNum = nTransCnt;
	}
	CGLASS_RECIPE_PARM& operator=(const CGLASS_RECIPE_PARM &rh)
	{
		m_nCameraNum = rh.m_nCameraNum;
		m_nScanNum = rh.m_nScanNum;
		m_GlassType = rh.m_GlassType;
		m_dGlassThickness = rh.m_dGlassThickness;
		m_nSelectCellOri = rh.m_nSelectCellOri;

		m_pRcpInfoPrm = rh.m_pRcpInfoPrm;
		m_pRefInspectPrm = rh.m_pRefInspectPrm;
		m_pTransInspectPrm = rh.m_pTransInspectPrm;
		m_pEdgeCrack = rh.m_pEdgeCrack;
		m_pTransLightParm = rh.m_pTransLightParm;
		m_pRefLightParm = rh.m_pRefLightParm;
		m_pGlassEtcParm = rh.m_pGlassEtcParm;
		m_pGlassAlignParm = rh.m_pGlassAlignParm;
		m_pGlassMaskParm = rh.m_pGlassMaskParm;
		m_pDefectJudge = rh.m_pDefectJudge;
		m_pStackParm = rh.m_pStackParm;
		return *this;
	}
	BOOL ReadRecipeAlong(CHMRegiConfig *pFile)
	{
		if(pFile == NULL)
			return FALSE;

		int			nValue;

		pFile->GetItemValue("GLASS_TYPEX", m_GlassType.m_nGlassSizeX);	// ÇöÀç GlassÀÇ X Å©±â
		pFile->GetItemValue("GLASS_TYPEY", m_GlassType.m_nGlassSizeY);	// ÇöÀç GlassÀÇ Y Å©±â
		pFile->GetItemValue("GLASS_ORIGINDIR", nValue);					// ÇöÀç GlassÀÇ Y Å©±â
		m_GlassType.m_OriginDirection = (GlassDirection)nValue;					// ÇöÀç GlassÀÇ ¿øÁ¡ ¹æÇâ
		pFile->GetItemValue("GLASS_CCDIR", nValue);
		m_GlassType.m_CCutDirection = (GlassDirection)nValue;					// ÇöÀç GlassÀÇ ÄÚ³ÊÄÆ ¹æÇâ
		pFile->GetItemValue("GLASS_THICKNESS", m_dGlassThickness);		// Glass µÎ²².
		pFile->GetItemValue("GLASS_CELL_ORI", m_nSelectCellOri);	

		m_pRcpInfoPrm.ReadRecipe(pFile);

		return TRUE;
	}
	BOOL ReadRecipe(CHMRegiConfig *pFile)
	{
		if(pFile == NULL)
			return FALSE;

		int			nValue;

		pFile->GetItemValue("GLASS_TYPEX", m_GlassType.m_nGlassSizeX);	// ÇöÀç GlassÀÇ X Å©±â
		pFile->GetItemValue("GLASS_TYPEY", m_GlassType.m_nGlassSizeY);	// ÇöÀç GlassÀÇ Y Å©±â
		pFile->GetItemValue("GLASS_ORIGINDIR", nValue);					// ÇöÀç GlassÀÇ Y Å©±â
		m_GlassType.m_OriginDirection = (GlassDirection)nValue;					// ÇöÀç GlassÀÇ ¿øÁ¡ ¹æÇâ
		pFile->GetItemValue("GLASS_CCDIR", nValue);
		m_GlassType.m_CCutDirection = (GlassDirection)nValue;					// ÇöÀç GlassÀÇ ÄÚ³ÊÄÆ ¹æÇâ
		pFile->GetItemValue("GLASS_THICKNESS", m_dGlassThickness);		// Glass µÎ²².
		pFile->GetItemValue("GLASS_CELL_ORI", m_nSelectCellOri);		

		m_pRcpInfoPrm.ReadRecipe(pFile);
		m_pRefInspectPrm.ReadRecipe(pFile,CamType_Reflex);
		m_pTransInspectPrm.ReadRecipe(pFile,CamType_Transfer);
		m_pEdgeCrack.ReadRecipe(pFile);
		m_pRefLightParm.ReadRecipe(pFile,CamType_Reflex);
		m_pTransLightParm.ReadRecipe(pFile,CamType_Transfer);
		m_pGlassAlignParm.ReadRecipe(pFile);
		m_pGlassEtcParm.ReadRecipe(pFile);
		m_pGlassMaskParm.ReadRecipe(pFile);
		m_pDefectJudge.ReadRecipe(pFile);
		m_pStackParm.ReadRecipe(pFile);
		return TRUE;
	}
	BOOL WriteRecipeAlong(CHMRegiConfig *pFile)
	{
		if(pFile == NULL)
			return FALSE;

		int			nValue;

		pFile->SetItemValue("GLASS_TYPEX", m_GlassType.m_nGlassSizeX);		// ÇöÀç GlassÀÇ X Å©±â
		pFile->SetItemValue("GLASS_TYPEY", m_GlassType.m_nGlassSizeY);		// ÇöÀç GlassÀÇ Y Å©±â
		nValue = (int)m_GlassType.m_OriginDirection;								// ÇöÀç GlassÀÇ ¿øÁ¡ ¹æÇâ
		pFile->SetItemValue("GLASS_ORIGINDIR", nValue);
		nValue = (int)m_GlassType.m_CCutDirection;									// ÇöÀç GlassÀÇ ÄÚ³ÊÄÆ ¹æÇâ
		pFile->SetItemValue("GLASS_CCDIR", nValue);
		pFile->SetItemValue("GLASS_THICKNESS", m_dGlassThickness);			// Glass µÎ²².
		pFile->SetItemValue("GLASS_CELL_ORI", m_nSelectCellOri);

		return TRUE;
	}
	BOOL WriteRecipe(CHMRegiConfig *pFile)
	{
		int			nValue;

		pFile->SetItemValue("GLASS_TYPEX", m_GlassType.m_nGlassSizeX);		// ÇöÀç GlassÀÇ X Å©±â
		pFile->SetItemValue("GLASS_TYPEY", m_GlassType.m_nGlassSizeY);		// ÇöÀç GlassÀÇ Y Å©±â
		nValue = (int)m_GlassType.m_OriginDirection;								// ÇöÀç GlassÀÇ ¿øÁ¡ ¹æÇâ
		pFile->SetItemValue("GLASS_ORIGINDIR", nValue);
		nValue = (int)m_GlassType.m_CCutDirection;									// ÇöÀç GlassÀÇ ÄÚ³ÊÄÆ ¹æÇâ
		pFile->SetItemValue("GLASS_CCDIR", nValue);
		pFile->SetItemValue("GLASS_THICKNESS", m_dGlassThickness);			// Glass µÎ²².
		pFile->SetItemValue("GLASS_CELL_ORI", m_nSelectCellOri);

		m_pRcpInfoPrm.WriteRecipe(pFile);
		m_pRefInspectPrm.WriteRecipe(pFile,CamType_Reflex);
		m_pTransInspectPrm.WriteRecipe(pFile,CamType_Transfer);
		m_pEdgeCrack.WriteRecipe(pFile);
		m_pRefLightParm.WriteRecipe(pFile,CamType_Reflex);
		m_pTransLightParm.WriteRecipe(pFile,CamType_Transfer);
		m_pGlassAlignParm.WriteRecipe(pFile);
		m_pGlassEtcParm.WriteRecipe(pFile);
		m_pGlassMaskParm.WriteRecipe(pFile);
		m_pDefectJudge.WriteRecipe(pFile);
		m_pStackParm.WriteRecipe(pFile);
		return TRUE;
	}
	BOOL ReadRecipe(CMosisPacket *pPacket)
	{			
		int			nValue;
		pPacket->ReadValue(m_GlassType.m_nGlassSizeX);
		pPacket->ReadValue(m_GlassType.m_nGlassSizeY);
		pPacket->ReadValue(nValue);
		m_GlassType.m_OriginDirection = (GlassDirection)nValue;
		pPacket->ReadValue(nValue);
		m_GlassType.m_CCutDirection = (GlassDirection)nValue;
		pPacket->ReadValue(m_dGlassThickness);
		pPacket->ReadValue(m_nSelectCellOri);

		m_pRcpInfoPrm.ReadRecipe(pPacket);
		m_pRefInspectPrm.ReadRecipe(pPacket);
		m_pTransInspectPrm.ReadRecipe(pPacket);
		m_pEdgeCrack.ReadRecipe(pPacket);
		m_pGlassAlignParm.ReadRecipe(pPacket);
		m_pGlassEtcParm.ReadRecipe(pPacket);
		return TRUE;
	}
	BOOL WriteRecipe(CMosisPacket *pPacket)
	{
		int			nValue;
		pPacket->WriteValue(m_GlassType.m_nGlassSizeX);
		pPacket->WriteValue(m_GlassType.m_nGlassSizeY);
		nValue = (int)m_GlassType.m_OriginDirection;
		pPacket->WriteValue(nValue);
		nValue = (int)m_GlassType.m_CCutDirection;
		pPacket->WriteValue(nValue);		
		pPacket->WriteValue(m_dGlassThickness);
		pPacket->WriteValue(m_nSelectCellOri);

		m_pRcpInfoPrm.WriteRecipe(pPacket);
		m_pRefInspectPrm.WriteRecipe(pPacket);
		m_pTransInspectPrm.WriteRecipe(pPacket);
		m_pEdgeCrack.WriteRecipe(pPacket);
		m_pGlassAlignParm.WriteRecipe(pPacket);
		m_pGlassEtcParm.WriteRecipe(pPacket);
		return TRUE;
	}
};

#endif