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

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

CRECIPE_INFO_PARM::~CRECIPE_INFO_PARM(void)
{

}

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

	m_strComment = _T("");
	m_dOneScanTime_sec = 100.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);
	pFile->GetItemValue(_T("COMMENT"), m_strComment);
	pFile->GetItemValue(_T("ONE_SCAN_TIME"), m_dOneScanTime_sec, 100);

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

	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());
}

//////////////////////////////////////////////////////////////////////////
// CRECIPE_INFO_COFG
void CRECIPE_INFO_COFG::Reset()
{
	m_bUse = FALSE;
}

BOOL CRECIPE_INFO_COFG::LoadRecipeConfigFile(CString strRecipe)
{
	if (strRecipe.IsEmpty())
		return FALSE;

	CString	strTaget;
	strTaget.Empty();
	strTaget = RECIPE_PATH;
	strTaget += "\\";
	strTaget += strRecipe;
	strTaget += ".cfg";

	CFileFind findFile;
	BOOL bFind = findFile.FindFile(strTaget);
	if (bFind == FALSE)
		return SaveRecipeConfigFile(strRecipe);

	CConfig Config;
	if (!Config.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strTaget, FileMap_Mode))
		return FALSE;

	Config.GetItemValue(_T("USE_TEST"), m_bUse, FALSE);

	return TRUE;
}

BOOL CRECIPE_INFO_COFG::SaveRecipeConfigFile(CString strRecipe)
{
	if (strRecipe.IsEmpty())
		return FALSE;

	CString	strTaget;
	strTaget.Empty();
	strTaget = RECIPE_PATH;
	strTaget += "\\";
	strTaget += strRecipe;
	strTaget += ".cfg";

	CFileFind findFile;
	BOOL bFind = findFile.FindFile(strTaget);
	if (bFind == FALSE)
	{
		CFile FileI;
		if (!FileI.Open(strTaget, CFile::modeCreate))
			return FALSE;
		FileI.Close();
	}

	CConfig Config;
	if (!Config.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strTaget, FileMap_Mode))
		return FALSE;

	Config.SetItemValue(_T("USE_TEST"), m_bUse);

	return Config.WriteToFile();
}

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

CLIGHT_PARM::~CLIGHT_PARM(void)
{

}

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;
}

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

CGlassRecipe::~CGlassRecipe(void)
{
}

void CGlassRecipe::Reset()
{
	m_RecieCofg.Reset();
	m_RecieParm.Reset();
	m_LightParm.Reset();

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
		m_SideParam[i].Reset();
}

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

	m_RecieParm.SetRecipeName(strRecipe);

	CString	str;
	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_LightParm.ReadRecipe(pFile);

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
		m_SideParam[i].ReadRecipe(pFile, i);

	return TRUE;
}

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

	m_RecieParm.WriteRecipe(pFile);
	m_LightParm.WriteRecipe(pFile);

	for(int i=0;i<MAX_DIMENSION_COUNT;i++)
		m_SideParam[i].WriteRecipe(pFile, i);

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

	return TRUE;
}

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

	CConfig recipeFile;

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

	return WriteRecipe(&recipeFile);	
}

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

	CConfig recipeFile;

	if (!recipeFile.SetRegiConfig(NULL, NULL, (TCHAR*)(LPCTSTR)strRecipe, FileMap_Mode))
	{		
		Reset();
		return FALSE;
	}

	return ReadRecipe(&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];
}

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

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

	CConfig recipeFile;

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

	return WriteRecipe(&recipeFile);	
}

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::LoadRecipeConfigFile(CString strRecipe)
{
	return TRUE;// m_RecieCofg.LoadRecipeConfigFile(strRecipe);
}

BOOL CGlassRecipe::SaveRecipeConfigFile(CString strRecipe)
{
	return TRUE;// m_RecieCofg.SaveRecipeConfigFile(strRecipe);
}

CSIDE_PARM::CSIDE_PARM()
{
	Reset();
}

CSIDE_PARM::~CSIDE_PARM(void)
{
}

void CSIDE_PARM::Reset()
{
	m_nSidePanelSize_um = 0;
	m_nFindStartEndLine_X_pxl = 0;
	m_nFindStartEndLine_Threshold = 0;

	m_nTopCornerShape = 0;
	m_bTopCornerFindDefect = FALSE;
	m_bTopCornerMeasureSize = FALSE;
	m_nTopCornerEdgeFilterSize = 0;
	m_nTopCornerEdgeThreshold = 0;
	m_nTopCornerSizeX_um = 0;
	m_nTopCornerSizeY_um = 0;
	m_nTopCornerIns_StartOffset = 0;
	m_nTopCornerIns_Range = 0;
	m_nTopCornerIns_Thres_Min = 0;
	m_nTopCornerIns_Thres_Max = 0;
	m_nTopCornerIns_Min_Size = 0;
	m_nTopCornerIns_Defect_Size_Dilation = 0;
	m_nTopCorner_Measure_Judge_Std_um_X = 0;
	m_nTopCorner_Measure_Judge_Min_um_X = 0;
	m_nTopCorner_Measure_Judge_Max_um_X = 0;
	m_nTopCorner_Measure_Judge_Std_um_Y = 0;
	m_nTopCorner_Measure_Judge_Min_um_Y = 0;
	m_nTopCorner_Measure_Judge_Max_um_Y = 0;
	m_nTopCorner_Measure_Judge_OR_AND = 0;
	m_nTopCorner_Judge_Size_Min_X_um = 0;
	m_nTopCorner_Judge_Size_Min_Y_um = 0;
	m_nTopCorner_Judge_Size_Min_OR_AND = 0;
	ZeroMemory(m_bTopCornerDimension_Use, sizeof(m_bTopCornerDimension_Use));
	ZeroMemory(m_dTopCornerDimensionSpec_mm_Std, sizeof(m_dTopCornerDimensionSpec_mm_Std));
	ZeroMemory(m_dTopCornerDimensionSpec_mm_Min, sizeof(m_dTopCornerDimensionSpec_mm_Min));
	ZeroMemory(m_dTopCornerDimensionSpec_mm_Max, sizeof(m_dTopCornerDimensionSpec_mm_Max));
	ZeroMemory(m_bTopCornerChamfer_Use, sizeof(m_bTopCornerChamfer_Use));
	ZeroMemory(m_dTopCornerChamfer_Spec_mm_Std, sizeof(m_dTopCornerChamfer_Spec_mm_Std));
	ZeroMemory(m_dTopCornerChamfer_Spec_mm_Min, sizeof(m_dTopCornerChamfer_Spec_mm_Min));
	ZeroMemory(m_dTopCornerChamfer_Spec_mm_Max, sizeof(m_dTopCornerChamfer_Spec_mm_Max));

	m_nBottomCornerShape = 0;
	m_bBottomCornerFindDefect = FALSE;
	m_bBottomCornerMeasureSize = FALSE;
	m_nBottomCornerEdgeFilterSize = 0;
	m_nBottomCornerEdgeThreshold = 0;
	m_nBottomCornerSizeX_um = 0;
	m_nBottomCornerSizeY_um = 0;
	m_nBottomCornerIns_StartOffset = 0;
	m_nBottomCornerIns_Range = 0;
	m_nBottomCornerIns_Thres_Min = 0;
	m_nBottomCornerIns_Thres_Max = 0;
	m_nBottomCornerIns_Min_Size = 0;
	m_nBottomCornerIns_Defect_Size_Dilation = 0;
	m_nBottomCorner_Measure_Judge_Std_um_X = 0;
	m_nBottomCorner_Measure_Judge_Min_um_X = 0;
	m_nBottomCorner_Measure_Judge_Max_um_X = 0;
	m_nBottomCorner_Measure_Judge_Std_um_Y = 0;
	m_nBottomCorner_Measure_Judge_Min_um_Y = 0;
	m_nBottomCorner_Measure_Judge_Max_um_Y = 0;
	m_nBottomCorner_Measure_Judge_OR_AND = 0;
	m_nBottomCorner_Judge_Size_Min_X_um = 0;
	m_nBottomCorner_Judge_Size_Min_Y_um = 0;
	m_nBottomCorner_Judge_Size_Min_OR_AND = 0;
	ZeroMemory(m_bBottomCornerDimension_Use, sizeof(m_bBottomCornerDimension_Use));
	ZeroMemory(m_dBottomCornerDimensionSpec_mm_Std, sizeof(m_dBottomCornerDimensionSpec_mm_Std));
	ZeroMemory(m_dBottomCornerDimensionSpec_mm_Min, sizeof(m_dBottomCornerDimensionSpec_mm_Min));
	ZeroMemory(m_dBottomCornerDimensionSpec_mm_Max, sizeof(m_dBottomCornerDimensionSpec_mm_Max));
	ZeroMemory(m_bBottomCornerChamfer_Use, sizeof(m_bBottomCornerChamfer_Use));
	ZeroMemory(m_dBottomCornerChamfer_Spec_mm_Std, sizeof(m_dBottomCornerChamfer_Spec_mm_Std));
	ZeroMemory(m_dBottomCornerChamfer_Spec_mm_Min, sizeof(m_dBottomCornerChamfer_Spec_mm_Min));
	ZeroMemory(m_dBottomCornerChamfer_Spec_mm_Max, sizeof(m_dBottomCornerChamfer_Spec_mm_Max));
	
	m_bTopMark_Use = 0;
	m_nTopMarkToEdgeY_um = 0;
	m_nTopMarkToEdgeX_um = 0;
	m_dTopMarkTemplateMatchingRate = 80.0;
	m_nTopMarkType = 2;

	m_bBottomMark_Use = 0;
	m_nBottomMarkToEdgeY_um = 0;
	m_nBottomMarkToEdgeX_um = 0;
	m_dBottomMarkTemplateMatchingRate = 80.0;
	m_nBottomMarkType = 2;

	m_nSideLineThreshold = 0;
	m_nSideDimensionCount = 0;
	ZeroMemory(m_nSideDimensionPos_TopMarkToDistance_um, sizeof(m_nSideDimensionPos_TopMarkToDistance_um));
	ZeroMemory(m_bSideDimension_Use, sizeof(m_bSideDimension_Use));
	ZeroMemory(m_nSideDimensionSpec_Thres, sizeof(m_nSideDimensionSpec_Thres));
	ZeroMemory(m_dSideDimensionSpec_mm_Std, sizeof(m_dSideDimensionSpec_mm_Std));
	ZeroMemory(m_dSideDimensionSpec_mm_Min, sizeof(m_dSideDimensionSpec_mm_Min));
	ZeroMemory(m_dSideDimensionSpec_mm_Max, sizeof(m_dSideDimensionSpec_mm_Max));
	ZeroMemory(m_dSideDimensionSpec_mm_Off, sizeof(m_dSideDimensionSpec_mm_Off));
	ZeroMemory(m_bSideChamfer_Use, sizeof(m_bSideChamfer_Use));
	ZeroMemory(m_dSideChamfer_Spec_mm_Std, sizeof(m_dSideChamfer_Spec_mm_Std));
	ZeroMemory(m_dSideChamfer_Spec_mm_Min, sizeof(m_dSideChamfer_Spec_mm_Min));
	ZeroMemory(m_dSideChamfer_Spec_mm_Max, sizeof(m_dSideChamfer_Spec_mm_Max));

	m_nCenterJudgeArea_StartLine_To_Start_pxl = 0;
	m_nCenterJudgeArea_StartLine_To_End_pxl = 0;

	m_strPosDirection = "C1-C2-L";

	for(int i=0; i<MAX_SIDE_INSPECT_TYPE; i++)
		m_InspectPrm[i].Reset();

	m_nNotchCount = 0;
	for(int i=0; i<MAX_SIDE_NOTCH_COUNT; i++)
		m_NotchPrm[i].Reset();

	m_nExptionCount = 0;
	for(int i=0; i<MAX_SIDE_EXCEPTION_AREA_COUNT; i++)
		m_ExpAreaPrm[i].Reset();

	m_nUserDefectAreaCount = 0;
	for(int i=0; i<MAX_SIDE_USER_DEFECT_AREA_COUNT; i++)
		m_UserDefectPrm[i].Reset();
}

BOOL CSIDE_PARM::ReadRecipe(CConfig *pFile, int nSideIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	pFile->GetItemValue(nSideIdx, _T("nSidePanelSize_um"), m_nSidePanelSize_um);
	pFile->GetItemValue(nSideIdx, _T("nFindStartEndLine_X_pxl"), m_nFindStartEndLine_X_pxl);
	pFile->GetItemValue(nSideIdx, _T("nFindStartEndLine_Threshold"), m_nFindStartEndLine_Threshold);

	pFile->GetItemValue(nSideIdx, _T("nTopCornerShape"), m_nTopCornerShape);
	pFile->GetItemValue(nSideIdx, _T("bTopCornerFindDefect"), m_bTopCornerFindDefect);
	pFile->GetItemValue(nSideIdx, _T("bTopCornerMeasureSize"), m_bTopCornerMeasureSize);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerEdgeFilterSize"), m_nTopCornerEdgeFilterSize);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerEdgeThreshold"), m_nTopCornerEdgeThreshold);

	pFile->GetItemValue(nSideIdx, _T("nTopCornerSizeX_um"), m_nTopCornerSizeX_um);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerSizeY_um"), m_nTopCornerSizeY_um);

	pFile->GetItemValue(nSideIdx, _T("nTopCornerIns_StartOffset"), m_nTopCornerIns_StartOffset);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerIns_Range"), m_nTopCornerIns_Range);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerIns_Thres_Min"), m_nTopCornerIns_Thres_Min);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerIns_Thres_Max"), m_nTopCornerIns_Thres_Max);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerIns_Min_Size"), m_nTopCornerIns_Min_Size);
	pFile->GetItemValue(nSideIdx, _T("nTopCornerIns_Defect_Size_Dilation"), m_nTopCornerIns_Defect_Size_Dilation);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Std_um_X"), m_nTopCorner_Measure_Judge_Std_um_X);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Min_um_X"), m_nTopCorner_Measure_Judge_Min_um_X);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Max_um_X"), m_nTopCorner_Measure_Judge_Max_um_X);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Std_um_Y"), m_nTopCorner_Measure_Judge_Std_um_Y);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Min_um_Y"), m_nTopCorner_Measure_Judge_Min_um_Y);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Max_um_Y"), m_nTopCorner_Measure_Judge_Max_um_Y);	
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_OR_AND"), m_nTopCorner_Measure_Judge_OR_AND);	
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Judge_Size_Min_X_um"), m_nTopCorner_Judge_Size_Min_X_um);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Judge_Size_Min_Y_um"), m_nTopCorner_Judge_Size_Min_Y_um);
	pFile->GetItemValue(nSideIdx, _T("nTopCorner_Judge_Size_Min_OR_AND"), m_nTopCorner_Judge_Size_Min_OR_AND);

	pFile->GetItemValue(nSideIdx, _T("nBottomCornerShape"), m_nBottomCornerShape);
	pFile->GetItemValue(nSideIdx, _T("bBottomCornerFindDefect"), m_bBottomCornerFindDefect);
	pFile->GetItemValue(nSideIdx, _T("bBottomCornerMeasureSize"), m_bBottomCornerMeasureSize);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerEdgeFilterSize"), m_nBottomCornerEdgeFilterSize);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerEdgeThreshold"), m_nBottomCornerEdgeThreshold);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerSizeX_um"), m_nBottomCornerSizeX_um);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerSizeY_um"), m_nBottomCornerSizeY_um);

	pFile->GetItemValue(nSideIdx, _T("nBottomCornerIns_StartOffset"), m_nBottomCornerIns_StartOffset);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerIns_Range"), m_nBottomCornerIns_Range);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerIns_Thres_Min"), m_nBottomCornerIns_Thres_Min);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerIns_Thres_Max"), m_nBottomCornerIns_Thres_Max);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerIns_Min_Size"), m_nBottomCornerIns_Min_Size);
	pFile->GetItemValue(nSideIdx, _T("nBottomCornerIns_Defect_Size_Dilation"), m_nBottomCornerIns_Defect_Size_Dilation);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Std_um_X"), m_nBottomCorner_Measure_Judge_Std_um_X);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Min_um_X"), m_nBottomCorner_Measure_Judge_Min_um_X);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Max_um_X"), m_nBottomCorner_Measure_Judge_Max_um_X);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Std_um_Y"), m_nBottomCorner_Measure_Judge_Std_um_Y);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Min_um_Y"), m_nBottomCorner_Measure_Judge_Min_um_Y);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Max_um_Y"), m_nBottomCorner_Measure_Judge_Max_um_Y);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_OR_AND"), m_nBottomCorner_Measure_Judge_OR_AND);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Judge_Size_Min_X_um"), m_nBottomCorner_Judge_Size_Min_X_um);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Judge_Size_Min_Y_um"), m_nBottomCorner_Judge_Size_Min_Y_um);
	pFile->GetItemValue(nSideIdx, _T("nBottomCorner_Judge_Size_Min_OR_AND"), m_nBottomCorner_Judge_Size_Min_OR_AND);

	for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
	{
		CString strTemp;

		strTemp.Format(_T("dTopCornerDimension_%d_Use"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_bTopCornerDimension_Use[i]);
		strTemp.Format(_T("dTopCornerDimension_%d_Spec_mm_Std"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dTopCornerDimensionSpec_mm_Std[i]);
		strTemp.Format(_T("dTopCornerDimension_%d_Spec_mm_Min"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dTopCornerDimensionSpec_mm_Min[i]);
		strTemp.Format(_T("dTopCornerDimension_%d_Spec_mm_Max"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dTopCornerDimensionSpec_mm_Max[i]);
		strTemp.Format(_T("bTopCornerChamfer_%d_Use"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_bTopCornerChamfer_Use[i]);
		strTemp.Format(_T("dTopCornerChamfer_%d_Spec_mm_Std"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dTopCornerChamfer_Spec_mm_Std[i]);
		strTemp.Format(_T("dTopCornerChamfer_%d_Spec_mm_Min"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dTopCornerChamfer_Spec_mm_Min[i]);
		strTemp.Format(_T("dTopCornerChamfer_%d_Spec_mm_Max"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dTopCornerChamfer_Spec_mm_Max[i]);

		strTemp.Format(_T("dBottomCornerDimension_%d_Use"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_bBottomCornerDimension_Use[i]);
		strTemp.Format(_T("dBottomCornerDimension_%d_Spec_mm_Std"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dBottomCornerDimensionSpec_mm_Std[i]);
		strTemp.Format(_T("dBottomCornerDimension_%d_Spec_mm_Min"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dBottomCornerDimensionSpec_mm_Min[i]);
		strTemp.Format(_T("dBottomCornerDimension_%d_Spec_mm_Max"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dBottomCornerDimensionSpec_mm_Max[i]);
		strTemp.Format(_T("bBottomCornerChamfer_%d_Use"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_bBottomCornerChamfer_Use[i]);
		strTemp.Format(_T("dBottomCornerChamfer_%d_Spec_mm_Min"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dBottomCornerChamfer_Spec_mm_Min[i]);
		strTemp.Format(_T("dBottomCornerChamfer_%d_Spec_mm_Max"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dBottomCornerChamfer_Spec_mm_Max[i]);
	}

	pFile->GetItemValue(nSideIdx, _T("bTopMark_Use"), m_bTopMark_Use);
	pFile->GetItemValue(nSideIdx, _T("nTopMarkToEdgeY_um"), m_nTopMarkToEdgeY_um);
	pFile->GetItemValue(nSideIdx, _T("nTopMarkToEdgeX_um"), m_nTopMarkToEdgeX_um);
	pFile->GetItemValue(nSideIdx, _T("dTopMarkTemplateMatchingRate"), m_dTopMarkTemplateMatchingRate);
	pFile->GetItemValue(nSideIdx, _T("nTopMarkType"), m_nTopMarkType);

	pFile->GetItemValue(nSideIdx, _T("bBottomMark_Use"), m_bBottomMark_Use);
	pFile->GetItemValue(nSideIdx, _T("nBottomMarkToEdgeY_um"), m_nBottomMarkToEdgeY_um);
	pFile->GetItemValue(nSideIdx, _T("nBottomMarkToEdgeX_um"), m_nBottomMarkToEdgeX_um);
	pFile->GetItemValue(nSideIdx, _T("dBottomMarkTemplateMatchingRate"), m_dBottomMarkTemplateMatchingRate);
	pFile->GetItemValue(nSideIdx, _T("nBottomMarkType"), m_nBottomMarkType);

	pFile->GetItemValue(nSideIdx, _T("nSideLineThreshold"), m_nSideLineThreshold);
	pFile->GetItemValue(nSideIdx, _T("nChamferLineThreshold"), m_nChamferLineThreshold);

	pFile->GetItemValue(nSideIdx, _T("nSideDimensionCount"), m_nSideDimensionCount);
	for(int i=0; i<MAX_SIDE_DIMENSION_MEASURE_COUNT; i++)
	{
		CString strTemp;
		strTemp.Format(_T("nSideDimensionPos_%d_TopMarkToDistance_um"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_nSideDimensionPos_TopMarkToDistance_um[i]);
		strTemp.Format(_T("dSideDimension_%d_Use"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_bSideDimension_Use[i]);

		strTemp.Format(_T("dSideDimensionPos_%d_Spec_Thres"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_nSideDimensionSpec_Thres[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Std"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Std[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Min"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Min[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Max"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Max[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Off"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Off[i]);

		strTemp.Format(_T("bSideChamfer_%d_Use"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_bSideChamfer_Use[i]);
		strTemp.Format(_T("dSideChamfer_%d_Spec_mm_Std"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideChamfer_Spec_mm_Std[i]);
		strTemp.Format(_T("dSideChamfer_%d_Spec_mm_Min"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideChamfer_Spec_mm_Min[i]);
		strTemp.Format(_T("dSideChamfer_%d_Spec_mm_Max"), i);
		pFile->GetItemValue(nSideIdx, strTemp, m_dSideChamfer_Spec_mm_Max[i]);
	}

	pFile->GetItemValue(nSideIdx, _T("nCenterJudgeArea_StartLine_To_Start_pxl"), m_nCenterJudgeArea_StartLine_To_Start_pxl);
	pFile->GetItemValue(nSideIdx, _T("nCenterJudgeArea_StartLine_To_End_pxl"), m_nCenterJudgeArea_StartLine_To_End_pxl);

	pFile->GetItemValue(nSideIdx, _T("strPose_Direction"), m_strPosDirection);

	for(int nInsType=0; nInsType<MAX_SIDE_INSPECT_TYPE; nInsType++)
		m_InspectPrm[nInsType].ReadRecipe(pFile, nSideIdx, (eSideInsType) nInsType);

	pFile->GetItemValue(nSideIdx, _T("nNotchCount"), m_nNotchCount, 0);

	for(int nNotchIdx=0; nNotchIdx<m_nNotchCount; nNotchIdx++)
		m_NotchPrm[nNotchIdx].ReadRecipe(pFile, nSideIdx, nNotchIdx);

	pFile->GetItemValue(nSideIdx, _T("nExptionCount"), m_nExptionCount);

	for(int nExceptionIdx=0; nExceptionIdx<m_nExptionCount; nExceptionIdx++)
		m_ExpAreaPrm[nExceptionIdx].ReadRecipe(pFile, nSideIdx, nExceptionIdx);

	pFile->GetItemValue(nSideIdx, _T("nUserDefectAreaCount"), m_nUserDefectAreaCount);

	for(int nUserDefectAreaIdx=0; nUserDefectAreaIdx<m_nUserDefectAreaCount; nUserDefectAreaIdx++)
		m_UserDefectPrm[nUserDefectAreaIdx].ReadRecipe(pFile, nSideIdx, nUserDefectAreaIdx);

	return TRUE;
}

BOOL CSIDE_PARM::WriteRecipe(CConfig *pFile, int nSideIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	pFile->SetItemValue(nSideIdx, _T("nSidePanelSize_um"), m_nSidePanelSize_um);
	pFile->SetItemValue(nSideIdx, _T("nFindStartEndLine_X_pxl"), m_nFindStartEndLine_X_pxl);
	pFile->SetItemValue(nSideIdx, _T("nFindStartEndLine_Threshold"), m_nFindStartEndLine_Threshold);

	pFile->SetItemValue(nSideIdx, _T("nTopCornerShape"), m_nTopCornerShape);
	pFile->SetItemValue(nSideIdx, _T("bTopCornerFindDefect"), m_bTopCornerFindDefect);
	pFile->SetItemValue(nSideIdx, _T("bTopCornerMeasureSize"), m_bTopCornerMeasureSize);	
	pFile->SetItemValue(nSideIdx, _T("nTopCornerEdgeFilterSize"), m_nTopCornerEdgeFilterSize);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerEdgeThreshold"), m_nTopCornerEdgeThreshold);	
	pFile->SetItemValue(nSideIdx, _T("nTopCornerSizeX_um"), m_nTopCornerSizeX_um);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerSizeY_um"), m_nTopCornerSizeY_um);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerIns_StartOffset"), m_nTopCornerIns_StartOffset);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerIns_Range"), m_nTopCornerIns_Range);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerIns_Thres_Min"), m_nTopCornerIns_Thres_Min);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerIns_Thres_Max"), m_nTopCornerIns_Thres_Max);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerIns_Min_Size"), m_nTopCornerIns_Min_Size);
	pFile->SetItemValue(nSideIdx, _T("nTopCornerIns_Defect_Size_Dilation"), m_nTopCornerIns_Defect_Size_Dilation);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Std_um_X"), m_nTopCorner_Measure_Judge_Std_um_X);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Min_um_X"), m_nTopCorner_Measure_Judge_Min_um_X);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Max_um_X"), m_nTopCorner_Measure_Judge_Max_um_X);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Std_um_Y"), m_nTopCorner_Measure_Judge_Std_um_Y);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Min_um_Y"), m_nTopCorner_Measure_Judge_Min_um_Y);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_Max_um_Y"), m_nTopCorner_Measure_Judge_Max_um_Y);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Measure_Judge_OR_AND"), m_nTopCorner_Measure_Judge_OR_AND);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Judge_Size_Min_X_um"), m_nTopCorner_Judge_Size_Min_X_um);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Judge_Size_Min_Y_um"), m_nTopCorner_Judge_Size_Min_Y_um);
	pFile->SetItemValue(nSideIdx, _T("nTopCorner_Judge_Size_Min_OR_AND"), m_nTopCorner_Judge_Size_Min_OR_AND);

	pFile->SetItemValue(nSideIdx, _T("nBottomCornerShape"), m_nBottomCornerShape);
	pFile->SetItemValue(nSideIdx, _T("bBottomCornerFindDefect"), m_bBottomCornerFindDefect);
	pFile->SetItemValue(nSideIdx, _T("bBottomCornerMeasureSize"), m_bBottomCornerMeasureSize);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerEdgeFilterSize"), m_nBottomCornerEdgeFilterSize);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerEdgeThreshold"), m_nBottomCornerEdgeThreshold);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerSizeX_um"), m_nBottomCornerSizeX_um);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerSizeY_um"), m_nBottomCornerSizeY_um);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerIns_StartOffset"), m_nBottomCornerIns_StartOffset);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerIns_Range"), m_nBottomCornerIns_Range);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerIns_Thres_Min"), m_nBottomCornerIns_Thres_Min);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerIns_Thres_Max"), m_nBottomCornerIns_Thres_Max);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerIns_Min_Size"), m_nBottomCornerIns_Min_Size);
	pFile->SetItemValue(nSideIdx, _T("nBottomCornerIns_Defect_Size_Dilation"), m_nBottomCornerIns_Defect_Size_Dilation);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Std_um_X"), m_nBottomCorner_Measure_Judge_Std_um_X);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Min_um_X"), m_nBottomCorner_Measure_Judge_Min_um_X);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Max_um_X"), m_nBottomCorner_Measure_Judge_Max_um_X);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Std_um_Y"), m_nBottomCorner_Measure_Judge_Std_um_Y);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Min_um_Y"), m_nBottomCorner_Measure_Judge_Min_um_Y);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_Max_um_Y"), m_nBottomCorner_Measure_Judge_Max_um_Y);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Measure_Judge_OR_AND"), m_nBottomCorner_Measure_Judge_OR_AND);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Judge_Size_Min_X_um"), m_nBottomCorner_Judge_Size_Min_X_um);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Judge_Size_Min_Y_um"), m_nBottomCorner_Judge_Size_Min_Y_um);
	pFile->SetItemValue(nSideIdx, _T("nBottomCorner_Judge_Size_Min_OR_AND"), m_nBottomCorner_Judge_Size_Min_OR_AND);

	for(int i=0; i<MAX_CORNER_DIMENSION_MEASURE_COUNT; i++)
	{
		CString strTemp;

		strTemp.Format(_T("dTopCornerDimension_%d_Use"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_bTopCornerDimension_Use[i]);
		strTemp.Format(_T("dTopCornerDimension_%d_Spec_mm_Std"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dTopCornerDimensionSpec_mm_Std[i]);
		strTemp.Format(_T("dTopCornerDimension_%d_Spec_mm_Min"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dTopCornerDimensionSpec_mm_Min[i]);
		strTemp.Format(_T("dTopCornerDimension_%d_Spec_mm_Max"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dTopCornerDimensionSpec_mm_Max[i]);
		strTemp.Format(_T("bTopCornerChamfer_%d_Use"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_bTopCornerChamfer_Use[i]);
		strTemp.Format(_T("dTopCornerChamfer_%d_Spec_mm_Std"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dTopCornerChamfer_Spec_mm_Std[i]);
		strTemp.Format(_T("dTopCornerChamfer_%d_Spec_mm_Min"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dTopCornerChamfer_Spec_mm_Min[i]);
		strTemp.Format(_T("dTopCornerChamfer_%d_Spec_mm_Max"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dTopCornerChamfer_Spec_mm_Max[i]);

		strTemp.Format(_T("dBottomCornerDimension_%d_Use"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_bBottomCornerDimension_Use[i]);
		strTemp.Format(_T("dBottomCornerDimension_%d_Spec_mm_Std"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dBottomCornerDimensionSpec_mm_Std[i]);
		strTemp.Format(_T("dBottomCornerDimension_%d_Spec_mm_Min"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dBottomCornerDimensionSpec_mm_Min[i]);
		strTemp.Format(_T("dBottomCornerDimension_%d_Spec_mm_Max"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dBottomCornerDimensionSpec_mm_Max[i]);
		strTemp.Format(_T("bBottomCornerChamfer_%d_Use"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_bBottomCornerChamfer_Use[i]);
		strTemp.Format(_T("dBottomCornerChamfer_%d_Spec_mm_Std"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dBottomCornerChamfer_Spec_mm_Std[i]);
		strTemp.Format(_T("dBottomCornerChamfer_%d_Spec_mm_Min"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dBottomCornerChamfer_Spec_mm_Min[i]);
		strTemp.Format(_T("dBottomCornerChamfer_%d_Spec_mm_Max"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dBottomCornerChamfer_Spec_mm_Max[i]);
	}

	pFile->SetItemValue(nSideIdx, _T("bTopMark_Use"), m_bTopMark_Use);
	pFile->SetItemValue(nSideIdx, _T("nTopMarkToEdgeY_um"), m_nTopMarkToEdgeY_um);
	pFile->SetItemValue(nSideIdx, _T("nTopMarkToEdgeX_um"), m_nTopMarkToEdgeX_um);
	pFile->SetItemValue(nSideIdx, _T("dTopMarkTemplateMatchingRate"), m_dTopMarkTemplateMatchingRate);
	pFile->SetItemValue(nSideIdx, _T("nTopMarkType"), m_nTopMarkType);

	pFile->SetItemValue(nSideIdx, _T("bBottomMark_Use"), m_bBottomMark_Use);
	pFile->SetItemValue(nSideIdx, _T("nBottomMarkToEdgeY_um"), m_nBottomMarkToEdgeY_um);
	pFile->SetItemValue(nSideIdx, _T("nBottomMarkToEdgeX_um"), m_nBottomMarkToEdgeX_um);
	pFile->SetItemValue(nSideIdx, _T("dBottomMarkTemplateMatchingRate"), m_dBottomMarkTemplateMatchingRate);
	pFile->SetItemValue(nSideIdx, _T("nBottomMarkType"), m_nBottomMarkType);

	pFile->SetItemValue(nSideIdx, _T("nSideLineThreshold"), m_nSideLineThreshold);
	pFile->SetItemValue(nSideIdx, _T("nChamferLineThreshold"), m_nChamferLineThreshold);

	pFile->SetItemValue(nSideIdx, _T("nSideDimensionCount"), m_nSideDimensionCount);
	for(int i=0; i<MAX_SIDE_DIMENSION_MEASURE_COUNT; i++)
	{
		CString strTemp;
		strTemp.Format(_T("nSideDimensionPos_%d_TopMarkToDistance_um"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_nSideDimensionPos_TopMarkToDistance_um[i]);
		strTemp.Format(_T("dSideDimension_%d_Use"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_bSideDimension_Use[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_Thres"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_nSideDimensionSpec_Thres[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Std"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Std[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Min"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Min[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Max"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Max[i]);
		strTemp.Format(_T("dSideDimensionPos_%d_Spec_mm_Off"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideDimensionSpec_mm_Off[i]);

		strTemp.Format(_T("bSideChamfer_%d_Use"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_bSideChamfer_Use[i]);
		strTemp.Format(_T("dSideChamfer_%d_Spec_mm_Std"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideChamfer_Spec_mm_Std[i]);
		strTemp.Format(_T("dSideChamfer_%d_Spec_mm_Min"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideChamfer_Spec_mm_Min[i]);
		strTemp.Format(_T("dSideChamfer_%d_Spec_mm_Max"), i);
		pFile->SetItemValue(nSideIdx, strTemp, m_dSideChamfer_Spec_mm_Max[i]);
	}

	pFile->SetItemValue(nSideIdx, _T("nCenterJudgeArea_StartLine_To_Start_pxl"), m_nCenterJudgeArea_StartLine_To_Start_pxl);
	pFile->SetItemValue(nSideIdx, _T("nCenterJudgeArea_StartLine_To_End_pxl"), m_nCenterJudgeArea_StartLine_To_End_pxl);

	pFile->SetItemValue(nSideIdx, _T("strPose_Direction"), m_strPosDirection);

	for(int nInsType=0; nInsType<MAX_SIDE_INSPECT_TYPE; nInsType++)
		m_InspectPrm[nInsType].WriteRecipe(pFile, nSideIdx, (eSideInsType) nInsType);

	pFile->SetItemValue(nSideIdx, _T("nNotchCount"), m_nNotchCount);

	for(int nNotchIdx=0; nNotchIdx<m_nNotchCount; nNotchIdx++)
		m_NotchPrm[nNotchIdx].WriteRecipe(pFile, nSideIdx, nNotchIdx);

	pFile->SetItemValue(nSideIdx, _T("nExptionCount"), m_nExptionCount);

	for(int nExceptionIdx=0; nExceptionIdx<m_nExptionCount; nExceptionIdx++)
		m_ExpAreaPrm[nExceptionIdx].WriteRecipe(pFile, nSideIdx, nExceptionIdx);

	pFile->SetItemValue(nSideIdx, _T("nUserDefectAreaCount"), m_nUserDefectAreaCount);

	for(int nUserDefectAreaIdx=0; nUserDefectAreaIdx<m_nUserDefectAreaCount; nUserDefectAreaIdx++)
		m_UserDefectPrm[nUserDefectAreaIdx].WriteRecipe(pFile, nSideIdx, nUserDefectAreaIdx);

	return TRUE;
}

void CSIDE_INSPECTT_PARM::Reset()
{
	m_bUseInspect = FALSE;
	m_nInspect_Method = 0;			// 0 : Gray, 1 : Pitch, 2 : Gray + Pitch
	m_nInspect_Range_um = 150;
	m_nInspect_SideLine_Offset_um = 50;
	m_nMin_Threshold = 30;
	m_nMax_Threshold = 255;
	m_nDiff_Threshold = 15;
	m_nDiff_Pitch = 10;
	m_bSide_Filter = TRUE;
	m_nSide_Filter_um = 5;
	m_nMinSize_Filter_pxl = 1;
	m_nMinSize_Filter_X_um = 1;
	m_nMinSize_Filter_Y_um = 1;
	m_nDefect_Size_Dilation = 0;	// - : Erosion, + : Dilation

	for(int i=0; i<3; i++)
	{
		m_nJudge_Size_Min_X_um[i] = 0;
		m_nJudge_Size_Min_Y_um[i] = 0;
		m_nJudge_Size_Min_OR_AND[i] = 0;	// 0 : No Use, 1 : OR, 2 : AND
	}
}

BOOL CSIDE_INSPECTT_PARM::ReadRecipe(CConfig *pFile, int nSideIdx, eSideInsType eInsType)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	if(eInsType < 0 || eSideInsType_Total <= eInsType)
		return FALSE;

	Reset();

	CString strTemp;

	strTemp.Format(_T("%s_bUseInspect"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_bUseInspect, m_bUseInspect);

	strTemp.Format(_T("%s_nInspect_Method"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nInspect_Method, m_nInspect_Method);

	strTemp.Format(_T("%s_nInspect_Range_um"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nInspect_Range_um, m_nInspect_Range_um);

	strTemp.Format(_T("%s_nInspect_SideLine_Offset_um"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nInspect_SideLine_Offset_um, m_nInspect_SideLine_Offset_um);

	strTemp.Format(_T("%s_nMin_Threshold"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nMin_Threshold, m_nMin_Threshold);

	strTemp.Format(_T("%s_nMax_Threshold"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nMax_Threshold, m_nMax_Threshold);

	strTemp.Format(_T("%s_nDiff_Threshold"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nDiff_Threshold, m_nDiff_Threshold);

	strTemp.Format(_T("%s_nDiff_Pitch"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nDiff_Pitch, m_nDiff_Pitch);

	strTemp.Format(_T("%s_bSide_Filter"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_bSide_Filter, m_bSide_Filter);

	strTemp.Format(_T("%s_nSide_Filter_um"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nSide_Filter_um, m_nSide_Filter_um);

	strTemp.Format(_T("%s_nMinSize_Filter_pxl"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nMinSize_Filter_pxl, m_nMinSize_Filter_pxl);

	strTemp.Format(_T("%s_nMinSize_Filter_X_um"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nMinSize_Filter_X_um, m_nMinSize_Filter_X_um);

	strTemp.Format(_T("%s_nMinSize_Filter_Y_um"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nMinSize_Filter_Y_um, m_nMinSize_Filter_Y_um);

	strTemp.Format(_T("%s_nDefect_Size_Dilation"), g_strInsType[(int) eInsType]);
	pFile->GetItemValue(nSideIdx, strTemp, m_nDefect_Size_Dilation, m_nDefect_Size_Dilation);

	for(int i=0; i<3; i++)
	{
		strTemp.Format(_T("%s_nJudge_Size_Min_X_um_%d"), g_strInsType[(int) eInsType], i);
		pFile->GetItemValue(nSideIdx, strTemp, m_nJudge_Size_Min_X_um[i], m_nJudge_Size_Min_X_um[i]);

		strTemp.Format(_T("%s_nJudge_Size_Min_Y_um_%d"), g_strInsType[(int) eInsType], i);
		pFile->GetItemValue(nSideIdx, strTemp, m_nJudge_Size_Min_Y_um[i], m_nJudge_Size_Min_Y_um[i]);

		strTemp.Format(_T("%s_nJudge_Size_Min_OR_AND_%d"), g_strInsType[(int) eInsType], i);
		pFile->GetItemValue(nSideIdx, strTemp, m_nJudge_Size_Min_OR_AND[i], m_nJudge_Size_Min_OR_AND[i]);
	}

	return TRUE;
}

BOOL CSIDE_INSPECTT_PARM::WriteRecipe(CConfig *pFile, int nSideIdx, eSideInsType eInsType)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	if(eInsType < 0 || eSideInsType_Total <= eInsType)
		return FALSE;

	CString strTemp;

	strTemp.Format(_T("%s_bUseInspect"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_bUseInspect);

	strTemp.Format(_T("%s_nInspect_Method"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nInspect_Method);

	strTemp.Format(_T("%s_nInspect_Range_um"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nInspect_Range_um);
	
	strTemp.Format(_T("%s_nInspect_SideLine_Offset_um"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nInspect_SideLine_Offset_um);

	strTemp.Format(_T("%s_nMin_Threshold"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nMin_Threshold);

	strTemp.Format(_T("%s_nMax_Threshold"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nMax_Threshold);

	strTemp.Format(_T("%s_nDiff_Threshold"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nDiff_Threshold);

	strTemp.Format(_T("%s_nDiff_Pitch"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nDiff_Pitch);

	strTemp.Format(_T("%s_bSide_Filter"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_bSide_Filter);

	strTemp.Format(_T("%s_nSide_Filter_um"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nSide_Filter_um);

	strTemp.Format(_T("%s_nMinSize_Filter_pxl"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nMinSize_Filter_pxl);

	strTemp.Format(_T("%s_nMinSize_Filter_X_um"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nMinSize_Filter_X_um);

	strTemp.Format(_T("%s_nMinSize_Filter_Y_um"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nMinSize_Filter_Y_um);

	strTemp.Format(_T("%s_nDefect_Size_Dilation"), g_strInsType[(int) eInsType]);
	pFile->SetItemValue(nSideIdx, strTemp, m_nDefect_Size_Dilation);

	for(int i=0; i<3; i++)
	{
		strTemp.Format(_T("%s_nJudge_Size_Min_X_um_%d"), g_strInsType[(int) eInsType], i);
		pFile->SetItemValue(nSideIdx, strTemp, m_nJudge_Size_Min_X_um[i]);

		strTemp.Format(_T("%s_nJudge_Size_Min_Y_um_%d"), g_strInsType[(int) eInsType], i);
		pFile->SetItemValue(nSideIdx, strTemp, m_nJudge_Size_Min_Y_um[i]);

		strTemp.Format(_T("%s_nJudge_Size_Min_OR_AND_%d"), g_strInsType[(int) eInsType], i);
		pFile->SetItemValue(nSideIdx, strTemp, m_nJudge_Size_Min_OR_AND[i]);
	}

	return TRUE;
}

void CNOTCH_PARM::Reset()
{
	m_nGlassStartLine_pxl = -1;
	m_ptTopMarkPos = CPoint(-1,-1);
	m_ptBotMarkPos = CPoint(-1,-1);

	m_bNotch_Use = FALSE;
	m_rtNotch_Area_pxl = CRect(-1,-1,-1,-1);

	m_nGrind_Threshold = 20;
	m_nGlass_Threshold = 80;
	m_nSmooth_Filter = 0;
	m_nReferece_Line_Threshold = 150;
	m_nNotchCenter_Offset_pxl = 0;

	m_bNotch_Inspect_Defect_Use = FALSE;
	m_nNotch_Inspect_Defect_Threshold = 30;
	m_nNotch_Inspect_Defect_Offset = 0;
	m_nNotch_Inspect_Defect_dilate = 10;
	m_nNotch_Inspect_Defect_Min_X_um = 10;
	m_nNotch_Inspect_Defect_Min_Y_um = 10;
	m_nNotch_Inspect_Defect_Judge_X_um = 30;
	m_nNotch_Inspect_Defect_Judge_Y_um = 30;
	m_nNotch_Inspect_Defect_Judge_And = 0;

	for(int i=0; i<MAX_SIDE_NOTCH_MEASURE_COUNT; i++)
	{
		m_bNotch_Dimension_Use[i] = TRUE;
		m_dNotch_Dimension_STD_mm[i] = 0.0;
		m_dNotch_Dimension_Diff_MIN_mm[i] = 0.1;
		m_dNotch_Dimension_Diff_MAX_mm[i] = 0.1;

		m_bNotch_Chamfer_Use[i] = TRUE;
		m_dNotch_Chamfer_STD_mm[i] = 0.1;
		m_dNotch_Chamfer_Diff_MIN_mm[i] = 0.1;
		m_dNotch_Chamfer_Diff_MAX_mm[i] = 0.1;
	}

	m_nNotch_Circle_Count = 0;

	for(int i=0; i<MAX_SIDE_NOTCH_CIRCLE_COUNT; i++)
	{
		m_bNotch_Circle_Use[i] = FALSE;
		m_ptNotch_Circle_TopMarkPos[i] = CPoint(-1,-1);
		m_ptNotch_Circle_BotMarkPos[i] = CPoint(-1,-1);
		m_rtNotch_Circle_Area_pxl[i] = CRect(-1,-1,-1,-1);
		m_dNotch_Circle_Spec_Radius_um[i] = 0.0;
		m_dNotch_Circle_Spec_Radius_Min_um[i] = 100.0;
		m_dNotch_Circle_Spec_Radius_Max_um[i] = 100.0;
	}
}

BOOL CNOTCH_PARM::ReadRecipe(CConfig *pFile, int nSideIdx, int nNotchIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	if(nNotchIdx < 0 || MAX_SIDE_NOTCH_COUNT <= nNotchIdx)
		return FALSE;

	CString strParam;
	int nTemp = 0;

	strParam.Format(_T("Notch_%d_m_nGlassStartLine_pxl"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_nGlassStartLine_pxl = nTemp;

	strParam.Format(_T("Notch_%d_m_ptTopMarkPos.x"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptTopMarkPos.x = nTemp;

	strParam.Format(_T("Notch_%d_m_ptTopMarkPos.y"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptTopMarkPos.y = nTemp;

	strParam.Format(_T("Notch_%d_m_ptBotMarkPos.x"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptBotMarkPos.x = nTemp;

	strParam.Format(_T("Notch_%d_m_ptBotMarkPos.y"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptBotMarkPos.y = nTemp;

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.left"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtNotch_Area_pxl.left = nTemp;

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.top"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtNotch_Area_pxl.top = nTemp;

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.right"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtNotch_Area_pxl.right = nTemp;

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.bottom"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtNotch_Area_pxl.bottom = nTemp;

	strParam.Format(_T("Notch_%d_m_bNotch_Use"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_bNotch_Use, 0);

	strParam.Format(_T("Notch_%d_m_nGrind_Threshold"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nGrind_Threshold, 20);

	strParam.Format(_T("Notch_%d_m_nGlass_Threshold"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nGlass_Threshold, 80);

	strParam.Format(_T("Notch_%d_m_nSmooth_Filter"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nSmooth_Filter, 0);

	strParam.Format(_T("Notch_%d_m_nReferece_Line_Threshold"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nReferece_Line_Threshold, 150);

	strParam.Format(_T("Notch_%d_m_nNotchCenter_Offset_pxl"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotchCenter_Offset_pxl, 0);

	strParam.Format(_T("Notch_%d_m_bNotch_Inspect_Defect_Use"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_bNotch_Inspect_Defect_Use, 0);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Threshold"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Threshold, 0);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Offset"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Offset, 0);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_dilate"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_dilate, 10);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Min_X_um"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Min_X_um, 10);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Min_Y_um"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Min_Y_um, 10);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Judge_X_um"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Judge_X_um, 30);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Judge_Y_um"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Judge_Y_um, 30);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Judge_And"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Judge_And, 0);

	for(int i=0; i<MAX_SIDE_NOTCH_MEASURE_COUNT; i++)
	{
		strParam.Format(_T("Notch_%d_m_bNotch_Dimension_Use_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_bNotch_Dimension_Use[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Dimension_STD_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Dimension_STD_mm[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Dimension_Diff_MIN_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Dimension_Diff_MIN_mm[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Dimension_Diff_MAX_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Dimension_Diff_MAX_mm[i], 0);

		strParam.Format(_T("Notch_%d_m_bNotch_Chamfer_Use_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_bNotch_Chamfer_Use[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Chamfer_STD_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Chamfer_STD_mm[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Chamfer_Diff_MIN_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Chamfer_Diff_MIN_mm[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Chamfer_Diff_MAX_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Chamfer_Diff_MAX_mm[i], 0);
	}

	strParam.Format(_T("Notch_%d_m_nNotch_Circle_Count"), nNotchIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nNotch_Circle_Count, 0);

	for(int i=0; i<MAX_SIDE_NOTCH_CIRCLE_COUNT; i++)
	{
		strParam.Format(_T("Notch_%d_m_bNotch_Circle_Use_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_bNotch_Circle_Use[i], 0);

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_TopMarkPos.x_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_ptNotch_Circle_TopMarkPos[i].x = nTemp;

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_TopMarkPos.y_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_ptNotch_Circle_TopMarkPos[i].y = nTemp;

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_BotMarkPos.x_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_ptNotch_Circle_BotMarkPos[i].x = nTemp;

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_BotMarkPos.y_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_ptNotch_Circle_BotMarkPos[i].y = nTemp;

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.left_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_rtNotch_Circle_Area_pxl[i].left = nTemp;

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.top_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_rtNotch_Circle_Area_pxl[i].top = nTemp;

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.right_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_rtNotch_Circle_Area_pxl[i].right = nTemp;

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.bottom_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
		m_rtNotch_Circle_Area_pxl[i].bottom = nTemp;

		strParam.Format(_T("Notch_%d_m_dNotch_Circle_Spec_Radius_um_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Circle_Spec_Radius_um[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Circle_Spec_Radius_Min_um_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Circle_Spec_Radius_Min_um[i], 0);

		strParam.Format(_T("Notch_%d_m_dNotch_Circle_Spec_Radius_Max_um_%d"), nNotchIdx, i);
		pFile->GetItemValue(nSideIdx, strParam, m_dNotch_Circle_Spec_Radius_Max_um[i], 0);
	}

	return TRUE;
}

BOOL CNOTCH_PARM::WriteRecipe(CConfig *pFile, int nSideIdx, int nNotchIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	if(nNotchIdx < 0 || MAX_SIDE_NOTCH_COUNT <= nNotchIdx)
		return FALSE;

	CString strParam;

	strParam.Format(_T("Notch_%d_m_nGlassStartLine_pxl"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nGlassStartLine_pxl);

	strParam.Format(_T("Notch_%d_m_ptTopMarkPos.x"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptTopMarkPos.x);

	strParam.Format(_T("Notch_%d_m_ptTopMarkPos.y"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptTopMarkPos.y);

	strParam.Format(_T("Notch_%d_m_ptBotMarkPos.x"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptBotMarkPos.x);

	strParam.Format(_T("Notch_%d_m_ptBotMarkPos.y"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptBotMarkPos.y);

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.left"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtNotch_Area_pxl.left);

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.top"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtNotch_Area_pxl.top);

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.right"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtNotch_Area_pxl.right);

	strParam.Format(_T("Notch_%d_m_rtNotch_Area_pxl.bottom"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtNotch_Area_pxl.bottom);

	strParam.Format(_T("Notch_%d_m_bNotch_Use"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_bNotch_Use);

	strParam.Format(_T("Notch_%d_m_nGrind_Threshold"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nGrind_Threshold);

	strParam.Format(_T("Notch_%d_m_nGlass_Threshold"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nGlass_Threshold);

	strParam.Format(_T("Notch_%d_m_nSmooth_Filter"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nSmooth_Filter);

	strParam.Format(_T("Notch_%d_m_nReferece_Line_Threshold"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nReferece_Line_Threshold);

	strParam.Format(_T("Notch_%d_m_nNotchCenter_Offset_pxl"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotchCenter_Offset_pxl);

	strParam.Format(_T("Notch_%d_m_bNotch_Inspect_Defect_Use"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_bNotch_Inspect_Defect_Use);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Threshold"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Threshold);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Offset"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Offset);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_dilate"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_dilate);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Min_X_um"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Min_X_um);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Min_Y_um"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Min_Y_um);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Judge_X_um"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Judge_X_um);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Judge_Y_um"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Judge_Y_um);

	strParam.Format(_T("Notch_%d_m_nNotch_Inspect_Defect_Judge_And"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Inspect_Defect_Judge_And);

	for(int i=0; i<MAX_SIDE_NOTCH_MEASURE_COUNT; i++)
	{
		strParam.Format(_T("Notch_%d_m_bNotch_Dimension_Use_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_bNotch_Dimension_Use[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Dimension_STD_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Dimension_STD_mm[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Dimension_Diff_MIN_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Dimension_Diff_MIN_mm[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Dimension_Diff_MAX_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Dimension_Diff_MAX_mm[i]);

		strParam.Format(_T("Notch_%d_m_bNotch_Chamfer_Use_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_bNotch_Chamfer_Use[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Chamfer_STD_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Chamfer_STD_mm[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Chamfer_Diff_MIN_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Chamfer_Diff_MIN_mm[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Chamfer_Diff_MAX_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Chamfer_Diff_MAX_mm[i]);
	}

	strParam.Format(_T("Notch_%d_m_nNotch_Circle_Count"), nNotchIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nNotch_Circle_Count);

	for(int i=0; i<MAX_SIDE_NOTCH_CIRCLE_COUNT; i++)
	{
		strParam.Format(_T("Notch_%d_m_bNotch_Circle_Use_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_bNotch_Circle_Use[i]);

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_TopMarkPos.x_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_ptNotch_Circle_TopMarkPos[i].x);

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_TopMarkPos.y_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_ptNotch_Circle_TopMarkPos[i].y);

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_BotMarkPos.x_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_ptNotch_Circle_BotMarkPos[i].x);

		strParam.Format(_T("Notch_%d_m_ptNotch_Circle_BotMarkPos.y_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_ptNotch_Circle_BotMarkPos[i].y);

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.left_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_rtNotch_Circle_Area_pxl[i].left);

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.top_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_rtNotch_Circle_Area_pxl[i].top);

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.right_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_rtNotch_Circle_Area_pxl[i].right);

		strParam.Format(_T("Notch_%d_m_rtNotch_Circle_Area_pxl.bottom_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_rtNotch_Circle_Area_pxl[i].bottom);

		strParam.Format(_T("Notch_%d_m_dNotch_Circle_Spec_Radius_um_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Circle_Spec_Radius_um[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Circle_Spec_Radius_Min_um_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Circle_Spec_Radius_Min_um[i]);

		strParam.Format(_T("Notch_%d_m_dNotch_Circle_Spec_Radius_Max_um_%d"), nNotchIdx, i);
		pFile->SetItemValue(nSideIdx, strParam, m_dNotch_Circle_Spec_Radius_Max_um[i]);
	}

	return TRUE;
}

void CEXCEPTION_AREA_PARM::Reset()
{
	m_ptTopMarkPos = CPoint(-1,-1);
	m_ptBotMarkPos = CPoint(-1,-1);

	m_nFilterType = 0;
	m_rtExceptionArea = CRect(-1,-1,-1,-1);

	m_nFilterSizeX = INT_MAX;
	m_nFilterSizeY = INT_MAX;
	m_bFilterAnd = TRUE;
}

BOOL CEXCEPTION_AREA_PARM::ReadRecipe(CConfig *pFile, int nSideIdx, int nExceptionIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	if(nExceptionIdx < 0 || MAX_SIDE_EXCEPTION_AREA_COUNT <= nExceptionIdx)
		return FALSE;

	CString strParam;
	int nTemp = 0;

	strParam.Format(_T("Exception_%d_m_ptTopMarkPos.x"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptTopMarkPos.x = nTemp;

	strParam.Format(_T("Exception_%d_m_ptTopMarkPos.y"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptTopMarkPos.y = nTemp;

	strParam.Format(_T("Exception_%d_m_ptBotMarkPos.x"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptBotMarkPos.x = nTemp;

	strParam.Format(_T("Exception_%d_m_ptBotMarkPos.y"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptBotMarkPos.y = nTemp;

	strParam.Format(_T("Exception_%d_m_rtExceptionArea.left"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtExceptionArea.left = nTemp;

	strParam.Format(_T("Exception_%d_m_rtExceptionArea.top"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtExceptionArea.top = nTemp;

	strParam.Format(_T("Exception_%d_m_rtExceptionArea.right"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtExceptionArea.right = nTemp;

	strParam.Format(_T("Exception_%d_m_rtExceptionArea.bottom"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtExceptionArea.bottom = nTemp;

	strParam.Format(_T("Exception_%d_m_nFilterType"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nFilterType, 0);
	strParam.Format(_T("Exception_%d_m_nFilterSizeX"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nFilterSizeX, 0);
	strParam.Format(_T("Exception_%d_m_nFilterSizeY"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nFilterSizeY, 0);
	strParam.Format(_T("Exception_%d_m_bFilterAnd"), nExceptionIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_bFilterAnd, 0);

	return TRUE;
}

BOOL CEXCEPTION_AREA_PARM::WriteRecipe(CConfig *pFile, int nSideIdx, int nExceptionIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	CString strParam;

	strParam.Format(_T("Exception_%d_m_ptTopMarkPos.x"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptTopMarkPos.x);
	strParam.Format(_T("Exception_%d_m_ptTopMarkPos.y"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptTopMarkPos.y);
	strParam.Format(_T("Exception_%d_m_ptBotMarkPos.x"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptBotMarkPos.x);
	strParam.Format(_T("Exception_%d_m_ptBotMarkPos.y"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptBotMarkPos.y);
	strParam.Format(_T("Exception_%d_m_rtExceptionArea.left"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtExceptionArea.left);
	strParam.Format(_T("Exception_%d_m_rtExceptionArea.top"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtExceptionArea.top);
	strParam.Format(_T("Exception_%d_m_rtExceptionArea.right"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtExceptionArea.right);
	strParam.Format(_T("Exception_%d_m_rtExceptionArea.bottom"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtExceptionArea.bottom);
	strParam.Format(_T("Exception_%d_m_nFilterType"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nFilterType);
	strParam.Format(_T("Exception_%d_m_nFilterSizeX"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nFilterSizeX);
	strParam.Format(_T("Exception_%d_m_nFilterSizeY"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nFilterSizeY);
	strParam.Format(_T("Exception_%d_m_bFilterAnd"), nExceptionIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_bFilterAnd);

	return TRUE;
}

void CUSER_DEFECT_AREA_PARM::Reset()
{
	m_ptTopMarkPos = CPoint(-1,-1);
	m_ptBotMarkPos = CPoint(-1,-1);

	m_rtUserDefectArea = CRect(-1,-1,-1,-1);

	m_bUseInspect = FALSE;
	m_nInspect_Method = 0;		// 0 : Gray, 1 : Y Pitch, 2 : X Pitch
	m_nMin_Threshold = 30;
	m_nMax_Threshold = 255;
	m_nDiff_Threshold = 20;
	m_nDiff_Pitch = 10;
	m_nMinSize_Filter_pxl = 3;

	m_nJudge_Size_Min_X_um = 200;
	m_nJudge_Size_Min_Y_um = 200;
	m_nJudge_Size_Min_OR_AND = 1;	// 0 : No Use, 1 : OR, 2 : AND
}

BOOL CUSER_DEFECT_AREA_PARM::ReadRecipe(CConfig *pFile, int nSideIdx, int nUserDefectAreaIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	if(nUserDefectAreaIdx < 0 || MAX_SIDE_USER_DEFECT_AREA_COUNT <= nUserDefectAreaIdx)
		return FALSE;

	CString strParam;
	int nTemp = 0;

	strParam.Format(_T("UserDefect_%d_m_ptTopMarkPos.x"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptTopMarkPos.x = nTemp;

	strParam.Format(_T("UserDefect_%d_m_ptTopMarkPos.y"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptTopMarkPos.y = nTemp;

	strParam.Format(_T("UserDefect_%d_m_ptBotMarkPos.x"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptBotMarkPos.x = nTemp;

	strParam.Format(_T("UserDefect_%d_m_ptBotMarkPos.y"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_ptBotMarkPos.y = nTemp;

	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.left"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtUserDefectArea.left = nTemp;

	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.top"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtUserDefectArea.top = nTemp;

	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.right"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtUserDefectArea.right = nTemp;

	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.bottom"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, nTemp, 0);
	m_rtUserDefectArea.bottom = nTemp;

	strParam.Format(_T("UserDefect_%d_m_bUseInspect"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_bUseInspect, 0);

	strParam.Format(_T("UserDefect_%d_m_nInspect_Method"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nInspect_Method, 0);

	strParam.Format(_T("UserDefect_%d_m_nMin_Threshold"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nMin_Threshold, 30);

	strParam.Format(_T("UserDefect_%d_m_nMax_Threshold"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nMax_Threshold, 255);

	strParam.Format(_T("UserDefect_%d_m_nDiff_Threshold"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nDiff_Threshold, 15);

	strParam.Format(_T("UserDefect_%d_m_nDiff_Pitch"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nDiff_Pitch, 10);

	strParam.Format(_T("UserDefect_%d_m_nMinSize_Filter_pxl"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nMinSize_Filter_pxl, 3);	

	strParam.Format(_T("UserDefect_%d_m_nJudge_Size_Min_X_um"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nJudge_Size_Min_X_um, 50);

	strParam.Format(_T("UserDefect_%d_m_nJudge_Size_Min_Y_um"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nJudge_Size_Min_Y_um, 50);

	strParam.Format(_T("UserDefect_%d_m_nJudge_Size_Min_OR_AND"), nUserDefectAreaIdx);
	pFile->GetItemValue(nSideIdx, strParam, m_nJudge_Size_Min_OR_AND, 0);

	return TRUE;
}

BOOL CUSER_DEFECT_AREA_PARM::WriteRecipe(CConfig *pFile, int nSideIdx, int nUserDefectAreaIdx)
{
	if(pFile == NULL)
		return FALSE;

	if(nSideIdx < 0 || MAX_SIDE_COUNT <= nSideIdx)
		return FALSE;

	CString strParam;

	strParam.Format(_T("UserDefect_%d_m_ptTopMarkPos.x"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptTopMarkPos.x);
	strParam.Format(_T("UserDefect_%d_m_ptTopMarkPos.y"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptTopMarkPos.y);
	strParam.Format(_T("UserDefect_%d_m_ptBotMarkPos.x"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptBotMarkPos.x);
	strParam.Format(_T("UserDefect_%d_m_ptBotMarkPos.y"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_ptBotMarkPos.y);
	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.left"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtUserDefectArea.left);
	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.top"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtUserDefectArea.top);
	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.right"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtUserDefectArea.right);
	strParam.Format(_T("UserDefect_%d_m_rtExceptionArea.bottom"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, (int) m_rtUserDefectArea.bottom);


	strParam.Format(_T("UserDefect_%d_m_bUseInspect"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_bUseInspect);
	strParam.Format(_T("UserDefect_%d_m_nInspect_Method"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nInspect_Method);
	strParam.Format(_T("UserDefect_%d_m_nMin_Threshold"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nMin_Threshold);
	strParam.Format(_T("UserDefect_%d_m_nMax_Threshold"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nMax_Threshold);
	strParam.Format(_T("UserDefect_%d_m_nDiff_Threshold"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nDiff_Threshold);
	strParam.Format(_T("UserDefect_%d_m_nDiff_Pitch"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nDiff_Pitch);
	strParam.Format(_T("UserDefect_%d_m_nMinSize_Filter_pxl"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nMinSize_Filter_pxl);
	strParam.Format(_T("UserDefect_%d_m_nJudge_Size_Min_X_um"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nJudge_Size_Min_X_um);
	strParam.Format(_T("UserDefect_%d_m_nJudge_Size_Min_Y_um"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nJudge_Size_Min_Y_um);
	strParam.Format(_T("UserDefect_%d_m_nJudge_Size_Min_OR_AND"), nUserDefectAreaIdx);
	pFile->SetItemValue(nSideIdx, strParam, m_nJudge_Size_Min_OR_AND);

	return TRUE;
}