#include "StdAfx.h"
|
#include "ResultData.h"
|
|
CResultData::CResultData(void)
|
{
|
m_pInspectOpt = NULL;
|
m_pProfileOpt = NULL;
|
}
|
|
CResultData::~CResultData(void)
|
{
|
}
|
|
void CResultData::Reset()
|
{
|
m_bGlassResult = TRUE;
|
|
m_strPCID = m_strScanStartTime = m_strScanEndTime = m_strRecipeName = _T("");
|
|
int i,j;
|
|
for(i=0;i<2;i++)
|
{
|
m_bNCutSize[i] = TRUE;
|
m_bNCutThick[i] = TRUE;
|
|
for(j=0;j<2;j++)
|
{
|
m_bCornerResWidth[i][j] = TRUE;
|
m_bCornerResHeight[i][j] = TRUE;
|
m_bSplineRes[i][j] = TRUE;
|
m_nCornerImageCamIdx[i][j] = -1;
|
}
|
for(j=0;j<MAX_DIMENSION_COUNT;j++)
|
{
|
m_bCutAreaRes[i][j] = TRUE;
|
m_bDimensionRes[j] = TRUE;
|
m_bCutAreaDiagonalLine[i][j] = TRUE;//20140622
|
}
|
}
|
ZeroMemory(m_dCutAreaPoint,sizeof(double)*2*MAX_DIMENSION_COUNT*RUSULT_POINT_COUNT);
|
ZeroMemory(m_dCutAreaAvg,sizeof(double)*2*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dCutAreaDiagonalLine,sizeof(double)*2*MAX_DIMENSION_COUNT);//20140622
|
|
ZeroMemory(m_dDimensionAvg,sizeof(double)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dDimensionPoint,sizeof(double)*MAX_DIMENSION_COUNT*RUSULT_POINT_COUNT);
|
ZeroMemory(m_dGlassSize,sizeof(double)*2);
|
|
ZeroMemory(m_dSplineAvg,sizeof(double)*4);
|
ZeroMemory(m_dSplineMaxDefect,sizeof(double)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dSplinePoint,sizeof(double)*4*RUSULT_POINT_COUNT);
|
|
ZeroMemory(m_bUseNCutChip,sizeof(BOOL)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_bUseNCutSize,sizeof(BOOL)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dNCutX,sizeof(double)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dNCutY,sizeof(double)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dNCutDiff,sizeof(double)*MAX_DIMENSION_COUNT);
|
ZeroMemory(m_dNCutThick,sizeof(double)*2);
|
ZeroMemory(m_dNCutAvg,sizeof(double)*2);
|
ZeroMemory(m_pointCAD,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
ZeroMemory(m_pointIMG,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
ZeroMemory(m_dNCutRange,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
|
ZeroMemory(m_pointCAD_Dy,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
ZeroMemory(m_pointIMG_Dy,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
ZeroMemory(m_dNCutRange_Dy,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
|
ZeroMemory(m_pointCAD_Cham,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
ZeroMemory(m_pointIMG_Cham,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
ZeroMemory(m_dNCutRange_Cham,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
|
for (int k=0; k<2; k++)//20140528
|
{
|
for(int j=0;j<MAX_DIMENSION_COUNT;j++)
|
{
|
for (int i=0; i<NOTCH_RANGE_VAL_MAX_COUNT; i++)
|
{
|
m_bNCutRange[k][j][i] = TRUE;
|
m_bNCutRange_Dy[k][j][i] = TRUE;
|
m_bNCutRange_Cham[k][j][i] = TRUE;
|
}
|
}
|
}
|
|
ZeroMemory(m_nNotchInsCount,sizeof(int)*MAX_DIMENSION_COUNT);//20140528
|
|
ZeroMemory(m_bUseNotchPointIns_Dimen,sizeof(BOOL)*MAX_DIMENSION_COUNT);//20140721
|
ZeroMemory(m_bUseNotchPointIns_Cham,sizeof(BOOL)*MAX_DIMENSION_COUNT);//20140721
|
|
ZeroMemory(m_dCornerWidth,sizeof(double)*4);
|
ZeroMemory(m_dCornerHeight,sizeof(double)*4);
|
|
ZeroMemory(m_dDefectPosMax,sizeof(double)*MAX_DIMENSION_COUNT);
|
|
m_nDefectCnt = 0;
|
m_pDefectIns = NULL;
|
m_nMaxDefectCam = 0;
|
m_nErrorCountCF = m_nErrorCountTFT = 0;
|
m_nCrackCount = m_nBrokenCount = m_nChipCount = m_nChamferCount = m_nBurrCount = m_nUnknownCount = 0;
|
}
|
|
CResultData& CResultData::operator=(CResultData& rh)
|
{
|
if(this != &rh)
|
{
|
Reset();
|
|
m_bGlassResult = rh.m_bGlassResult;
|
|
m_strPCID = rh.m_strPCID;
|
m_strScanStartTime = rh.m_strScanStartTime;
|
m_strScanEndTime = rh.m_strScanEndTime;
|
m_strRecipeName = rh.m_strRecipeName;
|
|
CopyMemory(m_bCutAreaRes,rh.m_bCutAreaRes,sizeof(BOOL)*2*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dCutAreaPoint,rh.m_dCutAreaPoint,sizeof(double)*2*MAX_DIMENSION_COUNT*RUSULT_POINT_COUNT);
|
CopyMemory(m_dCutAreaAvg,rh.m_dCutAreaAvg,sizeof(double)*2*MAX_DIMENSION_COUNT);//20140622
|
|
CopyMemory(m_bCutAreaDiagonalLine,rh.m_bCutAreaDiagonalLine,sizeof(BOOL)*2*MAX_DIMENSION_COUNT);//20140622
|
CopyMemory(m_dCutAreaDiagonalLine,rh.m_dCutAreaDiagonalLine,sizeof(double)*2*MAX_DIMENSION_COUNT);//20140622
|
|
CopyMemory(m_bDimensionRes,rh.m_bDimensionRes,sizeof(BOOL)*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dDimensionAvg,rh.m_dDimensionAvg,sizeof(double)*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dDimensionPoint,rh.m_dDimensionPoint,sizeof(double)*MAX_DIMENSION_COUNT*RUSULT_POINT_COUNT);
|
|
CopyMemory(m_bSplineRes,rh.m_bSplineRes,sizeof(BOOL)*4);
|
CopyMemory(m_dSplineAvg,rh.m_dSplineAvg,sizeof(double)*4);
|
CopyMemory(m_dSplineMaxDefect,rh.m_dSplineMaxDefect,sizeof(double)*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dSplinePoint,rh.m_dSplinePoint,sizeof(double)*4*RUSULT_POINT_COUNT);
|
|
CopyMemory(m_bNCutSize,rh.m_bNCutSize,sizeof(BOOL)*2);
|
CopyMemory(m_bNCutThick,rh.m_bNCutThick,sizeof(BOOL)*2);
|
CopyMemory(m_dNCutX,rh.m_dNCutX,sizeof(double)*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dNCutY,rh.m_dNCutY,sizeof(double)*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dNCutDiff,rh.m_dNCutDiff,sizeof(double)*MAX_DIMENSION_COUNT);
|
CopyMemory(m_dNCutThick,rh.m_dNCutThick,sizeof(double)*2);
|
CopyMemory(m_dNCutAvg,rh.m_dNCutAvg,sizeof(double)*2);
|
CopyMemory(m_pointCAD,rh.m_pointCAD,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_pointIMG,rh.m_pointIMG,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_dNCutRange,rh.m_dNCutRange,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_bNCutRange,rh.m_bNCutRange,sizeof(BOOL)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
|
CopyMemory(m_pointCAD_Dy,rh.m_pointCAD_Dy,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_pointIMG_Dy,rh.m_pointIMG_Dy,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_dNCutRange_Dy,rh.m_dNCutRange_Dy,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_bNCutRange_Dy,rh.m_bNCutRange_Dy,sizeof(BOOL)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
|
CopyMemory(m_pointCAD_Cham,rh.m_pointCAD_Cham,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_pointIMG_Cham,rh.m_pointIMG_Cham,sizeof(CPoint)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_dNCutRange_Cham,rh.m_dNCutRange_Cham,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
CopyMemory(m_bNCutRange_Cham,rh.m_bNCutRange_Cham,sizeof(double)*2*MAX_DIMENSION_COUNT*NOTCH_RANGE_VAL_MAX_COUNT);//20140528
|
|
CopyMemory(m_nNotchInsCount,rh.m_nNotchInsCount,sizeof(int)*MAX_DIMENSION_COUNT);//20140528
|
|
CopyMemory(m_bCornerResWidth,rh.m_bCornerResWidth,sizeof(BOOL)*4);
|
CopyMemory(m_bCornerResHeight,rh.m_bCornerResHeight,sizeof(BOOL)*4);
|
CopyMemory(m_dCornerWidth,rh.m_dCornerWidth,sizeof(double)*4);
|
CopyMemory(m_dCornerHeight,rh.m_dCornerHeight,sizeof(double)*4);
|
CopyMemory(m_nCornerImageCamIdx,rh.m_nCornerImageCamIdx,sizeof(int)*4);
|
|
CopyMemory(m_dDefectPosMax,rh.m_dDefectPosMax,sizeof(double)*MAX_DIMENSION_COUNT);
|
m_nMaxDefectCam = rh.m_nMaxDefectCam;
|
m_nDefectCnt = rh.m_nDefectCnt;
|
m_pDefectIns = rh.m_pDefectIns;
|
m_nErrorCountCF = rh.m_nErrorCountCF;
|
m_nErrorCountTFT = rh.m_nErrorCountTFT;
|
m_nCrackCount = rh.m_nCrackCount;
|
m_nBrokenCount = rh.m_nBrokenCount;
|
m_nChipCount = rh.m_nChipCount;
|
m_nChamferCount = rh.m_nChamferCount;
|
m_nBurrCount = rh.m_nBurrCount;
|
m_nUnknownCount = rh.m_nUnknownCount;
|
|
CopyMemory(m_nLeftLineMargin,rh.m_nLeftLineMargin,sizeof(int)*MAX_DIMENSION_COUNT*2);
|
}
|
return *this;
|
}
|
|
void CResultData::TrimString()
|
{
|
m_strPCID.TrimLeft(_T(" "));m_strPCID.TrimRight(_T(" "));
|
m_strScanStartTime.TrimLeft(_T(" "));m_strScanStartTime.TrimRight(_T(" "));
|
m_strScanEndTime.TrimLeft(_T(" "));m_strScanEndTime.TrimRight(_T(" "));
|
m_strRecipeName.TrimLeft(_T(" "));m_strRecipeName.TrimRight(_T(" "));
|
}
|
|
double CResultData::GetCutAreaAvg(std::vector<STU_THICKPOS*> *pCamThick,CAMERA_DIR camDir)
|
{
|
if(pCamThick == NULL || (int)pCamThick->size() <= 0)
|
return 0.;
|
|
double dSum,dCnt;
|
std::vector<STU_THICKPOS*>::iterator it;
|
STU_THICKPOS *pThick;
|
|
dSum = dCnt = 0.;
|
|
for(it=pCamThick->begin();it!=pCamThick->end();it++)
|
{
|
pThick = *it;
|
if(pThick == NULL || pThick->dThick <= 0)
|
continue;
|
|
switch(camDir)
|
{
|
case CAMDIR_TOP:
|
dSum += pThick->dThick;
|
dCnt++;
|
break;
|
case CAMDIR_BOTTOM:
|
dSum += pThick->dThick;
|
dCnt++;
|
break;
|
}
|
}
|
|
return dCnt > 0?dSum/dCnt:0.;
|
}
|
|
BOOL CResultData::GetRangeCheck(int nBase,int nMinus,int nPlus,int nValue)
|
{
|
if(nValue > nBase+nPlus || nValue < nBase-nMinus)
|
return FALSE;
|
|
return TRUE;
|
}
|
|
double CResultData::GetCutAreaStdDev(std::vector<STU_THICKPOS*> *pCamThick,CAMERA_DIR camDir,double dAvg)
|
{
|
if(pCamThick == NULL || (int)pCamThick->size() <= 0)
|
return 0.;
|
|
std::vector<STU_THICKPOS*>::iterator it;
|
STU_THICKPOS *pThick;
|
double dStdDev,dSum,dCnt;
|
|
dSum = dCnt = dStdDev = 0.;
|
for(it=pCamThick->begin();it!=pCamThick->end();it++)
|
{
|
pThick = *it;
|
if(pThick == NULL || pThick->dThick <= 0)
|
continue;
|
|
switch(camDir)
|
{
|
case CAMDIR_TOP:
|
dSum += pow((dAvg-pThick->dThick),2);
|
break;
|
case CAMDIR_BOTTOM:
|
dSum += pow((dAvg-pThick->dThick),2);
|
break;
|
}
|
dCnt++;
|
}
|
|
return dCnt>0?sqrt(dSum/dCnt):0.;
|
}
|
|
BOOL CResultData::GetJudgePointMaxMin(std::vector<STU_THICKPOS> *pVecThick,int &nMinPos,int &nMaxPos)
|
{
|
std::vector<STU_THICKPOS>::iterator it;
|
STU_THICKPOS stuThick;
|
|
nMinPos = INT_MAX,nMaxPos = 0;
|
|
for(it=pVecThick->begin();it!=pVecThick->end();it++)
|
{
|
stuThick = *it;
|
if(nMinPos > stuThick.yCoordi) nMinPos = (int)stuThick.yCoordi;
|
if(nMaxPos < stuThick.yCoordi) nMaxPos = (int)stuThick.yCoordi;
|
}
|
|
return TRUE;
|
}
|
|
#define CUTAREA_CALCULATE_SIZE 50000
|
double CResultData::GetJudgePointRangeValue(std::vector<STU_THICKPOS> *pVecThick,int nGlassSize,int iPos)
|
{
|
std::vector<STU_THICKPOS>::iterator it;
|
STU_THICKPOS stuThick;
|
int nRange[2];
|
|
if(iPos-CUTAREA_CALCULATE_SIZE < 0)
|
{
|
nRange[0] = 0;
|
nRange[1] = CUTAREA_CALCULATE_SIZE*2;
|
}
|
else if(iPos+CUTAREA_CALCULATE_SIZE > nGlassSize)
|
{
|
nRange[0] = nGlassSize - CUTAREA_CALCULATE_SIZE*2;
|
nRange[1] = nGlassSize;
|
}
|
else
|
{
|
nRange[0] = iPos - CUTAREA_CALCULATE_SIZE;
|
nRange[1] = iPos + CUTAREA_CALCULATE_SIZE;
|
}
|
|
double dValue = 0.,dSum = 0.,dCnt = 0;
|
for(it=pVecThick->begin();it!=pVecThick->end();it++)
|
{
|
stuThick = *it;
|
|
if(nRange[0] <= stuThick.yCoordi && nRange[1] >= stuThick.yCoordi)
|
{
|
dSum += stuThick.dThick;
|
dCnt++;
|
}
|
}
|
|
if(dCnt > 0)
|
dValue = dSum/dCnt;
|
|
return dValue;
|
}
|
|
void CResultData::GetJudgePointValue(std::vector<STU_THICKPOS> *pVecThick,CAMERA_DIR camDir,DimensionDir enDir,int nGlassSize)
|
{
|
if(pVecThick == NULL || (int)pVecThick->size() <= 0)
|
return;
|
|
double dSum = 0.;
|
double dCount = 0.;
|
int nMinPos,nMaxPos;
|
|
if(GetJudgePointMaxMin(pVecThick,nMinPos,nMaxPos) == FALSE)
|
return;
|
|
int nJumpVal = abs(nMaxPos-nMinPos)/RUSULT_POINT_COUNT;
|
int i;
|
|
for(i=0;i<RUSULT_POINT_COUNT-1;i++)
|
{
|
m_dCutAreaPoint[camDir][enDir][i] = GetJudgePointRangeValue(pVecThick,nGlassSize,nMinPos+nJumpVal*i);
|
}
|
m_dCutAreaPoint[camDir][enDir][RUSULT_POINT_COUNT-1] = GetJudgePointRangeValue(pVecThick,nGlassSize,nMaxPos);
|
}
|
|
BOOL CResultData::FlipImage(LPBYTE pImg,CSize szImg)
|
{
|
LPBYTE pTgt = new BYTE[szImg.cx*szImg.cy];
|
int v,iPos;
|
|
iPos = 0;
|
for(v=szImg.cy-1;v>=0;v--,iPos++)
|
{
|
CopyMemory(&pTgt[iPos*szImg.cx],&pImg[v*szImg.cx],szImg.cx);
|
}
|
|
CopyMemory(pImg,pTgt,szImg.cx*szImg.cy);
|
delete[] pTgt,pTgt=NULL;
|
|
return TRUE;
|
}
|
|
void CResultData::Save_FullImgProc_ROI(LPBYTE pImg,CSize szImg,CRect ROI,LPBYTE lpIn)
|
{
|
if(pImg == NULL || szImg.cx <= 0 || szImg.cy <= 0)
|
return;
|
|
int nYStart = ROI.top;
|
int nXStart = ROI.left;
|
|
//LPBYTE lpStart = pImg + (nYStart % szImg.cy) * szImg.cx + nXStart;
|
LPBYTE lpStart = pImg + nYStart * szImg.cx + nXStart;
|
|
for (int i = 0; i < ROI.Height(); i++)
|
{
|
memcpy(lpIn + i * ROI.Width(), lpStart + i * szImg.cx, ROI.Width());
|
}
|
CSize szTemp;
|
szTemp = CSize(ROI.Width(),ROI.Height());
|
FlipImage(lpIn,szTemp);
|
}
|
|
double CResultData::GetDimensionAvg(std::vector<STU_DIMENSIONPOS*> *pResult)
|
{
|
if(pResult == NULL || pResult->size() <= 0)
|
return 0.;
|
|
std::vector<STU_DIMENSIONPOS*>::iterator it;
|
double dSum,dCount;
|
STU_DIMENSIONPOS *pDimen;
|
|
dSum = dCount = 0.;
|
for(it=pResult->begin();it!=pResult->end();it++)
|
{
|
pDimen = *it;
|
if(pDimen == NULL || pDimen->dSize <= 0)
|
continue;
|
|
dSum+=pDimen->dSize;
|
dCount++;
|
}
|
|
return dCount>0?dSum/dCount:0.;
|
}
|
|
double CResultData::GetDimensionStd(std::vector<STU_DIMENSIONPOS*> *pResult,double dAvg)
|
{
|
if(pResult == NULL || pResult->size() <= 0)
|
return 0.;
|
|
std::vector<STU_DIMENSIONPOS*>::iterator it;
|
double dSum,dCount;
|
STU_DIMENSIONPOS *pDimen;
|
|
dSum = dCount = 0.;
|
for(it=pResult->begin();it!=pResult->end();it++)
|
{
|
pDimen = *it;
|
if(pDimen == NULL || pDimen->dSize <= 0)
|
continue;
|
|
dSum += pow((dAvg-pDimen->dSize),2);
|
dCount++;
|
}
|
|
return dCount>0?sqrt(dSum/dCount):0.;
|
}
|
|
void CResultData::GetDimensionPointValue(std::vector<STU_DIMENSIONPOS> *pData,DimensionDir enDir)
|
{
|
std::vector<STU_DIMENSIONPOS>::iterator it;
|
STU_DIMENSIONPOS pDimen;
|
double dMinVal,dMaxVal;
|
|
dMinVal = INT_MAX;
|
dMaxVal = 0;
|
for(it=pData->begin();it!=pData->end();it++)
|
{
|
pDimen = *it;
|
|
if(dMinVal > pDimen.yCoordi) dMinVal = pDimen.yCoordi;
|
if(dMaxVal < pDimen.yCoordi) dMaxVal = pDimen.yCoordi;
|
}
|
|
double dJumpVal = fabs(dMaxVal-dMinVal)/RUSULT_POINT_COUNT;
|
|
for(int i=0;i<RUSULT_POINT_COUNT;i++)
|
{
|
m_dDimensionPoint[enDir][i] = GetDimensionPointRangeValue(pData,dMinVal+dJumpVal*i);
|
}
|
m_dDimensionPoint[enDir][RUSULT_POINT_COUNT-1] = GetDimensionPointRangeValue(pData,dMaxVal);
|
}
|
|
double CResultData::GetDimensionPointRangeValue(std::vector<STU_DIMENSIONPOS> *pData,double dPos)
|
{
|
double dDiffVal = INT_MAX;
|
double dValue;
|
std::vector<STU_DIMENSIONPOS>::iterator it;
|
STU_DIMENSIONPOS pDimen;
|
|
dValue = 0;
|
for(it=pData->begin();it!=pData->end();it++)
|
{
|
pDimen = *it;
|
|
if(dDiffVal > fabs(pDimen.yCoordi-dPos))
|
{
|
dDiffVal = fabs(pDimen.yCoordi-dPos);
|
dValue = pDimen.dSize;
|
}
|
}
|
|
return dValue;
|
}
|
|
void CResultData::CalJudgement()
|
{
|
int i,j;
|
|
// CutArea
|
for(i=0;i<2;i++)//20140603
|
{
|
for(j=0;j<MAX_DIMENSION_COUNT;j++)
|
{
|
m_bGlassResult &= m_bCutAreaRes[i][j];
|
m_bGlassResult &= m_bCutAreaDiagonalLine[i][j];
|
}
|
}
|
|
// Dimension
|
for(i=0;i<MAX_DIMENSION_COUNT;i++)//20140603
|
{
|
m_bGlassResult &= m_bDimensionRes[i];
|
}
|
|
// Spline,Corner Cut,Notch
|
m_bGlassResult &= m_bNCutSize[CAMDIR_TOP];
|
for(i=0;i<2;i++)
|
{
|
m_bGlassResult &= m_bNCutThick[i];
|
for(j=0;j<2;j++)
|
{
|
// m_bGlassResult &= m_bSplineRes[i][j];
|
m_bGlassResult &= m_bCornerResWidth[i][j];
|
m_bGlassResult &= m_bCornerResHeight[i][j];
|
}
|
}
|
|
// Defect
|
if(m_nDefectCnt > 0)
|
m_bGlassResult = FALSE;
|
|
//Notch Range Value//20140721(Dim/chamºÐ¸®)
|
for (int iDim = 0; iDim<MAX_DIMENSION_COUNT; iDim++)
|
{
|
if(m_bUseNotchPointIns_Dimen[iDim] == TRUE)
|
{
|
for (int i=0; i<NOTCH_RANGE_VAL_MAX_COUNT; i++)
|
{
|
m_bGlassResult &= m_bNCutRange[CAMDIR_TOP][iDim][i];
|
}
|
}
|
if(m_bUseNotchPointIns_Cham[iDim] == TRUE)
|
{
|
for(int i=0; i<NOTCH_RANGE_VAL_MAX_COUNT; i++)
|
{
|
m_bGlassResult &= m_bNCutRange_Cham[CAMDIR_TOP][iDim][i];
|
m_bGlassResult &= m_bNCutRange_Cham[CAMDIR_BOTTOM][iDim][i];
|
}
|
}
|
}
|
}
|
