#if !defined(__MODEL_RECIPE_HEADER_INCLUDED__)
|
#define __MODEL_RECIPE_HEADER_INCLUDED__
|
|
#include "HMRegiConfig.h"
|
#include "MosisPacket.h"
|
|
typedef struct _CAMERARECIPEINFO
|
{
|
int m_nBMThreshold; // BM °Ë»ç ¹®Åΰª
|
int m_nPatThreshold; // Pattern °Ë»ç ¹®Åΰª
|
int m_nSkipSize; // À§/¾Æ·¡¿¡¼ °Ë»ç¸¦ ÇÏÁö ¾Ê´Â ¿µ¿ª.
|
|
_CAMERARECIPEINFO()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_nBMThreshold = 0;
|
m_nPatThreshold = 0;
|
m_nSkipSize = 0;
|
}
|
_CAMERARECIPEINFO& operator=(const _CAMERARECIPEINFO& rhs)
|
{
|
if (this != &rhs)
|
{
|
m_nBMThreshold = rhs.m_nBMThreshold;
|
m_nPatThreshold = rhs.m_nPatThreshold;
|
m_nSkipSize = rhs.m_nSkipSize;
|
}
|
return *this;
|
}
|
BOOL ReadRecipe(CHMRegiConfig *pFile,int nModelIdx,int nCamIdx,CameraType Camtype)
|
{
|
CString strSection,strTmp;
|
|
switch(Camtype)
|
{
|
case CamType_Transfer: strTmp="T"; break;
|
case CamType_Reflex: strTmp="R"; break;
|
}
|
|
strSection.Format("MODEL_%sCAMBMTHRES_%d",strTmp,nCamIdx);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nBMThreshold);
|
strSection.Format("MODEL_%sCAMPATTHRES_%d",strTmp,nCamIdx);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatThreshold);
|
strSection.Format("MODEL_%sCAMSKIPSIZE_%d",strTmp,nCamIdx);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nSkipSize);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CHMRegiConfig *pFile,int nModelIdx,int nCamIdx,CameraType Camtype)
|
{
|
CString strSection,strTmp;
|
|
switch(Camtype)
|
{
|
case CamType_Transfer: strTmp="T"; break;
|
case CamType_Reflex: strTmp="R"; break;
|
}
|
|
strSection.Format("MODEL_%sCAMBMTHRES_%d",strTmp,nCamIdx);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nBMThreshold);
|
strSection.Format("MODEL_%sCAMPATTHRES_%d",strTmp,nCamIdx);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatThreshold);
|
strSection.Format("MODEL_%sCAMSKIPSIZE_%d",strTmp,nCamIdx);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nSkipSize);
|
return TRUE;
|
}
|
BOOL ReadRecipe(CMosisPacket *pPacket)
|
{
|
pPacket->ReadValue(m_nBMThreshold);
|
pPacket->ReadValue(m_nPatThreshold);
|
pPacket->ReadValue(m_nSkipSize);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CMosisPacket *pPacket)
|
{
|
pPacket->WriteValue(m_nBMThreshold);
|
pPacket->WriteValue(m_nPatThreshold);
|
pPacket->WriteValue(m_nSkipSize);
|
return TRUE;
|
}
|
} CameraRecipeInfo, *pCameraRecipeInfo;
|
|
//////////////////////////////////////////////////////////////////////////
|
// ¸ðµ¨ Á¤º¸ Áß ÁÂÇ¥¿¡ Á¾¼ÓÀûÀÎ Á¤º¸µé.
|
typedef struct _MODELCOORDINFO
|
{
|
// Glass ¼¿ ¼ö ¹× Size
|
int m_nEdgetoPattern;
|
int m_nPattern;
|
int m_nPatterntoEdge;
|
|
int m_nCellNum;
|
int *m_pCellPat2Pat;
|
|
_MODELCOORDINFO()
|
{
|
m_pCellPat2Pat = NULL;
|
Reset();
|
}
|
~_MODELCOORDINFO()
|
{
|
DeleteBuffer();
|
}
|
void Reset()
|
{
|
m_nEdgetoPattern = 0;
|
m_nPattern = 0;
|
m_nPatterntoEdge = 0;
|
m_nCellNum = 0;
|
DeleteBuffer();
|
}
|
void DeleteBuffer()
|
{
|
if(m_pCellPat2Pat != NULL)
|
delete[] m_pCellPat2Pat, m_pCellPat2Pat=NULL;
|
m_nCellNum = 0;
|
}
|
void SetPat2PatNum(int nCount)
|
{
|
DeleteBuffer();
|
m_nCellNum = nCount;
|
if(nCount-1 <= 0)
|
{
|
m_nCellNum = 0;
|
return;
|
}
|
m_pCellPat2Pat = new int[nCount-1];
|
ZeroMemory(m_pCellPat2Pat,sizeof(int)*(nCount-1));
|
}
|
_MODELCOORDINFO& operator=(const _MODELCOORDINFO& rhs)
|
{
|
if (this != &rhs)
|
{
|
m_nEdgetoPattern = rhs.m_nEdgetoPattern;
|
m_nPattern = rhs.m_nPattern;
|
m_nPatterntoEdge = rhs.m_nPatterntoEdge;
|
SetPat2PatNum(rhs.m_nCellNum);
|
if(rhs.m_nCellNum-1 > 0 && m_pCellPat2Pat != NULL && rhs.m_pCellPat2Pat != NULL)
|
{
|
int i;
|
for(i=0;i<rhs.m_nCellNum-1;i++)
|
{
|
m_pCellPat2Pat[i] = rhs.m_pCellPat2Pat[i];
|
}
|
}
|
}
|
return *this;
|
}
|
BOOL ReadRecipe(CHMRegiConfig *pFile,int nModelIdx,ScanCoordinate dir)
|
{
|
CString strSection,strTmp;
|
|
switch(dir)
|
{
|
case SC_XCoord: strTmp="X"; break;
|
case SC_YCoord: strTmp="Y"; break;
|
}
|
|
strSection.Format("MODEL_%sEDGE2PATTERN",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nEdgetoPattern);
|
strSection.Format("MODEL_%sPATTERN",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPattern);
|
strSection.Format("MODEL_%sPATTERN2EDGE",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatterntoEdge);
|
strSection.Format("MODEL_%sCELLNUM",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCellNum);
|
|
SetPat2PatNum(m_nCellNum);
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCellNum-1;iLoop++)
|
{
|
strSection.Format("MODEL_%sCELL2CELL_%d",strTmp,iLoop);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_pCellPat2Pat[iLoop]);
|
}
|
return TRUE;
|
}
|
BOOL WriteRecipe(CHMRegiConfig *pFile,int nModelIdx,ScanCoordinate dir)
|
{
|
CString strSection,strTmp;
|
|
switch(dir)
|
{
|
case SC_XCoord: strTmp="X"; break;
|
case SC_YCoord: strTmp="Y"; break;
|
}
|
|
strSection.Format("MODEL_%sEDGE2PATTERN",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nEdgetoPattern);
|
strSection.Format("MODEL_%sPATTERN",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPattern);
|
strSection.Format("MODEL_%sPATTERN2EDGE",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatterntoEdge);
|
strSection.Format("MODEL_%sCELLNUM",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCellNum);
|
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCellNum-1;iLoop++)
|
{
|
strSection.Format("MODEL_%sCELL2CELL_%d",strTmp,iLoop);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_pCellPat2Pat[iLoop]);
|
}
|
return TRUE;
|
}
|
BOOL ReadRecipe(CMosisPacket *pPacket)
|
{
|
pPacket->ReadValue(m_nEdgetoPattern);
|
pPacket->ReadValue(m_nPattern);
|
pPacket->ReadValue(m_nPatterntoEdge);
|
pPacket->ReadValue(m_nCellNum);
|
|
SetPat2PatNum(m_nCellNum);
|
|
if(m_pCellPat2Pat != NULL)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCellNum-1;iLoop++)
|
pPacket->ReadValue(m_pCellPat2Pat[iLoop]);
|
}
|
return TRUE;
|
}
|
BOOL WriteRecipe(CMosisPacket *pPacket)
|
{
|
pPacket->WriteValue(m_nEdgetoPattern);
|
pPacket->WriteValue(m_nPattern);
|
pPacket->WriteValue(m_nPatterntoEdge);
|
pPacket->WriteValue(m_nCellNum);
|
|
if(m_pCellPat2Pat != NULL && m_nCellNum-1 > 0)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCellNum-1;iLoop++)
|
pPacket->WriteValue(m_pCellPat2Pat[iLoop]);
|
}
|
return TRUE;
|
}
|
} ModelCoordInfo, *pModelCoordInfo;
|
|
class AFX_EXT_CLASS CMODEL_FINDPATTERN_PARM
|
{
|
public:
|
FindBoundary m_FindBoundary; // 0 - ¾ÈãÀ½, 1 - ¸ÅĪ, 2 - È¥Àâµµ, 3 - ¹à±â, 4 - Template Matching, // kys 5 - Pitch Matching
|
int m_nThresholdBMtoPattern; // BM - Pat ã±â ¹®Åΰª
|
double m_dBoundaryOffset; // °æ°èã±â Offset - »ó°ü°è¼ö°¡ ÀÌ °ª ÀÌÇÏÀÎ ÁöÁ¡¿¡¼ °æ°è·Î ÀÎÁ¤.
|
|
CMODEL_FINDPATTERN_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_FindBoundary = FB_PitchMatching;
|
m_nThresholdBMtoPattern = 0;
|
m_dBoundaryOffset = 0.;
|
}
|
CMODEL_FINDPATTERN_PARM& operator=(const CMODEL_FINDPATTERN_PARM &rh)
|
{
|
m_FindBoundary = rh.m_FindBoundary;
|
m_nThresholdBMtoPattern = rh.m_nThresholdBMtoPattern;
|
m_dBoundaryOffset = rh.m_dBoundaryOffset;
|
return *this;
|
}
|
BOOL ReadRecipe(CHMRegiConfig *pFile,int nModelIdx,CameraType Camtype)
|
{
|
CString strSection,strTmp;
|
int nValue;
|
|
switch(Camtype)
|
{
|
case CamType_Transfer: strTmp="T"; break;
|
case CamType_Reflex: strTmp="R"; break;
|
}
|
|
strSection.Format("MODEL_FINDEDGEMETHOD_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, nValue);
|
m_FindBoundary = (FindBoundary)nValue;
|
strSection.Format("MODEL_THRESBM2PAT_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nThresholdBMtoPattern);
|
strSection.Format("MODEL_BOUNDARYOFFSET_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_dBoundaryOffset);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CHMRegiConfig *pFile,int nModelIdx,CameraType Camtype)
|
{
|
CString strSection,strTmp;
|
int nValue;
|
|
switch(Camtype)
|
{
|
case CamType_Transfer: strTmp="T"; break;
|
case CamType_Reflex: strTmp="R"; break;
|
}
|
|
strSection.Format("MODEL_FINDEDGEMETHOD_%s",strTmp);
|
nValue = (int)m_FindBoundary;
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, nValue);
|
strSection.Format("MODEL_THRESBM2PAT_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nThresholdBMtoPattern);
|
strSection.Format("MODEL_BOUNDARYOFFSET_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_dBoundaryOffset);
|
return TRUE;
|
}
|
BOOL ReadRecipe(CMosisPacket *pPacket)
|
{
|
int nValue;
|
pPacket->ReadValue(nValue);
|
m_FindBoundary = (FindBoundary)nValue;
|
pPacket->ReadValue(m_nThresholdBMtoPattern);
|
pPacket->ReadValue(m_dBoundaryOffset);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CMosisPacket *pPacket)
|
{
|
int nValue;
|
nValue = (int)m_FindBoundary;
|
pPacket->WriteValue(nValue);
|
pPacket->WriteValue(m_nThresholdBMtoPattern);
|
pPacket->WriteValue(m_dBoundaryOffset);
|
return TRUE;
|
}
|
};
|
|
class AFX_EXT_CLASS CMODEL_INSPECT_PARM
|
{
|
public:
|
int m_nCamNum;
|
int m_nPatternDummyX;
|
int m_nPatternDummyY;
|
int m_nCamMainPatThres;
|
int m_nCamMainBMThres;
|
int m_nCamMainSkipSize;
|
int m_nInspMethodPatIdx;
|
int m_nInspMethodBMIdx;
|
int m_nAddThresLevel;
|
int m_nAddThreshold;
|
int m_nAddGradient;
|
pCameraRecipeInfo m_pCameraRecipe;
|
|
CMODEL_INSPECT_PARM()
|
{
|
m_pCameraRecipe = NULL;
|
Reset();
|
}
|
~CMODEL_INSPECT_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_nCamNum = m_nPatternDummyX = m_nPatternDummyY = m_nCamMainPatThres = m_nCamMainBMThres = m_nCamMainSkipSize = 0;
|
m_nInspMethodPatIdx = m_nInspMethodBMIdx = m_nAddThresLevel = m_nAddThreshold = m_nAddGradient = 0;
|
if(m_pCameraRecipe != NULL)
|
delete[] m_pCameraRecipe, m_pCameraRecipe=NULL;
|
}
|
void SetCamNum(int nCount)
|
{
|
m_nCamNum = nCount;
|
if(m_pCameraRecipe != NULL)
|
delete[] m_pCameraRecipe, m_pCameraRecipe=NULL;
|
if(nCount<=0)
|
return;
|
m_pCameraRecipe = new CameraRecipeInfo[nCount];
|
}
|
CMODEL_INSPECT_PARM& operator=(const CMODEL_INSPECT_PARM &rh)
|
{
|
m_nCamNum = rh.m_nCamNum;
|
m_nPatternDummyX = rh.m_nPatternDummyX;
|
m_nPatternDummyY = rh.m_nPatternDummyY;
|
m_nCamMainPatThres = rh.m_nCamMainPatThres;
|
m_nCamMainBMThres = rh.m_nCamMainBMThres;
|
m_nCamMainSkipSize = rh.m_nCamMainSkipSize;
|
m_nInspMethodPatIdx = rh.m_nInspMethodPatIdx;
|
m_nInspMethodBMIdx = rh.m_nInspMethodBMIdx;
|
m_nAddThresLevel = rh.m_nAddThresLevel;
|
m_nAddThreshold = rh.m_nAddThreshold;
|
m_nAddGradient = rh.m_nAddGradient;
|
SetCamNum(m_nCamNum);
|
if(rh.m_pCameraRecipe != NULL && m_nCamNum > 0)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCamNum;iLoop++)
|
m_pCameraRecipe[iLoop] = rh.m_pCameraRecipe[iLoop];
|
}
|
return *this;
|
}
|
BOOL ReadRecipe(CHMRegiConfig *pFile,int nModelIdx,CameraType Camtype)
|
{
|
CString strSection,strTmp;
|
|
switch(Camtype)
|
{
|
case CamType_Transfer: strTmp="T"; break;
|
case CamType_Reflex: strTmp="R"; break;
|
}
|
|
strSection.Format("MODEL_CAMMAINPATTHRES_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCamMainPatThres, 0);
|
strSection.Format("MODEL_CAMMPATDUMMYTB_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatternDummyX, 0);
|
strSection.Format("MODEL_CAMMPATDUMMYLR_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatternDummyY, 0);
|
strSection.Format("MODEL_CAMMAINBMTHRES_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCamMainBMThres, 0);
|
strSection.Format("MODEL_CAMMAINSKIPSIZE_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCamMainSkipSize, 0);
|
strSection.Format("MODEL_INSPMETHODIDXPAT%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nInspMethodPatIdx, 0);
|
strSection.Format("MODEL_INSPMETHODIDXBM%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nInspMethodBMIdx, 0);
|
strSection.Format("MODEL_ADDTHRESLEVEL_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nAddThresLevel, 0);
|
strSection.Format("MODEL_ADDTHRESHOLD_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nAddThreshold, 0);
|
strSection.Format("MODEL_ADDGRADIENT_%s",strTmp);
|
pFile->GetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nAddGradient, 0);
|
|
SetCamNum(m_nCamNum);
|
|
if(m_pCameraRecipe != NULL && m_nCamNum > 0)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCamNum;iLoop++)
|
m_pCameraRecipe[iLoop].ReadRecipe(pFile,nModelIdx,iLoop,Camtype);
|
}
|
|
return TRUE;
|
}
|
BOOL WriteRecipe(CHMRegiConfig *pFile,int nModelIdx,CameraType Camtype)
|
{
|
CString strSection,strTmp;
|
|
switch(Camtype)
|
{
|
case CamType_Transfer: strTmp="T"; break;
|
case CamType_Reflex: strTmp="R"; break;
|
}
|
|
strSection.Format("MODEL_CAMMAINPATTHRES_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCamMainPatThres);
|
strSection.Format("MODEL_CAMMPATDUMMYTB_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatternDummyX);
|
strSection.Format("MODEL_CAMMPATDUMMYLR_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nPatternDummyY);
|
strSection.Format("MODEL_CAMMAINBMTHRES_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCamMainBMThres);
|
strSection.Format("MODEL_CAMMAINSKIPSIZE_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nCamMainSkipSize);
|
strSection.Format("MODEL_INSPMETHODIDXPAT%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nInspMethodPatIdx);
|
strSection.Format("MODEL_INSPMETHODIDXBM%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nInspMethodBMIdx);
|
strSection.Format("MODEL_ADDTHRESLEVEL_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nAddThresLevel);
|
strSection.Format("MODEL_ADDTHRESHOLD_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nAddThreshold);
|
strSection.Format("MODEL_ADDGRADIENT_%s",strTmp);
|
pFile->SetItemValue(nModelIdx, (LPSTR)(LPCTSTR)strSection, m_nAddGradient);
|
|
if(m_pCameraRecipe != NULL && m_nCamNum > 0)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCamNum;iLoop++)
|
m_pCameraRecipe[iLoop].WriteRecipe(pFile,nModelIdx,iLoop,Camtype);
|
}
|
|
return TRUE;
|
}
|
BOOL ReadRecipe(CMosisPacket *pPacket)
|
{
|
pPacket->ReadValue(m_nCamMainPatThres);
|
pPacket->ReadValue(m_nPatternDummyX);
|
pPacket->ReadValue(m_nPatternDummyY);
|
pPacket->ReadValue(m_nCamMainBMThres);
|
pPacket->ReadValue(m_nCamMainSkipSize);
|
pPacket->ReadValue(m_nInspMethodPatIdx);
|
pPacket->ReadValue(m_nInspMethodBMIdx);
|
pPacket->ReadValue(m_nAddThresLevel);
|
pPacket->ReadValue(m_nAddThreshold);
|
pPacket->ReadValue(m_nAddGradient);
|
|
SetCamNum(m_nCamNum);
|
|
if(m_pCameraRecipe != NULL && m_nCamNum > 0)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCamNum;iLoop++)
|
m_pCameraRecipe[iLoop].ReadRecipe(pPacket);
|
}
|
return TRUE;
|
}
|
BOOL WriteRecipe(CMosisPacket *pPacket)
|
{
|
pPacket->WriteValue(m_nCamMainPatThres);
|
pPacket->WriteValue(m_nPatternDummyX);
|
pPacket->WriteValue(m_nPatternDummyY);
|
pPacket->WriteValue(m_nCamMainBMThres);
|
pPacket->WriteValue(m_nCamMainSkipSize);
|
pPacket->WriteValue(m_nInspMethodPatIdx);
|
pPacket->WriteValue(m_nInspMethodBMIdx);
|
pPacket->WriteValue(m_nAddThresLevel);
|
pPacket->WriteValue(m_nAddThreshold);
|
pPacket->WriteValue(m_nAddGradient);
|
|
if(m_pCameraRecipe != NULL && m_nCamNum > 0)
|
{
|
int iLoop;
|
for(iLoop=0;iLoop<m_nCamNum;iLoop++)
|
m_pCameraRecipe[iLoop].WriteRecipe(pPacket);
|
}
|
return TRUE;
|
}
|
};
|
|
class AFX_EXT_CLASS CMODEL_COORDI_PARM
|
{
|
public:
|
ModelCoordInfo m_CoordInfoX;
|
ModelCoordInfo m_CoordInfoY;
|
CellLineType m_CellXLine;
|
CellLineType m_CellYLine;
|
int m_nCellXDir; // Glass XÃà°ú Cell XÃàÀÌ °°À¸¸é 1, ¹Ý´ë¸é -1
|
int m_nCellYDir; // Glass YÃà°ú Cell YÃàÀÌ °°À¸¸é 1, ¹Ý´ë¸é -1
|
|
CMODEL_COORDI_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_CoordInfoX.Reset();
|
m_CoordInfoY.Reset();
|
m_CellXLine = CellLine_Gate;
|
m_CellYLine = CellLine_Data;
|
m_nCellXDir = m_nCellYDir = 0;
|
}
|
CMODEL_COORDI_PARM& operator=(const CMODEL_COORDI_PARM &rh)
|
{
|
m_CoordInfoX = rh.m_CoordInfoX;
|
m_CoordInfoY = rh.m_CoordInfoY;
|
m_CellXLine = rh.m_CellXLine;
|
m_CellYLine = rh.m_CellYLine;
|
m_nCellXDir = rh.m_nCellXDir;
|
m_nCellYDir = rh.m_nCellYDir;
|
return *this;
|
}
|
BOOL ReadRecipe(CHMRegiConfig *pFile,int nModelIdx)
|
{
|
m_CoordInfoX.ReadRecipe(pFile,nModelIdx,SC_XCoord);
|
m_CoordInfoY.ReadRecipe(pFile,nModelIdx,SC_YCoord);
|
pFile->GetItemValue(nModelIdx, "MODEL_CELLXDIR", m_nCellXDir, 1);
|
pFile->GetItemValue(nModelIdx, "MODEL_CELLYDIR", m_nCellYDir, 1);
|
|
return TRUE;
|
}
|
BOOL WriteRecipe(CHMRegiConfig *pFile,int nModelIdx)
|
{
|
m_CoordInfoX.WriteRecipe(pFile,nModelIdx,SC_XCoord);
|
m_CoordInfoY.WriteRecipe(pFile,nModelIdx,SC_YCoord);
|
pFile->SetItemValue(nModelIdx, "MODEL_CELLXDIR", m_nCellXDir);
|
pFile->SetItemValue(nModelIdx, "MODEL_CELLYDIR", m_nCellYDir);
|
|
return TRUE;
|
}
|
BOOL ReadRecipe(CMosisPacket *pPacket)
|
{
|
m_CoordInfoX.ReadRecipe(pPacket);
|
m_CoordInfoY.ReadRecipe(pPacket);
|
pPacket->ReadValue(m_nCellXDir);
|
pPacket->ReadValue(m_nCellYDir);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CMosisPacket *pPacket)
|
{
|
m_CoordInfoX.WriteRecipe(pPacket);
|
m_CoordInfoY.WriteRecipe(pPacket);
|
pPacket->WriteValue(m_nCellXDir);
|
pPacket->WriteValue(m_nCellYDir);
|
return TRUE;
|
}
|
};
|
|
class AFX_EXT_CLASS CMODEL_RECIPE_PARM
|
{
|
public:
|
BOOL m_bTCSNum;
|
BOOL m_bUseDPC;
|
BOOL m_bReportResult; // °á°ú¸¦ º¸°íÇÒ °ÍÀÎÁö È®ÀÎ.
|
double m_dCellPitchConv;
|
double m_dCellPitchScan;
|
int m_nPitchCycleConv;
|
int m_nPitchCycleScan;
|
DefectLocation m_DefectLoc;
|
|
CMODEL_COORDI_PARM m_pCoordiParm;
|
CMODEL_INSPECT_PARM m_pTransInsParm;
|
CMODEL_INSPECT_PARM m_pRefInsParm;
|
CMODEL_FINDPATTERN_PARM m_pTransFindParm;
|
CMODEL_FINDPATTERN_PARM m_pRefFindParm;
|
|
|
CMODEL_RECIPE_PARM()
|
{
|
Reset();
|
}
|
void Reset()
|
{
|
m_bTCSNum = m_bUseDPC = m_bReportResult = FALSE;
|
m_dCellPitchConv = m_dCellPitchScan = 0.;
|
m_nPitchCycleConv = m_nPitchCycleScan = 0;
|
m_DefectLoc = DefectLoc_Pattern;
|
m_pCoordiParm.Reset();
|
m_pTransInsParm.Reset();
|
m_pRefInsParm.Reset();
|
m_pTransFindParm.Reset();
|
m_pRefFindParm.Reset();
|
}
|
CMODEL_RECIPE_PARM& operator=(const CMODEL_RECIPE_PARM &rh)
|
{
|
m_bTCSNum = rh.m_bTCSNum;
|
m_bUseDPC = rh.m_bUseDPC;
|
m_bReportResult = rh.m_bReportResult;
|
m_dCellPitchConv = rh.m_dCellPitchConv;
|
m_dCellPitchScan = rh.m_dCellPitchScan;
|
m_nPitchCycleConv = rh.m_nPitchCycleConv;
|
m_nPitchCycleScan = rh.m_nPitchCycleScan;
|
m_DefectLoc = rh.m_DefectLoc;
|
m_pCoordiParm = rh.m_pCoordiParm;
|
m_pTransInsParm = rh.m_pTransInsParm;
|
m_pRefInsParm = rh.m_pRefInsParm;
|
m_pTransFindParm = rh.m_pTransFindParm;
|
m_pRefFindParm = rh.m_pRefFindParm;
|
return *this;
|
}
|
BOOL ReadRecipe(CHMRegiConfig *pFile,int nModelIdx)
|
{
|
if(pFile == NULL)
|
return FALSE;
|
|
int nValue;
|
|
pFile->GetItemValue(nModelIdx, "MODEL_TCSNUM", m_bTCSNum, FALSE);
|
pFile->GetItemValue(nModelIdx, "MODEL_USEDPC", m_bUseDPC, FALSE);
|
pFile->GetItemValue(nModelIdx, "MODEL_REPORTRESULT", m_bReportResult, FALSE);
|
pFile->GetItemValue(nModelIdx, "MODEL_CELLPITCHCONV", m_dCellPitchConv, 0.);
|
pFile->GetItemValue(nModelIdx, "MODEL_CELLPITCHSCAN", m_dCellPitchScan, 0.);
|
pFile->GetItemValue(nModelIdx, "MODEL_PITCHCYCLECONV", m_nPitchCycleConv, 0);
|
pFile->GetItemValue(nModelIdx, "MODEL_PITCHCYCLESCAN", m_nPitchCycleScan, 0);
|
pFile->GetItemValue(nModelIdx, "MODEL_DEFECTLOC", nValue, FALSE);
|
m_DefectLoc = (DefectLocation)nValue;
|
|
m_pCoordiParm.ReadRecipe(pFile,nModelIdx);
|
m_pTransInsParm.ReadRecipe(pFile,nModelIdx,CamType_Transfer);
|
m_pRefInsParm.ReadRecipe(pFile,nModelIdx,CamType_Reflex);
|
m_pTransFindParm.ReadRecipe(pFile,nModelIdx,CamType_Transfer);
|
m_pRefFindParm.ReadRecipe(pFile,nModelIdx,CamType_Reflex);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CHMRegiConfig *pFile,int nModelIdx)
|
{
|
if(pFile == NULL)
|
return FALSE;
|
|
int nValue;
|
|
pFile->SetItemValue(nModelIdx, "MODEL_TCSNUM", m_bTCSNum);
|
pFile->SetItemValue(nModelIdx, "MODEL_USEDPC", m_bUseDPC);
|
pFile->SetItemValue(nModelIdx, "MODEL_REPORTRESULT", m_bReportResult);
|
pFile->SetItemValue(nModelIdx, "MODEL_CELLPITCHCONV", m_dCellPitchConv);
|
pFile->SetItemValue(nModelIdx, "MODEL_CELLPITCHSCAN", m_dCellPitchScan);
|
pFile->SetItemValue(nModelIdx, "MODEL_PITCHCYCLECONV", m_nPitchCycleConv);
|
pFile->SetItemValue(nModelIdx, "MODEL_PITCHCYCLESCAN", m_nPitchCycleScan);
|
nValue = (int)m_DefectLoc;
|
pFile->SetItemValue(nModelIdx, "MODEL_DEFECTLOC", nValue);
|
|
m_pCoordiParm.WriteRecipe(pFile,nModelIdx);
|
m_pTransInsParm.WriteRecipe(pFile,nModelIdx,CamType_Transfer);
|
m_pRefInsParm.WriteRecipe(pFile,nModelIdx,CamType_Reflex);
|
m_pTransFindParm.WriteRecipe(pFile,nModelIdx,CamType_Transfer);
|
m_pRefFindParm.WriteRecipe(pFile,nModelIdx,CamType_Reflex);
|
return TRUE;
|
}
|
BOOL ReadRecipe(CMosisPacket *pPacket)
|
{
|
int nValue;
|
pPacket->ReadValue(m_bTCSNum);
|
pPacket->ReadValue(m_bUseDPC);
|
pPacket->ReadValue(m_bReportResult);
|
pPacket->ReadValue(m_dCellPitchConv);
|
pPacket->ReadValue(m_dCellPitchScan);
|
pPacket->ReadValue(m_nPitchCycleConv);
|
pPacket->ReadValue(m_nPitchCycleScan);
|
pPacket->ReadValue(nValue);
|
m_DefectLoc = (DefectLocation)nValue;
|
|
m_pCoordiParm.ReadRecipe(pPacket);
|
m_pTransInsParm.ReadRecipe(pPacket);
|
m_pRefInsParm.ReadRecipe(pPacket);
|
m_pTransFindParm.ReadRecipe(pPacket);
|
m_pRefFindParm.ReadRecipe(pPacket);
|
return TRUE;
|
}
|
BOOL WriteRecipe(CMosisPacket *pPacket)
|
{
|
int nValue;
|
pPacket->WriteValue(m_bTCSNum);
|
pPacket->WriteValue(m_bUseDPC);
|
pPacket->WriteValue(m_bReportResult);
|
pPacket->WriteValue(m_dCellPitchConv);
|
pPacket->WriteValue(m_dCellPitchScan);
|
pPacket->WriteValue(m_nPitchCycleConv);
|
pPacket->WriteValue(m_nPitchCycleScan);
|
nValue = (int)m_DefectLoc;
|
pPacket->WriteValue(nValue);
|
|
m_pCoordiParm.WriteRecipe(pPacket);
|
m_pTransInsParm.WriteRecipe(pPacket);
|
m_pRefInsParm.WriteRecipe(pPacket);
|
m_pTransFindParm.WriteRecipe(pPacket);
|
m_pRefFindParm.WriteRecipe(pPacket);
|
return TRUE;
|
}
|
};
|
|
#endif
|
