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