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