#include "StdAfx.h"
|
#include "PostProcess.h"
|
#include "ResultData.h"
|
#include "FreeImage.h"
|
#include "ResultFile.h"
|
#include "Glass_Data.h"
|
#include "GlassRecipe.h"
|
#include "Transfer_Data.h"
|
#include "InspectCamera.h"
|
|
#define JPEG_RATE JPEG_QUALITYNORMAL|JPEG_OPTIMIZE
|
|
CPostProcess::CPostProcess(void)
|
{
|
InitPostProcessing();
|
m_pResultData = NULL;
|
}
|
|
CPostProcess::~CPostProcess(void)
|
{
|
}
|
|
void CPostProcess::SetInspectCamera(int iCam,CInspectCamera *pIns)
|
{
|
m_pInspectCamera[iCam] = pIns;
|
}
|
|
void CPostProcess::SetPrameter(CGlass_Data *pGlsData,CHardwareSettings *pHW,CGlassRecipe *pRecipe,CInspectOption *pInsOpt,CProfileOption *pProfileOpt,CTransfer_Data *pTransData,CResultData *pResultData)
|
{
|
m_pGlassData = pGlsData;
|
m_pHardware = pHW;
|
m_pRecipe = pRecipe;
|
m_pInspectOpt = pInsOpt;
|
m_pProfileOpt = pProfileOpt;
|
m_pTransData = pTransData;
|
m_pResultData = pResultData;
|
}
|
|
BOOL CPostProcess::InitPostProcessing()
|
{
|
m_pGlassData = NULL;
|
m_pHardware = NULL;
|
m_pRecipe = NULL;
|
|
for(int i=0;i<MAX_CAMERA_COUNT;i++)
|
{
|
m_pInspectCamera[i] = NULL;
|
}
|
|
return TRUE;
|
}
|
|
BOOL CPostProcess::ProcessingScanEnd()
|
{
|
|
return TRUE;
|
}
|
|
void CPostProcess::SetResultData()
|
{
|
m_pResultData->m_strRecipeName.Format(_T("%s"), m_pRecipe->GetRecipeName());
|
m_pResultData->m_strScanStartTime.Format(_T("%s"),m_pGlassData->GetLoadingTime());
|
m_pResultData->m_strScanEndTime.Format(_T("%s"),m_pGlassData->GetScanEndTime());
|
}
|
|
void CPostProcess::AddHistoryData(HISTORY_RESULT Data)
|
{
|
m_HistoryData = Data;
|
}
|
|
BOOL CPostProcess::RunPostProcessing()
|
{
|
g_pLog->DisplayMessage(_T("Start RunPostProcessing"));
|
|
if(m_pGlassData == NULL)
|
{
|
g_pLog->DisplayMessage(_T("Glass Data is NULL"));
|
return FALSE;
|
}
|
|
CreateDataDirectory();
|
|
m_pResultData->Reset();
|
m_pResultData->SetInspectOpt(m_pInspectOpt,m_pProfileOpt);
|
|
SetResultData();
|
|
MergeDefect();
|
|
int nDefectCount = GetInspectionDefect(m_pGlassData->GetMapDefect());
|
g_pLog->DisplayMessage(_T("Total Defect Count : Tot %d, Defect %d"),m_pGlassData->GetTotalDefectCount(),m_pGlassData->GetJudgeDefectCount());
|
|
m_pResultData->SetDefectIns(m_pGlassData->GetMapDefect(),nDefectCount);
|
|
return TRUE;
|
}
|
|
void CPostProcess::RunPostProcessing_SaveDefectInfo()
|
{
|
int nDefectCount = m_pGlassData->GetJudgeDefectCount();
|
SaveProfileData();
|
SaveChamferData(TRUE);
|
SaveChamferData(FALSE);
|
SaveDefectData(nDefectCount);
|
}
|
|
void CPostProcess::SaveDefectData(int nDefect)
|
{
|
int iDefect = 0;
|
CInspectDefect *pDefect;
|
MapDefectIt it;
|
MapDefect *pMapDefect = m_pGlassData->GetMapDefect();
|
|
CString glass_id;
|
glass_id.Format(_T("%s"), g_pBase->m_strHPanelID);
|
|
if (glass_id.IsEmpty() == TRUE)
|
{
|
glass_id.Format(_T("MANUAL_ID"));
|
}
|
|
CString defect_data,strValue;
|
CString strTime = g_pBase->m_strLoadingTime;
|
|
for(it=pMapDefect->begin();it!=pMapDefect->end();it++,iDefect++)
|
{
|
pDefect = static_cast<CInspectDefect*>(it->second);
|
if(pDefect == NULL)
|
continue;
|
if(pDefect->m_bJudgeDefect == FALSE)
|
continue;
|
|
switch(pDefect->m_sDefectLoc)
|
{
|
case 0: strValue.Format(_T("Crack")); break;
|
case 1: strValue.Format(_T("Broken")); break;
|
case 2: strValue.Format(_T("Chip")); break;
|
case 3: strValue.Format(_T("Chamfer")); break;
|
case 4: strValue.Format(_T("Burr")); break;
|
case 5: strValue.Format(_T("Thin")); break;
|
case 6: strValue.Format(_T("Area")); break;
|
case 7: strValue.Format(_T("NCut")); break;
|
case 8: strValue.Format(_T("CCD Hole")); break;
|
case 9: strValue.Format(_T("Profile")); break;
|
case 10: strValue.Format(_T("KDist")); break;
|
case 11: strValue.Format(_T("RCUTChip")); break;
|
default: strValue.Format(_T("Unknown")); break;
|
}
|
|
CString strEqip,strUnit,strInsGrind,strRoughPadLayer,strRoughPadCount,strRoughNonPadLayer,strRoughNonPadCount;
|
CString strPrePadLayer,strPrePadCount,strPreNonPadLayer,strPreNonPadCount;
|
|
CTransfer_Data *pTrans = m_pTransData;
|
if(pTrans != NULL)
|
{
|
strEqip.Format(_T("%d"),pTrans->m_nEqpNo);
|
strUnit.Format(_T("%d"),pTrans->m_nUnitNo);
|
strInsGrind.Format(_T("%d"),pTrans->m_nisGrind);
|
strRoughPadLayer.Format(_T("%d"),pTrans->m_nRoughPadLayer);
|
strRoughPadCount.Format(_T("%d"),pTrans->m_nRoughPadCount);
|
strRoughNonPadLayer.Format(_T("%d"),pTrans->m_nRoughNonPadLayer);
|
strRoughNonPadCount.Format(_T("%d"),pTrans->m_nRoughNonPadCount);
|
strPrePadLayer.Format(_T("%d"),pTrans->m_nPrePadLayer);
|
strPrePadCount.Format(_T("%d"),pTrans->m_nPrePadCount);
|
strPreNonPadLayer.Format(_T("%d"),pTrans->m_nPreNonPadLayer);
|
strPreNonPadCount.Format(_T("%d"),pTrans->m_nPreNonPadCount);
|
}
|
else
|
{
|
strEqip.Format(_T("%d"),0);
|
strUnit.Format(_T("%d"),0);
|
strInsGrind.Format(_T("%d"),0);
|
strRoughPadLayer.Format(_T("%d"),0);
|
strRoughPadCount.Format(_T("%d"),0);
|
strRoughNonPadLayer.Format(_T("%d"),0);
|
strRoughNonPadCount.Format(_T("%d"),0);
|
strPrePadLayer.Format(_T("%d"),0);
|
strPrePadCount.Format(_T("%d"),0);
|
strPreNonPadLayer.Format(_T("%d"),0);
|
strPreNonPadCount.Format(_T("%d"),0);
|
}
|
|
defect_data.AppendFormat(_T("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%d,%d,%d,%d,%s,"),
|
strTime,
|
glass_id,
|
strEqip,
|
strUnit,
|
strRoughPadLayer,
|
strRoughPadCount,
|
strRoughNonPadLayer,
|
strRoughNonPadCount,
|
strPrePadLayer,
|
strPrePadCount,
|
strPreNonPadLayer,
|
strPreNonPadCount,
|
PANEL_SIDE[pDefect->m_nSideLoc],
|
strValue,
|
pDefect->m_nUMOriginY, pDefect->m_nUMOriginX,
|
pDefect->m_nUMSizeY, pDefect->m_nUMSizeX,
|
pDefect->m_strDefectPath);
|
|
defect_data.Append(_T("\r\n"));
|
}
|
|
CString Defect_file_path;
|
|
Defect_file_path.Format(_T("%s\\%s_DefectData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay);
|
CheckDirectory(Defect_file_path);
|
|
CFile file_module;
|
CFileException file_exception;
|
|
file_module.Open(Defect_file_path, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &file_exception);
|
|
if(file_exception.m_cause == CFileException::none)
|
{
|
if(file_module.SeekToEnd() == 0L)
|
{
|
CString defect_title;
|
defect_title.Format(_T("TIME,ID,EQP NO,UNIT NO,ROUGH PAD LAYER 1,ROUGH PAD COUNT 1,ROUGH NON PAD LAYER 1,ROUGH NON PAD COUNT 1,ROUGH PAD LAYER 2,ROUGH PAD COUNT 2,ROUGH NON PAD LAYER 2,ROUGH NON PAD COUNT 2,SIDE,CAT,POS_X,POS_Y,WIDTH,HEIGHT,IMAGE_PATH\r\n"));
|
file_module.Write(defect_title, defect_title.GetLength()*sizeof(TCHAR));
|
}
|
file_module.Write(defect_data, defect_data.GetLength()*sizeof(TCHAR));
|
file_module.Close();
|
}
|
}
|
|
void CPostProcess::SaveProfileData()
|
{
|
CString glass_id;
|
glass_id.Format(_T("%s"), g_pBase->m_strHPanelID);
|
|
if (glass_id.IsEmpty() == TRUE)
|
{
|
glass_id.Format(_T("MANUAL_ID"));
|
}
|
|
CString profile_data;
|
CString strEqip,strUnit,strInsGrind,strRoughPadLayer,strRoughPadCount,strRoughNonPadLayer,strRoughNonPadCount;
|
CString strPrePadLayer,strPrePadCount,strPreNonPadLayer,strPreNonPadCount;
|
|
CTransfer_Data *pTrans = m_pTransData;
|
if(pTrans != NULL)
|
{
|
strEqip.Format(_T("%d"),pTrans->m_nEqpNo);
|
strUnit.Format(_T("%d"),pTrans->m_nUnitNo);
|
strInsGrind.Format(_T("%d"),pTrans->m_nisGrind);
|
strRoughPadLayer.Format(_T("%d"),pTrans->m_nRoughPadLayer);
|
strRoughPadCount.Format(_T("%d"),pTrans->m_nRoughPadCount);
|
strRoughNonPadLayer.Format(_T("%d"),pTrans->m_nRoughNonPadLayer);
|
strRoughNonPadCount.Format(_T("%d"),pTrans->m_nRoughNonPadCount);
|
strPrePadLayer.Format(_T("%d"),pTrans->m_nPrePadLayer);
|
strPrePadCount.Format(_T("%d"),pTrans->m_nPrePadCount);
|
strPreNonPadLayer.Format(_T("%d"),pTrans->m_nPreNonPadLayer);
|
strPreNonPadCount.Format(_T("%d"),pTrans->m_nPreNonPadCount);
|
}
|
else
|
{
|
strEqip.Format(_T("%d"),0);
|
strUnit.Format(_T("%d"),0);
|
strInsGrind.Format(_T("%d"),0);
|
strRoughPadLayer.Format(_T("%d"),0);
|
strRoughPadCount.Format(_T("%d"),0);
|
strRoughNonPadLayer.Format(_T("%d"),0);
|
strRoughNonPadCount.Format(_T("%d"),0);
|
strPrePadLayer.Format(_T("%d"),0);
|
strPrePadCount.Format(_T("%d"),0);
|
strPreNonPadLayer.Format(_T("%d"),0);
|
strPreNonPadCount.Format(_T("%d"),0);
|
}
|
|
CString strRet(_T("OK"));
|
if (m_HistoryData.bResult == FALSE)
|
{
|
strRet.Format(_T("NG"));
|
}
|
|
profile_data.Format(_T("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,"), g_pBase->m_strLoadingTime, glass_id, strRet, strEqip,
|
strUnit,
|
strRoughPadLayer,
|
strRoughPadCount,
|
strRoughNonPadLayer,
|
strRoughNonPadCount,
|
strPrePadLayer,
|
strPrePadCount,
|
strPreNonPadLayer,
|
strPreNonPadCount);
|
|
PROFILECHAMFER_RESULT_DATA *pResult = m_pGlassData->GetProfileInspectData();
|
|
for (BYTE loop_count=0; loop_count<MAX_PROFILE_SETTING_COUNT; loop_count++)
|
{
|
profile_data.AppendFormat(_T("%d,"), pResult->ProfileData[loop_count].nProfileDiff);
|
}
|
profile_data.Append(_T("\n"));
|
|
CString profile_file_path;
|
profile_file_path.Format(_T("%s\\%s_ProfileData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay);
|
CheckDirectory(profile_file_path);
|
|
CFile file_module;
|
CFileException file_exception;
|
|
file_module.Open(profile_file_path, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &file_exception);
|
|
if(file_exception.m_cause == CFileException::none)
|
{
|
if(file_module.SeekToEnd() == 0L)
|
{
|
CString profile_title;
|
profile_title.Format(_T("TIME,ID,NG/OK,EQP NO,UNIT NO,ROUGH PAD LAYER 1,ROUGH PAD COUNT 1,ROUGH NON PAD LAYER 1,ROUGH NON PAD COUNT 1,ROUGH PAD LAYER 2,ROUGH PAD COUNT 2,ROUGH NON PAD LAYER 2,ROUGH NON PAD COUNT 2,"));
|
|
for(BYTE header=1; header<(MAX_PROFILE_SETTING_COUNT+1); header++)
|
{
|
profile_title.AppendFormat(_T("%d,"),header);
|
}
|
|
profile_title.Append(_T("\r\n"));
|
file_module.Write(profile_title, profile_title.GetLength()*sizeof(TCHAR));
|
}
|
file_module.Write(profile_data, profile_data.GetLength()*sizeof(TCHAR));
|
file_module.Close();
|
}
|
}
|
|
void CPostProcess::SaveChamferData(BOOL bUp)
|
{
|
|
CString glass_id;
|
glass_id.Format(_T("%s"), g_pBase->m_strHPanelID);
|
|
if (glass_id.IsEmpty() == TRUE)
|
{
|
glass_id.Format(_T("MANUAL_ID"));
|
}
|
|
CString chamfer_data;
|
CString strEqip,strUnit,strInsGrind,strRoughPadLayer,strRoughPadCount,strRoughNonPadLayer,strRoughNonPadCount;
|
CString strPrePadLayer,strPrePadCount,strPreNonPadLayer,strPreNonPadCount;
|
|
CTransfer_Data *pTrans = m_pTransData;
|
if(pTrans != NULL)
|
{
|
strEqip.Format(_T("%d"),pTrans->m_nEqpNo);
|
strUnit.Format(_T("%d"),pTrans->m_nUnitNo);
|
strInsGrind.Format(_T("%d"),pTrans->m_nisGrind);
|
strRoughPadLayer.Format(_T("%d"),pTrans->m_nRoughPadLayer);
|
strRoughPadCount.Format(_T("%d"),pTrans->m_nRoughPadCount);
|
strRoughNonPadLayer.Format(_T("%d"),pTrans->m_nRoughNonPadLayer);
|
strRoughNonPadCount.Format(_T("%d"),pTrans->m_nRoughNonPadCount);
|
strPrePadLayer.Format(_T("%d"),pTrans->m_nPrePadLayer);
|
strPrePadCount.Format(_T("%d"),pTrans->m_nPrePadCount);
|
strPreNonPadLayer.Format(_T("%d"),pTrans->m_nPreNonPadLayer);
|
strPreNonPadCount.Format(_T("%d"),pTrans->m_nPreNonPadCount);
|
}
|
else
|
{
|
strEqip.Format(_T("%d"),0);
|
strUnit.Format(_T("%d"),0);
|
strInsGrind.Format(_T("%d"),0);
|
strRoughPadLayer.Format(_T("%d"),0);
|
strRoughPadCount.Format(_T("%d"),0);
|
strRoughNonPadLayer.Format(_T("%d"),0);
|
strRoughNonPadCount.Format(_T("%d"),0);
|
strPrePadLayer.Format(_T("%d"),0);
|
strPrePadCount.Format(_T("%d"),0);
|
strPreNonPadLayer.Format(_T("%d"),0);
|
strPreNonPadCount.Format(_T("%d"),0);
|
}
|
|
chamfer_data.Format(_T("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,"), g_pBase->m_strLoadingTime, glass_id,strEqip,
|
strUnit,
|
strRoughPadLayer,
|
strRoughPadCount,
|
strRoughNonPadLayer,
|
strRoughNonPadCount,
|
strPrePadLayer,
|
strPrePadCount,
|
strPreNonPadLayer,
|
strPreNonPadCount);
|
|
PROFILECHAMFER_RESULT_DATA *pResult = m_pGlassData->GetProfileInspectData();
|
|
for (BYTE loop_count=0; loop_count<MAX_PROFILE_SETTING_COUNT; loop_count++)
|
{
|
chamfer_data.AppendFormat(_T("%d,"), pResult->ResultChamfer[loop_count][bUp].nChamferCalThick);
|
}
|
chamfer_data.Append(_T("\n"));
|
|
CString profile_file_path;
|
if(bUp ==TRUE)
|
profile_file_path.Format(_T("%s\\%s_ChamferUpData.csv"),m_strResultFolder, g_pBase->m_strLoadingDay);
|
else
|
profile_file_path.Format(_T("%s\\%s_ChamferDownData.csv"),m_strResultFolder, g_pBase->m_strLoadingDay);
|
CheckDirectory(profile_file_path);
|
|
CFile file_module;
|
CFileException file_exception;
|
|
file_module.Open(profile_file_path, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &file_exception);
|
|
if(file_exception.m_cause == CFileException::none)
|
{
|
if(file_module.SeekToEnd() == 0L)
|
{
|
|
CString chamfer_title;
|
chamfer_title.Format(_T("TIME,ID,EQP NO,UNIT NO,ROUGH PAD LAYER 1,ROUGH PAD COUNT 1,ROUGH NON PAD LAYER 1,ROUGH NON PAD COUNT 1,ROUGH PAD LAYER 2,ROUGH PAD COUNT 2,ROUGH NON PAD LAYER 2,ROUGH NON PAD COUNT 2,"));
|
|
for(BYTE header=1; header<(MAX_PROFILE_SETTING_COUNT+1); header++)
|
{
|
chamfer_title.AppendFormat(_T("%d,"),header);
|
}
|
|
chamfer_title.Append(_T("\r\n"));
|
file_module.Write(chamfer_title, chamfer_title.GetLength()*sizeof(TCHAR));
|
}
|
file_module.Write(chamfer_data, chamfer_data.GetLength()*sizeof(TCHAR));
|
file_module.Close();
|
}
|
}
|
|
void CPostProcess::JudgementData()
|
{
|
if(m_pGlassData == NULL)
|
return;
|
|
PROFILECHAMFER_RESULT_DATA *pResult = m_pGlassData->GetProfileInspectData();
|
PROFILE_RESULT *pProfileRes;
|
int index;
|
|
for(index=0;index<MAX_PROFILE_SETTING_COUNT;index++)
|
{
|
pProfileRes = &pResult->ProfileData[index];
|
|
pProfileRes->bProfileJudge = TRUE;
|
if(pProfileRes->bUseJudge == TRUE)
|
{
|
if(pProfileRes->nProfileDiff < -1*pProfileRes->nJudgeMinus || pProfileRes->nProfileDiff > pProfileRes->nJudgePlus)
|
{
|
pProfileRes->bProfileJudge = FALSE;
|
}
|
}
|
|
for(int i=0;i<2;i++)
|
{
|
CHAMFER_RESULT *pChamferRes = &pResult->ResultChamfer[index][i];
|
pChamferRes->bChamferJudge = TRUE;
|
if(pChamferRes->bUseJudge == TRUE)
|
{
|
if(pChamferRes->nChamferThick < pChamferRes->nJudgeReference - pChamferRes->nJudgeMinusChamfer || pChamferRes->nChamferThick > pChamferRes->nJudgeReference+pChamferRes->nJudgePlusChamfer)
|
{
|
pChamferRes->bChamferJudge = FALSE;
|
//InsertManualDefect(pInspect,m_pHardware->GetCameraSettings(pProfileRes->iCam,pProfileRes->iScan),pProfileRes->iScan,pProfileRes->ptGlassStart.x,pProfileRes->ptGlassStart.y,DefectLoc_Chamfer);
|
}
|
}
|
}
|
}
|
}
|
|
BOOL CPostProcess::SaveDefectImage(LPBYTE pImage,CSize szImage,CRect rectDefect,CString strFile,DimensionDir emDir)
|
{
|
FIBITMAP *bitmap = NULL;
|
BYTE *pBitBuffer;
|
|
bitmap = FreeImage_Allocate(szImage.cx, szImage.cy,8);
|
|
pBitBuffer = FreeImage_GetBits(bitmap);
|
if(pBitBuffer == NULL)
|
{
|
FreeImage_Unload(bitmap);
|
return FALSE;
|
}
|
|
CopyMemory(pBitBuffer,pImage,szImage.cx*szImage.cy);
|
|
FIBITMAP *pBit24 = FreeImage_ConvertTo24Bits(bitmap);
|
if(pBit24 == NULL)
|
return FALSE;
|
|
char cFilePath[255];
|
|
#ifdef _UNICODE
|
int nSize = WideCharToMultiByte(CP_ACP, 0, strFile.GetBuffer(), -1, NULL, 0, NULL,NULL);
|
WideCharToMultiByte(CP_ACP, 0, strFile.GetBuffer(), -1, cFilePath, nSize, NULL, NULL);
|
#else
|
sprintf_s(cFilePath,sizeof(char)*255,_T("%s"),(LPSTR)(LPCTSTR)strFile);
|
#endif
|
|
FreeImage_FlipVertical(pBit24);
|
|
FreeImage_Save(FIF_JPEG, pBit24, cFilePath,JPEG_RATE);
|
|
FreeImage_Unload(bitmap);
|
FreeImage_Unload(pBit24);
|
|
|
return TRUE;
|
}
|
|
BOOL CPostProcess::SaveDefectImage2(LPBYTE pImage,CSize szImage,CRect rectDefect,CString strFile,DimensionDir emDir)
|
{
|
IplImage *pImageTmp = cvCreateImage(cvSize(szImage.cx, szImage.cy), 8,1);
|
cvZero(pImageTmp);
|
|
// add point to the image
|
for (int i = 0; i<szImage.cy; i++)
|
{
|
for (int j = 0; j<szImage.cx; j++)
|
{
|
pImageTmp->imageData[i*pImageTmp->widthStep+j] = pImage[i*szImage.cx+j];
|
}
|
}
|
|
IplImage *pColorImg = cvCreateImage(cvSize(szImage.cx, szImage.cy), 8, 3);
|
cvZero(pColorImg);
|
|
cvCvtColor(pImageTmp, pColorImg, CV_GRAY2BGR);
|
|
cvRectangle(pColorImg,CvPoint(rectDefect.left,rectDefect.top), CvPoint(rectDefect.left+rectDefect.Width(),rectDefect.top+rectDefect.Height()), cvScalar(0,0,255), 1);
|
|
USES_CONVERSION;
|
char str_filename[1024];
|
sprintf_s(str_filename, "%s", W2A(strFile));
|
cvSaveImage(str_filename, pColorImg);
|
|
cvReleaseImage(&pColorImg);
|
cvReleaseImage(&pImageTmp);
|
|
return TRUE;
|
}
|
|
void CPostProcess::GetJudgePrm(CDefect *pDefect,int &nJudgeW,int &nJudgeH,BOOL &bAnd,EM_CHIPPING_COMP &eComp,BOOL &bJudgeUse)
|
{
|
CINSPECT_JUDGEMENT_PARM *pJudge = m_pRecipe->GetJudgePrm();
|
|
nJudgeW = nJudgeH = 0;
|
bAnd = bJudgeUse = TRUE;
|
|
switch(pDefect->m_DefectLoc)
|
{
|
case DefectLoc_Chip:
|
nJudgeW = pJudge->defect[pDefect->m_nSideLoc][0].Chip_Side.szDefect.cx;
|
nJudgeH = pJudge->defect[pDefect->m_nSideLoc][0].Chip_Side.szDefect.cy;
|
bAnd = pJudge->defect[pDefect->m_nSideLoc][0].Chip_Side.bConditionAND;
|
bJudgeUse = pJudge->defect[pDefect->m_nSideLoc][0].Chip_Side.bError;
|
break;
|
case DefectLoc_Crack:
|
nJudgeW = pJudge->defect[pDefect->m_nSideLoc][0].Crack.szDefect.cx;
|
nJudgeH = pJudge->defect[pDefect->m_nSideLoc][0].Crack.szDefect.cy;
|
bAnd = pJudge->defect[pDefect->m_nSideLoc][0].Crack.bConditionAND;
|
bJudgeUse = pJudge->defect[pDefect->m_nSideLoc][0].Crack.bError;
|
break;
|
case DefectLoc_Broken:
|
nJudgeW = pJudge->defect[pDefect->m_nSideLoc][0].Broken.szDefect.cx;
|
nJudgeH = pJudge->defect[pDefect->m_nSideLoc][0].Broken.szDefect.cy;
|
bAnd = pJudge->defect[pDefect->m_nSideLoc][0].Broken.bConditionAND;
|
bJudgeUse = pJudge->defect[pDefect->m_nSideLoc][0].Broken.bError;
|
break;
|
case DefectLoc_Burr:
|
nJudgeW = pJudge->defect[pDefect->m_nSideLoc][0].Burr_Side.szDefect.cx;
|
nJudgeH = pJudge->defect[pDefect->m_nSideLoc][0].Burr_Side.szDefect.cy;
|
bAnd = pJudge->defect[pDefect->m_nSideLoc][0].Burr_Side.bConditionAND;
|
bJudgeUse = pJudge->defect[pDefect->m_nSideLoc][0].Burr_Side.bError;
|
break;
|
}
|
|
if(bAnd == TRUE)
|
eComp = CHIP_AND;
|
else
|
eComp = CHIP_OR;
|
}
|
|
int CPostProcess::GetInspectionDefect(MapDefect *mapDefectData)
|
{
|
if(m_pRecipe == NULL || m_pHardware == NULL)
|
return 0;
|
|
int nDefectCount = 0;
|
int iCam,iDefect;
|
CDefect *pDefect;
|
CHardwareSettings *pHard = m_pHardware;
|
CInspectDefect *pInsDefect = NULL;
|
int nResultCount = 0;
|
CString strFile;
|
CCameraSettings *pCamera = NULL;
|
|
int nJudgeW,nJudgeH;
|
BOOL bAnd,bJudgeUse;
|
EM_CHIPPING_COMP eComp;
|
double dScanRes = 0.,dConvRes = 0.;
|
BOOL bJudgeDefect;
|
int nStageNo = g_pBase->m_nStageNo;
|
|
if(nStageNo < 0 || nStageNo > 1)
|
nStageNo = 0;
|
|
for(iCam=0;iCam<pHard->GetCameraCount();iCam++)
|
{
|
nDefectCount = m_pInspectCamera[iCam]->GetDefectCount();
|
g_pLog->DisplayMessage(_T("[%d]Camera Defect Count : %d"), iCam,nDefectCount);
|
|
for(iDefect=0;iDefect<nDefectCount;iDefect++)
|
{
|
pDefect = m_pInspectCamera[iCam]->GetDefect(iDefect);
|
if(pDefect == NULL || pDefect->m_bRemoved == TRUE)
|
continue;
|
|
if(m_pGlassData->GetTotalDefectCount() >= MAX_DEFECT_COUNT)
|
return nResultCount;
|
|
GetJudgePrm(pDefect,nJudgeW,nJudgeH,bAnd,eComp,bJudgeUse);
|
if(bJudgeUse == FALSE)
|
continue;
|
|
pCamera = m_pHardware->GetCameraSettings(pDefect->m_nCamID,pDefect->m_nScanIdx);
|
if(pCamera == NULL)
|
continue;
|
|
dScanRes = pCamera->m_dScanResolution[nStageNo];
|
dConvRes = pCamera->m_dConvResolution[nStageNo];
|
if (dScanRes <= 0.0 || dConvRes <= 0)
|
continue;
|
|
if(pDefect->m_nSplineLoc == Spline_None)
|
{
|
bJudgeDefect = FALSE;
|
if(eComp == CHIP_AND)
|
{
|
if((double)pDefect->m_Defect.s_DefectRect.Width()*dConvRes >= nJudgeW && (double)pDefect->m_Defect.s_DefectRect.Height()*dScanRes >= nJudgeH)
|
bJudgeDefect = TRUE;
|
}
|
else if(eComp == CHIP_OR)
|
{
|
if((double)pDefect->m_Defect.s_DefectRect.Width()*dConvRes >= nJudgeW || (double)pDefect->m_Defect.s_DefectRect.Height()*dScanRes >= nJudgeH)
|
bJudgeDefect = TRUE;
|
}
|
else
|
continue;
|
}
|
else
|
{
|
bJudgeDefect = TRUE;
|
}
|
|
pInsDefect = new CInspectDefect;
|
|
pCamera = pHard->GetCameraSettings(iCam,pDefect->m_nScanIdx);
|
if(pCamera != NULL)
|
pInsDefect->m_nDir = (int)pCamera->m_enCamDir;
|
|
INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(pCamera->m_eDimension);
|
|
pInsDefect->m_nDefectIdx = pDefect->m_nIndex;
|
pInsDefect->m_nCameraID = iCam;
|
pInsDefect->m_nScanIdx = pDefect->m_nScanIdx;
|
pInsDefect->m_nPixelGlassStart = pEdgeInfo->nGlassStartLine;
|
pInsDefect->m_sDefectType = static_cast<short>(pDefect->m_Defect.s_DefectType);
|
pInsDefect->m_nPixelSize = pDefect->m_Defect.s_nDefectArea;
|
pInsDefect->SetPixelConv(pDefect->m_Defect.s_nDefectX);
|
pInsDefect->SetPixelScan(pDefect->m_Defect.s_nDefectY);
|
pInsDefect->m_nPixelConv = pDefect->m_Defect.s_DefectRect.left;
|
pInsDefect->m_nPixelScan = pDefect->m_Defect.s_DefectRect.top;
|
pInsDefect->m_sPixelWidth = pDefect->m_Defect.s_DefectRect.Width();
|
pInsDefect->m_sPixelHeight = pDefect->m_Defect.s_DefectRect.Height();
|
pInsDefect->m_nDefectRScale = pDefect->m_Defect.s_nDefectRScale;
|
|
pInsDefect->m_nLevelSrcMin = pDefect->m_Defect.s_sLevelSrcMin;
|
pInsDefect->m_nLevelSrcMax = pDefect->m_Defect.s_sLevelSrcMax;
|
pInsDefect->m_nLevelSrcAvg = pDefect->m_Defect.s_sLevelSrcAvg;
|
pInsDefect->m_nLevelRefMin = pDefect->m_Defect.s_sLevelRefMin;
|
pInsDefect->m_nLevelRefMax = pDefect->m_Defect.s_sLevelRefMax;
|
pInsDefect->m_nLevelRefAvg = pDefect->m_Defect.s_sLevelRefAvg;
|
pInsDefect->m_nLevelDiffMin = pDefect->m_Defect.s_sLevelDiffMin;
|
pInsDefect->m_nLevelDiffMax = pDefect->m_Defect.s_sLevelDiffMax;
|
pInsDefect->m_nLevelDiffAvg = pDefect->m_Defect.s_sLevelDiffAvg;
|
|
pInsDefect->m_sDefectLoc = static_cast<int>(pDefect->m_DefectLoc);
|
pInsDefect->m_sSplineLoc = static_cast<int>(pDefect->m_nSplineLoc);
|
pInsDefect->m_sThreshold = pDefect->m_Defect.s_sThreshold;
|
pInsDefect->m_sDefectPeak = pDefect->m_Defect.s_sDefectPeak;
|
pInsDefect->m_nSideLoc = (DimensionDir)pDefect->m_nSideLoc;
|
pInsDefect->m_dwTickCount = GetTickCount();
|
pInsDefect->m_bJudgeDefect = bJudgeDefect;
|
pInsDefect->m_nProfileIdx = pDefect->m_nProfileIndex;
|
|
if(DefectProcess(pInsDefect,m_pInspectCamera[iCam]) == FALSE)
|
{
|
delete pInsDefect, pInsDefect = NULL;
|
continue;
|
}
|
|
if(m_pGlassData->SetDefect(pInsDefect) == FALSE)
|
{
|
delete pInsDefect, pInsDefect = NULL;
|
continue;
|
}
|
|
if(pInsDefect->m_bJudgeDefect == TRUE)
|
{
|
CString str = _T("Unknown");
|
|
switch(pDefect->m_DefectLoc)
|
{
|
case DefectLoc_Crack: str=_T("Crack"); break;
|
case DefectLoc_Broken: str=_T("Broken"); break;
|
case DefectLoc_Chip:
|
{
|
if(pInsDefect->m_sSplineLoc == Spline_None)
|
str=_T("Chip");
|
else
|
str=_T("R_Chip");
|
break;
|
}
|
case DefectLoc_Chamfer: str=_T("Chamfer"); break;
|
case DefectLoc_Burr: str=_T("Burr"); break;
|
case DefectLoc_Thin: str=_T("Thin"); break;
|
case DefectLoc_Air: str=_T("Lifting"); break;
|
case DefectLoc_Notch: str=_T("NCut"); break;
|
case DefectLoc_Hole: str=_T("Hole"); break;
|
case DefectLoc_Profile: str=_T("Profile"); break;
|
case DefectLoc_KDist: str = _T("KDist"); break;
|
case DefectLoc_RCUTChip: str = _T("RCUTChip"); break;
|
}
|
|
strFile.Format(_T("%s\\%03d_%s_%s_%s.jpg"),m_strDefectFolder,pInsDefect->m_nGlassDefectIdx,g_pBase->m_strHPanelID,PANEL_SIDE[(DimensionDir)pDefect->m_nSideLoc],str);
|
|
CRect rectDefect;
|
rectDefect.left = DEFECTIMAGE_WIDTH/2-pInsDefect->m_sPixelWidth/2;
|
rectDefect.right = DEFECTIMAGE_WIDTH/2+pInsDefect->m_sPixelWidth/2;
|
rectDefect.top = DEFECTIMAGE_HEIGHT/2-pInsDefect->m_sPixelHeight/2;
|
rectDefect.bottom = DEFECTIMAGE_HEIGHT/2+pInsDefect->m_sPixelHeight/2;
|
|
CheckDirectory(strFile);
|
SaveDefectImage2(pDefect->m_Image,CSize(DEFECTIMAGE_WIDTH,DEFECTIMAGE_HEIGHT),rectDefect,strFile,(DimensionDir)pDefect->m_nSideLoc);
|
|
pInsDefect->m_strDefectPath = strFile;
|
}
|
nResultCount++;
|
}
|
}
|
|
return m_pGlassData->GetJudgeDefectCount();
|
}
|
|
BOOL CPostProcess::DefectProcess(CInspectDefect* pDefect,CInspectCamera *pInspect)
|
{
|
CGlassRecipe* pRecipe = m_pRecipe;
|
if(pRecipe == NULL)
|
return FALSE;
|
|
CCameraSettings *pCamera = m_pHardware->GetCameraSettings(pDefect->m_nCameraID,pDefect->m_nScanIdx);
|
if(pCamera == NULL)
|
return FALSE;
|
|
double dScanRes = 0.,dConvRes = 0.;
|
int nMarginLeft;
|
int nStageNo = g_pBase->m_nStageNo;
|
|
if(nStageNo < 0 || nStageNo > 1)
|
nStageNo = 0;
|
|
dScanRes = pCamera->m_dScanResolution[nStageNo];
|
dConvRes = pCamera->m_dConvResolution[nStageNo];
|
nMarginLeft = pCamera->m_nMarginLeft;
|
|
if (dScanRes <= 0.0 || dConvRes <= 0)
|
return FALSE;
|
|
pDefect->m_nUMOriginX = (int)((double)(pDefect->GetPixelScan() - pDefect->m_nPixelGlassStart) * dScanRes);
|
pDefect->m_nUMOriginY = (int)(((double)(pDefect->GetPixelConv()) * dConvRes));
|
|
pDefect->m_nUMSizeX = (int)((double)pDefect->m_sPixelHeight * dScanRes);
|
pDefect->m_nUMSizeY = (int)((double)pDefect->m_sPixelWidth * dConvRes);
|
pDefect->m_nUMSize =(int)((double)pDefect->m_nPixelSize * dScanRes * dConvRes);
|
|
if(pDefect->m_nUMOriginX <= -1 || pDefect->m_nUMOriginY <= -1)
|
return FALSE;
|
|
return TRUE;
|
}
|
|
void CPostProcess::CalcGlassSize()
|
{
|
int iCam,iScan;
|
CHardwareSettings *pHard = m_pHardware;
|
CCameraSettings *pCamera;
|
double dGlasssizeY[2],dGlasssizeX[2];
|
double dGlassSizeSumY[2],dGlassSizeCntY[2];
|
double dDist;
|
CAMERA_SCANDIR ScanDirection;
|
double dScanRes;
|
double dConvRes;
|
int nStageNo = g_pBase->m_nStageNo;
|
|
if(nStageNo < 0 || nStageNo > 1)
|
nStageNo = 0;
|
|
for(iCam=0;iCam<pHard->GetCameraCount();iCam++)
|
{
|
for(iScan=0;iScan<pHard->GetScanCount();iScan++)
|
{
|
pCamera = pHard->GetCameraSettings(iCam,iScan);
|
if(pCamera == NULL)
|
continue;
|
|
ZeroMemory(dGlasssizeY,sizeof(double)*2);
|
ZeroMemory(dGlasssizeX,sizeof(double)*2);
|
|
INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(pCamera->m_eDimension);
|
|
dGlasssizeX[0] = pEdgeInfo->nGlassEdgeXPos[0];
|
dGlasssizeX[1] = pEdgeInfo->nGlassEdgeXPos[1];
|
dGlasssizeY[0] = pEdgeInfo->nGlassStartLine;
|
dGlasssizeY[1] = pEdgeInfo->nGlassEndLine;
|
|
dScanRes = pCamera->m_dScanResolution[nStageNo];
|
dConvRes = pCamera->m_dConvResolution[nStageNo];
|
|
dDist = sqrt(pow((dGlasssizeX[0]*dConvRes-dGlasssizeX[1]*dConvRes),2) + pow((dGlasssizeY[0]*dScanRes-dGlasssizeY[1]*dScanRes),2));
|
if(dDist > 0)
|
{
|
ScanDirection = pCamera->m_eScanDir;
|
dGlassSizeCntY[(int)ScanDirection]++;
|
dGlassSizeSumY[(int)ScanDirection] += dDist;
|
}
|
}
|
}
|
|
// Glass Size
|
for(int i=0;i<2;i++)
|
{
|
if(dGlassSizeCntY[i] > 0)
|
m_pResultData->m_dGlassSize[i] = dGlassSizeSumY[i]/dGlassSizeCntY[i];
|
}
|
}
|
|
void CPostProcess::MergeDefect()
|
{
|
int iCam,iDefect,iDefectDest;
|
int nDefectCount;
|
CDefect *pDefect,*pDefectDest;
|
int nMergeDistX,nMergeDistY;
|
int nRemoveCount = 0;
|
CRect rect,rectOrg,rectTgt;
|
CHardwareSettings *pHard = m_pHardware;
|
CGlassRecipe *pGlsRcp = m_pRecipe;
|
|
if(pGlsRcp == NULL)
|
return;
|
|
nMergeDistX = nMergeDistY = 5;
|
|
for(iCam=0;iCam<pHard->GetCameraCount();iCam++)
|
{
|
nDefectCount = m_pInspectCamera[iCam]->GetDefectCount();
|
|
for(iDefect=0;iDefect<nDefectCount-1;iDefect++)
|
{
|
pDefect = m_pInspectCamera[iCam]->GetDefect(iDefect);
|
if(pDefect == NULL)
|
continue;
|
|
if(pDefect->m_bRemoved == TRUE)
|
continue;
|
|
if(pDefect->m_DefectLoc == DefectLoc_Chamfer || pDefect->m_DefectLoc == DefectLoc_Profile)
|
continue;
|
|
if (pDefect->m_DefectLoc == DefectLoc_Hole || pDefect->m_DefectLoc == DefectLoc_KDist || pDefect->m_DefectLoc == DefectLoc_RCUTChip)
|
continue;
|
|
rectOrg = pDefect->m_Defect.s_DefectRect;
|
rectOrg.InflateRect(nMergeDistX,nMergeDistY);
|
|
for(iDefectDest=iDefect+1;iDefectDest<nDefectCount;iDefectDest++)
|
{
|
pDefectDest = m_pInspectCamera[iCam]->GetDefect(iDefectDest);
|
if(pDefectDest == NULL)
|
continue;
|
|
if(pDefectDest->m_nScanIdx != pDefect->m_nScanIdx)
|
continue;
|
|
if(pDefectDest->m_bRemoved == TRUE)
|
continue;
|
|
if(pDefectDest->m_nCamDir != pDefect->m_nCamDir)
|
continue;
|
|
if(pDefectDest->m_DefectLoc == DefectLoc_Chamfer || pDefectDest->m_DefectLoc == DefectLoc_Profile)
|
continue;
|
|
rectTgt = pDefectDest->m_Defect.s_DefectRect;
|
|
if(rect.IntersectRect(rectOrg,rectTgt) == TRUE)
|
{
|
pDefect->m_Defect.MergeBlob(pDefectDest->m_Defect);
|
|
if(pDefect->m_DefectLoc == DefectLoc_Chip)
|
{
|
if(pDefectDest->m_DefectLoc == DefectLoc_Crack || pDefectDest->m_DefectLoc == DefectLoc_Broken)
|
pDefect->m_DefectLoc = pDefectDest->m_DefectLoc;
|
}
|
else if(pDefect->m_DefectLoc == DefectLoc_Crack)
|
{
|
if(pDefectDest->m_DefectLoc == DefectLoc_Broken)
|
pDefect->m_DefectLoc = pDefectDest->m_DefectLoc;
|
}
|
|
pDefectDest->m_bRemoved = TRUE;
|
nRemoveCount++;
|
}
|
}
|
}
|
}
|
|
g_pLog->DisplayMessage(_T("Defect Merge Count : %d"), nRemoveCount);
|
}
|
|
void CPostProcess::JudgeThinCrackDefect()
|
{
|
int iCam,iDefect;
|
int nDefectCount;
|
int nJudgeCount = 0;
|
CDefect *pDefect;
|
CHardwareSettings *pHard = m_pHardware;
|
CGlassRecipe *pGlsRcp = m_pRecipe;
|
if(pGlsRcp == NULL)
|
return;
|
|
for(iCam=0;iCam<pHard->GetCameraCount();iCam++)
|
{
|
nDefectCount = m_pInspectCamera[iCam]->GetDefectCount();
|
|
for(iDefect=0;iDefect<nDefectCount;iDefect++)
|
{
|
pDefect = m_pInspectCamera[iCam]->GetDefect(iDefect);
|
if(pDefect == NULL)
|
continue;
|
|
if(pDefect->m_bRemoved == TRUE)
|
continue;
|
|
if(pDefect->m_bThinCrackDefect == FALSE)
|
continue;
|
|
if(Judge_CornerChip_Item_ThinCrack(pDefect,iCam) == FALSE)
|
{
|
pDefect->m_bRemoved = TRUE;
|
}
|
else
|
{
|
nJudgeCount++;
|
pDefect->m_DefectLoc = DefectLoc_Thin;
|
}
|
}
|
}
|
|
g_pLog->DisplayMessage(_T("Thin Crack Count : %d"), nJudgeCount);
|
}
|
|
BOOL CPostProcess::Judge_CornerChip_Item_ThinCrack(CDefect* pDefect,int nCamIdx)
|
{
|
CHardwareSettings *pHard = m_pHardware;
|
CCameraSettings *pCamera;
|
|
pCamera = pHard->GetCameraSettings(nCamIdx,pDefect->m_nScanIdx);
|
if(pCamera == NULL)
|
return FALSE;
|
|
int nStageNo = g_pBase->m_nStageNo;
|
|
if(nStageNo < 0 || nStageNo > 1)
|
nStageNo = 0;
|
|
double dScanRes = pCamera->m_dScanResolution[nStageNo];
|
double dConvRes = pCamera->m_dConvResolution[nStageNo];
|
EM_CHIPPING_COMP emComp = CHIP_OR;
|
|
//Length and Depth
|
CINSPECT_JUDGEMENT_PARM *pJudgePrm = m_pRecipe->GetJudgePrm();
|
|
if(pJudgePrm->bUseLengthDepthComp)
|
{
|
//and
|
if(emComp == CHIP_AND)
|
{
|
if((double)pDefect->m_Defect.s_DefectRect.Width()*dConvRes >= pJudgePrm->nCornerJugeDepth && (double)pDefect->m_Defect.s_DefectRect.Height()*dScanRes >= pJudgePrm->nCornerJugeLength)
|
return TRUE;
|
}
|
else if(emComp == CHIP_OR)
|
{
|
if((double)pDefect->m_Defect.s_DefectRect.Width()*dConvRes >= pJudgePrm->nCornerJugeDepth || (double)pDefect->m_Defect.s_DefectRect.Height()*dScanRes >= pJudgePrm->nCornerJugeLength)
|
return TRUE;
|
}
|
}
|
|
return FALSE;
|
}
|
|
BOOL CPostProcess::CreateDataDirectory()
|
{
|
m_strResultFolder.Format(_T("%sDATA_RESULT"),PATH_INSPECTION_DATA);
|
CheckDirectory(m_strResultFolder);
|
m_strDefectFolder.Format(_T("%sIMG_DEFECT\\%s\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID,g_pBase->m_strLoadingTime);
|
CheckDirectory(m_strDefectFolder);
|
m_strSplineFolder.Format(_T("%sSPLINE\\%s\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID,g_pBase->m_strLoadingTime);
|
CheckDirectory(m_strSplineFolder);
|
m_strFullImgeFolder.Format(_T("%sIMG_FULL\\%s\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID,g_pBase->m_strLoadingTime);
|
CheckDirectory(m_strFullImgeFolder);
|
m_strImageMarkFolder.Format(_T("%sIMG_MARK\\%s\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID,g_pBase->m_strLoadingTime);
|
CheckDirectory(m_strImageMarkFolder);
|
|
return TRUE;
|
}
|
|
BOOL CPostProcess::CheckDirectory(const TCHAR szPathName[])
|
{
|
CFileFind finder;
|
CString strTemp;
|
CString strDir = szPathName;
|
int nPos;
|
if (finder.FindFile(szPathName) == FALSE)
|
{
|
nPos = strDir.Find(_T("\\"));
|
nPos = strDir.Find(_T("\\"), nPos+1);
|
while(nPos > 0)
|
{
|
strTemp = strDir.Mid(0,nPos);
|
if(0 < strTemp.GetLength())
|
{
|
if(CString("\\") == strTemp.GetAt(strTemp.GetLength()-1))
|
{
|
nPos = strDir.Find(_T("\\"), nPos+1);
|
continue;
|
}
|
}
|
if (finder.FindFile(strTemp) == FALSE)
|
{
|
if(::CreateDirectory(strTemp, NULL) == FALSE)
|
{
|
strTemp.Format(_T("[%s]Folder Create Fail. "), szPathName);
|
|
//LogMessage(strTemp, 2);
|
return FALSE;
|
}
|
}
|
nPos = strDir.Find(_T("\\"), nPos+1);
|
}
|
}
|
return TRUE;
|
}
|
|
CString CPostProcess::GetResultPath(EM_RESULT_PATH ePath)
|
{
|
CString str;
|
|
switch(ePath)
|
{
|
case EM_RESULT_FILE: str=m_strResultFolder; break;
|
case EM_RESULT_DEFECT: str=m_strDefectFolder; break;
|
case EM_RESULT_SPLINE: str=m_strSplineFolder; break;
|
case EM_RESULT_FULL: str=m_strFullImgeFolder; break;
|
case EM_RESULT_MARK: str=m_strImageMarkFolder; break;
|
}
|
|
return str;
|
}
|
