#include "StdAfx.h"
#include "NotchCut.h"
#include "SISMatch.h"
#include <math.h>
#include <algorithm>
#include "EdgeFind.h"
#include "EdgeProc.h"

#define	M_PI					acos(-1.0)
#define M_RADIAN(x)				(((M_PI)*(x))/180.0)
//#define		SAVE_NOTCH_DEBUG_IMAGE

#define DETECT_BROKEN_COUNT		5
#define DETECT_WHITE_CONTI_COUNT 3
#define DETECT_CHIP_MULTI_RATIO 1.1

CNotchCut::CNotchCut(void)
{
	m_nDefectCount = 0;
	m_strSavePath = "";
	m_bSaveDebug = FALSE;
}

CNotchCut::~CNotchCut(void)
{

}

void CNotchCut::Reset()
{
	m_InsParm.Reset();	
	for(int i=0; i<MAX_NOTCH_SCAN_COUNT; i++)
	{
		m_MasterParm[i].Reset();
		m_AlignMasterParm[i].Reset();
	}
	m_ObjectInfo.Reset();
	ResetData();
}

BOOL CNotchCut::CopyModelData(CNotchCut *pNotch)
{
	if(pNotch == NULL)
		return FALSE;

	int		iDim;
	std::multimap<int, CPoint>::iterator	it;
	CPoint	pointData,pointMove;

	for (iDim=0; iDim<MAX_NOTCH_SCAN_COUNT; iDim++)
	{
		m_mapOrgMaster[iDim].clear();
		m_mapAlignMaster[iDim].clear();

		for(it=pNotch->m_mapOrgMaster[iDim].begin();it!=pNotch->m_mapOrgMaster[iDim].end();it++)
		{
			pointData = static_cast<CPoint>(it->second);
			m_mapOrgMaster[iDim].insert(std::make_pair(pointData.y, pointData));
		}
		
		if(pNotch->m_MasterParm[iDim].imgBuf.IsValidBuffer() == TRUE && pNotch->m_MasterParm[iDim].bLoad == TRUE)
		{
			m_MasterParm[iDim].imgBuf.SetSize(pNotch->m_MasterParm[iDim].imgBuf.GetDataWidth(),pNotch->m_MasterParm[iDim].imgBuf.GetHeight());
			CopyMemory(m_MasterParm[iDim].imgBuf.GetDataAddress(),pNotch->m_MasterParm[iDim].imgBuf.GetDataAddress(),sizeof(BYTE)*pNotch->m_MasterParm[iDim].imgBuf.GetDataSize());

			m_MasterParm[iDim].bLoad = pNotch->m_MasterParm[iDim].bLoad;
			m_MasterParm[iDim].nPosX = pNotch->m_MasterParm[iDim].nPosX;
			m_MasterParm[iDim].nPosY = pNotch->m_MasterParm[iDim].nPosY;			
		}
	}

	return TRUE;
}

BOOL CNotchCut::AdjustTilt(int index,double dTheta,double baseCenY)
{	
	if(index < 0 || index >= MAX_NOTCH_SCAN_COUNT || (int)m_mapOrgMaster[index].size() <= 0 || (int)m_mapOrgMaster_InsPos[index].size() <= 0)//20140528
		return FALSE;

	m_mapAlignMaster[index].clear();
	m_mapAlignMaster_InsPos[index].clear();//20140528

	int		nStartY = (int)((double)baseCenY/m_InsParm.dCamRes-(double)(m_MasterParm[index].nPosY));
	std::multimap<int, CPoint>::iterator	it;
	CPoint	pointData,pointMove,pointMax;	
		
	pointMax = CPoint(0,0);
	for(it=m_mapOrgMaster[index].begin();it!=m_mapOrgMaster[index].end();it++)
	{
		pointData = static_cast<CPoint>(it->second);

		pointMove.x = static_cast<int>(static_cast<double>(pointData.x-m_MasterParm[index].nPosX) * cos(dTheta) - static_cast<double>(pointData.y+nStartY) * sin(dTheta));
		pointMove.y = static_cast<int>(static_cast<double>(pointData.y+nStartY) * cos(dTheta) + static_cast<double>(pointData.x-m_MasterParm[index].nPosX) * sin(dTheta));

		pointMove.Offset(m_MasterParm[index].nPosX,-nStartY);
		m_mapAlignMaster[index].insert(std::make_pair(pointMove.y, pointMove));

		if(pointMax.x < pointMove.x)
			pointMax.x = pointMove.x;
		if(pointMax.y < pointMove.y)
			pointMax.y = pointMove.y;
	}

	for(it=m_mapOrgMaster_InsPos[index].begin();it!=m_mapOrgMaster_InsPos[index].end();it++)//20140528
	{
		pointData = static_cast<CPoint>(it->second);

		pointMove.x = static_cast<int>(static_cast<double>(pointData.x-m_MasterParm[index].nPosX) * cos(dTheta) - static_cast<double>(pointData.y+nStartY) * sin(dTheta));
		pointMove.y = static_cast<int>(static_cast<double>(pointData.y+nStartY) * cos(dTheta) + static_cast<double>(pointData.x-m_MasterParm[index].nPosX) * sin(dTheta));

		pointMove.Offset(m_MasterParm[index].nPosX,-nStartY);
		m_mapAlignMaster_InsPos[index].insert(std::make_pair(pointMove.y, pointMove));
	}

	if(m_bSaveDebug == TRUE)
	{
		COwnerBuffer		imgBuf(pointMax.x*2,pointMax.y*2);
		ZeroMemory(imgBuf.GetDataAddress(),sizeof(BYTE)*imgBuf.GetDataSize());
		for(it=m_mapAlignMaster[index].begin();it!=m_mapAlignMaster[index].end();it++)
		{
			pointData = static_cast<CPoint>(it->second);
			if(pointData.x < 0 || pointData.y < 0 || pointData.x >= imgBuf.GetWidth() || pointData.y >= imgBuf.GetHeight())
				continue;

			imgBuf.SetPixel(pointData.x,pointData.y,255);
		}

		for(it=m_mapAlignMaster_InsPos[index].begin();it!=m_mapAlignMaster_InsPos[index].end();it++)//20140528
		{
			pointData = static_cast<CPoint>(it->second);
			if(pointData.x < 0 || pointData.y < 0 || pointData.x >= imgBuf.GetWidth() || pointData.y >= imgBuf.GetHeight())
				continue;

			imgBuf.SetPixel(pointData.x,pointData.y,128);
		}

		{
			CString		str;
			str.Format(_T("D:\\Image\\TiltAlign.bmp"),m_strSavePath);//20140528
			CBufferAttach	attach(str);
			attach.AttachToFile(imgBuf);
		}
	}

	m_AlignMasterParm[index].nPosX = static_cast<int>(static_cast<double>(m_MasterParm[index].nPosX) * cos(dTheta) - static_cast<double>(m_MasterParm[index].nPosY+nStartY) * sin(dTheta));
	m_AlignMasterParm[index].nMaxX = static_cast<int>(static_cast<double>(m_MasterParm[index].nMaxX) * cos(dTheta) - static_cast<double>(m_MasterParm[index].nPosY+nStartY) * sin(dTheta));
	m_AlignMasterParm[index].nPosY = static_cast<int>(static_cast<double>(m_MasterParm[index].nPosY+nStartY) * cos(dTheta) + static_cast<double>(m_MasterParm[index].nPosX) * sin(dTheta));
	m_AlignMasterParm[index].nPosY -= nStartY;
	m_AlignMasterParm[index].nMaxY = m_AlignMasterParm[index].nPosY;		

	return TRUE;
}

BOOL CNotchCut::LoadData(CString strFile)
{
	BOOL			bLoad = FALSE;
	CString			str;
	CSISImageBuffer	imgFile;

	for (int i=0; i<MAX_NOTCH_SCAN_COUNT; i++)
	{	
		str.Format(_T("%s_[%d].notch"),strFile,i);
		bLoad |= ReadModelData(str,i);

		str.Format(_T("%s_[%d]_notch.bmp"),strFile,i);
		if(imgFile.ReadFromFile(str) == TRUE)
		{
			m_MasterParm[i].bLoad = TRUE;
			m_MasterParm[i].imgBuf.SetSize(imgFile.GetDataWidth(),imgFile.GetHeight());
			CopyMemory(m_MasterParm[i].imgBuf.GetDataAddress(),imgFile.GetDataAddress(),sizeof(BYTE)*imgFile.GetDataSize());
			imgFile.ReleaseImage();
		}		
		if(m_MasterParm[i].bLoad == TRUE)
		{
			FindCenterPos(m_MasterParm[i].imgBuf,m_MasterParm[i].nPosX,m_MasterParm[i].nPosY);
		}
	}

	return bLoad;
}

void CNotchCut::FindRealPos(CSISBuffer &pOrg,CSISBuffer &pBin,int iLeftLine,int &nCenX,int &nCenY
							,int *nStartX,int *nFisrtY,int *nLastY,int iCam,int iDem,int nSkipSize)
{
	if(pBin.IsValidBuffer() == FALSE || pOrg.IsValidBuffer() == FALSE)
		return;

#define DEFECT_EDGE_AUTO_RATIO 0.3
#define DEFECT_EDGE_AUTO_PITCH 15
#define DEFECT_EDGE_CONTINUE 3
#define DETECT_EDGE_HEIGHT 10

	CEdgeFind		EdgeFind;
	CRect		rect;
	int			nCalSize = 50;
	const int	nSkipLeft = 40;
	const int	nVMargin = 10;
	int			nLeftLine[2],nMaxLeft;
	int			iStartU = iLeftLine-nSkipLeft;

	if(iStartU < 0)
		iStartU = 0;


	rect = CRect(iStartU,nVMargin,pBin.GetWidth(),nCalSize+nVMargin);//+nSkipSizeÃß°¡
	nLeftLine[0] = FindLeftLineReal(pBin,rect,0);//50°³ÀÇ Left °ª Æò±Õ(10~60)
	
	rect = CRect(iStartU,pBin.GetHeight()-nCalSize-nVMargin,pBin.GetWidth(),pBin.GetHeight()-nVMargin);//50°³ÀÇ Left °ª Æò±Õ(pImg.GetHeight()-60~pImg.GetHeight()-10)
	nLeftLine[1] = FindLeftLineReal(pBin,rect,0);

	nMaxLeft = max(nLeftLine[0],nLeftLine[1]);
//	nCenX = min(nLeftLine[0],nLeftLine[1]);

	rect = CRect(nMaxLeft+nSkipSize,0,pBin.GetWidth()-1,pBin.GetHeight());
	FindRealAccumXY(pBin,rect,255,nStartX,nFisrtY,nLastY);	
	nCenY = (int)FindRealAccumYPos(pBin,nSkipSize,255,nLeftLine);	
	if(nCenY <= 0)
		return;

	rect = CRect(nMaxLeft+nSkipSize,nCenY-DETECT_EDGE_HEIGHT,pOrg.GetWidth()-1,nCenY+DETECT_EDGE_HEIGHT);
	CCropBuffer		cropBuf(pOrg,rect);	

	int nRelLeft = EdgeFind.Find_LeftEdge(&cropBuf,DEFECT_EDGE_AUTO_PITCH,m_InsParm.nEdgeThres,DEFECT_EDGE_AUTO_RATIO,DEFECT_EDGE_CONTINUE);
	if(nRelLeft > 0)
		nCenX = nRelLeft+rect.left;
	
	if(m_bSaveDebug == TRUE)
	{	
		CString		strImg;
		strImg.Format(_T("%s\\[%d,%d]EdgeCrop_%d_%d_[%d,%d]_s[%d]_[%d,%d].bmp"),m_strSavePath,iCam,iDem,nMaxLeft+nSkipSize,nCenY,nRelLeft,nCenX,nSkipSize,nLeftLine[0],nLeftLine[1]);
		CBufferAttach	attach(strImg);
		attach.AttachToFile(cropBuf);
	}

	//MakeFoldImage(pBin,nCenY);
}

void CNotchCut::FindCenterPos(CSISBuffer &pImg,int &nPosX,int &nPosY,int nSkipSize)
{
	if(pImg.IsValidBuffer() == FALSE)
		return;

	CRect		rect;
	int			nCalSize = 50;
	const int	nSkipLeft = 40;
	int			nLeftLine[2],nMaxLeft;

	rect = CRect(0,nSkipSize,pImg.GetWidth(),nCalSize);
	nLeftLine[0] = FindLeftLine(pImg,rect,255);

	rect = CRect(0,pImg.GetHeight()-nCalSize-nSkipSize,pImg.GetWidth(),pImg.GetHeight()-nSkipSize);
	nLeftLine[1] = FindLeftLine(pImg,rect,255);

	nMaxLeft = max(nLeftLine[0],nLeftLine[1]);
	nPosX = nLeftLine[0];

	rect = CRect(nMaxLeft+nSkipLeft,0,pImg.GetWidth()-1,pImg.GetHeight());
	nPosY = FindAccumYPos(pImg,rect,255);	

	//	MakeFoldImage(pImg,nPosY);
}

void CNotchCut::MakeFoldImage(CSISBuffer &pImg,int nPosY)
{
	if(nPosY <= 0)
		return;

	COwnerBuffer		pFoldImg(pImg.GetWidth(),nPosY+1);
	ZeroMemory(pFoldImg.GetDataAddress(0,0),pFoldImg.GetDataSize());

	int			u,v,vPos;	

	for(v=0;v<=nPosY;v++)
	{
		CopyMemory(pFoldImg.GetDataAddress(0,v),pImg.GetDataAddress(0,v),sizeof(BYTE)*pImg.GetWidth());
	}

	CRect		rect;

	vPos = nPosY+1;
	for(v=nPosY-1;v>=0;v--,vPos++)
	{
		if(pImg.GetHeight() <= vPos)
			break;

		for(u=0;u<pImg.GetWidth();u++)
		{
			if(*pImg.GetDataAddress(u,vPos) == 0 && *pImg.GetDataAddress(u,v) == 0)
			{
				pFoldImg.SetPixel(u,v,180);
			}		
			else if(*pImg.GetDataAddress(u,v) == 0 && *pImg.GetDataAddress(u,vPos) != 0)
				pFoldImg.SetPixel(u,v,0);
			else
				pFoldImg.SetPixel(u,v,80);
		}
	}

	CString		str;
	str = "D:\\Image\\NotchCut\\FoldImg.bmp";
	CBufferAttach	attach(str);
	attach.AttachToFile(pFoldImg);

}

void CNotchCut::FindYPosPixel(CSISBuffer &pImg,CRect rect,std::vector<int> *vList,int nThres,int u,BOOL bDir)
{
	int			v;

	vList->clear();
	for(v=rect.top;v<rect.bottom;v++)
	{
		if(bDir == TRUE)
		{
			if(*pImg.GetDataAddress(u,v) >= nThres)
			{
				vList->push_back(v);
			}
		}
		else
		{
			if(*pImg.GetDataAddress(u,v) <= nThres)
			{
				vList->push_back(v);
			}
		}
	}
}

void CNotchCut::FindYPosMerge(std::vector<int> *vList,std::vector<NOTCH_Merge_STU> *vMergeList)
{
	NOTCH_Merge_STU	stuMerge,stuMax;
	std::vector<int>::iterator it;

	vMergeList->clear();
	stuMerge.Reset();
	stuMax.Reset();
	for(it=vList->begin();it!=vList->end();it++)
	{
		if(stuMerge.nStart == -1)
			stuMerge.nStart = *it;
		else
		{				
			if(stuMerge.nEnd == -1)
			{
				if(abs(stuMerge.nStart - *it) > 1)
				{
					stuMerge.nEnd = *it;					
					stuMerge.nSize = abs(stuMerge.nEnd-stuMerge.nStart)+1;

					if(stuMax.nSize < stuMerge.nSize)
						stuMax = stuMerge;

					stuMerge.Reset();					
				}
				else
					stuMerge.nStart = *it;
			}
		}
	}

	vMergeList->push_back(stuMax);
}

void CNotchCut::FindRealYPosMerge(std::vector<int> *vList,std::vector<NOTCH_Merge_STU> *vMergeList)
{
	NOTCH_Merge_STU	stuMerge;
	std::vector<int>::iterator it;

	vMergeList->clear();
	stuMerge.Reset();
	for(it=vList->begin();it!=vList->end();it++)
	{
		if(stuMerge.nStart == -1)
			stuMerge.nStart = *it;
		else
		{				
			if(stuMerge.nEnd == -1)
			{
				if(abs(stuMerge.nStart - *it) > 1)
				{
					stuMerge.nEnd = stuMerge.nStart;
					stuMerge.nSize = abs(stuMerge.nEnd-stuMerge.nStart)+1;
					vMergeList->push_back(stuMerge);
					stuMerge.Reset();
					stuMerge.nStart = *it;
				}
				else
					stuMerge.nEnd = *it;
			}
			else
			{
				if(abs(stuMerge.nEnd-*it) > 1)
				{
					stuMerge.nSize = abs(stuMerge.nEnd-stuMerge.nStart)+1;
					vMergeList->push_back(stuMerge);
					stuMerge.Reset();
					stuMerge.nStart = *it;
				}
				else
					stuMerge.nEnd = *it;
			}
		}
	}

	if(stuMerge.nStart != -1 && stuMerge.nEnd == -1)
	{
		stuMerge.nEnd = stuMerge.nStart;
		stuMerge.nSize = abs(stuMerge.nEnd-stuMerge.nStart)+1;
		vMergeList->push_back(stuMerge);
	}
	else if(stuMerge.nStart != -1 && stuMerge.nEnd != -1 )//&& (int)vMergeList->size() <= 0)//20140528
	{
		stuMerge.nSize = abs(stuMerge.nEnd-stuMerge.nStart)+1;
		vMergeList->push_back(stuMerge);
	}
}

/*
double CNotchCut::FindRealAccumYPos(CSISBuffer &pImg,CRect rect,int nThres,int *nStartX,int *nFirstY,int *nLastY)
{
	int			u;
	int			nYpos = 0,nCount = 0;
	const	int nDetCnt = 20;
	int			nNoDetCnt;	
	const int	nBreakCnt = 2;		

	std::vector<int> vList;		
	NOTCH_Merge_STU		stuMerge,stuMax;
	std::vector<NOTCH_Merge_STU> vMergeList;
	std::vector<NOTCH_Merge_STU>::iterator it;

	NOTCH_Circle_STU			*pPosList=NULL; 
	int						iIndex = 0;
	int						nVLineCnt = 0;

	*nStartX = *nFirstY = *nLastY = 0;	
	nNoDetCnt = 0;	

	nVLineCnt = rect.Width()+1;
	pPosList = new NOTCH_Circle_STU[nVLineCnt];
	ZeroMemory(pPosList,sizeof(NOTCH_Circle_STU)*nVLineCnt);

	for(u=rect.left;u<rect.right;u++)
	{			
		//FindYPosPixel(pImg,rect,&vList,nThres,u,FALSE);//ÀÌÁøÈ­µÈ ¿µ»ó¿¡¼­ ¹à±â°¡ 0ÀÎ ºÎºÐÀÇ YÁÂÇ¥¸¦ ã´Â´Ù
		FindYPosPixel(pImg,rect,&vList,nThres,u);

		FindRealYPosMerge(&vList,&vMergeList);		

		if((int)vMergeList.size() <= 0)
		{
			nNoDetCnt++;
			if(nNoDetCnt >= nBreakCnt)
				break;
		}
		else
		{
			stuMax.Reset();
			for(it=vMergeList.begin();it!=vMergeList.end();it++)
			{
				stuMerge = *it;

				if(stuMerge.nSize > stuMax.nSize)
				{
					stuMax = stuMerge;
				}
			}

			if(stuMax.nSize <= 100)
				continue;

			pPosList[iIndex].pointF = PointD(u,stuMerge.nStart);
			pPosList[iIndex].pointS = PointD(u,stuMerge.nEnd);
			iIndex++;

			if(*nFirstY <= 0 && *nLastY <= 0)
			{
				*nStartX = u;
				*nFirstY = stuMax.nStart;
				*nLastY = stuMax.nEnd;
			}
		}
	}

	if(iIndex <= 10)
	{
		delete[] pPosList, pPosList=NULL;
		return 0;
	}

	// ÃÑ 6Point¿¡ ´ëÇÑ ¿øÀÇ Á߽ɱ¸Çϱâ
	int			i;
	NOTCH_Circle_STU	nCenterPos[3],nLRPos[3];
	const int   nPointCnt = 6;
	PointD		pointCenter[nPointCnt];


	nCenterPos[0] = pPosList[iIndex-1];
	nCenterPos[1] = pPosList[iIndex-2];
	nCenterPos[2] = pPosList[iIndex-3];

	nLRPos[0] = pPosList[0];
	nLRPos[1] = pPosList[1];
	nLRPos[2] = pPosList[2];
	
	PointD		S,M,E;
	ZeroMemory(pointCenter,sizeof(PointD)*nPointCnt);

	int			iLoop = 0;
	for(i=0;i<3;i++)
	{
		S = nLRPos[0].pointF;
		M = nCenterPos[0].pointF;
		E = nLRPos[0].pointS;		
		pointCenter[iLoop] = GetCenterPointFrom3Points(S,M,E);
		TRACE("Center %d = %.3f,%.3f\n",iLoop,pointCenter[iLoop].X,pointCenter[iLoop].Y);
		iLoop++;
		
		M = nCenterPos[0].pointS;
		pointCenter[iLoop] = GetCenterPointFrom3Points(S,M,E);
		TRACE("Center %d = %.3f,%.3f\n",iLoop,pointCenter[iLoop].X,pointCenter[iLoop].Y);
		iLoop++;
	}

	double		dSum,dCount,dAvg,dStd;

	dAvg = dSum = dCount = 0.;
	for(iIndex=0;iIndex<nPointCnt;iIndex++)
	{		
		dSum += pointCenter[iIndex].Y;
		dCount++;
	}

	if(dCount > 0)
		dAvg = dSum/dCount;	

	dSum = dCount = 0.;
	for(iIndex=0;iIndex<nPointCnt;iIndex++)
	{
		dSum += pow((dAvg-pointCenter[iIndex].Y),2);	
		dCount++;				
	}

	dStd = dCount>0?sqrt(dSum/dCount):0.;

	dSum = dCount = 0.;
	for(iIndex=0;iIndex<nPointCnt;iIndex++)
	{			
		if(fabs(pointCenter[iIndex].Y-dAvg) > dStd)
			continue;

		dSum+=pointCenter[iIndex].Y;
		dCount++;
	}

	if(dCount > 0)
		dAvg = dSum/dCount;	
	
	delete[] pPosList, pPosList=NULL;

	return dAvg;
}
*/

PointD CNotchCut::GetCenterPointFrom3Points(const PointD& S, const PointD& M, const PointD& E)
{
	double ma = (M.Y - S.Y) / (M.X - S.X);
	double mb = (E.Y - M.Y) / (E.X - M.X);

	if (ma >= INT_MAX || ma <= INT_MIN)    
		ma = 1000000000000;

	if (mb >= INT_MAX || mb <= INT_MIN)    
		mb = 1000000000000;

	if (ma == 0)
		ma = 0.000000000001;

	if (mb == 0)
		mb = 0.000000000001;

	double centerX = (ma * mb * (S.Y - E.Y) + mb * (S.X + M.X) - ma * (M.X + E.X)) / (2 * (mb - ma));
	double centerY = (-1 * (centerX - (S.X + M.X) / 2) / ma) + ((S.Y + M.Y) / 2);

	return PointD(centerX, centerY);            
}

double CNotchCut::FindRealCenter(CSISBuffer &pImg,CRect rect,int nThres,int *nStartX,int *nFirstY,int *nLastY)
{
	int			u;
	int			nYpos = 0,nCount = 0;
	const	int nDetCnt = 20;
	int			nNoDetCnt;	
	const int	nBreakCnt = 2;		
	double		*dVLine = NULL;
	int			iIndex = 0,nVLineCnt;

	std::vector<int> vList;		
	NOTCH_Merge_STU		stuMerge,stuMax;
	std::vector<NOTCH_Merge_STU> vMergeList;
	std::vector<NOTCH_Merge_STU>::iterator it;

	*nStartX = *nFirstY = *nLastY = 0;	
	nNoDetCnt = 0;

	nVLineCnt = rect.Width()+1;
	dVLine = new double[nVLineCnt];
	ZeroMemory(dVLine,sizeof(double)*nVLineCnt);

	for(u=rect.left;u<rect.right;u++,iIndex++)
	{			
		//FindYPosPixel(pImg,rect,&vList,nThres,u,FALSE);//ÀÌÁøÈ­µÈ ¿µ»ó¿¡¼­ ¹à±â°¡ 0ÀÎ ºÎºÐÀÇ YÁÂÇ¥¸¦ ã´Â´Ù
		FindYPosPixel(pImg,rect,&vList,nThres,u);

		FindRealYPosMerge(&vList,&vMergeList);		

		if((int)vMergeList.size() <= 0)
		{
			nNoDetCnt++;
			if(nNoDetCnt >= nBreakCnt)
				break;
		}
		else
		{
			stuMax.Reset();
			for(it=vMergeList.begin();it!=vMergeList.end();it++)
			{
				stuMerge = *it;

				if(stuMerge.nSize > stuMax.nSize)
				{
					stuMax = stuMerge;
				}
			}

			if(stuMax.nSize <= 50)
				continue;

			nYpos = nCount = 0;			
			for(int i=stuMax.nStart;i<=stuMax.nEnd;i++)
			{
				nYpos += i;
				nCount++;
			}	

			if(nCount > 0)
			{
				if(iIndex < nVLineCnt)
				{
					dVLine[iIndex] = (double)nYpos/(double)nCount;		
					TRACE("VLine : index %d, VLine %.2f\n",iIndex,dVLine[iIndex]);
				}
			}

			if(*nFirstY <= 0 && *nLastY <= 0)
			{
				*nStartX = u;
				*nFirstY = stuMax.nStart;
				*nLastY = stuMax.nEnd;
			}
		}
	}

	double		dSum,dCount,dAvg,dStd;

	dAvg = dSum = dCount = 0.;
	for(iIndex=0;iIndex<nVLineCnt;iIndex++)
	{
		if(dVLine[iIndex] <= 0)
			continue;
		dSum += dVLine[iIndex];
		dCount++;
	}

	if(dCount > 0)
		dAvg = dSum/dCount;	

	dSum = dCount = 0.;
	for(iIndex=0;iIndex<nVLineCnt;iIndex++)
	{
		if(dVLine[iIndex] <= 0)
			continue;

		dSum += pow((dAvg-dVLine[iIndex]),2);	
		dCount++;				
	}

	dStd = dCount>0?sqrt(dSum/dCount):0.;

	dSum = dCount = 0.;
	for(iIndex=0;iIndex<nVLineCnt;iIndex++)
	{		
		if(dVLine[iIndex] <= 0)
			continue;

		if(fabs(dVLine[iIndex]-dAvg) > dStd)
			continue;

		dSum+=dVLine[iIndex];
		dCount++;
	}

	if(dCount > 0)
		dAvg = dSum/dCount;

	delete[] dVLine, dVLine=NULL;

	return dAvg;
}

void CNotchCut::FindRealAccumXY(CSISBuffer &pImg,CRect rect,int nThres,int *nStartX,int *nFirstY,int *nLastY)
{
	int			u;
	std::vector<int> vList;		
	NOTCH_Merge_STU		stuMerge,stuMax;
	std::vector<NOTCH_Merge_STU> vMergeList;
	std::vector<NOTCH_Merge_STU>::iterator it;

	*nStartX = *nFirstY = *nLastY = 0;	
	
	for(u=rect.left;u<rect.right;u++)
	{			
		//FindYPosPixel(pImg,rect,&vList,nThres,u,FALSE);//ÀÌÁøÈ­µÈ ¿µ»ó¿¡¼­ ¹à±â°¡ 0ÀÎ ºÎºÐÀÇ YÁÂÇ¥¸¦ ã´Â´Ù
		FindYPosPixel(pImg,rect,&vList,nThres,u);

		FindRealYPosMerge(&vList,&vMergeList);		

		if((int)vMergeList.size() <= 0)
		{
			continue;
		}
		else
		{
			stuMax.Reset();
			for(it=vMergeList.begin();it!=vMergeList.end();it++)
			{
				stuMerge = *it;

				if(stuMerge.nSize > stuMax.nSize)
				{
					stuMax = stuMerge;
				}
			}

			if(stuMax.nSize <= 100)
				continue;		
			
			*nStartX = u;
			*nFirstY = stuMax.nStart;
			*nLastY = stuMax.nEnd;
			break;			
		}
	}	
}

double CNotchCut::FindRealAccumYPos(CSISBuffer &pImg,int nSkipSize,int nThres,int *iLeftLine)
{
	if(iLeftLine[0] <= 0 || iLeftLine[1] <= 0)
		return 0.;

	int			u;
	int			nYpos = 0,nCount = 0;
	const	int nDetCnt = 20;
	int			nNoDetCnt;	
	const int	nBreakCnt = 4;		
	double		*dVLine = NULL;
	int			iIndex = 0,nVLineCnt;
	int			nMinLeft = min(iLeftLine[0],iLeftLine[1]);
	int			nLoopCnt = 100;
	int			iUp,iDw;
	CRect		rect;
	const int	nSIZE_FILTER= 50;

	std::vector<int>	vUpList,vDwList;		
	NOTCH_Merge_STU		stuMerge,stuUpMax,stuDwMax;
	std::vector<NOTCH_Merge_STU> vUpMergeList,vDwMergeList;
	std::vector<NOTCH_Merge_STU>::iterator it;
	
	nNoDetCnt = 0;
	
	nVLineCnt = nLoopCnt+1;
	dVLine = new double[nVLineCnt];
	ZeroMemory(dVLine,sizeof(double)*nVLineCnt);

	iUp = iLeftLine[0]+nSkipSize;
	iDw = iLeftLine[1]+nSkipSize;

	rect = CRect(0,0,0,pImg.GetHeight());

	for(u=0;u<nLoopCnt;u++,iIndex++,iUp++,iDw++)
	{	
		if(nNoDetCnt >= nBreakCnt)
			break;

		FindYPosPixel(pImg,rect,&vUpList,nThres,iUp);
		FindRealYPosMerge(&vUpList,&vUpMergeList);		

		if((int)vUpMergeList.size() <= 0)
		{
			nNoDetCnt++;
				continue;
		}

		stuUpMax.Reset();
		for(it=vUpMergeList.begin();it!=vUpMergeList.end();it++)
		{
			stuMerge = *it;
			if(stuMerge.nSize > stuUpMax.nSize)	
				stuUpMax = stuMerge;	
		}
		if(stuUpMax.nSize <= nSIZE_FILTER)
			{
			nNoDetCnt++;
			continue;
			}	

		FindYPosPixel(pImg,rect,&vDwList,nThres,iDw);
		FindRealYPosMerge(&vDwList,&vDwMergeList);		

		if((int)vDwMergeList.size() <= 0)
			{
			nNoDetCnt++;
			continue;
		}	
		
		stuDwMax.Reset();
		for(it=vDwMergeList.begin();it!=vDwMergeList.end();it++)
				{
			stuMerge = *it;
			if(stuMerge.nSize > stuDwMax.nSize)	
				stuDwMax = stuMerge;	
				}
		if(stuDwMax.nSize <= nSIZE_FILTER)
		{
			nNoDetCnt++;
			continue;
			}

		if(stuUpMax.nStart >= stuDwMax.nEnd)
			{
			nNoDetCnt++;
			continue;
			}

		nYpos = nCount = 0;
		for(int i=stuUpMax.nStart;i<=stuDwMax.nEnd;i++)
		{
			nYpos += i;
			nCount++;
		}

		if(nCount > 0)
			dVLine[iIndex] = ((double)nYpos/(double)nCount)+1;
		TRACE("VLine : index %d, VLine Up[%d],Dw[%d] %.2f\n",iIndex,iUp,iDw,dVLine[iIndex]);	
	}

	double		dSum,dCount,dAvg,dStd;

	dAvg = dSum = dCount = 0.;
	for(iIndex=0;iIndex<nVLineCnt;iIndex++)
	{
		if(dVLine[iIndex] <= 0)
			continue;
		dSum += dVLine[iIndex];
		dCount++;
	}

	if(dCount > 0)
		dAvg = dSum/dCount;	

	dSum = dCount = 0.;
	for(iIndex=0;iIndex<nVLineCnt;iIndex++)
	{
		if(dVLine[iIndex] <= 0)
			continue;

		dSum += pow((dAvg-dVLine[iIndex]),2);	
		dCount++;				
	}

	dStd = dCount>0?sqrt(dSum/dCount):0.;

	dSum = dCount = 0.;
	for(iIndex=0;iIndex<nVLineCnt;iIndex++)
	{		
		if(dVLine[iIndex] <= 0)
			continue;

		if(fabs(dVLine[iIndex]-dAvg) > dStd)
			continue;
		
		dSum+=dVLine[iIndex];
		dCount++;
	}

	if(dCount > 0)
		dAvg = (dSum/dCount)+0.5;

	delete[] dVLine, dVLine=NULL;

	return dAvg;
}


int CNotchCut::FindAccumYPos(CSISBuffer &pImg,CRect rect,int nThres)
{
	int			u;
	int			nYpos = 0,nCount = 0;
	int			nNoDetCnt;	
	const int	nBreakCnt = 5;		

	std::vector<int> vList;		
	std::vector<NOTCH_Merge_STU> vMergeList;
	NOTCH_Merge_STU		stuMerge,stuMax;
	std::vector<NOTCH_Merge_STU>::iterator it;	

	nNoDetCnt = 0;
	for(u=rect.left;u<rect.right;u++)
	{			
		FindYPosPixel(pImg,rect,&vList,nThres,u);

		FindYPosMerge(&vList,&vMergeList);		

		if((int)vMergeList.size() <= 0)
		{
			nNoDetCnt++;
			if(nNoDetCnt >= nBreakCnt)
				break;
		}
		else
		{
			stuMax.Reset();
			for(it=vMergeList.begin();it!=vMergeList.end();it++)
			{
				stuMerge = *it;

				if(stuMerge.nSize > stuMax.nSize)
				{
					stuMax = stuMerge;
				}
			}

			if(stuMax.nSize <= 0)
				continue;

			for(int i=stuMax.nStart;i<=stuMax.nEnd;i++)
			{
				nYpos += i;
				nCount++;
			}	
		}
	}

	return nCount>0?nYpos/nCount:-1;
}

int	 CNotchCut::FindLeftLine(CSISBuffer &pImg,CRect rect,int nThres)
{
	int			u,v;
	int			nLeft = 0,nCount = 0;

	for(v=rect.top;v<rect.bottom;v++)
	{
		for(u=rect.left;u<rect.right;u++)
		{
			if(*pImg.GetDataAddress(u,v) >= nThres)
			{
				nLeft += u;
				nCount++;
				break;
			}
		}
	}

	return nCount>0?nLeft/nCount:-1;
}

int	 CNotchCut::FindLeftLineReal(CSISBuffer &pImg,CRect rect,int nThres)
{
	int			u,v;
	int			nLeft = 0,nCount = 0;

	for(v=rect.top;v<rect.bottom;v++)
	{
		for(u=rect.left;u<rect.right;u++)
		{
			if(*pImg.GetDataAddress(u,v) <= nThres)
			{
				nLeft += u;
				nCount++;
				break;
			}
		}
	}

	return nCount>0?nLeft/nCount:-1;
}

void CNotchCut::SetParm(NOTCH_Parm_STU &parm)
{
	m_InsParm = parm;
}

void CNotchCut::AssertRect(CRect &rect,CSISBuffer pOrg)
{
	if(rect.left < 0) rect.left = 0;
	if(rect.top < 0) rect.top = 0;
	if(rect.right < 0) rect.right = 0;
	if(rect.bottom < 0) rect.bottom = 0;

	if(rect.left > rect.right) std::swap(rect.left,rect.right);
	if(rect.top > rect.bottom) std::swap(rect.top,rect.bottom);
}

void CNotchCut::ResetData()
{
	m_mapMaster.clear();
	m_mapMaster_InsPos.clear();//20140528
	m_mapChipData.clear();
	m_nDefectCount = 0;
	m_bSaveDebug = FALSE;
	m_nNoDetCount = m_nTotalCount = 0;
}

int CNotchCut::NotchExecute(CSISBuffer &pOrg,double *dResult,double *dResult_Dy,pNOTCH_RangePos_STU pRangeRes,pNOTCH_RangePos_STU pRangeRes_Dy,pNOTCH_RangePos_STU pRangeRes_Cham, int nRangeCnt,COwnerBuffer &pRes,COwnerBuffer &pRes_Dy, COwnerBuffer &pRes_Cham, double *dAvgThick, int iDimension
							, double *dFeedbackXY, int icam,double *dGlassXY,double dAlign2GlassX,int iLeftLine,BOOL bSaveDebug,CString strSavePath, double dTheta)//20140528
{
	ResetData();

	m_bSaveDebug = bSaveDebug;
	ZeroMemory(pRangeRes,sizeof(NOTCH_RangePos_STU)*nRangeCnt);
	ZeroMemory(pRangeRes_Dy,sizeof(NOTCH_RangePos_STU)*nRangeCnt);
	ZeroMemory(pRangeRes_Cham,sizeof(NOTCH_RangePos_STU)*nRangeCnt);//20140528
	ZeroMemory(dResult,sizeof(double)*2);
	ZeroMemory(dResult_Dy,sizeof(double)*2);
	ZeroMemory(dFeedbackXY,sizeof(double)*2);
	ZeroMemory(dGlassXY,sizeof(double)*2);
	*dAvgThick = 0.;


	if(m_InsParm.bChipIns == FALSE && m_InsParm.bSizeIns == FALSE)
		return NORMAL_EXE;

	if(pOrg.IsValidBuffer() == FALSE)
		return ERR_NO_ORGIMG;

	int			nErrCode = NORMAL_EXE;	
	CRect		rectOrg;

	if(m_bSaveDebug == TRUE)
	{
		m_strSavePath.Format(_T("%s\\NotchCut"),strSavePath);
		CString		str;	
		CreateDirectory(m_strSavePath,NULL);
		str.Format(_T("%s\\1.Notch_Org_%d_%d.bmp"),m_strSavePath,icam,iDimension);
		CBufferAttach	attach(str);
		attach.AttachToFile(pOrg);
	}

	
	CRect			rectEdge;	
	CEdgeProc		EdgeProc;
//	CEdgeFind		EdgeFind;

// #define DEFECT_EDGE_AUTO_RATIO 0.3
// #define DEFECT_EDGE_AUTO_PITCH 15
// #define DEFECT_EDGE_CONTINUE 3
// 	rectEdge = CRect(0,0,pOrg.GetWidth(),100);
// 	CSISBuffer	EdgeBuf(pOrg.GetDataAddress(),pOrg.GetDataWidth(),100);
// 	//m_ObjectInfo.nEdgeTop = (int)EdgeFind.FindGlassHorizontalLine(pOrg.GetDataAddress(0,0),CSize(pOrg.GetDataWidth(),pOrg.GetHeight()),rectEdge,m_InsParm.nEdgeThres,TRUE);
// 	m_ObjectInfo.nEdgeTop = EdgeFind.Find_LeftEdge(&EdgeBuf,DEFECT_EDGE_AUTO_PITCH,m_InsParm.nEdgeThres,DEFECT_EDGE_AUTO_RATIO,DEFECT_EDGE_CONTINUE);

	//	rectEdge = CRect(0,pOrg.GetHeight()-100,pOrg.GetWidth(),pOrg.GetHeight());
	//	m_ObjectInfo.nEdgeBot = (int)m_EdgeFind.FindGlassHorizontalLine(pOrg.GetDataAddress(0,0),CSize(pOrg.GetDataWidth(),pOrg.GetHeight()),rectEdge,m_InsParm.nEdgeThres,TRUE);

	COwnerBuffer		pBinImg(pOrg.GetWidth(),pOrg.GetHeight());	
	ZeroMemory(pBinImg.GetDataAddress(0,0),pBinImg.GetDataSize());

	rectEdge = CRect(10,pOrg.GetHeight()/2-20,52,pOrg.GetHeight()/2+20);
	CChamferInspect		ChamferIns;

	int		nBlankThres = (int)(ChamferIns.GetAreaAVG(pOrg.GetDataAddress(),CRect(0,0,pOrg.GetDataWidth(),pOrg.GetHeight()),rectEdge));

	m_InsParm.nDetThres = (int)((double)nBlankThres * 1.4);

	if(m_InsParm.dBlank2EdgeRatio <= 0)
		m_InsParm.dBlank2EdgeRatio = 0.8;
	m_InsParm.nSizeThres = (int)((double)nBlankThres * m_InsParm.dBlank2EdgeRatio);
	//	EdgeFind.Adaptive_Binarization(pOrg.GetDataAddress(0,0),pOrg.GetWidth(),pOrg.GetHeight(),pOrg.GetDataWidth(),20,0.2,pBinImg.GetDataAddress(0,0),rectEdge);

	rectEdge = CRect(0,0,pOrg.GetDataWidth(),pOrg.GetHeight());
	CSISBuffer::CopyBtoA(pBinImg,0,0,pOrg,rectEdge);
	EdgeProc.ThresholdProcessing(pBinImg.GetDataAddress(0,0),CSize(pBinImg.GetDataWidth(),pBinImg.GetHeight()),m_InsParm.nDetThres,0);

	if(m_bSaveDebug == TRUE)
	{
		CString		str;	
		str.Format(_T("%s\\2.Notch_Bin_%d_%d_[%d].bmp"),m_strSavePath,icam,iDimension,m_InsParm.nDetThres);
		CBufferAttach	attach(str);
		attach.AttachToFile(pBinImg);
	}

	COwnerBuffer		pBin(pOrg.GetWidth(),pOrg.GetHeight());

	CopyMemory(pBin.GetDataAddress(0,0),pOrg.GetDataAddress(0,0),pOrg.GetDataSize());
	EdgeProc.ThresholdProcessing(pBin.GetDataAddress(0,0),CSize(pBin.GetDataWidth(),pBin.GetHeight()),m_InsParm.nSizeThres,0);

	if(m_bSaveDebug == TRUE)
	{
		CString		str;	
		str.Format(_T("%s\\3.Notch_Ins_Bin_%d_%d.bmp"),m_strSavePath,icam,iDimension);
		CBufferAttach	attach(str);
		attach.AttachToFile(pBin);
	}	

	int			nCenX,nCenY;
	int			nStartX,nFirstY,nLastY;

	nCenX = nCenY = 0;	

	FindRealPos(pOrg,pBinImg,iLeftLine,nCenX,nCenY,&nStartX,&nFirstY,&nLastY,icam,iDimension
		,(int)((double)m_InsParm.nSkipSize/m_InsParm.dCamRes));

//	nCenX = (int)dAlign2GlassX;//m_ObjectInfo.nEdgeTop;

	MakeReal2AlignCad(pOrg,nCenY,(int)dAlign2GlassX,iDimension,icam);	

	if(m_InsParm.bChipIns == TRUE)
	{
		Exe_ChipInspect(pBin,pOrg,icam);
	}

	double			dAvgThickTemp=0,dChamferThick;//Chamfer
	
	//if(m_InsParm.bSizeIns == TRUE)
	{
		std::multimap<int,CSplinePoint>	mapDist;
		std::multimap<int,CSplinePoint>	mapDist_Dy;
		std::multimap<int,CSplinePoint>	mapChamfer;//20140528

		Inspection_Size(pOrg,pRes,pRes_Dy,pRes_Cham,pBinImg,pBin,&dChamferThick,&dAvgThickTemp,nCenX,nCenY,(int)dAlign2GlassX,dFeedbackXY,iDimension,icam,&mapDist,&mapDist_Dy,dGlassXY,dResult,&mapChamfer,dTheta);		//20140528

		//CalRangeVal(&mapDist,dResult,pRangeRes,nRangeCnt,nCenX,nCenY,nStartX,nFirstY,nLastY);//20140528

		CalRangeVal_New(&mapDist,&mapDist_Dy,dResult,dResult_Dy,pRangeRes,pRangeRes_Dy,pRangeRes_Cham,nRangeCnt,nCenX,nCenY,nStartX,nFirstY,nLastY,&mapChamfer);//20140528
	}

	if(m_InsParm.bChipIns == TRUE)
	{
		CRect		rectImg(0,0,pOrg.GetWidth(),pOrg.GetHeight());

		AnalysisThick(rectImg,m_InsParm.dCamRes,m_InsParm.nChipDiff,dAvgThickTemp*m_InsParm.dCamRes);
	}

	*dAvgThick = dChamferThick;

	if(m_nTotalCount > 0)
	{
		double		dRate = (double)m_nNoDetCount/(double)m_nTotalCount;

		if(dRate >= 0.1)
		{
			dResult[1] += ((double)200*m_InsParm.dCamRes);
		}
	}

	if(m_nTotalCount > 0)
	{
		double		dRate = (double)m_nNoDetCount/(double)m_nTotalCount;

		if(dRate >= 0.1)
		{
			dResult_Dy[1] += ((double)200*m_InsParm.dCamRes);
		}
	}

	SetNotchImgResPoint(&pRes,pRangeRes,nRangeCnt);
	SetNotchImgResPoint(&pRes_Dy,pRangeRes_Dy,nRangeCnt);
	SetNotchImgResPoint(&pRes_Cham,pRangeRes_Cham,nRangeCnt);//20140528

	return nErrCode;
}

void CNotchCut::SetNotchImgResPoint(COwnerBuffer *pRes,pNOTCH_RangePos_STU RangeVal,int nRangeCnt)
{
	int			iPoint;	

	for(iPoint=0;iPoint<nRangeCnt;iPoint++)
	{
		bresenham_Line(pRes,RangeVal[iPoint].pointCAD,RangeVal[iPoint].pointImg,255);
	}
}

// Bresenham's line algorithm
void CNotchCut::bresenham_Line(COwnerBuffer *pRes,CPoint posStart,CPoint posEnd,BYTE color)
{	
	if(posStart.x <= 0 || posStart.y <= 0 || posEnd.x <= 0 || posEnd.y <= 0)
		return;

	const bool steep = (abs(posEnd.y - posStart.y) > abs(posEnd.x - posStart.x));

	if(steep)
	{
		std::swap(posStart.x, posStart.y);
		std::swap(posEnd.x, posEnd.y);
	}

	if(posStart.x > posEnd.x)
	{
		std::swap(posStart.x, posEnd.x);
		std::swap(posStart.y, posEnd.y);
	}

	const int dx = posEnd.x - posStart.x;
	const int dy = abs(posEnd.y - posStart.y);

	float error = (float)dx / 2.0f;
	const int ystep = (posStart.y < posEnd.y) ? 1 : -1;
	int y = (int)posStart.y;

	const int maxX = (int)posEnd.x;

	for(int x=(int)posStart.x; x<maxX; x++)
	{
		if(steep)
		{
			pRes->SetPixel(y,x, color);
		}
		else
		{
			pRes->SetPixel(x,y, color);		
		}

		error -= dy;
		if(error < 0)
		{
			y += ystep;
			error += dx;
		}
	}
}

int CNotchCut::AnalysisThick(CRect rectImg,double dRes,int nJudgeThick,double dAvgThick)
{	
	vector<pair<int,CSplinePoint>>::iterator	it;	
	CSplinePoint		*splinePos;	
	double				dThick;
	std::vector<CChipPair>	vecPair;
	vector<CChipBlob>::iterator	itData;
	CChamferInspect		ChamferIns;
	int					nChipSize = (int)((double)nJudgeThick*DETECT_CHIP_MULTI_RATIO);

	for(it=m_mapChipData.begin();it!=m_mapChipData.end();it++)
	{
		splinePos = static_cast<CSplinePoint*>(&it->second);
		if(splinePos == NULL || splinePos->dThick <= 0)
			continue;		

		dThick = fabs((splinePos->dThick*dRes)-dAvgThick);
		if(dThick > nChipSize)		
		{
			ChamferIns.InsertPairing(splinePos->rotate.x,splinePos->rotate.y,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,dAvgThick+dThick);			
		}		
	}	

#define CONTINUE_DEFECT_CNT		3
	if(ChamferIns.GetPairDefectCount() > 0)
	{
		std::vector<CChipBlob> vecBlob;
		ChamferIns.BlobDefect_Pixel(vecBlob,0,5);

		if((int)vecBlob.size() > 0)
		{
			std::vector<CChipBlob>::iterator itBlob;

			for(itBlob=vecBlob.begin();itBlob!=vecBlob.end();itBlob++)
			{
				if(m_nDefectCount >= MAX_NOTCH_DEFECT_COUNT)
					return m_nDefectCount;

				if(itBlob->s_nDefectArea < CONTINUE_DEFECT_CNT)
					continue;

				CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];
				if(pChipBlob == NULL)
					continue;

				*pChipBlob = *itBlob;

				pChipBlob->s_DefectRect.OffsetRect(rectImg.left,rectImg.top);
				pChipBlob->s_nDefectX += rectImg.left;
				pChipBlob->s_nDefectY += rectImg.top;
				pChipBlob->s_nDefectRScale = (int)pChipBlob->s_dThick;
				pChipBlob->s_DefectPosType = CHIPPOSTYPE_CEN;
				pChipBlob->s_DefectRect = CRect(pChipBlob->s_nDefectX,pChipBlob->s_nDefectY,pChipBlob->s_nDefectX,pChipBlob->s_nDefectY);
				pChipBlob->s_DefectRect.InflateRect(pChipBlob->s_nDefectRScale/2,pChipBlob->s_nDefectRScale/2);

				m_nDefectCount++;
			}	
		}
	}

	return m_nDefectCount;
}

void CNotchCut::Inspection_Size(CSISBuffer &pOrg,COwnerBuffer &pRes,COwnerBuffer &pRes_Dy,COwnerBuffer &pRes_Cham,CSISBuffer &pBinEdge,CSISBuffer &pBin,double *dChamferAvgThick,double *dChipAvgThick,int nCenX,int nCenY,int nGlass2Edge,double *dFeedbackXY
								,int iDimension, int icam, std::multimap<int,CSplinePoint> *mapDist,std::multimap<int,CSplinePoint> *mapDist_Dy,double *dGlassXY,double *dResult,std::multimap<int,CSplinePoint> *mapChamfer,double dTheta)//20140528
{
	int				nUpVPos,nDwVPos;

	nUpVPos = 0;
	nDwVPos = INT_MAX;
	DistInspection_New(pBin,pOrg,dChamferAvgThick,dChipAvgThick,nCenX,nCenY,nGlass2Edge,dFeedbackXY,iDimension
					,icam,mapDist,mapDist_Dy,dGlassXY,&nUpVPos,&nDwVPos,mapChamfer,dTheta);//20140528
//	ZeroMemory(dResult,sizeof(double)*2);
//	double		dRangeRes[5];
//	DistInspection(pBin,pOrg,dResult,dRangeRes,dAvgThick,nCenX,nCenY,nGlass2Edge,dFeedbackXY,0,icam);

	if(m_bSaveDebug == TRUE)
	{
		COwnerBuffer		pBin2(pOrg.GetWidth(),pOrg.GetHeight());
		CEdgeProc EdgeProc;

		CopyMemory(pBin2.GetDataAddress(0,0),pOrg.GetDataAddress(0,0),pOrg.GetDataSize());
		EdgeProc.ThresholdProcessing(pBin2.GetDataAddress(0,0),CSize(pBin2.GetDataWidth(),pBin2.GetHeight()),m_InsParm.nChipThres,1);

		CString		str;	
		str.Format(_T("%s\\4.Notch_Ins_Bin_2_%d_%d.bmp"),m_strSavePath,icam,iDimension);
		CBufferAttach	attach(str);
		attach.AttachToFile(pBin2);
	}

	double dThickness = FindCenterThickness(pOrg,pBin,nCenX,nCenY,icam,iDimension);
	if(dThickness > 0)
	{
		*dChamferAvgThick = dThickness;
	}
	
	Inspection_SpChip(pBin,pOrg,nGlass2Edge,nUpVPos,nDwVPos);
	

	MakeReal2Cad_Image(pOrg,pRes,128);
	MakeReal2Cad_Image(pOrg,pRes_Dy,128);
	MakeReal2Cad_Image(pOrg,pRes_Cham,128);//20140528
}

double CNotchCut::FindCenterThickness(CSISBuffer &pOrg,CSISBuffer &pBin,int nCenX,int nCenY,int icam,int iDimension)
{
	double		dThickness = -1;
	CRect		rectCen;
	int			nHorMargin = 400,nVerMargin = 60;
	CChamferInspect		ChamferIns;
	int			nWidth;

	rectCen = CRect(nCenX-nHorMargin,nCenY-nVerMargin,nCenX+nHorMargin,nCenY+nVerMargin);
	if(rectCen.left < 0)
	{
		rectCen.left = 0;
		nWidth = align_4byte(rectCen.Width());
		rectCen.right = rectCen.left+nWidth;
	}	
	if(rectCen.right >= pOrg.GetWidth())
	{
		rectCen.right = pOrg.GetWidth()-1;
		nWidth = align_4byte(rectCen.Width());
		rectCen.left = rectCen.right-nWidth;
	}
	if(rectCen.top < 0 || rectCen.bottom >= pOrg.GetHeight())
	{
		rectCen = CRect(nCenX-nHorMargin,pOrg.GetHeight()/2-nVerMargin,nCenX+nHorMargin,pOrg.GetHeight()/2+nVerMargin);
	}	

	if(m_bSaveDebug == TRUE)
	{	
		COwnerBuffer		pCenImg(rectCen.Width(),rectCen.Height());
		ChamferIns.CopyRectImg(pOrg.GetDataAddress(),pCenImg.GetDataAddress(),CSize(pOrg.GetDataWidth(),pOrg.GetHeight()),rectCen);

		CString		str;	
		str.Format(_T("%s\\Notch_Cen_2_%d_%d.bmp"),m_strSavePath,icam,iDimension);
		CBufferAttach	attach(str);
		attach.AttachToFile(pCenImg);
	}

	CRect		rectChip(0,0,0,0);
	int			nThres = m_InsParm.nChipThres;//(int)((double)m_InsParm.nSizeThres*1.2);
	int		nResult;
	ChipErrCode errCode = ChamferIns.Inspection(&nResult,pOrg.GetDataAddress(),pOrg.GetWidth(),rectCen,nThres,FALSE,TRUE,rectChip,rectChip,rectChip,0,0,0,0,0,m_bSaveDebug,NULL,THRESMODE_FIXED);
	if(errCode == ERR_CHIP_SUCCESS)
	{
		dThickness = ChamferIns.GetAvgThick();
	}	

	return dThickness;
}

void CNotchCut::ThinImage(CSISBuffer &pBinThin,int iscan, int icam)
{	
	BOOL bThin = FALSE;
	for(int y=0; y<pBinThin.GetHeight(); y++)
	{	
		bThin = FALSE;
		for(int x=0; x<pBinThin.GetWidth(); x++)
		{
			if(*pBinThin.GetDataAddress(x,y)==255)
			{
				if(bThin == TRUE)
					pBinThin.SetPixel(x,y,0);

				bThin=TRUE;
			}				
		}
	}

	if(m_bSaveDebug == TRUE)
	{
		CString				str;
		str.Format(_T("%s\\6.ThinImage_%d_%d.bmp"),m_strSavePath,icam,iscan);
		CBufferAttach		attach(str);
		attach.AttachToFile(pBinThin);
	}
}

void CNotchCut::GetSpChipData(vector<pair<int,CPoint>> *pVec,CRect *rectIns)
{
	vector<pair<int,CPoint>>::iterator	it;
	CPoint					pointOrg;

	for(it=m_mapMaster.begin();it!=m_mapMaster.end();it++)//m_mapMaster´Â cad µµ¸éÀÇ Áß½ÉÀ» À̹ÌÁöÀÇ Áß½ÉÀ¸·Î offset½ÃŲ Cadµµ¸é
	{		
		pointOrg = static_cast<CPoint>(it->second);	

		if(rectIns->PtInRect(pointOrg) == TRUE)
		{
			pVec->push_back(std::make_pair(pointOrg.y, pointOrg));
		}
	}
}

double CNotchCut::Detect_Position(CSISBuffer &pBin,CSISBuffer &pOrg,std::multimap<double,CDetectPoint> *mapDist
								  ,vector<pair<int,CPoint>> *vecData)
{
	vector<pair<int,CPoint>>::iterator	it;
	CPoint					pointOrg,pointSet;
	int						nCount=0,nLineSampleDet = 10,nDetOffset=200;	
	sPoint					*pLinedata = NULL;	
	double					dAdjustTheta;
	CEdgeProc				EdgeProc;	
	int						iCnt,nValue,nOrgVal,nInterval;	
	double					dOutX,dOutY,dDist;		
	CSplinePoint			splinePos,spDist;	
	CDetectPoint			DetPos;
	double					dSumThick,dThickCnt;
	int						nNoDetCount = 0;
	int						nConti;
	int						nWhiteThres = (int)((double)m_InsParm.nChipThres*1.5);

	mapDist->clear();
	dSumThick = dThickCnt = 0.;
	pLinedata = new sPoint[nLineSampleDet];	
	for(it=vecData->begin();it!=vecData->end();it++)//m_mapMaster´Â cad µµ¸éÀÇ Áß½ÉÀ» À̹ÌÁöÀÇ Áß½ÉÀ¸·Î offset½ÃŲ Cadµµ¸é
	{		
		pointOrg = static_cast<CPoint>(it->second);			

		pLinedata[nCount].x = pointOrg.x;
		pLinedata[nCount].y = pointOrg.y;
		nCount++;
		if(nCount >= nLineSampleDet)
		{
			dAdjustTheta = EdgeProc.GetTheta(pLinedata,nLineSampleDet,5);									
			nCount = 0;		

			//TRACE("X=%d Y=%d Theta=%.2f\n",pointOrg.x,pointOrg.y,dAdjustTheta);

			for(iCnt=0;iCnt<nLineSampleDet;iCnt++)
			{
				pointOrg.x = pointSet.x = (int)pLinedata[iCnt].x;
				pointOrg.y = pointSet.y = (int)pLinedata[iCnt].y;														
				if(dAdjustTheta <= 90)
				{
					pointOrg.x -= nDetOffset;		
					nInterval = 1;
				}
				else
				{
					pointOrg.x += nDetOffset;		
					nInterval = -1;
				}

				spDist.Reset();
				spDist.dThick = INT_MAX;
				spDist.bFind = FALSE;
				splinePos.Reset();
				splinePos.dThick = INT_MAX;
				splinePos.bFind = FALSE;
				DetPos.Reset();

				nConti = 0;
				double		dOrgX,dOrgY;
				for(int iU=-1*nDetOffset;iU<nDetOffset;iU++)
				{	
					EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				

					if(dOutX < 0 || dOutY < 0 || (int)dOutX >= pBin.GetWidth() || (int)dOutY >= pBin.GetHeight())
						continue;

					nValue = *pBin.GetDataAddress((int)dOutX,(int)dOutY);					

					if(nValue > 0 && spDist.bFind == FALSE)
					{			
						if(nConti == 0)
						{
							dOrgX = dOutX;
							dOrgY = dOutY;
						}
						nConti++;
						if(nConti > DETECT_WHITE_CONTI_COUNT)
						{
							dDist = sqrt(pow(((double)pointSet.x-dOrgX),2)+pow(((double)pointSet.y-dOrgY),2));
							spDist.rotate = CPoint((int)dOrgX,(int)dOrgY);
							spDist.origin = pointSet;
							spDist.dTheta = dAdjustTheta;
							spDist.dThick = dDist;
							spDist.bFind = TRUE;
						}
					}	
					else
						nConti = 0;
					
					nOrgVal = *pOrg.GetDataAddress((int)dOutX,(int)dOutY);
					if(nOrgVal >= nWhiteThres && splinePos.bFind == FALSE)
					{
						dDist = sqrt(pow(((double)pointSet.x-dOutX),2)+pow(((double)pointSet.y-dOutY),2));
							splinePos.dThick = dDist;
							splinePos.origin = pointSet;
							splinePos.rotate = CPoint((int)dOutX,(int)dOutY);
							splinePos.dTheta = dAdjustTheta;
							splinePos.bFind = TRUE;
						}						

					pointOrg.x += nInterval;
				}	

				if(spDist.bFind == TRUE && splinePos.bFind == TRUE)
				{
					DetPos.orgX = spDist.rotate.x;
					DetPos.orgY = spDist.rotate.y;
					DetPos.imgX = splinePos.rotate.x;
					DetPos.imgY = splinePos.rotate.y;
					DetPos.dTheta = dAdjustTheta;
					DetPos.dDist = sqrt(pow(((double)spDist.rotate.x-(double)splinePos.rotate.x),2)+pow(((double)spDist.rotate.y-(double)splinePos.rotate.y),2));
					mapDist->insert(std::make_pair(DetPos.orgY, DetPos));
					dSumThick += DetPos.dDist;
					dThickCnt++;	
				}		

				m_nTotalCount++;
				if(spDist.bFind == FALSE)
				{
					nNoDetCount++;
					if(m_nNoDetCount < nNoDetCount)
						m_nNoDetCount = nNoDetCount;
				}
				else
				{
					nNoDetCount = 0;
				}
			}	
		}
	}

	delete[] pLinedata, pLinedata=NULL;	

	return dThickCnt>0?dSumThick/dThickCnt:0.;
}

void CNotchCut::SetBrokenDefect(CPoint pointBroken)
{
	CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];
	if(pChipBlob != NULL)
	{
		pChipBlob->s_nDefectX = pointBroken.x;
		pChipBlob->s_nDefectY = pointBroken.y;
		pChipBlob->s_DefectType = CHIPDEFTYPE_BLACK;
		pChipBlob->s_dThick = 100;
		pChipBlob->s_nDefectArea = 100;			
		pChipBlob->s_nDefectRScale = 50;
		pChipBlob->s_DefectRect = CRect(pChipBlob->s_nDefectX,pChipBlob->s_nDefectY,pChipBlob->s_nDefectX,pChipBlob->s_nDefectY);
		pChipBlob->s_DefectRect.InflateRect(pChipBlob->s_nDefectRScale/2,pChipBlob->s_nDefectRScale/2);

		m_nDefectCount++;
	}	
}

int CNotchCut::Defect_Analyze(std::multimap<double,CDetectPoint> *mapDist,double dAvgThick)
{
	if(dAvgThick <= 0 || (int)mapDist->size() <= 0)
		return m_nDefectCount;

	std::multimap<double,CDetectPoint>::iterator		it;
	CDetectPoint		DetectPos;
	CChamferInspect		ChamferIns;
	double				dThick;
	std::vector<CChipPair>	vecPair;
	vector<CChipBlob>::iterator	itData;
	int					nChipSize = (int)((double)m_InsParm.nChipDiff*DETECT_CHIP_MULTI_RATIO);

	for(it=mapDist->begin();it!=mapDist->end();it++)
	{
		DetectPos = static_cast<CDetectPoint>(it->second);			

		dThick = fabs((DetectPos.dDist*m_InsParm.dCamRes)-dAvgThick);
		if(dThick > nChipSize)		
		{		
			ChamferIns.InsertPairing((int)DetectPos.orgX,(int)DetectPos.orgY,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,dThick);			
		}		
	}	

#define CONTINUE_DEFECT_CNT		3
	if(ChamferIns.GetPairDefectCount() > 0)
	{
		std::vector<CChipBlob> vecBlob;
		ChamferIns.BlobDefect_Pixel(vecBlob,0,3);

		if((int)vecBlob.size() > 0)
		{
			std::vector<CChipBlob>::iterator itBlob;

			for(itBlob=vecBlob.begin();itBlob!=vecBlob.end();itBlob++)
			{
				if(m_nDefectCount >= MAX_NOTCH_DEFECT_COUNT)
					return m_nDefectCount;

				if(itBlob->s_nDefectArea < CONTINUE_DEFECT_CNT)
					continue;

				CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];
				if(pChipBlob == NULL)
					continue;

				*pChipBlob = *itBlob;

				pChipBlob->s_nDefectRScale = (int)pChipBlob->s_dThick;
				pChipBlob->s_DefectRect = CRect(pChipBlob->s_nDefectX,pChipBlob->s_nDefectY,pChipBlob->s_nDefectX,pChipBlob->s_nDefectY);
				pChipBlob->s_DefectRect.InflateRect(pChipBlob->s_nDefectRScale/2,pChipBlob->s_nDefectRScale/2);
				pChipBlob->s_DefectPosType = CHIPPOSTYPE_SP;

				m_nDefectCount++;
			}	
		}
	}
	
	return m_nDefectCount;
}

BOOL CNotchCut::Inspection_SpChip(CSISBuffer &pBin,CSISBuffer &pOrg,int nGlass2Edge,int nUpVPos,int nDwVPos)
{
	if(pBin.IsValidBuffer() == FALSE || pOrg.IsValidBuffer() == FALSE)
		return FALSE;
	
	CRect					rectIns;
	int						nSkipSize = (int)((double)m_InsParm.nSkipSize/m_InsParm.dCamRes);
	int						nSPInsSize;
	vector<pair<int,CPoint>>	vecData;
	std::multimap<double,CDetectPoint> mapDist;
	double					dAvgThick;

	if(m_InsParm.bSplineChip[0] == TRUE && nUpVPos != 0)
	{
		nSPInsSize = (int)((double)m_InsParm.nSpInsSize[0]/m_InsParm.dCamRes);
		rectIns = CRect(nGlass2Edge-nSkipSize,nUpVPos-nSPInsSize,nGlass2Edge+nSkipSize,nUpVPos);
		
		if(m_bSaveDebug == TRUE)
		{
			CString		str;
			str.Format(_T("%s\\UpImg.bmp"),m_strSavePath);
			CCropBuffer		cropBuf(pOrg,rectIns);
			CBufferAttach	attach(str);
			attach.AttachToFile(cropBuf);
		}


		GetSpChipData(&vecData,&rectIns);
		if((int)vecData.size() > 0)
		{
			std::sort(vecData.begin(),vecData.end(),ResSortYPos());

			dAvgThick = Detect_Position(pBin,pOrg,&mapDist,&vecData);

			Defect_Analyze(&mapDist,dAvgThick*m_InsParm.dCamRes);		
		}
	}

	if(m_InsParm.bSplineChip[1] == TRUE && nDwVPos != INT_MAX)
	{
		vecData.clear();
		nSPInsSize = (int)((double)m_InsParm.nSpInsSize[1]/m_InsParm.dCamRes);
		rectIns = CRect(nGlass2Edge-nSkipSize,nDwVPos,nGlass2Edge+nSkipSize,nDwVPos+nSPInsSize);

		if(m_bSaveDebug == TRUE)
		{
			CString		str;
			str.Format(_T("%s\\DwImg.bmp"),m_strSavePath);
			CCropBuffer		cropBuf(pOrg,rectIns);
			CBufferAttach	attach(str);
			attach.AttachToFile(cropBuf);
		}


		GetSpChipData(&vecData,&rectIns);
		if((int)vecData.size() > 0)
		{
			std::sort(vecData.begin(),vecData.end(),ResSortYPos());
			
			mapDist.clear();
			dAvgThick = Detect_Position(pBin,pOrg,&mapDist,&vecData);

			Defect_Analyze(&mapDist,dAvgThick*m_InsParm.dCamRes);	
		}
	}

	return TRUE;
}

void CNotchCut::Exe_ChipInspect(CSISBuffer &pBin,CSISBuffer &pOrg,int iCam)
{
	if(pBin.IsValidBuffer() == FALSE || pOrg.IsValidBuffer() == FALSE)
		return;

	vector<pair<int,CPoint>>::iterator	it;
	CPoint					pointOrg,pointSet,pointMax;
	int						nCount=0,nLineSampleDet = 10;	
	sPoint					*pLinedata = NULL;	
	double					dAdjustTheta;	
	int						nDetOffset = 80,nBlankSize=10;	
	int						iCnt,nValue;							
	double					dOutX,dOutY;	
	CEdgeFind				EdgeFind;
	CEdgeProc				EdgeProc;
	int						nInterval,nSkipSize,nDetPos,nChipSize;
	BOOL					bBlackFind;
	int						nPreChipPos,nChipContiCnt,iTerCnt;	
	std::vector<CChipPair>	vecPair;	
	CChamferInspect		ChamferIns;
	int						nConti = 0;

	nSkipSize = (int)((double)(m_InsParm.nChamferSize+m_InsParm.nChamferDiff)/m_InsParm.dCamRes);
	nChipSize = (int)(((double)(m_InsParm.nChipDiff)/m_InsParm.dCamRes)*2);


	COwnerBuffer		pChip(pOrg.GetDataWidth(),pOrg.GetHeight());
	if(m_bSaveDebug == TRUE)
	{		
		CopyMemory(pChip.GetDataAddress(),pOrg.GetDataAddress(),pOrg.GetDataSize());
	}

	nPreChipPos = -1;
	nChipContiCnt = iTerCnt = 0;
	pLinedata = new sPoint[nLineSampleDet];	
	for(it=m_mapMaster.begin();it!=m_mapMaster.end();it++)//m_mapMaster´Â cad µµ¸éÀÇ Áß½ÉÀ» À̹ÌÁöÀÇ Áß½ÉÀ¸·Î offset½ÃŲ Cadµµ¸é
	{		
		pointOrg = static_cast<CPoint>(it->second);	

		if(pointOrg.y <= nBlankSize || pointOrg.y >= pBin.GetHeight()-nBlankSize)
			continue;

		
		pLinedata[nCount].x = pointOrg.x;
		pLinedata[nCount].y = pointOrg.y;
		nCount++;
		if(nCount >= nLineSampleDet)
		{
			dAdjustTheta = EdgeProc.GetTheta(pLinedata,nLineSampleDet,5);									
			nCount = 0;		

			for(iCnt=0;iCnt<nLineSampleDet;iCnt++,iTerCnt++)
			{
				pointOrg.x = pointSet.x = (int)pLinedata[iCnt].x;
				pointOrg.y = pointSet.y = (int)pLinedata[iCnt].y;														
				if(dAdjustTheta <= 90)
				{
					pointOrg.x -= nDetOffset;		
					nInterval = 1;
				}
				else
				{
					pointOrg.x += nDetOffset;		
					nInterval = -1;
				}			
				
				bBlackFind = FALSE;			
				nDetPos = nConti = 0;
				pointMax = pointOrg;
				pointMax.x += (nInterval*(nDetOffset*2));

				int		iU;
				for(iU=-1*nDetOffset;iU<nDetOffset;iU++)
				{	
					EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				

					if(dOutX < 0 || dOutY < 0 || (int)dOutX >= pBin.GetWidth() || (int)dOutY >= pBin.GetHeight())
						continue;

					nValue = *pBin.GetDataAddress((int)dOutX,(int)dOutY);	

					if(bBlackFind == FALSE && nValue > 0)
					{
						nConti++;
						if(nConti > DETECT_WHITE_CONTI_COUNT)
						{
							nDetPos = iU-DETECT_WHITE_CONTI_COUNT;	
							bBlackFind = TRUE;
							break;
						}
					}		
					else
						nConti = 0;
					pointOrg.x += nInterval;
				}	
								
				if(bBlackFind == TRUE)
				{
					pointOrg.x += (nInterval*(nSkipSize+m_InsParm.nDetSkipSize));
				}
				else
				{
					pointOrg = pointSet;	
					pointOrg.x += (nInterval*(nSkipSize+m_InsParm.nNoDetSkipSize));										
					nDetPos = 0;
				}				
				
				int		nLoopCnt = nDetPos + abs(pointMax.x-pointOrg.x);
				for(iU=nDetPos;iU<nLoopCnt;iU++)
				{	
					EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				

					if(dOutX < 0 || dOutY < 0 || (int)dOutX >= pOrg.GetWidth() || (int)dOutY >= pOrg.GetHeight())
						continue;

					nValue = *pOrg.GetDataAddress((int)dOutX,(int)dOutY);					

					if(nValue < m_InsParm.nChipThres)
					{								
						ChamferIns.InsertPairing((int)dOutX,(int)dOutY,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,1);	
						
						if(m_bSaveDebug == TRUE)
						{
							pChip.SetPixel((int)dOutX,(int)dOutY,200);
						}
					}					

					pointOrg.x += nInterval;
				}					
			}	
		}
	}

	if(ChamferIns.GetPairDefectCount() > 0)		
	{
		std::vector<CChipBlob> vecBlob;
		ChamferIns.BlobDefect_Pixel(vecBlob,0,3);

		std::vector<CChipBlob>::iterator itBlob;

		for(itBlob=vecBlob.begin();itBlob!=vecBlob.end();itBlob++)
		{
			if(m_nDefectCount >= MAX_NOTCH_DEFECT_COUNT)
				return;

			if(itBlob->s_DefectRect.Width() < nChipSize || itBlob->s_DefectRect.Height() <= 2)
				continue;

			CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];
			if(pChipBlob == NULL)
				continue;

			*pChipBlob = *itBlob;	
			pChipBlob->s_DefectPosType = CHIPPOSTYPE_BIN;

			m_nDefectCount++;
		}	
	}

	if(m_bSaveDebug == TRUE)
	{
		CString		str;
		str.Format(_T("%s\\4.[%d]_ChipInsImg.bmp"),m_strSavePath,iCam);//20140528
		CBufferAttach		attach(str);
		attach.AttachToFile(pChip);
	}
}

BOOL CNotchCut::DistInspection_New(CSISBuffer &pBin,CSISBuffer &pOrg,double *dChamferThick,double *dChipAvgThick,int nCenX,int nCenY,int nGlass2Edge
							   , double *dFeedbackXY,int iDimension, int icam, std::multimap<int,CSplinePoint> *mapDist,std::multimap<int,CSplinePoint> *mapDist_Dy,double *dGlassXY
							   ,int *nUpVPos,int *nDwVPos,std::multimap<int,CSplinePoint> *mapChamfer,double dTheta)//20140528
{	
	ZeroMemory(dGlassXY,sizeof(double)*2);

	if(pBin.IsValidBuffer() == FALSE || pOrg.IsValidBuffer() == FALSE)
		return FALSE;

	vector<pair<int,CPoint>>::iterator	it;
	CPoint					pointOrg,pointOrg_Dy,pointSet;
	int						nCount=0,nLineSampleDet = 10;	
	sPoint					*pLinedata = NULL;	
	double					dAdjustTheta,dDist,dDist_Dy;	
	const	int				nDetOffset = 200;	
	int						iCnt,nValue,nOrgVal;							
	double					dOutX,dOutY;		
	CSplinePoint			splinePos,spDist,spDist_Dy,spDistBlack;	
	int						nInterval,nInterval_Dy;
	CEdgeFind				EdgeFind;
	CEdgeProc				EdgeProc;
	double					dSumThick,dThickCnt;
	double					dChamferSumThick,dChamferThickCnt;
	int						nNoDetCount,nConti,nConti_Dy,nWhiteConti;
	int						nWhiteThres = (int)((double)m_InsParm.nChipThres*1.6);
	int						nCenSkipRange[2],nSkipMargin=50;
	int						nFeedbackYOffset = 100;
	int						nCalFeedbackPosX = m_AlignMasterParm[iDimension].nPosX+nFeedbackYOffset;
	BOOL					bFindFeedbackY[2];
	int						nFeedbackYPos[2];
	bFindFeedbackY[0] = bFindFeedbackY[1] = FALSE;
	nFeedbackYPos[0] = nFeedbackYPos[1] = -9999;

//	int		nStartY = (int)((double)baseCenY/m_InsParm.dCamRes-(double)(m_MasterParm[index].nPosY));
	
	if(nCenX > 0 && nCenY > 0)
	{
		dFeedbackXY[0] = nCenX - m_AlignMasterParm[iDimension].nMaxX;
		dFeedbackXY[1] = nCenY - m_AlignMasterParm[iDimension].nMaxY;
		dGlassXY[0] = nCenX;
		dGlassXY[1] = nCenY;
	}
	else
	{
		dFeedbackXY[0] = -9999;
		dFeedbackXY[1] = -9999;
		dGlassXY[0] = m_AlignMasterParm[iDimension].nMaxX;
		dGlassXY[1] = m_AlignMasterParm[iDimension].nMaxY;
	}	

	nCenSkipRange[0] = pOrg.GetHeight()/2-nSkipMargin;
	nCenSkipRange[1] = pOrg.GetHeight()/2+nSkipMargin;

	dSumThick = dThickCnt = dChamferSumThick = dChamferThickCnt = 0.;

	*nUpVPos = 0;
	*nDwVPos = INT_MAX;

	nNoDetCount = 0;

	if(m_bSaveDebug == TRUE)
	{
		CString		str;
		str.Format(_T("%s\\[%d]_DistInspection_Bin.bmp"),m_strSavePath,icam);
		CBufferAttach		attach(str);
		attach.AttachToFile(pBin);
	}

	int			nSkipsize = (int)((double)m_InsParm.nSkipSize/m_InsParm.dCamRes);
	const		int		nContinueBlackCnt = 20;
	int			nConBlack;

	pLinedata = new sPoint[nLineSampleDet];	
	for(it=m_mapMaster.begin();it!=m_mapMaster.end();it++)//m_mapMaster´Â cad µµ¸éÀÇ Áß½ÉÀ» À̹ÌÁöÀÇ Áß½ÉÀ¸·Î offset½ÃŲ Cadµµ¸é
	{		
		pointOrg = static_cast<CPoint>(it->second);	

		if(pointOrg.x < nGlass2Edge+nSkipsize)
		{
			if(pointOrg.y < nCenY)
			{
				if(*nUpVPos < pointOrg.y)
					*nUpVPos = pointOrg.y;
			}
			else
			{
				if(*nDwVPos > pointOrg.y)
					*nDwVPos = pointOrg.y;
			}
			continue;
		}

		//////////////////////////////////////////////////////////////////////////
// 		if(pointOrg.x == nCalFeedbackPosX && pointOrg.y < m_AlignMasterParm[iDimension].nMaxY && bFindFeedbackY[0] == FALSE)
// 		{
// 			for (int i=m_AlignMasterParm[iDimension].nMaxY; i>0; i--)
// 			{
// 				nValue = *pBin.GetDataAddress(nCalFeedbackPosX,i);
// 
// 				if(nValue>0)
// 				{
// 					nFeedbackYPos[0] = i - pointOrg.y;
// 					bFindFeedbackY[0] = TRUE;
// 					break;
// 				}
// 			}
// 		}
// 
// 		if(pointOrg.x == nCalFeedbackPosX && pointOrg.y > m_AlignMasterParm[iDimension].nMaxY && bFindFeedbackY[1] == FALSE)
// 		{
// 			for (int i=m_AlignMasterParm[iDimension].nMaxY; i<pBin.GetHeight(); i++)
// 			{
// 				nValue = *pBin.GetDataAddress(nCalFeedbackPosX,i);
// 
// 				if(nValue>0)
// 				{
// 					nFeedbackYPos[1] = i - pointOrg.y;
// 					bFindFeedbackY[1] = TRUE;
// 					break;
// 				}
// 			}
// 		}
		//////////////////////////////////////////////////////////////////////////
		//notch ¿µ»ó centerÁß°£ ½ºÅµ
// 		if(nCenSkipRange[0] <= pointOrg.y && pointOrg.y <= nCenSkipRange[1])
// 			continue;

		pLinedata[nCount].x = pointOrg.x;
		pLinedata[nCount].y = pointOrg.y;
		nCount++;
		if(nCount >= nLineSampleDet)
		{
			dAdjustTheta = EdgeProc.GetTheta(pLinedata,nLineSampleDet,5);									
			nCount = 0;		

			for(iCnt=0;iCnt<nLineSampleDet;iCnt++)
			{
				pointOrg.x = pointOrg_Dy.x = pointSet.x = (int)pLinedata[iCnt].x;
				pointOrg.y = pointOrg_Dy.y = pointSet.y = (int)pLinedata[iCnt].y;			

				if(dAdjustTheta <= 90)
				{
					pointOrg.x -= nDetOffset;		
					nInterval = 1;
				}
				else
				{
					pointOrg.x += nDetOffset;		
					nInterval = -1;
				}

				pointOrg_Dy.x -= nDetOffset;
				nInterval_Dy = 1;
				
				spDist.Reset();
				spDist.bFind = FALSE;
				spDist.dThick = INT_MAX;
				spDist_Dy.Reset();
				spDist_Dy.bFind = FALSE;
				spDist_Dy.dThick = INT_MAX;
				splinePos.Reset();
				splinePos.bFind = FALSE;
				splinePos.dThick = INT_MAX;	
				spDistBlack.Reset();
				spDistBlack.bFind = FALSE;
				spDistBlack.dThick = INT_MAX;
				nConBlack = nConti = nConti_Dy = nWhiteConti = 0;

				double		dOrgX,dOrgY,dOrgX_Dy,dOrgY_Dy,dWhiteX,dWhiteY;
				int nOutX,nOutY;

				dOrgX = dOrgY = dOrgX_Dy = dOrgY_Dy = dWhiteX = dWhiteY = 0.;
				for(int iU=-1*nDetOffset;iU<nDetOffset;iU++)
				{	
					//////////////////////////////////////////////////////////////////////////
					//EdgeProc.RotatePoint(pointOrg_Dy,dOutX,dOutY,sin((dTheta)), cos((dTheta)));
					EdgeProc.RotatePoint(pointOrg_Dy,dOutX,dOutY,pointSet,sin(dTheta), cos(dTheta));
					
					nValue = *pBin.GetDataAddress((int)dOutX,(int)dOutY);
					nOutX = (int)dOutX;
					nOutY = (int)dOutY;
					
					if(spDist_Dy.bFind == FALSE && nValue > 0)
					{				
						if(nConti_Dy == 0)
						{
							dOrgX_Dy = dOutX;
							dOrgY_Dy = dOutY;
						}
						nConti_Dy++;
						if(nConti_Dy >DETECT_WHITE_CONTI_COUNT)
						{
							dDist_Dy = sqrt(pow(((double)pointSet.x-dOrgX_Dy),2)+pow(((double)pointSet.y-dOrgY_Dy),2));
							if(pointSet.x < dOrgX_Dy)		//20140721
								dDist_Dy *= -1;

							spDist_Dy.rotate = CPoint((int)dOrgX_Dy,(int)dOrgY_Dy);
							spDist_Dy.origin = pointSet;
							spDist_Dy.dTheta = dAdjustTheta;
							spDist_Dy.dThick = dDist_Dy;
							spDist_Dy.bFind = TRUE;
							//mapDist->insert(std::make_pair(spDist.rotate.y, spDist));//20140528
							mapDist_Dy->insert(std::make_pair(spDist_Dy.origin.y, spDist_Dy));//20140528
						}
					}
					else
						nConti_Dy = 0;

					dOutX = dOutY = 0.;
					//////////////////////////////////////////////////////////////////////////

					EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				

					if(dOutX < 0 || dOutY < 0 || (int)dOutX >= pBin.GetWidth() || (int)dOutY >= pBin.GetHeight())
						continue;

					nValue = *pBin.GetDataAddress((int)dOutX,(int)dOutY);					

					if(spDist.bFind == FALSE && nValue > 0)
					{				
						if(nConti == 0)
						{
							dOrgX = dOutX;
							dOrgY = dOutY;
						}
						nConti++;
						if(nConti > DETECT_WHITE_CONTI_COUNT)
						{
							dDist = sqrt(pow(((double)pointSet.x-dOrgX),2)+pow(((double)pointSet.y-dOrgY),2));
							if(pointSet.x < dOrgX)		//20140721
								dDist *= -1;
				
							spDist.rotate = CPoint((int)dOrgX,(int)dOrgY);
							spDist.origin = pointSet;
							spDist.dTheta = dAdjustTheta;
							spDist.dThick = dDist;
							spDist.bFind = TRUE;
							//mapDist->insert(std::make_pair(spDist.rotate.y, spDist));//20140528
							mapDist->insert(std::make_pair(spDist.origin.y, spDist));//20140528
						}
					}
					else
						nConti = 0;

					if(spDistBlack.bFind == FALSE)
					{
						if(spDist.bFind == TRUE && nValue == 0)
						{
							if(nConBlack == 0)
							{
								dDist = sqrt(pow(((double)spDist.rotate.x-dOutX),2)+pow(((double)spDist.rotate.y-dOutY),2));

								spDistBlack.rotate = CPoint((int)dOutX,(int)dOutY);
								//spDistBlack.origin = spDist.rotate;//20140528
								spDistBlack.origin = spDist.origin;//20140528
								spDistBlack.dTheta = dAdjustTheta;
								spDistBlack.dThick = dDist;								
							}

							nConBlack++;
							if(nConBlack >= nContinueBlackCnt)
							{
								spDistBlack.bFind = TRUE;
								dChamferSumThick += spDistBlack.dThick;
								dChamferThickCnt++;
								mapChamfer->insert(std::make_pair(spDistBlack.origin.y, spDistBlack));//20140528
							}
						}
						else
						{
							nConBlack = 0;
							spDistBlack.Reset();
							spDistBlack.bFind = FALSE;
							spDistBlack.dThick = INT_MAX;
						}						
					}		
					
					if(splinePos.bFind == FALSE)
					{
						nOrgVal = *pOrg.GetDataAddress((int)dOutX,(int)dOutY);
						if(nOrgVal >= nWhiteThres)
						{
							if(nWhiteConti == 0)
							{
								dWhiteX = dOutX;
								dWhiteY = dOutY;
							}
							nWhiteConti++;
							if(nWhiteConti > DETECT_WHITE_CONTI_COUNT)
							{
								dDist = sqrt(pow(((double)pointSet.x-dWhiteX),2)+pow(((double)pointSet.y-dWhiteY),2));								
								splinePos.dThick = dDist;
								splinePos.origin = pointSet;
								splinePos.rotate = CPoint((int)dWhiteX,(int)dWhiteY);
								splinePos.dTheta = dAdjustTheta;
								splinePos.bFind = TRUE;									
							}
						}	
						else
							nWhiteConti = 0;
					}
					pointOrg.x += nInterval;
					pointOrg_Dy.x += nInterval_Dy;
				}	

				if(splinePos.bFind == TRUE && spDist.bFind == TRUE)
				{
					splinePos.origin = spDist.rotate;
					splinePos.dThick = sqrt(pow(((double)spDist.rotate.x-(double)splinePos.rotate.x),2)+pow(((double)spDist.rotate.y-(double)splinePos.rotate.y),2));
					m_mapChipData.push_back(std::make_pair(splinePos.rotate.y, splinePos));			

					dSumThick += splinePos.dThick;
					dThickCnt++;
				}				

				m_nTotalCount++;
				if(spDist.bFind == FALSE)
				{
					nNoDetCount++;
					if(m_nNoDetCount < nNoDetCount)
						m_nNoDetCount = nNoDetCount;
				}
				else
				{
					nNoDetCount = 0;
				}
			}	
		}
	}

	if(dChamferThickCnt > 0)
		*dChamferThick = dChamferSumThick/dChamferThickCnt;

	if(dThickCnt > 0)
		*dChipAvgThick = dSumThick/dThickCnt;

// 	if(nFeedbackYPos[0] != -9999 && nFeedbackYPos[1] != -9999)
// 		dFeedbackXY[1] = (nFeedbackYPos[0] + nFeedbackYPos[1]) / 2.;

	return TRUE;
}

BOOL CNotchCut::DistInspection(CSISBuffer &pTgt,CSISBuffer &pOrg,double *dResult,double *dRangeRes,double *dAvgThick,int nCenX,int nCenY,int nGlass2Edge, double *dFeedbackXY,int iscan, int icam)
{	
	if(pTgt.IsValidBuffer() == FALSE)
		return FALSE;

	vector<pair<int,CPoint>>::iterator	it;
	CPoint					pointOrg,pointSet;
	int						nCount=0,nLineSampleDet = 10;	
	sPoint					*pLinedata = NULL;	
	double					dAdjustTheta,dSumThick,dThickCnt;	
	const	int				nDetOffset = 200;
	const	int				nDEF_LINE_COUNT = nLineSampleDet/3;
	int						iCnt,nValue,nOrgVal;	
	CDetectPoint			*pDetPoint;	
	CSplinePoint			pSpPoint;
	double					dSumDist,dSumCnt,dMaxAvg;
	double					dAvg=0.,dSum=0.,dDist=0.;				
	double					dOutX,dOutY;	
	std::vector<double>		vecDist;
	CSplinePoint			splinePos;
	double					dtemp[2];
	int						nCountDy = 0;
	CPoint					pointCadCenter;
	CPoint					pointGlassCenter;
	CRect					rectEdge;
	int						nInterval;
	int						nWhiteThres = (int)((double)m_InsParm.nChipThres*1.5);

	ZeroMemory(dtemp,sizeof(double)*2);

	for(it=m_mapMaster.begin();it!=m_mapMaster.end();it++)
	{
		pointOrg = static_cast<CPoint>(it->second);	
		if(pointOrg.y == pOrg.GetHeight()/2)
		{
			pointCadCenter.x=pointOrg.x;
			pointCadCenter.y=pointOrg.y;
		}
	}

	rectEdge = CRect(0,nCenY-1,pOrg.GetWidth(),nCenY+1);

	CEdgeFind		EdgeFind;
	CEdgeProc		EdgeProc;

	pointGlassCenter.x = (int)EdgeFind.FindGlassHorizontalLine(pOrg.GetDataAddress(0,0),CSize(pOrg.GetDataWidth(),pOrg.GetHeight()),rectEdge,m_InsParm.nEdgeThres,TRUE);
	pointGlassCenter.y = nCenY;

	dFeedbackXY[0] = pointGlassCenter.x - pointCadCenter.x;
	dFeedbackXY[1] = pointGlassCenter.y - pointCadCenter.y;

	TRACE("=====================================================================\r\n");
	TRACE("Inspect Start\r\n");

	//m_Log.DisplayEdgeLog("=====================================================================");
	//m_Log.DisplayEdgeLog("Inspect Start icam [%d] iscan [%d]",icam,iscan);

	*dAvgThick = dSumThick = dThickCnt = 0.;
	dSumDist = dSumCnt = dMaxAvg = 0;	

	pLinedata = new sPoint[nLineSampleDet];
	pDetPoint = new CDetectPoint[nLineSampleDet];
	for(it=m_mapMaster.begin();it!=m_mapMaster.end();it++)//m_mapMaster´Â cad µµ¸éÀÇ Áß½ÉÀ» À̹ÌÁöÀÇ Áß½ÉÀ¸·Î offset½ÃŲ Cadµµ¸é
	{		
		pointOrg = static_cast<CPoint>(it->second);	

		if(pointOrg.x < nGlass2Edge+10)
			continue;

		pLinedata[nCount].x = pointOrg.x;
		pLinedata[nCount].y = pointOrg.y;
		nCount++;
		if(nCount >= nLineSampleDet)
		{
			dAdjustTheta = EdgeProc.GetTheta(pLinedata,nLineSampleDet,5);						
			ZeroMemory(pDetPoint,sizeof(CDetectPoint)*nLineSampleDet);
			nCount = 0;		

			TRACE("X=%d Y=%d Theta=%.2f\n",pointOrg.x,pointOrg.y,dAdjustTheta);

			for(iCnt=0;iCnt<nLineSampleDet;iCnt++)
			{
				pointOrg.x = pointSet.x = (int)pLinedata[iCnt].x;
				pointOrg.y = pointSet.y = (int)pLinedata[iCnt].y;														
				if(dAdjustTheta <= 90)
				{
					pointOrg.x -= nDetOffset;		
					nInterval = 1;
				}
				else
				{
					pointOrg.x += nDetOffset;		
					nInterval = -1;
				}

				pDetPoint[iCnt].dDist = INT_MAX;
				pDetPoint[iCnt].bFind = FALSE;

				splinePos.Reset();
				splinePos.dThick = INT_MAX;	

				for(int iU=-1*nDetOffset;iU<nDetOffset;iU++)
				{	
					EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				

					if(dOutX < 0 || dOutY < 0 || (int)dOutX >= pTgt.GetWidth() || (int)dOutY >= pTgt.GetHeight())
						continue;

					//nValue = m_Labelling.GetSplineValue(m_EdgeFind,pTgt,dOutX,dOutY);

					nValue = *pTgt.GetDataAddress((int)dOutX,(int)dOutY);					

					if(pDetPoint[iCnt].bFind == FALSE)
					{
						if(nValue > 0)
						{
							dDist = sqrt(pow(((double)pointSet.x-dOutX),2)+pow(((double)pointSet.y-dOutY),2));

							if(pDetPoint[iCnt].dDist > dDist)
							{
								pDetPoint[iCnt].orgX = pointSet.x;
								pDetPoint[iCnt].orgY = pointSet.y;
								pDetPoint[iCnt].imgX = dOutX;
								pDetPoint[iCnt].imgY = dOutY;
								pDetPoint[iCnt].dTheta = dAdjustTheta;
								pDetPoint[iCnt].dDist = dDist;
								pDetPoint[iCnt].bFind = TRUE;
							}
						}	
					}		

					if(splinePos.bFind == FALSE)
					{
					//	if(m_InsParm.bChipIns == TRUE)
						{
							nOrgVal = *pOrg.GetDataAddress((int)dOutX,(int)dOutY);
							if(nOrgVal >= nWhiteThres)
							{
								dDist = sqrt(pow(((double)pointSet.x-dOutX),2)+pow(((double)pointSet.y-dOutY),2));
								if(splinePos.dThick > dDist)
								{
									splinePos.dThick = dDist;
									splinePos.origin = pointSet;
									splinePos.rotate = CPoint((int)dOutX,(int)dOutY);
									splinePos.dTheta = dAdjustTheta;
									splinePos.bFind = TRUE;
								}						
							}						
						}
					}
					//TRACE("pDetPoint[iCnt].orgX = %d pDetPoint[iCnt].orgY = %d pDetPoint[iCnt].imgX = %d pDetPoint[iCnt].imgY = %d pDetPoint[iCnt].dDist = %.2f splinePos.rotate.x = %d splinePos.rotate.y = %d splinePos.dThick = %.2f\n", (int)pDetPoint[iCnt].orgX,(int)pDetPoint[iCnt].orgY,(int)pDetPoint[iCnt].imgX,(int)pDetPoint[iCnt].imgY,pDetPoint[iCnt].dDist,splinePos.rotate.x,splinePos.rotate.y,splinePos.dThick);
					//TRACE("pointSet.x %d pointSet.y %d pointOrg.x %d pointSet.y %d dOutX %d dOutY %d\n",pointSet.x,pointSet.y,pointOrg.x,pointSet.y,(int)dOutX,(int)dOutY);
					pointOrg.x += nInterval;
				}	

				if(splinePos.dThick != INT_MAX && pDetPoint[iCnt].dDist != INT_MAX)
				{
					splinePos.dThick = sqrt(pow(((double)pDetPoint[iCnt].imgX-splinePos.rotate.x),2)+pow(((double)pDetPoint[iCnt].imgY-splinePos.rotate.y),2));
					m_mapChipData.push_back(std::make_pair(splinePos.origin.y, splinePos));									

					if(splinePos.dThick < 20)
					{
						dSumThick += splinePos.dThick;
						dThickCnt++;
					}

					//TRACE("pDetPoint[iCnt].orgX = %d pDetPoint[iCnt].orgY = %d pDetPoint[iCnt].imgX = %d pDetPoint[iCnt].imgY = %d pDetPoint[iCnt].dDist = %.2f splinePos.rotate.x = %d splinePos.rotate.y = %d splinePos.dThick = %.2f\n", (int)pDetPoint[iCnt].orgX,(int)pDetPoint[iCnt].orgY,(int)pDetPoint[iCnt].imgX,(int)pDetPoint[iCnt].imgY,pDetPoint[iCnt].dDist,splinePos.rotate.x,splinePos.rotate.y,splinePos.dThick);
				}

				if(splinePos.dThick == INT_MAX)
				{
					while(!splinePos.bFind)
					{
						pointOrg.x += nInterval;

						EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				

						if(dOutX < 0 || dOutY < 0 || (int)dOutX >= pTgt.GetWidth() || (int)dOutY >= pTgt.GetHeight())
							break;

						if(splinePos.bFind == FALSE)
						{
						//	if(m_InsParm.bChipIns == TRUE)
							{
								nOrgVal = *pOrg.GetDataAddress((int)dOutX,(int)dOutY);
								if(nOrgVal >= m_InsParm.nChipThres)
								{
									dDist = sqrt(pow(((double)pointSet.x-dOutX),2)+pow(((double)pointSet.y-dOutY),2));
									if(splinePos.dThick > dDist)
									{
										splinePos.dThick = dDist;
										splinePos.origin = pointSet;
										splinePos.rotate = CPoint((int)dOutX,(int)dOutY);
										splinePos.dTheta = dAdjustTheta;
										splinePos.bFind = TRUE;
									}						
								}						
							}
						}						
					}
					//TRACE("pDetPoint[iCnt].orgX = %d pDetPoint[iCnt].orgY = %d pDetPoint[iCnt].imgX = %d pDetPoint[iCnt].imgY = %d pDetPoint[iCnt].dDist = %.2f splinePos.rotate.x = %d splinePos.rotate.y = %d splinePos.dThick = %.2f\n", (int)pDetPoint[iCnt].orgX,(int)pDetPoint[iCnt].orgY,(int)pDetPoint[iCnt].imgX,(int)pDetPoint[iCnt].imgY,pDetPoint[iCnt].dDist,splinePos.rotate.x,splinePos.rotate.y,splinePos.dThick);

					if(splinePos.dThick != INT_MAX)
					{
						splinePos.dThick = sqrt(pow(((double)pDetPoint[iCnt].imgX-splinePos.rotate.x),2)+pow(((double)pDetPoint[iCnt].imgY-splinePos.rotate.y),2));
						m_mapChipData.push_back(std::make_pair(splinePos.origin.y, splinePos));									
					}
				}

				//m_Log.DisplayEdgeLog("icam [%d] iscan [%d] pDetPoint[iCnt].orgX = %d pDetPoint[iCnt].orgY = %d pDetPoint[iCnt].imgX = %d pDetPoint[iCnt].imgY = %d pDetPoint[iCnt].dDist = %.2f splinePos.rotate.x = %d splinePos.rotate.y = %d splinePos.dThick = %.2f\n", icam,iscan,(int)pDetPoint[iCnt].orgX,(int)pDetPoint[iCnt].orgY,(int)pDetPoint[iCnt].imgX,(int)pDetPoint[iCnt].imgY,pDetPoint[iCnt].dDist,splinePos.rotate.x,splinePos.rotate.y,splinePos.dThick);
			}	

			int		iHorCnt,nDetCnt=0;
			double  dSum=0;
			dAvg = 0;
			for(iHorCnt=0;iHorCnt<nLineSampleDet;iHorCnt++)
			{
				if(/*pDetPoint[iHorCnt].dDist > 1 && */pDetPoint[iHorCnt].bFind == TRUE)
				{
					dSum += pDetPoint[iHorCnt].dDist;
					nDetCnt++;					
				}
			}

			if(nDetCnt >= nDEF_LINE_COUNT)
			{
				if(dSum == 0)
					dAvg = 0;
				else
					dAvg = dSum/(double)nDetCnt;
			}			

			if(dMaxAvg < dAvg)
				dMaxAvg = dAvg;

			/*if(dAvg > 1)*/
			{				
				//	DrawImgRect(pTgt,pDetPoint[nDetIdx].imgX,pDetPoint[nDetIdx].imgY,100);

				dSumDist += dAvg;
				dSumCnt++;				
			}

			vecDist.push_back(dAvg);
		}
	}

	delete[] pLinedata, pLinedata=NULL;
	delete[] pDetPoint, pDetPoint=NULL;

	TRACE("=====================================================================\r\n");
	//m_Log.DisplayEdgeLog("=====================================================================");

	dResult[0] = dMaxAvg;
	if(dSumCnt > 0)
		dResult[1] = dSumDist/dSumCnt;
	else
		dResult[1] = 0;

	if((int)vecDist.size() > 5)
	{
		int			nJumpVal = (int)vecDist.size()/5;
		int			nIndex = 0;

		if(nJumpVal <= 0)
			return TRUE;

		dSumDist = 0;
		dSumCnt = 1;
		for(std::vector<double>::iterator it=vecDist.begin();it!=vecDist.end();it++,dSumCnt++)
		{
			dSumDist += *it;

			if(nIndex == 4)
			{
				if(dSumCnt >= (nJumpVal+vecDist.size()%5))
				{			
					if(nIndex >= 5)
						break;

					dRangeRes[nIndex] = dSumDist/dSumCnt;

					dSumDist = dSumCnt = 0;
					nIndex++;
				}
			}
			else
			{
				if(dSumCnt >= nJumpVal)
				{			
					if(nIndex >= 5)
						break;

					dRangeRes[nIndex] = dSumDist/dSumCnt;

					dSumDist = dSumCnt = 0;
					nIndex++;
				}
			}
		}
	}

	if(dThickCnt > 0)
		*dAvgThick = dSumThick/dThickCnt;

	TRACE("dAvgThick=%.2f, dSumThick=%.2f, dThickCnt=%.2f\n",*dAvgThick,dSumThick,dThickCnt);

	return TRUE;
}

int	CNotchCut::CropDataXY2(std::multimap<int,CSplinePoint> *mapCrop,std::multimap<int,CSplinePoint> *mapDist,int nStartX,int nFirstY,int nLastY,double *dResDist)
{
	std::multimap<int,CSplinePoint>::iterator it;
	CSplinePoint		spPoint;
	double				dSum,dCnt;
	int					nContiBrokenCnt = 0;
	BOOL				bBroken = FALSE;
// 	CPoint				pointBroken = CPoint(0,0);
// 	int					nBrokenSize = (int)((double)m_InsParm.nSizeDiff/m_InsParm.dCamRes*2);

	dSum = dCnt = 0;
	dResDist[0] = dResDist[1] = -1;

	for(it=mapDist->begin();it!=mapDist->end();it++)
	{
		spPoint = static_cast<CSplinePoint>(it->second);

		if(spPoint.rotate.x < nStartX || spPoint.rotate.y < nFirstY || spPoint.rotate.y > nLastY)
		{
			TRACE("[%d,%d] [%d,%d] => [%.3f] nStartX[%d] nFirstY[%d] nLastY[%d]\n",spPoint.origin.x,spPoint.origin.y,spPoint.rotate.x,spPoint.rotate.y,spPoint.dThick,nStartX,nFirstY,nLastY);//20140528
			continue;
		}

//		mapCrop->insert(std::make_pair(spPoint.rotate.y, spPoint));//20140528
		mapCrop->insert(std::make_pair(spPoint.origin.y, spPoint));//20140528
		dSum += fabs(spPoint.dThick);
		dCnt++;
		if(fabs(spPoint.dThick) > dResDist[0])
			dResDist[0] = spPoint.dThick;

// 		if(spPoint.dThick >= nBrokenSize && bBroken == FALSE)
// 		{
// 			if(nContiBrokenCnt == 0)
// 			{
// 				pointBroken = spPoint.origin;
// 			}
// 			nContiBrokenCnt++;
// 			if(nContiBrokenCnt >= DETECT_BROKEN_COUNT)
// 				bBroken = TRUE;
// 		}
// 		else
// 		{
// 			nContiBrokenCnt = 0;
// 		}

//		TRACE("[%d,%d] [%d,%d] => [%.3f]\n",spPoint.origin.x,spPoint.origin.y,spPoint.rotate.x,spPoint.rotate.y,spPoint.dThick);//20140528
	}

	if(dCnt > 0)
		dResDist[1] = dSum/dCnt;

// 	if(bBroken == TRUE)
// 	{
// 		SetBrokenDefect(pointBroken);
// 	}

	return (int)mapCrop->size();
}

int	CNotchCut::CropDataXY2_Chamfer(std::multimap<int,CSplinePoint> *mapCrop,std::multimap<int,CSplinePoint> *mapChamfer,int nStartX,int nFirstY,int nLastY)//20140528
{
	std::multimap<int,CSplinePoint>::iterator it;
	CSplinePoint		spPoint;
		
	for(it=mapChamfer->begin();it!=mapChamfer->end();it++)
	{
		spPoint = static_cast<CSplinePoint>(it->second);

		if(spPoint.rotate.x < nStartX || spPoint.rotate.y < nFirstY || spPoint.rotate.y > nLastY)
		{
			TRACE("[%d,%d] [%d,%d] => [%.3f] nStartX[%d] nFirstY[%d] nLastY[%d]\n",spPoint.origin.x,spPoint.origin.y,spPoint.rotate.x,spPoint.rotate.y,spPoint.dThick,nStartX,nFirstY,nLastY);
			continue;
		}

		mapCrop->insert(std::make_pair(spPoint.origin.y, spPoint));
	}

	return (int)mapCrop->size();
}

CSplinePoint CNotchCut::FindCenter2Vec(std::multimap<int,CSplinePoint> *mapCrop,int nCenY,int *nPosition)
{
	CSplinePoint	spPoint,vecPoint;
	int				nDist = INT_MAX,nLoop = 0;
	std::multimap<int,CSplinePoint>::iterator it;
	
	spPoint.rotate = CPoint(INT_MAX,INT_MAX);
	
	*nPosition = -1;
	for(it=mapCrop->begin();it!=mapCrop->end();it++,nLoop++)
	{
		vecPoint = static_cast<CSplinePoint>(it->second);
		if(abs(vecPoint.rotate.y-nCenY) < nDist)
		{
			spPoint = vecPoint;
			nDist = abs(vecPoint.rotate.y-nCenY);
			*nPosition = nLoop;
		}		
	}

	return spPoint;
}

void CNotchCut::GetRangeAvgThick(std::multimap<int,CSplinePoint> *mapCrop,pNOTCH_RangePos_STU pReangeRes,CSplinePoint spCenter,int nRangeCnt)
{
	double		dSum,dCnt;
	int			nMin,nMax;
	std::multimap<int,CSplinePoint>::iterator itFirst,itLast;

	nMin = spCenter.rotate.y - nRangeCnt/2;
	nMax = spCenter.rotate.y + nRangeCnt/2;

	itFirst = mapCrop->lower_bound(nMin);
	itLast = mapCrop->upper_bound(nMax);
	
	if(itFirst == mapCrop->end() || itLast == mapCrop->end())
		return;

	dSum = dCnt = 0;
	CSplinePoint	vecPoint;
	for(;itFirst!=itLast;itFirst++)
	{
		vecPoint = static_cast<CSplinePoint>(itFirst->second);

		dSum += vecPoint.dThick;
		dCnt++;
		if(dCnt == (nRangeCnt/2+1))
		{
			pReangeRes->pointCAD = vecPoint.origin;
			pReangeRes->pointImg = vecPoint.rotate;
		}
	}
	
	pReangeRes->dDist = dCnt>0?dSum/dCnt:0;
}

void CNotchCut::GetRangeAvgThick_New(std::multimap<int,CSplinePoint> *mapCrop,pNOTCH_RangePos_STU pReangeRes,CPoint point,int nRangeCnt)//20140528
{
	double		dSum,dCnt;
	int			nMin,nMax;
	std::multimap<int,CSplinePoint>::iterator itFirst,itLast;

	nMin = point.y - nRangeCnt/2;
	nMax = point.y + nRangeCnt/2;

	itFirst = mapCrop->lower_bound(nMin);
	itLast = mapCrop->upper_bound(nMax);

	if(itFirst == mapCrop->end() || itLast == mapCrop->end())
		return;

	dSum = dCnt = 0;
	CSplinePoint	vecPoint;
	for(;itFirst!=itLast;itFirst++)
	{
		vecPoint = static_cast<CSplinePoint>(itFirst->second);

		dSum += vecPoint.dThick;
		dCnt++;
		if(dCnt == (nRangeCnt/2+1))
		{
			pReangeRes->pointCAD = vecPoint.origin;
			pReangeRes->pointImg = vecPoint.rotate;
		}
	}
	
	if(dCnt > 0)
	{
		pReangeRes->dDist = dSum/dCnt;
		pReangeRes->nInsCount = (int)dCnt;
	}
	else
	{
		vecPoint = static_cast<CSplinePoint>(itFirst->second);
		pReangeRes->pointCAD = vecPoint.origin;
		pReangeRes->pointImg = vecPoint.rotate;
		pReangeRes->dDist = vecPoint.dThick;
		pReangeRes->nInsCount = 1;
	}	
}

void CNotchCut::GetRangeAvgThick_New_Cham(std::multimap<int,CSplinePoint> *mapCropChamfer,pNOTCH_RangePos_STU pReangeRes,CPoint point,int nRangeCnt)
{
	double		dSum,dCnt;
	int			nMin,nMax;
	std::multimap<int,CSplinePoint>::iterator itFirst,itLast;

	nMin = point.y - nRangeCnt/2;
	nMax = point.y + nRangeCnt/2;

	itFirst = mapCropChamfer->lower_bound(nMin);
	itLast = mapCropChamfer->upper_bound(nMax);

	if(itFirst == mapCropChamfer->end() || itLast == mapCropChamfer->end())
		return;

	dSum = dCnt = 0;
	CSplinePoint	vecPoint;
	for(;itFirst!=itLast;itFirst++)
	{
		vecPoint = static_cast<CSplinePoint>(itFirst->second);

		dSum += vecPoint.dThick;
		dCnt++;
		if(dCnt == (nRangeCnt/2+1))
		{
			pReangeRes->pointCAD = vecPoint.origin;
			pReangeRes->pointImg = vecPoint.rotate;
		}
	}

	if(dCnt > 0)
	{
		pReangeRes->dDist = dSum/dCnt;
		pReangeRes->nInsCount = (int)dCnt;
	}
	else
	{
		vecPoint = static_cast<CSplinePoint>(itFirst->second);
		pReangeRes->pointCAD = vecPoint.origin;
		pReangeRes->pointImg = vecPoint.rotate;
		pReangeRes->dDist = vecPoint.dThick;
		pReangeRes->nInsCount = 1;
	}	
}

int CNotchCut::GetRangeDivThick(std::multimap<int, CSplinePoint> *mapCrop,CSplinePoint	spCenter,int nCenterPos,pNOTCH_RangePos_STU pRangeRes,int nRangeCnt,BOOL bOpt,int nDivRange)
{
	int		nDivCnt,iCnt,iIndex;
	int		nHalfCnt = nRangeCnt/2;
	std::multimap<int, CSplinePoint>::iterator it,itCenter;

	itCenter = mapCrop->lower_bound(spCenter.rotate.y);
	if(itCenter == mapCrop->end())
		return 0;

	CSplinePoint	spPoint;
	double	dSum,dCnt;
	if(bOpt == TRUE)
	{
		nDivCnt = nCenterPos/(nHalfCnt+1);
		iCnt = iIndex = 0;
		dSum = dCnt = 0.;
		for(it=mapCrop->begin();it!=itCenter;it++,iCnt++)
		{
			if(iCnt >= nDivCnt-nDivRange)
			{
				spPoint = static_cast<CSplinePoint>(it->second);
				dSum += spPoint.dThick;
				dCnt++;

				if(iCnt == nDivCnt)
				{
					if(iIndex >= nRangeCnt)
						return iIndex;
					pRangeRes[iIndex].pointCAD = spPoint.origin;
					pRangeRes[iIndex].pointImg = spPoint.rotate;
				}
				else if(iCnt >= nDivCnt+nDivRange)				
				{
					iCnt = 0;						
					pRangeRes[iIndex].dDist = dSum/dCnt;					
					dSum = dCnt = 0.;
					iIndex++;
				}				
			}
		}
	}
	else
	{
		iIndex = nHalfCnt+1;

		nDivCnt = (int)(mapCrop->size()-nCenterPos)/(nHalfCnt+1);
		iCnt = 0;
		dSum = dCnt = 0.;
		for(it=itCenter;it!=mapCrop->end();it++,iCnt++)
		{
			if(iCnt >= nDivCnt-nDivRange)
			{
				spPoint = static_cast<CSplinePoint>(it->second);
				dSum += spPoint.dThick;
				dCnt++;

				if(iCnt == nDivCnt)
				{
					if(iIndex >= nRangeCnt)
						return iIndex;
					pRangeRes[iIndex].pointCAD = spPoint.origin;
					pRangeRes[iIndex].pointImg = spPoint.rotate;
				}
				else if(iCnt >= nDivCnt+nDivRange)				
				{
					iCnt = 0;						
					pRangeRes[iIndex].dDist = dSum/dCnt;					
					dSum = dCnt = 0.;
					iIndex++;
				}					
			}
		}
	}

	return iIndex;
}

void CNotchCut::CalRangeVal(std::multimap<int,CSplinePoint>	*mapDist,double *dResDist,pNOTCH_RangePos_STU dRangeRes,int nRangeCnt,int nCenX,int nCenY,int nStartX,int nFirstY,int nLastY)
{
	if(dRangeRes == NULL || nRangeCnt <= 0 || (int)mapDist->size() <= 0)
	{
		return;
	}
	
	std::multimap<int, CSplinePoint> mapCrop;	

	if(CropDataXY2(&mapCrop,mapDist,nStartX,nFirstY,nLastY,dResDist) <= 0)
	{
		return;
	}

	CSplinePoint	spCenter;
	int				nCenterPosition;

	spCenter = FindCenter2Vec(&mapCrop,nCenY,&nCenterPosition);	
	if(nCenterPosition <= 0 || spCenter.rotate.x == INT_MAX || spCenter.rotate.y == INT_MAX)
	{
		return;
	}

	const int RANGE_AVG_COUNT = 5;
	int			nHalfCnt = nRangeCnt/2;

	GetRangeAvgThick(&mapCrop,&dRangeRes[nHalfCnt],spCenter,RANGE_AVG_COUNT);

	if(nHalfCnt > 0)
	{
		GetRangeDivThick(&mapCrop,spCenter,nCenterPosition,dRangeRes,nRangeCnt,TRUE,RANGE_AVG_COUNT/2);
		GetRangeDivThick(&mapCrop,spCenter,nCenterPosition,dRangeRes,nRangeCnt,FALSE,RANGE_AVG_COUNT/2);
	}	
}

void CNotchCut::CalRangeVal_New(std::multimap<int,CSplinePoint>	*mapDist,std::multimap<int,CSplinePoint> *mapDist_Dy,double *dResDist,double *dResDist_Dy,pNOTCH_RangePos_STU dRangeRes,pNOTCH_RangePos_STU dRangeRes_Dy,pNOTCH_RangePos_STU dRangeRes_Cham,int nRangeCnt,int nCenX,int nCenY,int nStartX,int nFirstY,int nLastY,std::multimap<int,CSplinePoint> *mapChamfer)//20140528
{
	if(dRangeRes == NULL || dRangeRes_Dy == NULL || dRangeRes_Cham == NULL || nRangeCnt <= 0 || (int)mapDist->size() <= 0 || (int)mapDist_Dy->size() <= 0)
	{
		return;
	}

	std::multimap<int, CSplinePoint> mapCrop;	
	
	if(CropDataXY2(&mapCrop,mapDist,nStartX,nFirstY,nLastY,dResDist) <= 0)
	{
		return;
	}

	std::multimap<int, CSplinePoint> mapCrop_Dy;	

	if(CropDataXY2(&mapCrop_Dy,mapDist_Dy,nStartX,nFirstY,nLastY,dResDist_Dy) <= 0)
	{
		return;
	}

	std::multimap<int, CSplinePoint> mapCropChamfer;	

	if(CropDataXY2_Chamfer(&mapCropChamfer,mapChamfer,nStartX,nFirstY,nLastY) <= 0)
	{
		return;
	}

	const int RANGE_AVG_COUNT = m_InsParm.nPointInsAveCount;
	vector<pair<int,CPoint>>::iterator	it;
	CPoint	pointData;
	int nIndex;
	
	//for (int i=0; i<nRangeCnt; i++)
	{
		for(it=m_mapMaster_InsPos.begin();it!=m_mapMaster_InsPos.end();it++)
		{
			nIndex = static_cast<int>(it->first);
			pointData = static_cast<CPoint>(it->second);

			GetRangeAvgThick_New(&mapCrop,&dRangeRes[nIndex],pointData,RANGE_AVG_COUNT);
			GetRangeAvgThick_New(&mapCrop_Dy,&dRangeRes_Dy[nIndex],pointData,RANGE_AVG_COUNT);
			GetRangeAvgThick_New_Cham(&mapCropChamfer,&dRangeRes_Cham[nIndex],pointData,RANGE_AVG_COUNT);
		}		
	}
}

void CNotchCut::DrawImgRect(CSISBuffer &pOrg,double dX,double dY,int nValue)
{
	CRect		rect;
	int			nRange = 5;
	int			u,v;

	rect.left = (int)dX - nRange;
	rect.right = rect.left + nRange*2;
	rect.top = (int)dY - nRange;
	rect.bottom = rect.top + nRange*2;

	AssertRect(rect,pOrg);

	for(u=rect.left;u<=rect.right;u++)
	{
		pOrg.SetPixel(u,rect.top,nValue);
		pOrg.SetPixel(u,rect.bottom,nValue);
	}

	for(v=rect.top;v<=rect.bottom;v++)
	{
		pOrg.SetPixel(rect.left,v,nValue);
		pOrg.SetPixel(rect.right,v,nValue);
	}
}

void CNotchCut::MakeReal2Cad_Image(CSISBuffer &pOrg,COwnerBuffer &pRes,int nValue)
{
	if((int)m_mapMaster.size() <= 0)
		return;	

	pRes.SetSize(pOrg.GetWidth(),pOrg.GetHeight());

	CopyMemory(pRes.GetDataAddress(0,0),pOrg.GetDataAddress(0,0),pOrg.GetDataSize());	

	vector<pair<int,CPoint>>::iterator	it;
	CPoint	pointData;

	for(it=m_mapMaster.begin();it!=m_mapMaster.end();it++)
	{
		pointData = static_cast<CPoint>(it->second);

		if(pointData.x < 0 || pointData.y < 0 || pointData.x >= pOrg.GetWidth() || pointData.y >= pOrg.GetHeight())
			continue;

		pRes.SetPixel(pointData.x,pointData.y,nValue);
	}
}

void CNotchCut::MakeReal2AlignCad(CSISBuffer &pOrg,int nCenY,int nForeX, int iDimension, int icam)
{	
	if(iDimension < 0 || iDimension >= MAX_NOTCH_SCAN_COUNT || (int)m_mapAlignMaster[iDimension].size() <= 0)
		return;

	COwnerBuffer		pTgt(pOrg.GetWidth(),pOrg.GetHeight());

	CopyMemory(pTgt.GetDataAddress(0,0),pOrg.GetDataAddress(0,0),pOrg.GetDataSize());	

	std::multimap<int, CPoint>::iterator	it;
	CPoint	pointData,pointMove;

	pointMove.x = nForeX-m_AlignMasterParm[iDimension].nPosX;
	pointMove.y = pOrg.GetHeight()/2-m_AlignMasterParm[iDimension].nPosY;

	m_AlignMasterParm[iDimension].nMaxX += pointMove.x;
	m_AlignMasterParm[iDimension].nPosX += pointMove.x;
	m_AlignMasterParm[iDimension].nMaxY += pointMove.y;

	for(it=m_mapAlignMaster[iDimension].begin();it!=m_mapAlignMaster[iDimension].end();it++)
	{
		pointData = static_cast<CPoint>(it->second);

		pointData.Offset(pointMove.x,pointMove.y);		

		if(pointData.x < 0 || pointData.y < 0 || pointData.x >= pOrg.GetWidth() || pointData.y >= pOrg.GetHeight())
			continue;

		pTgt.SetPixel(pointData.x,pointData.y,200);

		m_mapMaster.push_back(std::make_pair(pointData.y, pointData));
	}

	std::sort(m_mapMaster.begin(),m_mapMaster.end(),SortYPos());

	int nIndex = 0;//20140528

	for(it=m_mapAlignMaster_InsPos[iDimension].begin();it!=m_mapAlignMaster_InsPos[iDimension].end();it++)//20140528
	{
		pointData = static_cast<CPoint>(it->second);

		pointData.Offset(pointMove.x,pointMove.y);		

		if(pointData.x < 0 || pointData.y < 0 || pointData.x >= pOrg.GetWidth() || pointData.y >= pOrg.GetHeight())
			continue;

		pTgt.SetPixel(pointData.x,pointData.y,128);

		m_mapMaster_InsPos.push_back(std::make_pair(nIndex++, pointData));
	}

	std::sort(m_mapMaster_InsPos.begin(),m_mapMaster_InsPos.end(),ResSortYPos());//20140528

	if(m_bSaveDebug == TRUE)
	{
		CString				str;
		str.Format(_T("%s\\5.Real2Cad_%d_%d_[%d,%d].bmp"),m_strSavePath,icam,iDimension,m_AlignMasterParm[iDimension].nMaxX,m_AlignMasterParm[iDimension].nMaxY);
		CBufferAttach		attach(str);
		attach.AttachToFile(pTgt);
	}
}

void CNotchCut::MakeReal2Cad(CSISBuffer &pOrg,int nCenX,int nCenY, int iDimension, int icam)
{	
	if(iDimension < 0 || iDimension >= MAX_NOTCH_SCAN_COUNT || (int)m_mapOrgMaster[iDimension].size() <= 0)
		return;

	COwnerBuffer		pTgt(pOrg.GetWidth(),pOrg.GetHeight());

	CopyMemory(pTgt.GetDataAddress(0,0),pOrg.GetDataAddress(0,0),pOrg.GetDataSize());	

	std::multimap<int, CPoint>::iterator	it;
	CPoint	pointData,pointMove;

	pointMove.x = nCenX-m_MasterParm[iDimension].nPosX;
	pointMove.y = pOrg.GetHeight()/2-m_MasterParm[iDimension].nPosY;
	TRACE("¿øº» ¿µ»ó X=%d, Y=%d, ¿µ»ó ÀÚü Y=%d, CAD X=%d, Y=%d\n",nCenX,nCenY,pOrg.GetHeight()/2,m_MasterParm[iDimension].nPosX,m_MasterParm[iDimension].nPosY);
	for(it=m_mapOrgMaster[iDimension].begin();it!=m_mapOrgMaster[iDimension].end();it++)
	{
		pointData = static_cast<CPoint>(it->second);

		pointData.Offset(pointMove.x,pointMove.y);		

		if(pointData.x < 0 || pointData.y < 0 || pointData.x >= pOrg.GetWidth() || pointData.y >= pOrg.GetHeight())
			continue;

		pTgt.SetPixel(pointData.x,pointData.y,200);

		m_mapMaster.push_back(std::make_pair(pointData.y, pointData));
	}

	std::sort(m_mapMaster.begin(),m_mapMaster.end(),SortYPos());

	if(m_bSaveDebug == TRUE)
	{
		CString				str;
		str.Format(_T("%s\\5.Real2Cad_%d_%d.bmp"),m_strSavePath,icam,iDimension);
		CBufferAttach		attach(str);
		attach.AttachToFile(pTgt);
	}
}

BOOL CNotchCut::ReadModelData(CString strFile, int index)
{
	if(index < 0 || index >= MAX_NOTCH_SCAN_COUNT)
		return FALSE;

	m_mapOrgMaster[index].clear();	
	m_mapAlignMaster[index].clear();		

	if(strFile.IsEmpty() == TRUE)
		return FALSE;

	CFileFind filefind;	
	if(filefind.FindFile(strFile) == FALSE)
		return FALSE;

	CFile			file;

	if(FALSE == file.Open(strFile, CFile::modeRead))
		return FALSE;

	int		nCnt,iLoop;
	CPoint	point;

	file.Read(&nCnt,sizeof(int));	
	for(iLoop=0;iLoop<nCnt;iLoop++)
	{
		file.Read(&point,sizeof(CPoint));		
		m_mapOrgMaster[index].insert(std::make_pair(point.y, point));		
		if(m_MasterParm[index].nMaxX < point.x)
			m_MasterParm[index].nMaxX = point.x;
		if(m_MasterParm[index].nMaxY < point.y)
			m_MasterParm[index].nMaxY = point.y;
	}

	file.Close();

	return TRUE;
}

BOOL CNotchCut::WriteModelData(CString strFile,CString strRecipe,CString strCut,std::multimap<int, CSplinePoint> *pPoint)
{
	if(pPoint == NULL || (int)pPoint->size() <= 0)
		return FALSE;
	if(strFile.IsEmpty() == TRUE)
		return FALSE;

	DeleteFile(strFile);	

	CFile			file;

	if(FALSE == file.Open(strFile, CFile::modeCreate | CFile::modeWrite))
		return FALSE;

	int nCnt = (int)pPoint->size();
	file.Write(&nCnt,sizeof(int));

	CPoint		pointMax(0,0);

	std::multimap<int, CSplinePoint>::iterator itData,itLoop;
	CSplinePoint	*splinePos;

	for(itData=pPoint->begin();itData!=pPoint->end();itData++)
	{		
		splinePos = static_cast<CSplinePoint*>(&itData->second);
		if(splinePos == NULL)
			continue;

		file.Write(&splinePos->origin,sizeof(CPoint));	

		if(pointMax.x < splinePos->origin.x) pointMax.x = splinePos->origin.x;
		if(pointMax.y < splinePos->origin.y) pointMax.y = splinePos->origin.y;
	}

	file.Close();	

	COwnerBuffer		ownerBuf(pointMax.x+10,pointMax.y+10);
	for(itData=pPoint->begin();itData!=pPoint->end();itData++)
	{		
		splinePos = static_cast<CSplinePoint*>(&itData->second);
		if(splinePos == NULL)
			continue;

		if(splinePos->origin.x < 0 || splinePos->origin.y < 0 
			|| splinePos->origin.x >= ownerBuf.GetWidth() || splinePos->origin.y >= ownerBuf.GetHeight())
			continue;

		ownerBuf.SetPixel(splinePos->origin.x,splinePos->origin.y,255);
	}

	CString				strimg;
	strimg.Format(_T("C:\\EdgeInspector_App\\Notch\\%s_%s_org.bmp"),strRecipe,strCut);
	CBufferAttach		attach(strimg);
	attach.AttachToFile(ownerBuf);

	return TRUE;
}

void CNotchCut::SetNotchInsPoint( std::vector<CPoint> *InsPoint , int index)//20140528
{
	std::vector<CPoint>::iterator	it;
	CPoint	point;

	m_mapOrgMaster_InsPos[index].clear();	

	for(it=InsPoint->begin();it!=InsPoint->end();it++)
	{

		point = *it;
		
		if(point.x < 0 || point.y < 0)
			continue;

		m_mapOrgMaster_InsPos[index].insert(std::make_pair(point.y, point));		
	}	
}