#include "StdAfx.h"
#include "GlassRecipe.h"

//////////////////////////////////////////////////////////////////////////
// CRECIPE_INFO_PARM
CRECIPE_INFO_PARM::CRECIPE_INFO_PARM(void)
{
	Reset();
}

CRECIPE_INFO_PARM::~CRECIPE_INFO_PARM(void)
{

}

CRECIPE_INFO_PARM& CRECIPE_INFO_PARM::operator=(CRECIPE_INFO_PARM& rh)
{
	if(this != &rh)
	{
		Reset();
		CopyMemory(m_strRecipeName,rh.m_strRecipeName,sizeof(TCHAR)*MAX_STRING_LENGTH);		
		CopyMemory(m_strRecipeFileName,rh.m_strRecipeFileName,sizeof(TCHAR)*MAX_STRING_LENGTH);		
		//park
		CopyMemory(m_strRecipeFileNameBackUp,rh.m_strRecipeFileNameBackUp,sizeof(TCHAR)*MAX_STRING_LENGTH);		
		m_nSoftRevision = rh.m_nSoftRevision;
	}
	return *this;
}

void CRECIPE_INFO_PARM::Reset()
{
	ZeroMemory(m_strRecipeName,sizeof(TCHAR)*MAX_STRING_LENGTH);	
	ZeroMemory(m_strRecipeFileName,sizeof(TCHAR)*MAX_STRING_LENGTH);	
	//park
	ZeroMemory(m_strRecipeFileNameBackUp,sizeof(TCHAR)*MAX_STRING_LENGTH);
	m_nSoftRevision = 0;
}

void CRECIPE_INFO_PARM::SetRecipeName(CString strRecipe)
{
	if(strRecipe.IsEmpty() == TRUE || strRecipe.GetLength() <= 0 || strRecipe.GetLength() >= MAX_STRING_LENGTH)
	{
		ZeroMemory(m_strRecipeName,sizeof(TCHAR)*MAX_STRING_LENGTH);
		return;
	}
	ZeroMemory(m_strRecipeName,sizeof(TCHAR)*MAX_STRING_LENGTH);
	CopyMemory(m_strRecipeName,strRecipe.GetBuffer(0),sizeof(TCHAR)*strRecipe.GetLength());
}

void CRECIPE_INFO_PARM::SetRecipeFileName(CString strFile)
{
	if(strFile.IsEmpty() == TRUE || strFile.GetLength() <= 0 || strFile.GetLength() >= MAX_STRING_LENGTH)
	{
		ZeroMemory(m_strRecipeFileName,sizeof(TCHAR)*MAX_STRING_LENGTH);
		return;
	}
	ZeroMemory(m_strRecipeFileName,sizeof(TCHAR)*MAX_STRING_LENGTH);
	CopyMemory(m_strRecipeFileName,strFile.GetBuffer(0),sizeof(TCHAR)*strFile.GetLength());
}

CString CRECIPE_INFO_PARM::GetRecipeName()
{
	CString		strRecipe;		
	strRecipe.Format(_T("%s"),m_strRecipeName);
	return strRecipe;
}
CString CRECIPE_INFO_PARM::GetRecipeFileName()
{
	CString		strFile;		
	strFile.Format(_T("%s"),m_strRecipeFileName);
	return strFile;
}

BOOL CRECIPE_INFO_PARM::ReadRecipe(CConfig *pFile)
{
	pFile->GetItemValue(_T("SOFTREV"), m_nSoftRevision);	

	return TRUE;
}
BOOL CRECIPE_INFO_PARM::WriteRecipe(CConfig *pFile)
{
	pFile->SetItemValue(_T("SOFTREV"), m_nSoftRevision);	

	return TRUE;
}

void CRECIPE_INFO_PARM::SetRecipeFileNameBackUp( CString strFile )
{
	if(strFile.IsEmpty() == TRUE || strFile.GetLength() <= 0 || strFile.GetLength() >= MAX_STRING_LENGTH)
	{
		ZeroMemory(m_strRecipeFileNameBackUp,sizeof(TCHAR)*MAX_STRING_LENGTH);
		return;
	}
	ZeroMemory(m_strRecipeFileNameBackUp,sizeof(TCHAR)*MAX_STRING_LENGTH);
	CopyMemory(m_strRecipeFileNameBackUp,strFile.GetBuffer(0),sizeof(TCHAR)*strFile.GetLength());
}

//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
// CGLASS_INFO_PARM
CGLASS_INFO_PARM::CGLASS_INFO_PARM(void)
{
	Reset();
}

CGLASS_INFO_PARM::~CGLASS_INFO_PARM(void)
{

}

CGLASS_INFO_PARM& CGLASS_INFO_PARM::operator=(CGLASS_INFO_PARM& rh)
{
	if(this != &rh)
	{
		Reset();
		CopyMemory(m_nFindGlassStartOffset,rh.m_nFindGlassStartOffset,sizeof(int)*MAX_DIMENSION_COUNT);
		CopyMemory(m_nGlassFindHorPos,rh.m_nGlassFindHorPos,sizeof(int)*MAX_DIMENSION_COUNT);		
		m_nGlassSizeX = rh.m_nGlassSizeX;
		m_nGlassSizeY = rh.m_nGlassSizeY;
		m_nGlassImageSize = rh.m_nGlassImageSize;
		m_nGlassImageLeftMargin = rh.m_nGlassImageLeftMargin;
		m_OriginDirection = rh.m_OriginDirection;			
		m_bGlassFullImageSave = rh.m_bGlassFullImageSave;
		m_bAllImageSave = rh.m_bAllImageSave;
		m_strDisp = rh.m_strDisp;
		m_bGlassDefaultImageSave = rh.m_bGlassDefaultImageSave;
		m_bOneScanMode = rh.m_bOneScanMode;
		m_bPanelReverse = rh.m_bPanelReverse;
		m_dOneScanTime = rh.m_dOneScanTime;
		m_emGlassType = rh.m_emGlassType;
	}
	return *this;
}

void CGLASS_INFO_PARM::Reset()
{	
	ZeroMemory(m_nFindGlassStartOffset,sizeof(int)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_nGlassFindHorPos,sizeof(int)*MAX_DIMENSION_COUNT);	
	m_nGlassSizeX = 0;
	m_nGlassSizeY = 0;
	m_nGlassImageSize = 1500;
	m_nGlassImageLeftMargin = 200;
	m_OriginDirection = GD_LeftTop;	
	m_strDisp.Empty();
	m_bGlassFullImageSave = FALSE;
	m_bAllImageSave = FALSE;

	m_bGlassDefaultImageSave = FALSE;
	m_bOneScanMode = FALSE;
	m_bPanelReverse = FALSE;
	m_dOneScanTime = 0.;
	m_emGlassType = GLASSTYPE_RCUT;
}

CString CGLASS_INFO_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_nGlassSizeX == pValue)
		str.Format(_T("GLASS_SIZE_X"));
	else if((void *)&m_nGlassSizeY == pValue)
		str.Format(_T("GLASS_SIZE_Y"));
	else if((void *)&m_nGlassImageSize == pValue)
		str.Format(_T("GLASS_IMAGE_SIZE"));
	else if((void *)&m_nGlassImageLeftMargin == pValue)
		str.Format(_T("GLASS_IMAGE_LEFT_MARGIN"));
	else if((void *)&m_OriginDirection == pValue)
		str.Format(_T("GLASS_ORIGIN_DIR"));	
	else if((void *)&m_strDisp == pValue)
		str.Format(_T("GLASS_Disp"));	
	else if((void *)&m_bGlassFullImageSave == pValue)
		str.Format(_T("GLASS_FullImageSave"));	
	else if((void *)&m_bAllImageSave == pValue)
		str.Format(_T("GLASS_AllImageSave"));
	else if((void *)&m_bGlassDefaultImageSave == pValue)
		str.Format(_T("GLASS_DefaultImageSave"));
	else if((void *)&m_bOneScanMode == pValue)
		str.Format(_T("GLASS_OneScanMode"));
	else if((void *)&m_bPanelReverse == pValue)
		str.Format(_T("GLASS_Reverse"));
	else if((void *)&m_dOneScanTime == pValue)
		str.Format(_T("GLASS_OneScanTime"));
	else if((void *)&m_emGlassType == pValue)
		str.Format(_T("GLASS_TYPE"));
	else
	{
		int		i;

		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			if((void *)&m_nFindGlassStartOffset[i] == pValue)
				str.Format(_T("GLASS_FindStartLineOffset[%d]"),i);
			else if((void *)&m_nGlassFindHorPos[i] == pValue)
				str.Format(_T("ETC_GLASSFINDHORPOS_%d"),i);
		}
	}

	return str;
}

BOOL CGLASS_INFO_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nGlassSizeX);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassSizeX);

	str = GetFileString((void *)&m_nGlassSizeY);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassSizeY);

	str = GetFileString((void *)&m_nGlassImageSize);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassImageSize);

	str = GetFileString((void *)&m_nGlassImageLeftMargin);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassImageLeftMargin);

	str = GetFileString((void *)&m_OriginDirection);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
	m_OriginDirection = (GlassDirection)nValue;

	str = GetFileString((void *)&m_strDisp);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_strDisp);

	str = GetFileString((void *)&m_bGlassFullImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bGlassFullImageSave);	

	str = GetFileString((void *)&m_bAllImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bAllImageSave);		

	str = GetFileString((void *)&m_bGlassDefaultImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bGlassDefaultImageSave);

	str = GetFileString((void *)&m_bOneScanMode);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bOneScanMode);

	str = GetFileString((void *)&m_bPanelReverse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bPanelReverse);

	str = GetFileString((void *)&m_dOneScanTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_dOneScanTime);	

	str = GetFileString((void *)&m_emGlassType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue, 0);		
	m_emGlassType = (EM_GLASSTYPE_COMP)nValue;

	int		i;
	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_nFindGlassStartOffset[i]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nFindGlassStartOffset[i]);	

		str = GetFileString((void *)&m_nGlassFindHorPos[i]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindHorPos[i]);			
	}


	return TRUE;
}
BOOL CGLASS_INFO_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;
	int				nValue;

	str = GetFileString((void *)&m_nGlassSizeX);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassSizeX);

	str = GetFileString((void *)&m_nGlassSizeY);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassSizeY);

	str = GetFileString((void *)&m_nGlassImageSize);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassImageSize);

	str = GetFileString((void *)&m_nGlassImageLeftMargin);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassImageLeftMargin);

	str = GetFileString((void *)&m_OriginDirection);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_OriginDirection;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

	str = GetFileString((void *)&m_strDisp);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,(TCHAR*)(LPCTSTR)m_strDisp);

	str = GetFileString((void *)&m_bGlassFullImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bGlassFullImageSave);

	str = GetFileString((void *)&m_bAllImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bAllImageSave);	

	str = GetFileString((void *)&m_bGlassDefaultImageSave);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bGlassDefaultImageSave);

	str = GetFileString((void *)&m_bOneScanMode);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bOneScanMode);

	str = GetFileString((void *)&m_bPanelReverse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bPanelReverse);	

	str = GetFileString((void *)&m_dOneScanTime);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_dOneScanTime);	

	str = GetFileString((void *)&m_emGlassType);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	nValue = (int)m_emGlassType;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

	int		i;
	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_nFindGlassStartOffset[i]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nFindGlassStartOffset[i]);	

		str = GetFileString((void *)&m_nGlassFindHorPos[i]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindHorPos[i]);		
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CCUTAREA_PARM
CCUTAREA_PARM::CCUTAREA_PARM(void)
{
	Reset();
}

CCUTAREA_PARM::~CCUTAREA_PARM(void)
{

}

CCUTAREA_PARM& CCUTAREA_PARM::operator=(CCUTAREA_PARM& rh)
{
	if(this != &rh)
	{
		Reset();		

		int			i;

		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{			
			CopyMemory(&m_stuCutAreaParm[i],&rh.m_stuCutAreaParm[i],sizeof(STU_CUTAREA_PARM));			
			CopyMemory(&m_stuChipParm[i],&rh.m_stuChipParm[i],sizeof(STU_CHIP_PARM));				
			CopyMemory(&m_stuCutAreaAlignMark[i],&rh.m_stuCutAreaAlignMark[i],sizeof(STU_CUTAREA_ALIGN_MARK));//20140611

			m_vecCutAreaExpPos[i].clear();
			std::vector<STU_CUTAREA_EXP_POS>::iterator	it;
			for(it=rh.m_vecCutAreaExpPos[i].begin();it!=rh.m_vecCutAreaExpPos[i].end();it++)
				m_vecCutAreaExpPos[i].push_back(*it);		
		}	

	}
	return *this;
}

void CCUTAREA_PARM::Reset()
{	
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{		
		m_stuCutAreaParm[i].Reset();
		m_stuChipParm[i].Reset();		
		m_stuCutAreaAlignMark[i].Reset();//20140611
		m_vecCutAreaExpPos[i].clear();
	}	
}

BOOL CCUTAREA_PARM::GetChipUse(int iPos)
{
	BOOL		bUse = FALSE;

	int				i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{			
			bUse |= m_stuChipParm[i].m_bChipping;
		}
	}
	else
	{		
		bUse |= m_stuChipParm[iPos].m_bChipping;
	}	

	return bUse;
}

BOOL CCUTAREA_PARM::GetCutAreaUse(int iPos)
{
	BOOL		bUse = FALSE;

	int				i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{			
			bUse |= m_stuCutAreaParm[i].m_bCutArea;			
		}
	}
	else
	{
		bUse |= m_stuCutAreaParm[iPos].m_bCutArea;
	}

	return bUse;
}

CString CCUTAREA_PARM::GetFileString(void *pValue)
{
	CString			str;
	int				iScan;

	for(iScan=0;iScan<MAX_DIMENSION_COUNT;iScan++)
	{		
		if((void *)&m_stuCutAreaParm[iScan].m_bCutArea == pValue)
			str.Format(_T("CUTAREA_USE_[%d]"),iScan);		
		else if((void *)&m_stuCutAreaParm[iScan].m_nThresT == pValue)
			str.Format(_T("CUTAREA_CUTTHRES_T_[%d]"),iScan);
		else if((void *)&m_stuCutAreaParm[iScan].m_nThresB == pValue)
			str.Format(_T("CUTAREA_CUTTHRES_B_[%d]"),iScan);
		else if((void *)&m_stuCutAreaParm[iScan].m_nSearchWidth == pValue)
			str.Format(_T("CUTAREA_SEARCHWIDTH_[%d]"),iScan);	
		else if((void *)&m_stuCutAreaParm[iScan].m_nCalArea == pValue)
			str.Format(_T("CUTAREA_CALAREA_[%d]"),iScan);		
		else if((void *)&m_stuChipParm[iScan].m_nThresMode == pValue)
			str.Format(_T("CUTAREA_CHIPPING_THRESMODE[%d]"),iScan);
		else if((void *)&m_stuChipParm[iScan].m_bChipping == pValue)
			str.Format(_T("CUTAREA_USE_CHIPPING_[%d]"),iScan);
		else if((void *)&m_stuChipParm[iScan].m_nChippingInsArea == pValue)
			str.Format(_T("CUTAREA_CHIPPINGAREA_[%d]"),iScan);
		else if((void *)&m_stuChipParm[iScan].m_nChippingThres_T == pValue)
			str.Format(_T("CUTAREA_CHIPPINGTHRES_T_[%d]"),iScan);
		else if((void *)&m_stuChipParm[iScan].m_nChippingThres_T_White == pValue)
			str.Format(_T("CUTAREA_CHIPPINGTHRES_T_WHITE[%d]"),iScan);	
		else if((void *)&m_stuChipParm[iScan].m_nChippingThres_B == pValue)
			str.Format(_T("CUTAREA_CHIPPINGTHRES_B_[%d]"),iScan);
		else if((void *)&m_stuChipParm[iScan].m_nChippingThres_T_L == pValue)
			str.Format(_T("CUTAREA_CHIPPINGTHRES_T_L_[%d]"),iScan);
		else if((void *)&m_stuChipParm[iScan].m_nChippingThres_B_L == pValue)
			str.Format(_T("CUTAREA_CHIPPINGTHRES_B_L_[%d]"),iScan);		
		else if((void *)&m_stuChipParm[iScan].m_nCrackThres == pValue)
			str.Format(_T("CUTAREA_CRACKTHRES_[%d]"),iScan);		
		else if((void *)&m_stuChipParm[iScan].m_nBrokenThres == pValue)
			str.Format(_T("CUTAREA_BROKENTHRES_[%d]"),iScan);		
		else if((void *)&m_stuChipParm[iScan].m_nChipDiffThres == pValue)
			str.Format(_T("CUTAREA_CHIPDIFFTHRES_[%d]"),iScan);

		//20140611
		if((void *)&m_stuCutAreaAlignMark[iScan].m_bCutAreaAlignMark == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_USE_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXPos[0] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_XPOS_TOP_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXSize[0] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_XSIZE_TOP_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYPos[0] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_YPOS_TOP_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYSize[0] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_YSIZE_TOP_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXPos[1] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_XPOS_BOT_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXSize[1] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_XSIZE_BOT_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYPos[1] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_YPOS_BOT_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYSize[1] == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_YSIZE_BOT_[%d]"),iScan);
		else if((void *)&m_stuCutAreaAlignMark[iScan].m_nAlign2GlassPos == pValue)
			str.Format(_T("CUTAREA_ALIGN_MARK_ALIGN2GLASSPOS_[%d]"),iScan);
		//20140611
	}

	return str;
}

BOOL CCUTAREA_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;	
	int				iScan,nValue;
	int				nCount,i;
	STU_CUTAREA_EXP_POS enExp;

	for(iScan=0;iScan<MAX_DIMENSION_COUNT;iScan++)
	{	
		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_bCutArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_bCutArea, FALSE);		

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nThresT);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nThresT, 0);

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nThresB);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nThresB, 0);

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nCalArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nCalArea, 0);

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nSearchWidth);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nSearchWidth, 0);		

		str = GetFileString((void *)&m_stuChipParm[iScan].m_bChipping);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_bChipping, FALSE);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nThresMode);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nThresMode, 0);				

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_T_L);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_T_L, 0);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_T);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_T, 0);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_T_White);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_T_White, 255);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_B_L);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_B_L, 0);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_B);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_B, 0);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nCrackThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nCrackThres, 0);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nBrokenThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nBrokenThres, 0);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChipDiffThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChipDiffThres, 255);		

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingInsArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingInsArea, 0);

		m_vecCutAreaExpPos[iScan].clear();
		str.Format(_T("CUTAREA_EXPCOUNT_[%d]"),iScan);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCount);
		for(i=0;i<nCount;i++)
		{
			enExp.Reset();

			str.Format(_T("CUTAREA_EXPREG[%d]_SIDE_%d"),iScan,i);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			enExp.enSide = (DimensionDir)nValue;

			str.Format(_T("CUTAREA_EXPREG[%d]_YPOS_%d"),iScan,i);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,enExp.nPosY);

			str.Format(_T("CUTAREA_EXPREG[%d]_YSIZE_%d"),iScan,i);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,enExp.nSize);

			str.Format(_T("CUTAREA_EXPREG[%d]_XPOS_%d"),iScan,i);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,enExp.nPosX);

			str.Format(_T("CUTAREA_EXPREG[%d]_XSIZE_%d"),iScan,i);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,enExp.nSizeX);

			str.Format(_T("CUTAREA_EXPREG[%d]_TYPE_%d"),iScan,i);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);

			enExp.enERType = (ExpRegionType)nValue;

			m_vecCutAreaExpPos[iScan].push_back(enExp);
		}

		//20140611
		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_bCutAreaAlignMark);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_bCutAreaAlignMark, FALSE);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXPos[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXPos[0], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXSize[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXSize[0], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYPos[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYPos[0], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYSize[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYSize[0], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXPos[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXPos[1], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXSize[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXSize[1], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYPos[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYPos[1], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYSize[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYSize[1], 0);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nAlign2GlassPos);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nAlign2GlassPos, 0);
		//20140611
	}		

	return TRUE;
}
BOOL CCUTAREA_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;	
	int				iScan,nValue;
	int				i;
	STU_CUTAREA_EXP_POS enExp;
	std::vector<STU_CUTAREA_EXP_POS>::iterator	it;

	for(iScan=0;iScan<MAX_DIMENSION_COUNT;iScan++)
	{		
		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_bCutArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_bCutArea);		

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nThresT);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nThresT);

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nThresB);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nThresB);

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nCalArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nCalArea);

		str = GetFileString((void *)&m_stuCutAreaParm[iScan].m_nSearchWidth);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaParm[iScan].m_nSearchWidth);			

		str = GetFileString((void *)&m_stuChipParm[iScan].m_bChipping);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_bChipping);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nThresMode);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nThresMode);		

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_T_L);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_T_L);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_T);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_T);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_T_White);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_T_White);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_B_L);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_B_L);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingThres_B);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingThres_B);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nCrackThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nCrackThres);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChipDiffThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChipDiffThres);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nBrokenThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nBrokenThres);

		str = GetFileString((void *)&m_stuChipParm[iScan].m_nChippingInsArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuChipParm[iScan].m_nChippingInsArea);

		str.Format(_T("CUTAREA_EXPCOUNT_[%d]"),iScan);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,(int)m_vecCutAreaExpPos[iScan].size());
		i = 0;
		for(it=m_vecCutAreaExpPos[iScan].begin();it!=m_vecCutAreaExpPos[iScan].end();it++,i++)
		{
			nValue = (int)it->enSide;

			str.Format(_T("CUTAREA_EXPREG[%d]_SIDE_%d"),iScan,i);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		

			str.Format(_T("CUTAREA_EXPREG[%d]_YPOS_%d"),iScan,i);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,it->nPosY);

			str.Format(_T("CUTAREA_EXPREG[%d]_YSIZE_%d"),iScan,i);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,it->nSize);

			str.Format(_T("CUTAREA_EXPREG[%d]_XPOS_%d"),iScan,i);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,it->nPosX);

			str.Format(_T("CUTAREA_EXPREG[%d]_XSIZE_%d"),iScan,i);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,it->nSizeX);

			nValue = (int)it->enERType;
			str.Format(_T("CUTAREA_EXPREG[%d]_TYPE_%d"),iScan,i);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);			
		}

		//20140611
		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_bCutAreaAlignMark);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_bCutAreaAlignMark);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXPos[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXPos[0]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXSize[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXSize[0]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYPos[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYPos[0]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYSize[0]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYSize[0]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXPos[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXPos[1]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkXSize[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkXSize[1]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYPos[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYPos[1]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nMarkYSize[1]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nMarkYSize[1]);

		str = GetFileString((void *)&m_stuCutAreaAlignMark[iScan].m_nAlign2GlassPos);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_stuCutAreaAlignMark[iScan].m_nAlign2GlassPos);
		//20140611
	}		

	return TRUE;
}

BOOL CCUTAREA_PARM::GetCutAreaAlignMarkUse( int iPos )//20140611
{
	BOOL		bUse = FALSE;

	int				i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			bUse |= m_stuCutAreaAlignMark[i].m_bCutAreaAlignMark;
		}
	}
	else
	{
		bUse |= m_stuCutAreaAlignMark[iPos].m_bCutAreaAlignMark;
	}

	return bUse;
}

//////////////////////////////////////////////////////////////////////////
// CCORNER_PARM
CCORNER_PARM::CCORNER_PARM(void)
{
	Reset();
}

CCORNER_PARM::~CCORNER_PARM(void)
{

}

CCORNER_PARM& CCORNER_PARM::operator=(CCORNER_PARM& rh)
{
	if(this != &rh)
	{
		Reset();

		int			i;

		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			m_Thres[i] = rh.m_Thres[i];
		}

		m_bUse = rh.m_bUse;
		m_bSaveImage = rh.m_bSaveImage;		
	}
	return *this;
}

void CCORNER_PARM::Reset()
{
	ZeroMemory(m_Thres,sizeof(int)*MAX_DIMENSION_COUNT);
	m_bSaveImage = FALSE;	 
	m_bUse = FALSE;
}


CString CCORNER_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_bSaveImage == pValue)
		str.Format(_T("CORNER_INSPECTION_USE_SAVEIMAGE"));
	else if((void *)&m_bUse == pValue)
		str.Format(_T("CORNER_INSPECTION_USE"));	

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		if((void *)&m_Thres[i] == pValue)
			str.Format(_T("CORNER_INSPECTION_Thres[%d]"),i);					

	}

	return str;
}

BOOL CCORNER_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;			

	str = GetFileString((void *)&m_bSaveImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bSaveImage, FALSE);

	str = GetFileString((void *)&m_bUse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bUse, FALSE);	

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_Thres[i]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_Thres[i], FALSE);	
	}

	return TRUE;
}
BOOL CCORNER_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;			

	str = GetFileString((void *)&m_bSaveImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bSaveImage);

	str = GetFileString((void *)&m_bUse);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bUse);

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_Thres[i]);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_Thres[i]);	
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CDIMENSION_PARM
CDIMENSION_PARM::CDIMENSION_PARM(void)
{
	Reset();
}

CDIMENSION_PARM::~CDIMENSION_PARM(void)
{

}

CDIMENSION_PARM& CDIMENSION_PARM::operator=(CDIMENSION_PARM& rh)
{
	if(this != &rh)
	{
		Reset();

		std::vector<STU_DI_POS>::iterator	it;

		m_bSaveDimImage = rh.m_bSaveDimImage;

		int			i;
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			m_DimInsParm[i] = rh.m_DimInsParm[i];			

			m_vecDiPosition[i].clear();
			for(it=rh.m_vecDiPosition[i].begin();it!=rh.m_vecDiPosition[i].end();it++)
			{
				m_vecDiPosition[i].push_back(*it);
			}			
		}

	}
	return *this;
}

void CDIMENSION_PARM::Reset()
{
	m_bSaveDimImage = FALSE;
	for(int	i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		m_DimInsParm[i].Reset();
		m_vecDiPosition[i].clear();				
	}
}

BOOL CDIMENSION_PARM::GetDimenUse(int iPos)
{
	BOOL		bUse = FALSE;
	int			i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			bUse |= m_DimInsParm[i].m_bUsePos;
		}
	}
	else
	{
		bUse = m_DimInsParm[iPos].m_bUsePos;
	}

	return bUse;
}

CString CDIMENSION_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");
	int			i;

	if((void *)&m_bSaveDimImage == pValue)
		str.Format(_T("DIMENSION_USE_SAVE_DEBUG_IMG"));				

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		if((void *)&m_DimInsParm[i].m_bUsePos == pValue)
			str.Format(_T("DIMENSION_USE_POS[%d]"),i);				
		else if((void *)&m_DimInsParm[i].m_nJudgeSetSize == pValue)
			str.Format(_T("DIMENSION_JUDGE_MIN[%d]"),i);	
		else if((void *)&m_DimInsParm[i].m_nJudgeSizeRange == pValue)
			str.Format(_T("DIMENSION_JUDGE_MAX[%d]"),i);		
		else if((void *)&m_DimInsParm[i].m_nOffset == pValue)
			str.Format(_T("DIMENSION_OFFSET[%d]"),i);
		else if((void *)&m_DimInsParm[i].m_nDetThres == pValue)
			str.Format(_T("DIMENSION_DETTHRES[%d]"),i);
		else if((void *)&m_DimInsParm[i].m_nCamDir == pValue)
			str.Format(_T("DIMENSION_DETCAMDIR[%d]"),i);	
		else if((void *)&m_DimInsParm[i].m_enDimenType == pValue)
			str.Format(_T("DIMENSION_FINDTYPE[%d]"),i);	

	}

	return str;
}

BOOL CDIMENSION_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;	
	int				i,nValue;

	str = GetFileString((void *)&m_bSaveDimImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bSaveDimImage);	

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_DimInsParm[i].m_enDimenType);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);	
		m_DimInsParm[i].m_enDimenType = (DIMEN_FIND_TYPE)nValue;

		str = GetFileString((void *)&m_DimInsParm[i].m_bUsePos);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_bUsePos);		

		str = GetFileString((void *)&m_DimInsParm[i].m_nJudgeSetSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nJudgeSetSize);		

		str = GetFileString((void *)&m_DimInsParm[i].m_nJudgeSizeRange);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nJudgeSizeRange);		

		str = GetFileString((void *)&m_DimInsParm[i].m_nOffset);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nOffset);	

		str = GetFileString((void *)&m_DimInsParm[i].m_nDetThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nDetThres);	

		str = GetFileString((void *)&m_DimInsParm[i].m_nCamDir);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nCamDir);					

		int			nCount,iLoop;
		STU_DI_POS	stuPos;
		str.Format(_T("DIMENSION_DETCOUNT[%d]"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCount);		

		m_vecDiPosition[i].clear();
		for(iLoop=0;iLoop<nCount;iLoop++)
		{
			str.Format(_T("DIMENSION_POS[%d]_BASEX[%d]"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nBasePosX);

			str.Format(_T("DIMENSION_POS[%d]_BASEY[%d]"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nBasePosY);

			str.Format(_T("DIMENSION_POS[%d]_SEARCHX[%d]"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSearchX);

			str.Format(_T("DIMENSION_POS[%d]_SEARCHY[%d]"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSearchY);

			m_vecDiPosition[i].push_back(stuPos);
		}
	}

	return TRUE;
}
BOOL CDIMENSION_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;	
	int				i;
	int			nCount,iLoop,nValue;
	STU_DI_POS	stuPos;
	std::vector<STU_DI_POS>::iterator	it;

	str = GetFileString((void *)&m_bSaveDimImage);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bSaveDimImage);	

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_DimInsParm[i].m_enDimenType);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		nValue = (int)m_DimInsParm[i].m_enDimenType;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);	

		str = GetFileString((void *)&m_DimInsParm[i].m_bUsePos);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_bUsePos);		

		str = GetFileString((void *)&m_DimInsParm[i].m_nJudgeSetSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nJudgeSetSize);		

		str = GetFileString((void *)&m_DimInsParm[i].m_nJudgeSizeRange);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nJudgeSizeRange);		

		str = GetFileString((void *)&m_DimInsParm[i].m_nOffset);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nOffset);	

		str = GetFileString((void *)&m_DimInsParm[i].m_nDetThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nDetThres);	

		str = GetFileString((void *)&m_DimInsParm[i].m_nCamDir);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_DimInsParm[i].m_nCamDir);	


		str.Format(_T("DIMENSION_DETCOUNT[%d]"),i);
		nCount = (int)m_vecDiPosition[i].size();
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCount);		

		iLoop = 0;
		for(it=m_vecDiPosition[i].begin();it!=m_vecDiPosition[i].end();it++,iLoop++)
		{
			stuPos = *it;

			str.Format(_T("DIMENSION_POS[%d]_BASEX[%d]"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nBasePosX);

			str.Format(_T("DIMENSION_POS[%d]_BASEY[%d]"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nBasePosY);

			str.Format(_T("DIMENSION_POS[%d]_SEARCHX[%d]"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSearchX);

			str.Format(_T("DIMENSION_POS[%d]_SEARCHY[%d]"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSearchY);
		}
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CSPLINE_PARM
CSPLINE_PARM::CSPLINE_PARM(void)
{
	Reset();
}

CSPLINE_PARM::~CSPLINE_PARM(void)
{

}

CSPLINE_PARM& CSPLINE_PARM::operator=(CSPLINE_PARM& rh)
{
	if(this != &rh)
	{
		Reset();

		int			i;
		std::vector<STU_SPLINE_CHIP_POS>::iterator it;

		m_bSP_SaveImg = rh.m_bSP_SaveImg;
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			m_SP_InsParm[i] = rh.m_SP_InsParm[i];
			m_SP_ChipParm[i] = rh.m_SP_ChipParm[i];

			for(it=rh.m_vecSplineChip[i].begin();it!=rh.m_vecSplineChip[i].end();it++)
			{
				m_vecSplineChip[i].push_back(*it);
			}
		}		
	}
	return *this;
}

void CSPLINE_PARM::Reset()
{
	int			i;

	m_bSP_SaveImg = FALSE;
	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		m_SP_InsParm[i].Reset();
		m_SP_ChipParm[i].Reset();
		m_vecSplineChip[i].clear();
	}	
}

BOOL CSPLINE_PARM::GetSplineChipUse(int iPos)
{
	BOOL		bUse = FALSE;
	int			i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			bUse |= m_SP_ChipParm[i].m_bSplineChip;
		}
	}
	else
	{
		bUse = m_SP_ChipParm[iPos].m_bSplineChip;
	}

	return bUse;
}

BOOL CSPLINE_PARM::GetSplineUsePointJudge(int iPos)
{
	BOOL		bUse = FALSE;
	int			i;

	if(iPos <= -1)
	{
		for(i=0;i<MAX_SCAN_COUNT;i++)
		{
			bUse |= m_SP_InsParm[i].m_bSplinePointJudge;
		}
	}
	else
	{
		bUse = m_SP_InsParm[iPos].m_bSplinePointJudge;
	}

	return bUse;
}

BOOL CSPLINE_PARM::GetSplineUse(int iPos)
{
	BOOL		bUse = FALSE;
	int			i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			bUse |= m_SP_InsParm[i].m_bSpline;
		}
	}
	else
	{
		bUse = m_SP_InsParm[iPos].m_bSpline;
	}

	return bUse;
}

CString CSPLINE_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");	
	int			i;

	if((void *)&m_bSP_SaveImg == pValue)
		str.Format(_T("SPLINE_SAVEIMAGE"));	

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		if((void *)&m_SP_InsParm[i].m_bSpline == pValue)
			str.Format(_T("SPLINE_USE_[%d]"),i);	
		else if((void *)&m_SP_InsParm[i].m_bSplinePointJudge == pValue)
			str.Format(_T("SPLINE_USE_POINT_JUDGE_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_DetMinPointDist == pValue)
			str.Format(_T("SPLINE_DET_POINT_MINDIST_[%d]"),i);

		else if((void *)&m_SP_InsParm[i].m_nStartCornerRadius_um == pValue)
			str.Format(_T("SPLINE_START_CORNER_RADIUS_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_nStartCornerSize_Y == pValue)
			str.Format(_T("SPLINE_START_CORNER_SIZE_Y_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_nEndCornerRadius_um == pValue)
			str.Format(_T("SPLINE_END_CORNER_RADIUS_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_nEndCornerSize_Y == pValue)
			str.Format(_T("SPLINE_END_CORNER_SIZE_Y_[%d]"),i);

		else if((void *)&m_SP_InsParm[i].m_nStartChamferSize == pValue)
			str.Format(_T("SPLINE_START_CHAMFER_SIZE_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_nEndChamferSize == pValue)
			str.Format(_T("SPLINE_END_CHAMFER_SIZE_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_emSPType == pValue)
			str.Format(_T("SPLINE_EM_TYPE_[%d]"),i);
		else if((void *)&m_SP_InsParm[i].m_DetMinDist == pValue)
			str.Format(_T("SPLINE_DET_MINDIST_[%d]"),i);		
		else if((void *)&m_SP_InsParm[i].m_nLineThres == pValue)
			str.Format(_T("SPLINE_LINE_THRES_[%d]"),i);	

		if((void *)&m_SP_ChipParm[i].m_bSplineChip == pValue)
			str.Format(_T("SPLINE_CHIP_USE_[%d]"),i);			
		else if((void *)&m_SP_ChipParm[i].m_nChipSize_Y == pValue)
			str.Format(_T("SPLINE_CHIP_SIZE_Y_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_nChipSize_X == pValue)
			str.Format(_T("SPLINE_CHIP_SIZE_X_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_nChipInsArea == pValue)
			str.Format(_T("SPLINE_CHIP_INSAREA_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_nChipThres == pValue)
			str.Format(_T("SPLINE_CHIP_THRES_[%d]"),i);			
		else if((void *)&m_SP_ChipParm[i].m_bCornerUse == pValue)
			str.Format(_T("SPLINE_CHIP_COR_USE_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_nCornerThres == pValue)
			str.Format(_T("SPLINE_CHIP_COR_THRES_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_nCornerRange == pValue)
			str.Format(_T("SPLINE_CHIP_COR_RANGE_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_dChipDistTheta == pValue)
			str.Format(_T("SPLINE_CHIP_DIST_THETA_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_dChipStartTheta == pValue)
			str.Format(_T("SPLINE_CHIP_START_THETA_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_dChipEndTheta == pValue)
			str.Format(_T("SPLINE_CHIP_END_THETA_[%d]"),i);	
		else if((void *)&m_SP_ChipParm[i].m_bChipJudgeAnd == pValue)
			str.Format(_T("SPLINE_CHIP_JUDGE_AND_[%d]"),i);	

	}

	return str;
}

BOOL CSPLINE_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;
	int				i;
	int			nCount,iLoop,nValue;
	STU_SPLINE_CHIP_POS	stuPos;

	str = GetFileString((void *)&m_bSP_SaveImg);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bSP_SaveImg);	


	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_SP_InsParm[i].m_bSpline);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_bSpline);	

		str = GetFileString((void *)&m_SP_InsParm[i].m_bSplinePointJudge);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_bSplinePointJudge);

		str = GetFileString((void *)&m_SP_InsParm[i].m_DetMinPointDist);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_DetMinPointDist);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nStartCornerSize_Y);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nStartCornerSize_Y);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nStartCornerRadius_um);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nStartCornerRadius_um);		

		str = GetFileString((void *)&m_SP_InsParm[i].m_nEndCornerSize_Y);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nEndCornerSize_Y);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nEndCornerRadius_um);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nEndCornerRadius_um);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nStartChamferSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nStartChamferSize, -1);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nEndChamferSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nEndChamferSize, -1);
		

		str = GetFileString((void *)&m_SP_InsParm[i].m_DetMinDist);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_DetMinDist);		

		str = GetFileString((void *)&m_SP_InsParm[i].m_nLineThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nLineThres);

		str = GetFileString((void *)&m_SP_InsParm[i].m_emSPType);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);	
		m_SP_InsParm[i].m_emSPType = (EM_SPLINE_TYPE)nValue;

		str.Format(_T("SPLINE_CHIPCOUNT_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCount);		

		m_vecSplineChip[i].clear();
		for(iLoop=0;iLoop<nCount;iLoop++)
		{
			stuPos.Reset();

			str.Format(_T("SPLINE_CHIPPOS[%d]_POS_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			stuPos.emPos = (STU_SPLINE_CHIP_POS::MAKE_IMAGE_POS)nValue;

			str.Format(_T("SPLINE_CHIPPOS[%d]_USE_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.bUse);

			str.Format(_T("SPLINE_CHIPPOS[%d]_START_X_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nStartX);

			str.Format(_T("SPLINE_CHIPPOS[%d]_END_X_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nEndX);

			str.Format(_T("SPLINE_CHIPPOS[%d]_THRES_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nThres);

			str.Format(_T("SPLINE_CHIPPOS[%d]_FINDTHRES_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nFindThres);		

			str.Format(_T("SPLINE_CHIPPOS[%d]_METHOD_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			stuPos.emMethod = (STU_SPLINE_CHIP_POS::MAKE_IMAGE_METHOD)nValue;
			stuPos.emMethod = STU_SPLINE_CHIP_POS::MAKE_METHOD_REGRESSION;

			str.Format(_T("SPLINE_CHIPPOS[%d]_INSRANGE_%d"),i,iLoop);		
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nInsRange);		

			str.Format(_T("SPLINE_CHIPPOS[%d]_SKIPDIST_%d"),i,iLoop);		
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSkipDist);		

			str.Format(_T("SPLINE_CHIPPOS[%d]_INSDIR_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			stuPos.emDir = (STU_SPLINE_CHIP_POS::SPLINE_INS_DIRECTION)nValue;

			m_vecSplineChip[i].push_back(stuPos);
		}

		str = GetFileString((void *)&m_SP_ChipParm[i].m_bSplineChip);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_bSplineChip);			

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipSize_X);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipSize_X);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipSize_Y);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipSize_Y);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipInsArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipInsArea);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipThres);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_bCornerUse);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_bCornerUse);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nCornerThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nCornerThres);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nCornerRange);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nCornerRange);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_dChipStartTheta);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_dChipStartTheta);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_dChipEndTheta);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_dChipEndTheta);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_dChipDistTheta);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_dChipDistTheta);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_bChipJudgeAnd);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_bChipJudgeAnd);

	}

	return TRUE;
}
BOOL CSPLINE_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;
	int				i;
	int			nCount,iLoop,nValue;
	STU_SPLINE_CHIP_POS	stuPos;

	str = GetFileString((void *)&m_bSP_SaveImg);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bSP_SaveImg);	

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_SP_InsParm[i].m_bSpline);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_bSpline);	

		str = GetFileString((void *)&m_SP_InsParm[i].m_bSplinePointJudge);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_bSplinePointJudge);

		str = GetFileString((void *)&m_SP_InsParm[i].m_DetMinPointDist);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_DetMinPointDist);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nStartCornerSize_Y);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nStartCornerSize_Y);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nStartCornerRadius_um);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nStartCornerRadius_um);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nEndCornerSize_Y);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nEndCornerSize_Y);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nEndCornerRadius_um);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nEndCornerRadius_um);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nStartChamferSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nStartChamferSize);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nEndChamferSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nEndChamferSize);


		str = GetFileString((void *)&m_SP_InsParm[i].m_DetMinDist);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_DetMinDist);

		str = GetFileString((void *)&m_SP_InsParm[i].m_nLineThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_InsParm[i].m_nLineThres);

		str = GetFileString((void *)&m_SP_InsParm[i].m_emSPType);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		nValue = (int)m_SP_InsParm[i].m_emSPType;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		


		str.Format(_T("SPLINE_CHIPCOUNT_%d"),i);
		nCount = (int)m_vecSplineChip[i].size();
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCount);		

		for(iLoop=0;iLoop<nCount;iLoop++)
		{
			stuPos = m_vecSplineChip[i][iLoop];

			str.Format(_T("SPLINE_CHIPPOS[%d]_POS_%d"),i,iLoop);
			nValue = (int)stuPos.emPos;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

			str.Format(_T("SPLINE_CHIPPOS[%d]_USE_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.bUse);

			str.Format(_T("SPLINE_CHIPPOS[%d]_START_X_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nStartX);

			str.Format(_T("SPLINE_CHIPPOS[%d]_END_X_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nEndX);

			str.Format(_T("SPLINE_CHIPPOS[%d]_THRES_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nThres);

			str.Format(_T("SPLINE_CHIPPOS[%d]_FINDTHRES_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nFindThres);		

			str.Format(_T("SPLINE_CHIPPOS[%d]_METHOD_%d"),i,iLoop);
			nValue = (int)stuPos.emMethod;
			nValue = STU_SPLINE_CHIP_POS::MAKE_METHOD_REGRESSION;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		

			str.Format(_T("SPLINE_CHIPPOS[%d]_INSDIR_%d"),i,iLoop);
			nValue = (int)stuPos.emDir;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

			str.Format(_T("SPLINE_CHIPPOS[%d]_INSRANGE_%d"),i,iLoop);		
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nInsRange);	

			str.Format(_T("SPLINE_CHIPPOS[%d]_SKIPDIST_%d"),i,iLoop);		
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSkipDist);		
		}

		str = GetFileString((void *)&m_SP_ChipParm[i].m_bSplineChip);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_bSplineChip);			

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipSize_X);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipSize_X);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipSize_Y);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipSize_Y);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipInsArea);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipInsArea);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nChipThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nChipThres);		

		str = GetFileString((void *)&m_SP_ChipParm[i].m_bCornerUse);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_bCornerUse);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nCornerThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nCornerThres);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_nCornerRange);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_nCornerRange);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_dChipStartTheta);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_dChipStartTheta);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_dChipEndTheta);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_dChipEndTheta);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_dChipDistTheta);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_dChipDistTheta);

		str = GetFileString((void *)&m_SP_ChipParm[i].m_bChipJudgeAnd);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_SP_ChipParm[i].m_bChipJudgeAnd);

	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CVCR_PARM
CVCR_PARM::CVCR_PARM(void)
{
	Reset();
}

CVCR_PARM::~CVCR_PARM(void)
{

}

CVCR_PARM& CVCR_PARM::operator=(CVCR_PARM& rh)
{
	if(this != &rh)
	{
		Reset();
		m_bVCR = rh.m_bVCR;		
		m_bAlarm	= rh.m_bAlarm;	
		m_bSetResult= rh.m_bSetResult;
		m_nVCPosY= rh.m_nVCPosY;
		m_nVCPosX= rh.m_nVCPosX;
		m_nHeight	= rh.m_nHeight;
		m_nWidth	= rh.m_nWidth;	
		m_nCamDir	= rh.m_nCamDir;
	}
	return *this;
}

void CVCR_PARM::Reset()
{
	m_bVCR = FALSE;
	m_bAlarm		= FALSE;
	m_bSetResult	= FALSE;
	m_nVCPosY		= 0;
	m_nVCPosX		= 0;
	m_nHeight		= 0;
	m_nWidth		= 0;
	m_nCamDir		= 0;

}

CRect CVCR_PARM::GetRect()
{
	CRect rect = CRect(m_nVCPosX,m_nVCPosY,m_nVCPosX,m_nVCPosY);
	rect.InflateRect(m_nWidth,m_nHeight);

	return rect;
}

CString CVCR_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");

	if((void *)&m_bVCR == pValue)				str.Format(_T("VCR_USE"));
	else if((void *)&m_bAlarm == pValue)		str.Format(_T("VCR_ALARM"));
	else if((void *)&m_bSetResult == pValue)	str.Format(_T("VCR_SETRESULT"));
	else if((void *)&m_nVCPosX == pValue)		str.Format(_T("VCR_POS_X"));
	else if((void *)&m_nVCPosY == pValue)		str.Format(_T("VCR_POS_Y"));
	else if((void *)&m_nHeight == pValue)		str.Format(_T("VCR_HEIGHT"));
	else if((void *)&m_nWidth == pValue)		str.Format(_T("VCR_WIDTH"));
	else if((void *)&m_nCamDir == pValue)		str.Format(_T("VCR_CAMDIR"));

	return str;
}

BOOL CVCR_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;	

	str = GetFileString((void *)&m_bVCR);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bVCR);	

	str = GetFileString((void *)&m_bAlarm);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bAlarm);	

	str = GetFileString((void *)&m_bSetResult);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bSetResult);	

	str = GetFileString((void *)&m_nVCPosX);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nVCPosX);	

	str = GetFileString((void *)&m_nVCPosY);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nVCPosY);	

	str = GetFileString((void *)&m_nHeight);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nHeight);	

	str = GetFileString((void *)&m_nWidth);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nWidth);	

	str = GetFileString((void *)&m_nCamDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nCamDir);		

	return TRUE;
}
BOOL CVCR_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;	

	str = GetFileString((void *)&m_bVCR);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bVCR);

	str = GetFileString((void *)&m_bAlarm);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bAlarm);	

	str = GetFileString((void *)&m_bSetResult);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bSetResult);	

	str = GetFileString((void *)&m_nVCPosX);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nVCPosX);	

	str = GetFileString((void *)&m_nVCPosY);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nVCPosY);	

	str = GetFileString((void *)&m_nHeight);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nHeight);	

	str = GetFileString((void *)&m_nWidth);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nWidth);	

	str = GetFileString((void *)&m_nCamDir);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nCamDir);	

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CLIGHT_PARM
CLIGHT_PARM::CLIGHT_PARM(void)
{
	Reset();
}

CLIGHT_PARM::~CLIGHT_PARM(void)
{

}

CLIGHT_PARM& CLIGHT_PARM::operator=(CLIGHT_PARM& rh)
{
	if(this != &rh)
	{
		m_bLightControl = rh.m_bLightControl;
		CopyMemory(m_nContValue,rh.m_nContValue,sizeof(int)*LIGHT_CONTROL_COUNT*LIGHT_CONTROL_CH_COUNT);		
	}
	return *this;
}

void CLIGHT_PARM::Reset()
{
	m_bLightControl = FALSE;
	ZeroMemory(m_nContValue,sizeof(int)*LIGHT_CONTROL_COUNT*LIGHT_CONTROL_CH_COUNT);
}

CString CLIGHT_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");	
	int			i,j;

	if((void *)&m_bLightControl == pValue)
		str.Format(_T("LIGHT_CONT_USE"));
	else
		for(i=0;i<LIGHT_CONTROL_COUNT;i++)
		{
			for(j=0;j<LIGHT_CONTROL_CH_COUNT;j++)
			{				
				if((void *)&m_nContValue[i][j] == pValue)
					str.Format(_T("LIGHT_CONT_VALUE_R_%d_%d"),i,j);			
			}
		}	

		return str;
}

BOOL CLIGHT_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;	
	int				i,j;

	str = GetFileString((void *)&m_bLightControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_bLightControl);

	for(i=0;i<LIGHT_CONTROL_COUNT;i++)
	{
		for(j=0;j<LIGHT_CONTROL_CH_COUNT;j++)
		{				
			str = GetFileString((void *)&m_nContValue[i][j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nContValue[i][j]);
		}		
	}

	return TRUE;
}
BOOL CLIGHT_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;	
	int				i,j;

	str = GetFileString((void *)&m_bLightControl);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_bLightControl);

	for(i=0;i<LIGHT_CONTROL_COUNT;i++)
	{
		for(j=0;j<LIGHT_CONTROL_CH_COUNT;j++)
		{				
			str = GetFileString((void *)&m_nContValue[i][j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nContValue[i][j]);
		}	
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CETC_PARM
CETC_PARM::CETC_PARM(void)
{
	Reset();
}

CETC_PARM::~CETC_PARM(void)
{

}

CETC_PARM& CETC_PARM::operator=(CETC_PARM& rh)
{
	if(this != &rh)
	{
		m_nGlassFindthres_Top = rh.m_nGlassFindthres_Top;
		m_nGlassFindHeight_Top = rh.m_nGlassFindHeight_Top;
		m_nGlassFindthres_Left = rh.m_nGlassFindthres_Left;
		m_nGlassLeftLineMargin[0] = rh.m_nGlassLeftLineMargin[0];
		m_nGlassLeftLineMargin[1] = rh.m_nGlassLeftLineMargin[1];
		m_nGlassFindWidth_Left = rh.m_nGlassFindWidth_Left;				
	}
	return *this;
}

void CETC_PARM::Reset()
{
	m_nGlassFindthres_Top = 0;
	m_nGlassFindHeight_Top = 0;
	m_nGlassFindthres_Left = 0;
	m_nGlassLeftLineMargin[0] = m_nGlassLeftLineMargin[1] = 0;
	m_nGlassFindWidth_Left = 0;		
}

CString CETC_PARM::GetFileString(void *pValue,int nIdx)
{
	CString		str = _T("");	

	if((void *)&m_nGlassFindthres_Top == pValue)
		str.Format(_T("ETC_GLASSFINDTHRES_TOP_%d"),nIdx);
	else if((void *)&m_nGlassFindHeight_Top == pValue)
		str.Format(_T("ETC_GLASSFINDHEIGHT_TOP_%d"),nIdx);
	else if((void *)&m_nGlassFindthres_Left == pValue)
		str.Format(_T("ETC_GLASSFINDTHRES_LEFT_%d"),nIdx);
	else if((void *)&m_nGlassFindWidth_Left == pValue)
		str.Format(_T("ETC_GLASSFINDWIDTH_LEFT_%d"),nIdx);
	else
	{		
		for(int i=0;i<2;i++)
		{
			if((void *)&m_nGlassLeftLineMargin[i] == pValue)
				str.Format(_T("ETC_GLASSFINDLEFT_LINEMARGIN_%d_%d"),nIdx,i);
		}
	}

	return str;
}

BOOL CETC_PARM::ReadRecipe(CConfig *pFile,int nIdx)
{
	CString			str;		

	str = GetFileString((void *)&m_nGlassFindthres_Top,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindthres_Top);

	str = GetFileString((void *)&m_nGlassFindHeight_Top,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindHeight_Top);

	str = GetFileString((void *)&m_nGlassFindthres_Left,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindthres_Left);

	for (int i=0; i<2; i++)
	{
		str = GetFileString((void *)&m_nGlassLeftLineMargin[i],nIdx);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassLeftLineMargin[i]);
	}	

	str = GetFileString((void *)&m_nGlassFindWidth_Left,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindWidth_Left);	

	return TRUE;
}
BOOL CETC_PARM::WriteRecipe(CConfig *pFile,int nIdx)
{
	CString			str;		

	str = GetFileString((void *)&m_nGlassFindthres_Top,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindthres_Top);

	str = GetFileString((void *)&m_nGlassFindHeight_Top,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindHeight_Top);

	str = GetFileString((void *)&m_nGlassFindthres_Left,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindthres_Left);

	for (int i=0; i<2; i++)
	{
		str = GetFileString((void *)&m_nGlassLeftLineMargin[i],nIdx);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassLeftLineMargin[i]);
	}

	str = GetFileString((void *)&m_nGlassFindWidth_Left,nIdx);
	if(str.IsEmpty() == TRUE)
		return FALSE;
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nGlassFindWidth_Left);

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CNOTCH_PARM
CNOTCH_PARM::CNOTCH_PARM(void)
{
	Reset();
}

CNOTCH_PARM::~CNOTCH_PARM(void)
{

}

CNOTCH_PARM& CNOTCH_PARM::operator=(CNOTCH_PARM& rh)
{
	if(this != &rh)
	{
		int			i;

		std::vector<CPoint>::iterator	it;//20140528

		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			m_NotchParm[i] = rh.m_NotchParm[i];

			m_vecNotchPosition[i].clear();//20140528
			for(it=rh.m_vecNotchPosition[i].begin();it!=rh.m_vecNotchPosition[i].end();it++)//20140528
			{
				m_vecNotchPosition[i].push_back(*it);
			}
		}	
	}
	return *this;
}

void CNOTCH_PARM::Reset()
{
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		m_NotchParm[i].Reset();
		m_vecNotchPosition[i].clear();	//20140528
	}
}

CString CNOTCH_PARM::GetFileString(void *pValue)
{
	CString		str = _T("");	
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		if((void *)&m_NotchParm[i].bChipIns == pValue)
			str.Format(_T("NOTCH_USE_CHIPINS_[%d]"),i);
		else if((void *)&m_NotchParm[i].bSizeIns == pValue)
			str.Format(_T("NOTCH_USE_SIZEINS_[%d]"),i);
		else if((void *)&m_NotchParm[i].nChipDiff == pValue)
			str.Format(_T("NOTCH_CHIPDIFF_[%d]"),i);
		else if((void *)&m_NotchParm[i].nSizeDiff == pValue)
			str.Format(_T("NOTCH_SIZEDIFF_[%d]"),i);
		else if((void *)&m_NotchParm[i].nDetThres == pValue)
			str.Format(_T("NOTCH_DETTHRES_[%d]"),i);
		else if((void *)&m_NotchParm[i].dBlank2EdgeRatio == pValue)
			str.Format(_T("NOTCH_BLANK2EDGERATIO_[%d]"),i);		
		else if((void *)&m_NotchParm[i].nSizeThres == pValue)
			str.Format(_T("NOTCH_SIZETHRES_[%d]"),i);
		else if((void *)&m_NotchParm[i].nChipThres == pValue)
			str.Format(_T("NOTCH_CHIPTHRES_[%d]"),i);
		else if((void *)&m_NotchParm[i].nVStart == pValue)
			str.Format(_T("NOTCH_VSTART_[%d]"),i);
		else if((void *)&m_NotchParm[i].nVSize == pValue)
			str.Format(_T("NOTCH_VSIZE_[%d]"),i);
		else if((void *)&m_NotchParm[i].nSkipSize == pValue)
			str.Format(_T("NOTCH_SKIPSIZE_[%d]"),i);
		else if((void *)&m_NotchParm[i].nAlign2GlassPos == pValue)
			str.Format(_T("NOTCH_ALIGN2GLASSPOS_[%d]"),i);		
		else if((void *)&m_NotchParm[i].nJudgeBaseWidth == pValue)
			str.Format(_T("NOTCH_CUTAREA_JUDGE_BASEWIDTH_[%d]"),i);
		else if((void *)&m_NotchParm[i].nJudgeDiffWidth == pValue)
			str.Format(_T("NOTCH_CUTAREA_JUDGE_DIFFWIDTH_[%d]"),i);	
		else if((void *)&m_NotchParm[i].bPointInsDimensionJudge == pValue)//20140721
			str.Format(_T("NOTCH_USE_POINT_INS_DIMENSION_JUDGE_[%d]"),i);
		else if((void *)&m_NotchParm[i].bPointInsChamferJudge == pValue)//20140721
			str.Format(_T("NOTCH_USE_POINT_INS_CHAMFER_JUDGE_[%d]"),i);
		else if((void *)&m_NotchParm[i].nPointInsAveCount == pValue)//20140528
			str.Format(_T("NOTCH_USE_POINT_INS_AVE_COUNT_[%d]"),i);

		for(int j=0;j<2;j++)
		{
			if((void *)&m_NotchParm[i].nMarkXPos[j] == pValue)
				str.Format(_T("NOTCH_MARK_XPOS_[%d][%d]"),i,j);
			else if((void *)&m_NotchParm[i].nMarkXSize[j] == pValue)
				str.Format(_T("NOTCH_MARK_XSIZE_[%d][%d]"),i,j);
			else if((void *)&m_NotchParm[i].nMarkYPos[j] == pValue)
				str.Format(_T("NOTCH_MARK_YPOS_[%d][%d]"),i,j);
			else if((void *)&m_NotchParm[i].nMarkYSize[j] == pValue)
				str.Format(_T("NOTCH_MARK_YSIZE_[%d][%d]"),i,j);
			else if((void *)&m_NotchParm[i].bSpChipIns[j] == pValue)
				str.Format(_T("NOTCH_USE_SPCHIP_[%d][%d]"),i,j);
			else if((void *)&m_NotchParm[i].nSpChipSize[j] == pValue)
				str.Format(_T("NOTCH_SPCHIPINSSIZE_[%d][%d]"),i,j);
		}		
	}	

	return str;
}

BOOL CNOTCH_PARM::ReadRecipe(CConfig *pFile)
{
	CString			str;		
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_NotchParm[i].bChipIns);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bChipIns);

		str = GetFileString((void *)&m_NotchParm[i].bSizeIns);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bSizeIns);

		str = GetFileString((void *)&m_NotchParm[i].nChipDiff);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nChipDiff);

		str = GetFileString((void *)&m_NotchParm[i].nSizeDiff);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSizeDiff);

		str = GetFileString((void *)&m_NotchParm[i].nDetThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nDetThres);

		str = GetFileString((void *)&m_NotchParm[i].dBlank2EdgeRatio);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].dBlank2EdgeRatio);

		str = GetFileString((void *)&m_NotchParm[i].nSizeThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSizeThres);

		str = GetFileString((void *)&m_NotchParm[i].nChipThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nChipThres);

		str = GetFileString((void *)&m_NotchParm[i].nVStart);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nVStart);

		str = GetFileString((void *)&m_NotchParm[i].nVSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nVSize);

		str = GetFileString((void *)&m_NotchParm[i].nAlign2GlassPos);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nAlign2GlassPos);		

		str = GetFileString((void *)&m_NotchParm[i].nJudgeBaseWidth);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nJudgeBaseWidth);

		str = GetFileString((void *)&m_NotchParm[i].nJudgeDiffWidth);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nJudgeDiffWidth);

		str = GetFileString((void *)&m_NotchParm[i].nSkipSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSkipSize);

		str = GetFileString((void *)&m_NotchParm[i].bPointInsDimensionJudge);//20140721
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bPointInsDimensionJudge);

		str = GetFileString((void *)&m_NotchParm[i].bPointInsChamferJudge);//20140721
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bPointInsChamferJudge);

		str = GetFileString((void *)&m_NotchParm[i].nPointInsAveCount);//20140528
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nPointInsAveCount);

		for(int j=0;j<2;j++)
		{
			str = GetFileString((void *)&m_NotchParm[i].nMarkXPos[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkXPos[j]);

			str = GetFileString((void *)&m_NotchParm[i].nMarkXSize[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkXSize[j]);

			str = GetFileString((void *)&m_NotchParm[i].nMarkYPos[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkYPos[j]);

			str = GetFileString((void *)&m_NotchParm[i].nMarkYSize[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkYSize[j]);

			str = GetFileString((void *)&m_NotchParm[i].bSpChipIns[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bSpChipIns[j]);

			str = GetFileString((void *)&m_NotchParm[i].nSpChipSize[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSpChipSize[j]);
		}	

		int			nCount,iLoop;//20140528
		CPoint	stuPos;//20140528
		str.Format(_T("NOTCH_DETCOUNT[%d]"),i);//20140528
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCount);//20140528		

		int			nValue;
		m_vecNotchPosition[i].clear();//20140528
		for(iLoop=0;iLoop<nCount;iLoop++)//20140528
		{
			str.Format(_T("NOTCH_POS[%d]_X[%d]"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			stuPos.x = nValue;

			str.Format(_T("NOTCH_POS[%d]_Y[%d]"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			stuPos.y = nValue;

			m_vecNotchPosition[i].push_back(stuPos);
		}

		std::sort(m_vecNotchPosition[i].begin(),m_vecNotchPosition[i].end(),SortCPointYPos());//20140528

	}

	return TRUE;
}

BOOL CNOTCH_PARM::WriteRecipe(CConfig *pFile)
{
	CString			str;		
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str = GetFileString((void *)&m_NotchParm[i].bChipIns);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bChipIns);

		str = GetFileString((void *)&m_NotchParm[i].bSizeIns);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bSizeIns);

		str = GetFileString((void *)&m_NotchParm[i].nChipDiff);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nChipDiff);

		str = GetFileString((void *)&m_NotchParm[i].nSizeDiff);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSizeDiff);

		str = GetFileString((void *)&m_NotchParm[i].nDetThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nDetThres);

		str = GetFileString((void *)&m_NotchParm[i].nSizeThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSizeThres);

		str = GetFileString((void *)&m_NotchParm[i].nChipThres);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nChipThres);

		str = GetFileString((void *)&m_NotchParm[i].dBlank2EdgeRatio);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].dBlank2EdgeRatio);		

		str = GetFileString((void *)&m_NotchParm[i].nVStart);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nVStart);

		str = GetFileString((void *)&m_NotchParm[i].nVSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nVSize);

		str = GetFileString((void *)&m_NotchParm[i].nAlign2GlassPos);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nAlign2GlassPos);

		str = GetFileString((void *)&m_NotchParm[i].nJudgeBaseWidth);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nJudgeBaseWidth);

		str = GetFileString((void *)&m_NotchParm[i].nJudgeDiffWidth);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nJudgeDiffWidth);

		str = GetFileString((void *)&m_NotchParm[i].nSkipSize);
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSkipSize);

		str = GetFileString((void *)&m_NotchParm[i].bPointInsDimensionJudge);//20140721
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bPointInsDimensionJudge);

		str = GetFileString((void *)&m_NotchParm[i].bPointInsChamferJudge);//20140721
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bPointInsChamferJudge);

		str = GetFileString((void *)&m_NotchParm[i].nPointInsAveCount);//20140528
		if(str.IsEmpty() == TRUE)
			return FALSE;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nPointInsAveCount);

		for(int j=0;j<2;j++)
		{
			str = GetFileString((void *)&m_NotchParm[i].nMarkXPos[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkXPos[j]);

			str = GetFileString((void *)&m_NotchParm[i].nMarkXSize[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkXSize[j]);

			str = GetFileString((void *)&m_NotchParm[i].nMarkYPos[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkYPos[j]);

			str = GetFileString((void *)&m_NotchParm[i].nMarkYSize[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nMarkYSize[j]);

			str = GetFileString((void *)&m_NotchParm[i].bSpChipIns[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].bSpChipIns[j]);

			str = GetFileString((void *)&m_NotchParm[i].nSpChipSize[j]);
			if(str.IsEmpty() == TRUE)
				return FALSE;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_NotchParm[i].nSpChipSize[j]);
		}	

		int nCount;//20140528
		str.Format(_T("NOTCH_DETCOUNT[%d]"),i);//20140528
		nCount = (int)m_vecNotchPosition[i].size();//20140528
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCount);//20140528		

		int iLoop = 0;//20140528
		CPoint	stuPos;//20140528
		std::vector<CPoint>::iterator	it;//20140528

		for(it=m_vecNotchPosition[i].begin();it!=m_vecNotchPosition[i].end();it++,iLoop++)//20140528
		{
			stuPos = *it;

			str.Format(_T("NOTCH_POS[%d]_X[%d]"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.x);

			str.Format(_T("NOTCH_POS[%d]_Y[%d]"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.y);			
		}
	}

	return TRUE;
}

BOOL CNOTCH_PARM::GetNotchSizeUse(int iPos)
{
	BOOL		bUse = FALSE;
	int			i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			bUse |= m_NotchParm[i].bSizeIns;
		}
	}
	else
	{
		bUse = m_NotchParm[iPos].bSizeIns;
	}

	return bUse;
}

BOOL CNOTCH_PARM::GetNotchChipUse(int iPos)
{
	BOOL		bUse = FALSE;
	int			i;

	if(iPos > DIMENSION_D_DN)
	{
		for(i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			bUse |= m_NotchParm[i].bChipIns;
		}
	}
	else
	{
		bUse = m_NotchParm[iPos].bChipIns;
	}

	return bUse;
}

//////////////////////////////////////////////////////////////////////////
// CINSPECT_JUDGEMENT_PARM
CINSPECT_JUDGEMENT_PARM::CINSPECT_JUDGEMENT_PARM(void)
{
	Reset();
}

CINSPECT_JUDGEMENT_PARM::~CINSPECT_JUDGEMENT_PARM(void)
{
}

CINSPECT_JUDGEMENT_PARM& CINSPECT_JUDGEMENT_PARM::operator=(CINSPECT_JUDGEMENT_PARM& rh)
{
	if(this != &rh)
	{
		Reset();	

		CopyMemory(corner_X,rh.corner_X,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE);
		CopyMemory(corner_Y,rh.corner_Y,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE);
		CopyMemory(grind,rh.grind,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE*2);
		CopyMemory(chamfer,rh.chamfer,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE*2);
		CopyMemory(cutting,rh.cutting,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE*2);
		CopyMemory(ptAlign,rh.ptAlign,sizeof(CPoint)*MAX_DIMENSION_COUNT*MAX_MARKER_COUNT);
		CopyMemory(nCFGrind,rh.nCFGrind,sizeof(int)*MAX_PANEL_SIDE);
		CopyMemory(EdgeToSubMark,rh.EdgeToSubMark,sizeof(JUDGE_EDGE)*MAX_DIMENSION_COUNT);
		CopyMemory(defect,rh.defect,sizeof(JUDGE_DEFECT)*MAX_DIMENSION_COUNT*3);
		CopyMemory(Dimension,rh.Dimension,sizeof(JUDGE_EDGE)*MAX_DIMENSION_COUNT);
		nCornerJugeLength = rh.nCornerJugeLength;
		nCornerJugeDepth = rh.nCornerJugeDepth;
		bUseLengthDepthComp = rh.bUseLengthDepthComp;
		CopyMemory(AvgProfile,rh.AvgProfile,sizeof(JUDGE_AVG)*MAX_DIMENSION_COUNT);
		CopyMemory(AvgChamfer,rh.AvgChamfer,sizeof(JUDGE_AVG)*MAX_DIMENSION_COUNT);

		CopyMemory(nMinProfileNgCount,rh.nMinProfileNgCount,sizeof(nMinProfileNgCount));
		CopyMemory(nMinProfileNgCount_MinDiff,rh.nMinProfileNgCount_MinDiff,sizeof(nMinProfileNgCount_MinDiff));
	}
	return *this;
}

void CINSPECT_JUDGEMENT_PARM::Reset()
{	
	ZeroMemory(corner_X,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE);
	ZeroMemory(corner_Y,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE);
	ZeroMemory(grind,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE*2);
	ZeroMemory(chamfer,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE*2);
	ZeroMemory(cutting,sizeof(JUDGE_EDGE)*MAX_PANEL_SIDE*2);
	ZeroMemory(ptAlign,sizeof(CPoint)*MAX_DIMENSION_COUNT*MAX_MARKER_COUNT);
	ZeroMemory(nCFGrind,sizeof(int)*MAX_PANEL_SIDE);
	ZeroMemory(EdgeToSubMark,sizeof(JUDGE_EDGE)*MAX_DIMENSION_COUNT);
	ZeroMemory(defect,sizeof(JUDGE_DEFECT)*MAX_DIMENSION_COUNT*3);
	ZeroMemory(Dimension,sizeof(JUDGE_EDGE)*MAX_DIMENSION_COUNT);
	nCornerJugeLength = nCornerJugeDepth = 0;
	bUseLengthDepthComp = FALSE;
	ZeroMemory(AvgProfile,sizeof(JUDGE_AVG)*MAX_DIMENSION_COUNT);
	ZeroMemory(AvgChamfer,sizeof(JUDGE_AVG)*MAX_DIMENSION_COUNT);
	ZeroMemory(nMinProfileNgCount,sizeof(nMinProfileNgCount));
	ZeroMemory(nMinProfileNgCount_MinDiff,sizeof(nMinProfileNgCount_MinDiff));
}

BOOL CINSPECT_JUDGEMENT_PARM::ReadRecipe(CConfig *pFile)
{
	int		i,j;
	CString	str;
	int		nValue;

	str.Format(_T("JUDGEMENT_CORNER_LENGTHDEPTH_USE"));
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,bUseLengthDepthComp);
	str.Format(_T("JUDGEMENT_CORNER_LENGTH"));
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCornerJugeLength);
	str.Format(_T("JUDGEMENT_CORNER_DEPTH"));
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCornerJugeDepth);

	for(i=0;i<MAX_PANEL_SIDE;i++)
	{
		str.Format(_T("JUDGEMENT_CORNER_X_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].bError);
		str.Format(_T("JUDGEMENT_CORNER_X_REFER_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].nRefernce);
		str.Format(_T("JUDGEMENT_CORNER_X_PLUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].nTolPlus);
		str.Format(_T("JUDGEMENT_CORNER_X_MINUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].nTolMinus);

		str.Format(_T("JUDGEMENT_CORNER_Y_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].bError);
		str.Format(_T("JUDGEMENT_CORNER_Y_REFER_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].nRefernce);
		str.Format(_T("JUDGEMENT_CORNER_Y_PLUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].nTolPlus);
		str.Format(_T("JUDGEMENT_CORNER_Y_MINUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].nTolMinus);

		for(j=0;j<2;j++)
		{
			str.Format(_T("JUDGEMENT_GRIND_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].bError);
			str.Format(_T("JUDGEMENT_GRIND_REFER_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].nRefernce);
			str.Format(_T("JUDGEMENT_GRIND_PLUS_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].nTolPlus);
			str.Format(_T("JUDGEMENT_GRIND_MINUS_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].nTolMinus);

			str.Format(_T("JUDGEMENT_CHAMFER_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].bError);
			str.Format(_T("JUDGEMENT_CHAMFER_REFER_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].nRefernce);
			str.Format(_T("JUDGEMENT_CHAMFER_PLUS_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].nTolPlus);
			str.Format(_T("JUDGEMENT_CHAMFER_MINUS_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].nTolMinus);

			str.Format(_T("JUDGEMENT_CUTTING_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].bError);
			str.Format(_T("JUDGEMENT_CUTTING_REFER_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].nRefernce);
			str.Format(_T("JUDGEMENT_CUTTING_PLUS_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].nTolPlus);
			str.Format(_T("JUDGEMENT_CUTTING_MINUS_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].nTolMinus);	
		}

		str.Format(_T("JUDGEMENT_CFGRIND%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCFGrind[i]);		
	}

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str.Format(_T("JUDGEMENT_AVG_PROFILE_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,AvgProfile[i].bUse);
		str.Format(_T("JUDGEMENT_AVG_PROFILE_DIFF_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,AvgProfile[i].nDiff);
		str.Format(_T("JUDGEMENT_AVG_CHAMFER_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,AvgChamfer[i].bUse);
		str.Format(_T("JUDGEMENT_AVG_CHAMFER_DIFF_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,AvgChamfer[i].nDiff);

		str.Format(_T("JUDGEMENT_MIN_PROFILE_NG_COUNT_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nMinProfileNgCount[i], 0);
		str.Format(_T("JUDGEMENT_DIFF_PROFILE_NG_COUNT_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nMinProfileNgCount_MinDiff[i], 0);
		
		str.Format(_T("JUDGEMENT_SUBMARK_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].bError);
		str.Format(_T("JUDGEMENT_SUBMARK_REFER_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].nRefernce);
		str.Format(_T("JUDGEMENT_SUBMARK_PLUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].nTolPlus);
		str.Format(_T("JUDGEMENT_SUBMARK_MINUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].nTolMinus);	

		str.Format(_T("DIMENSION_SUBMARK_USE_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].bError);
		str.Format(_T("DIMENSION_SUBMARK_REFER_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].nRefernce);
		str.Format(_T("DIMENSION_SUBMARK_PLUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].nTolPlus);
		str.Format(_T("DIMENSION_SUBMARK_MINUS_%d"),i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].nTolMinus);		

		for(j=0;j<MAX_MARKER_COUNT;j++)
		{
			str.Format(_T("ALIGNPOSITION_X_%d_%d"),i,j);			
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			ptAlign[j][i].x = nValue;
			str.Format(_T("ALIGNPOSITION_Y_%d_%d"),i,j);			
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			ptAlign[j][i].y = nValue;
		}

		for(j=0;j<3;j++)
		{
			str.Format(_T("JUDGEMENT_DEFECT_RNG_START_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].nRangeStart);
			str.Format(_T("JUDGEMENT_DEFECT_RNG_END_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].nRangeEnd);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_AND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_Side.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_Side.bError);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_MERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_Side.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_SIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Chip_Side.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_SIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Chip_Side.szDefect.cy = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_AND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_Side.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_Side.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_MERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_Side.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_SIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Burr_Side.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_SIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Burr_Side.szDefect.cy = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_AND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Broken.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Broken.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_MERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Broken.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_SIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Broken.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_SIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Broken.szDefect.cy = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_AND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Bevel.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Bevel.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_MERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Bevel.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_SIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Bevel.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_SIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Bevel.szDefect.cy = nValue;

			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_AND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_CF.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_CF.bError);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_MERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_CF.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_SIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Chip_CF.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_SIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Chip_CF.szDefect.cy = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFAND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_CF.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFUSE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_CF.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFMERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_CF.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFSIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Burr_CF.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFSIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Burr_CF.szDefect.cy = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_CRACKAND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Crack.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_CRACKUSE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Crack.bError);
			str.Format(_T("JUDGEMENT_DEFECT_CRACKMERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Crack.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_CRACKSIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Crack.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_CRACKSIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Crack.szDefect.cy = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_AND_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Compare_Panel.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_USE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Compare_Panel.bError);
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_MERGE_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Compare_Panel.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_SIZE_CX_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Compare_Panel.szDefect.cx = nValue;
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_SIZE_CY_%d_%d"),i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			defect[i][j].Compare_Panel.szDefect.cy = nValue;			
		}
	}
	return TRUE;
}

BOOL CINSPECT_JUDGEMENT_PARM::WriteRecipe(CConfig *pFile)
{
	int		i,j;
	CString	str;
	int		nValue;

	str.Format(_T("JUDGEMENT_CORNER_LENGTHDEPTH_USE"));
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,bUseLengthDepthComp);
	str.Format(_T("JUDGEMENT_CORNER_LENGTH"));
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCornerJugeLength);
	str.Format(_T("JUDGEMENT_CORNER_DEPTH"));
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCornerJugeDepth);

	for(i=0;i<MAX_PANEL_SIDE;i++)
	{
		str.Format(_T("JUDGEMENT_CORNER_X_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].bError);
		str.Format(_T("JUDGEMENT_CORNER_X_REFER_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].nRefernce);
		str.Format(_T("JUDGEMENT_CORNER_X_PLUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].nTolPlus);
		str.Format(_T("JUDGEMENT_CORNER_X_MINUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_X[i].nTolMinus);

		str.Format(_T("JUDGEMENT_CORNER_Y_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].bError);
		str.Format(_T("JUDGEMENT_CORNER_Y_REFER_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].nRefernce);
		str.Format(_T("JUDGEMENT_CORNER_Y_PLUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].nTolPlus);
		str.Format(_T("JUDGEMENT_CORNER_Y_MINUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,corner_Y[i].nTolMinus);

		for(j=0;j<2;j++)
		{
			str.Format(_T("JUDGEMENT_GRIND_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].bError);
			str.Format(_T("JUDGEMENT_GRIND_REFER_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].nRefernce);
			str.Format(_T("JUDGEMENT_GRIND_PLUS_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].nTolPlus);
			str.Format(_T("JUDGEMENT_GRIND_MINUS_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,grind[j][i].nTolMinus);

			str.Format(_T("JUDGEMENT_CHAMFER_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].bError);
			str.Format(_T("JUDGEMENT_CHAMFER_REFER_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].nRefernce);
			str.Format(_T("JUDGEMENT_CHAMFER_PLUS_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].nTolPlus);
			str.Format(_T("JUDGEMENT_CHAMFER_MINUS_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,chamfer[j][i].nTolMinus);

			str.Format(_T("JUDGEMENT_CUTTING_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].bError);
			str.Format(_T("JUDGEMENT_CUTTING_REFER_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].nRefernce);
			str.Format(_T("JUDGEMENT_CUTTING_PLUS_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].nTolPlus);
			str.Format(_T("JUDGEMENT_CUTTING_MINUS_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,cutting[j][i].nTolMinus);			
		}

		str.Format(_T("JUDGEMENT_CFGRIND%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCFGrind[i]);		
	}

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{		
		str.Format(_T("JUDGEMENT_AVG_PROFILE_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,AvgProfile[i].bUse);
		str.Format(_T("JUDGEMENT_AVG_PROFILE_DIFF_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,AvgProfile[i].nDiff);
		str.Format(_T("JUDGEMENT_AVG_CHAMFER_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,AvgChamfer[i].bUse);
		str.Format(_T("JUDGEMENT_AVG_CHAMFER_DIFF_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,AvgChamfer[i].nDiff);

		str.Format(_T("JUDGEMENT_MIN_PROFILE_NG_COUNT_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nMinProfileNgCount[i]);
		str.Format(_T("JUDGEMENT_DIFF_PROFILE_NG_COUNT_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nMinProfileNgCount_MinDiff[i]);

		str.Format(_T("JUDGEMENT_SUBMARK_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].bError);
		str.Format(_T("JUDGEMENT_SUBMARK_REFER_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].nRefernce);
		str.Format(_T("JUDGEMENT_SUBMARK_PLUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].nTolPlus);
		str.Format(_T("JUDGEMENT_SUBMARK_MINUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,EdgeToSubMark[i].nTolMinus);		

		str.Format(_T("DIMENSION_SUBMARK_USE_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].bError);
		str.Format(_T("DIMENSION_SUBMARK_REFER_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].nRefernce);
		str.Format(_T("DIMENSION_SUBMARK_PLUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].nTolPlus);
		str.Format(_T("DIMENSION_SUBMARK_MINUS_%d"),i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,Dimension[i].nTolMinus);

		for(j=0;j<MAX_MARKER_COUNT;j++)
		{
			str.Format(_T("ALIGNPOSITION_X_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,ptAlign[j][i].x);
			str.Format(_T("ALIGNPOSITION_Y_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,ptAlign[j][i].y);
		}

		for(j=0;j<3;j++)
		{
			str.Format(_T("JUDGEMENT_DEFECT_RNG_START_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].nRangeStart);
			str.Format(_T("JUDGEMENT_DEFECT_RNG_END_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].nRangeEnd);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_AND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_Side.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_Side.bError);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_MERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_Side.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_SIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Chip_Side.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_CHIPSIDE_SIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Chip_Side.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_AND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_Side.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_Side.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_MERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_Side.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_SIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Burr_Side.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_BURRSIDE_SIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Burr_Side.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_AND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Broken.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Broken.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_MERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Broken.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_SIZE_CX_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);
			nValue = defect[i][j].Broken.szDefect.cx;
			str.Format(_T("JUDGEMENT_DEFECT_BROKEN_SIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Broken.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);

			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_AND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Bevel.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Bevel.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_MERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Bevel.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_SIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Bevel.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_BEVEL_SIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Bevel.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		

			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_AND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_CF.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_CF.bError);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_MERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Chip_CF.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_SIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Chip_CF.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_CHIPCF_SIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Chip_CF.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFAND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_CF.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFUSE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_CF.bError);
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFMERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Burr_CF.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFSIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Burr_CF.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_BURRCFSIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Burr_CF.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_CRACKAND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Crack.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_CRACKUSE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Crack.bError);
			str.Format(_T("JUDGEMENT_DEFECT_CRACKMERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Crack.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_CRACKSIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Crack.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_CRACKSIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Crack.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_AND_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Compare_Panel.bConditionAND);
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_USE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Compare_Panel.bError);
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_MERGE_%d_%d"),i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,defect[i][j].Compare_Panel.nMerge);
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_SIZE_CX_%d_%d"),i,j);
			nValue = defect[i][j].Compare_Panel.szDefect.cx;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		
			str.Format(_T("JUDGEMENT_DEFECT_COMPARE_SIZE_CY_%d_%d"),i,j);
			nValue = defect[i][j].Compare_Panel.szDefect.cy;
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);
		}	
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CINSPECT_INFO_PARM
CINSPECT_INFO_PARM::CINSPECT_INFO_PARM(void)
{
	Reset();
}

CINSPECT_INFO_PARM::~CINSPECT_INFO_PARM(void)
{
}

CINSPECT_INFO_PARM& CINSPECT_INFO_PARM::operator=(CINSPECT_INFO_PARM& rh)
{
	if(this != &rh)
	{
		Reset();	
		m_CutAreaParm = rh.m_CutAreaParm;
		m_DimensionParm = rh.m_DimensionParm;
		m_SplineParm = rh.m_SplineParm;	
		m_CornerParm = rh.m_CornerParm;
		m_NotchParm = rh.m_NotchParm;
		m_VCRParm = rh.m_VCRParm;
		CopyMemory(m_nRCutThresGlass,rh.m_nRCutThresGlass,sizeof(int)*MAX_DIMENSION_COUNT*2);
		CopyMemory(m_nRCutThresChamfer,rh.m_nRCutThresChamfer,sizeof(int)*MAX_DIMENSION_COUNT*2);

		std::vector<STU_EXTRA_CHIP_REG>::iterator it;		

		for(it=rh.m_vecExtraChipReg.begin();it!=rh.m_vecExtraChipReg.end();it++)
		{
			m_vecExtraChipReg.push_back(*it);
		}

	}
	return *this;
}

void CINSPECT_INFO_PARM::Reset()
{
	m_CutAreaParm.Reset();
	m_DimensionParm.Reset();
	m_SplineParm.Reset();
	m_CornerParm.Reset();
	m_NotchParm.Reset();
	m_VCRParm.Reset();
	m_vecExtraChipReg.clear();	
	ZeroMemory(m_nRCutThresGlass,sizeof(int)*MAX_DIMENSION_COUNT*2);
	ZeroMemory(m_nRCutThresChamfer,sizeof(int)*MAX_DIMENSION_COUNT*2);
}

BOOL CINSPECT_INFO_PARM::ReadRecipe(CConfig *pFile)
{
	m_CutAreaParm.ReadRecipe(pFile);
	m_DimensionParm.ReadRecipe(pFile);	
	m_SplineParm.ReadRecipe(pFile);	
	m_CornerParm.ReadRecipe(pFile);	
	m_NotchParm.ReadRecipe(pFile);	
	m_VCRParm.ReadRecipe(pFile);

	STU_EXTRA_CHIP_REG		stuPos;
	int						iLoop,nCount,nValue;
	CString					str;

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		for(iLoop=0;iLoop<2;iLoop++)
		{
			str.Format(_T("RCUT_THRES_GLASS_%d_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nRCutThresGlass[i][iLoop]);
			str.Format(_T("RCUT_THRES_Chamfer_%d_%d"),i,iLoop);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str,m_nRCutThresChamfer[i][iLoop]);
		}
	}

	str.Format(_T("EXTRA_CHIP_REG_COUNT"));
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nCount);

	m_vecExtraChipReg.clear();
	for(iLoop=0;iLoop<nCount;iLoop++)
	{
		stuPos.Reset();

		str.Format(_T("EXTRA_CHIP_REG_DIMENSION_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,nValue);
		stuPos.enSide = (DimensionDir)nValue;

		str.Format(_T("EXTRA_CHIP_REG_TB_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.bTB);

		str.Format(_T("EXTRA_CHIP_REG_START_Y_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nStartY);

		str.Format(_T("EXTRA_CHIP_REG_END_Y_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nYSize);

		str.Format(_T("EXTRA_CHIP_REG_SIZE_X_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSizeX);

		str.Format(_T("EXTRA_CHIP_REG_CHAMFER_THRES_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChamferThres);		

		str.Format(_T("EXTRA_CHIP_REG_CHIP_THRES_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChipThres);		

		str.Format(_T("EXTRA_CHIP_REG_JUDGEBASE_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nJudgeBase);

		str.Format(_T("EXTRA_CHIP_REG_JUDGEDIFF_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nJudgeDiff);

		str.Format(_T("EXTRA_CHIP_REG_CHIP_WIDTH_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChipWidth);	

		str.Format(_T("EXTRA_CHIP_REG_CHIP_HEIGHT_%d"),iLoop);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChipHeight);	

		m_vecExtraChipReg.push_back(stuPos);
	}

	return TRUE;
}

BOOL CINSPECT_INFO_PARM::WriteRecipe(CConfig *pFile)
{
	m_CutAreaParm.WriteRecipe(pFile);
	m_DimensionParm.WriteRecipe(pFile);	
	m_SplineParm.WriteRecipe(pFile);	
	m_CornerParm.WriteRecipe(pFile);	
	m_NotchParm.WriteRecipe(pFile);
	m_VCRParm.WriteRecipe(pFile);

	STU_EXTRA_CHIP_REG		stuPos;
	int						iLoop,nCount,nValue;
	CString					str;

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		for(iLoop=0;iLoop<2;iLoop++)
		{
			str.Format(_T("RCUT_THRES_GLASS_%d_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nRCutThresGlass[i][iLoop]);
			str.Format(_T("RCUT_THRES_Chamfer_%d_%d"),i,iLoop);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str,m_nRCutThresChamfer[i][iLoop]);
		}
	}

	nCount = (int)m_vecExtraChipReg.size();
	str.Format(_T("EXTRA_CHIP_REG_COUNT"));
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nCount);

	for(iLoop=0;iLoop<nCount;iLoop++)
	{
		stuPos = m_vecExtraChipReg[iLoop];

		str.Format(_T("EXTRA_CHIP_REG_DIMENSION_%d"),iLoop);
		nValue = (int)stuPos.enSide;
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,nValue);		

		str.Format(_T("EXTRA_CHIP_REG_TB_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.bTB);

		str.Format(_T("EXTRA_CHIP_REG_START_Y_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nStartY);

		str.Format(_T("EXTRA_CHIP_REG_END_Y_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nYSize);

		str.Format(_T("EXTRA_CHIP_REG_SIZE_X_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nSizeX);

		str.Format(_T("EXTRA_CHIP_REG_CHAMFER_THRES_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChamferThres);		

		str.Format(_T("EXTRA_CHIP_REG_CHIP_THRES_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChipThres);		

		str.Format(_T("EXTRA_CHIP_REG_JUDGEBASE_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nJudgeBase);

		str.Format(_T("EXTRA_CHIP_REG_JUDGEDIFF_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nJudgeDiff);		

		str.Format(_T("EXTRA_CHIP_REG_CHIP_WIDTH_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChipWidth);	

		str.Format(_T("EXTRA_CHIP_REG_CHIP_HEIGHT_%d"),iLoop);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str,stuPos.nChipHeight);	
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// CALIGNMARK_PARM
CALIGNMARK_PARM::CALIGNMARK_PARM(void)
{
	for(int j = 0; j < MAX_MARKER_COUNT ; j++)
		for(int i=0;i<MAX_POS_MARKER_COUNT;i++)
			IpMarkImg[j][i] = NULL;
	Reset();
}

CALIGNMARK_PARM::~CALIGNMARK_PARM(void)
{

}

CALIGNMARK_PARM& CALIGNMARK_PARM::operator=(CALIGNMARK_PARM& rh)
{
	if(this != &rh)
	{
		Reset();
		CopyMemory(m_bIsMark,rh.m_bIsMark,sizeof(BOOL)*MAX_MARKER_COUNT);		
		CopyMemory(m_nMarkType,rh.m_nMarkType,sizeof(int)*MAX_MARKER_COUNT);		
		CopyMemory(m_dMarkMatchingRate,rh.m_dMarkMatchingRate,sizeof(double)*MAX_MARKER_COUNT*MAX_POS_MARKER_COUNT);	
		m_JudgeAlign = rh.m_JudgeAlign;		

	}
	return *this;
}

void CALIGNMARK_PARM::MarkImgDelete()
{
	for(int j = 0; j < MAX_MARKER_COUNT ; j++)
	{
		for(int i=0;i<MAX_POS_MARKER_COUNT;i++)
		{
			if(IpMarkImg[j][i])
			{
				cvReleaseImage(&IpMarkImg[j][i]);
				IpMarkImg[j][i] = NULL;
			}
		}
	}
}

void CALIGNMARK_PARM::Reset()
{
	ZeroMemory(m_bIsMark,sizeof(BOOL)*MAX_MARKER_COUNT);	
	ZeroMemory(m_nMarkType,sizeof(int)*MAX_MARKER_COUNT);		
	ZeroMemory(m_dMarkMatchingRate,sizeof(double)*MAX_MARKER_COUNT*MAX_POS_MARKER_COUNT);	
	ZeroMemory(&m_JudgeAlign,sizeof(JUDGEEDGE));
	MarkImgDelete();
}

BOOL CALIGNMARK_PARM::ReadRecipe(CConfig *pFile,int nIdx)
{	

	int			i;
	CString		str;

	for(i=0;i<MAX_MARKER_COUNT;i++)
	{
		str.Format(_T("ALIGNMARK_ISEXIT_MARKER_%d_%d"),nIdx,i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_bIsMark[i]);	
		str.Format(_T("ALIGNMARK_TYPE_MARKER_%d_%d"),nIdx,i);
		pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_nMarkType[i]);	
		for(int j=0;j<MAX_POS_MARKER_COUNT;j++)
		{
			str.Format(_T("ALIGNMARK_MATCHINGRATE_MARKER_%d_%d_%d"),nIdx,i,j);
			pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_dMarkMatchingRate[i][j]);	
		}
	}

	str.Format(_T("ALIGNMARK_JUGE_REF_%d"),nIdx);
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_JudgeAlign.nRefernce);	
	str.Format(_T("ALIGNMARK_JUGE_PLUS_%d"),nIdx);
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_JudgeAlign.nTolPlus);	
	str.Format(_T("ALIGNMARK_JUGE_MINUS_%d"),nIdx);
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_JudgeAlign.nTolMinus);		

	return TRUE;
}
BOOL CALIGNMARK_PARM::WriteRecipe(CConfig *pFile,int nIdx)
{
	int			i;
	CString		str;

	for(i=0;i<MAX_MARKER_COUNT;i++)
	{
		str.Format(_T("ALIGNMARK_ISEXIT_MARKER_%d_%d"),nIdx,i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_bIsMark[i]);	
		str.Format(_T("ALIGNMARK_TYPE_MARKER_%d_%d"),nIdx,i);
		pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_nMarkType[i]);	

		for(int j=0;j<MAX_POS_MARKER_COUNT;j++)
		{
			str.Format(_T("ALIGNMARK_MATCHINGRATE_MARKER_%d_%d_%d"),nIdx,i,j);
			pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_dMarkMatchingRate[i][j]);	
		}
	}

	str.Format(_T("ALIGNMARK_JUGE_REF_%d"),nIdx);
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_JudgeAlign.nRefernce);	
	str.Format(_T("ALIGNMARK_JUGE_PLUS_%d"),nIdx);
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_JudgeAlign.nTolPlus);	
	str.Format(_T("ALIGNMARK_JUGE_MINUS_%d"),nIdx);
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_JudgeAlign.nTolMinus);

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////

CHOLEINSPECT_PARM& CHOLEINSPECT_PARM::operator=(CHOLEINSPECT_PARM& rh)
{
	Reset();

	m_nTotalHoleCount = rh.m_nTotalHoleCount;
	m_vecHoleInsParam = rh.m_vecHoleInsParam;

	return *this;
}

BOOL CHOLEINSPECT_PARM::ReadRecipe(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	int			nValue = 0;
	CString		str;
	str.Format(_T("HOLE_INSPECT_TOTAL_COUNT"));
	pFile->GetItemValue((TCHAR*)(LPCTSTR)str, m_nTotalHoleCount);	

	HOLE_INS_PARM holeInsParam;

	m_vecHoleInsParam.clear();

	for(int i=0;i<m_nTotalHoleCount;i++)
	{
		// 1. Side
		str.Format(_T("HOLE_INSPECT_SIDE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, holeInsParam.m_nSideIdx);

		// 2. Template Area
		str.Format(_T("HOLE_INSPECT_ROI_L"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtArea.left = nValue;

		str.Format(_T("HOLE_INSPECT_ROI_T"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtArea.top = nValue;

		str.Format(_T("HOLE_INSPECT_ROI_R"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtArea.right = nValue;

		str.Format(_T("HOLE_INSPECT_ROI_B"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtArea.bottom = nValue;

		// 3. Hole Area
		str.Format(_T("HOLE_INSPECT_CIRCLE_L"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtHoleArea.left = nValue;

		str.Format(_T("HOLE_INSPECT_CIRCLE_T"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtHoleArea.top = nValue;

		str.Format(_T("HOLE_INSPECT_CIRCLE_R"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtHoleArea.right = nValue;

		str.Format(_T("HOLE_INSPECT_CIRCLE_B"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, nValue);
		holeInsParam.m_rtHoleArea.bottom = nValue;

		// 4. Inspection Param
		str.Format(_T("HOLE_INSPECT_THRESHOLD"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, holeInsParam.m_nThreshold);

		str.Format(_T("HOLE_INSPECT_OFFSET"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, holeInsParam.m_nOffset);

		str.Format(_T("HOLE_INSPECT_MINSIZE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, holeInsParam.m_nMinSize);

		str.Format(_T("HOLE_INSPECT_MATRATE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, holeInsParam.m_dMatRate);

		str.Format(_T("HOLE_INSPECT_TEMPLATE_IMG_PATH"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, holeInsParam.m_strTemplatePath);

		m_vecHoleInsParam.push_back(holeInsParam);
	}

	return TRUE;
}

BOOL CHOLEINSPECT_PARM::WriteRecipe(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	CString		str;
	str.Format(_T("HOLE_INSPECT_TOTAL_COUNT"));
	pFile->SetItemValue((TCHAR*)(LPCTSTR)str, m_nTotalHoleCount);	

	HOLE_INS_PARM holeInsParam;

	for(int i=0;i<m_nTotalHoleCount;i++)
	{
		if(m_vecHoleInsParam.size() <= i)
			continue;

		// 1. Side
		str.Format(_T("HOLE_INSPECT_SIDE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_vecHoleInsParam[i].m_nSideIdx);

		// 2. Template Area
		str.Format(_T("HOLE_INSPECT_ROI_L"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtArea.left);

		str.Format(_T("HOLE_INSPECT_ROI_T"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtArea.top);

		str.Format(_T("HOLE_INSPECT_ROI_R"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtArea.right);

		str.Format(_T("HOLE_INSPECT_ROI_B"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtArea.bottom);

		// 3. Hole Area
		str.Format(_T("HOLE_INSPECT_CIRCLE_L"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtHoleArea.left);

		str.Format(_T("HOLE_INSPECT_CIRCLE_T"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtHoleArea.top);

		str.Format(_T("HOLE_INSPECT_CIRCLE_R"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtHoleArea.right);

		str.Format(_T("HOLE_INSPECT_CIRCLE_B"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, (int) m_vecHoleInsParam[i].m_rtHoleArea.bottom);

		// 4. Inspection Param
		str.Format(_T("HOLE_INSPECT_THRESHOLD"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str,  m_vecHoleInsParam[i].m_nThreshold);

		str.Format(_T("HOLE_INSPECT_OFFSET"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str,  m_vecHoleInsParam[i].m_nOffset);

		str.Format(_T("HOLE_INSPECT_MINSIZE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str,  m_vecHoleInsParam[i].m_nMinSize);

		str.Format(_T("HOLE_INSPECT_MATRATE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str,  m_vecHoleInsParam[i].m_dMatRate);		

		str.Format(_T("HOLE_INSPECT_TEMPLATE_IMG_PATH"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str,  m_vecHoleInsParam[i].m_strTemplatePath);
	}

	return TRUE;
}

void CHOLEINSPECT_PARM::Reset()
{
	m_nTotalHoleCount = 0;
	m_vecHoleInsParam.clear();
}

//////////////////////////////////////////////////////////////////////////

CProfileInspect_Prm& CProfileInspect_Prm::operator=(CProfileInspect_Prm& rh)
{
	Reset();

	CopyMemory(m_bUseOriginAlignKey,rh.m_bUseOriginAlignKey,sizeof(BOOL)*MAX_DIMENSION_COUNT);
	CopyMemory(m_nOriginAlignKeyOffsetX,rh.m_nOriginAlignKeyOffsetX,sizeof(int)*MAX_DIMENSION_COUNT);
	CopyMemory(m_nOriginAlignKeyOffsetY,rh.m_nOriginAlignKeyOffsetY,sizeof(int)*MAX_DIMENSION_COUNT);
	CopyMemory(m_nOriginAlignKeyOffsetDwX,rh.m_nOriginAlignKeyOffsetDwX,sizeof(int)*MAX_DIMENSION_COUNT);
	CopyMemory(m_nOriginAlignKeyOffsetDwY,rh.m_nOriginAlignKeyOffsetDwY,sizeof(int)*MAX_DIMENSION_COUNT);
	CopyMemory(m_nCADOffsetX,rh.m_nCADOffsetX,sizeof(int)*MAX_DIMENSION_COUNT);
	CopyMemory(m_nCADOffsetY,rh.m_nCADOffsetY,sizeof(int)*MAX_DIMENSION_COUNT);
	CopyMemory(m_stProfile,rh.m_stProfile,sizeof(ST_PROFILE_SETTING)*MAX_PROFILE_SETTING_COUNT);
	CopyMemory(m_stCamferUp,rh.m_stCamferUp,sizeof(ST_CHAMFER_SETTING)*MAX_PROFILE_SETTING_COUNT);
	CopyMemory(m_stCamferDn,rh.m_stCamferDn,sizeof(ST_CHAMFER_SETTING)*MAX_PROFILE_SETTING_COUNT);
	CopyMemory(m_dConvResolution, rh.m_dConvResolution, sizeof(double) * MAX_DIMENSION_COUNT * MAX_STAGE_HAND_COUNT);
	CopyMemory(m_dScanResolution, rh.m_dScanResolution, sizeof(double) * MAX_DIMENSION_COUNT * MAX_STAGE_HAND_COUNT);

	return *this;
}

BOOL CProfileInspect_Prm::ReadRecipe(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	int			nValue = 0;
	CString		str;
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str.Format(_T("USE_ORIGIN_ALIGNKEY_OFFSET"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_bUseOriginAlignKey[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_X"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetX[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_Y"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetY[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_DW_X"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetDwX[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_DW_Y"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetDwY[i]);
		str.Format(_T("CAD_PROFILE_OFFSET_X"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nCADOffsetX[i]);	
		str.Format(_T("CAD_PROFILE_OFFSET_Y"));
		pFile->GetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nCADOffsetY[i]);

		for (int j = 0; j < MAX_STAGE_HAND_COUNT; j++) {
			// Conv Resolution
			str.Format(_T("CONV_RESOLUTION_%d_%d"), i, j);
			pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_dConvResolution[i][j]);

			// Scan Resolution
			str.Format(_T("SCAN_RESOLUTION_%d_%d"), i, j);
			pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_dScanResolution[i][j]);
		}
	}

	for(i=0;i<MAX_PROFILE_SETTING_COUNT;i++)
	{		
		str.Format(_T("PROFILE_PRM_X"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].x);
		str.Format(_T("PROFILE_PRM_Y"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].y);
		str.Format(_T("PROFILE_PRM_USE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].use);
		str.Format(_T("PROFILE_PRM_MINUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].minus);
		str.Format(_T("PROFILE_PRM_PLUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].plus);
		str.Format(_T("PROFILE_PRM_RADIUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].radius);
		str.Format(_T("CHAMFER_UP_PRM_USE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].use);
		str.Format(_T("CHAMFER_UP_PRM_REFERENCE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].reference);
		str.Format(_T("CHAMFER_UP_PRM_MINUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].minus);
		str.Format(_T("CHAMFER_UP_PRM_PLUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].plus);
		str.Format(_T("CHAMFER_DN_PRM_USE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].use);
		str.Format(_T("CHAMFER_DN_PRM_REFERENCE"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].reference);
		str.Format(_T("CHAMFER_DN_PRM_MINUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].minus);
		str.Format(_T("CHAMFER_DN_PRM_PLUS"));
		pFile->GetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].plus);
	}	

	return TRUE;
}

BOOL CProfileInspect_Prm::WriteRecipe(CConfig *pFile)
{
	if(pFile == NULL)
		return FALSE;

	int			nValue = 0;
	CString		str;
	int			i;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		str.Format(_T("USE_ORIGIN_ALIGNKEY_OFFSET"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_bUseOriginAlignKey[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_X"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetX[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_Y"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetY[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_DW_X"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetDwX[i]);
		str.Format(_T("ORIGIN_ALIGNKEY_OFFSET_DW_Y"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nOriginAlignKeyOffsetDwY[i]);
		str.Format(_T("CAD_PROFILE_OFFSET_X"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nCADOffsetX[i]);	
		str.Format(_T("CAD_PROFILE_OFFSET_Y"));
		pFile->SetItemValue(i,(TCHAR*)(LPCTSTR)str, m_nCADOffsetY[i]);

		for (int j = 0; j < MAX_STAGE_HAND_COUNT; j++) {
			str.Format(_T("CONV_RESOLUTION_%d_%d"), i, j);
			pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_dConvResolution[i][j]);

			str.Format(_T("SCAN_RESOLUTION_%d_%d"), i, j);
			pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_dScanResolution[i][j]);
		}
	}

	for(i=0;i<MAX_PROFILE_SETTING_COUNT;i++)
	{		
		str.Format(_T("PROFILE_PRM_X"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].x);
		str.Format(_T("PROFILE_PRM_Y"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].y);
		str.Format(_T("PROFILE_PRM_USE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].use);
		str.Format(_T("PROFILE_PRM_MINUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].minus);
		str.Format(_T("PROFILE_PRM_PLUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].plus);
		str.Format(_T("PROFILE_PRM_RADIUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stProfile[i].radius);
		str.Format(_T("CHAMFER_UP_PRM_USE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].use);
		str.Format(_T("CHAMFER_UP_PRM_REFERENCE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].reference);
		str.Format(_T("CHAMFER_UP_PRM_MINUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].minus);
		str.Format(_T("CHAMFER_UP_PRM_PLUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferUp[i].plus);
		str.Format(_T("CHAMFER_DN_PRM_USE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].use);
		str.Format(_T("CHAMFER_DN_PRM_REFERENCE"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].reference);
		str.Format(_T("CHAMFER_DN_PRM_MINUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].minus);
		str.Format(_T("CHAMFER_DN_PRM_PLUS"));
		pFile->SetItemValue(i, (TCHAR*)(LPCTSTR)str, m_stCamferDn[i].plus);
	}	

	return TRUE;
}

void CProfileInspect_Prm::Reset()
{
	ZeroMemory(m_bUseOriginAlignKey,sizeof(BOOL)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_nOriginAlignKeyOffsetX,sizeof(int)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_nOriginAlignKeyOffsetY,sizeof(int)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_nOriginAlignKeyOffsetDwX,sizeof(int)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_nOriginAlignKeyOffsetDwY,sizeof(int)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_nCADOffsetY,sizeof(int)*MAX_DIMENSION_COUNT);	
	ZeroMemory(m_nCADOffsetX,sizeof(int)*MAX_DIMENSION_COUNT);
	ZeroMemory(m_stProfile,sizeof(ST_PROFILE_SETTING)*MAX_PROFILE_SETTING_COUNT);
	ZeroMemory(m_stCamferUp,sizeof(ST_CHAMFER_SETTING)*MAX_PROFILE_SETTING_COUNT);
	ZeroMemory(m_stCamferDn,sizeof(ST_CHAMFER_SETTING)*MAX_PROFILE_SETTING_COUNT);
	ZeroMemory(m_dConvResolution, sizeof(double) * MAX_DIMENSION_COUNT * MAX_STAGE_HAND_COUNT);
	ZeroMemory(m_dScanResolution, sizeof(double) * MAX_DIMENSION_COUNT * MAX_STAGE_HAND_COUNT);
}

//////////////////////////////////////////////////////////////////////////
// CGlassRecipe
CGlassRecipe::CGlassRecipe(void)
{
	Reset();
}

CGlassRecipe::~CGlassRecipe(void)
{
	DeleteExpAreaList();
}

CGlassRecipe& CGlassRecipe::operator=(CGlassRecipe& rh)
{
	if(this != &rh)
	{
		Reset();
		m_RecieParm = rh.m_RecieParm;	
		m_GlassParm = rh.m_GlassParm;						 
		m_LightParm = rh.m_LightParm;		
		CopyMemory(m_ETCParm,rh.m_ETCParm,sizeof(CETC_PARM)*MAX_DIMENSION_COUNT);
		CopyMemory(m_AlignMarkParm,rh.m_AlignMarkParm,sizeof(CALIGNMARK_PARM)*MAX_DIMENSION_COUNT);

		itUSER_DEFECT_AREA_LIST it;
		ST_USER_DEFECT_AREA	stUserDefect;
		itEXCEPTION_AREA_LIST	itExp;
		EXECPTION_AREA			*pExp = NULL;

		DeleteExpAreaList();

		for(int i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			m_UserDefectPrm[i].clear();
			for(it=rh.m_UserDefectPrm[i].begin();it!=rh.m_UserDefectPrm[i].end();it++)
			{
				stUserDefect = *it;
				m_UserDefectPrm[i].push_back(stUserDefect);
			}			

			for(itExp=rh.m_ExpAreaPrm[i].begin();itExp!=rh.m_ExpAreaPrm[i].end();itExp++)
			{
				pExp = new EXECPTION_AREA();

				pExp->CopyData(*itExp);
				m_ExpAreaPrm[i].push_back(pExp);
			}
		}		

		m_InspectInfoParm = rh.m_InspectInfoParm;
		m_Judgement = rh.m_Judgement;		 
		m_HoleInspectParm = rh.m_HoleInspectParm;
		m_ProfilePrm = rh.m_ProfilePrm;

	}
	return *this;
}

void CGlassRecipe::DeleteExpAreaList()
{
	itEXCEPTION_AREA_LIST	itExp;	

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{		
		for(itExp=m_ExpAreaPrm[i].begin();itExp!=m_ExpAreaPrm[i].end();itExp++)
		{				
			delete (*itExp);	
		}
		m_ExpAreaPrm[i].clear();		
	}		
}

void CGlassRecipe::Reset()
{
	m_RecieParm.Reset();
	m_GlassParm.Reset();			
	m_LightParm.Reset();	
	ZeroMemory(m_AlignMarkParm,sizeof(CALIGNMARK_PARM)*MAX_DIMENSION_COUNT);	
	ZeroMemory(m_ETCParm,sizeof(CETC_PARM)*MAX_DIMENSION_COUNT);

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		m_UserDefectPrm[i].clear();				
	}	

	DeleteExpAreaList();

	m_InspectInfoParm.Reset();	
	m_Judgement.Reset();
	m_ProfilePrm.Reset();
}

BOOL CGlassRecipe::MakeRecipeFileName(CString strRecipe)
{
	if (strRecipe.IsEmpty())
		return FALSE;

	CString			str;	

	m_RecieParm.SetRecipeName(strRecipe);

	str.Empty();
	str = RECIPE_PATH;
	str += "\\";
	str += strRecipe;
	str += ".rcp";
	m_RecieParm.SetRecipeFileName(str);

	return TRUE;
}

BOOL CGlassRecipe::ReadRecipe(CConfig *pFile)
{
	m_RecieParm.ReadRecipe(pFile);
	m_GlassParm.ReadRecipe(pFile);			
	m_LightParm.ReadRecipe(pFile);		
	m_InspectInfoParm.ReadRecipe(pFile);
	m_Judgement.ReadRecipe(pFile);
	m_HoleInspectParm.ReadRecipe(pFile);
	m_ProfilePrm.ReadRecipe(pFile);

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		m_ETCParm[i].ReadRecipe(pFile,i);
		m_AlignMarkParm[i].ReadRecipe(pFile,i);
	}		

	LoadAlignMark();

	LoadUserDefectList();

	LoadExpAreaList();

	return TRUE;
}

BOOL CGlassRecipe::WriteRecipe(CConfig *pFile)
{
	pFile->SetRewriteMode(FALSE);

	m_RecieParm.WriteRecipe(pFile);
	m_GlassParm.WriteRecipe(pFile);	
	m_InspectInfoParm.WriteRecipe(pFile);			
	m_LightParm.WriteRecipe(pFile);		
	m_Judgement.WriteRecipe(pFile);
	m_HoleInspectParm.WriteRecipe(pFile);
	m_ProfilePrm.WriteRecipe(pFile);

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		m_ETCParm[i].WriteRecipe(pFile,i);
		m_AlignMarkParm[i].WriteRecipe(pFile,i);
	}

	SaveAlignMark();

	//pFile->SetRewriteMode(TRUE);
	pFile->WriteToFile();

	return TRUE;
}

BOOL CGlassRecipe::WriteRecipeFile()
{
	CString		strRecipe = m_RecieParm.m_strRecipeFileName;

	m_RecipeFile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode);

	return WriteRecipe(&m_RecipeFile);	
}

BOOL CGlassRecipe::ReadRecipeFile()
{
	CString		strRecipe = m_RecieParm.m_strRecipeFileName;	
	if (!m_RecipeFile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode))
	{		
		Reset();
		return FALSE;
	}

	return ReadRecipe(&m_RecipeFile);	
}

CString CGlassRecipe::GetRecipeName()
{
	return m_RecieParm.GetRecipeName();
}

BOOL CGlassRecipe::WriteRecipeFileBackUp()
{
	CString		strRecipe = m_RecieParm.m_strRecipeFileNameBackUp;

	m_RecipeFile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode);

	return WriteRecipe(&m_RecipeFile);	
}

int CGlassRecipe::GetLightValue(int iCon,int iCh)
{
	if(iCon	< 0 || iCon >= LIGHT_CONTROL_COUNT)
		return 0;
	if(iCh	< 0 || iCh >= LIGHT_CONTROL_CH_COUNT)
		return 0;

	return m_LightParm.m_nContValue[iCon][iCh];
}

CALIGNMARK_PARM	*CGlassRecipe::GetAlignMarkPrm(DimensionDir eDim)
{
	if(eDim < DIMENSION_A || eDim > DIMENSION_D_DN)
		return NULL;

	return &m_AlignMarkParm[eDim];
}

BOOL CGlassRecipe::LoadAlignMark()
{
	int		i,j;
	CALIGNMARK_PARM	*pAlign;
	CString	strPath;

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		pAlign = GetAlignMarkPrm((DimensionDir)i);
		if(pAlign == NULL)
			continue;

		for( j = 0 ; j < MAX_MARKER_COUNT ; j++)
		{			
			for(int iPos=0;iPos<MAX_POS_MARKER_COUNT;iPos++)
			{
				strPath.Format(_T("%s\\%s\\Align_%d_%d_%d.bmp"),RECIPE_ALIGN_PATH,GetRecipeName(),i,j,iPos);
				Load_Image(strPath,&pAlign->IpMarkImg[j][iPos]);
			}
		}
	}
	return TRUE;
}

BOOL CGlassRecipe::SaveAlignMark()
{
	int		i,j;
	CALIGNMARK_PARM	*pAlign;
	CString	strPath;

	CreateDirectory(RECIPE_ALIGN_PATH,NULL);
	strPath.Format(_T("%s\\%s"),RECIPE_ALIGN_PATH,GetRecipeName());
	CreateDirectory(strPath,NULL);

	for(i=0;i<MAX_DIMENSION_COUNT;i++)
	{
		pAlign = GetAlignMarkPrm((DimensionDir)i);
		if(pAlign == NULL)
			continue;

		for( j = 0 ; j < MAX_MARKER_COUNT ; j++)
		{			
			for(int iPos=0;iPos<MAX_POS_MARKER_COUNT;iPos++)
			{
				strPath.Format(_T("%s\\%s\\Align_%d_%d_%d.bmp"),RECIPE_ALIGN_PATH,GetRecipeName(),i,j,iPos);
				Save_Image(strPath,pAlign->IpMarkImg[j][iPos]);
			}		
		}
	}
	return TRUE;
}

pSTU_CUTAREA_PARM CGlassRecipe::GetCutAreaPrm(DimensionDir eDim)
{
	if(eDim < DIMENSION_A || eDim > DIMENSION_D_DN)
		return NULL;

	return m_InspectInfoParm.GetCutAreaParm(eDim);
}

CETC_PARM *CGlassRecipe::GetEtcPrm(DimensionDir eDim)
{
	if(eDim < DIMENSION_A || eDim > DIMENSION_D_DN)
		return NULL;

	return &m_ETCParm[eDim];
}

BOOL CGlassRecipe::MakeRecipeFileNameBackUp( CString strRecipe )
{
	if (strRecipe.IsEmpty())
		return FALSE;

	CString			str;	

	str.Empty();
	str = RECIPE_PATH;
	str += _T("\\");
	str += _T("BackUp");

	CreateDirectory(str,NULL);		

	str += _T("\\");
	str += strRecipe;

	CString			strtemp;
	CTime	time = CTime::GetCurrentTime();

	strtemp.Format(_T("_[%04d%02d%02d_%02d%02d%02d]"),time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond());
	str +=strtemp;

	str += _T(".rcp");
	m_RecieParm.SetRecipeFileNameBackUp(str);

	return TRUE;
}

BOOL CGlassRecipe::Save_Image(CString strPath,IplImage *IpImg)
{
	if(IpImg)
	{		
		USES_CONVERSION;
		char str_filename[200];
		sprintf_s(str_filename, "%s", W2A(strPath));

		cvSaveImage(str_filename,IpImg);
		return TRUE;
	}
	else
	{
		DeleteFile(strPath);
	}
	return FALSE;
}

BOOL CGlassRecipe::Load_Image(CString strPath,IplImage **pIpImg)
{
	if(*pIpImg)
		cvReleaseImage(pIpImg);

	USES_CONVERSION;
	char str_filename[200];
	sprintf_s(str_filename, "%s", W2A(strPath));

	(*pIpImg) = cvLoadImage(str_filename,CV_LOAD_IMAGE_GRAYSCALE);	

	if((*pIpImg))
		return TRUE;

	return FALSE;
}

BOOL CGlassRecipe::LoadUserDefectList()
{
	CString strRecipe;

	strRecipe.Format(_T("%s\\UserDefect\\%s_UserDefectArea.ini"), RECIPE_PATH, GetRecipeName());	

	CConfig profile;

	if(profile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode) == FALSE)
	{
		CFile File;
		if (!File.Open((TCHAR*)(LPCTSTR)strRecipe, CFile::modeCreate))
		{			
			return FALSE;
		}
		File.Close();
	}

	CString			str;
	for (int index = 0; index < MAX_DIMENSION_COUNT; index++)
	{		
		int list_count = 0;

		m_UserDefectPrm[index].clear();

		str.Format(_T("%d_cnt"),index);
		profile.GetItemValue((TCHAR*)(LPCTSTR)str, list_count);

		for (int count = 0; count < list_count; count++)
		{
			ST_USER_DEFECT_AREA user_defect_area;

			str.Format(_T("%d_pos_x_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.x);

			str.Format(_T("%d_pos_y_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.y);

			str.Format(_T("%d_area_width_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.area_width);

			str.Format(_T("%d_area_height_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.area_height);			

			str.Format(_T("%d_defect_width_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.defect_width);			

			str.Format(_T("%d_defect_height_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.defect_height);			

			str.Format(_T("%d_defect_threshold_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.defect_threshold);			

			str.Format(_T("%d_defect_dilation_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, user_defect_area.defect_dilation);			

			m_UserDefectPrm[index].push_back(user_defect_area);
		}
	}

	return TRUE;
}

BOOL CGlassRecipe::SaveUserDefectList()
{
	CString strRecipe;

	strRecipe.Format(_T("%s\\UserDefect\\%s_UserDefectArea.ini"), RECIPE_PATH, GetRecipeName());

	CConfig profile;

	if(profile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode) == FALSE)
	{
		CFile File;
		if (!File.Open((TCHAR*)(LPCTSTR)strRecipe, CFile::modeCreate))
		{			
			return FALSE;
		}
		File.Close();
	}

	CString					str;
	itUSER_DEFECT_AREA_LIST it;
	ST_USER_DEFECT_AREA	stUserDefect;
	for (int index = 0; index < MAX_DIMENSION_COUNT; index++)
	{		
		int list_count = 0;

		str.Format(_T("%d_cnt"),index);
		list_count = (int)m_UserDefectPrm[index].size();
		profile.SetItemValue((TCHAR*)(LPCTSTR)str, list_count);

		int		count = 0;
		for(it=m_UserDefectPrm[index].begin();it!=m_UserDefectPrm[index].end();it++,count++)
		{
			stUserDefect = *it;

			str.Format(_T("%d_pos_x_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.x);

			str.Format(_T("%d_pos_y_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.y);

			str.Format(_T("%d_area_width_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.area_width);

			str.Format(_T("%d_area_height_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.area_height);			

			str.Format(_T("%d_defect_width_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.defect_width);			

			str.Format(_T("%d_defect_height_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.defect_height);			

			str.Format(_T("%d_defect_threshold_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.defect_threshold);			

			str.Format(_T("%d_defect_dilation_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, stUserDefect.defect_dilation);	

		}
	}

	profile.WriteToFile();

	return TRUE;
}

BOOL CGlassRecipe::LoadExpAreaList()
{
	CString strRecipe;

	strRecipe.Format(_T("%s\\ExpArea\\%s_ExpArea.ins"), RECIPE_PATH, GetRecipeName());	

	CConfig profile;

	if(profile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode) == FALSE)
	{
		CFile File;
		if (!File.Open((TCHAR*)(LPCTSTR)strRecipe, CFile::modeCreate))
		{			
			return FALSE;
		}
		File.Close();
	}

	DeleteExpAreaList();

	CString			str;
	int				nValue;
	for (int index = 0; index < MAX_DIMENSION_COUNT; index++)
	{		
		int list_count = 0;

		str.Format(_T("%d_cnt"),index);
		profile.GetItemValue((TCHAR*)(LPCTSTR)str, list_count);

		for (int count = 0; count < list_count; count++)
		{
			EXECPTION_AREA	*pExp = new EXECPTION_AREA();

			str.Format(_T("%d_AppDefect_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, pExp->nAppDefect);

			str.Format(_T("%d_ErrSizeCX_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, nValue);
			pExp->szErrSize.cx = nValue;

			str.Format(_T("%d_ErrSizeCY_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, nValue);
			pExp->szErrSize.cy = nValue;

			str.Format(_T("%d_Area_Top_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, nValue);			
			pExp->rc.top = nValue;

			str.Format(_T("%d_Area_Bottom_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, nValue);					
			pExp->rc.bottom = nValue;

			str.Format(_T("%d_Area_Left_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, nValue);			
			pExp->rc.left = nValue;

			str.Format(_T("%d_Area_Right_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, nValue);			
			pExp->rc.right = nValue;

			str.Format(_T("%d_Area_Type_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, pExp->nAreaType);	

			str.Format(_T("%d_DetectLimitedArea_%d"),index,count);
			profile.GetItemValue((TCHAR*)(LPCTSTR)str, pExp->nDetectLimitedArea);

			m_ExpAreaPrm[index].push_back(pExp);
		}
	}

	return TRUE;
}

BOOL CGlassRecipe::SaveExpAreaList()
{
	CString strRecipe;

	strRecipe.Format(_T("%s\\ExpArea\\%s_ExpArea.ins"), RECIPE_PATH, GetRecipeName());	

	CConfig profile;

	if(profile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode) == FALSE)
	{
		CFile File;
		if (!File.Open((TCHAR*)(LPCTSTR)strRecipe, CFile::modeCreate))
		{			
			return FALSE;
		}
		File.Close();
	}

	CString			str;
	int				nValue;
	EXECPTION_AREA	*pExp;
	for (int index = 0; index < MAX_DIMENSION_COUNT; index++)
	{			
		int count = 0;

		str.Format(_T("%d_cnt"),index);
		profile.SetItemValue((TCHAR*)(LPCTSTR)str, (int)m_ExpAreaPrm[index].size());

		for (itEXCEPTION_AREA_LIST it=m_ExpAreaPrm[index].begin();it!=m_ExpAreaPrm[index].end();it++)
		{
			pExp = *it;

			str.Format(_T("%d_AppDefect_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, pExp->nAppDefect);

			str.Format(_T("%d_ErrSizeCX_%d"),index,count);
			nValue = pExp->szErrSize.cx;
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, nValue);			

			str.Format(_T("%d_ErrSizeCY_%d"),index,count);
			nValue = pExp->szErrSize.cy;
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, nValue);			

			str.Format(_T("%d_Area_Top_%d"),index,count);
			nValue = pExp->rc.top;
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, nValue);						

			str.Format(_T("%d_Area_Bottom_%d"),index,count);
			nValue = pExp->rc.bottom;
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, nValue);								

			str.Format(_T("%d_Area_Left_%d"),index,count);
			nValue = pExp->rc.left;
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, nValue);			

			str.Format(_T("%d_Area_Right_%d"),index,count);
			nValue = pExp->rc.right;
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, nValue);						

			str.Format(_T("%d_Area_Type_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, pExp->nAreaType);	

			str.Format(_T("%d_DetectLimitedArea_%d"),index,count);
			profile.SetItemValue((TCHAR*)(LPCTSTR)str, pExp->nDetectLimitedArea);		

			count++;
		}
	}

	profile.WriteToFile();

	return TRUE;
}