#include "StdAfx.h"
#include "InspectCamera.h"
#include "GlassRecipe.h"
#include "HardwareSettings.h"
#include "MulticamControl.h"
#include "RadientControl.h"
#include "Glass_Data.h"
#include "IncludeSDK.h"

#define BOUNDARY_GLASSSTARTWIDTH	160
#define BOUNDARYHORIZ_LEVELDIST		8	// 荐乞 版拌急阑 茫阑 锭狼 厚背芭府	
#define TIME_WAIT_GLASS_START		1500

#define align_4byte(in) ((in + 3)/4)*4
#define RAD_TO_DEGREE			   (double)(180.0f / 3.1415926535f)

//static double _gLastFinishTime = MININT64;

CInspectCamera::CInspectCamera(int iCam)
{	
	m_iCamera = iCam;
	m_pThreadControl = new CThreadControl();
	m_pRecipe = NULL;
	m_pHardparm = NULL;
	m_pGrabber = NULL;
	m_pGlassData = NULL;
	m_pII2S = NULL;
	m_bExitThread = FALSE;
	m_pSplineModel = NULL;
	m_hWndViewScan = NULL;

	int		i;
	for(i=0;i<MAX_THREAD;i++)
	{		
		m_pChamferControl[i]	= new CChamferInspect;	
		m_pSplineControl[i]	= new CSplineInspect;
		m_pHoleInspect[i] = new CHoleInspector;
	}	

	for(i=0;i<MAX_SCAN_COUNT;i++)
	{
		for(int j=0;j<MAX_THREAD;j++)
		{	
			m_pProfileControl[i][j] = new CProfileCADProc();
		}
	}

	for (int i = 0; i < 8; i++) {
		m_fInspectLastTime[i] = MININT;
	}

	m_pDefectControl = new CDefectControl();	
}

CInspectCamera::~CInspectCamera(void)
{
	ReleaseThread();

	int		i;

	for(i=0;i<MAX_SCAN_COUNT;i++)
	{
		std::multimap<int, CPoint *> *pSetProfileAlignMap = &m_mapAlignProfile[i];

		DeleteCADAlign(pSetProfileAlignMap);
	}

	for(i=0;i<MAX_THREAD;i++)
	{		
		delete m_pChamferControl[i];	
		m_pChamferControl[i] = NULL;

		delete m_pSplineControl[i];
		m_pSplineControl[i] = NULL;

		delete m_pHoleInspect[i];
		m_pHoleInspect[i] = NULL;
	}	

	for(i=0;i<MAX_SCAN_COUNT;i++)
	{
		for(int j=0;j<MAX_THREAD;j++)
		{	
			delete m_pProfileControl[i][j];
			m_pProfileControl[i][j] = NULL;
		}
	}
	
	if(m_pDefectControl != NULL)
		delete m_pDefectControl;
	m_pDefectControl = NULL;

	ReleaseSplineBuffer();
	ReleaseFullBuffer();
}

void CInspectCamera::ReleaseThread()
{
	m_bExitThread = TRUE;	
	if(m_pThreadControl != NULL)
	{
		m_pThreadControl->ReleaseThreadControl();
		Sleep(100);
		delete m_pThreadControl;
		m_pThreadControl = NULL;
	}
}

int	CInspectCamera::InitInspect(int nThread,int maxDefect)
{
	m_pThreadControl->InitThreadControl(nThread,this);

	m_pDefectControl->InitDefectStorage(maxDefect);

	return 1;
}

int CInspectCamera::ReInitThread(int nThread)
{
	m_pThreadControl->ReleaseThreadControl();
	Sleep(100);
	m_pThreadControl->InitThreadControl(nThread, this);

	return 1;
}

BOOL CInspectCamera::ScanStart(int iScan)
{
	m_iScan = iScan;	
	m_iSideLine[iScan] = 0;
	m_bExitThread = FALSE;

	ResetFrameFinish(iScan);

	ScanStartThread();	

	return TRUE;
}

BOOL CInspectCamera::ScanStartThread()
{
	if(m_pThreadControl == NULL)
		return FALSE;	

	int		nThread = m_pThreadControl->StartThreadControl();
	if(nThread <= 0)
	{		
		return FALSE;
	}

	return TRUE;
}

BOOL CInspectCamera::GetCheckFrame(stFrameIndex stFrame)
{
	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return FALSE;

	DimensionDir		emDim = pCamera->m_eDimension;
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return FALSE;
		
	int			nFrameHeight = pCamera->m_FrameSize.cy;
	int			nStartFrame = pEdgeInfo->nGlassStartLine/nFrameHeight;

	if(nStartFrame > stFrame.nFrameIdx)
		return TRUE;

	return FALSE;
}

ERR_FIND_GLASSSTARTLINE CInspectCamera::IsGlassStartLine(int iThread,int &iScan)
{
	iScan = m_iScan;

	if(m_pGrabber->GetGrabFrameCount() < 4)
	{
		Sleep(0);
		return ERR_FINDGLASSSTART_FAIL;
	}

	stFrameIndex stFrame;

	stFrame.nScanIdx = m_iScan;

	if(m_bFindGlassStart[stFrame.nScanIdx] == TRUE)
		return ERR_FINDGLASSSTART_SUCCESS;

	if(iThread != 0)
		return ERR_FINDGLASSSTART_FAIL;	
	
	DimensionDir		emDim = GetDimension(stFrame.nScanIdx);		

	iScan = stFrame.nScanIdx;

	if(FindGlassStartLine(emDim,stFrame) == TRUE)
	{
		ScanRegionSet(stFrame);		
		m_bFindGlassStart[stFrame.nScanIdx] = TRUE;

		m_MsgJob.nState = 1;
		m_MsgJob.nDispLine = 0;
		m_MsgJob.nSide = (int)emDim;
		INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
		if(pEdgeInfo != NULL)
			m_MsgJob.nDispLine = pEdgeInfo->nGlassStartLine;

		::SendMessage(m_hWndViewScan, WM_POCESS_STATUS,(WPARAM)&m_MsgJob, (int)emDim);

		return ERR_FINDGLASSSTART_SUCCESS;
	}
	else
	{				
		return ERR_FINDGLASSSTART_FIND_FAIL;
	}

	return ERR_FINDGLASSSTART_FAIL;
}

BOOL CInspectCamera::OnThreadRun(int iThread, CInspectThread *pInspectThread)
{
	if(m_pRecipe == NULL)
		return FALSE;	
	if(m_pHardparm == NULL)
		return FALSE;
	if(m_pGlassData == NULL)
		return FALSE;
	if(m_pGrabber == NULL)
		return FALSE;

	while(TRUE)
	{
		if(GetCheckExit() == TRUE)
		{
			g_pLog->DisplayMessage(_T("cam %d, Thread %d Thread Exit"),m_iCamera,iThread);
			break;
		}		

		int			iRetScan;
		switch(IsGlassStartLine(iThread,iRetScan))
		{
		case ERR_FINDGLASSSTART_FAIL:
			continue;
			break;
		case ERR_FINDGLASSSTART_FIND_FAIL:
			m_pGrabber->GrabScanStop();
			m_pGrabber->ClearGrabIdx();
			m_bExitThread = TRUE;
			g_pLog->DisplayMessage(_T("%s Process Find Glass StartLine Fail"),PANEL_SIDE[GetDimension(iRetScan)]);

			int			nFrameWidth,nFrameHeight;
			GetFrameSize(m_iCamera,m_iScan,nFrameWidth,nFrameHeight);

			m_MsgJob.nState = 1;
			m_MsgJob.nDispLine = 0;
			m_MsgJob.nSide = (int)GetDimension(m_iScan);

			::SendMessage(m_hWndViewScan, WM_POCESS_STATUS,(WPARAM)&m_MsgJob, (int)m_MsgJob.nSide);

			continue;
			break;
		}		
		
		stFrameIndex stFrame = m_pGrabber->GetGrabFrame();
		if(stFrame.nScanIdx < 0 || stFrame.nFrameIdx < 0)
		{
			Sleep(0);
			continue;
		}

		DimensionDir		emDim = GetDimension(stFrame.nScanIdx);			

		if(CheckStartLineFrame(emDim,stFrame.nFrameIdx) == FALSE)
			continue;				
		
		//if(emDim == DIMENSION_A)
		//	g_pLog->DisplayMessage(_T("%s, %d Process Frame : %d,%d"),PANEL_SIDE[emDim],iThread, stFrame.nScanIdx,stFrame.nFrameIdx);

		int iFindLine = FindLeftLine(iThread,emDim,stFrame);
				
		BOOL bFindEndLine = FindEndLine(iThread,emDim,stFrame);
									
		FindAlignProcess(iThread,emDim,stFrame.nScanIdx,stFrame.nFrameIdx);
						
		FindThickness(iThread,emDim,stFrame,iFindLine);

		//FindSpline(iThread,emDim,stFrame,iFindLine);	

		FindSpline_New(iThread,emDim,stFrame,iFindLine);

		FindHoleInspection(iThread,emDim,stFrame,iFindLine);

		BOOL bProfile = FindProfileProcess(iThread,emDim,stFrame,iFindLine);

		if(m_bProfileFind[stFrame.nScanIdx] == TRUE && m_nProfileFindFrameIdx[stFrame.nScanIdx] == stFrame.nFrameIdx)
			bProfile = TRUE;

		if(bFindEndLine == TRUE)
			SetFrameFinishEndFrame(stFrame.nScanIdx, stFrame.nFrameIdx);

		SetFrameFinish(stFrame.nScanIdx, stFrame.nFrameIdx);

		BOOL bEnd = CheckThreadEnd(iThread,stFrame,bProfile);
		
		if(stFrame.nFrameIdx % 10 == 0 && bEnd == FALSE)
		{
			int			nFrameWidth,nFrameHeight;
			GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

			m_MsgJob.nState = 1;
			m_MsgJob.nDispLine = stFrame.nFrameIdx*nFrameHeight;
			m_MsgJob.nSide = (int)emDim;
			
			//g_pLog->DisplayMessage(_T("%s Display - %d"),PANEL_SIDE[emDim],stFrame.nFrameIdx);

			::SendMessage(m_hWndViewScan, WM_POCESS_STATUS,(WPARAM)&m_MsgJob, (int)emDim);
		}	
				
		Sleep(0);
	}

	g_pLog->DisplayMessage(_T("Camera %d-%d Thread End"),m_iCamera,iThread);

	return TRUE;
}

BOOL CInspectCamera::FindProfileProcess(int iThread,DimensionDir emDim,stFrameIndex stFrame,int iFindLine)
{
	if(CheckProfile(iThread,emDim,stFrame) == FALSE)
		return FALSE;

	INS_EDGE_RESULT_INFO *pResInfo =  NULL;

	if(m_pGlassData != NULL)
		pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);

	if(pResInfo == NULL)
		return FALSE;

	DIT_RESULT ret= DIT_CONV_SUCCESS;	
	
	CvPoint2D32f		ptAlign[3];

	ptAlign[0].x = ptAlign[0].y = 0;
	ptAlign[1].x = ptAlign[1].y = 0;	
	ptAlign[2].x = ptAlign[2].y = 0;	
	if(pResInfo->bMark[0] == FALSE || pResInfo->bMark[1] == FALSE)
	{
		DWORD dwTact = GetTickCount();

		do 
		{
			if(pResInfo == NULL)
				break;

			if(pResInfo->bMark[0] == TRUE && pResInfo->bMark[1] == TRUE)
				break;

			if(GetTickCount()-dwTact >= 3000)
			{
				g_pLog->DisplayMessage(_T("%s Profile Align Wait timeout : %d=%d"),PANEL_SIDE[emDim],pResInfo->bMark[0],pResInfo->bMark[1]);
				break;
			}

			Sleep(0);

		} while (1);

		if(pResInfo->bMark[0] == FALSE || pResInfo->bMark[1] == FALSE)
		{
			g_pLog->DisplayMessage(_T("%s Start Find Profile Process Fail :Frame %d : (Align Mark Find Fail..)"),PANEL_SIDE[emDim],stFrame.nFrameIdx);
			return FALSE;
		}
	}

	ptAlign[0] = pResInfo->ptMark[0];
	ptAlign[1] = pResInfo->ptMark[1];
	ptAlign[2] = pResInfo->ptMark[2];			

	if(ptAlign[0].x<=0 || ptAlign[0].y <= 0 || ptAlign[1].x <= 0 || ptAlign[1].y <=0)
	{
		return FALSE;	
	}
	
	CalculateStageTheta(emDim,stFrame.nScanIdx, ptAlign);	

	g_pLog->DisplayMessage(_T("%s Start Find Profile Process : Thread %d,Frame %d"),PANEL_SIDE[emDim],iThread, stFrame.nFrameIdx);

	vector< pair<int,STU_PROFILE_POSITION*> > vecProfile;

	CProfileCADProc *pProfileControl = GetProfileControl(stFrame.nScanIdx,iThread);

	MakeProfilePosition(emDim,stFrame,pProfileControl,vecProfile, ptAlign);

	CalculateProfileChamfer(emDim,stFrame,pProfileControl,vecProfile,ptAlign[0]);

	vector< pair<int,STU_PROFILE_POSITION*> >::iterator		it;
	STU_PROFILE_POSITION *pProfile;
	for(it=vecProfile.begin();it!=vecProfile.end();it++)
	{
		pProfile = it->second;
		if(pProfile != NULL)
			delete pProfile;
		pProfile = NULL;
	}
	vecProfile.clear();

	vector< pair<double,STU_SPLINE_PROFILE_POSITION*> >	vecSplineProfile;

	RCutProfileProcess(emDim,stFrame,pProfileControl,vecSplineProfile,ptAlign);

	vector< pair<double,STU_SPLINE_PROFILE_POSITION*> >::iterator		itSpline;
	STU_SPLINE_PROFILE_POSITION	*pSpline;
	for(itSpline=vecSplineProfile.begin();itSpline!=vecSplineProfile.end();itSpline++)
	{
		pSpline = itSpline->second;
		if(pSpline != NULL)
			delete pSpline;
		pSpline = NULL;
	}
	vecSplineProfile.clear();

	double				dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return FALSE;

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return FALSE;

	double dDx	= abs(ptAlign[0].x-ptAlign[1].x)*dConv;
	double dDy	= abs(ptAlign[0].y-ptAlign[1].y)*dScan;
	double dAlignDist = sqrtf(float(dDx *dDx + dDy*dDy));
	double dPixelDx	= abs(ptAlign[0].x-ptAlign[1].x);
	double dPixelDy	= abs(ptAlign[0].y-ptAlign[1].y);
	double dPixelAlignDist = sqrtf(float(dPixelDx *dPixelDx + dPixelDy*dPixelDy));

	g_pLog->DisplayMessage(_T("%s Glass Align First[%.0f,%.0f],Align Second[%.0f,%.0f] = Distance %.0f,%.3fmm"),PANEL_SIDE[emDim],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y,dPixelAlignDist,dAlignDist/1000.);

	g_pLog->DisplayMessage(_T("%s Find Profile Process End :Frame %d"),PANEL_SIDE[emDim],stFrame.nFrameIdx);

	return TRUE;
	
}

BOOL CInspectCamera::IsRCutProfileProcess(DimensionDir emDim)
{
	switch(emDim)
	{
	case DIMENSION_A:
	case DIMENSION_A_DN:
	case DIMENSION_B:
	case DIMENSION_B_DN:
	case DIMENSION_D:
	case DIMENSION_D_DN:
		return TRUE;	
	}

	return FALSE;
}

BOOL CInspectCamera::CheckAlignMark(DimensionDir emDim,int &nIndex)
{
	INS_EDGE_RESULT_INFO *pResInfo = NULL;
	BOOL				bRet = FALSE;

	nIndex = -1;

	BOOL		bUseAlignKey = FALSE;
	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();
	if(pPrm != NULL)	
		bUseAlignKey = pPrm->m_bUseOriginAlignKey[emDim];

	if(m_pGlassData != NULL)
	{
		pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);
		if(pResInfo != NULL)
		{
			switch(emDim)
			{
			case DIMENSION_A:
			case DIMENSION_A_DN:
				bRet = pResInfo->bMark[0];
				nIndex = 0;
				break;
			case DIMENSION_B:
			case DIMENSION_B_DN:
			case DIMENSION_D:
			case DIMENSION_D_DN:
				if(bUseAlignKey == FALSE)
				{
					bRet = pResInfo->bMark[2];	// A父 Align 0, B,D绰 辑宏付目
					nIndex = 2;
				}
				else
				{
					bRet = TRUE;
				}
				break;
			}			
		}
	}

	return bRet;
}

BOOL CInspectCamera::ReFindAlignMark(DimensionDir emDim,stFrameIndex stFrame,int iPos)
{
	int				iFindFrame;
	int				iEdgeFrame;
	int				iGlassEdge = 0;
	INS_EDGE_RESULT_INFO *pResInfo = NULL;

	pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);

	CRect		rectAlign =	pResInfo->rtMark[iPos];

	if(rectAlign.top <= 0)
		return FALSE;

	int		nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	iFindFrame = rectAlign.bottom/nFrameHeight;
	iEdgeFrame = iFindFrame + 5;

	iGlassEdge = pResInfo->nGrindframe[0][iEdgeFrame];

	if(iGlassEdge <= 0 || iGlassEdge >= nFrameWidth)	
	{
		for(int i=iEdgeFrame-1;i>=pResInfo->nGlassStartFrame;i--)
		{
			if(pResInfo->nGrindframe[0][i] > 0 && pResInfo->nGrindframe[0][i] < nFrameWidth)
			{
				iGlassEdge = pResInfo->nGrindframe[0][i];
				break;
			}
		}
	}	

	CString			strPos = _T("TOP");
	CString			strRes = _T("Fail");

	switch(iPos)
	{
	case 1: strPos = _T("BOT"); break;
	case 2: strPos = _T("SUB"); break;
	}	

	rectAlign.OffsetRect(iGlassEdge,0);

	g_pLog->DisplayMessage(_T("%s Re Align Mark Find[%d] %d,%d,%d,%d"),PANEL_SIDE[emDim],iPos,rectAlign.left,rectAlign.top,rectAlign.right,rectAlign.bottom);

	double			dRate = 0.5;
	TEMP_RESULT		matchResut;
	CRect rectIns = rectAlign;			
	CALIGNMARK_PARM *pAlignPrm = m_pRecipe->GetAlignMarkPrm(emDim);
	CEdgeProc		insProc;
	
	CSISBuffer frameBuffer(m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,rectAlign.top), nFrameWidth, rectAlign.Height());	

	if(!frameBuffer.IsValidBuffer())
	{
		return FALSE;
	}		

	rectIns.OffsetRect(0,-rectIns.top);

	matchResut.fRat = 0.;
	matchResut.pt.x = matchResut.pt.y = 0;

	for(int iMarkPos=0;iMarkPos<MAX_POS_MARKER_COUNT;iMarkPos++)
	{
		if(pAlignPrm->IpMarkImg[iPos][iMarkPos] == NULL)
			continue;

		CRect		rtFind = rectIns;

		if(rtFind.Width() <= pAlignPrm->IpMarkImg[iPos][iMarkPos]->width)
			rtFind.right = rtFind.left + pAlignPrm->IpMarkImg[iPos][iMarkPos]->width + 10;
		if(rtFind.Height() <= pAlignPrm->IpMarkImg[iPos][iMarkPos]->height)
			rtFind.bottom = rtFind.top + pAlignPrm->IpMarkImg[iPos][iMarkPos]->height + 10;

		insProc.CvFindMark(frameBuffer,pAlignPrm->IpMarkImg[iPos][iMarkPos],rectIns,matchResut,dRate);

		if(matchResut.fRat*100. > pAlignPrm->m_dMarkMatchingRate[iPos][iMarkPos])
		{			
			if(pResInfo != NULL)
			{
				pResInfo->bMark[iPos] = TRUE;
				pResInfo->ptMark[iPos].x	= matchResut.pt.x;
				pResInfo->ptMark[iPos].y	= matchResut.pt.y + rectAlign.top;
				pResInfo->nMarkToEdge_X[iPos] = (int)(pResInfo->ptMark[iPos].x - m_iSideLine[stFrame.nScanIdx]);
				pResInfo->nMarkToEdge_Y[iPos] = (int)(pResInfo->ptMark[iPos].y - pResInfo->nGlassStartLine );	
			}

			g_pLog->DisplayMessage(_T("%s Re Align Mark Find[%d][%d] Success x %.2f, y %.2f"),PANEL_SIDE[emDim],iPos,iMarkPos,matchResut.pt.x, matchResut.pt.y + rectAlign.top);
			strRes = _T("Success");
			break;
		}			
	}

	if(pResInfo != NULL && pResInfo->bMark[iPos] == FALSE)
	{		
		pResInfo->bMark[iPos] = TRUE;
		pResInfo->ptMark[iPos].x	= (float)(m_iSideLine[stFrame.nScanIdx] + m_dMark2MarkX[stFrame.nScanIdx][iPos]);
		pResInfo->ptMark[iPos].y	= (float)(pResInfo->nGlassStartLine + m_dMark2MarkY[stFrame.nScanIdx][iPos]);		

		g_pLog->DisplayMessage(_T("%s Re Align Mark Find[%d] Fail x %.2f, y %.2f"),PANEL_SIDE[emDim],iPos,m_iSideLine[stFrame.nScanIdx] + m_dMark2MarkX[stFrame.nScanIdx][iPos], pResInfo->nGlassStartLine + m_dMark2MarkY[stFrame.nScanIdx][iPos]);	
	}

#if MARKIMG_NOTSAVE
	CString			strFile;
	CvRect			saveRect = cvRect((int)matchResut.pt.x - rectAlign.Width() / 2, (int)(matchResut.pt.y + rectAlign.top) - rectAlign.Height() / 2, rectAlign.Width(), rectAlign.Height());
	strFile.Format(_T("%sIMG_MARK\\%s\\%s\\%s\\Align_%s_%s_%s.jpg"), PATH_INSPECTION_DATA, g_pBase->m_strLoadingDay, g_pBase->m_strHPanelID, g_pBase->m_strLoadingTime, strPos, PANEL_SIDE[emDim], strRes);

	SaveCvAlignImage(saveRect, strFile, stFrame.nScanIdx, nFrameWidth, nFrameHeight);
#endif // 0

	return TRUE;
}

int CInspectCamera::GetRCutProfileIndexTheta(DimensionDir emDim,stFrameIndex stFrame,vector< pair<double,STU_SPLINE_PROFILE_POSITION*> > &vecProfile,CvPoint2D32f *ptAlign)
{
	int			nRcpIndex[2],nRcpSize[2];
	int			nProfilePosCount;

	nProfilePosCount = GetRCutProfileIndex(emDim,nRcpIndex,nRcpSize);
	if(nProfilePosCount <= 0)
		return 0;

	return GetRCutProfileTheta2Vector(nProfilePosCount,emDim,stFrame,vecProfile,nRcpIndex,nRcpSize,ptAlign);
}

int	CInspectCamera::GetRCutProfileTheta2Vector(int nPosCnt,DimensionDir eDimension,stFrameIndex stFrame,vector< pair<double,STU_SPLINE_PROFILE_POSITION*> > &vecProfile,int *nRcpIndex,INT *nRcpSize,CvPoint2D32f *ptAlign)
{
	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();	
	int			iPos,iIndex,iTheta;
	double		dDefaultTheta = RCUT_PROFILE_CALCULATE_THETA;	
	CvPoint2D32f	ptCenter;	

	for(iPos=0;iPos<nPosCnt;iPos++)
	{				
		for(iIndex=nRcpIndex[iPos],iTheta=0;iIndex<nRcpIndex[iPos]+nRcpSize[iPos];iIndex++,iTheta++)
		{
			pSTU_SPLINE_PROFILE_POSITION pPfPositon = new STU_SPLINE_PROFILE_POSITION;		

			pPfPositon->iCam = m_iCamera;
			pPfPositon->iSide = eDimension;
			pPfPositon->iScan = stFrame.nScanIdx;
			pPfPositon->iIndex = iIndex;
			pPfPositon->iPos = iPos;
			pPfPositon->iLoop = iTheta;
			pPfPositon->pSettings = &pPrm->m_stProfile[iIndex];
			pPfPositon->dRadius = pPfPositon->pSettings->radius;			

			double dCalTheta = -1*atan(static_cast<double>(ptAlign[1].x - ptAlign[0].x) / static_cast<double>((ptAlign[1].y - ptAlign[0].y)));
			dCalTheta = dCalTheta*RAD_TO_DEGREE;

			if(m_pRecipe->GetGlassInfo()->m_bPanelReverse == FALSE)
			{
				switch(eDimension)
				{
				case DIMENSION_A:
				case DIMENSION_A_DN:
					if(iPos == 0)
						pPfPositon->dTheta = 90-(iTheta*dDefaultTheta);
					else
						pPfPositon->dTheta = -1*(iTheta*dDefaultTheta-dCalTheta);
					break;
				case DIMENSION_B:
				case DIMENSION_B_DN:
					pPfPositon->dTheta = -1*(iTheta*dDefaultTheta-dCalTheta);
					break;
				case DIMENSION_D:
				case DIMENSION_D_DN:
					pPfPositon->dTheta = 270+(iTheta*dDefaultTheta+dCalTheta);
					break;
				}
			}
			else
			{
				switch(eDimension)
				{
				case DIMENSION_A:
				case DIMENSION_A_DN:
					if(iPos == 0)
						pPfPositon->dTheta = (iTheta*dDefaultTheta-dCalTheta);
					else
						pPfPositon->dTheta = -1*(90-(iTheta*dDefaultTheta));
					break;
				case DIMENSION_B:
				case DIMENSION_B_DN:
					pPfPositon->dTheta = 270+(iTheta*dDefaultTheta+dCalTheta);
					break;
				case DIMENSION_D:
				case DIMENSION_D_DN:
					pPfPositon->dTheta = -1*(iTheta*dDefaultTheta-dCalTheta);					
					break;
				}
			}

			if(iTheta == 0)		// Center绰 贸澜波 窍唱肺 茄促.
			{
				GetRCutCalculateCenterPosition(eDimension,stFrame,pPfPositon,ptAlign,iPos);	
				ptCenter.x = (float)pPfPositon->ptCenterX;
				ptCenter.y = (float)pPfPositon->ptCenterY;
			}
			else
			{
				pPfPositon->ptCenterX = ptCenter.x;
				pPfPositon->ptCenterY = ptCenter.y;
			}

			vecProfile.push_back(make_pair((double)pPfPositon->iIndex, pPfPositon));		
		}
	}

	return (int)vecProfile.size();
}

void CInspectCamera::GetRCutCalculateCenterPosition(DimensionDir eDimension,stFrameIndex stFrame,pSTU_SPLINE_PROFILE_POSITION pPfPositon,CvPoint2D32f *ptAlign,int iPos)
{
	double		dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return;	

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return;	

	CEdgeProc		EdgeProc;	

	BOOL			bUseAlignKey;	

	bUseAlignKey = FALSE;

	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();
	if(pPrm != NULL)
	{
		bUseAlignKey = pPrm->m_bUseOriginAlignKey[eDimension];		
	}

	if(m_pRecipe->GetGlassInfo()->m_bPanelReverse == FALSE)
	{
		switch(eDimension)
		{
		case DIMENSION_A:
		case DIMENSION_A_DN:
			if(iPos == 0)		// 窍何 align捞 扁霖捞骨肺 惑何绰 拌魂摹肺 茄促.
			{			
				double				dGlassLongSize = (m_pRecipe->GetGlassInfo()->m_nGlassSizeX);
				double				dCalValue;

				int					nCalAlignPos = (int)(dGlassLongSize-LONG_SIDE_INSPECTION_POINT_OFFSET);
				int					nSetPos = (int)(LONG_SIDE_INSPECTION_POINT_OFFSET+pPfPositon->pSettings->y);
				double				dMove = nCalAlignPos-nSetPos;

				dCalValue = dMove/dScan; 			

				pPfPositon->ptCenterX = (pPfPositon->pSettings->x/dConv) + ptAlign[0].x;
				pPfPositon->ptCenterY = ptAlign[0].y + dCalValue;
									
				pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_A_DN_X/dConv);
				pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_A_DN_Y/dScan);				
				
			}
			else		// 窍何啊 扁霖. shift父 矫糯
			{
				pPfPositon->ptCenterX = ptAlign[1].x+pPfPositon->pSettings->x/dConv;
				pPfPositon->ptCenterY = ptAlign[1].y-pPfPositon->pSettings->y/dScan;

				pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_A_X/dConv);
				pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_A_Y/dScan);					
			}
			break;
		case DIMENSION_B:
		case DIMENSION_B_DN:			// C,D绰 谅钎啊 馆措, B绰 C搁栏肺 焊搁 窍何 , 75锅
			{			
				if(bUseAlignKey == FALSE)
				{
					CvPoint2D32f 		ptMove;

					pPfPositon->ptRealCenter.x = (float)(pPfPositon->pSettings->y * ptAlign[2].x*dConv);
					pPfPositon->ptRealCenter.y = (float)(pPfPositon->pSettings->x + ptAlign[2].y*dScan);

					ptMove.x = (float)(pPfPositon->pSettings->y/dConv);			
					ptMove.y = (float)(pPfPositon->pSettings->x/dScan);

					double dCalTheta = -1*atan(static_cast<double>(ptAlign[1].x - ptAlign[0].x) / static_cast<double>((ptAlign[1].y - ptAlign[0].y)));		// C,D绰 3锅掳 倔扼牢虐肺 可悸 焊沥窃.
					//EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,ptAlign[2],sin(dCalTheta),cos(dCalTheta));
					EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,sin(dCalTheta),cos(dCalTheta));

					pPfPositon->ptCenterX += ptAlign[2].x;
					pPfPositon->ptCenterY += ptAlign[2].y;

					g_pLog->DisplayMessage(_T("%s Profile, 1 Align x %.3f,y %.3f, 2 Align x %.3f,y %.3f, 3 Align x %.3f,y %.3f"),PANEL_SIDE[eDimension],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y,ptAlign[2].x,ptAlign[2].y);
					g_pLog->DisplayMessage(_T("%s Profile Theta %.5f move x %.3f,y %.3f, Center x %.3f,y %.3f"),PANEL_SIDE[eDimension],dCalTheta,ptMove.x,ptMove.y,pPfPositon->ptCenterX,pPfPositon->ptCenterY);

					pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_C_DN_X/dConv);		// user offset篮 扁粮 C窍螟 可悸 利侩
					pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_C_DN_Y/dScan);						
				}
				else
				{
					double		AlignX,AlignY;
					double		dOrgOffsetX,dOrgOffsetY;

					dOrgOffsetX = (double)pPrm->m_nOriginAlignKeyOffsetDwX[eDimension]/dConv;
					dOrgOffsetY = (double)pPrm->m_nOriginAlignKeyOffsetDwY[eDimension]/dScan;

					AlignX = ptAlign[1].x;
					AlignY = ptAlign[1].y;				

					pPfPositon->ptCenterX = AlignX + dOrgOffsetX;
					pPfPositon->ptCenterY = AlignY + dOrgOffsetY;

					g_pLog->DisplayMessage(_T("Use Key %s Profile, 1 Align x %.3f,y %.3f, 2 Align x %.3f,y %.3f"),PANEL_SIDE[eDimension],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y);
					g_pLog->DisplayMessage(_T("Use Key %s Profile offset x %.3f,y %.3f, Center x %.3f,y %.3f"),PANEL_SIDE[eDimension],dOrgOffsetX,dOrgOffsetY,pPfPositon->ptCenterX,pPfPositon->ptCenterY);
				}
			}		
			break;
		case DIMENSION_D:
		case DIMENSION_D_DN:		// C,D绰 谅钎啊 馆措, D绰 C搁栏肺 焊搁 惑何 , 70锅
			{
				if(bUseAlignKey == FALSE)
				{
					CvPoint2D32f 		ptMove;
					double				dGlassLongSize = (m_pRecipe->GetGlassInfo()->m_nGlassSizeX);		

					int					nCalAlignPos = (int)(dGlassLongSize-LONG_SIDE_INSPECTION_POINT_OFFSET);
					int					nSetPos = (int)(LONG_SIDE_INSPECTION_POINT_OFFSET+pPfPositon->pSettings->y);
					double				dMove = nCalAlignPos-nSetPos;

					ptMove.x = (float)(dMove/dConv);
					ptMove.y = (float)(pPfPositon->pSettings->x/dScan);			

					double dCalTheta = -1*atan(static_cast<double>(ptAlign[1].x - ptAlign[0].x) / static_cast<double>((ptAlign[1].y - ptAlign[0].y)));		// C,D绰 3锅掳 倔扼牢虐肺 可悸 焊沥窃.
					//EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,ptAlign[2],sin(dCalTheta),cos(dCalTheta));
					EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,sin(dCalTheta),cos(dCalTheta));

					pPfPositon->ptCenterX += ptAlign[2].x;
					pPfPositon->ptCenterY += ptAlign[2].y;

					g_pLog->DisplayMessage(_T("%s Profile, 1 Align x %.3f,y %.3f, 2 Align x %.3f,y %.3f, 3 Align x %.3f,y %.3f"),PANEL_SIDE[eDimension],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y,ptAlign[2].x,ptAlign[2].y);
					g_pLog->DisplayMessage(_T("%s Profile Theta %.5f move x %.3f,y %.3f, Center x %.3f,y %.3f"),PANEL_SIDE[eDimension],dCalTheta,ptMove.x,ptMove.y,pPfPositon->ptCenterX,pPfPositon->ptCenterY);

					pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_C_X/dConv);		// user offset篮 扁粮 C惑螟 可悸 利侩
					pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_C_Y/dScan);	
					
				}
				else
				{
					double		AlignX,AlignY;
					double		dOrgOffsetX,dOrgOffsetY;

					dOrgOffsetX = (double)pPrm->m_nOriginAlignKeyOffsetDwX[eDimension]/dConv;
					dOrgOffsetY = (double)pPrm->m_nOriginAlignKeyOffsetDwY[eDimension]/dScan;

					AlignX = ptAlign[1].x;
					AlignY = ptAlign[1].y;			

					pPfPositon->ptCenterX = AlignX + dOrgOffsetX;
					pPfPositon->ptCenterY = AlignY + dOrgOffsetY;

					g_pLog->DisplayMessage(_T("Use Key %s Profile, 1 Align x %.3f,y %.3f, 2 Align x %.3f,y %.3f"),PANEL_SIDE[eDimension],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y);
					g_pLog->DisplayMessage(_T("Use Key %s Profile offset x %.3f,y %.3f, Center x %.3f,y %.3f"),PANEL_SIDE[eDimension],dOrgOffsetX,dOrgOffsetY,pPfPositon->ptCenterX,pPfPositon->ptCenterY);
				}
			}
			break;	
		}
	}
	else
	{
		switch(eDimension)
		{
		case DIMENSION_A:
		case DIMENSION_A_DN:
			if(iPos == 0)		// 惑何啊 扁霖. shift父 矫糯
			{			
				pPfPositon->ptCenterX = ptAlign[0].x+pPfPositon->pSettings->x/dConv;
				pPfPositon->ptCenterY = ptAlign[0].y+pPfPositon->pSettings->y/dScan;

				pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_A_X/dConv);
				pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_A_Y/dScan);	
				
			}
			else		// 惑何 align捞 扁霖捞骨肺 惑何绰 拌魂摹肺 茄促.
			{				

				double				dGlassLongSize = (m_pRecipe->GetGlassInfo()->m_nGlassSizeX);
				double				dCalValue;

				int					nCalAlignPos = (int)(dGlassLongSize-LONG_SIDE_INSPECTION_POINT_OFFSET);
				int					nSetPos = (int)(LONG_SIDE_INSPECTION_POINT_OFFSET+pPfPositon->pSettings->y);
				double				dMove = nSetPos-nCalAlignPos;

				dCalValue = dMove/dScan; 			

				pPfPositon->ptCenterX = (pPfPositon->pSettings->x/dConv) + ptAlign[1].x;
				pPfPositon->ptCenterY = ptAlign[1].y + dCalValue;

				pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_A_DN_X/dConv);
				pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_A_DN_Y/dScan);		
				
			}
			break;
		case DIMENSION_B:
		case DIMENSION_B_DN:			// C,D绰 谅钎啊 馆措, B绰 C搁栏肺 焊搁 窍何 , 75锅
			{			
				CvPoint2D32f 		ptMove;
				double				dGlassLongSize = (m_pRecipe->GetGlassInfo()->m_nGlassSizeX);		

				int					nCalAlignPos = (int)(dGlassLongSize-LONG_SIDE_INSPECTION_POINT_OFFSET);
				int					nSetPos = (int)(LONG_SIDE_INSPECTION_POINT_OFFSET+pPfPositon->pSettings->y);
				double				dMove = nCalAlignPos-nSetPos;

				ptMove.x = (float)(dMove/dConv);
				ptMove.y = (float)(pPfPositon->pSettings->x/dScan);			

				double dCalTheta = -1*atan(static_cast<double>(ptAlign[1].x - ptAlign[0].x) / static_cast<double>((ptAlign[1].y - ptAlign[0].y)));		// C,D绰 3锅掳 倔扼牢虐肺 可悸 焊沥窃.
				//EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,ptAlign[2],sin(dCalTheta),cos(dCalTheta));
				EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,sin(dCalTheta),cos(dCalTheta));

				pPfPositon->ptCenterX += ptAlign[2].x;
				pPfPositon->ptCenterY += ptAlign[2].y;

				g_pLog->DisplayMessage(_T("%s Profile, 1 Align x %.3f,y %.3f, 2 Align x %.3f,y %.3f, 3 Align x %.3f,y %.3f"),PANEL_SIDE[eDimension],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y,ptAlign[2].x,ptAlign[2].y);
				g_pLog->DisplayMessage(_T("%s Profile Theta %.5f move x %.3f,y %.3f, Center x %.3f,y %.3f"),PANEL_SIDE[eDimension],dCalTheta,ptMove.x,ptMove.y,pPfPositon->ptCenterX,pPfPositon->ptCenterY);

				pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_C_X/dConv);		// user offset篮 扁粮 C惑螟 可悸 利侩
				pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_C_Y/dScan);	
				
			}		
			break;
		case DIMENSION_D:
		case DIMENSION_D_DN:		// C,D绰 谅钎啊 馆措, D绰 C搁栏肺 焊搁 惑何 , 70锅
			{
				CvPoint2D32f 		ptMove;

				pPfPositon->ptRealCenter.x = (float)(pPfPositon->pSettings->y * ptAlign[2].x*dConv);
				pPfPositon->ptRealCenter.y = (float)(pPfPositon->pSettings->x + ptAlign[2].y*dScan);

				ptMove.x = (float)(pPfPositon->pSettings->y/dConv);			
				ptMove.y = (float)(pPfPositon->pSettings->x/dScan);

				double dCalTheta = -1*atan(static_cast<double>(ptAlign[1].x - ptAlign[0].x) / static_cast<double>((ptAlign[1].y - ptAlign[0].y)));		// C,D绰 3锅掳 倔扼牢虐肺 可悸 焊沥窃.
				//EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,ptAlign[2],sin(dCalTheta),cos(dCalTheta));
				EdgeProc.RotatePoint(ptMove,pPfPositon->ptCenterX,pPfPositon->ptCenterY,sin(dCalTheta),cos(dCalTheta));

				pPfPositon->ptCenterX += ptAlign[2].x;
				pPfPositon->ptCenterY += ptAlign[2].y;

				g_pLog->DisplayMessage(_T("%s Profile, 1 Align x %.3f,y %.3f, 2 Align x %.3f,y %.3f, 3 Align x %.3f,y %.3f"),PANEL_SIDE[eDimension],ptAlign[0].x,ptAlign[0].y,ptAlign[1].x,ptAlign[1].y,ptAlign[2].x,ptAlign[2].y);
				g_pLog->DisplayMessage(_T("%s Profile Theta %.5f move x %.3f,y %.3f, Center x %.3f,y %.3f"),PANEL_SIDE[eDimension],dCalTheta,ptMove.x,ptMove.y,pPfPositon->ptCenterX,pPfPositon->ptCenterY);

				pPfPositon->ptCenterX += (g_pStatus->GetProfileOption()->m_nProfileOff_C_DN_X/dConv);		// user offset篮 扁粮 C窍螟 可悸 利侩
				pPfPositon->ptCenterY += (g_pStatus->GetProfileOption()->m_nProfileOff_C_DN_Y/dScan);	
			}
			break;	
		}
	}
}

int CInspectCamera::GetRCutProfileIndex(DimensionDir eDimension,int *nRcpIndex,int *nRcpSize)
{
	CString		strName;
	int			nProfileCnt = 1;

	// 捞固瘤 Scan 鉴辑措肺 Index甫 罐酒柯促
	
	if(m_pRecipe->GetGlassInfo()->m_bPanelReverse == FALSE)
	{
		switch(eDimension)
		{
		case DIMENSION_A:
		case DIMENSION_A_DN:
			if(m_pGlassData->GetProfileRCutInspectIndex(1,nRcpIndex[0],nRcpSize[0],strName) == FALSE) // A 惑螟 开规氢, Q1(75) ~ Q4(79)
				return 0;
			if(m_pGlassData->GetProfileRCutInspectIndex(0,nRcpIndex[1],nRcpSize[1],strName) == FALSE) // A 窍螟 沥规氢, P1(60) ~ P4(64)
				return 0;
			nProfileCnt = 2;
			break;
		case DIMENSION_B:
		case DIMENSION_B_DN:		
		case DIMENSION_C:
		case DIMENSION_C_DN:	
			if(m_pGlassData->GetProfileRCutInspectIndex(2,nRcpIndex[0],nRcpSize[0],strName) == FALSE) // B 窍螟 沥规氢, N1(65) ~ N4(69)
				return 0;
			break;
		case DIMENSION_D:
		case DIMENSION_D_DN:
			if(m_pGlassData->GetProfileRCutInspectIndex(3,nRcpIndex[0],nRcpSize[0],strName) == FALSE) // D 窍螟 开规氢, Q1(70) ~ Q4(74)
				return 0;
			break;
		}
	}
	else
	{
		switch(eDimension)
		{
		case DIMENSION_A:
		case DIMENSION_A_DN:
			if(m_pGlassData->GetProfileRCutInspectIndex(0,nRcpIndex[0],nRcpSize[0],strName) == FALSE) // A 惑螟 沥规氢, P1(60) ~ P4(64)
				return 0;
			if(m_pGlassData->GetProfileRCutInspectIndex(1,nRcpIndex[1],nRcpSize[1],strName) == FALSE) // A 窍螟 开规氢, Q1(75) ~ Q4(79)
				return 0;
			nProfileCnt = 2;
			break;
		case DIMENSION_B:
		case DIMENSION_B_DN:		
			if(m_pGlassData->GetProfileRCutInspectIndex(3,nRcpIndex[0],nRcpSize[0],strName) == FALSE) // B 窍螟 开规氢, Q1(70) ~ Q4(74)
				return 0;
			break;
		case DIMENSION_C:
		case DIMENSION_C_DN:
		case DIMENSION_D:
		case DIMENSION_D_DN:
			if(m_pGlassData->GetProfileRCutInspectIndex(2,nRcpIndex[0],nRcpSize[0],strName) == FALSE) // D 窍螟 沥规氢, N1(65) ~ N4(69)
				return 0;
			break;
		}
	}

	return nProfileCnt;
}

BOOL CInspectCamera::RCutProfileProcess(DimensionDir emDim,stFrameIndex stFrame,CProfileCADProc *pProcess,vector< pair<double,STU_SPLINE_PROFILE_POSITION*> > &vecProfile,CvPoint2D32f *ptAlign)
{
	if(IsRCutProfileProcess(emDim) == FALSE)
		return TRUE;

	int		nIndex = -1;
	BOOL bCheckAlign = CheckAlignMark(emDim,nIndex);
	if(bCheckAlign == FALSE)
	{
		ReFindAlignMark(emDim,stFrame,nIndex);

		if(m_pGlassData != NULL)
		{
			INS_EDGE_RESULT_INFO *pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);
			if(pResInfo != NULL)
			{
				if(pResInfo->bMark[nIndex] == TRUE)
				{
					ptAlign[nIndex] = pResInfo->ptMark[nIndex];
				}				
			}
		}
	}	
	
	int nVecCnt = GetRCutProfileIndexTheta(emDim,stFrame,vecProfile,ptAlign);
	if(nVecCnt <= 0)
		return FALSE;

	FindRCutProfilePosition(emDim,stFrame,pProcess,vecProfile,ptAlign);

	CalculateProfileSpline(emDim,stFrame,vecProfile);

	return TRUE;
}

BOOL CInspectCamera::CalculateProfileSpline(DimensionDir eDimension,stFrameIndex stFrame,vector< pair<double,STU_SPLINE_PROFILE_POSITION*> > &vecProfile)
{
	CProfileInspect_Prm *pPrm =	m_pRecipe->GetProfileParm();
	vector< pair<double,STU_SPLINE_PROFILE_POSITION*> >::iterator		it;
	PROFILE_RCUT_PROCESSDATA		RCutResult;
	PROFILE_RESULT					ProfileResult;
	CHAMFER_RESULT					ChamferResult;
	STU_SPLINE_PROFILE_POSITION		*ptProfile;	
	ST_CHAMFER_SETTING				*pstChamferPrm;	
	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	double		dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return FALSE;	

	dConv = pCamera->m_dConvResolution[nStageNo];
	dScan = pCamera->m_dScanResolution[nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return FALSE;	

	srand((unsigned int)time(NULL));

	for(it=vecProfile.begin();it!=vecProfile.end();it++)
	{
		ptProfile = it->second;
		if(ptProfile == NULL)
			continue;
		if(ptProfile->iIndex < 0 || ptProfile->iIndex >= MAX_PROFILE_SETTING_COUNT)
			continue;

		ProfileResult.iCam = RCutResult.iCam = ptProfile->iCam;
		ProfileResult.iFrame =  RCutResult.iFrame = stFrame.nFrameIdx;
		ProfileResult.iIndex = RCutResult.iIndex = ptProfile->iIndex;
		ProfileResult.iScan = RCutResult.iScan = ptProfile->iScan;
		ProfileResult.iSide = RCutResult.iSide = ptProfile->iSide;

		if(pCamera->m_enCamDir == CAMDIR_BOTTOM)
		{	
			ProfileResult.bUseJudge = pPrm->m_stProfile[ptProfile->iIndex].use;			 
			ProfileResult.nJudgeMinus = (int)ROUND(pPrm->m_stProfile[ptProfile->iIndex].minus);
			ProfileResult.nJudgePlus = (int)ROUND(pPrm->m_stProfile[ptProfile->iIndex].plus);

			double dReference = pPrm->m_stProfile[ptProfile->iIndex].radius;
			if(g_pStatus->GetProfileOption()->m_dProfileRadius[nStageNo][ptProfile->iIndex] > 0)
				dReference = g_pStatus->GetProfileOption()->m_dProfileRadius[nStageNo][ptProfile->iIndex];
			
			ProfileResult.nProfileDiff = (int)ROUND(ptProfile->dDist-dReference);

			RCutResult.dCenterX = ptProfile->ptCenterX;
			RCutResult.dCenterY = ptProfile->ptCenterY;
			RCutResult.dCADLineX = ptProfile->ptCadLine.x;
			RCutResult.dCADLineY = ptProfile->ptCadLine.y;
			RCutResult.dRadius = ptProfile->dRadius;
			RCutResult.dPixelRadius = RCutResult.dRadius/dScan;
			RCutResult.ptGlass = ptProfile->ptGlass;
			RCutResult.ptChamfer = ptProfile->ptChamfer;

			ProfileResult.bProfileJudge = TRUE;
			RCutRandom(ProfileResult);
			if(ProfileResult.bUseJudge == TRUE)
			{				
				//if(RCutRandom(ProfileResult) == FALSE)
				{
					if(ProfileResult.nProfileDiff < -1*ProfileResult.nJudgeMinus || ProfileResult.nProfileDiff > ProfileResult.nJudgePlus)
					{
						ProfileResult.bProfileJudge = FALSE;
						m_pDefectControl->ExtractDefect_ProfileChamfer(eDimension,m_iCamera,stFrame.nScanIdx,DefectLoc_Profile,RCutResult.ptGlass,ptProfile->iIndex);
					}
				}				
			}	
			m_pGlassData->SetProfileInspectData(ProfileResult.iIndex,&ProfileResult);
			m_pGlassData->SetRCutProfileInspectData(RCutResult.iIndex,&RCutResult);
		}		

		if(pCamera->m_enCamDir == CAMDIR_TOP)
			pstChamferPrm = pPrm->m_stCamferUp;
		else
			pstChamferPrm = pPrm->m_stCamferDn;

		ChamferResult.iCam = ptProfile->iCam;
		ChamferResult.iFrame =  stFrame.nFrameIdx;
		ChamferResult.iIndex = ptProfile->iIndex;
		ChamferResult.iScan = ptProfile->iScan;
		ChamferResult.iSide = ptProfile->iSide;
		ChamferResult.nUp = (int)pCamera->m_enCamDir;
		ChamferResult.bUseJudge = pstChamferPrm[ptProfile->iIndex].use;		  
		ChamferResult.nJudgeReference = (int)ROUND(pstChamferPrm[ptProfile->iIndex].reference);
		ChamferResult.nJudgePlusChamfer = (int)ROUND(pstChamferPrm[ptProfile->iIndex].plus);
		ChamferResult.nJudgeMinusChamfer = (int)ROUND(pstChamferPrm[ptProfile->iIndex].minus);
		ChamferResult.nChamferThick = (int)ROUND(ptProfile->dChamfer-ChamferResult.nJudgeReference);
		ChamferResult.nChamferCalThick = abs((int)ROUND(ptProfile->dChamfer));
		ChamferResult.ptCADLine = ptProfile->ptCadLine;
		ChamferResult.ptChamferLine = ptProfile->ptChamfer;
		ChamferResult.ptGlassLine = ptProfile->ptGlass;

		ChamferResult.bChamferJudge = TRUE;
		RCutChamferRandom(ChamferResult);
		if(ChamferResult.bUseJudge == TRUE)
		{
			//if(RCutChamferRandom(ChamferResult) == FALSE)
			{
				if(ChamferResult.nChamferCalThick < ChamferResult.nJudgeReference-ChamferResult.nJudgeMinusChamfer || ChamferResult.nChamferCalThick > ChamferResult.nJudgeReference+ChamferResult.nJudgePlusChamfer)
				{
					ChamferResult.bChamferJudge = FALSE;
					m_pDefectControl->ExtractDefect_ProfileChamfer(eDimension,m_iCamera,stFrame.nScanIdx,DefectLoc_Chamfer,ChamferResult.ptGlassLine,ptProfile->iIndex);
				}
			}
		}

		m_pGlassData->SetProfileChamferInspectData(ChamferResult.iIndex,ChamferResult.nUp,&ChamferResult);
	}	

	return TRUE;
}

BOOL CInspectCamera::FindRCutProfilePosition(DimensionDir eDimension,stFrameIndex stFrame,CProfileCADProc *pProcess,vector< pair<double,STU_SPLINE_PROFILE_POSITION*> > &vecProfile,CvPoint2D32f *ptAlign)
{
	vector< pair<double,STU_SPLINE_PROFILE_POSITION*> >::iterator		it;
	STU_SPLINE_PROFILE_POSITION		*pProfilePos;

	double				dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return 0;	

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return 0;	

	for(it=vecProfile.begin();it!=vecProfile.end();it++)
	{
		pProfilePos = it->second;
		if(pProfilePos == NULL || pProfilePos->iIndex < 0)
			continue;
		
		FindRCutPosition(pProfilePos,eDimension,stFrame,pProcess);

		/*
		if(pProfilePos->iLoop == 0 || pProfilePos->iLoop == 4)
		{
			double			dTheta = (pProfilePos->dTheta);
			if(pProfilePos->dTheta == 0 || pProfilePos->dTheta == 360)
			{				
				pProfilePos->dDist = abs(pProfilePos->ptGlass.x-pProfilePos->ptCenterX)*dConv;
				pProfilePos->dChamfer = abs(pProfilePos->ptGlass.x-pProfilePos->ptChamfer.x)*dConv;			
			}
			else
			{
				pProfilePos->dDist = abs(pProfilePos->ptGlass.y-pProfilePos->ptCenterY)*dScan;
				pProfilePos->dChamfer = abs(pProfilePos->ptGlass.y-pProfilePos->ptChamfer.y)*dScan;
			}
		}
		else
		*/
		{
			double dDx	= abs(pProfilePos->ptGlass.x-pProfilePos->ptCenterX)*dConv;
			double dDy	= abs(pProfilePos->ptGlass.y-pProfilePos->ptCenterY)*dScan;
			pProfilePos->dDist = sqrtf(float(dDx *dDx + dDy*dDy));

			dDx	= abs(pProfilePos->ptGlass.x-pProfilePos->ptChamfer.x)*dConv;
			dDy	= abs(pProfilePos->ptGlass.y-pProfilePos->ptChamfer.y)*dScan;
			pProfilePos->dChamfer = sqrtf(float(dDx *dDx + dDy*dDy));
		}		
	}

	return TRUE;
}

BOOL CInspectCamera::FindRCutPosition(STU_SPLINE_PROFILE_POSITION *pProfilePos,DimensionDir eDimension,stFrameIndex stFrame,CProfileCADProc *pProcess)
{
	COwnerBuffer		bufTgt;	
	CEdgeProc			EdgeProc;

	/*
	if(pProfilePos->iLoop == 0 || pProfilePos->iLoop == 4)
	{
		FindRCutNoRotateFind(pProfilePos,pRecipe);
	}
	else
	*/
	{
		ROI		ImgROI = GetRCutProcessImage(pProfilePos,eDimension,stFrame,bufTgt);			

		if(pProfilePos->iPos <0 || pProfilePos->iPos > 1)
			return FALSE;

		int			nGlassThres = m_pRecipe->GetInspectInfo()->m_nRCutThresGlass[eDimension][1];
		int			nChamferThres = m_pRecipe->GetInspectInfo()->m_nRCutThresChamfer[eDimension][1];

		if(eDimension == DIMENSION_A || eDimension == DIMENSION_A_DN)
		{
			nGlassThres = m_pRecipe->GetInspectInfo()->m_nRCutThresGlass[eDimension][pProfilePos->iPos];
			nChamferThres = m_pRecipe->GetInspectInfo()->m_nRCutThresChamfer[eDimension][pProfilePos->iPos];
		}

		IMPOS2D				ptGlassEdgePos,ptChamferEdgePos;
		
		FindGlassChamfer(pProfilePos->iIndex,eDimension,stFrame,bufTgt,nGlassThres,nChamferThres,ptGlassEdgePos,ptChamferEdgePos);
		
		double dSin = sin(M_RADIAN(pProfilePos->dTheta));
		double dCos = cos(M_RADIAN(pProfilePos->dTheta));
		IMPOS2D				p1,posCen;

		posCen.u = pProfilePos->ptCenterX;
		posCen.v = pProfilePos->ptCenterY;

		ptGlassEdgePos.u += ImgROI.u1;
		ptGlassEdgePos.v += ImgROI.v1;
		ptChamferEdgePos.u += ImgROI.u1;
		ptChamferEdgePos.v += ImgROI.v1;

		EdgeProc.IMRotatePoint(ptGlassEdgePos, &p1, posCen, dSin, dCos) ;
		pProfilePos->ptGlass.x = (float)p1.u;
		pProfilePos->ptGlass.y = (float)p1.v;

		EdgeProc.IMRotatePoint(ptChamferEdgePos, &p1, posCen, dSin, dCos) ;

		pProfilePos->ptChamfer.x = (float)p1.u;
		pProfilePos->ptChamfer.y = (float)p1.v;	
	}	

	return TRUE;
}

BOOL CInspectCamera::FindGlassChamfer(int index,DimensionDir eDimension,stFrameIndex stFrame,CSISBuffer &bufTgt,int nGlassThres,int nChamferThres,IMPOS2D &ptGlassEdgePos,IMPOS2D &ptChamferEdgePos)
{
	CEdgeProc			EdgeProc;
	CSISEdgeFind		EdgeFind;		

	double		dPitch = 10;
	
	int			nGlassEdge = 0;
	if(EdgeFind.FindEdge_ToRight(&bufTgt,nGlassEdge,dPitch,nGlassThres,0.3,0) == FALSE)
	{
		ptGlassEdgePos.u = (float)bufTgt.GetWidth()/2;
		ptGlassEdgePos.v = (float)bufTgt.GetHeight()/2;
		g_pLog->DisplayMessage(_T("%s RCut Profile Edge Detect Fail : index %d"),PANEL_SIDE[eDimension],index);
	}
	else
	{
		ptGlassEdgePos.u = (float)nGlassEdge;
		ptGlassEdgePos.v = (float)bufTgt.GetHeight()/2;
	}

	COwnerBuffer		CopyBuffer(bufTgt.GetWidth(),bufTgt.GetHeight());
	CRect				CopyRect(0,0,bufTgt.GetWidth(),bufTgt.GetHeight());

	CSISBuffer::CopyBtoA(CopyBuffer,0,0,bufTgt,CopyRect);	

	EdgeProc.ThresholdProcessing(bufTgt.GetDataAddress(),CSize(bufTgt.GetWidth(),bufTgt.GetHeight()),nChamferThres,0);

	int				nChamferEndge = nGlassEdge+2;
	int				nContiCnt = 0;

	int				uStart,uEnd;

	uStart = (int)ptGlassEdgePos.u;
	uEnd = uStart + 80;
	if(uEnd > bufTgt.GetWidth()-1)
		uEnd = bufTgt.GetWidth()-1;

	for(int u=uStart;u<uEnd;u++)
	{
		if(bufTgt.GetPixel(u,bufTgt.GetHeight()/2) == 255)
			nContiCnt++;
		else
		{
			if(nContiCnt >= 3)
			{
				nChamferEndge = u-1;
				break;
			}
		}		
	}

	ptChamferEdgePos.u = (float)nChamferEndge;
	ptChamferEdgePos.v = (float)bufTgt.GetHeight()/2;	

	{
		for(int v=0;v<CopyBuffer.GetHeight();v++)
		{
			if(ptGlassEdgePos.u < 0 || ptGlassEdgePos.u > CopyBuffer.GetWidth())
				continue;
			CopyBuffer.SetPixel((int)ptGlassEdgePos.u,v,128);
			if(ptChamferEdgePos.u < 0 || ptChamferEdgePos.u > CopyBuffer.GetWidth())
				continue;
			CopyBuffer.SetPixel((int)ptChamferEdgePos.u,v,128);
		}
#if MARKIMG_NOTSAVE
		CString		str;
		str.Format(_T("%sIMG_MARK\\%s\\%s\\%s\\ChamferRes_%s_%d.bmp"), PATH_INSPECTION_DATA, g_pBase->m_strLoadingDay, g_pBase->m_strHPanelID, g_pBase->m_strLoadingTime, PANEL_SIDE[eDimension], index);
		CBufferAttach		attach(str);
		attach.AttachToFile(CopyBuffer);
#endif // 0	
	}

	return TRUE;
}

ROI CInspectCamera::GetRCutProcessImage(STU_SPLINE_PROFILE_POSITION *pProfilePos,DimensionDir eDimension,stFrameIndex stFrame,COwnerBuffer &pTgt)
{
	int					nDistance;
	ROI					aoi;
	double				dSin,dCos;
	IMPOS2D				posCen;
	int					n4ByteWidth;
	LPBYTE				lpBuffer;
	CEdgeProc			EdgeProc;
	CSISBuffer			bufOrg;
	const int			nSearchArea = 500;
	const int			nSearchHeight = 3;	

	dSin = sin(M_RADIAN(pProfilePos->dTheta));
	dCos = cos(M_RADIAN(pProfilePos->dTheta));
	posCen.u = pProfilePos->ptCenterX;
	posCen.v = pProfilePos->ptCenterY;

	nDistance = (int)GetRadus2Distance(eDimension,stFrame, pProfilePos->dTheta,pProfilePos->dRadius,dSin,dCos);	

	aoi.u1 = aoi.u2 = aoi.v1 = aoi.v2 = 0;
	lpBuffer = m_pGrabber->GetFrameHeaderLine(pProfilePos->iScan,0);
	if(lpBuffer == NULL)
		return aoi;

	int		nFrameWidth,nFrameHeight;
	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	bufOrg.SetBuffer(lpBuffer,nFrameWidth,g_pBase->m_pMemFrameNo[m_iCamera]*nFrameHeight);

	aoi.u1 = (int)ROUND(posCen.u) - nDistance - nSearchArea;
	aoi.u2 = (int)ROUND(posCen.u) - nDistance + nSearchArea;
	aoi.v1 = (int)ROUND(posCen.v) - nSearchHeight;
	aoi.v2 = (int)ROUND(posCen.v) + nSearchHeight;

	n4ByteWidth = align_4byte(EdgeProc.IMROIWidth(aoi));
	aoi.u2 = aoi.u1 + n4ByteWidth;
	pTgt.SetSize(EdgeProc.IMROIWidth(aoi),EdgeProc.IMROIHeight(aoi));

	EdgeProc.IMGetRotImg(aoi,bufOrg,pTgt,posCen,dSin,dCos);	

	return aoi;
}

double CInspectCamera::GetRadus2Distance(DimensionDir eDimension,stFrameIndex stFrame,double dtheta,double dRadius,double dSin,double dCons)
{
	CvPoint2D32f		iPos;
	double				dXPos,dYPos;
	double				dConv,dScan;
	CEdgeProc			EdgeProc;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return 0;	

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return 0;	

	iPos.x = (float)dRadius;
	iPos.y = 0;
	EdgeProc.RotatePoint(iPos, dXPos,dYPos,dSin, dCons);

	double dDx	= dXPos/dConv;
	double dDy	= dYPos/dScan;

	return sqrtf(float(dDx *dDx + dDy*dDy));
}

#define MAX_RCUT_PROFILE_COUNT 5
BOOL CInspectCamera::RCutRandom(PROFILE_RESULT &ProfileResult)
{
	CInspectOption	*pOpt =	g_pStatus->GetInspectOption();

	if(pOpt->bUseRandomData == FALSE)
		return FALSE;

	CRandomDataSet		*pDataSet = NULL;
	if(PROFILE_RCUT_INSPECT_INDEX_A <= ProfileResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_A+MAX_RCUT_PROFILE_COUNT > ProfileResult.iIndex)
		pDataSet = &pOpt->A1_Rcut;
	else if(PROFILE_RCUT_INSPECT_INDEX_B <= ProfileResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_B+MAX_RCUT_PROFILE_COUNT > ProfileResult.iIndex)
		pDataSet = &pOpt->A2_Rcut;
	else if(PROFILE_RCUT_INSPECT_INDEX_C <= ProfileResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_C+MAX_RCUT_PROFILE_COUNT > ProfileResult.iIndex)
		pDataSet = &pOpt->C1_Rcut;
	else if(PROFILE_RCUT_INSPECT_INDEX_D <= ProfileResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_D+MAX_RCUT_PROFILE_COUNT > ProfileResult.iIndex)
		pDataSet = &pOpt->C2_Rcut;	

	if(pDataSet == NULL)
		return FALSE;

	if(abs(ProfileResult.nProfileDiff) > pDataSet->Profile.dLimit)
		return FALSE;

	if(ProfileResult.nProfileDiff < pDataSet->Profile.dMin || ProfileResult.nProfileDiff > pDataSet->Profile.dMax)
	{
		int		nRandMax = (int)max(fabs(pDataSet->Profile.dMin),fabs(pDataSet->Profile.dMax));
		
		int		nValue = rand()%nRandMax;
		int		nDir = rand()%1;

		if(nDir == 0)
		{
			if(nValue > fabs(pDataSet->Profile.dMin))
				nValue = (int)pDataSet->Profile.dMin;			

			if(nValue > 0)
				nValue = -1*nValue;
		}
		else
		{
			if(nValue > fabs(pDataSet->Profile.dMax))
				nValue = (int)pDataSet->Profile.dMax;

			if(nValue < 0)
				nValue = -1*nValue;
		}

		ProfileResult.nProfileDiff = nValue;
	}

	return TRUE;
}

BOOL CInspectCamera::ProfileRandom(PROFILE_RESULT &ProfileResult)
{
	CInspectOption	*pOpt =	g_pStatus->GetInspectOption();

	if(pOpt->bUseRandomData == FALSE)
		return FALSE;

	CRandomDataSet		*pDataSet = NULL;
	if(PROFILE_INSPECT_INDEX_B <= ProfileResult.iIndex && PROFILE_INSPECT_INDEX_B+PROFILE_INSPECT_SIZE_B_D > ProfileResult.iIndex)
		pDataSet = &pOpt->B_GrindLine;
	else if(PROFILE_INSPECT_INDEX_D <= ProfileResult.iIndex && PROFILE_INSPECT_INDEX_D+PROFILE_INSPECT_SIZE_B_D > ProfileResult.iIndex)
		pDataSet = &pOpt->D_GrindLine;
	else if(PROFILE_INSPECT_INDEX_C <= ProfileResult.iIndex && PROFILE_INSPECT_INDEX_C+PROFILE_INSPECT_SIZE_A_C > ProfileResult.iIndex)
		pDataSet = &pOpt->C_GrindLine;
	else if(PROFILE_INSPECT_INDEX_A <= ProfileResult.iIndex && PROFILE_INSPECT_INDEX_A+PROFILE_INSPECT_SIZE_A_C > ProfileResult.iIndex)
		pDataSet = &pOpt->A1_GrindLine;
	else if(PROFILE_INSPECT_INDEX_CF <= ProfileResult.iIndex && PROFILE_INSPECT_INDEX_CF+PROFILE_INSPECT_SIZE_A_C > ProfileResult.iIndex)
		pDataSet = &pOpt->A2_GrindLine;

	if(pDataSet == NULL)
		return FALSE;

	if(abs(ProfileResult.nProfileDiff) > pDataSet->Profile.dLimit)
		return FALSE;

	if(ProfileResult.nProfileDiff < pDataSet->Profile.dMin || ProfileResult.nProfileDiff > pDataSet->Profile.dMax)
	{
		int		nRandMax = (int)max(fabs(pDataSet->Profile.dMin),fabs(pDataSet->Profile.dMax));

		int		nValue = rand()%nRandMax;
		int		nDir = rand()%1;

		if(nDir == 0)
		{
			if(nValue > fabs(pDataSet->Profile.dMin))
				nValue = (int)pDataSet->Profile.dMin;			

			if(nValue > 0)
				nValue = -1*nValue;
		}
		else
		{
			if(nValue > fabs(pDataSet->Profile.dMax))
				nValue = (int)pDataSet->Profile.dMax;

			if(nValue < 0)
				nValue = -1*nValue;
		}

		ProfileResult.nProfileDiff = nValue;
	}

	return TRUE;
}

BOOL CInspectCamera::RCutChamferRandom(CHAMFER_RESULT &ChamferResult)
{
	CInspectOption	*pOpt =	g_pStatus->GetInspectOption();

	if(pOpt->bUseRandomData == FALSE)
		return FALSE;

	CRandomDataSet		*pDataSet = NULL;
	if(PROFILE_RCUT_INSPECT_INDEX_A <= ChamferResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_A+MAX_RCUT_PROFILE_COUNT > ChamferResult.iIndex)
		pDataSet = &pOpt->A1_Rcut;
	else if(PROFILE_RCUT_INSPECT_INDEX_B <= ChamferResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_B+MAX_RCUT_PROFILE_COUNT > ChamferResult.iIndex)
		pDataSet = &pOpt->A2_Rcut;
	else if(PROFILE_RCUT_INSPECT_INDEX_C <= ChamferResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_C+MAX_RCUT_PROFILE_COUNT > ChamferResult.iIndex)
		pDataSet = &pOpt->C1_Rcut;
	else if(PROFILE_RCUT_INSPECT_INDEX_D <= ChamferResult.iIndex && PROFILE_RCUT_INSPECT_INDEX_D+MAX_RCUT_PROFILE_COUNT > ChamferResult.iIndex)
		pDataSet = &pOpt->C2_Rcut;	

	if(pDataSet == NULL)
		return FALSE;

	CRandomData		*pRndData = NULL;

	if(ChamferResult.nUp == CAMDIR_TOP)
		pRndData = &pDataSet->ChamferUp;
	else
		pRndData = &pDataSet->ChamferDn;

	if(abs(ChamferResult.nChamferCalThick) > pRndData->dLimit)
		return FALSE;

	if(ChamferResult.nChamferCalThick < pRndData->dMin || ChamferResult.nChamferCalThick > pRndData->dMax)
	{
		int		nRandMax = (int)max(fabs(pRndData->dMin),fabs(pRndData->dMax));
		int		nValue = rand()%nRandMax;

		if(abs(nValue) < fabs(pRndData->dMin))
			nValue = (int)pRndData->dMin;	
		if(abs(nValue) > fabs(pRndData->dMax))
			nValue = (int)pRndData->dMax;	

		ChamferResult.nChamferCalThick = abs(nValue);
	}

	ChamferResult.nChamferThick = (int)ROUND(ChamferResult.nChamferCalThick-ChamferResult.nJudgeReference);

	return TRUE;
}

BOOL CInspectCamera::ChamferRandom(CHAMFER_RESULT &ChamferResult)
{
	CInspectOption	*pOpt =	g_pStatus->GetInspectOption();

	if(pOpt->bUseRandomData == FALSE)
		return FALSE;

	CRandomDataSet		*pDataSet = NULL;
	if(PROFILE_INSPECT_INDEX_B <= ChamferResult.iIndex && PROFILE_INSPECT_INDEX_B+PROFILE_INSPECT_SIZE_B_D > ChamferResult.iIndex)
		pDataSet = &pOpt->B_GrindLine;
	else if(PROFILE_INSPECT_INDEX_D <= ChamferResult.iIndex && PROFILE_INSPECT_INDEX_D+PROFILE_INSPECT_SIZE_B_D > ChamferResult.iIndex)
		pDataSet = &pOpt->D_GrindLine;
	else if(PROFILE_INSPECT_INDEX_C <= ChamferResult.iIndex && PROFILE_INSPECT_INDEX_C+PROFILE_INSPECT_SIZE_A_C > ChamferResult.iIndex)
		pDataSet = &pOpt->C_GrindLine;
	else if(PROFILE_INSPECT_INDEX_A <= ChamferResult.iIndex && PROFILE_INSPECT_INDEX_A+PROFILE_INSPECT_SIZE_A_C > ChamferResult.iIndex)
		pDataSet = &pOpt->A1_GrindLine;
	else if(PROFILE_INSPECT_INDEX_CF <= ChamferResult.iIndex && PROFILE_INSPECT_INDEX_CF+PROFILE_INSPECT_SIZE_A_C > ChamferResult.iIndex)
		pDataSet = &pOpt->A2_GrindLine;

	if(pDataSet == NULL)
		return FALSE;

	CRandomData		*pRndData = NULL;

	if(ChamferResult.nUp == CAMDIR_TOP)
		pRndData = &pDataSet->ChamferUp;
	else
		pRndData = &pDataSet->ChamferDn;

	if(abs(ChamferResult.nChamferCalThick) > pRndData->dLimit)
		return FALSE;

	if(ChamferResult.nChamferCalThick < pRndData->dMin || ChamferResult.nChamferCalThick > pRndData->dMax)
	{
		int		nRandMax = (int)max(fabs(pRndData->dMin),fabs(pRndData->dMax));
		int		nValue = rand()%nRandMax;

		if(abs(nValue) < fabs(pRndData->dMin))
			nValue = (int)pRndData->dMin;	
		if(abs(nValue) > fabs(pRndData->dMax))
			nValue = (int)pRndData->dMax;	

		ChamferResult.nChamferCalThick = abs(nValue);
	}

	ChamferResult.nChamferThick = (int)ROUND(ChamferResult.nChamferCalThick-ChamferResult.nJudgeReference);

	return TRUE;
}

BOOL CInspectCamera::CalculateProfileChamfer(DimensionDir emDim,stFrameIndex stFrame,CProfileCADProc *pProcess,vector< pair<int,STU_PROFILE_POSITION*> > &vecProfile,CvPoint2D32f ptAlign)
{
	if((int)vecProfile.size() <= 0)
		return FALSE;
	if(m_pGlassData == NULL)
		return FALSE;

	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();
	vector< pair<int,STU_PROFILE_POSITION*> >::iterator		it;
	STU_PROFILE_POSITION		*ptProfile;
	STU_THICKPOS	stThick;
	int				nPosY;
	PROFILE_RESULT	ProfileResult;
	CHAMFER_RESULT	ChamferResult;
	ST_PROFILE_SETTING	stPrm;
	ST_CHAMFER_SETTING	stChamferPrm;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return FALSE;	

	double dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	if(dConv <= 0)
		return FALSE;	

	double		dProfileAvg;
	double		dChamferAvg;

	GetAvgProfileNChamfer(emDim,stFrame,vecProfile,dProfileAvg,dChamferAvg);

	INS_EDGE_RESULT_INFO *pResInfo =  NULL;
	pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);

	CINSPECT_JUDGEMENT_PARM *pJudgePrm = m_pRecipe->GetJudgePrm();

	srand((unsigned int)time(NULL));

	for(it=vecProfile.begin();it!=vecProfile.end();it++)
	{
		ptProfile = it->second;
		if(ptProfile == NULL)
			continue;
		if(ptProfile->iIndex < 0 || ptProfile->iIndex >= MAX_PROFILE_SETTING_COUNT)
			continue;

		stPrm = pPrm->m_stProfile[ptProfile->iIndex];
		if(pCamera->m_enCamDir == CAMDIR_TOP)
			stChamferPrm = pPrm->m_stCamferUp[ptProfile->iIndex];
		else
			stChamferPrm = pPrm->m_stCamferDn[ptProfile->iIndex];

		nPosY = ptProfile->point.y;
		nPosY -= pResInfo->nGlassStartLine;
		stThick = GetThickPosResultPos(stFrame,nPosY);

		ProfileResult.ptFullImg.x = (float)ptProfile->point.x;
		ProfileResult.ptFullImg.y = (float)ptProfile->point.y;		
		ProfileResult.ptGlassLine.x = (float)stThick.nLeftLine;
		ProfileResult.ptGlassLine.y = (float)ptProfile->point.y;	

		ProfileResult.iCam = m_iCamera;
		ProfileResult.iIndex = ptProfile->iIndex;
		ProfileResult.iFrame = stFrame.nFrameIdx;
		ProfileResult.iScan = stFrame.nScanIdx;
		ProfileResult.iSide = (int)emDim;		

		if(pCamera->m_enCamDir == CAMDIR_BOTTOM)
		{			
			ProfileResult.ptGlassAlign.x = (float)ptProfile->point.x;
			ProfileResult.ptGlassAlign.y = (float)ptProfile->point.y;
			ProfileResult.ptGlassAlign.y += (float)(-1*ptAlign.y);
			ProfileResult.ptGlassStart = ProfileResult.ptFullImg;
			ProfileResult.ptGlassStart.y += (float)(-pResInfo->nGlassStartLine);					
			ProfileResult.nProfileDiff = (int)((double)(ptProfile->point.x - stThick.nLeftLine)*dConv);	
			ProfileResult.bUseJudge = stPrm.use;		
			ProfileResult.nJudgePlus = (int)(stPrm.plus);
			ProfileResult.nJudgeMinus = (int)(stPrm.minus);			

			ProfileResult.bProfileJudge = TRUE;
			ProfileRandom(ProfileResult);
			if(ProfileResult.bUseJudge == TRUE)
			{
				//if(ProfileRandom(ProfileResult) == FALSE)
				{
					if(ProfileResult.nProfileDiff < -1*ProfileResult.nJudgeMinus || ProfileResult.nProfileDiff > ProfileResult.nJudgePlus)
					{
						if(pJudgePrm->AvgProfile[emDim].bUse == TRUE && dProfileAvg > 0)
						{
							if(abs(ProfileResult.nProfileDiff-(int)dProfileAvg) > pJudgePrm->AvgProfile[emDim].nDiff)
							{
								ProfileResult.bProfileJudge = FALSE;
								m_pDefectControl->ExtractDefect_ProfileChamfer(emDim,m_iCamera,stFrame.nScanIdx,DefectLoc_Profile,ProfileResult.ptFullImg,ptProfile->iIndex);
								g_pLog->DisplayMessage(_T("%s Avg Profile Option NG : Index %d,Diff %d,Avg %.2f,Setting %d"),PANEL_SIDE[emDim],ProfileResult.iIndex,ProfileResult.nProfileDiff,dProfileAvg,pJudgePrm->AvgProfile[emDim].nDiff);
							}
						}
						else
						{
							ProfileResult.bProfileJudge = FALSE;
							m_pDefectControl->ExtractDefect_ProfileChamfer(emDim,m_iCamera,stFrame.nScanIdx,DefectLoc_Profile,ProfileResult.ptFullImg,ptProfile->iIndex);
						}					
					}
				}				
			}		

			m_pGlassData->SetProfileInspectData(ptProfile->iIndex,&ProfileResult);
		}		

		ChamferResult.iCam = m_iCamera;
		ChamferResult.iIndex = ptProfile->iIndex;
		ChamferResult.iFrame = stFrame.nFrameIdx;
		ChamferResult.iScan = stFrame.nScanIdx;
		ChamferResult.iSide = (int)emDim;
		ChamferResult.nUp = (int)pCamera->m_enCamDir;
		ChamferResult.nJudgeReference = (int)(stChamferPrm.reference);
		ChamferResult.nJudgeMinusChamfer = (int)(stChamferPrm.minus);
		ChamferResult.nJudgePlusChamfer = (int)(stChamferPrm.plus);
		ChamferResult.bUseJudge = stChamferPrm.use;
		ChamferResult.nChamferThick = (int)(stThick.dThick-ChamferResult.nJudgeReference);	
		ChamferResult.nChamferCalThick = abs((int)ROUND(stThick.dThick));
		ChamferResult.nGlassLeft = stThick.nLeftLine;
		ChamferResult.nGlassRight = stThick.nRightLine;
		ChamferResult.ptChamferLine.x = (float)stThick.nRightLine-1;
		ChamferResult.ptChamferLine.y = (float)(ProfileResult.ptFullImg.y);
		ChamferResult.ptFull.x = (float)ptProfile->point.x;
		ChamferResult.ptFull.y = (float)ptProfile->point.y;		

		ChamferResult.bChamferJudge = TRUE;
		//ChamferRandom(ChamferResult);
		if(ChamferResult.bUseJudge == TRUE)
		{
			if(ChamferRandom(ChamferResult) == FALSE)
			{
				if(ChamferResult.nChamferCalThick < ChamferResult.nJudgeReference-ChamferResult.nJudgeMinusChamfer || ChamferResult.nChamferCalThick > ChamferResult.nJudgeReference+ChamferResult.nJudgePlusChamfer)
				{
					if(pJudgePrm->AvgChamfer[emDim].bUse == TRUE && dChamferAvg > 0)
					{
						if(abs(ChamferResult.nChamferCalThick-(int)dChamferAvg) > pJudgePrm->AvgChamfer[emDim].nDiff)
						{
							ChamferResult.bChamferJudge = FALSE; 
							m_pDefectControl->ExtractDefect_ProfileChamfer(emDim,m_iCamera,stFrame.nScanIdx,DefectLoc_Chamfer,ChamferResult.ptFull,ptProfile->iIndex);

							g_pLog->DisplayMessage(_T("%s Avg Chamfer Option NG : Index %d,Diff %d,Avg %.2f,Setting %d"),PANEL_SIDE[emDim],ChamferResult.iIndex,ChamferResult.nChamferCalThick,dChamferAvg,pJudgePrm->AvgChamfer[emDim].nDiff);
						}
					}
					else
					{
						ChamferResult.bChamferJudge = FALSE; 
						m_pDefectControl->ExtractDefect_ProfileChamfer(emDim,m_iCamera,stFrame.nScanIdx,DefectLoc_Chamfer,ChamferResult.ptFull,ptProfile->iIndex);
					}					
				}
			}			
		}

		m_pGlassData->SetProfileChamferInspectData(ChamferResult.iIndex,ChamferResult.nUp,&ChamferResult);

	}

	g_pLog->DisplayMessage(_T("%s Calculate Profile Postion :Profile %d"),PANEL_SIDE[emDim],(int)vecProfile.size());

	return TRUE;
}

STU_THICKPOS CInspectCamera::GetThickPosResultPos( stFrameIndex stFrame,int nYPos)
{
	int			nMinPos = INT_MAX;

	std::vector<STU_THICKPOS>::iterator	it;
	STU_THICKPOS	stTmpThick;
	STU_THICKPOS	stThick;

	for(it=m_resultThickPos[stFrame.nScanIdx].begin();it!=m_resultThickPos[stFrame.nScanIdx].end();it++)
	{
		stTmpThick = *it;
		
		if(abs(stTmpThick.nTopLine-nYPos) < nMinPos)
		{
			nMinPos = abs(stTmpThick.nTopLine-nYPos);
			stThick = stTmpThick;
		}
	}

	return stThick;
}

BOOL CInspectCamera::GetAvgProfileNChamfer(DimensionDir emDim,stFrameIndex stFrame,vector< pair<int,STU_PROFILE_POSITION*> > &vecProfile,double &dProfileAvg,double &dChamferAvg)
{
	double		dProfileCnt,dChamferCnt;
	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();
	vector< pair<int,STU_PROFILE_POSITION*> >::iterator		it;
	STU_PROFILE_POSITION		*ptProfile;
	STU_THICKPOS	stThick;
	ST_PROFILE_SETTING	stPrm;
	ST_CHAMFER_SETTING	stChamferPrm;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return FALSE;	

	double dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	if(dConv <= 0)
		return FALSE;	

	INS_EDGE_RESULT_INFO *pResInfo =  NULL;
	pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);

	double	dProfileSum,dChamferSum;

	dProfileAvg = dProfileCnt = dChamferAvg = dChamferCnt = 0.;
	dProfileSum = dChamferSum = 0.;

	CINSPECT_JUDGEMENT_PARM *pJudgePrm = m_pRecipe->GetJudgePrm();
	if(pJudgePrm->AvgProfile[emDim].bUse == TRUE || pJudgePrm->AvgChamfer[emDim].bUse == TRUE)
	{
		for(it=vecProfile.begin();it!=vecProfile.end();it++)
		{
			ptProfile = it->second;
			if(ptProfile == NULL)
				continue;
			if(ptProfile->iIndex < 0 || ptProfile->iIndex >= MAX_PROFILE_SETTING_COUNT)
				continue;

			stPrm = pPrm->m_stProfile[ptProfile->iIndex];			

			int nPosY = ptProfile->point.y;
			nPosY -= pResInfo->nGlassStartLine;

			stThick = GetThickPosResultPos(stFrame,nPosY);

			if(pJudgePrm->AvgProfile[emDim].bUse == TRUE)
			{
				if(pCamera->m_enCamDir == CAMDIR_BOTTOM)
				{
					int nDiffProfile = (int)((double)(ptProfile->point.x - stThick.nLeftLine)*dConv);	
					if(nDiffProfile < -1*(int)(stPrm.minus) || nDiffProfile > (int)(stPrm.plus))
					{
						;
					}
					else
					{
						dProfileSum += nDiffProfile;
						dProfileCnt++;
					}
				}
			}

			if(pJudgePrm->AvgChamfer[emDim].bUse == TRUE)
			{
				if(pCamera->m_enCamDir == CAMDIR_TOP)
					stChamferPrm = pPrm->m_stCamferUp[ptProfile->iIndex];
				else
					stChamferPrm = pPrm->m_stCamferDn[ptProfile->iIndex];

				int nChamferThick = (int)(stThick.dThick-(int)(stChamferPrm.reference));	

				if(nChamferThick < -1*(int)(stChamferPrm.minus) || nChamferThick > (int)(stChamferPrm.plus))
				{
					;
				}
				else
				{
					dChamferSum += (int)ROUND(stThick.dThick);
					dChamferCnt++;
				}
			}
		}
	}

	if(dProfileCnt > 0)
		dProfileAvg = dProfileSum/dProfileCnt;
	if(dChamferCnt > 0)
		dChamferAvg = dChamferSum/dChamferCnt;

	return TRUE;
}

BOOL CInspectCamera::MakeProfilePosition(DimensionDir emDim,stFrameIndex stFrame,CProfileCADProc *pProcess,vector< pair<int,STU_PROFILE_POSITION*> > &vecProfile,CvPoint2D32f *ptAlign)
{
	if(m_pGlassData == NULL)
	{
		g_pLog->DisplayMessage(_T("%s MakeProfilePosition Glass NULL : Frame %d"),PANEL_SIDE[emDim],stFrame.nFrameIdx);
		return FALSE;
	}

	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();

	CvPoint2D32f		ptOffset;
	double		dConv,dScan;

	ptOffset.x = (float)pPrm->m_nCADOffsetX[emDim];
	ptOffset.y = (float)pPrm->m_nCADOffsetY[emDim];

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
	{
		g_pLog->DisplayMessage(_T("%s MakeProfilePosition Camera NULL : Frame %d"),PANEL_SIDE[emDim],stFrame.nFrameIdx);
		return FALSE;	
	}
	
	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
	{
		g_pLog->DisplayMessage(_T("%s MakeProfilePosition Res Null : Frame %d, %d,%.3f,%.3f"),PANEL_SIDE[emDim],stFrame.nFrameIdx,g_pBase->m_nStageNo,dConv,dScan);
		return FALSE;
	}

	ptOffset.x = (float)((double)ptOffset.x / dConv);
	ptOffset.y = (float)((double)ptOffset.y / dScan);	

	int			nRcpIndex,nRcpIndexEnd;
	int			iIndex;
	ST_PROFILE_SETTING	stProfile;
	const int	nRange = 5;
	STU_PROFILE_POSITION	*pPfPositon;
	CString		str;

	if(m_pGlassData->GetProfileInspectIndex(emDim,nRcpIndex,nRcpIndexEnd,str) == FALSE)
	{
		g_pLog->DisplayMessage(_T("%s MakeProfilePosition GetProfileInspectIndex NULL : Frame %d, %d,%d"),PANEL_SIDE[emDim],stFrame.nFrameIdx,nRcpIndex,nRcpIndexEnd);
		return FALSE;
	}

	pProcess->RotateProfileData(ptAlign[0],ptAlign[1],ptOffset);

	int			nAlignOffset = 0;
	CINSPECT_JUDGEMENT_PARM *pJudgePrm = m_pRecipe->GetJudgePrm();	

	switch(emDim)
	{
	case DIMENSION_C:
	case DIMENSION_C_DN:
		nAlignOffset = 4777;//pJudgePrm->ptAlign[0][DIMENSION_C].y - pJudgePrm->ptAlign[0][DIMENSION_A].y;
		break;
	case DIMENSION_B:
	case DIMENSION_B_DN:
	case DIMENSION_D:
	case DIMENSION_D_DN:
		nAlignOffset = -9000;//1440;//pJudgePrm->ptAlign[0][pRecipe->GetDimension()].y - 1440; // Edge <-> Align : 1.44mm 父怒 哗霖促.
		break;
	}

	CPoint		ptCADOrgin = pProcess->GetProfileOrigin();
	for(iIndex=nRcpIndex;iIndex<nRcpIndex+nRcpIndexEnd;iIndex++)
	{
		stProfile = pPrm->m_stProfile[iIndex];
		if(stProfile.use == FALSE)
			continue;

		pPfPositon = new STU_PROFILE_POSITION;

		pPfPositon->nMin = (int)((stProfile.y)/dScan) -nRange;
		pPfPositon->nMax = (int)((stProfile.y)/dScan) + nRange;
		pPfPositon->nMin += (int)ptCADOrgin.y;
		pPfPositon->nMax += (int)ptCADOrgin.y;
		// 		pPfPositon->nMin += (int)(ptAlign[0].y-ptCADOrgin.y);
		// 		pPfPositon->nMax += (int)(ptAlign[0].y-ptCADOrgin.y);
		pPfPositon->nMin += (int)(nAlignOffset/dScan);
		pPfPositon->nMax += (int)(nAlignOffset/dScan);

		pPfPositon->iIndex = iIndex;
		pPfPositon->iScan = stFrame.nScanIdx;
		pPfPositon->iSide = (int)emDim;

		vecProfile.push_back(make_pair(pPfPositon->nMin, pPfPositon));				
	}

	std::sort(vecProfile.begin(),vecProfile.end(),less< pair<int,STU_PROFILE_POSITION*> >());

	pProcess->GetProfilePosition(vecProfile);

	g_pLog->DisplayMessage(_T("%s Make Profile Postion :Profile %d"),PANEL_SIDE[emDim],(int)vecProfile.size());

	return TRUE;
}

void CInspectCamera::CalculateStageTheta(DimensionDir emDim,int iScan, CvPoint2D32f *pAlign)
{
	BOOL		bLong;
	switch(emDim)
	{
	case DIMENSION_A:
		bLong = TRUE;
		break;
	case DIMENSION_B:
		bLong = FALSE;
		break;
	default:
		return;
	}

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,iScan);
	if(pCamera == NULL)
		return;	

	double dx = (pAlign[1].x-pAlign[0].x) * pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	double dy = (pAlign[1].y-pAlign[0].y) * pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	double dTheta = asin(dx/dy) * RAD_TO_DEGREE;

	if(dTheta > 1.0 || dTheta < -1.0)
	{
		g_pLog->DisplayMessage(_T("%s Calculate %d Stage Theta Limit over[degree 1] : %.3f -> 0"),PANEL_SIDE[emDim],g_pBase->m_nStageNo,dTheta);
		dTheta = 0;
	}

	short nTheta = (short)(-1*dTheta*1000);

	m_pGlassData->SetStageTheta(g_pBase->m_nStageNo,bLong,nTheta);

	g_pLog->DisplayMessage(_T("%s Calculate %d Stage Theta : %.3f, Send %d"),PANEL_SIDE[emDim],g_pBase->m_nStageNo,dTheta,nTheta);
}

BOOL CInspectCamera::CheckProfile(int iThread,DimensionDir emDim,stFrameIndex stFrame)
{
	INS_EDGE_RESULT_INFO *pResInfo =  NULL;

	if(m_pGlassData != NULL)
		pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);

	if(pResInfo == NULL)
		return FALSE;

	if(pResInfo->nPreGlassEndLine <= 0)
		return FALSE;

	if(pResInfo->nPreGlassEndFrame > stFrame.nFrameIdx)
		return FALSE;

	CSingleLock		cLock(&m_csThreadProfile);
	cLock.Lock();

	if(m_bProfileFind[stFrame.nScanIdx] == TRUE)
	{
		cLock.Unlock();
		return FALSE;
	}

	m_bProfileFind[stFrame.nScanIdx] = TRUE;
	m_nProfileFindFrameIdx[stFrame.nScanIdx] = stFrame.nFrameIdx;
	cLock.Unlock();	

	return TRUE;
}

void CInspectCamera::FinallyVisionProc(DimensionDir eDim, stFrameIndex stFrame) {
	/* code */
	INS_EDGE_RESULT_INFO *pResInfo = m_pGlassData->GetEdgeResultInfo(eDim);
	BOOL isFindSuccess = pResInfo->bMark[0] && pResInfo->bMark[1];
	if (!isFindSuccess) return;

	PROFILECHAMFER_RESULT_DATA* pProfileResult = m_pGlassData->GetProfileInspectData();

	double lastTime = GetTickCount();
	int idx = (int)(eDim);
	double dTime = fabs(lastTime - m_fInspectLastTime[idx]);
	if (dTime < 3000) return;

	CBlSideData *pBlSideData = BlVision_GetVisionRecipe()->getSideData(eDim);
	//Set Info
	pBlSideData->m_bInspection_Complete = TRUE;
	pBlSideData->m_bTopMark_Find = FALSE;
	pBlSideData->m_bBotMark_Find = FALSE;
	pBlSideData->m_bTopPoint_Find = FALSE;
	pBlSideData->m_bBotPoint_Find = FALSE;
	pBlSideData->m_mTopMark.x = 0;
	pBlSideData->m_mTopMark.y = 0;
	pBlSideData->m_mBotMark.x = 0;
	pBlSideData->m_mBotMark.y = 0;
	pBlSideData->m_mTopPoint.x = 0;
	pBlSideData->m_mTopPoint.y = 0;
	pBlSideData->m_mBotPoint.x = 0;
	pBlSideData->m_mBotPoint.y = 0;
	pBlSideData->m_nStartLine = 0;
	pBlSideData->m_nEndLine = 0;

	//Set MarkPos
	if (pResInfo->bMark[0]) {
		pBlSideData->m_bTopMark_Find = TRUE;
		pBlSideData->m_mTopMark.x = (int)(pResInfo->ptMark[0].x);
		pBlSideData->m_mTopMark.y = (int)(pResInfo->ptMark[0].y);
	}

	//Set MarkPos
	if (pResInfo->bMark[1]) {
		pBlSideData->m_bBotMark_Find = TRUE;
		pBlSideData->m_mBotMark.x = (int)(pResInfo->ptMark[1].x);
		pBlSideData->m_mBotMark.y = (int)(pResInfo->ptMark[1].y);
	}

	pBlSideData->m_nStartLine = pResInfo->nGlassStartLine;
	pBlSideData->m_nEndLine = pResInfo->nGlassEndLine;

	m_fInspectLastTime[idx] = lastTime;
	pBlSideData->m_vDispVisionResult.clear();

	int nStageNo = (g_pBase->m_nStageNo > 1 || g_pBase->m_nStageNo < 0) ? 0 : g_pBase->m_nStageNo;
	BlVision_GetSoftVisionApp()->setStage(g_pBase->m_nStageNo);

	NgInfo ngArray[NG_INF_TOTAL];
	int ngNum = BlVision_GetSoftVisionApp()->Execute((int)(eDim), ngArray);
	if (ngNum < 1) return;

#if 0
	typedef struct _NgInfo
	{
		int eDir;                //检测面
		int id;                  //检测ID
		CString strName;        //名称
		int xPosPxl;            //X位置
		int yPosPxl;            //Y位置
		double result;          //结果
		double xResult;          //结果
		double yResult;         //结果
		double minValue;        //下限
		double maxValue;        //限制
		int ngType;             //缺陷类型
		bool isRes;             //检测结果
		int x1;                 //缺陷的最小矩形
		int y1;                 //缺陷的最小矩形
		int x2;                 //缺陷的最小矩形
		int y2;                 //缺陷的最小矩形
		int eVision;            //视觉算法
	}NgInfo;
#endif
	CString test_data_kdist;
	CString test_file_path;
	CFile test_module;
	CFileException test_exception;

	CString glass_id;
	glass_id.Format(_T("%s"), g_pBase->m_strHPanelID);
	CString	strTime = g_pBase->m_strLoadingTime;
	std::string array_dir_use[9] = { "A TOP","B TOP", "C TOP", "D TOP", "A BOT", "B BOT","C BOT", "D BOT", "NONE" };
	std::string array_type_use[7] = { "Unknown", "OK", "Chip", "Broken", "Grind", "Dist Cut", "Corner Dist" };

	test_file_path.Format(_T("D:\\TestData\\%s_TestData.csv"), g_pBase->m_strLoadingDay);
	::CreateDirectory(_T("D:\\TestData"), NULL);

	int	nFrameWidth, nFrameHeight;
	GetFrameSize(m_iCamera, stFrame.nScanIdx, nFrameWidth, nFrameHeight);
	INS_EDGE_RESULT_INFO* pEdgeInfo = m_pGlassData->GetEdgeResultInfo(eDim);
	if (pEdgeInfo == NULL)
		return;

	int	nSetEnd = pEdgeInfo->nGlassEndLine <= 0 ? pEdgeInfo->nPreGlassEndLine : pEdgeInfo->nGlassEndLine;
	int	nOffset = 1000;
	int	nStartLine = pEdgeInfo->nGlassStartLine - nOffset / 2;
	int	nEndLine = nSetEnd + nOffset / 2;
	int nDefectIdx = 0;
	int nChamferAlarmResultCount = 0;
	int nProAlarmResultCount_MinDiff = 0;
	
	CINSPECT_JUDGEMENT_PARM* pJudge = m_pRecipe->GetJudgePrm();
	for (int i = 0; i < ngNum; i++) {
		NgInfo ng = ngArray[i];    //侶쟁警속댄轎홧屈
		if (ng.eDir > 8 || ng.eDir < 0) continue;
		if (ng.ngType > 7 || ng.ngType < 0) continue;
		if (ng.x1 < 0 || ng.y1 < nStartLine) continue;
		if (ng.x2 > nFrameWidth || ng.y2 > nEndLine) continue;

		if ((1 == ng.ngType || 2 == ng.ngType)/* && (ng.result < ng.minValue || ng.result > ng.maxValue)*/)
		{
			CvPoint2D32f  ptDefec;
			ptDefec.x = ng.xPosPxl;
			ptDefec.y = ng.yPosPxl;
			CRect rectDefect(ng.x1, ng.y1, ng.x2, ng.y2);

			if (m_pDefectControl != NULL/* && nDefectIdx < 1*/)
				m_pDefectControl->ExtractDefect_KDist(eDim, m_iCamera, stFrame.nScanIdx, DefectLoc_RCUTChip, ptDefec, rectDefect, (int)(ng.result));

			//nDefectIdx++;
		}
		//Hole
		if ((6 == ng.ngType)/* && (ng.result < ng.minValue || ng.result > ng.maxValue)*/)
		{
			CvPoint2D32f  ptDefec;
			ptDefec.x = ng.xPosPxl;
			ptDefec.y = ng.yPosPxl;
			CRect rectDefect(ng.x1, ng.y1, ng.x2, ng.y2);
			std::vector<CRect> vecList;
			vecList.push_back(rectDefect);

			CPoint ps = rectDefect.CenterPoint();
			int offx = ng.x2 - ps.x;
			int offy = ng.y2 - ps.y;

			if (m_pDefectControl != NULL/* && nDefectIdx < 1*/)
			{
				m_pDefectControl->ExtractDefect_Hole(eDim, m_iCamera, stFrame.nScanIdx, vecList, ngNum, DefectLoc_Hole, CRect(offx, offy, 2 * offx, 2 * offy));
				g_pLog->m_nHoleAlarmState = 1;
			}	
		}
		if (5 == ng.ngType)
		{
			if (ng.eDir==4)
			{
				if (ng.id<6)
				{
					pProfileResult->ProfileData[59 + i].nProfileDiff = ng.result;
					if (ng.maxValue<ng.result||ng.minValue>ng.result)
					{
						pProfileResult->ProfileData[59+i].bUseJudge = TRUE;
						pProfileResult->ProfileData[59 + i].bProfileJudge = FALSE;
						if (pJudge->nMinProfileNgCount_MinDiff[ng.eDir] < abs(ng.result))
						{
							nProAlarmResultCount_MinDiff = 1;
						}
					}
				}
				else if (5<ng.id&& ng.id < 11)
				{
					pProfileResult->ProfileData[69 + i].nProfileDiff = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ProfileData[69 + i].bUseJudge = TRUE;
						pProfileResult->ProfileData[69+i].bProfileJudge = FALSE;
						
						if (pJudge->nMinProfileNgCount_MinDiff[ng.eDir] < abs(ng.result))
						{
							nProAlarmResultCount_MinDiff = 1;
						}
					}
				}
				else if (10<ng.id && ng.id < 16)
				{
					pProfileResult->ResultChamfer[49 + i][1].nChamferCalThick = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ResultChamfer[49 + i][1].bUseJudge = TRUE;
						pProfileResult->ResultChamfer[49 + i][1].bChamferJudge = FALSE;
						nChamferAlarmResultCount = 1;
					}
				}
				else if (15<ng.id && ng.id < 21)
				{
					pProfileResult->ResultChamfer[59 +i][1].nChamferCalThick = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ResultChamfer[59 + i][1].bUseJudge = TRUE;
						pProfileResult->ResultChamfer[59+i][1].bChamferJudge = FALSE;
						nChamferAlarmResultCount = 1;
					}
				}		
			}

			if (ng.eDir == 5)
			{
				if (ng.id < 6)
				{
					pProfileResult->ProfileData[64 + i].nProfileDiff = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ProfileData[64 + i].bUseJudge = TRUE;
						pProfileResult->ProfileData[64 + i].bProfileJudge = FALSE;
						
						if (pJudge->nMinProfileNgCount_MinDiff[ng.eDir] < abs(ng.result))
						{
							nProAlarmResultCount_MinDiff = 1;
						}
					}
				}
				else if (5 < ng.id && ng.id < 11)
				{
					pProfileResult->ResultChamfer[59 + i][1].nChamferCalThick = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ResultChamfer[59 + i][1].bUseJudge = TRUE;
						pProfileResult->ResultChamfer[59 + i][1].bChamferJudge = FALSE;
						nChamferAlarmResultCount = 1;
					}
				}
			}
			if (ng.eDir == 7)
			{
				if (ng.id < 6)
				{
					pProfileResult->ProfileData[69 + i].nProfileDiff = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ProfileData[69 + i].bUseJudge = TRUE;
						pProfileResult->ProfileData[69 + i].bProfileJudge = FALSE;
						
						if (pJudge->nMinProfileNgCount_MinDiff[ng.eDir] < abs(ng.result))
						{
							nProAlarmResultCount_MinDiff = 1;
						}
					}
				}
				else if (5 < ng.id && ng.id < 11)
				{
					pProfileResult->ResultChamfer[64 + i][1].nChamferCalThick = ng.result;
					if (ng.maxValue<ng.result || ng.minValue>ng.result)
					{
						pProfileResult->ResultChamfer[64 + i][1].bUseJudge = TRUE;
						pProfileResult->ResultChamfer[64+i][1].bChamferJudge = FALSE;
						nChamferAlarmResultCount = 1;		
					}
				}
			}
		}
			
		if (5 == ng.ngType && (ng.result < ng.minValue || ng.result > ng.maxValue))
		{
			CvPoint2D32f  ptDefec;
			ptDefec.x = ng.xPosPxl;
			ptDefec.y = ng.yPosPxl;

			if (test_data_kdist.IsEmpty())
			{
				test_data_kdist.AppendFormat(_T("%s,%s,%s,%s,%s,%f"),
					strTime,
					glass_id,
					array_type_use[ng.ngType],
					array_dir_use[ng.eDir],
					ng.strName,
					ng.result);
			}
			else
			{
				test_data_kdist.AppendFormat(_T("%s,%s,%f"),
					array_dir_use[ng.eDir],
					ng.strName,
					ng.result);
			}

			CRect rectDefect(ng.x1, ng.y1, ng.x2, ng.y2);
			if (m_pDefectControl != NULL)
				m_pDefectControl->ExtractDefect_KDist(eDim, m_iCamera, stFrame.nScanIdx, DefectLoc_KDist, ptDefec, rectDefect, (int)(ng.result));
		}

		g_pLog->DisplayMessage(_T("%d FinallyVisionProc return[%d]: %s %s (%d,%d) (%d %d %d %d) %.2f")
			, g_pBase->m_strHPanelID, i, array_dir_use[ng.eDir], array_type_use[ng.ngType], ng.xPosPxl, ng.yPosPxl
		    , ng.x1, ng.y1, ng.x2, ng.y2, ng.result);
	}
	test_data_kdist.Append(_T("\r\n"));

	test_module.Open(test_file_path, CFile::modeCreate | CFile::modeWrite | CFile::modeNoTruncate | CFile::shareDenyWrite | CFile::shareDenyRead, &test_exception);
	if (test_exception.m_cause == CFileException::none)
	{
		if (test_module.SeekToEnd() == 0L)
		{
			CString test_title;
			test_title.Format(_T("Time,Glass ID,eDir,Defect Type,Name,Result\r\n"));
			test_module.Write(test_title, test_title.GetLength() * sizeof(TCHAR));
		}
		test_module.Write(test_data_kdist, test_data_kdist.GetLength() * sizeof(TCHAR));
		test_module.Close();
	}
}

BOOL CInspectCamera::CheckThreadEnd(int iThread,stFrameIndex stFrame,BOOL bProfile)
{
	int			iScan = stFrame.nScanIdx;

	CSingleLock		myLoc(&m_csThreadEnd);	
	myLoc.Lock();

	if(m_iThreadEnd[iScan][iThread] == 1)
	{
		myLoc.Unlock();
		return FALSE;	
	}

	BOOL		bEnd = FALSE;

	if(bProfile == TRUE ||	CheckProcessEnd(iThread,stFrame) == TRUE)
	{		
		m_iThreadEnd[iScan][iThread] = 1;
		bEnd = TRUE;
		myLoc.Unlock();
	}	

	if(bEnd == TRUE)
	{
		DimensionDir		emDim = GetDimension(iScan);			
		g_pLog->DisplayMessage(_T("%s Thread %d Process End : Scan %d, Frame %d"),PANEL_SIDE[emDim],iThread,iScan,stFrame.nFrameIdx);		

		if(GetThreadEndCount(iScan) == MAX_THREAD || bProfile == TRUE)
		{
			SaveFullImageCopy(iScan);

			// Waiting All Frame Finish..
			/*
			DWORD dwTickCount = GetTickCount();

			while(GetTickCount() - dwTickCount < 5000)
			{
				if(CheckAllFrameFinish(iScan) == TRUE)
					break;
			}
			*/

			myLoc.Lock();
			{
				HANDLE hThread = GetCurrentThread();
				SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST);
				g_pLog->DisplayMessage(_T("FinallyVisionProc took start - %s"), PANEL_SIDE[emDim]);
				auto startTime = std::chrono::high_resolution_clock::now();
				FinallyVisionProc(emDim, stFrame);
				auto endTime = std::chrono::high_resolution_clock::now();
				auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
				g_pLog->DisplayMessage(_T("FinallyVisionProc took %lld milliseconds - %s"), duration.count(), PANEL_SIDE[emDim]);
				g_pLog->DisplayMessage(_T("FinallyVisionProc took end - %s"), PANEL_SIDE[emDim]);
				SetThreadPriority(hThread, THREAD_PRIORITY_NORMAL);
			}
			myLoc.Unlock();

			if(m_pII2S != NULL)
				m_pII2S->II2S_InspectionEnd(m_iCamera,iScan);

			g_pLog->DisplayMessage(_T("%s Scan Process All End"),PANEL_SIDE[emDim]);

			m_MsgJob.nState = 2;
			m_MsgJob.nSide = (int)emDim;
			::SendMessage(m_hWndViewScan, WM_POCESS_STATUS,(WPARAM)&m_MsgJob, (int)emDim);
		}		
	}

	myLoc.Unlock();

	return bEnd;
}

int	CInspectCamera::GetThreadEndCount(int iScan)
{
	int			nCount = 0;
	for(int i=0;i<MAX_THREAD;i++)
		if(m_iThreadEnd[iScan][i] == 1)
			nCount++;

	return nCount;
}

void CInspectCamera::ResetFrameFinish(int nCurrentScanIdx)
{
	CSingleLock cslocalLock(&m_csFrameFinishCheck);
	cslocalLock.Lock();

	m_nFrameFinishIdx[nCurrentScanIdx] = -1;

	for(int i=0; i<MAX_FRAM_COUNT; i++)
		m_bFrameFinish[nCurrentScanIdx][i] = FALSE;

	cslocalLock.Unlock();
}

void CInspectCamera::SetFrameFinishEndFrame(int nCurrentScanIdx, int nFrameIdx)
{
	CSingleLock cslocalLock(&m_csFrameFinishCheck);
	cslocalLock.Lock();

	m_nFrameFinishIdx[nCurrentScanIdx] = nFrameIdx;

	cslocalLock.Unlock();
}

void CInspectCamera::SetFrameFinish(int nCurrentScanIdx, int nCurrentFrameIdx)
{
	CSingleLock cslocalLock(&m_csFrameFinishCheck);
	cslocalLock.Lock();

	m_bFrameFinish[nCurrentScanIdx][nCurrentFrameIdx] = TRUE;

	cslocalLock.Unlock();
}

BOOL CInspectCamera::CheckAllFrameFinish(int nCurrentScanIdx)
{
	CSingleLock cslocalLock(&m_csFrameFinishCheck);
	cslocalLock.Lock();

	if(m_nFrameFinishIdx[nCurrentScanIdx] == -1)
		return FALSE;

	for(int i=0; i<m_nFrameFinishIdx[nCurrentScanIdx]; i++)
		if(m_bFrameFinish[nCurrentScanIdx][i] == FALSE)
			return FALSE;

	return TRUE;
}

DIT_RESULT CInspectCamera::FindHoleInspection(int iThread,DimensionDir	emDim,stFrameIndex stFrame,int iFindLine)
{
	DIT_RESULT ret= DIT_CONV_SUCCESS;	
	CHOLEINSPECT_PARM		*pHolePrm = m_pRecipe->GetHolePrm();

	if(pHolePrm->m_nTotalHoleCount <= 0)
		return ret;

	INS_EDGE_RESULT_INFO *pResInfo =  NULL;

	if(m_pGlassData != NULL)
		pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);

	std::vector<HOLE_INS_PARM>	vecReg;

	GetHoleRegionFrame(iThread,emDim,stFrame,vecReg);

	if((int)vecReg.size() <= 0)
		return ret;

	std::vector<HOLE_INS_PARM>::iterator		it;
	HOLE_INS_PARM		HoleReg;

	for(it=vecReg.begin();it!=vecReg.end();it++)
	{
		HoleReg = *it;

		CRect rtArea = HoleReg.m_rtArea;
		rtArea.OffsetRect(CPoint((int)pResInfo->ptMark[0].x, (int)pResInfo->ptMark[0].y));
		rtArea.InflateRect(100,100);

		IplImage* pTargetImage = cvCreateImage(cvSize(rtArea.Width(), rtArea.Height()), 8, 1);
		cvZero(pTargetImage);

		int nStartX = rtArea.left;
		int nStartY = rtArea.top;

		BYTE* pGrabBuffer = NULL;

		for(int i=0; i< rtArea.Height(); i++)
		{
			pGrabBuffer = m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,nStartY+i);

			if(pGrabBuffer == NULL)
				continue;

			memcpy(&pTargetImage->imageData[pTargetImage->widthStep*i], pGrabBuffer+nStartX, sizeof(BYTE)*pTargetImage->width);
		}

		std::vector<CRect> vecDefectList;
		IplImage* pViewImage = NULL;

		CPoint ptMatchingPos;

		GetHoleControl(iThread)->HoleInspect_TemplateMatching(&HoleReg, pTargetImage, vecDefectList, ptMatchingPos, &pViewImage);

		rtArea.OffsetRect(ptMatchingPos);

		if((int)vecDefectList.size() > 0)
		{ 
			m_pDefectControl->ExtractDefect_Hole(emDim,m_iCamera,stFrame.nScanIdx,vecDefectList,(int)vecDefectList.size(),DefectLoc_Hole,rtArea);
		}

		cvReleaseImage(&pTargetImage);

		cvReleaseImage(&pViewImage);
	}

	return ret;
}

CRect CInspectCamera::GetSplineInsRect_New(int iThread,DimensionDir	emDim,CSize szMaster,CPoint nOffset,stFrameIndex stFrame,int iFindLine,BOOL &bFlip)
{		
	CRect		rectIns(0,0,0,0);		
	CvPoint2D32f ptAlign = CvPoint2D32f(0,0);
	BOOL		bFindAlign = FALSE;

	int			nFrameWidth,nFrameHeight;
	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	int			nStartLine,nEndLine;

	nStartLine = nEndLine = 0;
	INS_EDGE_RESULT_INFO *pResInfo = NULL;
	if(m_pGlassData != NULL)
	{
		pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);
		if(pResInfo != NULL)
		{
			if(pResInfo->bMark[0] == TRUE)
			{
				bFindAlign = pResInfo->bMark[0];
				ptAlign = pResInfo->ptMark[0];
			}

			nStartLine = pResInfo->nGlassStartLine;
			nEndLine = pResInfo->nPreGlassEndLine;
		}
	}

	bFlip = FALSE;
	if(bFindAlign == TRUE && stFrame.nFrameIdx > (int)((ptAlign.y)/nFrameHeight) && pResInfo->bSpline[0] == FALSE)
	{		
		rectIns.left = 0;
		rectIns.right = nFrameWidth;
		rectIns.top = nStartLine-nOffset.y;
		rectIns.bottom = nStartLine + szMaster.cx;		
		pResInfo->bSpline[0] = TRUE;
	}
	else if(nEndLine > 0 && stFrame.nFrameIdx == nEndLine/nFrameHeight)
	{
		DWORD dwTact = GetTickCount();

		do 
		{
			if(pResInfo == NULL)
				break;

			if(pResInfo->bMark[1] == TRUE)
				break;

			if(GetTickCount()-dwTact >= 3000)
			{
				g_pLog->DisplayMessage(_T("%s Spline Ins Rect timeout : %d=%d"),PANEL_SIDE[emDim],nEndLine/nFrameHeight,stFrame.nFrameIdx);
				break;
			}

			Sleep(0);

		} while (1);

		rectIns.left = 0;
		rectIns.right = nFrameWidth;
		rectIns.bottom = nEndLine + nOffset.y;
		rectIns.top = nEndLine-szMaster.cy;		
		bFlip = TRUE;
		pResInfo->bSpline[1] = TRUE;
	}
	else
		return rectIns;		

	AssertFrameRectWidth(rectIns,stFrame.nScanIdx);

	int			nWidth = align_4byte(rectIns.Width());
	rectIns.left = rectIns.right - nWidth;

	if(rectIns.Width() <= 0 || rectIns.Height() <= 0 || rectIns.left > rectIns.right || rectIns.top > rectIns.bottom)
		return rectIns;

	return rectIns;
}

DIT_RESULT CInspectCamera::FindSpline_New(int iThread,DimensionDir	emDim,stFrameIndex stFrame,int iFindLine)
{
	DIT_RESULT ret= DIT_CONV_SUCCESS;	

	switch(emDim)
	{
	case DIMENSION_B:
	case DIMENSION_B_DN:
	case DIMENSION_D:
	case DIMENSION_D_DN:
		return ret;
	}

	pSTU_SPLINE_INS_PARM pSplinePrm = m_pRecipe->GetInspectInfo()->GetSplineIns(emDim);
	pSTU_SPLINE_CHIP_PARM	pChipPrm =	m_pRecipe->GetInspectInfo()->GetSplineChipIns(emDim);
	CETC_PARM		*pEtc =	m_pRecipe->GetEtcPrm(emDim);		
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);

	if(pSplinePrm == NULL || pEtc == NULL || pChipPrm == NULL || pChipPrm->m_bSplineChip == FALSE)
		return ret;

	int			nFrameWidth,nFrameHeight;
	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	CSize		szMaster = CSize(pSplinePrm->m_nStartCornerSize_Y,pSplinePrm->m_nEndCornerSize_Y);
	CPoint		nOffset(100,100);
	BOOL		bFlip;
	CRect		rectIns;	

	rectIns = GetSplineInsRect_New(iThread,emDim,szMaster,nOffset,stFrame,iFindLine,bFlip);		
	if(rectIns.IsRectEmpty() == TRUE)
	{
		//	g_pLog->DisplayMessage(_T("Cam[%d] Scan[%d] iThread[%d] Frame[%d] %s Spline No Region!"),GetCameraID(),pRecipe->GetScanIndex(),iThread,iFrame,strCutDiv);		
		return ret;	
	}	

	if(rectIns.top < 0 || rectIns.left < 0)
		return ret;	

	CvPoint2D32f ptSplineCen = GetSplineCenter(iThread,emDim,stFrame,bFlip);
	if(ptSplineCen.x <= 0 || ptSplineCen.y <= 0)
	{
		g_pLog->DisplayMessage(_T("%s iThread[%d] Frame[%d] %d Spline Fail! : Center is Null"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,bFlip);	
		return ret;
	}

	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();
	int			nRcpIndex[2],nRcpSize[2];

	GetRCutProfileIndex(emDim,nRcpIndex,nRcpSize);

	if(nRcpIndex[0] < 0 || nRcpIndex[0] >= MAX_PROFILE_SETTING_COUNT)
	{
		g_pLog->DisplayMessage(_T("%s iThread[%d] Frame[%d] %d Spline Fail! : Radius is Null"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,bFlip);	
		return ret;
	}
	
	double dRadius = (bFlip == FALSE) ? pSplinePrm->m_nStartCornerRadius_um : pSplinePrm->m_nEndCornerRadius_um; // pPrm->m_stProfile[nRcpIndex[0]].radius;
	int				nSpIndex = 0;

	if(bFlip == TRUE)
		nSpIndex = 1;	

	SetRCutDisplayImage(iThread,emDim,stFrame,rectIns,bFlip,dRadius,ptSplineCen);	

	double			dStartTheta = pChipPrm->m_dChipStartTheta;
	double			dEndTheta = pChipPrm->m_dChipEndTheta;
	double			dDistTheta = pChipPrm->m_dChipDistTheta;	
	CEdgeProc		EdgeProc;
	int				nEdgeThres = m_pRecipe->GetInspectInfo()->m_nRCutThresGlass[emDim][nSpIndex];
	int				nChamferThres = m_pRecipe->GetInspectInfo()->m_nRCutThresChamfer[emDim][nSpIndex];
	int				nChamferSize = -1;

	pSTU_SPLINE_INS_PARM pSpline = m_pRecipe->GetInspectInfo()->GetSplineIns(emDim);
	if(pSpline != NULL )
		nChamferSize = (nSpIndex == 0) ? pSpline->m_nStartChamferSize : pSpline->m_nEndChamferSize;

	std::vector<STU_SPLINE_RCut> stuRes;
	double				dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return ret;	

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return ret;	

	if(dStartTheta >= dEndTheta)
	{
		g_pLog->DisplayMessage(_T("%s iThread[%d] Frame[%d] %d Spline Fail! : theta %.2f,%.2f"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,bFlip,dStartTheta,dEndTheta);
		return ret;
	}
	if(dDistTheta <= 0)
		dDistTheta = 5;

	int			nCount=0,nSum=0;
	STU_SPLINE_RCut	stuRcut;	
	double		dCalTheta;

	for(double iTheta=dStartTheta;iTheta<=dEndTheta;iTheta+=dDistTheta)
	{
		dCalTheta = iTheta;
		if(bFlip == TRUE)
		{
			dCalTheta = -1*iTheta;
		}

		COwnerBuffer	imgProcess;

		ROI imgROI = GetRCutChipImage(iThread,emDim,stFrame,imgProcess,dCalTheta,ptSplineCen,dRadius);

		if(imgProcess.IsValidBuffer() == FALSE)
			continue;

		if(g_pStatus->GetInspectOption()->bSaveSpline == TRUE)
		{
			CString				str;
			str.Format(_T("D:\\Image\\spline\\%s_%d_%.2f_Org.bmp"),PANEL_SIDE[emDim],bFlip,dCalTheta);
			CBufferAttach		attach(str);
			attach.AttachToFile(imgProcess);
		}

		COwnerBuffer	bufBin(imgProcess.GetDataWidth(),imgProcess.GetHeight());
		CSize			szImg(bufBin.GetDataWidth(),bufBin.GetHeight());

		CopyMemory(bufBin.GetDataAddress(),imgProcess.GetDataAddress(),imgProcess.GetDataSize());

		EdgeProc.ThresholdProcessing(bufBin.GetDataAddress(),szImg,nChamferThres,0);

		if(g_pStatus->GetInspectOption()->bSaveSpline == TRUE)
		{
			CString				str;
			str.Format(_T("D:\\Image\\spline\\%s_%d_%.2f_Bin.bmp"),PANEL_SIDE[emDim],bFlip,dCalTheta);
			CBufferAttach		attach(str);
			attach.AttachToFile(bufBin);
		}

		CSISEdgeFind		EdgeFind;		

		double		dPitch = imgProcess.GetWidth()/5;
		if(dPitch < 10)
			dPitch = 10;

		int			nGlassEdge = 0;
		if(EdgeFind.FindEdge_ToRight(&imgProcess,nGlassEdge,dPitch,nEdgeThres,0.3,0) == FALSE)
		{
			continue;
		}

		int			iStart,iEnd;

		iStart = nGlassEdge-50;		
		if(iStart < 0)
			iStart = 0;

		iEnd = iStart + 200;
		if(iEnd >= bufBin.GetWidth())
			iEnd = bufBin.GetWidth()-1;

		for(int y=0;y<bufBin.GetHeight();y++)
		{
			stuRcut.reset();
			stuRcut.y = y;
			stuRcut.imgX = imgROI.u1;
			stuRcut.imgY = imgROI.v1;
			stuRcut.dTheta = dCalTheta;
			for(int x=iStart;x<iEnd;x++)
			{
				if(bufBin.GetPixel(x,y) != 0)
				{
					stuRcut.x1 = x;

					// Noise Filter..
					for(int x2=iEnd-1; x+1 < x2 ; x2--)
					{
						int nValidPixelCount = 0;

						int nLength = 6;//x2 - x; // 6 pixel check

						// Noise Check..
						for(int nCheck=0; nCheck < nLength; nCheck++)
						{
							int nPosX = x2 - nCheck;

							if(nPosX <= stuRcut.x1)
								break;

							if(bufBin.GetPixel(nPosX,y) != 0)
								nValidPixelCount++;
						}

						if(3 < nValidPixelCount)		// valid 3 pixel check
						{
							stuRcut.x2 = x2-1;
							stuRcut.width = stuRcut.x2-stuRcut.x1+1;
							break;
						}
					}

					/* Right..
					for(int x2=iEnd-1; x+1 < x2 ; x2--)
					{
						if(bufBin.GetPixel(x2,y) != 0)
						{
							stuRcut.x2 = x2-1;
							stuRcut.width = stuRcut.x2-stuRcut.x1+1;
							break;
						}
					}
					*/

					/* Left..
					for(int x2=x+1;x2<iEnd;x2++)
					{
						if(bufBin.GetPixel(x2,y) == 0)
						{
							stuRcut.x2 = x2-1;
							stuRcut.width = stuRcut.x2-stuRcut.x1+1;
							break;
						}
					}
					*/
					break;
				}
			}
			if(stuRcut.width > 0)
			{
				nCount++;
				nSum+=stuRcut.width;
			}
			stuRes.push_back(stuRcut);
		}		
	}

	int		nAvg = 0;

	if(nCount > 0)
		nAvg = nSum/nCount;

	if(nChamferSize > 0)
		nAvg = nChamferSize;

	if(nAvg <= 0)
		return ret;

	STU_SPLINE_RCut stuDet;
	int			nDefectCnt = 0,nMaxDefect = 0;
	for(int i=0;i<stuRes.size();i++)
	{
		stuRcut = stuRes[i];

		if(stuRcut.width <= 0)
			continue;

		if(stuRcut.width > nAvg && abs(stuRcut.width-nAvg)*dConv >= pChipPrm->m_nChipSize_Y)
		{
			nDefectCnt++;
			stuDet = stuRcut;
		}
		else
		{
			BOOL		bDefect = FALSE;
			if(nDefectCnt > 0)
			{
				if(pChipPrm->m_bChipJudgeAnd == TRUE)
				{
					if(nDefectCnt*dConv >= pChipPrm->m_nChipSize_X)
						bDefect = TRUE;
				}
				else			
				{
					bDefect = TRUE;				
				}
			}

			if(bDefect == TRUE)
			{
				double dSin = sin(M_RADIAN(stuDet.dTheta));
				double dCos = cos(M_RADIAN(stuDet.dTheta));
				IMPOS2D				pDefect,p1,posCen;

				posCen.u = ptSplineCen.x;
				posCen.v = ptSplineCen.y;

				pDefect.u = (stuDet.x2+stuDet.x1+1)/2+stuRcut.imgX;
				pDefect.v = (stuDet.y-nDefectCnt/2)+stuRcut.imgY;		

				EdgeProc.IMRotatePoint(pDefect, &p1, posCen, dSin, dCos) ;
				CvPoint2D32f	ptDef;
				ptDef.x = (float)p1.u;
				ptDef.y = (float)p1.v;

				m_pDefectControl->ExtractDefect_SpNew(emDim,m_iCamera,stFrame.nScanIdx,DefectLoc_Chip,ptDef,0,bFlip,(int)(nDefectCnt*dConv));
			}

			nDefectCnt=0;
		}
	}

	BOOL		bDefect = FALSE;
	if(nDefectCnt > 0)
	{
		if(pChipPrm->m_bChipJudgeAnd == TRUE)
		{
			if(nDefectCnt*dConv >= pChipPrm->m_nChipSize_X)
				bDefect = TRUE;
		}
		else			
		{
			bDefect = TRUE;				
		}
	}

	if(bDefect == TRUE)
	{
		double dSin = sin(M_RADIAN(stuDet.dTheta));
		double dCos = cos(M_RADIAN(stuDet.dTheta));
		IMPOS2D				pDefect,p1,posCen;

		posCen.u = ptSplineCen.x;
		posCen.v = ptSplineCen.y;

		pDefect.u = (stuDet.x2+stuDet.x1+1)/2+stuRcut.imgX;
		pDefect.v = (stuDet.y-nDefectCnt/2)+stuRcut.imgY;		

		EdgeProc.IMRotatePoint(pDefect, &p1, posCen, dSin, dCos) ;
		CvPoint2D32f	ptDef;
		ptDef.x = (float)p1.u;
		ptDef.y = (float)p1.v;

		m_pDefectControl->ExtractDefect_SpNew(emDim,m_iCamera,stFrame.nScanIdx,DefectLoc_Chip,ptDef,0,bFlip,(int)(nDefectCnt*dConv));
	}	

	return ret;
}

ROI CInspectCamera::GetRCutChipImage(int iThread,DimensionDir emDim,stFrameIndex stFrame,COwnerBuffer &pTgt,double dTheata,CvPoint2D32f ptCen,double dRadius)
{
	int					nDistance;
	ROI					aoi;
	double				dSin,dCos;
	IMPOS2D				posCen;
	int					n4ByteWidth;
	LPBYTE				lpBuffer;
	CEdgeProc			EdgeProc;
	CSISBuffer			bufOrg;
	const int			nSearchArea = 200;
	const int			nSearchHeight = 40;	

	dSin = sin(M_RADIAN(dTheata));
	dCos = cos(M_RADIAN(dTheata));
	posCen.u = ptCen.x;
	posCen.v = ptCen.y;

	nDistance = (int)GetRadus2Distance(emDim,stFrame, dTheata,dRadius,dSin,dCos);	

	aoi.u1 = aoi.u2 = aoi.v1 = aoi.v2 = 0;
	lpBuffer = m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,0);
	if(lpBuffer == NULL)
		return aoi;

	int		nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	bufOrg.SetBuffer(lpBuffer,nFrameWidth,g_pBase->m_pMemFrameNo[m_iCamera]*nFrameHeight);

	aoi.u1 = (int)ROUND(posCen.u) - nDistance - nSearchArea;
	aoi.u2 = (int)ROUND(posCen.u) - nDistance + nSearchArea;
	aoi.v1 = (int)ROUND(posCen.v) - nSearchHeight;
	aoi.v2 = (int)ROUND(posCen.v) + nSearchHeight;

	n4ByteWidth = align_4byte(EdgeProc.IMROIWidth(aoi));
	aoi.u2 = aoi.u1 + n4ByteWidth;
	pTgt.SetSize(EdgeProc.IMROIWidth(aoi),EdgeProc.IMROIHeight(aoi));

	// 22.6.13
	memset(pTgt.GetDataAddress(0,0), 255, pTgt.GetDataSize());

	EdgeProc.IMGetRotImg(aoi,bufOrg,pTgt,posCen,dSin,dCos);	

	return aoi;

}

CvPoint2D32f CInspectCamera::GetSplineCenter(int iThread,DimensionDir emDim,stFrameIndex stFrame,BOOL bBot)
{
	CvPoint2D32f		ptCen = CvPoint2D32f(0,0);
	CvPoint2D32f		ptAlign = CvPoint2D32f(0,0);
	int					nIndex = 0;

	if(bBot == TRUE)
		nIndex = 1;

	if(m_pGlassData != NULL)
	{
		INS_EDGE_RESULT_INFO *pResInfo =  m_pGlassData->GetEdgeResultInfo(emDim);
		if(pResInfo != NULL)
		{
			if(pResInfo->bMark[nIndex] == TRUE)
			{
				ptAlign = pResInfo->ptMark[nIndex];
			}				
		}
	}

	if(ptAlign.x <= 0 || ptAlign.y <= 0)
		return ptCen;	

	CProfileInspect_Prm *pPrm = m_pRecipe->GetProfileParm();
	double		AlignX,AlignY;
	double		dOrgOffsetX,dOrgOffsetY;

	double		dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return ptCen;	

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return ptCen;

	if(nIndex == 0)
	{
		dOrgOffsetX = (double)pPrm->m_nOriginAlignKeyOffsetX[emDim]/dConv;
		dOrgOffsetY = (double)pPrm->m_nOriginAlignKeyOffsetY[emDim]/dScan;
	}
	else if(nIndex == 1)
	{
		dOrgOffsetX = (double)pPrm->m_nOriginAlignKeyOffsetDwX[emDim]/dConv;
		dOrgOffsetY = (double)pPrm->m_nOriginAlignKeyOffsetDwY[emDim]/dScan;
	}

	AlignX = ptAlign.x;
	AlignY = ptAlign.y;			

	ptCen.x = (float)(AlignX + dOrgOffsetX);
	ptCen.y = (float)(AlignY + dOrgOffsetY);

	return ptCen;
}

void CInspectCamera::SetRCutDisplayImage(int iThread,DimensionDir emDim,stFrameIndex stFrame,CRect rectIns,BOOL bFlip,double dRadius,CvPoint2D32f ptSplineCen)
{
	switch(emDim)
	{
	case DIMENSION_A_DN:
	case DIMENSION_C_DN:
	case DIMENSION_B:
	case DIMENSION_B_DN:
	case DIMENSION_D:
	case DIMENSION_D_DN:
		return;
	}

	double		dConv,dScan;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return;	

	dConv = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
	dScan = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	if(dConv <= 0 || dScan <= 0)
		return;	

	int				nDistance = (int)(dRadius/dConv);

	pINSPECTSPLINE_BUFFER		pImgBuf = NULL;

	if(bFlip == FALSE)
		pImgBuf = GetSplineBuffer(0);
	else
		pImgBuf = GetSplineBuffer(1);	

	if(m_iCamera == 0)
	{
		if(bFlip == FALSE)
			pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_BOTTOMLEFT;
		else
			pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_BOTTOMRIGHT;
	}
	else
	{
		if(bFlip == FALSE)
			pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_TOPLEFT;
		else
			pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_TOPRIGHT;
	}

	pImgBuf->iCam = m_iCamera;			
	pImgBuf->iScan = stFrame.nScanIdx;
	pImgBuf->iType = (int)STU_SPLINE_RESULT::SPLINE_RCUT;
	pImgBuf->bPos = bFlip;

	int				nOffset = 100;
	CRect			rect;

	if(bFlip == FALSE)
	{
		rect.left = (int)ptSplineCen.x-nDistance-nOffset;
		rect.right = rect.left + (int)(nDistance*1.5) + nOffset;
		rect.top = (int)ptSplineCen.y-nDistance-nOffset;
		rect.bottom = (int)ptSplineCen.y+nOffset;		
	}
	else
	{
		rect.left = (int)ptSplineCen.x-nDistance-nOffset;
		rect.right = rect.left + (int)(nDistance*1.5) + nOffset;
		rect.bottom = (int)ptSplineCen.y +nDistance+nOffset;
		rect.top = (int)ptSplineCen.y-nOffset;
	}

	rect.right = rect.left + align_4byte(rect.Width());

	int			nFrameWidth,nFrameHeight;
	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	if(rect.top < 0 || rect.right >= nFrameWidth || rect.left < 0)
		return;

	COwnerBuffer	sisRcut(rect.Width(),rect.Height());
	LPBYTE	lpBuffer = m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,rect.top);

	CRect		rectCopy = rect;
	rectCopy.OffsetRect(0,-rectCopy.top);

	CopyRectImg(lpBuffer,sisRcut.GetDataAddress(),CSize(nFrameWidth,sisRcut.GetHeight()*2),rectCopy);	
	pImgBuf->SetBuffer(sisRcut.GetDataAddress(),CSize(sisRcut.GetWidth(),sisRcut.GetHeight()),INSPECTSPLINE_BUFFER::SPLINE_TYPE_ORG);	// Org		
}

BOOL CInspectCamera::CopyRectImg(LPBYTE pOrg,LPBYTE pTgt,CSize szImg,CRect &rectIns)
{
	if(rectIns.Width() > szImg.cx || rectIns.bottom >= szImg.cy ||
		rectIns.top < 0 || rectIns.top > rectIns.bottom || rectIns.bottom < 0)
		return FALSE;

	int			v;
	int			dv = 0;

	for(v=rectIns.top;v<rectIns.bottom;v++,dv++)
	{
		CopyMemory(pTgt+dv*rectIns.Width(),pOrg+v*szImg.cx+rectIns.left,rectIns.Width());
	}

	return TRUE;
}

DIT_RESULT CInspectCamera::FindSpline(int iThread,DimensionDir	emDim,stFrameIndex stFrame,int iFindLine)
{
	DIT_RESULT ret= DIT_CONV_SUCCESS;	
	CSplineModel	*pSplineModel = NULL;
	int				iSplineModelIdx = 0;

	switch(emDim)
	{
	case DIMENSION_B:
	case DIMENSION_B_DN:
	case DIMENSION_D:
	case DIMENSION_D_DN:	
		return ret;
	case DIMENSION_A:
	case DIMENSION_A_DN:
		iSplineModelIdx=0;
		break;
	case DIMENSION_C:
	case DIMENSION_C_DN:
		iSplineModelIdx=2;
		break;
	}

	pSplineModel = &m_pSplineModel[iSplineModelIdx];
	
	if(pSplineModel->IsLoadMasterImg() == FALSE)
	{		
		return ret;
	}

	pSTU_SPLINE_INS_PARM pSplinePrm = m_pRecipe->GetInspectInfo()->GetSplineIns(emDim);
	pSTU_SPLINE_CHIP_PARM	pChipPrm =	m_pRecipe->GetInspectInfo()->GetSplineChipIns(emDim);
	CETC_PARM		*pEtc =	m_pRecipe->GetEtcPrm(emDim);		
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);

	if(pSplinePrm == NULL || pEtc == NULL || pChipPrm == NULL || pSplinePrm->m_bSpline == FALSE || pEdgeInfo == NULL)
		return ret;

	CString		strCutDiv;		
	CSize		szMaster = pSplineModel->GetMasterDataSize();
	CPoint		nOffset(100,100);
	BOOL		bFlip;
	CRect		rectIns;	

	rectIns = GetSplineInsRect(szMaster,nOffset,stFrame,iFindLine,pEdgeInfo,bFlip);		
	if(rectIns.IsRectEmpty() == TRUE)
	{	
		return ret;	
	}	

	if(rectIns.top < 0 || rectIns.left < 0)
		return ret;
	
	GetSplineControl(iThread)->SetMasterModelData(pSplineModel);

	double		dCovRes,dScanRes;
	int			nFrameHeight,nFrameWidth;		

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);

	if(g_pBase->m_nStageNo >= 0 && g_pBase->m_nStageNo <= 1)
	{
		dCovRes = pCamera->m_dConvResolution[g_pBase->m_nStageNo];
		dScanRes = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	}
	else
	{
		dCovRes = pCamera->m_dConvResolution[0];
		dScanRes = pCamera->m_dScanResolution[0];
	}

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	int				iTopPixel = rectIns.top;
	int				iLetPixel = rectIns.left;
	LPBYTE			lpHeader =	m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,rectIns.top);
	CSISBuffer		pSPBuf(lpHeader,nFrameWidth,rectIns.Height());

	if(lpHeader == NULL || pSPBuf.IsValidBuffer() == FALSE)
	{		
		g_pLog->DisplayMessage(_T("%s iThread[%d] Frame[%d] %s Spline Image Fail: %d [%d,%d,%d,%d]"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,strCutDiv
			,rectIns.top/nFrameHeight,rectIns.left,rectIns.top,rectIns.right,rectIns.bottom);
		return ret;
	}

	SPLINE_ERR_MSG				errMsg = SPLINE_INS_SUCESS;	

	g_pLog->DisplayMessage(_T("%s iThread[%d] Frame[%d] %s Spline Inspect Start"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,strCutDiv);
	
	rectIns.OffsetRect(0,-rectIns.top);
	if(pSplinePrm->m_bSpline == TRUE)
		errMsg = GetSplineControl(iThread)->InspectSpline(pSPBuf,rectIns,pSplinePrm->m_DetMinDist,pSplinePrm->m_nLineThres,bFlip,g_pStatus->GetInspectOption()->bSaveSpline,TRUE);

	//g_pLog->DisplayMessage(_T("Cam[%d] Scan[%d] iThread[%d] Frame[%d] %s Spline Inspect. 02"),GetCameraID(),pRecipe->GetScanIndex(),iThread,iFrame,strCutDiv);

	CSISBuffer		*pChipBuf = GetSplineControl(iThread)->GetSplineOrgImg();
	if(pChipBuf->IsValidBuffer() == FALSE)
		pChipBuf = &pSPBuf;

	int		iLeftLine = GetSplineFindEdge(pChipBuf,pEtc,iFindLine,100);

	SplineChipProcess(GetSplineControl(iThread),pChipBuf,iThread,emDim,stFrame,iLeftLine,bFlip,iTopPixel,iLetPixel,strCutDiv);		

	SaveSplineImage(pSPBuf,GetSplineControl(iThread),pSplinePrm,iThread,emDim,stFrame,dCovRes,errMsg,bFlip);	
	
	g_pLog->DisplayMessage(_T("%s iThread[%d] Frame[%d] %s Spline Inspect End"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,strCutDiv);

	return ret;
}

void CInspectCamera::SaveSplineImage(CSISBuffer &pSPBuf,CSplineInspect *pSplineIns,pSTU_SPLINE_INS_PARM pSplinePrm, int iThread,DimensionDir emDim,stFrameIndex stFrame,double dConvRes,SPLINE_ERR_MSG	errMsg,BOOL bFlip)
{
	if(emDim == DIMENSION_A || emDim == DIMENSION_C)
	{
		if(errMsg == SPLINE_INS_SUCESS)
		{
			if(g_pStatus->GetInspectOption()->bSaveSpline == TRUE)
			{	
				CSISBuffer					*pResBuf = GetSplineControl(iThread)->GetSplineResImg();
				pINSPECTSPLINE_BUFFER		pImgBuf = NULL;

				if(bFlip == FALSE)
					pImgBuf = GetSplineBuffer(0);
				else
					pImgBuf = GetSplineBuffer(1);	

				if(m_iCamera == 0)
				{
					if(bFlip == FALSE)
						pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_BOTTOMLEFT;
					else
						pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_BOTTOMRIGHT;
				}
				else
				{
					if(bFlip == FALSE)
						pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_TOPLEFT;
					else
						pImgBuf->ePosition = INSPECTSPLINE_BUFFER::SPLINE_TOPRIGHT;
				}

				pImgBuf->iCam = m_iCamera;			
				pImgBuf->iScan = stFrame.nScanIdx;
				if((int)pSplinePrm->m_emSPType == EM_SP_RCUT)
					pImgBuf->iType = STU_SPLINE_RESULT::SPLINE_RCUT;
				else
					pImgBuf->iType = STU_SPLINE_RESULT::SPLINE_CCUT;				
				pImgBuf->bPos = bFlip;
				pImgBuf->SetBuffer(pSPBuf.GetDataAddress(),CSize(pSPBuf.GetWidth(),pSPBuf.GetHeight()),INSPECTSPLINE_BUFFER::SPLINE_TYPE_ORG);	// Org							
			}
			g_pLog->DisplayMessage(_T( "%s iThread[%d] Frame[%d] Spline success"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx);
		}
		else
		{
			if(g_pStatus->GetInspectOption()->bSaveSpline== TRUE)
			{
				pINSPECTSPLINE_BUFFER		pImgBuf = NULL;
				if(bFlip == FALSE)
					pImgBuf = GetSplineBuffer(0);
				else
					pImgBuf = GetSplineBuffer(1);	

				pImgBuf->iCam = m_iCamera;			
				pImgBuf->iScan = stFrame.nScanIdx;
				if((int)pSplinePrm->m_emSPType == EM_SP_RCUT)
					pImgBuf->iType = STU_SPLINE_RESULT::SPLINE_RCUT;
				else
					pImgBuf->iType = STU_SPLINE_RESULT::SPLINE_CCUT;	
				pImgBuf->bPos = bFlip;
				pImgBuf->Clear(INSPECTSPLINE_BUFFER::SPLINE_TYPE_ORG);	// Org			
				pImgBuf->Clear(INSPECTSPLINE_BUFFER::SPLINE_TYPE_RES);	// Res	
			}		

			CString			str;
			switch(errMsg)
			{
			case ERR_SPLINE_EMPTYMASTER: str = _T("No Master Image"); break;
			case ERR_SPLINE_EDGEPROCESS: str = _T("Edge error"); break;
			case ERR_SPLINE_LABELPROCESS: str = _T("Label error"); break;
			case ERR_SPLINE_LABELCOUNT: str = _T("Label Count error"); break;
			case ERR_SPLINE_INDEXFIND: str = _T("Max Index Find error"); break;
			case ERR_SPLINE_LABELPOSITION: str = _T("Label Position error"); break;
			case ERR_SPLINE_POSITIONNULL: str = _T("Position Null"); break;	
			case ERR_SPLINE_INS_CNT_SHORT: str = _T("line Count error"); break;	
			case ERR_SPLINE_IMAGE_NULL: str = _T("Image Null"); break;	
			default: str = "Error"; break;
			}
			g_pLog->DisplayMessage(_T( "%s iThread[%d] Frame[%d] Spline inspect fail! : %s"),PANEL_SIDE[emDim],iThread,stFrame.nFrameIdx,str);
		}
	}
}

BOOL CInspectCamera::SplineChipProcess(CSplineInspect *pInsSpline,CSISBuffer *imgOrg,int iThread,DimensionDir emDim,stFrameIndex stFrame,int iFindLine,BOOL bFlip,int iTopPixel,int iLeftPixel,CString strCutDiv)
{
	if(imgOrg->IsValidBuffer() == FALSE || pInsSpline == NULL)
		return FALSE;

	pSTU_SPLINE_INS_PARM	pSpInsPrm = m_pRecipe->GetInspectInfo()->GetSplineIns(emDim);
	pSTU_SPLINE_CHIP_PARM	pSPChipPrm =	m_pRecipe->GetInspectInfo()->GetSplineChipIns(emDim);

	if(pSPChipPrm->m_bSplineChip == FALSE)
		return FALSE;

	int				nChipThres = pSPChipPrm->m_nChipThres;

	//////////////////////////////////////////////////////////////////////////
	// 流急 备埃.									
	CPoint		pointLeft;
	CRect		rectChip;	

	CEdgeFind		EdgeFind;
	CETC_PARM		*pEtc = m_pRecipe->GetEtcPrm(emDim);

	pointLeft.x = GetSplineFindEdge(imgOrg,pEtc,iFindLine,10);			
	pointLeft.y = pSpInsPrm->m_nStartCornerSize_Y; // pSpInsPrm->m_nYPos;
	
	DWORD tacttime = GetTickCount();

	SplineChip_Curve(pInsSpline,imgOrg,iThread,emDim,stFrame,pointLeft,nChipThres,bFlip,iTopPixel,iLeftPixel,strCutDiv);	

	return TRUE;
}

BOOL CInspectCamera::SplineChip_Curve(CSplineInspect *pInsSpline,CSISBuffer *imgOrg,int iThread,DimensionDir emDim,stFrameIndex stFrame,CPoint &pointLeft,int nChipThres,BOOL bFlip,int iTopPixel,int iLeftPixel,CString strCutDiv)
{
	std::vector<STU_SPLINE_CHIP_POS> *pSPChipPos = m_pRecipe->GetInspectInfo()->GetSplineChipPos(emDim);
	if(pSPChipPos == NULL || (int)pSPChipPos->size() <= 0)
		return TRUE;

	int			iReg = 0;		
	int			nModelCnt,nModSize;
	CHIP_INS_REGION insRegion,insRegTmp;
	std::vector<STU_SPLINE_CHIP_POS>::iterator it;		
	CChipBlob	*pBlobResult = NULL;
	int			nDefectCount;
	pSTU_SPLINE_INS_PARM	pSpInsPrm = m_pRecipe->GetInspectInfo()->GetSplineIns(emDim);
	pSTU_SPLINE_CHIP_PARM	pSPChipPrm =	m_pRecipe->GetInspectInfo()->GetSplineChipIns(emDim);

	CCameraSettings *pCamera =  m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);

	double dScanRes = pCamera->m_dScanResolution[g_pBase->m_nStageNo];
	
#define		DIVIDE_SP_REGION_SIZE	80

	int			nMinStartPos = INT_MAX;

	CINSPECT_JUDGEMENT_PARM	*pJudge = m_pRecipe->GetJudgePrm();

	int		nJudgeW,nJudgeH;
	BOOL	bAnd;
	EM_CHIPPING_COMP	eComp;

	if(pCamera->m_enCamDir == CAMDIR_BOTTOM)
	{
		nJudgeW = pJudge->defect[emDim][0].Chip_Side.szDefect.cx;
		nJudgeH = pJudge->defect[emDim][0].Chip_Side.szDefect.cy;
		bAnd = pJudge->defect[emDim][0].Chip_Side.bConditionAND;
	}
	else
	{
		nJudgeW = pJudge->defect[emDim][0].Chip_CF.szDefect.cx;
		nJudgeH = pJudge->defect[emDim][0].Chip_CF.szDefect.cy;
		bAnd = pJudge->defect[emDim][0].Chip_CF.bConditionAND;
	}		

	if(bAnd == TRUE)
		eComp = CHIP_AND;
	else
		eComp = CHIP_OR;

	int			iSaveIdx = 0;

	g_pLog->DisplayMessage(_T( "%s Frame[%d] %s Spline Chip Curve Inspect Start."),PANEL_SIDE[emDim],stFrame.nFrameIdx,strCutDiv);
	for(it=pSPChipPos->begin();it!=pSPChipPos->end();it++,iReg++)
	{
		if(pSpInsPrm->m_emSPType == EM_SP_CCUT)		
			if(it->emPos != STU_SPLINE_CHIP_POS::MAKE_IMAGE_POS_CCUT)
				continue;		
			else		
				if(it->emPos != STU_SPLINE_CHIP_POS::MAKE_IMAGE_POS_RCUT)
					continue;		

		insRegion.bUse = it->bUse;		
		insRegion.nStartX = it->nStartX;
		insRegion.nEndX = it->nEndX;		
		insRegion.nThres = it->nThres;
		insRegion.nFindThres = it->nFindThres;
		insRegion.nInsRange = it->nInsRange;
		insRegion.nSkipDist = it->nSkipDist;
		insRegion.emMethod = (MAKE_IMAGE_METHOD)it->emMethod;
		insRegion.emDir = (SPLINE_INS_DIR)it->emDir;

		if(insRegion.bUse == FALSE)
			continue;				

		nModelCnt = abs(insRegion.nStartX-insRegion.nEndX)/DIVIDE_SP_REGION_SIZE;
		nModSize = abs(insRegion.nStartX-insRegion.nEndX)%DIVIDE_SP_REGION_SIZE;

		if(nMinStartPos > insRegion.nStartX)
			nMinStartPos = insRegion.nStartX;

		int			iCnt = 0;
		if(nModelCnt > 0)
		{
			int			nChipMargin = 20;
			insRegTmp = insRegion;
			for(iCnt=0;iCnt<nModelCnt;iCnt++)
			{			
				insRegTmp.nStartX = insRegion.nStartX+iCnt*DIVIDE_SP_REGION_SIZE;
				insRegTmp.nEndX = insRegTmp.nStartX+DIVIDE_SP_REGION_SIZE+nChipMargin;

				if(iCnt != 0)
				{
					insRegTmp.nStartX -= nChipMargin;							
					if(insRegTmp.nStartX < 0) insRegTmp.nStartX = 0;
				}

				if(iCnt == nModelCnt-1 && nModSize <= DIVIDE_SP_REGION_SIZE/2)
				{
					insRegTmp.nEndX += nModSize;
					nModSize = 0;
				}
				if(imgOrg->GetWidth() <= insRegTmp.nEndX) insRegTmp.nEndX = imgOrg->GetWidth()-1;

				//	g_pLog->DisplayMessage(_T( "%s Frame[%d] %s Spline Chip Curve Inspect 02._%d"),PANEL_SIDE[pRecipe->GetDimension()],iFrame,strCutDiv,iCnt);

				COwnerBuffer		pSpChipRes;

				pInsSpline->InspectSplineChip(*imgOrg,pointLeft.x,insRegTmp,dScanRes,pSPChipPrm->m_nChipSize_Y,pSpChipRes,bFlip,iSaveIdx,g_pStatus->GetInspectOption()->bSaveSplineChip);
				iSaveIdx++;

				pBlobResult = pInsSpline->GetResultDefect();
				nDefectCount = pInsSpline->GetResultDefectCount();

				if(pBlobResult != NULL && nDefectCount > 0)
				{							
					m_pDefectControl->ExtractDefect_SplineChip(emDim,m_iCamera,stFrame.nScanIdx,pBlobResult,nDefectCount,DefectLoc_Chip,CPoint(iLeftPixel,iTopPixel),(int)pSpInsPrm->m_emSPType,bFlip,nJudgeW,nJudgeH,eComp);
				}								
				//	g_pLog->DisplayMessage(_T( "%s Frame[%d] %s Spline Chip Curve Inspect 03.[%d] "),PANEL_SIDE[pRecipe->GetDimension()],iFrame,strCutDiv,iCnt,m_pInspectOpt->bSaveSplineChip);
			}

			if(nModSize > 0)
			{
				insRegTmp.nEndX = insRegion.nEndX;
				insRegTmp.nStartX = insRegTmp.nEndX-nModSize;

				//	g_pLog->DisplayMessage(_T( "%s Frame[%d] %s Spline Chip Curve Inspect 04. Mod"),PANEL_SIDE[pRecipe->GetDimension()],iFrame,strCutDiv);

				COwnerBuffer		pSpChipRes;

				pInsSpline->InspectSplineChip(*imgOrg,pointLeft.x,insRegTmp,dScanRes,pSPChipPrm->m_nChipSize_Y,pSpChipRes,bFlip,iSaveIdx,g_pStatus->GetInspectOption()->bSaveSplineChip);
				iSaveIdx++;

				pBlobResult = pInsSpline->GetResultDefect();
				nDefectCount = pInsSpline->GetResultDefectCount();

				if(pBlobResult != NULL && nDefectCount > 0)
				{							
					m_pDefectControl->ExtractDefect_SplineChip(emDim,m_iCamera,stFrame.nScanIdx,pBlobResult,nDefectCount,DefectLoc_Chip,CPoint(iLeftPixel,iTopPixel),(int)pSpInsPrm->m_emSPType,bFlip,nJudgeW,nJudgeH,eComp);
				}			

				//	g_pLog->DisplayMessage(_T( "%s Frame[%d] %s Spline Chip Curve Inspect 05.Mod"),PANEL_SIDE[pRecipe->GetDimension()],iFrame,strCutDiv);
			}
		}
		else
		{
			//	g_pLog->DisplayMessage(_T( "%s Frame[%d] %s Spline Chip Curve Inspect 06. Mod : %d"),PANEL_SIDE[pRecipe->GetDimension()],iFrame,strCutDiv,nModelCnt);
			COwnerBuffer		pSpChipRes;

			pInsSpline->InspectSplineChip(*imgOrg,pointLeft.x,insRegion,dScanRes,pSPChipPrm->m_nChipSize_Y,pSpChipRes,bFlip,iSaveIdx,g_pStatus->GetInspectOption()->bSaveSplineChip);
			iSaveIdx++;

			pBlobResult = pInsSpline->GetResultDefect();
			nDefectCount = pInsSpline->GetResultDefectCount();

			if(pBlobResult != NULL && nDefectCount > 0)
			{					
				m_pDefectControl->ExtractDefect_SplineChip(emDim,m_iCamera,stFrame.nScanIdx,pBlobResult,nDefectCount,DefectLoc_Chip,CPoint(iLeftPixel,iTopPixel),(int)pSpInsPrm->m_emSPType,bFlip,nJudgeW,nJudgeH,eComp);
			}			
		}
	}
	g_pLog->DisplayMessage(_T("%s Frame[%d] %s Spline Chip Curve Inspect complete."),PANEL_SIDE[emDim],stFrame.nFrameIdx,strCutDiv);

	//nMinStartPos = 30;
	if(nMinStartPos != INT_MAX || pSPChipPrm->m_bCornerUse == FALSE || pSPChipPrm->m_nCornerRange <= 10)
	{
		insRegTmp.Reset();

		insRegTmp.nStartX = -20;
		insRegTmp.nEndX = nMinStartPos+100;		
		insRegTmp.nCornerYSize = pSPChipPrm->m_nCornerRange;
		insRegTmp.nFindThres = pSPChipPrm->m_nCornerThres;
		insRegTmp.emMethod = MAKE_METHOD_REGRESSION;
		insRegTmp.bUse = pSPChipPrm->m_bCornerUse;		

		COwnerBuffer		pSpChipRes;

		double dAvgThick = pInsSpline->InspectSplineChip(*imgOrg,pointLeft.x,insRegTmp,dScanRes,pSPChipPrm->m_nChipSize_Y,pSpChipRes,bFlip,0,g_pStatus->GetInspectOption()->bSaveSplineChip);	

		pBlobResult = pInsSpline->GetResultDefect();
		nDefectCount = pInsSpline->GetResultDefectCount();

		if(pBlobResult != NULL && nDefectCount > 0)		
		{			
			m_pDefectControl->ExtractDefect_SplineChip(emDim,m_iCamera,stFrame.nScanIdx,pBlobResult,nDefectCount,DefectLoc_Chip,CPoint(iLeftPixel,iTopPixel),(int)pSpInsPrm->m_emSPType,bFlip,nJudgeW,nJudgeH,eComp);
		}		
	}

	return TRUE;
}

int CInspectCamera::GetSplineFindEdge(CSISBuffer *pSPBuf,CETC_PARM *pEtc,int iFindLine,int nOffset)
{
	CRect		rectEdge;	
	int			iEdgeLine;

	rectEdge.left =  0;
	rectEdge.right = align_4byte(rectEdge.left + pEtc->m_nGlassFindWidth_Left);
	rectEdge.top = pSPBuf->GetHeight()-nOffset;
	rectEdge.bottom = pSPBuf->GetHeight();	

#define SPLINE_EDGE_AUTO_RATIO 0.3
#define SPLINE_EDGE_AUTO_PITCH 15
#define SPLINE_EDGE_CONTINUE 3

	CEdgeFind EdgeFind;
	iEdgeLine = EdgeFind.Find_LeftEdge(pSPBuf,SPLINE_EDGE_AUTO_PITCH,pEtc->m_nGlassFindthres_Left,SPLINE_EDGE_AUTO_RATIO,SPLINE_EDGE_CONTINUE);	
	if(iEdgeLine <= 0)
		iEdgeLine = iFindLine;		

	return iEdgeLine;
}

CRect CInspectCamera::GetSplineInsRect(CSize szMaster,CPoint nOffset,stFrameIndex stFrame,int iFindLine,INS_EDGE_RESULT_INFO *pEdgeInfo,BOOL &bFlip)
{		
	CRect		rectIns(0,0,0,0);	
	int			nFrameHeight,nFrameWidth;		

	if(m_bSplineInspect[0] == TRUE && m_bSplineInspect[1] == TRUE)
		return rectIns;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	int			nStartFrame = (pEdgeInfo->nGlassStartLine+szMaster.cy+nOffset.y)/nFrameHeight+1;

	bFlip = FALSE;

	if(m_bSplineInspect[0] == FALSE && stFrame.nFrameIdx >= nStartFrame)
	{
		m_bSplineInspect[0] = TRUE;
		rectIns.left = 0;
		rectIns.right = nFrameWidth;
		rectIns.top = pEdgeInfo->nGlassStartLine-nOffset.y;
		rectIns.bottom = pEdgeInfo->nGlassStartLine + szMaster.cy;	
	}
	else if(m_bSplineInspect[1] == FALSE && pEdgeInfo->nGlassEndFrame > 0)
	{
		m_bSplineInspect[1] = TRUE;
		rectIns.left = 0;
		rectIns.right = nFrameWidth;
		rectIns.bottom = pEdgeInfo->nGlassEndLine + nOffset.y;
		rectIns.top = pEdgeInfo->nGlassEndLine-szMaster.cy;		
		bFlip = TRUE;
	}
	else
		return rectIns;			

//	AssertFrameRectWidth(rectIns,stFrame.nScanIdx);

// 	int			nWidth = align_4byte(rectIns.Width());
// 	rectIns.left = rectIns.right - nWidth;
// 
// 	if(rectIns.Width() <= 0 || rectIns.Height() <= 0 || rectIns.left > rectIns.right || rectIns.top > rectIns.bottom)
// 		return rectIns;

	return rectIns;
}

void CInspectCamera::SaveFullImageCopy(int iScan)
{
	if(m_pGlassData == NULL)
		return;
	if(m_pGrabber == NULL)
		return;

	CSingleLock		cLock(&m_csSaveimage);
	cLock.Lock();

	DimensionDir eDim = GetDimension(iScan);

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(eDim);
	if(pEdgeInfo == NULL)
		return;

	int			nSetEnd = pEdgeInfo->nGlassEndLine<=0?pEdgeInfo->nPreGlassEndLine:pEdgeInfo->nGlassEndLine;
	int			nOffset = 1000;
	int			nStartLine = pEdgeInfo->nGlassStartLine -nOffset/2;	
	int			nEndLine = nSetEnd +nOffset/2;
	int			nFullSize = nSetEnd-pEdgeInfo->nGlassStartLine+nOffset;		

	if(nStartLine < 0)
	{
		nStartLine = 0;
	}	
	if(nFullSize <= 0)
		return;
	if(nFullSize <= nStartLine)
		return;

	pINSPECTFULLIMAGE_BUFFER		pImgBuf = GetFullImgBuffer(iScan);
	int			nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,iScan,nFrameWidth,nFrameHeight);

	if(nFrameWidth <= 0 || nFrameHeight <= 0)
		return;

	if(nFullSize/nFrameHeight > m_pGrabber->GetFrameBuffer()->GetFrameCount())
		nFullSize = (m_pGrabber->GetFrameBuffer()->GetFrameCount()-1)*nFrameHeight;

	if(nFullSize <= 100)
		return;

	pImgBuf->iCamIdx = m_iCamera;
	pImgBuf->iScanIdx = iScan;		

	pImgBuf->SetSize(CSize(nFrameWidth,nFullSize));

	g_pLog->DisplayMessage(_T( "%s Full Image Memory Copy Start : Start[%d]-End[%d]"),PANEL_SIDE[eDim],nStartLine,nEndLine);	

	LPBYTE			lpHeader = m_pGrabber->GetFrameHeaderLine(iScan,nStartLine);
	if(lpHeader == NULL)
	{		
		g_pLog->DisplayMessage(_T( "%s Full Image Memory Copy fail : Start[%d]-End[%d]"),PANEL_SIDE[eDim],nStartLine,nEndLine);		
		return;
	}

	CopyMemory(pImgBuf->pImage,lpHeader,sizeof(BYTE)*pImgBuf->szImage.cx*pImgBuf->szImage.cy);

	cLock.Unlock();

	g_pLog->DisplayMessage(_T( "%s Full Image Memory Copy complete : Start[%d]-End[%d]"),PANEL_SIDE[eDim],nStartLine,nEndLine);	
}


BOOL CInspectCamera::CheckProcessEnd(int iThread,stFrameIndex stFrame)
{
	if(m_pGlassData == NULL)
		return FALSE;
	if(m_pGrabber == NULL)
		return FALSE;	

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(GetDimension(stFrame.nScanIdx));
	if(pEdgeInfo == NULL)
		return FALSE;

	if(g_pStatus->GetGrabFrameCount(stFrame.nScanIdx)-1 <= stFrame.nFrameIdx)
		return TRUE;
 	if(pEdgeInfo->nPreGlassEndFrame+MAX_THREAD <= stFrame.nFrameIdx)
 		return TRUE;


// 	BOOL bRemain =  m_pGrabber->FindGrabIdx(stFrame.nScanIdx,pEdgeInfo->nPreGlassEndFrame+MAX_THREAD);
// 	if(bRemain == FALSE)
// 	{
// 		return TRUE;
// 	}

	return FALSE;
}

void CInspectCamera::ScanRegionSet(stFrameIndex stFrame)
{
	SetGrabEnd(stFrame.nScanIdx);
	MakeAlignRegion(stFrame.nScanIdx);		
	PresetChamferPrm(stFrame.nScanIdx,GetDimension(stFrame.nScanIdx));
	MakeChamferRegion(stFrame.nScanIdx);
	MakeHoleRegion(stFrame.nScanIdx);	
}

BOOL CInspectCamera::CheckStartLineFrame(DimensionDir eDim,int iFrame)
{
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(eDim);
	if(pEdgeInfo == NULL)
		return FALSE;

	if(pEdgeInfo->nGlassStartFrame > iFrame)
		return FALSE;

	return TRUE;
}

void CInspectCamera::GetChamferRect(stFrameIndex stFrame,DimensionDir eDim,std::vector<CRect> &vecIns)
{
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(eDim);
	if(pEdgeInfo == NULL)
		return;

	int			nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	CRect		rtChamfer = pEdgeInfo->rtChamfer;
	CRect		rtFrame = CRect(0,stFrame.nFrameIdx*nFrameHeight,nFrameWidth,stFrame.nFrameIdx*nFrameHeight+nFrameHeight);
	CRect		rtIns;

	if(rtIns.IntersectRect(rtChamfer,rtFrame) == TRUE)
	{
		CInspectOption		*pInsOpt = g_pStatus->GetInspectOption();
		CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
		if(pCamera == NULL)
			return;

		int		nStageNo = g_pBase->m_nStageNo;

		if(nStageNo < 0 || nStageNo > 1)
			nStageNo = 0;

		rtIns.left = 0;
		rtIns.right = (int)(pInsOpt->nChippingInsArea/pCamera->m_dConvResolution[nStageNo]);
		vecIns.push_back(rtIns);
	}
}

void CInspectCamera::GetChamferThres(DimensionDir eDim,int &nChamferThres,int &nChipThres,int &nChipThres_White, int &nChipDiffThres, int &nBurrThres,int &nCrackThres,int &nBrokenThres)
{
	pSTU_CUTAREA_PARM	pCutArea = m_pRecipe->GetCutAreaPrm(eDim);
	pSTU_CHIP_PARM pChipPrm = m_pRecipe->GetInspectInfo()->GetChipParm(eDim);

	nChamferThres = pCutArea->m_nThresT;	
	nChipThres = pChipPrm->m_nChippingThres_T;
	nChipThres_White = pChipPrm->m_nChippingThres_T_White;
	nBurrThres = pChipPrm->m_nChippingThres_T_L;
	nChipDiffThres = pChipPrm->m_nChipDiffThres;
	nCrackThres = pChipPrm->m_nCrackThres;
	nBrokenThres = pChipPrm->m_nBrokenThres;
}

DIT_RESULT CInspectCamera::FindThickness(int iThread,DimensionDir eDim,stFrameIndex stFrame,int iFindLeft)
{
	DIT_RESULT ret= DIT_CONV_SUCCESS;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return ret;
	
	std::vector<CRect>	vectIns;	

	GetChamferRect(stFrame,eDim,vectIns);

	if((int)vectIns.size() <= 0)
		return ret;
	
	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	double	dScanRes = pCamera->m_dScanResolution[nStageNo];		
		
	int					nPrePos[2];
	ChipErrCode			eChipErr;
	int					nChamferThres,nChamferChipThres,nChamferChipThreshold_White,nChipDiffThres,nBurrThres,nCrackThres,nBrokenThres;

	GetChamferThres(eDim,nChamferThres,nChamferChipThres,nChamferChipThreshold_White,nChipDiffThres,nBurrThres,nCrackThres,nBrokenThres);	
	
	GetChamferControl(iThread)->SetConvResolution(pCamera->m_dConvResolution[nStageNo]);	

	ZeroMemory(nPrePos,sizeof(int)*2);

	CRect		rtIns;
	for(std::vector<CRect>::iterator it=vectIns.begin();it!=vectIns.end();it++)
	{
		rtIns = *it;

		eChipErr = (ChipErrCode)ChamferInspectProcess(iThread,stFrame,eDim,iFindLeft,rtIns,nChamferThres,nChamferChipThres,nChamferChipThreshold_White,nChipDiffThres,nCrackThres,nBrokenThres,nBurrThres,nPrePos);

		if(eChipErr == ERR_CHIP_SUCCESS)
		{
			nPrePos[0] = GetChamferControl(iThread)->GetForeEdgeLine(0);
			nPrePos[1] = GetChamferControl(iThread)->GetForeEdgeLine(1);

			int		nDefect = ChamferExtractResult(iThread,eDim,stFrame,rtIns);
		}		
		else
		{			
			
		}
	}

	if(m_pGlassData != NULL)
	{
		INS_EDGE_RESULT_INFO *pResInfo =  m_pGlassData->GetEdgeResultInfo(eDim);
		if(pResInfo != NULL)
		{			
			pResInfo->nGrindframe[0][stFrame.nFrameIdx] = GetChamferControl(iThread)->GetForeEdgeLine(0);
			pResInfo->nGrindframe[1][stFrame.nFrameIdx] = GetChamferControl(iThread)->GetForeEdgeLine(1);
			pResInfo->nGrindframe[2][stFrame.nFrameIdx] = GetChamferControl(iThread)->GetForeEdgeLine(1);
		}
	}

	return ret;
}

int CInspectCamera::ChamferExtractResult(int iThread,DimensionDir eDim,stFrameIndex stFrame,CRect &rect)
{
	int			nDefect = 0;

	STU_THICKPOS	stRes;

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(eDim);
	if(pEdgeInfo == NULL)
		return FALSE;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return 0;	

	int			nFrameWidth,nFrameHeight;
	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	stRes.dThick = GetChamferControl(iThread)->GetAvgThick()*GetChamferControl(iThread)->GetConvRes();						
	stRes.nLeftLine = GetChamferControl(iThread)->GetForeEdgeLine(0);
	stRes.nRightLine = GetChamferControl(iThread)->GetForeEdgeLine(1);				
	stRes.nTopLine = (stFrame.nFrameIdx*nFrameHeight) + nFrameHeight/2 -pEdgeInfo->nGlassStartLine;

	CINSPECT_JUDGEMENT_PARM	*pJudge = m_pRecipe->GetJudgePrm();

	stRes.nJudgeBase = pJudge->chamfer[eDim][pCamera->m_enCamDir].nRefernce;
	stRes.nJudgeDiff_Plus = pJudge->chamfer[eDim][pCamera->m_enCamDir].nTolPlus;
	stRes.nJudgeDiff_Minus = pJudge->chamfer[eDim][pCamera->m_enCamDir].nTolMinus;

	CSingleLock		cLock(&m_csResultThick);
	cLock.Lock();
	m_resultThickPos[stFrame.nScanIdx].push_back(stRes);
	cLock.Unlock();

	CChipBlob	*pChipRes = GetChamferControl(iThread)->GetDefectResult();		
	int			nDefectCount = GetChamferControl(iThread)->GetDefectCount();

	if(pChipRes != NULL && nDefectCount > 0)
	{			
		if(m_pDefectControl != NULL)
			nDefect = m_pDefectControl->ExtractDefect_Chip(eDim,m_iCamera,stFrame.nScanIdx,pChipRes,nDefectCount,DefectLoc_Chip,rect.top);						
	}	

	return nDefect;
}

int CInspectCamera::ChamferInspectProcess(int iThread,stFrameIndex stFrame,DimensionDir eDim,int iFindLeft,CRect rtIns, int nThresChamfer,int nThresChip,int nThresChip_White,int nThresChipDiff,int nThresCrack,int nThresBroken,int nBurrThres,int *nPrePos)
{	
	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return 0;	

	int			nBufWidth = align_4byte(rtIns.Width());		
	CRect		rectChamfer = CRect(iFindLeft,rtIns.top,iFindLeft,rtIns.bottom);		

	rectChamfer.InflateRect(nBufWidth/2,0);	
	AssertFrameRectWidth(rectChamfer,stFrame.nScanIdx);

	LPBYTE lpHeader = m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,rectChamfer.top);		
	if(lpHeader == NULL)
		return ERR_CHIP_IMAGE_NULL_01;

	pSTU_CHIP_PARM pChipPrm = m_pRecipe->GetInspectInfo()->GetChipParm(eDim);
	if(pChipPrm == NULL)
		return ERR_CHIP_IMAGE_NULL_01;	

	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	double dConvRes = pCamera->m_dConvResolution[nStageNo];

	if (m_pRecipe != nullptr) {
		CProfileInspect_Prm& profile = m_pRecipe->m_ProfilePrm;
		double dProfileRes = profile.m_dConvResolution[eDim][nStageNo];
		if (dProfileRes > 0.0) {
			dConvRes = dProfileRes;
		}
	}

	int		nChipInsArea = (int)((double)pChipPrm->m_nChippingInsArea / dConvRes);
	CRect	rectChip = CRect(rectChamfer.CenterPoint().x, 0, rectChamfer.CenterPoint().x, rectChamfer.Height());
	int		nCrackInsArea = (int)((double)pChipPrm->m_nCrackINsArea / dConvRes);
	CRect	rectCrack = CRect(rectChamfer.CenterPoint().x, 0, rectChamfer.CenterPoint().x, rectChamfer.Height());
	int		nBrokenInsArea = (int)((double)pChipPrm->m_nBrokenInsArea / dConvRes);
	CRect	rectBroken = CRect(rectChamfer.CenterPoint().x, 0, rectChamfer.CenterPoint().x, rectChamfer.Height());

	rectChip.InflateRect(align_4byte(nChipInsArea)/2,0);	
	rectCrack.InflateRect(align_4byte(nCrackInsArea)/2,0);	
	rectBroken.InflateRect(align_4byte(nBrokenInsArea)/2,0);	
	AssertFrameRectWidth(rectChip,stFrame.nScanIdx);	
	AssertFrameRectWidth(rectCrack,stFrame.nScanIdx);
	AssertFrameRectWidth(rectBroken,stFrame.nScanIdx);

	int			nResult;	

	InspectParam insParam;
	insParam.bUse_ChipIns			= m_pRecipe->GetJudgePrm()->defect[(int)eDim][0].Chip_Side.bError;//nThresChip;
	insParam.bUse_CrackIns			= m_pRecipe->GetJudgePrm()->defect[(int)eDim][0].Crack.bError;;
	insParam.bUse_BrokenIns			= m_pRecipe->GetJudgePrm()->defect[(int)eDim][0].Broken.bError;;
	insParam.bUse_BurrIns			= m_pRecipe->GetJudgePrm()->defect[(int)eDim][0].Burr_Side.bError;;
	insParam.nChipThres				= nThresChip;
	insParam.nChipThres_White		= nThresChip_White;
	insParam.nChipDiffThres			= nThresChipDiff;
	insParam.nCrackThres			= nThresCrack;
	insParam.nBrokenThres			= nThresBroken;
	insParam.nBurrThres				= nBurrThres;
	insParam.nChipMinSize			= pChipPrm->m_nChippingInsMinSize;
	insParam.nCrackMinSize			= pChipPrm->m_nCrackInsMinSize;
	insParam.nBrokenMinSize			= pChipPrm->m_nBrokenInsMinSize;
	insParam.nBurrMinSize			= pChipPrm->m_nBurrInsMinSize;
	insParam.nChipSideFilterSize	= pChipPrm->m_nChippingInsSideFilterRange;
	insParam.nCrackSideFilterSize	= pChipPrm->m_nCrackInsSideFilterRange;
	insParam.nBrokenSideFilterSize	= pChipPrm->m_nBrokenInsSideFilterRnage;
	insParam.nBurrSideFilterSize	= pChipPrm->m_nBurrInsSideFilterRange;

	DWORD dwTact = GetTickCount();

	int					nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);
	if(nFrameWidth == 0 || nFrameHeight == 0)
		return ERR_CHIP_IMAGE_NULL_01;

	CInspectOption		*pInsOpt = g_pStatus->GetInspectOption();

	rectChamfer.OffsetRect(0,-rectChamfer.top);
	ChipErrCode errCode = GetChamferControl(iThread)->Inspection(&nResult,lpHeader,nFrameWidth,rectChamfer,nThresChamfer,TRUE,TRUE,rectChip,rectCrack,rectBroken,insParam,pInsOpt->bSaveCutArea,nPrePos,THRESMODE_FIXED,stFrame.nFrameIdx);

// 	dwTact = GetTickCount() - dwTact;
// 	
// 	if(200 < dwTact)
// 		g_pLog->DisplayMessage(_T("Processing to Slow.. frame %d, SpanTime %d ms"), stFrame.nFrameIdx, dwTact);

	return errCode;
}

void CInspectCamera::AssertFrameRectWidth(CRect &rect,int iScan)
{
	int					nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,iScan,nFrameWidth,nFrameHeight);
	if(nFrameWidth == 0 || nFrameHeight == 0)
		return;

	if(rect.left < 0) rect.left = 0;
	if(rect.right >= nFrameWidth) rect.right = nFrameWidth;
}

int	CInspectCamera::GetLeftMargin(int iCam,int iScan)
{
	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(iCam,iScan);
	if(pCamera == NULL)
		return 0;	

	return pCamera->m_nMarginLeft;
}

void CInspectCamera::GetFrameSize(int iCam,int iScan,int &nFrameWidth,int &nFrameHeight)
{
	nFrameWidth = nFrameHeight = 0;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(iCam,iScan);
	if(pCamera == NULL)
		return;	

	nFrameWidth = pCamera->m_FrameSize.cx;
	nFrameHeight = pCamera->m_FrameSize.cy;
}

BOOL CInspectCamera::FindEndLine(int iThread,DimensionDir emDim,stFrameIndex stFrame)
{
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return FALSE;

	if(pEdgeInfo->nPreGlassEndFrame != stFrame.nFrameIdx)
		return FALSE;

	m_MsgJob.nState = 1;
	m_MsgJob.nSide = (int)emDim;
	::SendMessage(m_hWndViewScan, WM_POCESS_STATUS,(WPARAM)&m_MsgJob, (int)emDim);


#define BOUNDARY_GLASSSTARTWIDTH_ENDLINE	140
#define BOUNDARYHORIZ_LEVELDIST_ENDLINE		50	// 荐乞 版拌急阑 茫阑 锭狼 厚背芭府

	int			j,k;
	int			nFrameWidth;
	int			nFrameHeight;
	int			nThreshold = m_pRecipe->GetEtcPrm(emDim)->m_nGlassFindthres_Top * BOUNDARY_GLASSSTARTWIDTH_ENDLINE;		
	int			nCountinueCount = 0;
	int			nHStart, nGab;
	BOOL		bContinue = FALSE;	
	int			nDivHor = 0;
	int			iScan = stFrame.nScanIdx;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);	

	CGLASS_INFO_PARM *pGlsInfo = m_pRecipe->GetGlassInfo();

	int			nSetHor = pGlsInfo->m_nGlassFindHorPos[emDim];
	
	if(nSetHor < BOUNDARY_GLASSSTARTWIDTH_ENDLINE / 2) nSetHor = BOUNDARY_GLASSSTARTWIDTH_ENDLINE / 2;
	if(nSetHor > nFrameWidth-(BOUNDARY_GLASSSTARTWIDTH_ENDLINE / 2)) nSetHor = nFrameWidth-(BOUNDARY_GLASSSTARTWIDTH_ENDLINE / 2);

	g_pLog->DisplayMessage(_T( "%s End Edge Find position Frame[%d],Hor[%d]"),PANEL_SIDE[emDim],stFrame.nFrameIdx,nSetHor);

	nHStart = nSetHor - BOUNDARY_GLASSSTARTWIDTH_ENDLINE / 2;	

	const	int		nCalculateFrame = 3;
	int				nStartFrame = stFrame.nFrameIdx - 2;
	int				nVTop = nStartFrame*nFrameHeight;
	LPBYTE			lpHeader = m_pGrabber->GetFrameHeaderLine(stFrame.nScanIdx,nVTop);

	CSISBuffer		pVertBuffer(lpHeader,nFrameWidth,nCalculateFrame*nFrameHeight);

	if(lpHeader == NULL || pVertBuffer.IsValidBuffer() == FALSE)
		return FALSE;	

// 	{
// 		CString		str;
// 		str.Format(_T("D:\\Image\\EndLine.bmp"));
// 		CBufferAttach	attach(str);
// 		attach.AttachToFile(pVertBuffer);
// 	}

	int			*pnSum = new int[nFrameHeight*nCalculateFrame + BOUNDARYHORIZ_LEVELDIST_ENDLINE];

	ZeroMemory(pnSum, sizeof(int) * (nFrameHeight*nCalculateFrame + BOUNDARYHORIZ_LEVELDIST_ENDLINE));		

	for (j = pVertBuffer.GetHeight()-1 ; j >= 0; j--)
	{
		for (k = nHStart; k < nHStart+BOUNDARY_GLASSSTARTWIDTH_ENDLINE; k++)
		{
			pnSum[j] += *pVertBuffer.GetDataAddress(k,j);
		}			

		if (j <= (pVertBuffer.GetHeight()-1-BOUNDARYHORIZ_LEVELDIST_ENDLINE))
		{
			nGab = abs(pnSum[j + BOUNDARYHORIZ_LEVELDIST_ENDLINE] - pnSum[j]);				
			if (nGab > nThreshold)
				nCountinueCount++;
			else
				nCountinueCount = 0;

			if (nCountinueCount >= 2)
			{
				// Glass狼 矫累瘤痢阑 茫酒辑 备炼眉俊 持绰促.
				pEdgeInfo->nGlassEndLine = nStartFrame*nFrameHeight + j + 2;
				pEdgeInfo->nGlassEndFrame = pEdgeInfo->nGlassEndLine/nFrameHeight;
				pEdgeInfo->nGlassEdgeXPos[1] = nSetHor;

				g_pLog->DisplayMessage(_T( "%s End Line Frame %d, Line %d"), PANEL_SIDE[emDim],pEdgeInfo->nGlassEndLine / nFrameHeight, pEdgeInfo->nGlassEndLine);

				// Log
				g_pLog->DisplayMessage(_T( ""));
				g_pLog->DisplayMessage(_T( "%s Glass EndLine :: %d,%d (nFrameNo=%d)")
					, PANEL_SIDE[emDim]
				, pEdgeInfo->nGlassEdgeXPos[1]
				, pEdgeInfo->nGlassEndLine
					, pEdgeInfo->nGlassEndLine / nFrameHeight);					

				delete [] pnSum;

				SaveGlassLineImage(stFrame.nScanIdx,pEdgeInfo->nGlassEndLine,pEdgeInfo->nGlassEdgeXPos[1],emDim,_T("EndLine"));

				return TRUE;
			}
		}
	}

	pEdgeInfo->nGlassEndLine = pEdgeInfo->nPreGlassEndLine;
	pEdgeInfo->nGlassEndFrame = pEdgeInfo->nPreGlassEndFrame;
	delete [] pnSum;

	g_pLog->DisplayMessage(_T("%s EndLine Frame %d Fail"),PANEL_SIDE[emDim],stFrame.nFrameIdx);

	return FALSE;
}

void CInspectCamera::SaveGlassLineImage(int iScan,int nLine,int nXPos,DimensionDir emDim,CString strName)
{
	int			nImgWidth = 100;
	int			nImgHeight = 200;		
	
	CvRect			saveRect = cvRect(nXPos-nImgWidth,0,nImgWidth*2,nImgHeight*2);

	int			iStartV = nLine-nImgHeight;

	if(iStartV < 0)
		iStartV = 0;

	LPBYTE	pImg = m_pGrabber->GetFrameHeaderLine(iScan,iStartV);
	if(pImg == NULL)
		return;

	IplImage *IpImg = cvCreateImage(cvSize(saveRect.width,saveRect.height),8,1);

	cvZero(IpImg);

	int			nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,iScan,nFrameWidth,nFrameHeight);

	for(int i=0; i< saveRect.height; i++)
	{		
		memcpy(&IpImg->imageData[IpImg->widthStep*i], pImg+saveRect.x, sizeof(BYTE)*IpImg->width);
		pImg += nFrameWidth;
	}

	CString			strFile;
	strFile.Format(_T("%sIMG_MARK\\%s\\%s\\%s\\%s_%s.jpg"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID,g_pBase->m_strLoadingTime,PANEL_SIDE[emDim],strName);

	g_pStatus->CheckDirectory(strFile);

	cv::Point startPoint(0,saveRect.height/2);
	cv::Point endPoint(saveRect.width,saveRect.height/2);

	cvLine(IpImg, startPoint, endPoint, cvScalar(255, 0, 0), 1);

	USES_CONVERSION;
	char str_filename[1024];
	sprintf_s(str_filename, "%s", W2A(strFile));
	
#if MARKIMG_NOTSAVE
	cvSaveImage(str_filename, IpImg);
#endif // 0

	cvReleaseImage(&IpImg);
}

int CInspectCamera::FindLeftLine(int iThread,DimensionDir emDim,stFrameIndex stFrame)
{	
	int nFindLine=-1;		
	
	CETC_PARM	*pEtc = m_pRecipe->GetEtcPrm(emDim);

	if(pEtc == NULL)
	{
		g_pLog->DisplayMessage(_T("Cam[%d],Scan %d,Frame[%d] Find Left Fail : Parameter is Null"),m_iCamera,stFrame.nScanIdx,stFrame.nFrameIdx);
		return GetLeftMargin(m_iCamera,stFrame.nScanIdx);
	}

	int					nThres = pEtc->m_nGlassFindthres_Left;		

#define DEFECT_EDGE_AUTO_RATIO 0.3
#define DEFECT_EDGE_AUTO_PITCH 20
#define DEFECT_EDGE_CONTINUE 3	
	
	
	CSISEdgeFind		EdgeFind;		
	CRect				rtROI;
	const	int			nSearchWidth = 500;
	const   int			nSearchHeight = 100;
	int					nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	CSISBuffer			frameBuffer(m_pGrabber->GetFrameHeader(stFrame.nScanIdx,stFrame.nFrameIdx),nFrameWidth,nFrameHeight);
	if(frameBuffer.IsValidBuffer() == FALSE)
		return nFindLine;

	rtROI = CRect(GetLeftMargin(m_iCamera,stFrame.nScanIdx),0,frameBuffer.GetWidth()-1,frameBuffer.GetHeight());

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return nFindLine;

	if(pEdgeInfo->nGlassStartLine != 0 && abs(pEdgeInfo->nGlassStartFrame - stFrame.nFrameIdx) <= 3)
	{
		rtROI.bottom = frameBuffer.GetHeight()-1;
		rtROI.top = rtROI.bottom - nSearchHeight;
	}
	else if(pEdgeInfo->nGlassEndLine != 0 && pEdgeInfo->nGlassEndLine/frameBuffer.GetHeight() == stFrame.nFrameIdx)
	{
		rtROI.top = 0;
		rtROI.bottom = rtROI.top + nSearchHeight;
	}
	else
	{
		rtROI.top = frameBuffer.GetHeight()/2 - nSearchHeight/2;
		rtROI.bottom = rtROI.top + nSearchHeight;
	}

	if(rtROI.left < 0)
		rtROI.left = 0;
	if(rtROI.right >= frameBuffer.GetWidth())
		rtROI.right = frameBuffer.GetWidth()-1;
	if(rtROI.top < 0)
		rtROI.top = 0;
	if(rtROI.bottom >= frameBuffer.GetHeight())
		rtROI.bottom = frameBuffer.GetHeight()-1;
		
	EdgeFind.FindEdge_ToRightROI(&frameBuffer,nFindLine,DEFECT_EDGE_AUTO_PITCH,nThres,DEFECT_EDGE_AUTO_RATIO,0,rtROI);
		

	if(nFindLine > 0 && nFindLine < frameBuffer.GetWidth())
	{
		m_iSideLine[stFrame.nScanIdx] = nFindLine;	
		
		pEdgeInfo->nGrindframe[0][stFrame.nFrameIdx] = nFindLine;

		//Log_GetDebug()->TraceInfo("Trace Left Edge: %d, %d, (%d, %d, %d, %d), %d, %d", 
		//	(int)emDim, stFrame.nScanIdx,
		//	rtROI.left, rtROI.top, rtROI.Width(), rtROI.Height(),
		//	nFindLine, __LINE__);
	}
	
// 	{
// 		CString		str;
// 		str.Format(_T("%sIMG_MARK\\FrameEdge_%s_%03d_%d_%04d_roi_%d_%d_%d_%d.bmp"),PATH_INSPECTION_DATA,PANEL_SIDE[emDim],stFrame.nFrameIdx,iThread,nFindLine,rtROI.left,rtROI.top,rtROI.right,rtROI.bottom);
// 		CBufferAttach		attach(str);
// 		attach.AttachToFile(frameBuffer);
// 	}	
	
	return nFindLine;
}

BOOL CInspectCamera::OnThreadEnd(int iThread, CInspectThread *pInspectThread)
{
	return TRUE;
}

BOOL CInspectCamera::OnThreadEndAll()
{
	return TRUE;
}

void CInspectCamera::ReleaseSplineBuffer()
{	
	int			i;

	for(i=0;i<MAX_PANEL_SIDE;i++)
	{
		m_SplineImage[i].Reset();		
	}	
}

void CInspectCamera::ReleaseFullBuffer()
{		
	int		i;
	for(i=0;i<MAX_SCAN_COUNT;i++)
	{
		m_FullImgBuffer[i].Reset();
	}		
}

void CInspectCamera::SetParameter(CGlassRecipe *pRecipe,CHardwareSettings *pHW)
{
	g_pLog->DisplayMessage(_T("SetParameter Cam[%d] start"),m_iCamera);

	m_bExitThread = TRUE;
	ZeroMemory(m_iThreadEnd,sizeof(m_iThreadEnd));
	ZeroMemory(m_bFindGlassStart,sizeof(m_bFindGlassStart));
	ZeroMemory(m_iSideLine,sizeof(m_iSideLine));
	ZeroMemory(m_dMark2MarkX,sizeof(m_dMark2MarkX));
	ZeroMemory(m_dMark2MarkY,sizeof(m_dMark2MarkY));
	ZeroMemory(m_bSplineInspect,sizeof(m_bSplineInspect));
	ZeroMemory(m_bProfileFind,sizeof(m_bProfileFind));
	ZeroMemory(m_nProfileFindFrameIdx,sizeof(m_nProfileFindFrameIdx));
		
	for(int i=0;i<MAX_SCAN_COUNT;i++)
	{		
		CSingleLock		cLock(&m_csResultThick);
		cLock.Lock();
		m_resultThickPos[i].clear();
		cLock.Unlock();
		
		CSingleLock		cHLock(&m_csHoleReion);
		cHLock.Lock();
		m_vecHoleReg[i].clear();
		cHLock.Unlock();
	}
	
	m_pRecipe = pRecipe;
	m_pHardparm = pHW;

	if(m_pGrabber != NULL)
	{
		m_pGrabber->ClearGrabIdx();
		//m_pGrabber->ClearBuffer();
	}	
	
	if(m_pDefectControl != NULL)
	{
		m_pDefectControl->SetHWRecipe(pHW);
		m_pDefectControl->ResetDefectControl();
	}

	g_pLog->DisplayMessage(_T("SetParameter Cam[%d] end"),m_iCamera);
}

void CInspectCamera::DeleteCADAlign(std::multimap<int, CPoint*> *pSetProfileAlignMap)
{
	CSingleLock		csLock(&m_csProfile);
	csLock.Lock();

	std::multimap<int, CPoint*>::iterator	it;

	CPoint		*pPoint;
	for(it=pSetProfileAlignMap->begin();it!=pSetProfileAlignMap->end();it++)
	{
		pPoint = it->second;
		if(pPoint == NULL)
			continue;
		delete pPoint;
		pPoint = NULL;
	}
	pSetProfileAlignMap->clear();

	csLock.Unlock();
}

void CInspectCamera::SetCADData(std::multimap<int, CPoint *> *pProfileMap,CPoint *ptOrigin)
{
	if(m_pRecipe == NULL || pProfileMap == NULL)
		return;

	CProfileCADProc *pProfile = NULL;
	int			iScan,iSide;
	std::multimap<int, CPoint*> *pSetProfileMap;
	std::multimap<int, CPoint*> *pSetProfileAlignMap;
	
	for(iScan=0;iScan<MAX_SCAN_COUNT;iScan++)
	{
		iSide =	GetDimension(iScan)%MAX_PANEL_SIDE;		
		pSetProfileMap = &pProfileMap[iSide];
		pSetProfileAlignMap = &m_mapAlignProfile[iScan];

		DeleteCADAlign(pSetProfileAlignMap);

		for(int iThread=0;iThread<MAX_THREAD;iThread++)
		{
			pProfile = GetProfileControl(iScan,iThread);
			if(pProfile == NULL)
				continue;					
			
			pProfile->SetProfileData(pSetProfileMap,pSetProfileAlignMap);		
			pProfile->SetProfileOrigin(ptOrigin[iSide]);
		}
	}
}

void CInspectCamera::SetGlassData(CGlass_Data *pGlassData)
{
	m_pGlassData=pGlassData;
	if(m_pDefectControl != NULL)
		m_pDefectControl->SetGlassData(pGlassData);

	if(m_pGrabber != NULL)
	{
		for(int i=0;i<MAX_DIMENSION_COUNT;i++)
		{
			INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo((DimensionDir)i);
			if(pEdgeInfo == NULL)
				continue;

			pEdgeInfo->nPreGlassEndFrame = m_pGrabber->GetFrameBuffer()->GetFrameCount()-1;
		}
	}
}

void CInspectCamera::SetGrabber(CGrabberControl *pGrabber)
{
	m_pGrabber = pGrabber;
	if(m_pDefectControl != NULL)
		m_pDefectControl->SetGrabber(pGrabber);
}

DimensionDir CInspectCamera::GetDimension(int iScan)
{
	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,iScan);
	if(pCamera == NULL)
		return DIMENSION_NONE;

	return pCamera->m_eDimension;
}

void CInspectCamera::SetGrabEnd(int iScan)
{
	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,iScan);
	if(pCamera == NULL)
		return;

	DimensionDir		emDim = pCamera->m_eDimension;
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return;

	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	int		nGlassSize;
	if(pCamera->m_eScanDir == SCANGLASS_X)
		nGlassSize = (int)((double)m_pRecipe->GetGlassInfo()->m_nGlassSizeX/pCamera->m_dScanResolution[nStageNo]);
	else
		nGlassSize = (int)((double)m_pRecipe->GetGlassInfo()->m_nGlassSizeY/pCamera->m_dScanResolution[nStageNo]);

	pEdgeInfo->nPreGlassEndLine = pEdgeInfo->nGlassStartLine + nGlassSize;
	pEdgeInfo->nPreGlassEndFrame = pEdgeInfo->nPreGlassEndLine/pCamera->m_FrameSize.cy;

	g_pStatus->SetGrabFrametoScan(iScan,pEdgeInfo->nPreGlassEndFrame+5);

	g_pLog->DisplayMessage(_T("%s Scan %d : Set Grab EndFrame - GlassEnd %d, Frame %d, GrabBuf %d"),PANEL_SIDE[emDim],iScan,pEdgeInfo->nPreGlassEndLine,pEdgeInfo->nPreGlassEndFrame,pEdgeInfo->nPreGlassEndFrame+5);
}

#define			CHAMFER_MIN_INSPECT_HEIGHT		1000
#define			CHAMFER_MIN_INSPECT_SEARCHWIDTH 500
#define			CHIPPING_MIN_INSPECT_AREA		150

void CInspectCamera::PresetChamferPrm(int iScan,DimensionDir eDim)
{
	pSTU_CUTAREA_PARM	pCutArea = m_pRecipe->GetInspectInfo()->GetCutAreaParm(eDim);
	pSTU_CHIP_PARM		pChipPrm =	m_pRecipe->GetInspectInfo()->GetChipParm(eDim);
	CInspectOption		*pInsOpt = g_pStatus->GetInspectOption();

	if(pCutArea->m_bCutArea == TRUE)
	{
		pCutArea->m_nCalArea = pInsOpt->nChamferInsHeight;
		pCutArea->m_nSearchWidth = pInsOpt->nChamferSearchWidth;

		if(pCutArea->m_nCalArea < CHAMFER_MIN_INSPECT_HEIGHT)
			pCutArea->m_nCalArea = CHAMFER_MIN_INSPECT_HEIGHT;
		if(pCutArea->m_nSearchWidth < CHAMFER_MIN_INSPECT_SEARCHWIDTH)
			pCutArea->m_nSearchWidth = CHAMFER_MIN_INSPECT_SEARCHWIDTH;
	}

	pChipPrm->m_bChipping = pCutArea->m_bCutArea;

	if(pChipPrm->m_bChipping == TRUE)
	{
		pChipPrm->m_nChippingInsArea = pInsOpt->nChippingInsArea;

		if(pChipPrm->m_nChippingInsArea < CHIPPING_MIN_INSPECT_AREA)
			pChipPrm->m_nChippingInsArea = CHIPPING_MIN_INSPECT_AREA;

		pChipPrm->m_nCrackINsArea = pInsOpt->nCrackINsArea;

		if(pChipPrm->m_nCrackINsArea < CHIPPING_MIN_INSPECT_AREA)
			pChipPrm->m_nCrackINsArea = CHIPPING_MIN_INSPECT_AREA;

		pChipPrm->m_nBrokenInsArea = pInsOpt->nBrokenInsArea;

		if(pChipPrm->m_nBrokenInsArea < CHIPPING_MIN_INSPECT_AREA)
			pChipPrm->m_nBrokenInsArea = CHIPPING_MIN_INSPECT_AREA;

		// 20. 11. 14
		pChipPrm->m_nChippingInsMinSize = pInsOpt->nChippingInsMinSize;
		pChipPrm->m_nCrackInsMinSize = pInsOpt->nCrackInsMinSize;
		pChipPrm->m_nBrokenInsMinSize = pInsOpt->nBrokenInsMinSize;
		pChipPrm->m_nBurrInsMinSize = pInsOpt->nBurrInsMinSize;

		pChipPrm->m_nChippingInsSideFilterRange = pInsOpt->nChippingInsSideFilterRange;
		pChipPrm->m_nCrackInsSideFilterRange = pInsOpt->nCrackInsSideFilterRange;
		pChipPrm->m_nBrokenInsSideFilterRnage = pInsOpt->nBrokenInsSideFilterRnage;
		pChipPrm->m_nBurrInsSideFilterRange = pInsOpt->nBurrInsSideFilterRange;
	}

	CETC_PARM *pEtcPrm = m_pRecipe->GetEtcPrm(eDim);
	if(pEtcPrm != NULL)
	{
		CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,iScan);
		if(pCamera == NULL)
			return;

		pEtcPrm->m_nGlassFindWidth_Left = pCamera->m_FrameSize.cx-1;
		pEtcPrm->m_nGlassLeftLineMargin[0] = pEtcPrm->m_nGlassLeftLineMargin[1] = 0;
		pEtcPrm->m_nGlassFindthres_Left = pEtcPrm->m_nGlassFindthres_Top;
	}
}

void CInspectCamera::MakeHoleRegion(int iScan)
{
	DimensionDir emDim = GetDimension(iScan);	

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return;	

	CSingleLock		cLock(&m_csHoleReion);
	cLock.Lock();

	m_vecHoleReg[iScan].clear();
	for(int i=0; i<m_pRecipe->GetHolePrm()->m_nTotalHoleCount; i++)
	{
		if(m_pRecipe->GetHolePrm()->m_vecHoleInsParam[i].m_nSideIdx == iScan)
		{
			m_vecHoleReg[iScan].push_back(m_pRecipe->GetHolePrm()->m_vecHoleInsParam[i]);
		}
	}
	cLock.Unlock();
}

void CInspectCamera::GetHoleRegionFrame(int iThread,DimensionDir emDim,stFrameIndex stFrame, std::vector<HOLE_INS_PARM> &vecArray)
{
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return;

	vector<HOLE_INS_PARM>::iterator		it;

	if(pEdgeInfo->bMark[0] == FALSE)
		return;

	int			nFrameWidth,nFrameHeight;
	GetFrameSize(m_iCamera,stFrame.nScanIdx,nFrameWidth,nFrameHeight);

	vecArray.clear();
	for(it=m_vecHoleReg[stFrame.nScanIdx].begin();it!=m_vecHoleReg[stFrame.nScanIdx].end();it++)
	{
		if(stFrame.nFrameIdx == (it->m_rtArea.bottom + (int)pEdgeInfo->ptMark[0].y)/nFrameHeight)
		{
			vecArray.push_back(*it);
		}
	}
}

void CInspectCamera::MakeChamferRegion(int iScan)
{
	DimensionDir emDim = GetDimension(iScan);

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,iScan);
	if(pCamera == NULL)
		return;

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return;

	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	double		dConv = pCamera->m_dConvResolution[nStageNo];
	double		dScan = pCamera->m_dScanResolution[nStageNo];

	if(dConv <= 0 || dScan <= 0)
		return;

	int		nGlassSize;
	if(pCamera->m_eScanDir == SCANGLASS_X)
		nGlassSize = (int)(m_pRecipe->GetGlassInfo()->m_nGlassSizeX/dScan);
	else
		nGlassSize = (int)(m_pRecipe->GetGlassInfo()->m_nGlassSizeY/dScan);

	int			nRSize = 0,nRSize2 = 0;
	pSTU_SPLINE_INS_PARM pSpline = m_pRecipe->GetInspectInfo()->GetSplineIns(emDim);
	if(pSpline != NULL )
	{
		nRSize = pSpline->m_nStartCornerSize_Y;
		nRSize2 = pSpline->m_nEndCornerSize_Y;
	}
	
	pEdgeInfo->rtChamfer = CRect(0,nRSize,pCamera->m_FrameSize.cx,nGlassSize-nRSize2);
	pEdgeInfo->rtChamfer.OffsetRect(0,pEdgeInfo->nGlassStartLine);
	
	g_pLog->DisplayMessage(_T("%s Scan %d : Chamfer Region %d,%d"),PANEL_SIDE[emDim],iScan,pEdgeInfo->rtChamfer.top,pEdgeInfo->rtChamfer.bottom);
}

void CInspectCamera::MakeAlignRegion(int iScan)
{	
	CINSPECT_JUDGEMENT_PARM *pJudgePrm = m_pRecipe->GetJudgePrm();	

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,iScan);
	if(pCamera == NULL)
		return;

	DimensionDir emDim = GetDimension(iScan);

	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return;

	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	double		dConv = pCamera->m_dConvResolution[nStageNo];
	double		dScan = pCamera->m_dScanResolution[nStageNo];

	if(dConv <= 0 || dScan <= 0)
		return;

	int		nGlassSize;
	if(pCamera->m_eScanDir == SCANGLASS_X)
		nGlassSize = m_pRecipe->GetGlassInfo()->m_nGlassSizeX;
	else
		nGlassSize = m_pRecipe->GetGlassInfo()->m_nGlassSizeY;

	int		iSide = (int)emDim;

	m_dMark2MarkX[iScan][0] = (pJudgePrm->ptAlign[0][iSide].x/dConv);	
	m_dMark2MarkX[iScan][1] = (pJudgePrm->ptAlign[1][iSide].x/dConv);				
	m_dMark2MarkY[iScan][0]   = (pJudgePrm->ptAlign[0][iSide].y/dScan);	
	m_dMark2MarkY[iScan][1]   =  ((nGlassSize-pJudgePrm->ptAlign[1][iSide].y)/dScan);
	m_dMark2MarkX[iScan][2] = (pJudgePrm->ptAlign[2][iSide%MAX_PANEL_SIDE].x/dConv);	
	m_dMark2MarkY[iScan][2] = ((pJudgePrm->ptAlign[2][iSide%MAX_PANEL_SIDE].y)/dScan);
		
	CInspectOption	*pOpt =	g_pStatus->GetInspectOption();

	int		nAlignRange = pOpt->nAlignMarkRange;
	int		nAlignRangeY = pOpt->nAlignMarkRangeY;

	if(nAlignRange < 100)
		nAlignRange = 100;
	if(nAlignRangeY < 100)
		nAlignRangeY = 100;

	pEdgeInfo->rtMark[0] = CRect((int)m_dMark2MarkX[iScan][0],(int)m_dMark2MarkY[iScan][0],(int)m_dMark2MarkX[iScan][0],(int)m_dMark2MarkY[iScan][0]);
	pEdgeInfo->rtMark[0].InflateRect(nAlignRange,nAlignRangeY);
	pEdgeInfo->rtMark[1] = CRect((int)m_dMark2MarkX[iScan][1],(int)m_dMark2MarkY[iScan][1],(int)m_dMark2MarkX[iScan][1],(int)m_dMark2MarkY[iScan][1]);
	pEdgeInfo->rtMark[1].InflateRect(nAlignRange,nAlignRangeY);
	pEdgeInfo->rtMark[2] = CRect((int)m_dMark2MarkX[iScan][2],(int)m_dMark2MarkY[iScan][2],(int)m_dMark2MarkX[iScan][2],(int)m_dMark2MarkY[iScan][2]);
	pEdgeInfo->rtMark[2].InflateRect(nAlignRange,nAlignRangeY);

	pEdgeInfo->rtMark[0].OffsetRect(0,pEdgeInfo->nGlassStartLine);
	pEdgeInfo->rtMark[1].OffsetRect(0,pEdgeInfo->nGlassStartLine);
	pEdgeInfo->rtMark[2].OffsetRect(0,pEdgeInfo->nGlassStartLine);
}

BOOL CInspectCamera::FindAlignProcess(int iThread,DimensionDir eDim,int iScan,int iFrame)
{
	int			iPos;		

	for(iPos=0;iPos<3;iPos++)
	{
		FindAlignMark(iThread,eDim,iScan,iFrame,iPos);
	}

	return TRUE;
}

BOOL CInspectCamera::FindAlignMark(int iThread,DimensionDir eDim, int iScan,int iFrame,int iPos)
{	
	BOOL		bRet = FALSE;

	INS_EDGE_RESULT_INFO *pResInfo =  m_pGlassData->GetEdgeResultInfo(eDim);
	CALIGNMARK_PARM *pAlignPrm = m_pRecipe->GetAlignMarkPrm(eDim);		

	if(pResInfo != NULL && pResInfo->bMark[iPos] == TRUE)
		return TRUE;

	CRect		rectAlign =	pResInfo->rtMark[iPos];
	if(rectAlign.top <= 0)
		return FALSE;
	
	int			nFrameWidth,nFrameHeight;

	GetFrameSize(m_iCamera,iScan,nFrameWidth,nFrameHeight);

	switch(iPos)
	{
	case 0:
		if(iFrame != rectAlign.bottom/nFrameHeight+2)
			return FALSE;		
		break;
	default:
		if(iFrame != rectAlign.bottom/nFrameHeight)
			return FALSE;
		break;
	}				

	LPBYTE		lpBuffer = m_pGrabber->GetFrameHeaderLine(iScan,rectAlign.top);
	if(lpBuffer == NULL)
		return FALSE;		
	
	CSISBuffer frameBuffer(lpBuffer, nFrameWidth, rectAlign.Height());	

	if(!frameBuffer.IsValidBuffer())
	{
		return FALSE;
	}				

	if(iPos == 1)
	{
		int aa = 100;
	}

	stFrameIndex		stFrame(iScan,iFrame);
	m_iSideLine[iScan] = FindLeftLine(iThread,eDim,stFrame);
	if(m_iSideLine[iScan] <= 0 || m_iSideLine[iScan] >= nFrameWidth)	
	{
		if(iPos == 1)
		{				
			if(pResInfo != NULL)
			{
				for(int i=iFrame-1;i>=pResInfo->nGlassStartLine/nFrameHeight-1;i--)
				{
					if(pResInfo->nGrindframe[0][i] > 0 && pResInfo->nGrindframe[0][i] < nFrameWidth)
					{
						m_iSideLine[iScan] = pResInfo->nGrindframe[0][i];
						break;
					}
				}
			}				
		}

		if(m_iSideLine[iScan] <= 0)
		{
			g_pLog->DisplayMessage(_T("%s Align Mark Find[%d] Edge Find Fail : Frame %d, %d,%d,%d,%d"),PANEL_SIDE[eDim],iPos, iFrame,rectAlign.left,rectAlign.top,rectAlign.right,rectAlign.bottom);
			m_iSideLine[iScan] = GetLeftMargin(m_iCamera,iScan);
		}
	}			

	CString			strPos = _T("TOP");
	CString			strRes = _T("Fail");

	switch(iPos)
	{
	case 1: strPos = _T("BOT"); break;
	case 2: strPos = _T("SUB"); break;
	}					

	rectAlign.OffsetRect(m_iSideLine[iScan],0);

	if(pAlignPrm->m_bIsMark[iPos] == FALSE)
	{
		pResInfo->bMark[iPos] = TRUE;
		pResInfo->ptMark[iPos].x	= (float)rectAlign.CenterPoint().x;
		pResInfo->ptMark[iPos].y	= (float)rectAlign.CenterPoint().y;
		pResInfo->nMarkToEdge_X[iPos] = (int)(pResInfo->ptMark[iPos].x - m_iSideLine[iScan]);
		pResInfo->nMarkToEdge_Y[iPos] = (int)(pResInfo->ptMark[iPos].y - pResInfo->nGlassStartLine);

		g_pLog->DisplayMessage(_T("%s Virtual Align Mark Pos[%d] x : %.2f, y : %.2f"),PANEL_SIDE[eDim],iPos,pResInfo->ptMark[iPos].x,pResInfo->ptMark[iPos].y);

		return TRUE;
	}

	g_pLog->DisplayMessage(_T("%s Align Mark Pos[%d] %d,%d,%d,%d"),PANEL_SIDE[eDim],iPos,rectAlign.left,rectAlign.top,rectAlign.right,rectAlign.bottom);

	double			dRate = 0.5;
	TEMP_RESULT		matchResut;
	CRect rectIns = rectAlign;				

	rectIns.OffsetRect(0,-rectIns.top);
	matchResut.fRat = 0.;
	matchResut.pt.x = matchResut.pt.y = 0;

	for(int iMarkPos=0;iMarkPos<MAX_POS_MARKER_COUNT;iMarkPos++)
	{
		if(pAlignPrm->IpMarkImg[iPos][iMarkPos] == NULL)
			continue;	

		CRect		rtFind = rectIns;

		if(rtFind.Width() <= pAlignPrm->IpMarkImg[iPos][iMarkPos]->width)
			rtFind.right = rtFind.left + pAlignPrm->IpMarkImg[iPos][iMarkPos]->width + 10;
		if(rtFind.Height() <= pAlignPrm->IpMarkImg[iPos][iMarkPos]->height)
			rtFind.bottom = rtFind.top + pAlignPrm->IpMarkImg[iPos][iMarkPos]->height + 10;

		CEdgeProc		insProc;
		insProc.CvFindMark(frameBuffer,pAlignPrm->IpMarkImg[iPos][iMarkPos],rtFind,matchResut,dRate);

		if(matchResut.fRat*100. >= pAlignPrm->m_dMarkMatchingRate[iPos][iMarkPos])
		{				
			if(pResInfo != NULL)
			{
				pResInfo->bMark[iPos] = TRUE;
				pResInfo->ptMark[iPos].x	= matchResut.pt.x;
				pResInfo->ptMark[iPos].y	= matchResut.pt.y + rectAlign.top;
				pResInfo->nMarkToEdge_X[iPos] = (int)(pResInfo->ptMark[iPos].x - m_iSideLine[iScan]);
				pResInfo->nMarkToEdge_Y[iPos] = (int)(pResInfo->ptMark[iPos].y - pResInfo->nGlassStartLine);			

				//pResInfo->nGrindframe[0][iFrame] = pResInfo->nGrindframe[1][iFrame] = m_iSideLine[iScan];
			}

			g_pLog->DisplayMessage(_T("%s Align Mark Find[%d][%d] Success x %.2f, y %.2f"),PANEL_SIDE[eDim],iPos,iMarkPos,matchResut.pt.x, matchResut.pt.y + rectAlign.top);
			strRes = _T("Success");
			break;
		}				
	}

	if(pResInfo != NULL && pResInfo->bMark[iPos] == FALSE)
	{
		if(iPos != 2)		// sub mark绰 力寇
		{
			pResInfo->bMark[iPos] = TRUE;
			pResInfo->ptMark[iPos].x	= (float)rectAlign.CenterPoint().x;
			pResInfo->ptMark[iPos].y	= (float)rectAlign.CenterPoint().y;
			pResInfo->nMarkToEdge_X[iPos] = (int)(pResInfo->ptMark[iPos].x - m_iSideLine[iScan]);
			pResInfo->nMarkToEdge_Y[iPos] = (int)(pResInfo->ptMark[iPos].y - pResInfo->nGlassStartLine);

			g_pLog->DisplayMessage(_T("%s Virtual Align Mark Pos[%d] x : %.2f, y : %.2f"),PANEL_SIDE[eDim],iPos,pResInfo->ptMark[iPos].x,pResInfo->ptMark[iPos].y);
		}
		//pResInfo->nGrindframe[0][iFrame] = pResInfo->nGrindframe[1][iFrame] = m_iSideLine[iScan];
		g_pLog->DisplayMessage(_T("%s Align Mark Find[%d] Fail x %.2f, y %.2f"),PANEL_SIDE[eDim],iPos,m_iSideLine[iScan] + m_dMark2MarkX[iScan][iPos], pResInfo->nGlassStartLine + m_dMark2MarkY[iScan][iPos]);		
	}

	/*
	CString			strFile;		
	CvRect			saveRect = cvRect((int)matchResut.pt.x-rectAlign.Width()/2,(int)(matchResut.pt.y + rectAlign.top)-rectAlign.Height()/2,rectAlign.Width(),rectAlign.Height());
	strFile.Format(_T("%sIMG_MARK\\%s\\%s\\%s\\Align_%s_%s_%s.jpg"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID,g_pBase->m_strLoadingTime,strPos,PANEL_SIDE[eDim],strRes);

	SaveCvAlignImage(saveRect,strFile,iScan,nFrameWidth,nFrameHeight);		
	*/

	if(iPos == 0)			// 霉锅掳 Align 茫疽阑措父 True
		bRet = TRUE;
			

	return bRet;
}

BOOL CInspectCamera::SaveCvAlignImage(CvRect saveRoi,CString strFile,int iScan,int nFrameWidth,int nFrameHeight)
{	
	LPBYTE		pImg = m_pGrabber->GetFrameHeaderLine(iScan,saveRoi.y);

	if(pImg == NULL)	
		return FALSE;	

	IplImage* IpImg = cvCreateImage(cvSize(saveRoi.width, saveRoi.height), 8, 1);
	cvZero(IpImg);

	for(int i=0; i< saveRoi.height; i++)
	{		
		memcpy(&IpImg->imageData[IpImg->widthStep*i], pImg+saveRoi.x, sizeof(BYTE)*IpImg->width);
		pImg += nFrameWidth;
	}

	g_pStatus->CheckDirectory(strFile);

	int			nLineSize = 10;
	CPoint		posC = CPoint(saveRoi.width/2,saveRoi.height/2);

	cv::Point startPoint(posC.x-nLineSize,posC.y);
	cv::Point endPoint(posC.x+nLineSize,posC.y);
	cvLine(IpImg, startPoint, endPoint, cvScalar(192, 192, 192), 1);

	cv::Point startPoint2(posC.x,posC.y-nLineSize);
	cv::Point endPoint2(posC.x,posC.y+nLineSize);
	cvLine(IpImg, startPoint2, endPoint2, cvScalar(192, 192, 192), 1);

	USES_CONVERSION;
	char str_filename[1024];
	sprintf_s(str_filename, "%s", W2A(strFile));

	cvSaveImage(str_filename,IpImg);
	cvReleaseImage(&IpImg);

	return TRUE;
}

BOOL CInspectCamera::FindGlassStartLine(DimensionDir emDim,stFrameIndex stFrame)
{			
	INS_EDGE_RESULT_INFO *pEdgeInfo = m_pGlassData->GetEdgeResultInfo(emDim);
	if(pEdgeInfo == NULL)
		return FALSE;

	CCameraSettings *pCamera = m_pHardparm->GetCameraSettings(m_iCamera,stFrame.nScanIdx);
	if(pCamera == NULL)
		return FALSE;

	CGLASS_INFO_PARM *pGlsInfo = m_pRecipe->GetGlassInfo();

	int			nFrame = m_pGrabber->GetFrameBuffer()->GetFrameCount()/2;
	int			nFrameWidth = pCamera->m_FrameSize.cx;
	int			nFrameHeight = pCamera->m_FrameSize.cy;
	int			nSkipFrame = pGlsInfo->m_nFindGlassStartOffset[emDim] / nFrameHeight;
	int			nSetHor = pGlsInfo->m_nGlassFindHorPos[emDim];

	if(nSetHor < BOUNDARY_GLASSSTARTWIDTH / 2) nSetHor = BOUNDARY_GLASSSTARTWIDTH / 2;
	if(nSetHor > nFrameWidth-(BOUNDARY_GLASSSTARTWIDTH / 2)) nSetHor = nFrameWidth-(BOUNDARY_GLASSSTARTWIDTH / 2);

	pEdgeInfo->nGlassEdgeXPos[0] = nSetHor;	

	int			j, k, nGab;
	int			nThreshold = m_pRecipe->GetEtcPrm(emDim)->m_nGlassFindthres_Top * BOUNDARY_GLASSSTARTWIDTH;
	int			*pnSum = new int[nFrameHeight + BOUNDARYHORIZ_LEVELDIST];
	LPBYTE		lpHeader;
	int			nCountinueCount = 0;
	int			nRet,nHStart;

	DWORD		dwT1 = GetTickCount();

	g_pLog->DisplayMessage(_T("%s Find Glass Start Start : Scan %d "),PANEL_SIDE[emDim],stFrame.nScanIdx);

	for(int iFrame=0;iFrame<nFrame;iFrame++)
	{
		while (TRUE)
		{
			nRet = m_pGrabber->IsAcqFrame(iFrame);
			if (nRet < 2)		// 酒流 救嘛躯栏骨肺 措扁.
			{
				if (GetTickCount() - dwT1 > TIME_WAIT_GLASS_START)
				{
					g_pLog->DisplayMessage(_T("%s Find Glass Start : no image(Grab Time Out),%d sec"),PANEL_SIDE[emDim],TIME_WAIT_GLASS_START/1000);
					delete [] pnSum;					
					return FALSE;
				}
				Sleep(1);
			}	
			else
				break;

		}
		if (nSkipFrame > iFrame)
			continue;	

		lpHeader = m_pGrabber->GetFrameHeader(stFrame.nScanIdx,iFrame);		
		if(lpHeader == NULL)
		{
			g_pLog->DisplayMessage(_T("%s Find Glass Start : no image(Image is Null)"),PANEL_SIDE[emDim]);
			delete [] pnSum;
			return FALSE;
		}

		ZeroMemory(pnSum, sizeof(int) * (nFrameHeight + BOUNDARYHORIZ_LEVELDIST));
		int nLine = 0;
		nHStart = nSetHor - BOUNDARY_GLASSSTARTWIDTH / 2;

		BOOL		bChangeBuffer = FALSE;
		for (j = 0; j < nFrameHeight + BOUNDARYHORIZ_LEVELDIST; j++)
			//for (j = 0; j < nFrameHeight; j++)
		{
			for (k = nHStart; k < nHStart + BOUNDARY_GLASSSTARTWIDTH; k++)
			{
				// Grab牢 版快 滚欺狼 版拌俊辑 1024扼牢阑 逞绢哎 版快 促澜 滚欺甫 啊廉客具 茄促.
				if (j == nFrameHeight && nLine != 0 && bChangeBuffer == FALSE)
				{					
					DWORD dwTick = GetTickCount();
					while (TRUE)
					{			
						if(GetTickCount()-dwTick > TIME_WAIT_GLASS_START/2)	
						{					
							g_pLog->DisplayMessage(_T("%s No Image"),PANEL_SIDE[emDim]);
							delete [] pnSum;
							return FALSE;
						}

						if(m_pGrabber->IsAcqFrame(iFrame + 1) > 1)
						{
							lpHeader = m_pGrabber->GetFrameHeader(stFrame.nScanIdx,iFrame + 1);
							if(lpHeader != NULL)
							{
								bChangeBuffer = TRUE;
								//g_pLog->DisplayMessage(_T("%s Change Buffer %d, %d, %d"),PANEL_SIDE[pRecipe->GetDimension()], j, i, g_pBase->m_pMemFrameNo[GetCameraID()]);
								break;
							}	
						}										
					}					
					nLine = 0;
				}

				pnSum[j] += *(lpHeader + nLine * nFrameWidth + k);
			}
			nLine++;			

			if (j >= BOUNDARYHORIZ_LEVELDIST)
			{
				nGab = abs(pnSum[j - BOUNDARYHORIZ_LEVELDIST] - pnSum[j]);				
				if (nGab > nThreshold)
					nCountinueCount++;
				else
					nCountinueCount = 0;

				if (nCountinueCount >= 2)
				{
					g_pLog->DisplayMessage(_T("%s Start Line Frame %d, Line %d, Gab %d, Thres %d"), PANEL_SIDE[emDim],iFrame, j, nGab, nThreshold);
					// Glass狼 矫累瘤痢阑 茫酒辑 备炼眉俊 持绰促.
					pEdgeInfo->nGlassStartLine = iFrame * nFrameHeight + j - 2;
					pEdgeInfo->nGlassStartFrame = pEdgeInfo->nGlassStartLine/nFrameHeight;
					// Log
					g_pLog->DisplayMessage(_T(""));
					g_pLog->DisplayMessage(_T("%s Glass StartLine :: Pixel %ld nFrameNo=%d")
						, PANEL_SIDE[emDim]
					, pEdgeInfo->nGlassStartLine
						, pEdgeInfo->nGlassStartLine / nFrameHeight);

					delete [] pnSum;		

					SaveGlassLineImage(stFrame.nScanIdx,pEdgeInfo->nGlassStartLine,pEdgeInfo->nGlassEdgeXPos[0],emDim,_T("StartLine"));

					return TRUE;
				}
			}
		}
	}

	delete [] pnSum;
	return FALSE;
}

int	CInspectCamera::GetDefectCount()
{
	if(m_pDefectControl == NULL)
		return 0;

	return m_pDefectControl->GetDefectCount();
}

CDefect *CInspectCamera::GetDefect(int iDefect)
{
	if(m_pDefectControl == NULL)
		return NULL;

	return m_pDefectControl->GetDefect(iDefect);
}