#include "StdAfx.h"
#include "SplineInspect.h"
#include <math.h>
#include <algorithm>
#include "ChamferInspect.h"
#include "Edge_Log.h"

const int g_SearchDirection[8][2] = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};

CSplineModel::CSplineModel(void)
{	
	ClearModelData();	
}

CSplineModel::~CSplineModel(void)
{	
	ClearModelData();
}

void CSplineModel::ClearModelData()
{
	m_pointMasterMax = m_pointMasterMin =  CPoint(0,0);	
	m_bLoadMasterImg = FALSE;			
	m_strLoadModel = "";
	m_mapMasterPos.clear();	
}

BOOL CSplineModel::CopyModelData(CSplineModel *pSpline)
{
	m_bLoadMasterImg = FALSE;
	m_mapMasterPos.clear();
	m_pointMasterMax = CPoint(0,0);
	m_pointMasterMin = CPoint(INT_MAX,INT_MAX);

	if(pSpline == NULL)
		return FALSE;

	m_strLoadModel = pSpline->m_strLoadModel;
	m_bLoadMasterImg = pSpline->m_bLoadMasterImg;
	m_pointMasterMax = pSpline->m_pointMasterMax;
	m_pointMasterMin = pSpline->m_pointMasterMin;

	CPoint		pointOrg;
	std::multimap<int, CPoint>::iterator	it;
	for(it=pSpline->m_mapMasterPos.begin();it!=pSpline->m_mapMasterPos.end();it++)
	{		
		pointOrg = static_cast<CPoint>(it->second);	
		m_mapMasterPos.insert(std::make_pair(pointOrg.x, pointOrg));
	}

	return TRUE;
}

BOOL CSplineModel::ReadModelData(CString strFile,CString strRecipe)
{	
	m_bLoadMasterImg = FALSE;
	m_mapMasterPos.clear();
	m_pointMasterMax = CPoint(0,0);
	m_pointMasterMin = CPoint(INT_MAX,INT_MAX);
	const	int		MASTER_OFFSET = 100;		// Rotation ¿µ¿ª È®º¸¸¦ À§Çؼ­.

	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));
		point.Offset(MASTER_OFFSET,MASTER_OFFSET);
		m_mapMasterPos.insert(std::make_pair(point.x, point));		
		if(point.x > m_pointMasterMax.x) m_pointMasterMax.x = point.x;
		if(point.y > m_pointMasterMax.y) m_pointMasterMax.y = point.y;
		if(point.x < m_pointMasterMin.x) m_pointMasterMin.x = point.x;
		if(point.y < m_pointMasterMin.y) m_pointMasterMin.y = point.y;
	}

	file.Close();

	int		*nPosCnt_X = new int[m_pointMasterMax.x+1];
	int		*nPosCnt_Y = new int[m_pointMasterMax.y+1];
	ZeroMemory(nPosCnt_X,sizeof(int)*(m_pointMasterMax.x+1));
	ZeroMemory(nPosCnt_Y,sizeof(int)*(m_pointMasterMax.y+1));

	CPoint	pointData;
	std::multimap<int, CPoint>::iterator	it;	
	for(it=m_mapMasterPos.begin();it!=m_mapMasterPos.end();it++)
	{
		pointData = static_cast<CPoint>(it->second);
		if(RANGEIN(pointData.x,0,m_pointMasterMax.x) == TRUE)
			nPosCnt_X[pointData.x]++;
		if(RANGEIN(pointData.y,0,m_pointMasterMax.y) == TRUE)
			nPosCnt_Y[pointData.y]++;
	}

	int		nMaxCnt = 0;

	for(iLoop=0;iLoop<=m_pointMasterMax.x;iLoop++)
	{
		if(nPosCnt_X[iLoop] > nMaxCnt)
		{
			nMaxCnt = nPosCnt_X[iLoop];
			m_pointMasterMin.x = iLoop;
		}
	}
	nMaxCnt = 0;
	for(iLoop=0;iLoop<=m_pointMasterMax.y;iLoop++)
	{
		if(nPosCnt_Y[iLoop] > nMaxCnt)
		{
			nMaxCnt = nPosCnt_Y[iLoop];
			m_pointMasterMin.y = iLoop;
		}
	}

	delete[] nPosCnt_X,nPosCnt_X=NULL;
	delete[] nPosCnt_Y,nPosCnt_Y=NULL;
	m_bLoadMasterImg = TRUE;	
	m_strLoadModel = strRecipe;

	return TRUE;
}

BOOL CSplineModel::WriteCSVData(CString strFile,CPoint *pPoint,int nCnt,CPoint pointOffset)
{
	CStdioFile		studioF;	
	CFileException	ex;

	int			iLoop;	
	CPoint		point;
	CString		strContents,str;

	DeleteFile(strFile);

	for(iLoop=0;iLoop<nCnt;iLoop++)
	{
		point = pPoint[iLoop];		
		//point.Offset(-pointOffset.x,-pointOffset.y);
		str.Format(_T("%d,%d,\n"),point.x,point.y);
		strContents += str;
	}

	if(studioF.Open(strFile, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeWrite|CFile::shareDenyWrite, &ex) == FALSE)
	{
		return FALSE;
	}

	if(strContents.GetLength() > 0)
		studioF.WriteString(strContents);

	studioF.Close();

	return TRUE;
}

BOOL CSplineModel::WriteModelData(CString strFile,CString strRecipe,CString strCut,std::multimap<int, CSplinePoint> *pPoint,CPoint pointOffset)
{
	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;

	AdjustTilt(pPoint);

	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->rotate,sizeof(CPoint));	

		if(pointMax.x < splinePos->rotate.x) pointMax.x = splinePos->rotate.x;
		if(pointMax.y < splinePos->rotate.y) pointMax.y = splinePos->rotate.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->rotate.x < 0 || splinePos->rotate.y < 0 
			|| splinePos->rotate.x >= ownerBuf.GetWidth() || splinePos->rotate.y >= ownerBuf.GetHeight())
			continue;

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

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

	return TRUE;
}

BOOL CSplineModel::AdjustTilt(std::multimap<int, CSplinePoint> *pPos)
{
	double		dAngle,dAdjustAngle;
	double		dCenX,dCenY;
	CEdgeProc	EdgeProc;

	dAngle = GetTilt(pPos,dCenX,dCenY);

	dAdjustAngle = -90-dAngle; 
	/*if(dAdjustAngle == 0)
		return TRUE;*/

	CPoint		pointOut;
	CPoint		pointMin(INT_MAX,INT_MAX);

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

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

		EdgeProc.RotatePoint(splinePos->origin,&pointOut,CPoint((int)dCenX,(int)dCenY),sin(M_RADIAN(dAdjustAngle)), cos(M_RADIAN(dAdjustAngle)));
		splinePos->rotate = pointOut;

		if(splinePos->rotate.x < pointMin.x) pointMin.x = splinePos->rotate.x;
		if(splinePos->rotate.y < pointMin.y) pointMin.y = splinePos->rotate.y;		
	}

	return TRUE;
}

double CSplineModel::GetTilt(std::multimap<int, CSplinePoint> *pPos,double &dCenX,double &dCenY)
{
	int			nRange = 10;
	int			nDiffDist = 200;
	CPoint		pointSum[2];

	if((int)pPos->size() < nRange*2+nDiffDist)
		return 0.;

	std::multimap<int, CSplinePoint>::iterator it;
	vector<pair<int,CSplinePoint>> vec;

	for(it = pPos->begin(); it != pPos->end(); ++it)
	{
		vec.push_back(make_pair(it->second.origin.y,it->second));
	}
	std::sort(vec.begin(),vec.end(),SortOrginYPos());

	ZeroMemory(pointSum,sizeof(CPoint)*2);
	int			iPos;

	iPos = 0;
	CSplinePoint	splinePos;
	for(iPos = 0; iPos < nRange; iPos++)
	{
		splinePos = vec[iPos].second;

		pointSum[0].x += splinePos.origin.x;
		pointSum[0].y += splinePos.origin.y;
	}

	iPos = 0;
	for(iPos = nRange+nDiffDist; iPos < nRange+nDiffDist+nRange; iPos++)	
	{
		splinePos = vec[iPos].second;
		pointSum[1].x += splinePos.origin.x;
		pointSum[1].y += splinePos.origin.y;
	}

	double		dXPos[2],dYPos[2];

	dXPos[0] = (double)pointSum[0].x/(double)nRange;
	dYPos[0] = (double)pointSum[0].y/(double)nRange;
	dXPos[1] = (double)pointSum[1].x/(double)nRange;
	dYPos[1] = (double)pointSum[1].y/(double)nRange;

	dCenX = dXPos[0];
	dCenY = dYPos[0];

	return M_DEGREE( atan2(dYPos[1] - dYPos[0], dXPos[1] - dXPos[0]) );
}

//////////////////////////////////////////////////////////////////////////
CSplineInspect::CSplineInspect(void)
{
	m_pLabelMap = NULL;
	m_lpBuffer = NULL;
	m_pContourMap = NULL;
	m_pContourCnt = NULL;
	m_pSpModel = NULL;
	m_nCCCount = 0;	
	m_szImageOrg = CSize(0,0);	
	m_nDefectCount = 0;	
}

CSplineInspect::CSplineInspect(CSISBuffer *lpBuffer)
{
	m_pLabelMap = NULL;
	m_lpBuffer = NULL;
	m_pContourMap = NULL;	
	m_pContourCnt = NULL;
	m_pSpModel = NULL;
	m_nCCCount = 0;	
	m_szImageOrg = CSize(0,0);	
	SetImage(lpBuffer);
}

CSplineInspect::~CSplineInspect(void)
{	
	ReleaseBuffer();
	ResetValue();
}

void CSplineInspect::ReleaseBuffer()
{
	int		i;

	if(m_pLabelMap != NULL)
	{
		for(i = 0; i < m_szImageOrg.cy; i++)
		{
			if(m_pLabelMap[i] != NULL)
			{
				delete[] m_pLabelMap[i];
				m_pLabelMap[i] = NULL;				
			}
		}
		delete[] m_pLabelMap;
		m_pLabelMap=NULL;
	}

	if(m_pContourMap != NULL)
	{
		for(i = 0; i < m_szImageOrg.cy; i++)
		{
			if(m_pContourMap[i] != NULL)
			{
				delete[] m_pContourMap[i];
				m_pContourMap[i] = NULL;				
			}
		}
		delete[] m_pContourMap;
		m_pContourMap=NULL;
	}
	
	m_nCCCount = 0;

	if(m_pContourCnt != NULL)
		delete[] m_pContourCnt, m_pContourCnt=NULL;

	m_nSplineOffsetX = m_nSplineOffsetY = 0;
	
}


void CSplineInspect::ResetValue()
{
	m_dImageTheta = 0.;
	m_pointPosLeft = m_pointDiffImg = CPoint(0,0);
	m_mapSplinePos.clear();		

	ZeroMemory(m_dResultData,sizeof(double)*SPLINE_RESULT_DATA_CNT);

	m_insSplineOrg.ReleaseSpace();
	m_insSplineRes.ReleaseSpace();

	ReleaseBlob();
}

void CSplineInspect::ReleaseBlob()
{
	m_nDefectCount = 0;
}

BOOL CSplineInspect::FindForeLine(CSISBuffer &pBuffer,int *nForeLine,double &dTheta)
{
	CRect		rectLine;
	int			nSize = 50,nSkipSize=200;	
	int			nVertSkipSize = 50;
	int			u,v;	
	int			nLineCnt;
	CPoint		nLinePos[2];
	int			nDetLine = (int)((double)nSize*0.3);
	BOOL		bRet;		

	nForeLine[0] = nForeLine[1] = -1;
	nLinePos[0] = nLinePos[1] = -1;	

	rectLine = CRect(pBuffer.GetWidth()-nSize-nVertSkipSize,0,pBuffer.GetWidth()-1-nVertSkipSize,pBuffer.GetHeight()-1);		

	bRet = FALSE;
	for(v=rectLine.top;v<rectLine.bottom;v++)	
	{
		if(nLinePos[0].y > 0 && nLinePos[1].y > 0)
		{
			bRet = TRUE;
			break;
		}

		nLineCnt = 0;
		for(u=rectLine.left;u<rectLine.right;u++)
		{
			if(*pBuffer.GetDataAddress(u,v) == 255)
				nLineCnt++;
		}
		if(nLineCnt >= nDetLine)
		{
			nLinePos[0].y = v;
			nLinePos[0].x = rectLine.right;
		}

		nLineCnt = 0;
		for(u=rectLine.left-nSkipSize;u<rectLine.right-nSkipSize;u++)
		{
			if(*pBuffer.GetDataAddress(u,v) == 255)
				nLineCnt++;
		}
		if(nLineCnt >= nDetLine)
		{
			nLinePos[1].y = v;
			nLinePos[1].x = rectLine.left-nSkipSize;
		}
	}

	if(bRet == TRUE)
	{
		nForeLine[1] = (nLinePos[0].y+nLinePos[1].y)/2;		
	}	


	bRet = FALSE;
	nLinePos[0] = nLinePos[1] = -1;

	rectLine = CRect(0,pBuffer.GetHeight()-nSize,pBuffer.GetWidth(),pBuffer.GetHeight()-1);			
	for(u=rectLine.left;u<rectLine.right;u++)
	{
		if(nLinePos[0].x > 0 && nLinePos[1].x > 0)
		{
			bRet = TRUE;
			break;
		}

		nLineCnt = 0;
		for(v=rectLine.top;v<rectLine.bottom;v++)
		{
			if(*pBuffer.GetDataAddress(u,v) == 255)
				nLineCnt++;
		}
		if(nLineCnt >= nDetLine)
		{
			nLinePos[0].x = u;
			nLinePos[0].y = rectLine.top;
		}

		nLineCnt = 0;
		for(v=rectLine.top-nSkipSize;v<rectLine.bottom-nSkipSize;v++)
		{
			if(*pBuffer.GetDataAddress(u,v) == 255)
				nLineCnt++;
		}
		if(nLineCnt >= nDetLine)
		{
			nLinePos[1].x = u;			
			nLinePos[1].y = rectLine.top-nSkipSize;
		}
	}

	if(bRet == TRUE)
	{
		double		dXPos[2],dYPos[2];

		nForeLine[0] = (nLinePos[0].x+nLinePos[1].x)/2;

		dXPos[0] = (double)nLinePos[0].x;
		dYPos[0] = (double)nLinePos[0].y;
		dXPos[1] = (double)nLinePos[1].x;
		dYPos[1] = (double)nLinePos[1].y;

		dTheta = -90-M_DEGREE(atan2(dYPos[1] - dYPos[0], dXPos[1] - dXPos[0]));
	}

	if(dTheta <= 2)
		dTheta = 0.;

	return TRUE;
}

BOOL CSplineInspect::ShiftNRotateImage(CSISBuffer pOrg,CSISBuffer pBin,COwnerBuffer &pProcess,COwnerBuffer &pProcImg,int *nForeLine,double dTheta,CPoint &pPosImg)
{
	if(pOrg.IsValidBuffer() == FALSE || pBin.IsValidBuffer() == FALSE)
		return FALSE;	
	if(m_pSpModel == NULL)
		return FALSE;
	
	CPoint		pointOut;	
	int			v,nSize;
	CPoint		pointOrg,pointTgt;

	CPoint		ptMasterMin = m_pSpModel->GetptMasterMin();
	CPoint		ptMasterMax = m_pSpModel->GetptMasterMax();

	pointOrg = pointTgt = CPoint(0,0);

	if(nForeLine[0] > ptMasterMin.x)		
		pointOrg.x = nForeLine[0]-ptMasterMin.x;					
	else		
		pointTgt.x = ptMasterMin.x-nForeLine[0];

	if(nForeLine[1] > ptMasterMin.y)
		pointOrg.y = nForeLine[1]-ptMasterMin.y;
	else
		pointTgt.y = ptMasterMin.y-nForeLine[1];

	int		nImgWidth = pBin.GetWidth();
	nSize = align_4byte(pBin.GetWidth()-(pointOrg.x+pointTgt.x));	

	pProcess.SetSize(nImgWidth,(int)((double)ptMasterMax.y+1));
	pProcImg.SetSize(nImgWidth,(int)((double)ptMasterMax.y+1));
	if(pProcess.IsValidBuffer() == FALSE || pProcImg.IsValidBuffer() == FALSE)
		return FALSE;

	ZeroMemory(pProcess.GetDataAddress(0,0),pProcess.GetDataSize());
	ZeroMemory(pProcImg.GetDataAddress(0,0),pProcImg.GetDataSize());

	//if(dTheta <= 0)		// Shift¸¸
	{					
		for(v=pointOrg.y;v<pBin.GetHeight();v++,pointTgt.y++)	
		{			
			if(pointTgt.y >= pProcess.GetHeight())
				break;

			CopyMemory(pProcess.GetDataAddress(pointTgt.x,pointTgt.y),pBin.GetDataAddress(pointOrg.x,v),sizeof(BYTE)*nSize);
			CopyMemory(pProcImg.GetDataAddress(pointTgt.x,pointTgt.y),pOrg.GetDataAddress(pointOrg.x,v),sizeof(BYTE)*nSize);
		}		
	}
	/*else
	{
		int			u;
		CPoint		pointOrg,pointBase;
		
		pointBase = CPoint(nForeLine[0],pOrg.GetHeight()-1);

		for(v=pointOrg.y;v<pOrg.GetHeight();v++)	
		{
			for(u=pointOrg.x;u<nSize;u++)
			{
				pointOrg = CPoint(u,v);
				RotatePoint(pointOrg,&pointOut,pointBase,sin(M_RADIAN(dTheta)), cos(M_RADIAN(dTheta)));

				pointOut.x += pointTgt.x;
				pointOut.y += pointTgt.y;
				if(pointOut.x < 0 || pointOut.x >= pTgt.GetWidth() || pointOut.y < 0 || pointOut.y >= pTgt.GetHeight())
					continue;

				pTgt.SetPixel(pointOut.x,pointOut.y,*pOrg.GetDataAddress(u,v));
			}
		}
	}*/

	/*
	if(pProcess.IsValidBuffer() == TRUE)
	{
		CString				str;

		str.Format(_T("D:\\Image\\Spline\\RotateProc.bmp"));
		CBufferAttach		attach(str);
		attach.AttachToFile(pProcess);

		str.Format(_T("D:\\Image\\Spline\\RotateProcImg.bmp"));
		CBufferAttach		attach2(str);
		attach2.AttachToFile(pProcImg);
	}	
	*/

	return TRUE;
}

int CSplineInspect::GetSplineValue(CEdgeProc &EdgeProc,CSISBuffer pOrg,double dXPos,double dYPos)
{	
	if((int)dXPos >= pOrg.GetWidth()-3 || (int)dYPos >= pOrg.GetHeight()-3
		|| (int)dXPos < 1 || (int)dYPos < 1 || pOrg.IsValidBuffer() == FALSE)
		return 0;		

	float			dMod,dXValue,dYValue;
	int				nIntPosX,nIntPosY;	

	nIntPosX = (int)dXPos;
	nIntPosY = (int)dYPos;

	LPBYTE			pImg = pOrg.GetDataAddress(nIntPosX-1,nIntPosY);

	dMod = (float)dXPos-(float)nIntPosX;
	dXValue = EdgeProc.catmullRomSpline(dMod,*pImg,*(pImg+1),*(pImg+2),*(pImg+3));

	dMod = (float)dYPos-(float)nIntPosY;
	pImg = pOrg.GetDataAddress(nIntPosX,nIntPosY-1);
	dYValue = EdgeProc.catmullRomSpline(dMod,*pImg,*(pImg+pOrg.GetDataWidth()),*(pImg+pOrg.GetDataWidth()*2),*(pImg+pOrg.GetDataWidth()*3));

	return (int)((dXValue+dYValue)/2.);
}

BOOL CSplineInspect::DistInspection(CEdgeProc &EdgeProc,CSISBuffer &pTgt,double *dResult,double *dRangeRes)
{	
	if(m_pSpModel == NULL)
		return FALSE;

	std::multimap<int, CPoint>::iterator	it;
	CPoint					pointOrg,pointSet;
	int						nCount=0,nLineSampleDet = 10;	
	sPoint					*pLinedata = NULL;	
	double					dAdjustTheta;	
	const	int				nDetOffset = 50;
	const	int				nDEF_LINE_COUNT = nLineSampleDet/3;
	int						iCnt,nValue,nDetPointCnt,iHorCnt;	
	CDetectPoint			*pDetPoint;
	int						*pSampleHorCnt;
	CSplinePoint			pSpPoint;
	double					dSumDist,dSumCnt,dMaxAvg;
	double					dAvg=0.,dSum=0.,dDist=0.;			
	int						nDetRange = 5,nMargin=200;
	double					dOutX,dOutY;	
	std::vector<double>		vecDist;

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

	//m_Log.DisplayEdgeLog("=====================================================================");
	//m_Log.DisplayEdgeLog("Inspect Start");

	dSumDist = dSumCnt = dMaxAvg = 0;
	pDetPoint = new CDetectPoint[nDetOffset*2];	
	pSampleHorCnt = new int[nDetOffset*2];

	std::multimap<int, CPoint> *pMasterData = m_pSpModel->GetMasterData();
	CPoint ptMasterMin = m_pSpModel->GetptMasterMin();

	pLinedata = new sPoint[nLineSampleDet];
	for(it=pMasterData->begin();it!=pMasterData->end();it++)
	{		
		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);						
			ZeroMemory(pDetPoint,sizeof(CDetectPoint)*(nDetOffset*2));
			nDetPointCnt = nCount = 0;
			ZeroMemory(pSampleHorCnt,sizeof(int)*(nDetOffset*2));

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

				iHorCnt = 0;
				for(int iU=-1*nDetOffset;iU<nDetOffset;iU++,pointOrg.x++,iHorCnt++)
				{	
					EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dAdjustTheta)), cos(M_RADIAN(dAdjustTheta)));				
					nValue = pTgt.GetPixel((int)dOutX,(int)dOutY);
					//nValue = GetSplineValue(EdgeProc,pTgt,dOutX,dOutY);

					if(nValue > 0)
					{
						pDetPoint[iHorCnt].orgX = pointSet.x;
						pDetPoint[iHorCnt].orgY = pointSet.y;
						pDetPoint[iHorCnt].imgX = dOutX;
						pDetPoint[iHorCnt].imgY = dOutY;
						pDetPoint[iHorCnt].dTheta = dAdjustTheta;		

						pSampleHorCnt[iHorCnt]++;
					}
				}			
			}			

			int		nDetIdx = -1;
			for(iHorCnt=0;iHorCnt<nDetOffset*2;iHorCnt++)
			{
				if(pSampleHorCnt[iHorCnt] >= nDEF_LINE_COUNT)
				{
					nDetIdx = iHorCnt;
					break;
				}
			}

			if(nDetIdx < 0)
			{
				// ã±â ½ÇÆÐ ÇßÀ»°æ¿ì, Max °ªÀ» ³Ö´Â´Ù.
				dAvg = nDetOffset;
				vecDist.push_back(dAvg);
				continue;
			}

			if(pDetPoint[nDetIdx].imgX > 0 && pDetPoint[nDetIdx].imgY > 0)
			{
				dDist = sqrt(pow((pDetPoint[nDetIdx].orgX-pDetPoint[nDetIdx].imgX),2)+pow((pDetPoint[nDetIdx].orgY-pDetPoint[nDetIdx].imgY),2));
				dAvg = dDist;						

				if(abs(ptMasterMin.x-(int)pDetPoint[nDetIdx].imgX) <= nDetRange)
				{
					if(m_pointPosLeft.y > (int)pDetPoint[nDetIdx].imgY)
					{
						m_pointPosLeft.x = (int)pDetPoint[nDetIdx].imgX;
						m_pointPosLeft.y = (int)pDetPoint[nDetIdx].imgY;
					}
				}			
			}

			if(dAvg > 1)
			{
				if(dMaxAvg < dAvg)
					dMaxAvg = dAvg;
				dSumDist += dAvg;
				dSumCnt++;

				vecDist.push_back(dAvg);
			}
		}
	}

	if(m_pointPosLeft.x != INT_MAX && m_pointPosLeft.y != INT_MAX)
	{
		m_pointPosLeft.y += nMargin;	
		m_pointPosLeft.Offset(m_pointDiffImg.x,m_pointDiffImg.y);
	}
	else
		m_pointPosLeft = CPoint(0,0);

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


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

	dResult[0] = dMaxAvg;
	if(dSumCnt > 0)
		dResult[1] = dSumDist/dSumCnt;
	//m_Log.DisplayEdgeLog("dResult = %f, dSumCnt = %f",dResult[1]*10.0816502900-10,dSumCnt);

	int nMaxCount=0;
	int nCurIndex=1;

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

		double dAverage = 0;
		double dCount = 0;
		for(std::vector<double>::iterator it=vecDist.begin();it!=vecDist.end();it++,nCurIndex++)
		{
			double dtemp = *it;

			if(dtemp != nDetOffset)
			{
				dAverage += dtemp;
				dCount++;
			}

			if(nIndex == 4)
			{
				nMaxCount=nJumpVal+(int)dSumCnt%5;
			}
			else
			{
				nMaxCount=nJumpVal;
			}

			if(nCurIndex >= nMaxCount)
			{			
				if(nIndex >= 5)
					break;
				if(dSumCnt != 0)
					dRangeRes[nIndex] = dAverage/dCount;
				else
					dRangeRes[nIndex] = 1;

				dAverage = 0;
				dCount = 0;
				nIndex++;
				nCurIndex=0;
			}
		}
	}

	return TRUE;
}

double CSplineInspect::GetTilt(std::multimap<int, CSplinePoint> *pPos,double &dCenX,double &dCenY)
{
	int			nRange = 10;
	int			nDiffDist = 200;
	CPoint		pointSum[2];

	if((int)pPos->size() < nRange*2+nDiffDist)
		return 0.;

	std::multimap<int, CSplinePoint>::iterator it;
	vector<pair<int,CSplinePoint>> vec;

	for(it = pPos->begin(); it != pPos->end(); ++it)
	{
		vec.push_back(make_pair(it->second.origin.y,it->second));
	}
	std::sort(vec.begin(),vec.end(),SortOrginYPos());

	ZeroMemory(pointSum,sizeof(CPoint)*2);
	int			iPos;

	iPos = 0;
	CSplinePoint	splinePos;
	for(iPos = 0; iPos < nRange; iPos++)
	{
		splinePos = vec[iPos].second;

		pointSum[0].x += splinePos.origin.x;
		pointSum[0].y += splinePos.origin.y;
	}

	iPos = 0;
	for(iPos = nRange+nDiffDist; iPos < nRange+nDiffDist+nRange; iPos++)	
	{
		splinePos = vec[iPos].second;
		pointSum[1].x += splinePos.origin.x;
		pointSum[1].y += splinePos.origin.y;
	}

	double		dXPos[2],dYPos[2];

	dXPos[0] = (double)pointSum[0].x/(double)nRange;
	dYPos[0] = (double)pointSum[0].y/(double)nRange;
	dXPos[1] = (double)pointSum[1].x/(double)nRange;
	dYPos[1] = (double)pointSum[1].y/(double)nRange;

	dCenX = dXPos[0];
	dCenY = dYPos[0];

	return M_DEGREE( atan2(dYPos[1] - dYPos[0], dXPos[1] - dXPos[0]) );
}

BOOL CSplineInspect::AdjustTilt(std::multimap<int, CSplinePoint> *pPos)
{
	double		dAngle,dAdjustAngle;
	double		dCenX,dCenY;
	CEdgeProc	EdgeProc;

	dAngle = GetTilt(pPos,dCenX,dCenY);

	dAdjustAngle = -90-dAngle; 
	/*if(dAdjustAngle == 0)
		return TRUE;*/

	CPoint		pointOut;
	CPoint		pointMin(INT_MAX,INT_MAX);

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

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

		EdgeProc.RotatePoint(splinePos->origin,&pointOut,CPoint((int)dCenX,(int)dCenY),sin(M_RADIAN(dAdjustAngle)), cos(M_RADIAN(dAdjustAngle)));
		splinePos->rotate = pointOut;

		if(splinePos->rotate.x < pointMin.x) pointMin.x = splinePos->rotate.x;
		if(splinePos->rotate.y < pointMin.y) pointMin.y = splinePos->rotate.y;		
	}

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

		splinePos->rotate.Offset(-pointMin.x,-pointMin.y);		
	}

	return TRUE;
}



void CSplineInspect::MakeSplineResultImage(COwnerBuffer &pRes,CSISBuffer &pProcess)
{
	if(pProcess.IsValidBuffer() == FALSE)
		return;
	if(m_pSpModel == NULL)
		return;

	std::multimap<int, CPoint>::iterator	it;
	CPoint				pointData;
	int					nWidth = align_4byte(pProcess.GetWidth());

	pRes.SetSize(nWidth,pProcess.GetHeight());
	CopyMemory(pRes.GetDataAddress(0,0),pProcess.GetDataAddress(0,0),pProcess.GetDataSize());

	std::multimap<int, CPoint> *pMasterData = m_pSpModel->GetMasterData();	

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

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

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

SPLINE_ERR_MSG CSplineInspect::InspectSpline(CSISBuffer &pImg,CRect &rectCrop,int nDetDist,int nThres,BOOL bFlip,BOOL bSaveImg,BOOL bSaveDebug)
{
	ResetValue();

	if(pImg.IsValidBuffer() == FALSE)
		return ERR_SPLINE_IMAGE_NULL;		

	bSaveDebug =FALSE;
	
	if(bSaveDebug == TRUE)
	{
		CString				strImg = _T("D:\\Image\\Spline\\CropImg_2.bmp");		
		CBufferAttach		attachDefect(strImg);
		attachDefect.AttachToFile(pImg);	
	}

	m_insSplineOrg.SetSize(rectCrop.Width(),rectCrop.Height());
	CopyRectImg(pImg.GetDataAddress(),m_insSplineOrg.GetDataAddress(),CSize(pImg.GetDataWidth(),pImg.GetHeight()),rectCrop);	
	if(bFlip == TRUE)	
		m_insSplineOrg.FlipUpDown();		

	return SPLINE_INS_SUCESS;

	if(bSaveDebug == TRUE)
	{
		CString				strImg = _T("D:\\Image\\Spline\\CropImg_3.bmp");		
		CBufferAttach		attachDefect(strImg);
		attachDefect.AttachToFile(m_insSplineOrg);	
	}

	CEdgeProc		EdgeProc;
	CRect			rect(0,0,m_insSplineOrg.GetWidth(),m_insSplineOrg.GetHeight());		
	COwnerBuffer	BufferCanny(m_insSplineOrg.GetWidth(),m_insSplineOrg.GetHeight());	
	if(BufferCanny.IsValidBuffer() == FALSE)
		return ERR_SPLINE_IMAGE_NULL_02;

	ZeroMemory(BufferCanny.GetDataAddress(),BufferCanny.GetDataSize());
	EdgeProc.CannyEdgeProcessing(m_insSplineOrg.GetDataAddress(0,0),rect,GM_Sobel,nThres,BufferCanny);	

	if(bSaveDebug == TRUE)
	{
		CString				strImg = _T("D:\\Image\\Spline\\Canny.bmp");		
		CBufferAttach		attachDefect(strImg);
		attachDefect.AttachToFile(BufferCanny);	
	}

	int			nForeLine[2];		
	FindForeLine(BufferCanny,nForeLine,m_dImageTheta);
	if(nForeLine[0] <= 0 || nForeLine[1] <= 0)		
		return ERR_SPLINE_INDEXFIND;	

	COwnerBuffer		pProcess,pProcImg;		

	if(ShiftNRotateImage(m_insSplineOrg,BufferCanny,pProcess,pProcImg,nForeLine,m_dImageTheta,m_pointDiffImg) == FALSE)
	{		
		return ERR_SPLINE_INDEXFIND;
	}

	if(pProcess.IsValidBuffer() == FALSE || pProcImg.IsValidBuffer() == FALSE)
		return ERR_SPLINE_IMAGE_NULL_03;		

	DistInspection(EdgeProc,pProcess,m_dResultData,m_dRangeResult);

	if(bSaveDebug == TRUE)
	{
		CString				strImg = _T("D:\\Image\\Spline\\Process.bmp");		
		CBufferAttach		attachDefect(strImg);
		attachDefect.AttachToFile(pProcess);	
	}

	if(bSaveImg == TRUE)
		MakeSplineResultImage(m_insSplineRes,pProcess);	

	if(bSaveDebug == TRUE)
	{
		CString				strImg = _T("D:\\Image\\Spline\\Res.bmp");		
		CBufferAttach		attachDefect(strImg);
		attachDefect.AttachToFile(m_insSplineRes);	
	}

	return SPLINE_INS_SUCESS;
}

BOOL CSplineInspect::CopyRectImg(LPBYTE pOrg,LPBYTE pTgt,CSize szImg,CRect &rectIns)
{
	if(pOrg == NULL || pTgt == NULL)
		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;
}

BOOL CSplineInspect::MakeCADLine(CHIP_INS_REGION & insRegion,std::multimap<int, CPoint> &mapData,CPoint &pointMin,CPoint &pointMax,SPLINECHIP_INS_METHOD enOpt)
{
	if(m_pSpModel == NULL)
		return FALSE;

	std::multimap<int, CPoint> *pMasterData = m_pSpModel->GetMasterData();
	CPoint		ptMasterMin = m_pSpModel->GetptMasterMin();

	if((int)pMasterData->size() <= 0)
		return FALSE;

	int		nStartX,nEndX;
	CPoint	pointData;	
	std::multimap<int, CPoint>::iterator	it;
	std::multimap<int, CPoint>::iterator	lowerIter;
	std::multimap<int, CPoint>::iterator	upperIter;

	nStartX = insRegion.nStartX+ptMasterMin.x;
	nEndX = insRegion.nEndX+ptMasterMin.x;

	lowerIter = pMasterData->lower_bound(nStartX);
	upperIter = pMasterData->upper_bound(nEndX);

	switch(enOpt)
	{
	case METHOD_INS_LINE:
		for(it = lowerIter; it != upperIter; it++)
		{
			pointData = static_cast<CPoint>(it->second);

			if(pointData.x >= nStartX && pointData.x <= nEndX)
			{
				pointData.x -= nStartX;			
				if(pointMin.y > pointData.y)									
					pointMin = pointData;
				if(pointMax.y < pointData.y)									
					pointMax = pointData;
				mapData.insert(std::make_pair(pointData.y, pointData));				
			}
		}
		break;
	case METHOD_INT_ROUND:		
		for(it = lowerIter; it != upperIter; it++)
		{
			pointData = static_cast<CPoint>(it->second);

			if(pointData.x >= nStartX && pointData.x <= nEndX)
			{
				pointData.x -= nStartX;			
				if(pointMin.x > pointData.x)
					pointMin = pointData;
				if(pointMax.x < pointData.x)
					pointMax = pointData;
				mapData.insert(std::make_pair(pointData.x, pointData));				
			}
		}
		break;
	}

	return TRUE;
}

double CSplineInspect::GetCAD2ImgOffset(std::multimap<int, CPoint> &mapData,CSISBuffer pBin,CPoint pointMin,CPoint pointMax,int nGap)
{
	double		dYPos = INT_MAX;	
	int			u,v;	
	int			*pImgPos = NULL;
	int			*pCADPos = NULL;

	int			nSampling = 4;

	int			nWidth = pBin.GetWidth()/nSampling;

	if(pointMin.x > pointMax.x)
		return dYPos;

	pImgPos = new int[nWidth];
	pCADPos = new int[nWidth];

	for(u=0;u<nWidth;u++)
	{
		pImgPos[u] = -1;
		pCADPos[u] = -1;
	}

	BOOL bFirstFind = FALSE;
	int nPreFind = 0;

	int nFindStartY = nGap;
	int nFindEndY = pBin.GetHeight();
	
	for(u=nWidth-1;u>=nWidth/2;u--)
	{	
// 		if(bFirstFind == TRUE)
// 		{
// 			nFindStartY = nPreFind - 8;
// 			nFindEndY = nPreFind + 8;
// 
// 			nFindStartY = (nFindStartY < 0) ? 0 : nFindStartY;
// 			nFindEndY = (pBin.GetHeight() <= nFindEndY) ? pBin.GetHeight()-1 : nFindEndY;
// 		}

		for(v=nFindStartY;v<nFindEndY;v++)
		{
			if(*pBin.GetDataAddress(u*nSampling,v) == 255)
			{
				pImgPos[u] = v;
				bFirstFind = TRUE;
				nPreFind = v;
				break;
			}
		}
		if(pImgPos[u] == 0)
			pImgPos[u] = -1;
	}

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

	int nStart = pointMin.x/nSampling;
	int nEnd = pointMax.x/nSampling;

	for(u=nStart,iLoop=0;u<=nEnd;u++,iLoop++)
	{
		int nX = u * nSampling;

		if(iLoop >= nWidth)
			break;

		pointDataMin = CPoint(INT_MAX,INT_MAX);
		for(it=mapData.begin();it!=mapData.end();it++)
		{
			pointData = static_cast<CPoint>(it->second);
			if(pointData.x == nX && pointData.y < pointDataMin.y)
			{
				pointDataMin = pointData;				
			}
		}
		if(iLoop < nWidth && pointDataMin.y != INT_MAX)
			pCADPos[iLoop] = pointDataMin.y;

		if(pCADPos[iLoop] == 0)
			pCADPos[iLoop] = -1;
	}

	int			nOffsety,nOffsetCnt;

	nOffsety = nOffsetCnt = 0;
	for(u=0;u<nWidth;u++)
	{
		if(pCADPos[u] != -1 && pImgPos[u] != -1)
		{
			nOffsety += pImgPos[u]-pCADPos[u];
			nOffsetCnt++;
		}
	}

	if(nOffsetCnt > 0)
		dYPos = (double)nOffsety/(double)nOffsetCnt;

	delete[] pImgPos, pImgPos=NULL;
	delete[] pCADPos, pCADPos=NULL;

	return dYPos;
}

void CSplineInspect::MakeInspectResultImage(CSISBuffer &pRes,std::multimap<int, CSplinePoint> &mapIns)
{
	std::multimap<int, CSplinePoint>::iterator itData;
	CSplinePoint	splinePos;

	for(itData=mapIns.begin();itData!=mapIns.end();itData++)
	{
		splinePos = static_cast<CSplinePoint>(itData->second);		

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

		pRes.SetPixel(splinePos.origin.x,splinePos.origin.y,255);
	}	

	int			nPair = m_ChamferIns.GetPairDefectCount();

	CChipPair		*pPair;

	for(int i = 0; i < nPair; i++)
	{
		pPair = m_ChamferIns.GetPairDefect(i);
		if(pPair == NULL)
			continue;

		pRes.SetPixel(pPair->s_nDefectX,pPair->s_nDefectY,255);
	}
}

void CSplineInspect::MakeInspectResultImage(CSISBuffer &pRes,std::multimap<int, CPoint> &mapIns)
{
	std::multimap<int, CPoint>::iterator itData;
	CPoint	splinePos;

	for(itData=mapIns.begin();itData!=mapIns.end();itData++)
	{
		splinePos = static_cast<CPoint>(itData->second);		

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

		pRes.SetPixel(splinePos.x,splinePos.y,255);
	}	
}

void CSplineInspect::MakeSplineDebugImg(COwnerBuffer &pRes,std::multimap<int, CPoint> *pMaster,std::multimap<int, CSplinePoint> *pData)
{	
	std::multimap<int, CPoint>::iterator	it;	
	CPoint				pointData;	
	int					nOffset = 20;

	pRes.SetSize(m_szImageOrg.cx+nOffset,m_szImageOrg.cy+nOffset);	

	if(pMaster != NULL)
	{
		for(it=pMaster->begin();it!=pMaster->end();it++)
		{
			pointData = static_cast<CPoint>(it->second);
			pointData.Offset(nOffset,nOffset);
			if(pointData.x >= pRes.GetWidth() || pointData.y >= pRes.GetHeight()
				|| pointData.x < 0 || pointData.y < 0)
				continue;						

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

	if(pData != NULL)
	{
		std::multimap<int, CSplinePoint>::iterator itData;
		CSplinePoint	splinePos;

		for(itData=pData->begin();itData!=pData->end();itData++)
		{
			splinePos = static_cast<CSplinePoint>(itData->second);
			splinePos.rotate.Offset(nOffset,nOffset);

			if(splinePos.rotate.x >= pRes.GetWidth() || splinePos.rotate.y >= pRes.GetHeight()
				|| splinePos.rotate.x < 0 || splinePos.rotate.y < 0)
				continue;

			pRes.SetPixel(splinePos.rotate.x,splinePos.rotate.y,100);
		}		
	}
}

BOOL CSplineInspect::MakeInspectLine(std::multimap<int, CPoint> &mapData,std::multimap<int, CSplinePoint> &mapIns,double dYPos,SPLINECHIP_INS_METHOD enOpt)
{	
	if((int)mapData.size() <= 0)
		return FALSE;

	int			nOffsety = (int)dYPos;
	std::multimap<int, CPoint>::iterator	it;		
	CPoint		pointData;
	CSplinePoint	splinePos;

	switch(enOpt)
	{
	case METHOD_INS_LINE:	

		break;
	case METHOD_INT_ROUND:	
		for(it=mapData.begin();it!=mapData.end();it++)
		{
			pointData = static_cast<CPoint>(it->second);

			splinePos.Reset();
			splinePos.origin = splinePos.rotate = pointData;		

			splinePos.origin.Offset(0,nOffsety);
			splinePos.rotate.Offset(0,nOffsety);
			mapIns.insert(std::make_pair(pointData.x, splinePos));
		}
		break;
	}	

	return TRUE;
}

#define DEF_THICK_COUNT 3
double CSplineInspect::FindThick(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CPoint pointSet,CPoint &pointRotate,double dTheta,int nDetThres)
{
	double			dThick = 0.;
	double			dOutX,dOutY;
	int				iU,nValue;
	CPoint			pointOrg = pointSet;
	const	int		nDetOffset = 100;	
	int				nContiCnt;

	nContiCnt = 0;
	for(iU=0;iU<nDetOffset;iU++,pointOrg.x++)
	{	
		EdgeProc.RotatePoint(pointOrg,dOutX,dOutY,pointSet,sin(M_RADIAN(dTheta)), cos(M_RADIAN(dTheta)));					

		nValue = pOrg.GetPixel((int)(dOutX+insRect.left),(int)(dOutY+insRect.top));
		//nValue = GetSplineValue(EdgeProc,pOrg,dOutX+insRect.left,dOutY+insRect.top);

		if(nValue >= nDetThres)
			nContiCnt++;
		else
			nContiCnt = 0;

		if(nContiCnt >= DEF_THICK_COUNT)
		{
			dThick = sqrt(pow(((double)pointSet.x-dOutX),2)+pow(((double)pointSet.y-dOutY),2))+1;
			pointRotate = CPoint((int)dOutX,(int)dOutY);
			break;
		}
	}

	return dThick;
}

int	CSplineInspect::FilteringDefect(CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns,double dRes,int nJudge,CRect &insRect,BOOL bFlip)
{
	if(m_nDefectCount <= 0)
		return m_nDefectCount;

	int			i;
	std::multimap<int, CSplinePoint>::iterator	it;
	CSplinePoint		*splinePos;	
	std::vector<CChipBlob> vecBlob;
	int			nSize,nDist;
	int			nRange = 2;
	CPoint		ptIns;
	CRect		rect;

	for(i=0;i<m_nDefectCount;i++)
	{
		CChipBlob	*pChipBlob = &m_ResultDefect[i];

		switch(insRegion.emDir)
		{
		case SPLINE_INS_DIRECTION_X:
			nSize = (int)(pChipBlob->s_DefectRect.Width()*dRes);		
			break;
		case SPLINE_INS_DIRECTION_Y:			
			nSize = (int)(pChipBlob->s_DefectRect.Height()*dRes);	
			break;
		}

		if(nSize < nJudge)
			continue;

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

			switch(insRegion.emDir)
			{
			case SPLINE_INS_DIRECTION_X:
				ptIns = splinePos->origin;
				ptIns.Offset(insRegion.nSkipDist,0);

				if(pChipBlob->s_DefectRect.top > ptIns.y || pChipBlob->s_DefectRect.bottom < ptIns.y)
					continue;

				if(pChipBlob->s_DefectRect.PtInRect(ptIns) == TRUE)
					nDist = 0;
				else
					nDist = abs(ptIns.x-pChipBlob->s_DefectRect.left);
				break;
			case SPLINE_INS_DIRECTION_Y:
				ptIns = splinePos->origin;
				ptIns.Offset(0,insRegion.nSkipDist);
				
				if(pChipBlob->s_DefectRect.left > ptIns.x || pChipBlob->s_DefectRect.right < ptIns.x)
					continue;

				if(pChipBlob->s_DefectRect.PtInRect(ptIns) == TRUE)
					nDist = 0;
				else
					nDist = abs(ptIns.y-pChipBlob->s_DefectRect.top);
				break;
			}

			if(nDist < nRange)
			{
				vecBlob.push_back(*pChipBlob);
				break;
			}
		}
	}

	m_nDefectCount = 0;

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

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

		CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];

		*pChipBlob = *itBlob;

		pChipBlob->s_DefectRect.OffsetRect(insRect.left,insRect.top);
		pChipBlob->s_nDefectX += insRect.left;
		pChipBlob->s_nDefectY += insRect.top;
		pChipBlob->s_nDefectRScale = (int)pChipBlob->s_dThick;

		if(bFlip == TRUE)
		{
			pChipBlob->s_DefectRect.top = insRect.Height()-pChipBlob->s_DefectRect.top;
			pChipBlob->s_DefectRect.bottom = insRect.Height()-pChipBlob->s_DefectRect.bottom;
			std::swap(pChipBlob->s_DefectRect.top,pChipBlob->s_DefectRect.bottom);
			pChipBlob->s_nDefectY = insRect.Height()-pChipBlob->s_nDefectY;
		}

		m_nDefectCount++;
	}

	return m_nDefectCount;
}

int CSplineInspect::InspectChipBin(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns)
{
	std::multimap<int, CSplinePoint>::iterator	it;
	CSplinePoint		*splinePos;	
	CPoint				ptIns,ptEnd;
	int					nValue,x,y;

	m_ChamferIns.ResetPairDefect();

	if(insRegion.emDir == SPLINE_INS_DIRECTION_X)
	{
		for(it=mapIns.begin();it!=mapIns.end();it++)
		{
			splinePos = static_cast<CSplinePoint*>(&it->second);
			if(splinePos == NULL)
				continue;

			ptIns = splinePos->origin;
			ptIns.Offset(insRegion.nSkipDist+insRect.left,insRect.top);
			ptEnd = ptIns;
			ptEnd.Offset(insRegion.nInsRange,0);

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

			for(x=ptIns.x ; x<ptEnd.x ; x++)
			{
				nValue = pOrg.GetPixel(x,ptIns.y);
				if(nValue <= insRegion.nFindThres)
				{
					m_ChamferIns.InsertPairing(x-insRect.left,(int)ptIns.y-insRect.top,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,0);	
				}
// 				else
// 					break;
			}
		}
	}
	else
	{
		for(it=mapIns.begin();it!=mapIns.end();it++)
		{
			splinePos = static_cast<CSplinePoint*>(&it->second);
			if(splinePos == NULL)
				continue;

			ptIns = splinePos->origin;
			ptIns.Offset(insRect.left,insRegion.nSkipDist+insRect.top);
			ptEnd = ptIns;
			ptEnd.Offset(0,insRegion.nInsRange);

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

			for(y=ptIns.y ; y<ptEnd.y ; y++)
			{
				nValue = pOrg.GetPixel(ptIns.x,y);
				if(nValue <= insRegion.nFindThres)
				{
					m_ChamferIns.InsertPairing((int)ptIns.x-insRect.left,y-insRect.top,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,0);	
				}
// 				else
// 					break;
			}
		}
	}
	
	if(m_ChamferIns.GetPairDefectCount() > 0)
	{
		std::vector<CChipBlob> vecBlob;
		m_ChamferIns.BlobDefect_Pixel(vecBlob,0,4);

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

			for(itBlob=vecBlob.begin();itBlob!=vecBlob.end();itBlob++)
			{
				if(m_nDefectCount >= MAX_SPLINE_DEFECT_COUNT)
					return m_nDefectCount;				
				
				CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];

				*pChipBlob = *itBlob;

				pChipBlob->s_nDefectRScale = (int)pChipBlob->s_dThick;				

				m_nDefectCount++;
			}	
		}
	}


	return m_nDefectCount;
}

int CSplineInspect::InspectChipBin_Diagonal(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns)
{
	std::multimap<int, CSplinePoint>::iterator	it;
	CSplinePoint		*splinePos;	
	CPoint				ptIns,ptEnd;
	int					nValue,x,y;

	m_ChamferIns.ResetPairDefect();

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

		ptIns = splinePos->origin;
		ptIns.Offset(insRegion.nSkipDist+insRect.left, insRegion.nSkipDist+insRect.top);
		ptEnd = ptIns;
		ptEnd.Offset(insRegion.nInsRange, insRegion.nInsRange);

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

		for(x=ptIns.x, y=ptIns.y; x<ptEnd.x && y<ptEnd.y ; x++)
		{
			nValue = pOrg.GetPixel(x, y);

			if(nValue <= insRegion.nFindThres)
			{
				int nX = x - insRect.left;
				int nY = y - insRect.top;

				m_ChamferIns.InsertPairing(nX,nY,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,0);
			}
		}

		/*
		for(y=ptIns.y ; y<ptEnd.y ; y++)
		{
			for(x=ptIns.x ; x<ptEnd.x ; x++)
			{
				nValue = pOrg.GetPixel(x, y);

				if(nValue <= insRegion.nFindThres)
				{
					int nX = x - insRect.left;
					int nY = y - insRect.top;

					m_ChamferIns.InsertPairing(nX,nY,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,0);
				}
			}
		}
		*/
	}

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

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

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

				CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];

				*pChipBlob = *itBlob;

				pChipBlob->s_nDefectRScale = (int)pChipBlob->s_dThick;				

				m_nDefectCount++;
			}	
		}
	}


	return m_nDefectCount;
}

double CSplineInspect::InspectChip(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns)
{
	sPoint				*pLinedata = NULL;
	int					nLineCnt = 0;	
	double				dAdjustTheta;			
	std::multimap<int, CSplinePoint>::iterator	it;
	CSplinePoint		*splinePos;	
	double				dSumThick,dSumCnt;	

	dSumThick = dSumCnt = 0.;
	if(insRegion.emMethod == MAKE_METHOD_LINEAR)
	{
		pLinedata = new sPoint[(int)mapIns.size()+1];
		for(it=mapIns.begin();it!=mapIns.end();it++)
		{
			splinePos = static_cast<CSplinePoint*>(&it->second);
			if(splinePos == NULL)
				continue;

			pLinedata[nLineCnt].x = splinePos->origin.x;
			pLinedata[nLineCnt].y = splinePos->origin.y;
			nLineCnt++;
		}

		if(nLineCnt <= 0)
		{
			if(pLinedata != NULL)
				delete[] pLinedata, pLinedata=NULL;
			return TRUE;
		}

		dAdjustTheta = EdgeProc.GetTheta(pLinedata,nLineCnt,3);

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

			splinePos->dTheta = dAdjustTheta;
			splinePos->dThick =	FindThick(EdgeProc,pOrg,insRect,splinePos->origin,splinePos->rotate,dAdjustTheta,insRegion.nFindThres);		
			TRACE("Thick Pos : org[%d,%d],roate[%d,%d],Thick[%.2f]\r\n",splinePos->origin.x,splinePos->origin.y,splinePos->rotate.x,splinePos->rotate.y,splinePos->dThick);
			if(splinePos->dThick > 0)
			{
				dSumThick += splinePos->dThick;
				dSumCnt++;
			}
		}
	}
	else
	{
		int				nCount=0,nLineSampleDet = 10;
		CPoint			pointOrg,pointSet;
		std::vector<CSplinePoint*> pvecSpPoint;
		std::vector<CSplinePoint*>::iterator itData;

		pLinedata = new sPoint[nLineSampleDet];
		for(it=mapIns.begin();it!=mapIns.end();it++)
		{		
			splinePos = static_cast<CSplinePoint*>(&it->second);
			if(splinePos == NULL)
				continue;

			pvecSpPoint.push_back(splinePos);
			pLinedata[nCount].x = splinePos->origin.x;
			pLinedata[nCount].y = splinePos->origin.y;
			nCount++;
			if(nCount >= nLineSampleDet)
			{
				dAdjustTheta = EdgeProc.GetTheta(pLinedata,nLineSampleDet,3);														

				for(itData=pvecSpPoint.begin();itData!=pvecSpPoint.end();itData++)				
				{
					splinePos = *itData;		
					if(splinePos == NULL)
						continue;

					splinePos->dTheta = dAdjustTheta;
					splinePos->dThick =	FindThick(EdgeProc,pOrg,insRect,splinePos->origin,splinePos->rotate,dAdjustTheta,insRegion.nFindThres);	
					TRACE("Thick Pos : org[%d,%d],roate[%d,%d],Thick[%.2f]\r\n",splinePos->origin.x,splinePos->origin.y,splinePos->rotate.x,splinePos->rotate.y,splinePos->dThick);
					if(splinePos->dThick > 0)
					{
						dSumThick += splinePos->dThick;
						dSumCnt++;
					}		
				}	
				nCount = 0;
				pvecSpPoint.clear();
			}
		}

	}

	delete[] pLinedata, pLinedata=NULL;	

	return dSumCnt>0?dSumThick/dSumCnt:-1;
}

#define SP_CHIP_CONTI_COUNT	3

int CSplineInspect::AnalysisThick(CEdgeProc &EdgeProc,CRect rectImg,double dRes,int nJudgeThick,double dAvgThick,BOOL bFlip,std::multimap<int, CSplinePoint> &mapIns)
{	
	std::multimap<int, CSplinePoint>::iterator	it;	
	CSplinePoint		*splinePos;	
	CResultDefect		resDefect;			
	double				dOutX,dOutY,dThick;
	CPoint				pointSet;	
	std::vector<CChipPair>	vecPair;
	vector<CChipBlob>::iterator	itData;
	int					nDetCnt = 0;	

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

		dThick = fabs((splinePos->dThick*dRes)-dAvgThick);
		if(dThick > nJudgeThick)		
		{
			nDetCnt++;
			if(nDetCnt >= SP_CHIP_CONTI_COUNT)
			{
				pointSet = splinePos->origin;
				pointSet.x += (int)(((dThick/dRes)/2)+(dAvgThick/dRes));
				EdgeProc.RotatePoint(pointSet,dOutX,dOutY,splinePos->origin,sin(M_RADIAN(splinePos->dTheta)), cos(M_RADIAN(splinePos->dTheta)));
				if(dOutX < 0 || dOutY < 0)
					continue;

				m_ChamferIns.InsertPairing((int)dOutX,(int)dOutY,1,0,0,0,CHIPREGTYPE_RIGHT,INS_DEFECT_CHIP,FALSE,dThick);	
				nDetCnt = 0;
			}	
		}
		else
			nDetCnt=0;

	}	

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

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

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

				CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];

				*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;

				if(bFlip == TRUE)
				{
					pChipBlob->s_DefectRect.top = rectImg.Height()-pChipBlob->s_DefectRect.top;
					pChipBlob->s_DefectRect.bottom = rectImg.Height()-pChipBlob->s_DefectRect.bottom;
					std::swap(pChipBlob->s_DefectRect.top,pChipBlob->s_DefectRect.bottom);
					pChipBlob->s_nDefectY = rectImg.Height()-pChipBlob->s_nDefectY;
				}

				m_nDefectCount++;
			}	
		}
	}

	return m_nDefectCount;
}

//#define SAVE_SPLINE_CHIP
double CSplineInspect::InspectSplineChip(CSISBuffer pImg,int nPosLeft,CHIP_INS_REGION &insRegion,double dRes,int nJudgeThick,COwnerBuffer &pRes,BOOL bFlip
	,int iReg,BOOL bSaveDebug,SPLINECHIP_INS_METHOD enOpt)
{
	double		dAvgThick = 0;

	ReleaseBlob();

	if(insRegion.bUse == FALSE || pImg.IsValidBuffer() == FALSE || nPosLeft <= 0)
	{		
		return dAvgThick;
	}

	CRect			insRect;		

	insRect = CRect(nPosLeft+insRegion.nStartX,0,nPosLeft+insRegion.nEndX,pImg.GetHeight());
	insRect.right= insRect.left + align_4byte(insRect.Width());
	if(insRect.Width() <= 0 || insRect.Height() <= 0 || insRect.left < 0 || insRect.left >= pImg.GetWidth() || insRect.right <= 0 || insRect.right >= pImg.GetWidth())	
		return dAvgThick;	

	pRes.SetSize(insRect.Width(),insRect.Height());
	ZeroMemory(pRes.GetDataAddress(0,0),pRes.GetDataSize());

	CEdgeProc		EdgeProc;
	CRect			rectBin(0,0,insRect.Width(),insRect.Height());
	int				nAdpSize = 15;
	COwnerBuffer	ProcBuf(insRect.Width(),insRect.Height());

	if(CopyRectImg(pImg.GetDataAddress(0,0),ProcBuf.GetDataAddress(0,0),CSize(pImg.GetDataWidth(),pImg.GetHeight()),insRect) == FALSE)
		return dAvgThick;
	
	if(bSaveDebug == TRUE)
	{
		if(ProcBuf.IsValidBuffer() == TRUE)
		{
			CString		str;
			str.Format(_T("D:\\Image\\Spline\\[%d,%d]OrgImg.bmp"),bFlip,iReg);
			CBufferAttach		attach(str);
			attach.AttachToFile(ProcBuf);
		}
	}

	int			nLineThres = insRegion.nThres;//(int)((double)insRegion.nFindThres - (double)insRegion.nFindThres*0.1);
	EdgeProc.ThresholdProcessing(ProcBuf.GetDataAddress(0,0),CSize(ProcBuf.GetDataWidth(),ProcBuf.GetHeight()),nLineThres,0);

	//EdgeProc.Adaptive_Binarization(ProcBuf.GetDataAddress(0,0),ProcBuf.GetWidth(),ProcBuf.GetHeight(),ProcBuf.GetDataWidth(),nAdpSize,0.2,ProcBuf.GetDataAddress(0,0),rectBin);

	if(bSaveDebug == TRUE)
	{
		if(ProcBuf.IsValidBuffer() == TRUE)
		{
			CString		str;
			str.Format(_T("D:\\Image\\Spline\\[%d,%d]Line_BinImg.bmp"),bFlip,iReg);
			CBufferAttach		attach(str);
			attach.AttachToFile(ProcBuf);

			COwnerBuffer		pInsBin(insRect.Width(),insRect.Height());

			if(CopyRectImg(pImg.GetDataAddress(0,0),pInsBin.GetDataAddress(0,0),CSize(pImg.GetDataWidth(),pImg.GetHeight()),insRect) == FALSE)
				return dAvgThick;

			EdgeProc.ThresholdProcessing(pInsBin.GetDataAddress(0,0),CSize(pInsBin.GetDataWidth(),pInsBin.GetHeight()),insRegion.nFindThres,0);

			str.Format(_T("D:\\Image\\Spline\\[%d,%d]Defect_BinImg.bmp"),bFlip,iReg);
			CBufferAttach		attach2(str);
			attach2.AttachToFile(pInsBin);

		}
	}

	std::multimap<int, CPoint>	mapData;
	CPoint	 pointMin = CPoint(INT_MAX,INT_MAX);
	CPoint	 pointMax = CPoint(0,0);
	if(MakeCADLine(insRegion,mapData,pointMin,pointMax,enOpt) == FALSE)
	{		
		return dAvgThick;
	}

	if(bSaveDebug == TRUE)
	{
		COwnerBuffer		pCAD(insRect.Width(),insRect.Height());

		ZeroMemory(pCAD.GetDataAddress(0,0),pCAD.GetDataSize());
		MakeInspectResultImage(pCAD,mapData);

		CString		strContour;
		strContour.Format(_T("D:\\Image\\Spline\\[%d,%d]CADMap.bmp"),bFlip,iReg);
		CBufferAttach	attach(strContour);
		attach.AttachToFile(pCAD);

	}

	double dYPos = GetCAD2ImgOffset(mapData,ProcBuf,pointMin,pointMax);
	if(dYPos == INT_MAX)
		return dAvgThick;


	std::multimap<int, CSplinePoint> mapIns;

	if(MakeInspectLine(mapData,mapIns,dYPos,enOpt) == FALSE)
	{
		return dAvgThick;
	}	

	if((int)mapIns.size() <= 0)
		return dAvgThick;

	int		nDefect = InspectChipBin(EdgeProc,pImg,insRect,insRegion,mapIns);
		
	nDefect = FilteringDefect(insRegion,mapIns,dRes,nJudgeThick,insRect,bFlip);

	/*
	dAvgThick = InspectChip(EdgeProc,pImg,insRect,insRegion,mapIns);
	dAvgThick *= dRes;

	if(dAvgThick > 0)
	{		
		AnalysisThick(EdgeProc,insRect,dRes,nJudgeThick,dAvgThick,bFlip,mapIns);	
	}
	*/

	if(bSaveDebug == TRUE)
	{
		if(pRes.IsValidBuffer() == TRUE)
		{
			if(CopyRectImg(pImg.GetDataAddress(0,0),pRes.GetDataAddress(0,0),CSize(pImg.GetDataWidth(),pImg.GetHeight()),insRect) == FALSE)
				return dAvgThick;

			MakeInspectResultImage(pRes,mapIns);

			CString		strContour;
			strContour.Format(_T("D:\\Image\\Spline\\[%d,%d]ResultMap.bmp"),bFlip,iReg);
			CBufferAttach	attach(strContour);
			attach.AttachToFile(pRes);
		}
	}

	return nDefect;
}

double CSplineInspect::InspectSplineChip_New(CSISBuffer pImg,int nPosLeft,CHIP_INS_REGION &insRegion,double dRes,int nJudgeThick,BOOL bFlip,int iReg,BOOL bSaveDebug,SPLINECHIP_INS_METHOD enOpt/*=METHOD_INT_ROUND*/)
{
	double		dAvgThick = 0;

	ReleaseBlob();

	if(insRegion.bUse == FALSE || pImg.IsValidBuffer() == FALSE || nPosLeft <= 0)
	{		
		return dAvgThick;
	}

	CRect			insRect;		

	insRect = CRect(nPosLeft+insRegion.nStartX,0,nPosLeft+insRegion.nEndX,pImg.GetHeight());
	insRect.right= insRect.left + align_4byte(insRect.Width());
	if(insRect.Width() <= 0 || insRect.Height() <= 0 || insRect.left < 0 || insRect.left >= pImg.GetWidth() || insRect.right <= 0 || insRect.right >= pImg.GetWidth())	
		return dAvgThick;	

	CEdgeProc		EdgeProc;
	CRect			rectBin(0,0,insRect.Width(),insRect.Height());

	COwnerBuffer	ProcBuf(insRect.Width(),insRect.Height());

	if(CopyRectImg(pImg.GetDataAddress(0,0),ProcBuf.GetDataAddress(0,0),CSize(pImg.GetDataWidth(),pImg.GetHeight()),insRect) == FALSE)
		return dAvgThick;

	if(bSaveDebug == TRUE)
	{
		if(ProcBuf.IsValidBuffer() == TRUE)
		{
			CString		str;
			str.Format(_T("D:\\Image\\Spline\\[%d]OrgImg.bmp"),iReg);
			CBufferAttach		attach(str);
			attach.AttachToFile(ProcBuf);
		}
	}

	int			nLineThres = insRegion.nThres;//(int)((double)insRegion.nFindThres - (double)insRegion.nFindThres*0.1);
	EdgeProc.ThresholdProcessing(ProcBuf.GetDataAddress(0,0),CSize(ProcBuf.GetDataWidth(),ProcBuf.GetHeight()),nLineThres,0);

	if(bSaveDebug == TRUE)
	{
		if(ProcBuf.IsValidBuffer() == TRUE)
		{
			CString		str;
			str.Format(_T("D:\\Image\\Spline\\[%d]BinImg.bmp"),iReg);
			CBufferAttach		attach(str);
			attach.AttachToFile(ProcBuf);
		}
	}

	std::multimap<int, CPoint>	mapData;
	CPoint	 pointMin = CPoint(INT_MAX,INT_MAX);
	CPoint	 pointMax = CPoint(0,0);
	if(MakeCADLine(insRegion,mapData,pointMin,pointMax,enOpt) == FALSE)
	{		
		return dAvgThick;
	}

	if(bSaveDebug == TRUE)
	{
		COwnerBuffer		pCAD(insRect.Width(),insRect.Height());

		ZeroMemory(pCAD.GetDataAddress(0,0),pCAD.GetDataSize());
		MakeInspectResultImage(pCAD,mapData);

		CString		strContour;
		strContour.Format(_T("D:\\Image\\Spline\\[%d]CADMap.bmp"),iReg);
		CBufferAttach	attach(strContour);
		attach.AttachToFile(pCAD);

	}

	double dYPos = GetCAD2ImgOffset(mapData,ProcBuf,pointMin,pointMax);
	if(dYPos == INT_MAX)
		return dAvgThick;


	std::multimap<int, CSplinePoint> mapIns;

	if(MakeInspectLine(mapData,mapIns,dYPos,enOpt) == FALSE)
	{
		return dAvgThick;
	}	

	if((int)mapIns.size() <= 0)
		return dAvgThick;

	int		nDefect = InspectChipBin_New(EdgeProc,pImg,insRect,insRegion,mapIns);
		
	nDefect = FilteringDefect_New(insRegion,mapIns,dRes,nJudgeThick,insRect,bFlip);

	return nDefect;
}

int CSplineInspect::InspectChipBin_New(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns)
{
	std::multimap<int, CSplinePoint>::iterator	it;
	CSplinePoint		*splinePos;	
	CPoint				ptIns,ptEnd;
	int					nValue,x,y;

	m_ChamferIns.ResetPairDefect();

	COwnerBuffer pBinBuffer(insRect.Width(), insRect.Height());

	pBinBuffer.MemSet(0);

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

		ptIns = splinePos->origin;
		ptIns.Offset(insRegion.nSkipDist+insRect.left, insRegion.nSkipDist+insRect.top);
		ptEnd = ptIns;
		ptEnd.Offset(insRegion.nInsRange, insRegion.nInsRange);

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

		for(y=ptIns.y ; y<ptEnd.y ; y++)
		{
			for(x=ptIns.x ; x<ptEnd.x ; x++)
			{
				nValue = pOrg.GetPixel(x, y);

				if(nValue <= insRegion.nFindThres)
				{
					int nX = x - insRect.left;
					int nY = y - insRect.top;

					if(nX < 0 || pBinBuffer.GetWidth() <= nX )
						continue;

					if(nY < 0 || pBinBuffer.GetHeight() <= nY )
						continue;

					pBinBuffer.SetPixel(nX, nY, 255);
				}
			}
		}
	}

	std::vector<CChipBlob> blobData;

	Blob_OpenCV(&pOrg, &pBinBuffer, insRect, &blobData, CHIPREGTYPE_RIGHT, INS_DEFECT_CHIP, 50, -1, FALSE);

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

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

			CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];

			*pChipBlob = *itBlob;

			m_nDefectCount++;
		}
	}

	return m_nDefectCount;
}

BOOL CSplineInspect::Blob_OpenCV(CSISBuffer* pOriginImg, COwnerBuffer* pBinImage, CRect rtInsRect, std::vector<CChipBlob>* vecBlobList, ChipResionType s_RegionType,DefectPosType s_DefectPos, int nMinSize, int nSideFilter, BOOL bROIOffset)
{
	if (pOriginImg == NULL || pBinImage == NULL || vecBlobList == NULL)
		return FALSE;

	if (pOriginImg->GetWidth() == 0 || pOriginImg->GetHeight() == 0)
		return FALSE;

	if (rtInsRect.Width() != pBinImage->GetWidth() || rtInsRect.Height() != pBinImage->GetHeight())
		return FALSE;

	cv::Mat pBinMat = cv::Mat::zeros(pBinImage->GetHeight(), pBinImage->GetWidth(), CV_8UC1);

	CopyMemory(pBinMat.data, pBinImage->GetDataAddress(), pBinImage->GetSize());

	cv::Mat matLabel, matStats, matCentrois;

	int numOfLables = connectedComponentsWithStats(pBinMat, matLabel, matStats, matCentrois, 8);

	std::vector<int> vecMin, vecMax, vecSum, vecPixelCount;

	vecMin.resize(numOfLables, 9999);
	vecMax.resize(numOfLables, -9999);
	vecSum.resize(numOfLables, 0);
	vecPixelCount.resize(numOfLables, 0);

	int nBackGroundIdx = 0;

	for (int i = 0; i < matLabel.rows; i++)
	{
		int* label = matLabel.ptr<int>(i);

		for (int j = 0; j < matLabel.cols; j++)
		{
			int nLabelIdx = (int)label[j];

			int nPxlValue = (int)pOriginImg->GetPixel(rtInsRect.left + j, rtInsRect.top + i);

			if (pBinImage->GetPixel(j, i) == 0)
				nBackGroundIdx = nLabelIdx;

			if (nPxlValue < vecMin[nLabelIdx])
				vecMin[nLabelIdx] = nPxlValue;

			if (nPxlValue > vecMax[nLabelIdx])
				vecMax[nLabelIdx] = nPxlValue;

			vecSum[nLabelIdx] = vecSum[nLabelIdx] + nPxlValue;

			vecPixelCount[nLabelIdx] = vecPixelCount[nLabelIdx] + 1;
		}
	}

	for (int nIdx = 0; nIdx < numOfLables; nIdx++)
	{
		int area = matStats.at<int>(nIdx, cv::CC_STAT_AREA);
		int left = matStats.at<int>(nIdx, cv::CC_STAT_LEFT);
		int top = matStats.at<int>(nIdx, cv::CC_STAT_TOP);
		int width = matStats.at<int>(nIdx, cv::CC_STAT_WIDTH);
		int height = matStats.at<int>(nIdx, cv::CC_STAT_HEIGHT);

		int x = (int)matCentrois.at<double>(nIdx, 0);
		int y = (int)matCentrois.at<double>(nIdx, 1);

		if (nBackGroundIdx == nIdx)
			continue;

		if (vecPixelCount[nIdx] < nMinSize)
			continue;

		CRect rtDefectArea;
		rtDefectArea.left = left;
		rtDefectArea.top = top;
		rtDefectArea.right = left + width;
		rtDefectArea.bottom = top + height;

		if(0 < nSideFilter && s_RegionType == CHIPREGTYPE_RIGHT && nSideFilter <= rtDefectArea.left)
			continue;

		if(0 < nSideFilter && s_RegionType == CHIPREGTYPE_LEFT && rtDefectArea.right <= rtInsRect.Width() - nSideFilter)
			continue;

		if(bROIOffset == TRUE)
			rtDefectArea.OffsetRect(rtInsRect.left, rtInsRect.top);


		CChipBlob chipBlob;
		chipBlob.Reset();
		// CheckDefectRect(chipBlob, pPair->s_nDefectX, pPair->s_nDefectY);
		// chipBlob.SetDefectPair(pPair->s_DefectPair);
		chipBlob.s_DefectRect		= rtDefectArea;
		chipBlob.s_nDefectRScale    = rtDefectArea.Width()*rtDefectArea.Height();
		chipBlob.s_nIndex			= (short) vecBlobList->size();
		chipBlob.s_nDefectArea		= vecPixelCount[nIdx];

		if(bROIOffset == TRUE)
		{
			chipBlob.s_nDefectX			= x + rtInsRect.left;
			chipBlob.s_nDefectY			= y + rtInsRect.top;
		}
		else
		{
			chipBlob.s_nDefectX			= x;
			chipBlob.s_nDefectY			= y;
		}

		chipBlob.s_DefectType		= CHIPDEFTYPE_MIXED;	//pPair->s_DefectType;			//½ÇÁ¦ ¹é°áÇÔÀº 1,Èæ°áÇÔÀº 0
		chipBlob.s_sThreshold		= 0;
		chipBlob.s_RegionType		= s_RegionType;
		chipBlob.s_dThick			= 0.0;
		chipBlob.s_bCornerChip		= FALSE;
		chipBlob.s_DefectJudgeType  = s_DefectPos;
		chipBlob.s_sLevelSrcMax		= (short) vecMax[nIdx];
		chipBlob.s_xLevelSrcMax		= (short) chipBlob.s_nDefectX;
		chipBlob.s_yLevelSrcMax		= (short) chipBlob.s_nDefectY;
		chipBlob.s_sLevelSrcMin		= (short) vecMin[nIdx];
		chipBlob.s_nLevelSrcSum		= vecSum[nIdx];

		vecBlobList->push_back(chipBlob);
	}

	return TRUE;
}

int CSplineInspect::FilteringDefect_New(CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns,double dRes,int nJudge,CRect &insRect,BOOL bFlip)
{
	if(m_nDefectCount <= 0)
		return m_nDefectCount;

	int			i;
	CSplinePoint		*splinePos;	
	std::vector<CChipBlob> vecBlob;
	int			nSizeX, nSizeY;
	int			nRange = 2;
	CPoint		ptIns;
	CRect		rect;

	std::multimap<int, CSplinePoint>::iterator it;
	std::multimap<int, CSplinePoint>::iterator lowerIter;
	std::multimap<int, CSplinePoint>::iterator upperIter;

	for(i=0;i<m_nDefectCount;i++)
	{
		CChipBlob	*pChipBlob = &m_ResultDefect[i];

		nSizeX = (int)(pChipBlob->s_DefectRect.Width()*dRes);
		nSizeY = (int)(pChipBlob->s_DefectRect.Height()*dRes);

		if(nSizeX < nJudge && nSizeY < nJudge)
			continue;

		lowerIter = mapIns.lower_bound(pChipBlob->s_DefectRect.left - insRegion.nSkipDist - nRange);
		upperIter = mapIns.upper_bound(pChipBlob->s_DefectRect.right - insRegion.nSkipDist - nRange);

		for(it = lowerIter; it != upperIter; it++)
		{
			splinePos = static_cast<CSplinePoint*>(&it->second);

			if(splinePos == NULL)
				continue;

			ptIns = splinePos->origin;
			ptIns.Offset(insRegion.nSkipDist+nRange,insRegion.nSkipDist+nRange);

			if(pChipBlob->s_DefectRect.PtInRect(ptIns) == TRUE)
			{
				vecBlob.push_back(*pChipBlob);
				break;
			}
		}
	}

	m_nDefectCount = 0;

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

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

		CChipBlob	*pChipBlob = &m_ResultDefect[m_nDefectCount];

		*pChipBlob = *itBlob;

		pChipBlob->s_DefectRect.OffsetRect(insRect.left,insRect.top);
		pChipBlob->s_nDefectX += insRect.left;
		pChipBlob->s_nDefectY += insRect.top;
		pChipBlob->s_nDefectRScale = (int)pChipBlob->s_dThick;

		if(bFlip == TRUE)
		{
			pChipBlob->s_DefectRect.top = insRect.Height()-pChipBlob->s_DefectRect.top;
			pChipBlob->s_DefectRect.bottom = insRect.Height()-pChipBlob->s_DefectRect.bottom;
			std::swap(pChipBlob->s_DefectRect.top,pChipBlob->s_DefectRect.bottom);
			pChipBlob->s_nDefectY = insRect.Height()-pChipBlob->s_nDefectY;
		}

		m_nDefectCount++;
	}

	return m_nDefectCount;
}

BOOL CSplineInspect::FindCADLine()
{
	if(m_lpBuffer == NULL || m_lpBuffer->GetHeight() <= 0 || m_lpBuffer->GetWidth() <= 0)
		return FALSE;

	int			ix,iy,iLoop;		
	int			nImgOffset = 5;

	m_mapSplinePos.clear();

	CSplinePoint		splinePos;
	m_nSplineOffsetX = m_nSplineOffsetY = INT_MAX;
	iLoop = 0;
	for(iy=m_lpBuffer->GetHeight()-nImgOffset;iy>=nImgOffset;iy--)
	{
		for(ix=nImgOffset;ix<m_lpBuffer->GetWidth()-nImgOffset;ix++)
		{
			if(m_lpBuffer->GetPixel(ix,iy) == 255)
			{
				splinePos.Reset();

				if(m_nSplineOffsetX > ix) m_nSplineOffsetX = ix;
				if(m_nSplineOffsetY > iy) m_nSplineOffsetY = iy;

				splinePos.origin = splinePos.rotate = CPoint(ix,iy);
				m_mapSplinePos.insert(std::make_pair(ix, splinePos));				
			}
		}		
	}

	return TRUE;
}

BOOL CSplineInspect::LabelingProcess()
{
	if(CheckBuffer() == FALSE)
		return FALSE;

	int			cx,cy;		
	int			nLabelingIdx,nTracedir;
	DWORD		dwStarttime = GetTickCount();
	const int	MAX_DELAY_TIME = 1000;
	BOOL		bBreak = FALSE;

// 	CString		str = _T("D:\\Image\\Spline\\Recipe_org.bmp");
// 	CBufferAttach	attach(str);
// 	attach.AttachToFile(*m_lpBuffer);


	nLabelingIdx = m_nCCCount = 0;
	for(cy = 2; cy < m_lpBuffer->GetHeight() - 2; cy++)
	{
		for(cx = 2, nLabelingIdx = 0; cx < m_lpBuffer->GetWidth() - 2; cx++)
		{
			if((GetTickCount()-dwStarttime) >= MAX_DELAY_TIME)
			{
				bBreak = TRUE;
				break;
			}

			if(CheckRange(cx,cy,m_lpBuffer) == FALSE)
				break;

			if(*m_lpBuffer->GetDataAddress(cx,cy) == 255)// black pixel
			{
				if(nLabelingIdx != 0)// use pre-pixel label
				{
					m_pLabelMap[cy][cx] = nLabelingIdx;
				}
				else
				{
					nLabelingIdx = m_pLabelMap[cy][cx];

					if(nLabelingIdx == 0)
					{
						nLabelingIdx = ++m_nCCCount;
						nTracedir = 0;
						ContourTracing(cy, cx, nLabelingIdx, nTracedir);// external contour
						m_pLabelMap[cy][cx] = nLabelingIdx;
					}
				}
			}
			else if(nLabelingIdx != 0)// white pixel & pre-pixel has been labeled
			{
				if(m_pLabelMap[cy][cx] == 0)
				{
					nTracedir = 1;
					ContourTracing(cy, cx - 1, nLabelingIdx, nTracedir);// internal contour
				}

				nLabelingIdx = 0;
			}		
		}

		if(bBreak == TRUE)
			return TRUE;		
	}

	return TRUE;
}

BOOL CSplineInspect::LabelingCounting()
{
	if(CheckBuffer() == FALSE)
		return FALSE;

	int			ix,iy;

	m_nMaxContourIdx = m_nMaxContourCount = 0;
	ZeroMemory(m_pContourCnt,sizeof(int)*m_lpBuffer->GetHeight()*m_lpBuffer->GetWidth());
	for(iy=0;iy<m_lpBuffer->GetHeight();iy++)
	{
		for(ix=0;ix<m_lpBuffer->GetWidth();ix++)
		{
			if(m_pContourMap[iy][ix] > 0)
			{
				m_pContourCnt[m_pContourMap[iy][ix]]++;

				if(m_nMaxContourCount < m_pContourCnt[m_pContourMap[iy][ix]])
				{
					m_nMaxContourIdx = m_pContourMap[iy][ix];
					m_nMaxContourCount = m_pContourCnt[m_pContourMap[iy][ix]];
				}
			}
		}
	}

	return TRUE;
}

BOOL CSplineInspect::LabelFiltering( int nFilterCnt )
{
	if(CheckBuffer() == FALSE)
		return FALSE;

	int			iLoop;

	for(iLoop=0;iLoop<m_lpBuffer->GetHeight()*m_lpBuffer->GetWidth();iLoop++)
	{
		if(m_pContourCnt[iLoop] > 0 && m_pContourCnt[iLoop] <= nFilterCnt)
			m_pContourCnt[iLoop] = 0;
	}

	return TRUE;
}

int CSplineInspect::GetRectInLabelMaxIndex( CRect &rect )
{
	if(CheckBuffer() == FALSE)
		return -1;
	if(CheckRectToBuffer(rect) == FALSE)
		return -1;

	int					ix,iy,iLoop;
	CArray<int,int>		arrIndex;
	BOOL				bFind;

	for(iy=rect.top;iy<=rect.bottom;iy++)
	{
		for(ix=rect.left;ix<=rect.right;ix++)
		{
			if(m_pContourMap[iy][ix] > 0)
			{
				bFind = FALSE;
				for(iLoop=0;iLoop<arrIndex.GetSize();iLoop++)
				{
					if(m_pContourMap[iy][ix] == arrIndex.GetAt(iLoop))
					{
						bFind = TRUE;
						break;
					}
				}
				if(bFind == FALSE)
					arrIndex.Add(m_pContourMap[iy][ix]);
			}
		}
	}

	int					nMaxIdx = 0,nMaxVal = 0,nIdx=0;
	nMaxIdx = -1;
	for(iLoop=0;iLoop<arrIndex.GetSize();iLoop++)
	{
		nIdx = arrIndex.GetAt(iLoop);		
		if(m_pContourCnt[nIdx] > nMaxVal)
		{
			nMaxVal = m_pContourCnt[nIdx];
			nMaxIdx = nIdx;
		}
	}

	return nMaxIdx;	
}

BOOL CSplineInspect::GetLabelPosition( int nIdx )
{
	m_mapSplinePos.clear();

	if(CheckBuffer() == FALSE)
		return FALSE;

	int			ix,iy,iLoop;		

	CSplinePoint		splinePos;
	m_nSplineOffsetX = m_nSplineOffsetY = INT_MAX;
	iLoop = 0;
	for(iy=m_lpBuffer->GetHeight()-1;iy>=0;iy--)
	{
		for(ix=0;ix<m_lpBuffer->GetWidth();ix++)
		{
			if(m_pContourMap[iy][ix] == nIdx)
			{
				splinePos.Reset();

				if(m_nSplineOffsetX > ix) m_nSplineOffsetX = ix;
				if(m_nSplineOffsetY > iy) m_nSplineOffsetY = iy;

				splinePos.origin = splinePos.rotate = CPoint(ix,iy);
				m_mapSplinePos.insert(std::make_pair(ix, splinePos));				
			}
		}		
	}

	return TRUE;
}

BOOL CSplineInspect::CheckBuffer()
{
	if(m_lpBuffer == NULL || m_lpBuffer->GetHeight() <= 0 || m_lpBuffer->GetWidth() <= 0)
		return FALSE;
	if(m_pLabelMap == NULL || m_pContourMap == NULL || m_pContourCnt == NULL)
		return FALSE;

	return TRUE;
}

BOOL CSplineInspect::CheckRange( int x,int y,CSISBuffer *buffer )
{
	if(x < 0 || y < 0)
		return FALSE;
	if(x >= buffer->GetWidth() || y >= buffer->GetHeight())
		return FALSE;

	return TRUE;
}

void CSplineInspect::ContourTracing( int cy, int cx, int labelindex, int tracingdirection )
{
	char tracingstopflag = 0, SearchAgain = 1;
	int fx, fy, sx = cx, sy = cy;

	Tracer(&cy, &cx, &tracingdirection);
	m_pContourMap[cy][cx] = labelindex;

	DWORD		dwStarttime = GetTickCount();
	const int	MAX_DELAY_TIME = 500;

	if(cx != sx || cy != sy)
	{
		fx = cx;
		fy = cy;

		while(SearchAgain)
		{
			if((GetTickCount()-dwStarttime) >= MAX_DELAY_TIME)							
				break;			

			tracingdirection = (tracingdirection + 6) % 8;
			m_pLabelMap[cy][cx] = labelindex;
			Tracer(&cy, &cx, &tracingdirection);
			m_pContourMap[cy][cx] = labelindex;

			if(cx == sx && cy == sy)
			{
				tracingstopflag = 1;
			}
			else if(tracingstopflag)
			{
				if(cx == fx && cy == fy)
				{
					SearchAgain = 0;
				}
				else
				{
					tracingstopflag = 0;
				}
			}
		}
	}
}

BOOL CSplineInspect::CheckRectToBuffer( CRect &rect )
{
	if(rect.left < 0 || rect.right >= m_lpBuffer->GetWidth() 
		|| rect.right < 0 || rect.right >= m_lpBuffer->GetWidth())
		return FALSE;

	if(rect.top < 0 || rect.top >= m_lpBuffer->GetHeight() 
		|| rect.bottom < 0 || rect.bottom >= m_lpBuffer->GetHeight())
		return FALSE;

	return TRUE;
}

BOOL CSplineInspect::Tracer( int *cy, int *cx, int *tracingdirection )
{
	int i, y, x;

	for(i = 0; i < 7; i++)
	{
		y = *cy + g_SearchDirection[*tracingdirection][0];
		x = *cx + g_SearchDirection[*tracingdirection][1];

		if(CheckRange(x,y,m_lpBuffer) == FALSE)
			return FALSE;

		if(*m_lpBuffer->GetDataAddress(x,y) == 0)
		{
			m_pLabelMap[y][x] = -1;
			*tracingdirection = (*tracingdirection + 1) % 8;
		}
		else
		{
			*cy = y;
			*cx = x;
			return TRUE;
		}
	}
	return TRUE;
}	

BOOL CSplineInspect::SetImage( CSISBuffer *lpBuffer )
{
	if(lpBuffer == NULL || lpBuffer->IsValidBuffer() == FALSE)
		return FALSE;

	int			i;

	ReleaseBuffer();
	ReleaseBlob();
	
	m_lpBuffer = lpBuffer;
	m_szImageOrg = CSize(m_lpBuffer->GetWidth(),m_lpBuffer->GetHeight());
	
	if(m_lpBuffer != NULL && m_lpBuffer->GetHeight() > 0 && m_lpBuffer->GetWidth() > 0)
	{		
		m_pLabelMap = new int*[m_lpBuffer->GetHeight()];	
		m_pContourMap = new int*[m_lpBuffer->GetHeight()];
		
		for(i=0;i<m_lpBuffer->GetHeight();i++)
		{
			m_pLabelMap[i] = new int[m_lpBuffer->GetWidth()];			
			m_pContourMap[i] = new int[m_lpBuffer->GetWidth()];

			ZeroMemory(m_pLabelMap[i],sizeof(int)*m_lpBuffer->GetWidth());
			ZeroMemory(m_pContourMap[i],sizeof(int)*m_lpBuffer->GetWidth());
		}

		m_pContourCnt = new int[m_lpBuffer->GetHeight()*m_lpBuffer->GetWidth()];
		ZeroMemory(m_pContourCnt,sizeof(int)*m_lpBuffer->GetHeight()*m_lpBuffer->GetWidth());

		return TRUE;
	/*
		CString				strFile = "D:\\Image\\Origin.bmp";
		CBufferAttach		attach(strFile);
		attach.AttachToFile(*m_lpBuffer);
*/
	}

	return FALSE;
}