#include "StdAfx.h"
#include "EdgeTriangle.h"
#include "CHImageControls/CHImageProcess.h"
#include "FormulaParser.h"
#include "CHCommonClasses/ProcessTimer.h"
#include "CHImageControls/CHDataFitting.h"
#include <numeric>
#include <math.h>
#include <tmmintrin.h>
#include <smmintrin.h>

#include "OpenCV/cxcore.h"



using namespace CHImageControls;

static BYTE pDeleteArray[512] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 
								  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
								  1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; 

inline bool CompareMaxSize(CPixelRegion& a, CPixelRegion& b)
{
	return (a.GetMaxSize() > b.GetMaxSize());
}

inline bool CompareMinSize(CPixelRegion& a, CPixelRegion& b)
{
	return (a.GetMinSize() > b.GetMinSize());
}

int  Round( double value )
{
#if (defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__)
	__m128d t = _mm_set_sd( value );
	return _mm_cvtsd_si32(t);
#elif defined _MSC_VER && defined _M_IX86
	int t;
	__asm
	{
		fld value;
		fistp t;
	}
	return t;
#elif defined _MSC_VER && defined _M_ARM && defined HAVE_TEGRA_OPTIMIZATION
	TEGRA_ROUND(value);
#elif defined CV_ICC || defined __GNUC__
#  ifdef HAVE_TEGRA_OPTIMIZATION
	TEGRA_ROUND(value);
#  else
	return (int)lrint(value);
#  endif
#else
	double intpart, fractpart;
	fractpart = modf(value, &intpart);
	if ((fabs(fractpart) != 0.5) || ((((int)intpart) % 2) != 0))
		return (int)(value + (value >= 0 ? 0.5 : -0.5));
	else
		return (int)intpart;
#endif
}

double CEdgeTriangle::AbsSum(double init, double x)
{
	x = (x>0) ? x: -x;
	return init + x;
}

double CEdgeTriangle::Sum(double init, double x)
{
	return init + x;
}

double CEdgeTriangle::Square(double init, double x)
{
	return init + x*x;
}

double CEdgeTriangle::Cubic(double init, double x)
{
	return init + x*x*x;
}

double CEdgeTriangle::ForthPower(double init, double x)
{
	return init + x*x*x*x;
}

void CEdgeTriangle::GetMinLocation(float *pImage, int nWidth, int nHeight, int nStep, int& nPosX, int& nPosY, double& dValue)
{
	float fValue = 9999.9f;  

	float *pSubX, *pSubY;
	pSubY = pImage;
	for(int i=0; i<nHeight; i++)
	{
		pSubX = pSubY;
		for(int j=0; j<nWidth; j++)  
		{  
			if (fValue > *pSubX)
			{
				nPosX = j;
				nPosY = i;
				fValue = *pSubX;
			}
			pSubX++;
		} 
		pSubY += nStep;
	}

	dValue = fValue;
}

void CEdgeTriangle::GetMaxLocation(float *pImage, int nWidth, int nHeight, int nStep, int& nPosX, int& nPosY, double& dValue)
{
	float fValue = -9999.9f;  

	float *pSubX, *pSubY;
	pSubY = pImage;
	for(int i=0; i<nHeight; i++)
	{
		pSubX = pSubY;
		for(int j=0; j<nWidth; j++)  
		{  
			if (fValue < *pSubX)
			{
				nPosX = j;
				nPosY = i;
				fValue = *pSubX;
			}
			pSubX++;
		} 
		pSubY += nStep;
	}

	dValue = fValue;
}


CEdgeTriangle::CEdgeTriangle(void)
{
	Reset();
}

CEdgeTriangle::~CEdgeTriangle(void)
{
	Reset();
}

BOOL CEdgeTriangle::ImageSobelEdge(CCHImageData* pSrcImage, CCHImageData* pDstImage)
{
	if (pSrcImage==NULL || pDstImage==NULL) return FALSE;

	BYTE *pSrcPtr = (BYTE*)pSrcImage->GetImageBuffer();
	short *pDstPtr = (short*)pDstImage->GetImageBuffer();

	int nWidth = pSrcImage->GetWidth();
	int nHeight = pSrcImage->GetHeight();
	int nSrcStep = pSrcImage->GetWidthStep();
	int nDstStep = pDstImage->GetWidthStep() / sizeof(short);

	__m128i zeroData		= _mm_setzero_si128();
	__m128i currentData		= _mm_setzero_si128();
	__m128i sobelData		= _mm_set1_epi16(2);
	__m128i lowUnpack		= _mm_setzero_si128(); // low unpack
	__m128i highUnpack		= _mm_setzero_si128(); // high unpack
	__m128i multiData		= _mm_setzero_si128();
	__m128i TopKernel		= _mm_setzero_si128();
	__m128i BottomKernel	= _mm_setzero_si128();
	__m128i tempData		= _mm_setzero_si128();

	static int nShiftOne, nShiftTwo;

	BYTE *pSrcImageX;
	short *pDstImageX;

	int nY0X2 = 2;
	int nY1X0 = nWidth;
	int nY1X2 = nWidth + 2;
	int nY2X0 = 2*nWidth;
	int nY2X2 = 2*nWidth + 2;

	int nRight = nWidth - 1;

	for (int y=0; y<nHeight-2; y++)
	{
		pSrcImageX = pSrcPtr + (y*nSrcStep);
		pDstImageX = pDstPtr + ((y+1)*nDstStep) + 1;

		for (int x=0; x<nWidth-7; x+=8)
		{
			// [1] vertical kernel

			// get pixel data (y+2,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0));
			tempData	= _mm_unpacklo_epi8(currentData, zeroData);		// low (Y2X0)
			highUnpack	= _mm_unpackhi_epi8(currentData, zeroData);		// high

			nShiftOne	= _mm_extract_epi16(highUnpack, 0);
			nShiftTwo	= _mm_extract_epi16(highUnpack, 1);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(tempData, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftOne, 7);

			// mul * 2
			multiData	= _mm_mullo_epi16(highUnpack, sobelData);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(highUnpack, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftTwo, 7);

			BottomKernel = _mm_add_epi16(tempData, multiData);
			BottomKernel = _mm_add_epi16(BottomKernel, highUnpack);		// bottom kernel value

			// get pixel data (y,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX));
			lowUnpack	= _mm_unpacklo_epi8(currentData, zeroData);		// low (Y0X0)
			highUnpack	= _mm_unpackhi_epi8(currentData, zeroData);		// high

			nShiftOne	= _mm_extract_epi16(highUnpack, 0);
			nShiftTwo	= _mm_extract_epi16(highUnpack, 1);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(lowUnpack, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftOne, 7);

			// mul * 2
			multiData	= _mm_mullo_epi16(highUnpack, sobelData);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(highUnpack, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftTwo, 7);

			TopKernel	= _mm_add_epi16(lowUnpack, multiData);
			TopKernel	= _mm_add_epi16(TopKernel, highUnpack);			// top kernel value

			TopKernel	= _mm_sub_epi16(TopKernel, BottomKernel);		// top = top - bottom

			// lowUnpack, TopKernel, sobelData, currentData, 

			// lowUnpack (Y0X0)
			// [1] Horizontal kernel
			// get pixel data (y+1,x) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low (Y1X0)
			highUnpack		= _mm_mullo_epi16(highUnpack, sobelData);		// mul * 2
			lowUnpack		= _mm_add_epi16(lowUnpack, highUnpack);			// add result

			// get pixel data (y+2,x) tempData (Y2X0)
			lowUnpack		= _mm_add_epi16(lowUnpack, tempData);			// add result


			// get pixel data (y,x+2) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY0X2));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low (Y0X2)
			lowUnpack		= _mm_sub_epi16(lowUnpack, highUnpack);			// sub result

			// get pixel data (y+1,x+2) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X2));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low (Y1X2)
			highUnpack		= _mm_mullo_epi16(highUnpack, sobelData);		// mul * 2
			lowUnpack		= _mm_sub_epi16(lowUnpack, highUnpack);			// sub result

			// get pixel data (y+2,x+2) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X2));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low (Y2X2)
			lowUnpack		= _mm_sub_epi16(lowUnpack, highUnpack);			// sub result

			TopKernel		= _mm_add_epi16(TopKernel, lowUnpack);			// add horizontal + vertical

			TopKernel		= _mm_srai_epi16(TopKernel, 1);					// shift right 1 <div>

			_mm_storeu_si128( (__m128i*)(pDstImageX), TopKernel);

			pSrcImageX += 8;
			pDstImageX += 8;
		}
		// error
		*(pDstPtr + (y*nDstStep)) = 0;
		*(pDstPtr + (y*nDstStep) + nRight) = 0;
	}

	// error
	*(pDstPtr + ((nHeight-1)*nDstStep)) = 0;
	*(pDstPtr + ((nHeight-2)*nDstStep)) = 0;
	*(pDstPtr + ((nHeight-1)*nDstStep)+ nRight) = 0;
	*(pDstPtr + ((nHeight-2)*nDstStep)+ nRight) = 0;

	return TRUE;
}

BOOL CEdgeTriangle::SetImageSource(CCHImageData* imageSource)
{
	if (imageSource==NULL) return FALSE;

	if (!imageSource->GetImageExist()) return FALSE;

	return m_imageSource.CopyImageFrom(imageSource);
}

BOOL CEdgeTriangle::SetImageModel(CCHImageData* imageModel)
{
	if (imageModel==NULL) return FALSE;

	if (!imageModel->GetImageExist()) return FALSE;

	return m_imageModel.CopyImageFrom(imageModel);
}

BOOL CEdgeTriangle::SetRecipeTriangle(const CRecipeTriangle& recipeTriangle)
{
	if (recipeTriangle.GetRecipeModelCount()<1) 
	{
		return FALSE;
	}

	if (recipeTriangle.GetRecipeMarkerCount()<1)
	{
		return FALSE;
	}

	if (recipeTriangle.GetRecipeFormulaCount()<1)
	{
		return FALSE;
	}

	m_recipeTriangle = recipeTriangle;

	return FALSE;
}

int CEdgeTriangle::ModelProcess(CCHImageData *imageModel, CCHImageData *imageSource)
{
	m_resultTriangle.ResetResultModel();

	if (imageModel==NULL || !imageModel->GetImageExist())
	{
		return ImageFailModel;
	}

	if (imageSource==NULL || !imageSource->GetImageExist())
	{
		return ImageFailSource;
	}

	UINT nModelCount = 0;
	if ((nModelCount=m_recipeTriangle.GetRecipeModelCount())<1)
	{
		return RecipeFailModel;
	}

	// find process
	CResultModel resultModel;
	CRecipeModel *pRecipeModel = NULL;
	CCHImageData bandModel, bandSource;
	
	for (UINT i=0; i<nModelCount; i++)
	{
		resultModel.Reset();
		pRecipeModel = m_recipeTriangle.GetRecipeModel(i);
		
		if (pRecipeModel!=NULL)
		{
			if (imageModel->GetBandImage(pRecipeModel->m_nTypeBand, &bandModel))
			{
				if (imageSource->GetBandImage(pRecipeModel->m_nTypeBand, &bandSource))
				{
					switch(pRecipeModel->m_nTypeMethod)
					{
					case ModelMethod_Full:
						resultModel.m_nResultCode = MatchFull(&bandSource, &bandModel, pRecipeModel, resultModel);
						break;

					case ModelMethod_Level:
						resultModel.m_nResultCode = MatchLevel(&bandSource, &bandModel, pRecipeModel, resultModel);
						break;

					default:
						resultModel.m_nResultCode = RecipeFailModel;
						break;
					}
				}
				else
				{
					resultModel.m_nResultCode = ImageFailBandSource;
				}
			}
			else
			{
				resultModel.m_nResultCode = ImageFailBandModel;
			}
		}
		else
		{
			resultModel.m_nResultCode = RecipeFailModel;
		}

		m_resultTriangle.AddResultModel(resultModel);
	}
	
	return ProcessSuccess;
}

BOOL CEdgeTriangle::MatchImage(CCHImageData *pSource, CCHImageData *pModel, CRect* pRect, double dScore, int& nPosX, int& nPosY, double& dResult)
{
	if (pRect==NULL)
	{
		if (!CCHImageProcess::ImageMatching(pSource, pModel, nPosX, nPosY, dResult))
		{
			return FALSE;
		}
	}
	else
	{
		if (!CCHImageProcess::ImageMatching(pSource, pModel, *pRect, nPosX, nPosY, dResult))
		{
			return FALSE;
		}
	}

	if (dResult < dScore) return FALSE;

	if (pRect)
	{
		nPosX = pRect->left + nPosX + int(double(pModel->GetWidth()) / 2.0 + 0.5);
		nPosY = pRect->top + nPosY + int(double(pModel->GetHeight()) / 2.0 + 0.5);
	}
	else
	{
		nPosX = nPosX + int(double(pModel->GetWidth()) / 2.0 + 0.5);
		nPosY = nPosY + int(double(pModel->GetHeight()) / 2.0 + 0.5);
	}

	return TRUE;
}

BOOL CEdgeTriangle::MatchImage(CCHImageData *pSource, CCHImageData *pModel, CRect* pRect, double dScore, double& dPosX, double& dPosY, double& dResult)
{
	if (pRect==NULL)
	{
		if (!CCHImageProcess::ImageMatching(pSource, pModel, dPosX, dPosY, dResult))
		{
			return FALSE;
		}
	}
	else
	{
		if (!CCHImageProcess::ImageMatching(pSource, pModel, *pRect, dPosX, dPosY, dResult))
		{
			return FALSE;
		}
	}

	if (dResult < dScore) return FALSE;
	
	double dHalfWidth = double(pModel->GetWidth()) / 2.0;
	double dHalfHeight = double(pModel->GetHeight()) / 2.0;

	// result
	if (pRect)
	{
		dPosX	+= double(pRect->left) + double(pModel->GetWidth()) / 2.0;
		dPosY	+= double(pRect->top) + double(pModel->GetHeight()) / 2.0;
	}
	else
	{
		dPosX	+= double(pModel->GetWidth()) / 2.0;
		dPosY	+= double(pModel->GetHeight()) / 2.0;
	}

	return TRUE;
}

int CEdgeTriangle::MatchFull(CCHImageData *pSource, CCHImageData *pModel, const CRecipeModel *pRecipeModel, CResultModel& resultModel)
{
	resultModel.Reset();

	if (!MatchImage(pSource, pModel, NULL, pRecipeModel->m_dScoreThres, resultModel.m_dCenterX, resultModel.m_dCenterY, resultModel.m_dResultScore))
	{
		return ProcessFailModel;
	}

	// full match
	double dHalfWidth	= double(pModel->GetWidth()) / 2.0;
	double dHalfHeight	= double(pModel->GetHeight()) / 2.0;

	resultModel.m_nFindLeft		= Round(resultModel.m_dCenterX - dHalfWidth);
	resultModel.m_nFindTop		= Round(resultModel.m_dCenterY - dHalfHeight);
	resultModel.m_nFindRight	= resultModel.m_nFindLeft + pModel->GetWidth();
	resultModel.m_nFindBottom	= resultModel.m_nFindTop + pModel->GetHeight();

	return ProcessSuccess;
}


int CEdgeTriangle::MatchLevel(CCHImageData *pSource, CCHImageData *pModel, const CRecipeModel *pRecipeModel, CResultModel& resultModel)
{
	resultModel.Reset();

	if (pRecipeModel->m_nLevelFirst < pRecipeModel->m_nLevelLast) return ProcessFailModel;

	CCHImageData resizeSource, resizeModel, resultImage;
	CCHImageData* pProcessSource = NULL;
	CCHImageData* pProcessModel = NULL;

	CRect rtRect;
	double dResult;
	int nLevel, nScale, nPosX, nPosY;
	
	nLevel = pRecipeModel->m_nLevelFirst;

	do
	{
		nPosX = nPosY = 0;
		pProcessSource = pProcessModel = NULL;
						
		if (nLevel==1)
		{
			pProcessSource = pSource;
			pProcessModel = pModel;
		}
		else
		{
			switch(nLevel)
			{
			case 2:
				if (ImageResizeHalf(pModel, &resizeModel)!=1) return ProcessFailModel;
				if (ImageResizeHalf(pSource, &resizeSource)!=1) return ProcessFailModel;
				break;
			case 3:
				if (ImageResizeQuarter(pModel, &resizeModel)!=1) return ProcessFailModel;
				if (ImageResizeQuarter(pSource, &resizeSource)!=1) return ProcessFailModel;
				break;
			case 4:
				if (ImageResizeOneEighth(pModel, &resizeModel)!=1) return ProcessFailModel;
				if (ImageResizeOneEighth(pSource, &resizeSource)!=1) return ProcessFailModel;
				break;
			default:
				return ProcessFailModel;
			}

			pProcessSource = &resizeSource;
			pProcessModel = &resizeModel;

		} // end if

		// last & first level
		if (nLevel==pRecipeModel->m_nLevelLast && nLevel==pRecipeModel->m_nLevelFirst)
		{
			if (!MatchImage(pProcessSource, pProcessModel, NULL, pRecipeModel->m_dScoreThres, resultModel.m_dCenterX, resultModel.m_dCenterY, resultModel.m_dResultScore))
			{
				return ProcessFailModel;
			}

			double dHalfWidth			= double(pProcessModel->GetWidth()) / 2.0;
			double dHalfHeight			= double(pProcessModel->GetHeight()) / 2.0;

			nScale = 1;
			nScale = nScale << (nLevel-1);

			resultModel.m_dCenterX		*= double(nScale);
			resultModel.m_dCenterY		*= double(nScale);

			resultModel.m_nFindLeft		= Round(resultModel.m_dCenterX - (dHalfWidth*double(nScale)));
			resultModel.m_nFindTop		= Round(resultModel.m_dCenterY - (dHalfHeight*double(nScale)));
			resultModel.m_nFindRight	= resultModel.m_nFindLeft + (pProcessModel->GetWidth()*nScale);
			resultModel.m_nFindBottom	= resultModel.m_nFindTop + (pProcessModel->GetHeight()*nScale);

			break; // break while
		}

		// last level
		if (nLevel==pRecipeModel->m_nLevelLast) 
		{
			if (!MatchImage(pProcessSource, pProcessModel, &rtRect, pRecipeModel->m_dScoreThres, resultModel.m_dCenterX, resultModel.m_dCenterY, resultModel.m_dResultScore))
			{
				return ProcessFailModel;
			}

			double dHalfWidth			= double(pProcessModel->GetWidth()) / 2.0;
			double dHalfHeight			= double(pProcessModel->GetHeight()) / 2.0;

			nScale = 1;
			nScale = nScale << (nLevel-1);

			resultModel.m_dCenterX		*= double(nScale);
			resultModel.m_dCenterY		*= double(nScale);

			resultModel.m_nFindLeft		= Round(resultModel.m_dCenterX - (dHalfWidth*double(nScale)));
			resultModel.m_nFindTop		= Round(resultModel.m_dCenterY - (dHalfHeight*double(nScale)));
			resultModel.m_nFindRight	= resultModel.m_nFindLeft + (pProcessModel->GetWidth()*nScale);
			resultModel.m_nFindBottom	= resultModel.m_nFindTop + (pProcessModel->GetHeight()*nScale);

			break; // break while
		}

		// first level
		if (nLevel==pRecipeModel->m_nLevelFirst) 
		{
			if (!MatchImage(pProcessSource, pProcessModel, NULL, pRecipeModel->m_dScoreThres, nPosX, nPosY, dResult))
			{
				return ProcessFailModel;
			}
			
			// check stop score
			nScale = 1;
			if (dResult > pRecipeModel->m_dScoreStop)
			{
				nScale = nScale << (nLevel-pRecipeModel->m_nLevelLast);
				nLevel = pRecipeModel->m_nLevelLast;
			}
			else
			{
				nScale = 2;
				nLevel--;
			}

			// set next level search range
			nPosX *= nScale;
			nPosY *= nScale;
			
			int nHalfWidth	= (pProcessModel->GetWidth() * nScale) / 2;
			int nHalfHeight	= (pProcessModel->GetWidth() * nScale) / 2;

			rtRect.left		= nPosX - nHalfWidth - pRecipeModel->m_nLevelRange;
			rtRect.top		= nPosY - nHalfHeight - pRecipeModel->m_nLevelRange;
			rtRect.right	= nPosX + nHalfWidth + pRecipeModel->m_nLevelRange;
			rtRect.bottom	= nPosY + nHalfHeight + pRecipeModel->m_nLevelRange;

			continue; // continue while
		}

		// middle level
		if (!MatchImage(pProcessSource, pProcessModel, &rtRect, pRecipeModel->m_dScoreThres, nPosX, nPosY, dResult))
		{
			return ProcessFailModel;
		}

		// check stop score
		nScale = 1;
		if (dResult > pRecipeModel->m_dScoreStop)
		{
			nScale = nScale << (nLevel-pRecipeModel->m_nLevelLast);
			nLevel = pRecipeModel->m_nLevelLast;
		}
		else
		{
			nScale = 2;
			nLevel--;
		}

		// set next level search range
		nPosX *= nScale;
		nPosY *= nScale;

		int nHalfWidth	= (pProcessModel->GetWidth() * nScale) / 2;
		int nHalfHeight	= (pProcessModel->GetWidth() * nScale) / 2;

		rtRect.left		= nPosX - nHalfWidth - pRecipeModel->m_nLevelRange;
		rtRect.top		= nPosY - nHalfHeight - pRecipeModel->m_nLevelRange;
		rtRect.right	= nPosX + nHalfWidth + pRecipeModel->m_nLevelRange;
		rtRect.bottom	= nPosY + nHalfHeight + pRecipeModel->m_nLevelRange;

	} while(nLevel>=pRecipeModel->m_nLevelLast);

	return ProcessSuccess;
}


int CEdgeTriangle::MarkerProcess(CCHImageData *imageSource)
{
	m_resultTriangle.ResetResultMarker();

	if (imageSource==NULL || !imageSource->GetImageExist())
	{
		return ImageFailSource;
	}

	UINT nMarkerCount = 0;
	if ((nMarkerCount=m_recipeTriangle.GetRecipeMarkerCount())<1)
	{
		return RecipeFailMarker;
	}

	// measure process
	int nResultCode = ProcessSuccess;

	CResultMarker resultMarker;
	CRecipeMarker *pRecipeMarker = NULL;
	CCHImageData bandSource;
	for (UINT i=0; i<nMarkerCount; i++)
	{
		resultMarker.Reset();
		pRecipeMarker = m_recipeTriangle.GetRecipeMarker(i);

		if (pRecipeMarker!=NULL)
		{
			resultMarker.m_nResultCode = MeasureImage(imageSource, pRecipeMarker, resultMarker);
		}
		else
		{
			nResultCode = RecipeFailMarker;
			resultMarker.m_nResultCode = RecipeFailMarker;
		}

		if (resultMarker.m_nResultCode!=ProcessSuccess)
		{
			nResultCode = ProcessFailMarker;
		}

		m_resultTriangle.AddResultMarker(resultMarker);
	}

	return nResultCode;
}

/*

BOOL CEdgeTriangle::GetEdgeLeftPosition(int nEdgeType, int nSearchType, int nStartPos, double& dPosition)
{
	if (m_vectorEdgeResult.size()<1) return FALSE;

	BOOL	bReturn		= FALSE;
	UINT	nWidth		= (UINT)m_vectorImageData.size();
	double	dValue		= -9999.0;
	int		nIndex		= -1;

	UINT i = 0;
	switch(nSearchType)
	{
	case EdgeSearch_Out2In:
		dPosition = 9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	

			if (m_vectorEdgeResult[i].dPosition < dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_In2Out:
		dPosition = -9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > (nWidth/2)) continue;

			if (m_vectorEdgeResult[i].dPosition > dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_MinMax:
		dValue = 0.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	

			if ( fabs(dValue) < fabs(m_vectorEdgeResult[i].dStrength))
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	default:
		return FALSE;
	}

	if (nIndex!=-1)
		m_vectorEdgeResult[nIndex].nEdgeType = EdgeResult_Left;

	return bReturn;
}

BOOL CEdgeTriangle::GetEdgeRightPosition(int nEdgeType, int nSearchType, int nStartPos, double& dPosition)
{
	if (m_vectorEdgeResult.size()<1) return FALSE;

	BOOL	bReturn		= FALSE;
	UINT	nWidth		= (UINT)m_vectorImageData.size();
	double	dValue		= -9999.0;
	int		nIndex		= -1;

	UINT i = 0;
	switch(nSearchType)
	{
	case EdgeSearch_Out2In:
		dPosition = -9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	

			if (m_vectorEdgeResult[i].dPosition > dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_In2Out:
		dPosition = 9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	

			if (m_vectorEdgeResult[i].dPosition < dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_MinMax:
		dValue = 0;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	

			if ( fabs(dValue) < fabs(m_vectorEdgeResult[i].dStrength))
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	default:
		return FALSE;
	}

	if (nIndex!=-1)
		m_vectorEdgeResult[nIndex].nEdgeType = EdgeResult_Right;

	return bReturn;
}

*/

BOOL CEdgeTriangle::GetEdgeLeftPosition(int nEdgeType, int nSearchType, int nStartPos, int nEndPos, double& dPosition)
{
	if (m_vectorEdgeResult.size()<1) return FALSE;

	BOOL	bReturn		= FALSE;
	UINT	nWidth		= (UINT)m_vectorImageData.size();
	double	dValue		= -9999.0;
	int		nIndex		= -1;

	UINT i = 0;
	switch(nSearchType)
	{
	case EdgeSearch_Out2In:
		dPosition = 9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > nEndPos) continue;	

			if (m_vectorEdgeResult[i].dPosition < dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_In2Out:
		dPosition = -9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > nEndPos) continue;

			if (m_vectorEdgeResult[i].dPosition > dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_MinMax:
		dValue = 0.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > nEndPos) continue;

			if ( fabs(dValue) < fabs(m_vectorEdgeResult[i].dStrength))
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	default:
		return FALSE;
	}

	if (nIndex!=-1)
		m_vectorEdgeResult[nIndex].nEdgeType = EdgeResult_Left;

	return bReturn;
}

BOOL CEdgeTriangle::GetEdgeRightPosition(int nEdgeType, int nSearchType, int nStartPos, int nEndPos, double& dPosition)
{
	if (m_vectorEdgeResult.size()<1) return FALSE;

	BOOL	bReturn		= FALSE;
	UINT	nWidth		= (UINT)m_vectorImageData.size();
	double	dValue		= -9999.0;
	int		nIndex		= -1;

	UINT i = 0;
	switch(nSearchType)
	{
	case EdgeSearch_Out2In:
		dPosition = -9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > nEndPos) continue;	

			if (m_vectorEdgeResult[i].dPosition > dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_In2Out:
		dPosition = 9999.;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > nEndPos) continue;	

			if (m_vectorEdgeResult[i].dPosition < dPosition)
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	case EdgeSearch_MinMax:
		dValue = 0;
		for (i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if (m_vectorEdgeResult[i].nSignal != nEdgeType) continue;
			if (m_vectorEdgeResult[i].dPosition < nStartPos) continue;	
			if (m_vectorEdgeResult[i].dPosition > nEndPos) continue;	

			if ( fabs(dValue) < fabs(m_vectorEdgeResult[i].dStrength))
			{
				dValue		= m_vectorEdgeResult[i].dStrength;
				dPosition	= m_vectorEdgeResult[i].dPosition;
				bReturn		= TRUE;
				nIndex		= i;
			}
		}
		break;

	default:
		return FALSE;
	}

	if (nIndex!=-1)
		m_vectorEdgeResult[nIndex].nEdgeType = EdgeResult_Right;

	return bReturn;
}


BOOL CEdgeTriangle::GetImageData(CCHImageData* pSubImage, VectorDouble& vectorImageData)
{
	if (pSubImage==NULL || !pSubImage->GetImageExist() || pSubImage->GetChannels()>1) return FALSE;

	int nWidth = pSubImage->GetWidth();
	int nHeight = pSubImage->GetHeight();
	int nStep = pSubImage->GetWidthStep();
	BYTE *pImage = (BYTE*)pSubImage->GetImageBuffer();

	// edge dir
	if (pSubImage->GetWidth()>pSubImage->GetHeight())
	{
		return CalculateImageValue(EdgeDirection_Vert, pImage, nWidth, nHeight, nStep, vectorImageData);
	}

	return CalculateImageValue(EdgeDirection_Horiz, pImage, nWidth, nHeight, nStep, vectorImageData);
}

BOOL CEdgeTriangle::GetEdgeData(CCHImageData* pSubImage, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma)
{
	VectorDouble vectorImageData;
	if (!GetImageData(pSubImage, vectorImageData))
	{
		return FALSE;
	}
	return CalculateEdgeValue(vectorImageData, vectorEdgeData, nKernelSize, dKernelSigma);
}

BOOL CEdgeTriangle::GetEdgeData(int& nBandType, CCHImageData* pSubImage, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma)
{
	if (nBandType==BandTypeColor)
	{
		CCHImageData bandImage;
		
		double dSum = 0.0, dTmpSum;
		VectorDouble vectorBandData;
		VectorDouble vectorBandEdgeData;

		for (int i=0; i<BandTypeColor; i++)
		{
			vectorBandData.clear();
			vectorBandEdgeData.clear();

			if (!pSubImage->GetBandImage(i, &bandImage)) continue;

			if (!GetImageData(&bandImage, vectorBandData)) continue;

			if (!CalculateEdgeValue(vectorBandData, vectorBandEdgeData, nKernelSize, dKernelSigma)) continue;

			dTmpSum = std::accumulate(vectorBandEdgeData.begin(), vectorBandEdgeData.end(), 0.0, Sum);
			if (dSum > dTmpSum) continue;
			
			dSum = dTmpSum;
			nBandType = i;
			vectorEdgeData = vectorBandEdgeData;
		}

		if (nBandType==BandTypeColor) return FALSE;

		return TRUE;
	}

	VectorDouble vectorImageData;
	if (!GetImageData(pSubImage, vectorImageData))
	{
		return FALSE;
	}

	return CalculateEdgeValue(vectorImageData, vectorEdgeData, nKernelSize, dKernelSigma);
}


int CEdgeTriangle::MeasureImage(CCHImageData *imageSource, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker)
{
	// sub image
	int nRet = ProcessFailMarker;
	CCHImageData rectImage;

	int nWidth = pRecipeMarker->m_nROIWidth + (4 - (pRecipeMarker->m_nROIWidth%4));

	if (!imageSource->GetBandImage(pRecipeMarker->m_nTypeBand, 
		pRecipeMarker->m_nROILeft, pRecipeMarker->m_nROITop, nWidth, pRecipeMarker->m_nROIHeight, 
		&rectImage))
	{
		return ImageFailSub;	
	}

	// measure type
	resultMarker.m_nMeasureType = pRecipeMarker->m_nMeasureType;

	switch(pRecipeMarker->m_nMeasureType)
	{
	case Measure_Line:
		nRet = Process_MeasureLine(rectImage, pRecipeMarker, resultMarker);
		break;
	case Measure_Circle:
		nRet = Process_MeasureCircle(rectImage, pRecipeMarker, resultMarker);
		break;
	case Measure_Ellipse:
		nRet = Process_MeasureEllipse(rectImage, pRecipeMarker, resultMarker);
		break;
	default:
		return ProcessFailMarker;
	}

	return nRet;
}

int CEdgeTriangle::Process_MeasureLine(CCHImageData& imageData, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker)
{
	// result clear
	m_vectorImageData.clear();
	m_vectorEdgeType.clear();
	m_vectorEdgeData.clear();
	m_vectorEdgeResult.clear();

	// pre-process
	switch(pRecipeMarker->m_nTypePreProcess)
	{
	case PreProc_None:
		{
			CalculateImageValue(
				pRecipeMarker->m_nEdgeDirection, 
				(BYTE*)imageData.GetImageBuffer(), 
				imageData.GetWidth(), 
				imageData.GetHeight(), 
				imageData.GetWidthStep()/sizeof(BYTE), 
				m_vectorImageData);

			CalculateEdgeValue(
				m_vectorImageData, 
				m_vectorEdgeData, 
				m_vectorEdgeType,
				pRecipeMarker->m_dEdgePosiThres, 
				pRecipeMarker->m_dEdgeNegaThres,
				pRecipeMarker->m_nEdgeKernelSize,
				pRecipeMarker->m_dEdgeKernelSigma);

			break;
		}

	case PreProc_Sobel:
		{
			CCHImageData edgeImage(imageData.GetWidth(), imageData.GetHeight(), IPL_DEPTH_16S, 1);
			if (!ImageSobelEdge(&imageData, &edgeImage)) 
			{
				return PreProcessFail;
			}

			CalculateEdgeValue(
				pRecipeMarker->m_nEdgeDirection,
				(short*)edgeImage.GetImageBuffer(), 
				edgeImage.GetWidth(), 
				edgeImage.GetHeight(), 
				edgeImage.GetWidthStep()/sizeof(short), 
				m_vectorEdgeData, 
				m_vectorEdgeType,
				pRecipeMarker->m_dEdgePosiThres, 
				pRecipeMarker->m_dEdgeNegaThres);

			break;
		}

	default:
		return ProcessFailMarker;
	}

// 	FILE *fp = NULL;
// 	_tfopen_s(&fp, _T("d:\\result.csv"), _T("w"));
// 	for (int i=0; i<(int)m_vectorImageData.size(); i++)
// 	{
// 		_ftprintf_s(fp, _T("%d, %lf, %lf\n"), i, m_vectorImageData[i], m_vectorEdgeData[i]);	
// 	}
// 	fclose(fp);


	// calculate edge position
	CalculateEdgePosition(pRecipeMarker->m_nTypeSubPixel, pRecipeMarker->m_dEdgePosiThres, pRecipeMarker->m_dEdgeNegaThres, pRecipeMarker->m_nIteration);

	double dLeftPos = 9999.0;
	double dRightPos = -9999.0;

	if(pRecipeMarker->m_nEdgeSearchType==EdgeSearch_MinMax)
	{
		int nIdx = -1;
		double dValue = 0;

		//left
		for(int i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if(m_vectorEdgeResult[i].nSignal != pRecipeMarker->m_nEdgeLeft)	continue;
			if(fabs(dValue) < fabs(m_vectorEdgeResult[i].dStrength))
			{
				dValue = m_vectorEdgeResult[i].dStrength;
				dLeftPos = m_vectorEdgeResult[i].dPosition;
				nIdx = i;
			}
		}
		if(dLeftPos == 9999.0) return EdgeFailLeft;
		m_vectorEdgeResult[nIdx].nEdgeType = EdgeResult_Left;

		dValue = 0;
		//Right
		for(int i=0; i<m_vectorEdgeResult.size(); i++)
		{
			if(m_vectorEdgeResult[i].nSignal != pRecipeMarker->m_nEdgeRight)	continue;
			if(fabs(dValue) < fabs(m_vectorEdgeResult[i].dStrength))
			{
				dValue = m_vectorEdgeResult[i].dStrength;
				dRightPos = m_vectorEdgeResult[i].dPosition;
				nIdx = i;
			}
		}
		if(dRightPos == -9999.0) return EdgeFailRight;
		m_vectorEdgeResult[nIdx].nEdgeType = EdgeResult_Right;
	}
	else
	{
		// get left position
		if (!GetEdgeLeftPosition(pRecipeMarker->m_nEdgeLeft, pRecipeMarker->m_nEdgeSearchType, 0, int(m_vectorEdgeData.size()/2), dLeftPos))
		{
			return EdgeFailLeft;
		}

		// get right position
		if (!GetEdgeRightPosition(pRecipeMarker->m_nEdgeRight, pRecipeMarker->m_nEdgeSearchType, int(m_vectorEdgeData.size()/2), int(m_vectorEdgeData.size()), dRightPos))
		{
			return EdgeFailRight;
		}
	}

	// set marker result
	switch (pRecipeMarker->m_nEdgeDirection)
	{
	case EdgeDirection_Vert:
		resultMarker.m_nEdgeDirection = EdgeDirection_Vert;
		resultMarker.m_dLength = dRightPos - dLeftPos;

		resultMarker.m_dFirstX = double(pRecipeMarker->m_nROILeft) + dLeftPos;
		resultMarker.m_dSecondX = double(pRecipeMarker->m_nROILeft) + dRightPos;
		resultMarker.m_dCenterX = double(pRecipeMarker->m_nROILeft) + dLeftPos + (resultMarker.m_dLength)/2.0;

		resultMarker.m_dFirstY = double(pRecipeMarker->m_nROITop) + (double(pRecipeMarker->m_nROIHeight)/2.0);
		resultMarker.m_dSecondY = double(pRecipeMarker->m_nROITop) + (double(pRecipeMarker->m_nROIHeight)/2.0);
		resultMarker.m_dCenterY = double(pRecipeMarker->m_nROITop) + (double(pRecipeMarker->m_nROIHeight)/2.0);
		break;

	case EdgeDirection_Horiz:
		resultMarker.m_nEdgeDirection = EdgeDirection_Horiz;
		resultMarker.m_dLength = dRightPos - dLeftPos;

		resultMarker.m_dFirstY = double(pRecipeMarker->m_nROITop) + dLeftPos;
		resultMarker.m_dSecondY = double(pRecipeMarker->m_nROITop) + dRightPos;
		resultMarker.m_dCenterY = double(pRecipeMarker->m_nROITop) + dLeftPos + (resultMarker.m_dLength)/2.0;

		resultMarker.m_dFirstX = double(pRecipeMarker->m_nROILeft) + (double(pRecipeMarker->m_nROIWidth)/2.0);
		resultMarker.m_dSecondX = double(pRecipeMarker->m_nROILeft) + (double(pRecipeMarker->m_nROIWidth)/2.0);
		resultMarker.m_dCenterX = double(pRecipeMarker->m_nROILeft) + (double(pRecipeMarker->m_nROIWidth)/2.0);
		break;
	}

	return ProcessSuccess;
}

int CEdgeTriangle::Process_MeasureCircle(CCHImageData& imageData, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker)
{
	int nWidth = imageData.GetWidth();
	int nHeight = imageData.GetHeight();

	CCHImageData edgeImage;
	edgeImage.CreateImage(nWidth, nHeight);
	edgeImage.ClearImage(0);

	BYTE* pSrcImage = (BYTE*)imageData.GetImageBuffer();
	BYTE *pEdgeImage = (BYTE*)edgeImage.GetImageBuffer();

	// step 1: sobel edge
	if (!ImageSobelEdge(pSrcImage, pEdgeImage, nWidth, nHeight))
	{
		return CircleCoefficientFail;
	}
	//	edgeImage.SaveImage(_T("d:\\edge.bmp"));

	// step 2: threshold
	if (!ImageThresholding(pEdgeImage, nWidth, nHeight, pRecipeMarker->m_nCircleThreshold))
	{
		return CircleCoefficientFail;
	}
	//	edgeImage.SaveImage(_T("d:\\thres.bmp"));

	// step 3: closing
	CCHImageData closeImage;
	closeImage.CreateImage(nWidth, nHeight);
	BYTE *pCloseImage = (BYTE*)closeImage.GetImageBuffer();
	ImageDilate(pEdgeImage, pCloseImage, nWidth, nHeight);
	ImageErode(pCloseImage, pEdgeImage, nWidth, nHeight);
	//	edgeImage.SaveImage(_T("d:\\close.bmp"));

	// step 4: thinning
	if (!ImageThinning(pEdgeImage, nWidth, nHeight))
	{
		return CircleCoefficientFail;
	}
	//	edgeImage.SaveImage(_T("d:\\thin.bmp"));

	// step 5: blob analysis
	VectorPixelRegion vectorPixelRegion;
	if (!ImageBlobAnalysis(pEdgeImage, nWidth, nHeight, vectorPixelRegion, pRecipeMarker->m_nCircleBlobMargin))
	{
		return CircleCoefficientFail;
	}

	VectorDouble vectorX, vectorY, vectorResult;
	for (VectorPointIt it=vectorPixelRegion[0].vectorPoint.begin(); it!=vectorPixelRegion[0].vectorPoint.end(); it++)
	{
		vectorX.push_back(it->x);
		vectorY.push_back(it->y);
	}

	if (CCHDataFitting::CircleFitting(vectorX, vectorY, vectorResult)<1)
	{
		return CircleCoefficientFail;
	}

	resultMarker.m_dCenterX = pRecipeMarker->m_nROILeft + vectorResult[0];
	resultMarker.m_dCenterY = pRecipeMarker->m_nROITop + vectorResult[1];
	resultMarker.m_dLength	= vectorResult[2];

	return TRUE;
}

int CEdgeTriangle::Process_MeasureEllipse(CCHImageData& imageData, const CRecipeMarker* pRecipeMarker, CResultMarker& resultMarker)
{
	int nWidth = imageData.GetWidth();
	int nHeight = imageData.GetHeight();

	CCHImageData edgeImage;
	edgeImage.CreateImage(nWidth, nHeight);
	edgeImage.ClearImage(0);
	
	BYTE* pSrcImage = (BYTE*)imageData.GetImageBuffer();
	BYTE *pEdgeImage = (BYTE*)edgeImage.GetImageBuffer();

	// step 1: sobel edge
	if (!ImageSobelEdge(pSrcImage, pEdgeImage, nWidth, nHeight))
	{
		return CircleCoefficientFail;
	}
//	edgeImage.SaveImage(_T("d:\\edge.bmp"));

	// step 2: threshold
	if (!ImageThresholding(pEdgeImage, nWidth, nHeight, pRecipeMarker->m_nCircleThreshold))
	{
		return CircleCoefficientFail;
	}
//	edgeImage.SaveImage(_T("d:\\thres.bmp"));

	// step 3: closing
	CCHImageData closeImage;
	closeImage.CreateImage(nWidth, nHeight);
	BYTE *pCloseImage = (BYTE*)closeImage.GetImageBuffer();
	ImageDilate(pEdgeImage, pCloseImage, nWidth, nHeight);
	ImageErode(pCloseImage, pEdgeImage, nWidth, nHeight);
//	edgeImage.SaveImage(_T("d:\\close.bmp"));
	
	// step 4: thinning
	if (!ImageThinning(pEdgeImage, nWidth, nHeight))
	{
		return CircleCoefficientFail;
	}
//	edgeImage.SaveImage(_T("d:\\thin.bmp"));

	// step 5: blob analysis
	VectorPixelRegion vectorPixelRegion;
	if (!ImageBlobAnalysis(pEdgeImage, nWidth, nHeight, vectorPixelRegion, pRecipeMarker->m_nCircleBlobMargin))
	{
		return CircleCoefficientFail;
	}

	VectorDouble vectorX, vectorY, vectorResult;
	for (VectorPointIt it=vectorPixelRegion[0].vectorPoint.begin(); it!=vectorPixelRegion[0].vectorPoint.end(); it++)
	{
		vectorX.push_back(it->x);
		vectorY.push_back(it->y);
	}

	// step 6: ellipse fitting
	if (CCHDataFitting::EllipseFitting(vectorX, vectorY, vectorResult)<1)
	{
		return CircleCoefficientFail;
	}

	resultMarker.m_dCenterX = pRecipeMarker->m_nROILeft + vectorResult[0];	// center x
	resultMarker.m_dCenterY = pRecipeMarker->m_nROITop + vectorResult[1];	// center y
	resultMarker.m_dFirstY	= resultMarker.m_dFirstX	= vectorResult[2];	// length width
	resultMarker.m_dSecondY	= resultMarker.m_dSecondX	= vectorResult[3];	// length height
	resultMarker.m_dLength	= vectorResult[4];								// angle

	return TRUE;
}

BOOL CEdgeTriangle::CalculateImageValue(int nDirection, BYTE *pImage, int nWidth, int nHeight, int nStep, VectorDouble& vectorImageData)
{
	vectorImageData.clear();

	if (pImage==NULL) return FALSE;

	double dValue = 0.0;

	switch (nDirection)
	{
	case EdgeDirection_Vert:
		for (int j=0; j<nWidth; j++)
		{
			dValue = 0.0;
			for (int i=0; i<nHeight; i++)
			{
				dValue += pImage[(i*nStep)+j];
			}
			dValue /= double(nHeight);
			vectorImageData.push_back(dValue);
		}
		break;

	case EdgeDirection_Horiz:
		for (int i=0; i<nHeight; i++)
		{	
			dValue = 0.0;
			for (int j=0; j<nWidth; j++)
			{
				dValue += UCHAR(pImage[(i*nStep)+j]);
			}
			dValue /= double(nWidth);
			vectorImageData.push_back(dValue);
		}
		break;
	}

	return TRUE;
}


BOOL CEdgeTriangle::CalculateEdgeValue(int nDirection, short *pImage, int nWidth, int nHeight, int nStep, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres)
{
	vectorEdgeData.clear();
	vectorEdgeType.clear();

	if (pImage==NULL) return FALSE;

	double dValue = 0.0;
	int nType = EdgeSignal_None;

	switch (nDirection)
	{
	case EdgeDirection_Vert:
		for (int j=0; j<nWidth; j++)
		{
			dValue = 0.0;
			nType = EdgeSignal_None;

			for (int i=0; i<nHeight; i++)
			{
				dValue += pImage[(i*nStep)+j];
			}
			dValue /= double(nHeight);

			if (dValue >= dPositiveThres)
			{
				nType = EdgeSignal_Positive;
			}
			else if (dValue <= dNegativeThres )
			{
				nType = EdgeSignal_Negative;
			}

			vectorEdgeType.push_back(nType);
			vectorEdgeData.push_back(dValue);
		}
		break;

	case EdgeDirection_Horiz:
		for (int i=0; i<nHeight; i++)
		{	
			dValue = 0.0;
			nType = EdgeSignal_None;

			for (int j=0; j<nWidth; j++)
			{
				dValue += UCHAR(pImage[(i*nStep)+j]);
			}
			dValue /= double(nWidth);
			
			if (dValue >= dPositiveThres)
			{
				nType = EdgeSignal_Positive;
			}
			else if (dValue <= dNegativeThres )
			{
				nType = EdgeSignal_Negative;
			}

			vectorEdgeData.push_back(dValue);
			vectorEdgeType.push_back(nType);
		}
		break;
	}

	return TRUE;
}

//2014-02-28
/*
BOOL CEdgeTriangle::CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma)
{	
	vectorEdgeData.clear();

	double dLeft	= 0.0;
	double dRight	= 0.0;
	double dValue	= 0.0;

	// half gaussian
	VectorDouble kernelTemp;
	double dDiv = sqrt(2.0*CV_PI)*dKernelSigma;
	for (int i=0; i<10; i++)
	{
		dValue = (i + 0.5) * (i + 0.5);
		dValue = exp( -1.0 * ( dValue / (2.0*(dKernelSigma*dKernelSigma)) ) ) / dDiv;
		if (dValue<0.0001) break;
		kernelTemp.push_back(dValue);
	}

	// full gaussian
	int nPitchSize = (int)kernelTemp.size();
	VectorDouble kernelGaussian;
	for (int i=nPitchSize-1; i>=0; i--)
	{
		kernelGaussian.push_back(kernelTemp[i]);
	}
	for (int i=0; i<nPitchSize; i++)
	{
		kernelGaussian.push_back(kernelTemp[i]);
	}

	nKernelSize = nPitchSize * 2;

	if (vectorImageData.size()<nKernelSize) return FALSE;

	// push first pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
	}

	// push center pitch
	for (int i=0; i<vectorImageData.size()-(nKernelSize); i++)
	{
		dLeft = dRight = 0.0;
		for (int j=0; j<nPitchSize; j++)
		{
			dLeft	+= vectorImageData[i+j] * kernelGaussian[j];
			dRight	+= vectorImageData[i+j+nPitchSize] * kernelGaussian[j+nPitchSize];
		}
		dValue = dRight - dLeft;
		vectorEdgeData.push_back(dValue);
	}

	// push last pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
	}

	return TRUE;
}

BOOL CEdgeTriangle::CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres, int nKernelSize, double dKernelSigma)
{	
	vectorEdgeData.clear();
	vectorEdgeType.clear();

	int nType		= EdgeSignal_None;
	double dLeft	= 0.0;
	double dRight	= 0.0;
	double dValue	= 0.0;

	// half gaussian
	VectorDouble kernelTemp;
	double dDiv = sqrt(2.0*CV_PI)*dKernelSigma;
	for (int i=0; i<10; i++)
	{
		dValue = (i + 0.5) * (i + 0.5);
		dValue = exp( -1.0 * ( dValue / (2.0*(dKernelSigma*dKernelSigma)) ) ) / dDiv;
		if (dValue<0.0001) break;
		kernelTemp.push_back(dValue);
	}

	// full gaussian
	int nPitchSize = (int)kernelTemp.size();
	VectorDouble kernelGaussian;
	for (int i=nPitchSize-1; i>=0; i--)
	{
		kernelGaussian.push_back(kernelTemp[i]);
	}
	for (int i=0; i<nPitchSize; i++)
	{
		kernelGaussian.push_back(kernelTemp[i]);
	}

	nKernelSize = nPitchSize * 2;

	if (vectorImageData.size()<nKernelSize) return FALSE;

	// push first pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
		vectorEdgeType.push_back(EdgeSignal_None);
	}

	// push center pitch
	for (int i=0; i<vectorImageData.size()-(nKernelSize); i++)
	{
		dLeft = dRight = 0.0;
		nType = EdgeSignal_None;

		for (int j=0; j<nPitchSize; j++)
		{
			dLeft	+= vectorImageData[i+j] * kernelGaussian[j];
			dRight	+= vectorImageData[i+j+nPitchSize] * kernelGaussian[j+nPitchSize];
		}

		dValue = dRight - dLeft;
		if (dValue >= dPositiveThres)
		{
			nType = EdgeSignal_Positive;
		}
		else if (dValue <= dNegativeThres )
		{
			nType = EdgeSignal_Negative;
		}

		vectorEdgeData.push_back(dValue);
		vectorEdgeType.push_back(nType);
	}

	// push last pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
		vectorEdgeType.push_back(EdgeSignal_None);
	}

	return TRUE;
}
*/

BOOL CEdgeTriangle::CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, int nKernelSize, double dKernelSigma)
{       
	vectorEdgeData.clear();
	double dValue  = 0.0;

	// half gaussian
	VectorDouble kernelTemp;
	double dDiv = sqrt(2.0*CV_PI)*dKernelSigma;
	for (int i=0; i<20; i++)
	{
		dValue = (i) * (i);
		dValue = exp( -1.0 * ( dValue / (2.0*(dKernelSigma*dKernelSigma)) ) ) / dDiv;
		if (dValue<0.00001) break;
		kernelTemp.push_back(dValue);
	}

	// full gaussian
	int nPitchSize = (int)kernelTemp.size();
	VectorDouble kernelData;
	for (int i=nPitchSize-1; i>=0; i--)
	{
		kernelData.push_back(-kernelTemp[i]);
	}
	kernelData.push_back(0.0);

	for (int i=0; i<nPitchSize; i++)
	{
		kernelData.push_back(kernelTemp[i]);
	}

	nKernelSize = nPitchSize * 2;

	if (vectorImageData.size()<nKernelSize) return FALSE;

	// push first pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
	}

	// push center pitch
	for (int i=0; i<vectorImageData.size()-(nKernelSize); i++)
	{
		dValue = 0.0;
		for (int j=0; j<(int)kernelData.size(); j++)
		{
			dValue  += vectorImageData[i+j] * kernelData[j];
		}
		vectorEdgeData.push_back(dValue);
	}

	// push last pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
	}

	return TRUE;
}

BOOL CEdgeTriangle::CalculateEdgeValue(const VectorDouble& vectorImageData, VectorDouble& vectorEdgeData, VectorInteger& vectorEdgeType, double dPositiveThres, double dNegativeThres, int nKernelSize, double dKernelSigma)
{       
	vectorEdgeData.clear();
	vectorEdgeType.clear();
	int nType = EdgeSignal_None;
	double dValue  = 0.0;

	// half gaussian
	VectorDouble kernelTemp;
	double dDiv = sqrt(2.0*CV_PI)*dKernelSigma;
	for (int i=0; i<20; i++)
	{
		dValue = (i) * (i);
		dValue = exp( -1.0 * ( dValue / (2.0*(dKernelSigma*dKernelSigma)) ) ) / dDiv;
		if (dValue<0.00001) break;
		kernelTemp.push_back(dValue);
	}

	// full gaussian
	int nPitchSize = (int)kernelTemp.size();
	VectorDouble kernelData;
	for (int i=nPitchSize-1; i>=0; i--)
	{
		kernelData.push_back(-kernelTemp[i]);
	}
	kernelData.push_back(0.0);

	for (int i=0; i<nPitchSize; i++)
	{
		kernelData.push_back(kernelTemp[i]);
	}
	nKernelSize = nPitchSize * 2;

	if (vectorImageData.size()<nKernelSize) return FALSE;

	// push first pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
		vectorEdgeType.push_back(EdgeSignal_None);
	}

	// push center pitch
	for (int i=0; i<vectorImageData.size()-(nKernelSize); i++)
	{
		dValue = 0.0;
		nType = EdgeSignal_None;
		for (int j=0; j<(int)kernelData.size(); j++)
		{
			dValue  += vectorImageData[i+j] * kernelData[j];
		}

		if (dValue >= dPositiveThres)
		{
			nType = EdgeSignal_Positive;
		}
		else if (dValue <= dNegativeThres )
		{
			nType = EdgeSignal_Negative;
		}

		vectorEdgeData.push_back(dValue);
		vectorEdgeType.push_back(nType);
	}

	// push last pitch
	for (int i=0; i<nPitchSize; i++)
	{
		vectorEdgeData.push_back(0.0);
		vectorEdgeType.push_back(EdgeSignal_None);
	}

	return TRUE;
}

void CEdgeTriangle::CalculateEdgePosition(int nSubPixelType, double dPosiThres, double dNegaThres, int nIteration)
{
	m_vectorEdgeResult.clear();

	int nEdgeIndex = 0;
	int nEdgePosition = 0;
	int nEdgeType = EdgeSignal_None;
	double dEdgeValue = 0.0;
	double dEdgeThres = 0.0;

	if (nSubPixelType==SubPixel_Linear)
	{
		for (UINT i=1; i<m_vectorEdgeType.size()-1; i++)
		{
			if (m_vectorEdgeType[i-1] == m_vectorEdgeType[i]) continue;

			switch(m_vectorEdgeType[i])
			{
			case EdgeSignal_None:
				nEdgePosition = i-1;
				nEdgeType = m_vectorEdgeType[nEdgePosition];
				dEdgeThres = (m_vectorEdgeType[nEdgePosition]==EdgeSignal_Positive) ? dPosiThres: dNegaThres;
				dEdgeValue = m_vectorEdgeData[nEdgePosition];
				break;
			case EdgeSignal_Negative:
				nEdgePosition = i;
				nEdgeType = EdgeSignal_Negative;
				dEdgeThres = dNegaThres;
				dEdgeValue = m_vectorEdgeData[i];
				break;
			case EdgeSignal_Positive:
				nEdgePosition = i;
				nEdgeType = EdgeSignal_Positive;
				dEdgeThres = dPosiThres;
				dEdgeValue = m_vectorEdgeData[i];
				break;
			} // end switch

			if (nEdgeType==EdgeSignal_None) continue;
			
			CEdgeResult edgeResult(nEdgeIndex, nEdgeType, nEdgePosition, dEdgeValue);

			if (CalculateInterpolateLinear(edgeResult, dEdgeThres))
			{
				m_vectorEdgeResult.push_back(edgeResult);
				nEdgeIndex++;
			}

		} // end for
	}
	else
	{

		for (UINT i=1; i<m_vectorEdgeType.size()-1; i++)
		{
			nEdgeType = EdgeSignal_None;

			switch(m_vectorEdgeType[i])
			{
			case EdgeSignal_Positive:
				{
					nEdgeType		= EdgeSignal_Positive;
					nEdgePosition	= i;
					dEdgeValue		= m_vectorEdgeData[i];

					for (UINT j=i+1; m_vectorEdgeType.size()-1; j++)
					{
						if (m_vectorEdgeType[j] != EdgeSignal_Positive) break;

						if (dEdgeValue < m_vectorEdgeData[j])
						{
							nEdgePosition	= j;
							dEdgeValue		= m_vectorEdgeData[j];
						}
						i = j;
					}
				}
				break;

			case EdgeSignal_Negative:
				{
					nEdgeType		= EdgeSignal_Negative;
					nEdgePosition	= i;
					dEdgeValue		= m_vectorEdgeData[i];

					for (UINT j=i+1; m_vectorEdgeType.size()-1; j++)
					{
						if (m_vectorEdgeType[j] != EdgeSignal_Negative) break;

						if (dEdgeValue > m_vectorEdgeData[j])
						{
							nEdgePosition	= j;
							dEdgeValue		= m_vectorEdgeData[j];
						}
						i = j;
					}

				}
				break;
			} // end switch

			if (nEdgeType==EdgeSignal_None) continue;

			CEdgeResult edgeResult(nEdgeIndex, nEdgeType, nEdgePosition, dEdgeValue);

			switch(nSubPixelType)
			{
			case SubPixel_Quadratic:
				if (CalculateInterpolateQuadratic(edgeResult))
				{
					m_vectorEdgeResult.push_back(edgeResult);
					nEdgeIndex++;
				}
				break;

			case SubPixel_Gaussian:
				if (CalculateInterpolateGaussian(edgeResult, nEdgeType))
				{
					m_vectorEdgeResult.push_back(edgeResult);
					nEdgeIndex++;
				}
				break;
			
			case SubPixel_Quadratic_Regress:
				if (CalculateInterpolateQuadraticRegression(edgeResult))
				{
					m_vectorEdgeResult.push_back(edgeResult);
					nEdgeIndex++;
				}
				break;

			case SubPixel_Gaussian_Regress:
				if (CalculateInterpolateGaussianRegression(edgeResult, nEdgeType))
				{
					m_vectorEdgeResult.push_back(edgeResult);
					nEdgeIndex++;
				}
				break;

			} // end switch

		} // end for 
	}

}

BOOL CEdgeTriangle::CalculateInterpolateLinear(CEdgeResult& edgeResult, double dEdgeThreshold)
{
	UINT i = 0;

	int nPosition = edgeResult.nEdgePosition-1;
	double dPositionValue = m_vectorEdgeData[edgeResult.nEdgePosition-1];
	double dValue = m_vectorEdgeData[edgeResult.nEdgePosition];

	VectorDouble vectorX; // x point
	vectorX.push_back(double(edgeResult.nEdgePosition-1));
	vectorX.push_back(double(edgeResult.nEdgePosition));

	VectorDouble vectorY; // y point
	vectorY.push_back(m_vectorEdgeData[edgeResult.nEdgePosition-1]);
	vectorY.push_back(m_vectorEdgeData[edgeResult.nEdgePosition]);


	VectorDouble vectorResult;
	if (CCHDataFitting::PolynomialFitting(vectorX, vectorY, vectorResult, 1)<1)
	{
		return FALSE;
	}

	edgeResult.dPosition	= (dEdgeThreshold-vectorResult[0]) / vectorResult[1];
	edgeResult.dStrength	= dEdgeThreshold;

	return TRUE;
}

BOOL CEdgeTriangle::CalculateInterpolateQuadratic(CEdgeResult& edgeResult)
{
	if (m_vectorEdgeData.size()<1) return FALSE;

	UINT i = 0;

	for (i=edgeResult.nEdgePosition-1; i>0; i--)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nLeftPosition = i;
	}

	for (i=edgeResult.nEdgePosition+1; i<m_vectorEdgeType.size(); i++)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nRightPosition = i;
	}

	// coef
	if (edgeResult.nLeftPosition==edgeResult.nEdgePosition) 
		edgeResult.nLeftPosition = edgeResult.nEdgePosition - 1;

	if (edgeResult.nRightPosition==edgeResult.nEdgePosition) 
		edgeResult.nRightPosition = edgeResult.nEdgePosition + 1;

	edgeResult.nLeftPosition = edgeResult.nEdgePosition - 1;
	edgeResult.nRightPosition = edgeResult.nEdgePosition + 1;

	// set 3 point
	VectorDouble vectorX; // x point
// 	vectorX.push_back(double(edgeResult.nLeftPosition));
// 	vectorX.push_back(double(edgeResult.nEdgePosition));
// 	vectorX.push_back(double(edgeResult.nRightPosition));
	vectorX.push_back(0.0);
	vectorX.push_back(1.0);
	vectorX.push_back(2.0);

	VectorDouble vectorY; // y point
	vectorY.push_back(m_vectorEdgeData[edgeResult.nLeftPosition]);
	vectorY.push_back(m_vectorEdgeData[edgeResult.nEdgePosition]);
	vectorY.push_back(m_vectorEdgeData[edgeResult.nRightPosition]);

	VectorDouble vectorResult;
	if (CCHDataFitting::PolynomialFitting(vectorX, vectorY, vectorResult, 2)<1)
	{
		return FALSE;
	}

	edgeResult.dPosition	= edgeResult.nLeftPosition + (-1.0 * vectorResult[1]) / (2.0 * vectorResult[2]);
	edgeResult.dStrength	= -1.0 * ( ( (vectorResult[1]*vectorResult[1]) - (4.0 * vectorResult[2] * vectorResult[0]) ) / (4.0 * vectorResult[2]) );
	

	return TRUE;
}

BOOL CEdgeTriangle::CalculateInterpolateGaussian(CEdgeResult& edgeResult, int nEdgeType)
{
	if (m_vectorEdgeData.size()<1) return FALSE;

	UINT i = 0;

	for (i=edgeResult.nEdgePosition-1; i>0; i--)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nLeftPosition = i;
	}

	for (i=edgeResult.nEdgePosition+1; i<m_vectorEdgeType.size(); i++)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nRightPosition = i;
	}

	// coef
	if (edgeResult.nLeftPosition==edgeResult.nEdgePosition) 
		edgeResult.nLeftPosition = edgeResult.nEdgePosition - 1;

	if (edgeResult.nRightPosition==edgeResult.nEdgePosition) 
		edgeResult.nRightPosition = edgeResult.nEdgePosition + 1;

	edgeResult.nLeftPosition = edgeResult.nEdgePosition - 1;
	edgeResult.nRightPosition = edgeResult.nEdgePosition + 1;

	// set 3 point
	VectorDouble vectorX; // x point
// 	vectorX.push_back(double(edgeResult.nLeftPosition));
// 	vectorX.push_back(double(edgeResult.nEdgePosition));
// 	vectorX.push_back(double(edgeResult.nRightPosition));
	vectorX.push_back(0.0);
	vectorX.push_back(1.0);
	vectorX.push_back(2.0);


	VectorDouble vectorY; // y point
	if (nEdgeType==EdgeSignal_Negative)
	{
		vectorY.push_back(-m_vectorEdgeData[edgeResult.nLeftPosition]);
		vectorY.push_back(-m_vectorEdgeData[edgeResult.nEdgePosition]);
		vectorY.push_back(-m_vectorEdgeData[edgeResult.nRightPosition]);
	}
	else
	{
		vectorY.push_back(m_vectorEdgeData[edgeResult.nLeftPosition]);
		vectorY.push_back(m_vectorEdgeData[edgeResult.nEdgePosition]);
		vectorY.push_back(m_vectorEdgeData[edgeResult.nRightPosition]);
	}

	VectorDouble vectorResult;
	if (CCHDataFitting::GaussianFitting(vectorX, vectorY, vectorResult)<1)
	{
		return FALSE;
	}

	edgeResult.dPosition	= edgeResult.nLeftPosition + vectorResult[1];
	edgeResult.dStrength	= (nEdgeType==EdgeSignal_Negative) ? -vectorResult[0]: vectorResult[0];

	return TRUE;
}

BOOL CEdgeTriangle::CalculateInterpolateQuadraticRegression(CEdgeResult& edgeResult)
{
	if (m_vectorEdgeData.size()<1) return FALSE;

	UINT i = 0;

	for (i=edgeResult.nEdgePosition-1; i>0; i--)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nLeftPosition = i;
	}

	for (i=edgeResult.nEdgePosition+1; i<m_vectorEdgeType.size(); i++)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nRightPosition = i;
	}

	if ((edgeResult.nRightPosition-edgeResult.nLeftPosition)<2) return FALSE;

	int nIndex = 0;
	VectorDouble vectorX, vectorY;
	for (i=(UINT)edgeResult.nLeftPosition; i<(UINT)edgeResult.nRightPosition+1; i++)
	{
		vectorX.push_back(nIndex++);
		vectorY.push_back(m_vectorEdgeData[i]);
	}

	VectorDouble vectorResult;
	if (CCHDataFitting::PolynomialFitting(vectorX, vectorY, vectorResult, 2)<1)
	{
		return FALSE;
	}


	edgeResult.dPosition	= edgeResult.nLeftPosition + (-1.0 * vectorResult[1]) / (2.0 * vectorResult[2]);
	edgeResult.dStrength	= -1.0 * ( ( (vectorResult[1]*vectorResult[1]) - (4.0 * vectorResult[2] * vectorResult[0]) ) / (4.0 * vectorResult[2]) );

	return TRUE;
}

BOOL CEdgeTriangle::CalculateInterpolateGaussianRegression(CEdgeResult& edgeResult, int nEdgeType)
{
	if (m_vectorEdgeData.size()<1) return FALSE;

	UINT i = 0;

	for (i=edgeResult.nEdgePosition-1; i>0; i--)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nLeftPosition = i;
	}

	for (i=edgeResult.nEdgePosition+1; i<m_vectorEdgeType.size(); i++)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nRightPosition = i;
	}

	if ((edgeResult.nRightPosition-edgeResult.nLeftPosition)<2) return FALSE;

	int nIndex = 0;
	VectorDouble vectorX, vectorY;
	for (i=(UINT)edgeResult.nLeftPosition; i<(UINT)edgeResult.nRightPosition+1; i++)
	{
		vectorX.push_back(nIndex++);
		
		if (nEdgeType==EdgeSignal_Negative)
			vectorY.push_back(-m_vectorEdgeData[i]);
		else
			vectorY.push_back(m_vectorEdgeData[i]);
	}

	VectorDouble vectorResult;
	if (CCHDataFitting::GaussianFitting(vectorX, vectorY, vectorResult)<1)
	{
		return FALSE;
	}
 
	int nMaxPos = edgeResult.nEdgePosition - edgeResult.nLeftPosition;

	if (vectorResult[1] < nMaxPos-1.0 || vectorResult[1] > nMaxPos+1.0)
	{
		vectorX.clear();
		vectorX.push_back(0.0);
		vectorX.push_back(1.0);
		vectorX.push_back(2.0);

		vectorY.clear();
		edgeResult.nLeftPosition = edgeResult.nEdgePosition - 1;
		edgeResult.nRightPosition = edgeResult.nEdgePosition + 1;
		if (nEdgeType==EdgeSignal_Negative)
		{
			vectorY.push_back(-m_vectorEdgeData[edgeResult.nLeftPosition]);
			vectorY.push_back(-m_vectorEdgeData[edgeResult.nEdgePosition]);
			vectorY.push_back(-m_vectorEdgeData[edgeResult.nRightPosition]);
		}
		else
		{
			vectorY.push_back(m_vectorEdgeData[edgeResult.nLeftPosition]);
			vectorY.push_back(m_vectorEdgeData[edgeResult.nEdgePosition]);
			vectorY.push_back(m_vectorEdgeData[edgeResult.nRightPosition]);
		}

		vectorResult.clear();
		if (CCHDataFitting::GaussianFitting(vectorX, vectorY, vectorResult)<1)
		{
			return FALSE;
		}
	}

	edgeResult.dPosition	= edgeResult.nLeftPosition + vectorResult[1];
	edgeResult.dStrength	= (nEdgeType==EdgeSignal_Negative) ? -vectorResult[0]: vectorResult[0];

	return TRUE;
}

BOOL CEdgeTriangle::CalculateInterpolateGaussianRegressionReweight(CEdgeResult& edgeResult, int nEdgeType, int nIteration)
{
	if (m_vectorEdgeData.size()<1) return FALSE;

	UINT i = 0;

	for (i=edgeResult.nEdgePosition-1; i>0; i--)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nLeftPosition = i;
	}

	for (i=edgeResult.nEdgePosition+1; i<m_vectorEdgeType.size(); i++)
	{
		if (m_vectorEdgeType[i]!=edgeResult.nSignal) break;
		edgeResult.nRightPosition = i;
	}

	if ((edgeResult.nRightPosition-edgeResult.nLeftPosition)<2) return FALSE;

	VectorDouble vectorX, vectorY;
	for (i=(UINT)edgeResult.nLeftPosition; i<(UINT)edgeResult.nRightPosition+1; i++)
	{
		vectorX.push_back(double(i));

		if (nEdgeType==EdgeSignal_Negative)
			vectorY.push_back(-m_vectorEdgeData[i]);
		else
			vectorY.push_back(m_vectorEdgeData[i]);
	}

	VectorDouble vectorResult;
	nIteration = CCHDataFitting::IRLS_GaussianFitting(vectorX, vectorY, vectorResult, nIteration, 3.0);

	if (nIteration<1) return FALSE;

	edgeResult.dPosition	= vectorResult[1];
	edgeResult.dStrength	= (nEdgeType==EdgeSignal_Negative) ? -vectorResult[0]: vectorResult[0];

	return TRUE;
}


int	CEdgeTriangle::ModelMarkerProcess(CCHImageData *imageModel, CCHImageData *imageSource)
{
	int nResultCode = ModelProcess(imageModel, imageSource);

	if (nResultCode!=ProcessSuccess)
	{
		return nResultCode;
	}

	const CResultModel *pResultModel = m_resultTriangle.GetResultModel(0);
	if (pResultModel==NULL)
	{
		return ProcessFailModel;
	}

	if (pResultModel->m_nResultCode!=ProcessSuccess)
	{
		return ResultFailModel;
	}

	CCHImageData subImage;
	CRect rtRect(pResultModel->m_nFindLeft, pResultModel->m_nFindTop, pResultModel->m_nFindRight, pResultModel->m_nFindBottom);
	if (!imageSource->GetSubImage(rtRect, &subImage))
	{
		return ImageFailSub;
	}

	return MarkerProcess(&subImage);
}

int	CEdgeTriangle::MarkerFormulaProcess(CCHImageData *imageSource)
{
	m_resultTriangle.ResetResultMarker();

	int nResultCode = MarkerProcess(imageSource);

	if (nResultCode!=ProcessSuccess)
	{
		return nResultCode;
	}

	return FormulaProcess();
}

BOOL CEdgeTriangle::CheckFormulationString(const CString& strFormulation, CString& strResultFormulation, CRecipeTriangle* pRecipeTriangle)
{
	if (pRecipeTriangle==NULL) return FALSE;

	strResultFormulation = _T("");

	int s_idx = 0;
	int nIndex = 0;
	int nMarkerIndex = 0;
	CString cMarkerType = _T("");
	CString strItem = _T("");

	CRecipeMarker *pRecipeMarker = NULL;

	for (int i=0; i<strFormulation.GetLength(); i++)
	{
		TCHAR ch = strFormulation.GetAt(i);

		if (ch==_T('['))
		{
			nIndex = strFormulation.Find(_T(']'), i+1);

			if (nIndex>i)
			{
				strItem = strFormulation.Mid(i, (nIndex-i+1));
				
				int s_idx = strItem.Find(_T('%'), 0);
				if (s_idx<1) return FALSE;

				int e_idx = strItem.Find(_T('_'), s_idx+1);
				if (e_idx<1) return FALSE;

				// get marker index & result
				CString strIndex = strItem.Mid(s_idx+1, e_idx-s_idx-1);
				nMarkerIndex = ::_ttoi(strIndex) - 1;

				pRecipeMarker = pRecipeTriangle->GetRecipeMarker(nMarkerIndex);
				if (pRecipeMarker==NULL) return FALSE;

				// get marker type & result
				cMarkerType = strItem.GetAt(e_idx+1);

#ifdef X
				switch(cMarkerType)
				{
				case _T('F'):
					strItem.Format(_T("%d_First"), nMarkerIndex);
					break;
				case _T('S'):
					strItem.Format(_T("%d_Second"), nMarkerIndex);
					break;
				case _T('C'):
					strItem.Format(_T("%d_Center"), nMarkerIndex);
					break;
				case _T('L'):
					strItem.Format(_T("%d_Length"), nMarkerIndex);
					break;
				default:
					return FALSE;
				}
#else

				if (cMarkerType == "F") { strItem.Format(_T("%d_First"),  nMarkerIndex); }
				if (cMarkerType == "S") { strItem.Format(_T("%d_Second"), nMarkerIndex); }
				if (cMarkerType == "C") { strItem.Format(_T("%d_Center"), nMarkerIndex); }
				if (cMarkerType == "L") { strItem.Format(_T("%d_Length"), nMarkerIndex); }
#endif

				strResultFormulation += strItem;
				i = nIndex;
			}
			else
			{
				return FALSE;
			}

			continue;
		} // end if

		strResultFormulation += ch;
	}

	return TRUE;
}

BOOL CEdgeTriangle::GetResultFormulation(const CString& strFormulation, CString& strResultFormulation)
{
	strResultFormulation = _T("");
	
	int s_idx = 0;
	int nIndex = 0;
	int nMarkerIndex = 0;
	CString cMarkerType = _T("");
	CString strItem = _T("");

	const CResultMarker *pResultMarker = NULL;
	
	for (int i=0; i<strFormulation.GetLength(); i++)
	{
		TCHAR ch = strFormulation.GetAt(i);

		if (ch==_T('['))
		{
			nIndex = strFormulation.Find(_T(']'), i+1);

			if (nIndex>i)
			{
				strItem = strFormulation.Mid(i, (nIndex-i+1));

				int s_idx = strItem.Find(_T('%'), 0);
				if (s_idx<1) return FALSE;

				int e_idx = strItem.Find(_T('_'), s_idx+1);
				if (e_idx<1) return FALSE;

				// get marker index & result
				CString strIndex = strItem.Mid(s_idx+1, e_idx-s_idx-1);
				nMarkerIndex = ::_ttoi(strIndex) - 1;


				pResultMarker = m_resultTriangle.GetResultMarker((UINT)nMarkerIndex);
				if (pResultMarker==NULL) return FALSE;

				// get marker type & result
				cMarkerType = strItem.GetAt(e_idx+1);

				if (pResultMarker->m_nEdgeDirection==EdgeDirection_Vert)
				{
#ifdef X
					switch(cMarkerType)
					{
					case _T('F'):
						strItem.Format(_T("%lf"), pResultMarker->m_dFirstX);
						break;
					case _T('S'):
						strItem.Format(_T("%lf"), pResultMarker->m_dSecondX);
						break;
					case _T('C'):
						strItem.Format(_T("%lf"), pResultMarker->m_dCenterX);
						break;
					case _T('L'):
						strItem.Format(_T("%lf"), pResultMarker->m_dLength);
						break;
					default:
						return FALSE;
					}
#else
					if (cMarkerType == "F") { strItem.Format(_T("%lf"), pResultMarker->m_dFirstX);  }
					if (cMarkerType == "S") { strItem.Format(_T("%lf"), pResultMarker->m_dSecondX); }
					if (cMarkerType == "C") { strItem.Format(_T("%lf"), pResultMarker->m_dCenterX); }
					if (cMarkerType == "L") { strItem.Format(_T("%lf"), pResultMarker->m_dLength);  }
#endif
				}
				else
				{
#ifdef X
					switch(cMarkerType)
					{
					case _T('F'):
						strItem.Format(_T("%lf"), pResultMarker->m_dFirstY);
						break;
					case _T('S'):
						strItem.Format(_T("%lf"), pResultMarker->m_dSecondY);
						break;
					case _T('C'):
						strItem.Format(_T("%lf"), pResultMarker->m_dCenterY);
						break;
					case _T('L'):
						strItem.Format(_T("%lf"), pResultMarker->m_dLength);
						break;
					default:
						return FALSE;
					}
#else
					if (cMarkerType == "F") { strItem.Format(_T("%lf"), pResultMarker->m_dFirstY);  }
					if (cMarkerType == "S") { strItem.Format(_T("%lf"), pResultMarker->m_dSecondY); }
					if (cMarkerType == "C") { strItem.Format(_T("%lf"), pResultMarker->m_dCenterY); }
					if (cMarkerType == "L") { strItem.Format(_T("%lf"), pResultMarker->m_dLength);  }
#endif
				}
						
				strResultFormulation += strItem;
				i = nIndex;
			}
			else
			{
				return FALSE;
			}

			continue;
		} // end if
		
		strResultFormulation += ch;
	}
	
	return TRUE;
}

int	CEdgeTriangle::FormulaProcess()
{
	m_resultTriangle.ResetResultFormula();

	if (m_resultTriangle.GetResultMarkerCount()<1)
	{
		return ResultFailMarker;
	}

	UINT nFormulaCount = 0; 
	if ((nFormulaCount=m_recipeTriangle.GetRecipeFormulaCount())<1)
	{
		return RecipeFailFormula;
	}
	
	CString strResultFormulation = _T("");
	CEvaluator evaluator; 
	CRecipeFormula *pRecipeFormula = NULL;
	CResultFormula resultFormula;
	for (UINT i=0; i<nFormulaCount; i++)
	{
		resultFormula.Reset();
		pRecipeFormula = m_recipeTriangle.GetRecipeFormula(i);

		if (pRecipeFormula!=NULL)
		{
			resultFormula.m_strResultName = pRecipeFormula->m_strResultName;

			// get result formula string
			if (!GetResultFormulation(pRecipeFormula->m_strFormulation, strResultFormulation))
			{
				resultFormula.m_nResultCode = ProcessFailFormula;
			}
			else if(evaluator.Interpret(strResultFormulation))  // interpret formula
			{
				resultFormula.m_nResultCode = ProcessFailFormula;
			}
			else if (evaluator.Evaluate(resultFormula.m_dResultValue)) // calculate formula
			{
				resultFormula.m_nResultCode = ProcessFailFormula;
			}
			else
			{
				resultFormula.m_nResultCode = ProcessSuccess;
			}
		}
		else
		{
			resultFormula.m_nResultCode = RecipeFailFormula;
		}

		m_resultTriangle.AddResultFormula(resultFormula);
	}

	return ProcessSuccess;
}

int	CEdgeTriangle::TriangleProcess(CCHImageData *imageModel, CCHImageData *imageSource)
{
	int nResultCode = ModelMarkerProcess(imageModel, imageSource);

	if (nResultCode!=ProcessSuccess)
	{
		return nResultCode;
	}

	nResultCode = FormulaProcess();

	if (nResultCode!=ProcessSuccess)
	{
		return nResultCode;
	}

	return ProcessSuccess;
}

int	CEdgeTriangle::ProcessModel()
{
	return ModelProcess(&m_imageModel, &m_imageSource);
}

int	CEdgeTriangle::ProcessModel(CCHImageData* imageSource, const CRecipeModel& recipeModel)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.AddRecipeModel(recipeModel);

	return ModelProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModel(CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.SetRecipeModel(vectorRecipeModel);

	return ModelProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModel(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeModel& recipeModel)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.AddRecipeModel(recipeModel);

	return ModelProcess(imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModel(CCHImageData* imageModel, CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.SetRecipeModel(vectorRecipeModel);

	return ModelProcess(imageModel, imageSource);
}


int	CEdgeTriangle::ProcessMarker()
{
	return MarkerProcess(&m_imageModel);
}

int	CEdgeTriangle::ProcessMarker(CCHImageData* imageSource, const CRecipeMarker& recipeMarker)
{
	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.AddRecipeMarker(recipeMarker);

	return MarkerProcess(imageSource);
}

int	CEdgeTriangle::ProcessMarker(CCHImageData* imageSource, const VectorRecipeMarker& vectorRecipeMarker)
{
	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.SetRecipeMarker(vectorRecipeMarker);

	return MarkerProcess(imageSource);
}

int	CEdgeTriangle::ProcessModelMarker()
{
	return ModelMarkerProcess(&m_imageModel, &m_imageSource);
}

int	CEdgeTriangle::ProcessModelMarker(CCHImageData* imageSource, const CRecipeModel& recipeModel, const CRecipeMarker& recipeMarker)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.AddRecipeModel(recipeModel);

	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.AddRecipeMarker(recipeMarker);

	return ModelMarkerProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModelMarker(CCHImageData* imageSource, const CRecipeModel& recipeModel, const VectorRecipeMarker& vectorRecipeMarker)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.AddRecipeModel(recipeModel);

	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.SetRecipeMarker(vectorRecipeMarker);

	return ModelMarkerProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModelMarker(CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel, const VectorRecipeMarker& vectorRecipeMarker)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.SetRecipeModel(vectorRecipeModel);

	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.SetRecipeMarker(vectorRecipeMarker);

	return ModelMarkerProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModelMarker(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeModel& recipeModel, const CRecipeMarker& recipeMarker)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.AddRecipeModel(recipeModel);

	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.AddRecipeMarker(recipeMarker);

	return ModelMarkerProcess(imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModelMarker(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeModel& recipeModel, const VectorRecipeMarker& vectorRecipeMarker)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.AddRecipeModel(recipeModel);

	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.SetRecipeMarker(vectorRecipeMarker);

	return ModelMarkerProcess(imageModel, imageSource);
}

int	CEdgeTriangle::ProcessModelMarker(CCHImageData* imageModel, CCHImageData* imageSource, const VectorRecipeModel& vectorRecipeModel, const VectorRecipeMarker& vectorRecipeMarker)
{
	m_recipeTriangle.ResetRecipeModel();
	m_recipeTriangle.SetRecipeModel(vectorRecipeModel);

	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.SetRecipeMarker(vectorRecipeMarker);

	return ModelMarkerProcess(imageModel, imageSource);
}

int	CEdgeTriangle::ProcessMarkerFormula()
{
	return MarkerFormulaProcess(&m_imageModel);
}

int	CEdgeTriangle::ProcessMarkerFormula(CCHImageData* imageSource, const CRecipeMarker& recipeMarker, const CRecipeFormula& recipeFormula)
{
	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.AddRecipeMarker(recipeMarker);

	m_recipeTriangle.ResetRecipeFormula();
	m_recipeTriangle.AddRecipeFormula(recipeFormula);

	return MarkerFormulaProcess(imageSource);
}

int	CEdgeTriangle::ProcessMarkerFormula(CCHImageData* imageSource, const VectorRecipeMarker& vectorRecipeMarker, const VectorRecipeFormula& vectorRecipeFormula)
{
	m_recipeTriangle.ResetRecipeMarker();
	m_recipeTriangle.SetRecipeMarker(vectorRecipeMarker);

	m_recipeTriangle.ResetRecipeFormula();
	m_recipeTriangle.SetRecipeFormula(vectorRecipeFormula);

	return MarkerFormulaProcess(imageSource);
}

int	CEdgeTriangle::ProcessTriangle()
{
	return TriangleProcess(&m_imageModel, &m_imageSource);
}

int	CEdgeTriangle::ProcessTriangle(CCHImageData* imageSource)
{
	return TriangleProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessTriangle(CCHImageData* imageSource, const CRecipeTriangle& recipeTriangle)
{
	m_recipeTriangle = recipeTriangle;

	return TriangleProcess(&m_imageModel, imageSource);
}

int	CEdgeTriangle::ProcessTriangle(CCHImageData* imageModel, CCHImageData* imageSource, const CRecipeTriangle& recipeTriangle)
{
	m_recipeTriangle = recipeTriangle;

	return TriangleProcess(imageModel, imageSource);
}

int CEdgeTriangle::ImageResizeHalf(CCHImageData* pSource, CCHImageData* pResult)
{
	if (pSource==NULL || pResult==NULL) return 0;

	if (!pSource->GetImageExist()) return 0;

	if (pSource->GetChannels()!=1) return 0;

	const int nScale = 2;
	int nWidth = pSource->GetWidth() / nScale;
	int nHeight = pSource->GetHeight() / nScale;
	
	if (!pResult->CreateImage(nWidth, nHeight)) return 0;

	const int nSrcWidthStep = pSource->GetWidthStep() * nScale;
	const int nResWidthStep = pResult->GetWidthStep();

	BYTE *pSrcBuf, *pResBuf, *pSrcImg, *pResImg;
	pSrcBuf = (BYTE*)pSource->GetImageBuffer();
	pResBuf = (BYTE*)pResult->GetImageBuffer();

	unsigned long long mask[2] = {0x00FF00FF00FF00FF, 0x00FF00FF00FF00FF};
	__m128i MaskData = _mm_loadu_si128((const __m128i*)mask);
	__m128i CurrentData;

	for (int i=0; i<nHeight; i++)
	{
		pSrcImg = pSrcBuf;
		pResImg = pResBuf;

		int j=0;
		for (j=0; j<nWidth-8; j+=8)
		{
			CurrentData = _mm_loadu_si128((const __m128i*)(pSrcImg));
			CurrentData = _mm_and_si128(CurrentData, MaskData);
			CurrentData = _mm_packus_epi16(CurrentData, CurrentData);

			_mm_storel_epi64((__m128i*)pResImg, CurrentData);

			pSrcImg += 16;
			pResImg += 8;
		}

		for (; j<nWidth; j++)
		{
			*pResImg = *pSrcImg;
			pSrcImg += nScale;
			pResImg++;
		}

		pSrcBuf += nSrcWidthStep;
		pResBuf += nResWidthStep;

	}

	return 1;
}

int CEdgeTriangle::ImageResizeQuarter(CCHImageData* pSource, CCHImageData* pResult)
{
	if (pSource==NULL || pResult==NULL) return 0;

	if (!pSource->GetImageExist()) return 0;

	if (pSource->GetChannels()!=1) return 0;

	const int nScale = 4;
	int nWidth = pSource->GetWidth() / nScale;
	int nHeight = pSource->GetHeight() / nScale;

	if (!pResult->CreateImage(nWidth, nHeight)) return 0;

	const int nSrcWidthStep = pSource->GetWidthStep() * nScale;
	const int nResWidthStep = pResult->GetWidthStep();

	BYTE *pSrcBuf, *pResBuf, *pSrcImg, *pResImg;
	pSrcBuf = (BYTE*)pSource->GetImageBuffer();
	pResBuf = (BYTE*)pResult->GetImageBuffer();

	unsigned long long mask[2] = {0x000000FF000000FF, 0x000000FF000000FF};
	__m128i MaskData = _mm_loadu_si128((const __m128i*)mask);
	__m128i CurrentData1;
	__m128i CurrentData2;

	for (int i=0; i<nHeight; i++)
	{
		pSrcImg = pSrcBuf;
		pResImg = pResBuf;

		int j;
		for (j=0; j<nWidth-8; j+=8)
		{
			CurrentData1 = _mm_loadu_si128((const __m128i*)(pSrcImg));
			CurrentData2 = _mm_loadu_si128((const __m128i*)(pSrcImg+16));

			CurrentData1 = _mm_and_si128(CurrentData1, MaskData);
			CurrentData2 = _mm_and_si128(CurrentData2, MaskData);

			CurrentData1 = _mm_packus_epi16(CurrentData1, CurrentData2);
			CurrentData1 = _mm_packus_epi16(CurrentData1, CurrentData1);

			_mm_storel_epi64((__m128i*)pResImg, CurrentData1);

			pSrcImg += 32;
			pResImg += 8;
		}

		for (; j<nWidth; j++)
		{
			*pResImg = *pSrcImg;
			pSrcImg += nScale;
			pResImg++;
		}

		pSrcBuf += nSrcWidthStep;
		pResBuf += nResWidthStep;
	}

	return 1;
}

int CEdgeTriangle::ImageResizeOneEighth(CCHImageData* pSource, CCHImageData* pResult)
{
	if (pSource==NULL || pResult==NULL) return 0;

	if (!pSource->GetImageExist()) return 0;

	if (pSource->GetChannels()!=1) return 0;

	const int nScale = 8;
	int nWidth = pSource->GetWidth() / nScale;
	int nHeight = pSource->GetHeight() / nScale;

	if (!pResult->CreateImage(nWidth, nHeight)) return 0;

	const int nSrcWidthStep = pSource->GetWidthStep() * nScale;
	const int nResWidthStep = pResult->GetWidthStep();

	BYTE *pSrcBuf, *pResBuf, *pSrcImg, *pResImg;
	pSrcBuf = (BYTE*)pSource->GetImageBuffer();
	pResBuf = (BYTE*)pResult->GetImageBuffer();

	unsigned long long mask[2] = {0x00000000000000FF, 0x00000000000000FF};
	__m128i MaskData = _mm_loadu_si128((const __m128i*)mask);
	__m128i CurrentData1;
	__m128i CurrentData2;
	__m128i CurrentData3;
	__m128i CurrentData4;

	for (int i=0; i<nHeight; i++)
	{
		pSrcImg = pSrcBuf;
		pResImg = pResBuf;

		int j;
		for (j=0; j<nWidth-8; j+=8)
		{
			CurrentData1 = _mm_loadu_si128((const __m128i*)(pSrcImg));
			CurrentData2 = _mm_loadu_si128((const __m128i*)(pSrcImg+16));
			CurrentData3 = _mm_loadu_si128((const __m128i*)(pSrcImg+32));
			CurrentData4 = _mm_loadu_si128((const __m128i*)(pSrcImg+48));

			CurrentData1 = _mm_and_si128(CurrentData1, MaskData);
			CurrentData2 = _mm_and_si128(CurrentData2, MaskData);
			CurrentData3 = _mm_and_si128(CurrentData3, MaskData);
			CurrentData4 = _mm_and_si128(CurrentData4, MaskData);

			CurrentData1 = _mm_packus_epi16(CurrentData1, CurrentData2);
			CurrentData3 = _mm_packus_epi16(CurrentData3, CurrentData4);

			CurrentData1 = _mm_packus_epi16(CurrentData1, CurrentData3);

			CurrentData1 = _mm_packus_epi16(CurrentData1, CurrentData1);

			_mm_storel_epi64((__m128i*)pResImg, CurrentData1);

			pSrcImg += 64;
			pResImg += 8;
		}

		for (; j<nWidth; j++)
		{
			*pResImg = *pSrcImg;
			pSrcImg += nScale;
			pResImg++;
		}

		pSrcBuf += nSrcWidthStep;
		pResBuf += nResWidthStep;
	}

	return 1;
}

int	CEdgeTriangle::ImageAverage(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage==NULL || pDstImage==NULL) return 0;

	__m128i zeroData		= _mm_setzero_si128();
	__m128i currentData		= _mm_setzero_si128();
	__m128i totalData		= _mm_setzero_si128();
	__m128i divData			= _mm_set1_epi16(65536/9);
	__m128i k1				= _mm_setzero_si128();
	__m128i k2				= _mm_setzero_si128();
	__m128i k3				= _mm_setzero_si128();
	__m128i k4				= _mm_setzero_si128();
	
	static int nShiftOne, nShiftTwo;

	register BYTE *pSrcImageX, *pDstImageX;

	int nY1X0 = nWidth;
	int nY2X0 = 2*nWidth;

	for (int y=0; y<nHeight-2; y++)
	{
		pSrcImageX = pSrcImage + (y*nWidth);
		pDstImageX = pDstImage + ((y+1)*nWidth) + 1;

		for (int x=0; x<nWidth; x+=8)
		{
			// get pixel data (y,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX));
			k1 = _mm_unpacklo_epi8(currentData, zeroData);		// low
			k2 = _mm_unpackhi_epi8(currentData, zeroData);		// high
			nShiftOne = _mm_extract_epi16(k2, 0);
			nShiftTwo = _mm_extract_epi16(k2, 1);
			k3 = _mm_srli_si128(k1, 2);
			k3 = _mm_insert_epi16(k3, nShiftOne, 7);
			k4 = _mm_srli_si128(k3, 2);
			k4 = _mm_insert_epi16(k4, nShiftTwo, 7);

			totalData = _mm_add_epi16(k1, k3);			// k1 + k3
			totalData = _mm_add_epi16(totalData, k4);	// k4

			// get pixel data (y+1,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0));
			k1 = _mm_unpacklo_epi8(currentData, zeroData);		// low
			k2 = _mm_unpackhi_epi8(currentData, zeroData);		// high
			nShiftOne = _mm_extract_epi16(k2, 0);
			nShiftTwo = _mm_extract_epi16(k2, 1);
			k3 = _mm_srli_si128(k1, 2);
			k3 = _mm_insert_epi16(k3, nShiftOne, 7);
			k4 = _mm_srli_si128(k3, 2);
			k4 = _mm_insert_epi16(k4, nShiftTwo, 7);

			totalData = _mm_add_epi16(totalData, k1); // k1
			totalData = _mm_add_epi16(totalData, k3); // k3
			totalData = _mm_add_epi16(totalData, k4); // k4

			// get pixel data (y+2,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0));
			k1 = _mm_unpacklo_epi8(currentData, zeroData);		// low
			k2 = _mm_unpackhi_epi8(currentData, zeroData);		// high
			nShiftOne = _mm_extract_epi16(k2, 0);
			nShiftTwo = _mm_extract_epi16(k2, 1);
			k3 = _mm_srli_si128(k1, 2);
			k3 = _mm_insert_epi16(k3, nShiftOne, 7);
			k4 = _mm_srli_si128(k3, 2);
			k4 = _mm_insert_epi16(k4, nShiftTwo, 7);

			totalData = _mm_add_epi16(totalData, k1); // k1
			totalData = _mm_add_epi16(totalData, k3); // k3
			totalData = _mm_add_epi16(totalData, k4); // k4

			totalData = _mm_srai_epi16(totalData, 3);

			totalData = _mm_packus_epi16(totalData, totalData);		// last result

			_mm_storel_epi64( (__m128i*)(pDstImageX), totalData);

			pSrcImageX += 8;
			pDstImageX += 8;
		}

	}

	memcpy(pDstImage, pSrcImage, nWidth);
	memcpy(pDstImage+((nHeight-1)*nWidth), pSrcImage+((nHeight-1)*nWidth), nWidth);

	return 1;
}

int	CEdgeTriangle::ImageErode(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage==NULL || pDstImage==NULL) return 0;

	__m128i p1		= _mm_setzero_si128();
	__m128i p2		= _mm_setzero_si128();
	__m128i p3		= _mm_setzero_si128();
	__m128i p4		= _mm_setzero_si128();
	__m128i s		= _mm_setzero_si128();
	__m128i t		= _mm_setzero_si128();
	__m128i u		= _mm_setzero_si128();
	__m128i v		= _mm_setzero_si128();


	register BYTE *pSrcImageX, *pDstImageX;
	register int nShiftOne, nShiftTwo;
	register int nY1X0 = nWidth;
	register int nY2X0 = 2*nWidth;

	register int nLast = (nWidth % 16) ? 6: 2;

	int nSrcIdx = 0;
	int nDstIdx = 0;

	for (int y=0; y<nHeight-2; y++)
	{
		pSrcImageX = pSrcImage + (y*nWidth);
		pDstImageX = pDstImage + ((y+1)*nWidth) + 1;

		nSrcIdx = (y*nWidth);
		nDstIdx = ((y+1)*nWidth) + 1;

		*(pDstImageX-1) = 0;

		for (int x=0; x<nWidth; x+=16)
		{
			// get pixel data (y,x), (y,x+16) 
			p1	= _mm_loadu_si128((__m128i*)(pSrcImageX));
			p2	= _mm_loadu_si128((__m128i*)(pSrcImageX+16));

			nShiftOne = _mm_extract_epi8(p2, 0);
			nShiftTwo = _mm_extract_epi8(p2, 1);

			p3 = _mm_srli_si128(p1, 1);
			p3 = _mm_insert_epi8(p3, nShiftOne, 15);
			p4 = _mm_srli_si128(p3, 1);
			p4 = _mm_insert_epi8(p4, nShiftTwo, 15);

			// first line and
			s = _mm_and_si128(p1, p3); // p1 & p3
			s = _mm_and_si128(s, p4);	// p1 & p3 & p4

			// get pixel data (y+1,x), (y+1,x+16) 
			p1	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0));
			p2	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0+16));

			nShiftOne = _mm_extract_epi8(p2, 0);
			nShiftTwo = _mm_extract_epi8(p2, 1);

			p3 = _mm_srli_si128(p1, 1);
			p3 = _mm_insert_epi8(p3, nShiftOne, 15);
			p4 = _mm_srli_si128(p3, 1);
			p4 = _mm_insert_epi8(p4, nShiftTwo, 15);

			// second line and
			t = _mm_and_si128(p1, p3); // p1 & p3
			t = _mm_and_si128(t, p4);	// p1 & p3 & p4

			// get pixel data (y+2,x), (y+2,x+16) 
			p1	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0));
			p2	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0+16));

			nShiftOne = _mm_extract_epi8(p2, 0);
			nShiftTwo = _mm_extract_epi8(p2, 1);

			p3 = _mm_srli_si128(p1, 1);
			p3 = _mm_insert_epi8(p3, nShiftOne, 15);
			p4 = _mm_srli_si128(p3, 1);
			p4 = _mm_insert_epi8(p4, nShiftTwo, 15);

			// second line and
			u = _mm_and_si128(p1, p3); // p1 & p3
			u = _mm_and_si128(u, p4);	// p1 & p3 & p4

			// last result
			v = _mm_and_si128(s, t); // s & t
			v = _mm_and_si128(v, u);	// s & t & u

			_mm_storeu_si128( (__m128i*)(pDstImageX), v);

			pSrcImageX += 16;
			pDstImageX += 16;

			nSrcIdx += 16;
			nDstIdx += 16;
		}

		*(pDstImageX-nLast) = 0;

	}

	memset(pDstImage, 0, nWidth);
	memset(pDstImage+((nHeight-1)*nWidth), 0, nWidth);

	return 1;

}

int	CEdgeTriangle::ImageOR(BYTE* pSrcImage1, BYTE *pSrcImage2, BYTE* pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage1==NULL || pSrcImage2==NULL || pDstImage==NULL) return 0;

	register BYTE *pSrcBuffer1 = pSrcImage1;
	register BYTE *pSrcBuffer2 = pSrcImage2;
	register BYTE *pDstBuffer = pDstImage;

	__m128i v0, v1, r;

	register int i;
	register int nTotalSize = nWidth*nHeight;

	for(i=0; i<=nTotalSize-16; i+=16 )
	{
		v0 = _mm_loadu_si128( (const __m128i*)(pSrcBuffer1) );
		v1 = _mm_loadu_si128( (const __m128i*)(pSrcBuffer2) );

		r = _mm_or_si128(v0, v1);

		_mm_storeu_si128( (__m128i*)(pDstBuffer), r );
		pSrcBuffer1 += 16;
		pSrcBuffer2 += 16;
		pDstBuffer += 16;
	}

	for( ; i <=nTotalSize-8; i+=8 )
	{
		v0 = _mm_loadl_epi64( (const __m128i*)(pSrcBuffer1) );
		v1 = _mm_loadl_epi64( (const __m128i*)(pSrcBuffer2) );

		r = _mm_or_si128(v0, v1);

		_mm_storel_epi64( (__m128i*)(pDstBuffer), r );
		pSrcBuffer1 += 8;
		pSrcBuffer2 += 8;
		pDstBuffer += 8;
	}

	for ( ; i<nTotalSize; i++)
	{
		*(pDstBuffer++) = (*pSrcBuffer1++)|(*pSrcBuffer2++);
	}

	return 1;
}

int	CEdgeTriangle::ImageAND(BYTE* pSrcImage1, BYTE *pSrcImage2, BYTE* pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage1==NULL || pSrcImage2==NULL || pDstImage==NULL) return 0;

	register BYTE *pSrcBuffer1 = pSrcImage1;
	register BYTE *pSrcBuffer2 = pSrcImage2;
	register BYTE *pDstBuffer = pDstImage;

	__m128i v0, v1, r;

	register int i;
	register int nTotalSize = nWidth*nHeight;

	for(i=0; i<=nTotalSize-16; i+=16 )
	{
		v0 = _mm_loadu_si128( (const __m128i*)(pSrcBuffer1) );
		v1 = _mm_loadu_si128( (const __m128i*)(pSrcBuffer2) );

		r = _mm_and_si128(v0, v1);

		_mm_storeu_si128( (__m128i*)(pDstBuffer), r );
		pSrcBuffer1 += 16;
		pSrcBuffer2 += 16;
		pDstBuffer += 16;
	}

	for( ; i <=nTotalSize-8; i+=8 )
	{
		v0 = _mm_loadl_epi64( (const __m128i*)(pSrcBuffer1) );
		v1 = _mm_loadl_epi64( (const __m128i*)(pSrcBuffer2) );

		r = _mm_and_si128(v0, v1);

		_mm_storel_epi64( (__m128i*)(pDstBuffer), r );
		pSrcBuffer1 += 8;
		pSrcBuffer2 += 8;
		pDstBuffer += 8;
	}

	for ( ; i<nTotalSize; i++)
	{
		*(pDstBuffer++) = (*pSrcBuffer1++)&(*pSrcBuffer2++);
	}

	return 1;
}

int	CEdgeTriangle::ImageExclusiveOR(BYTE* pSrcImage1, BYTE *pSrcImage2, BYTE* pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage1==NULL || pSrcImage2==NULL || pDstImage==NULL) return 0;

	register BYTE *pSrcBuffer1 = pSrcImage1;
	register BYTE *pSrcBuffer2 = pSrcImage2;
	register BYTE *pDstBuffer = pDstImage;

	__m128i v0, v1, r;

	register int i;
	register int nTotalSize = nWidth*nHeight;

	for(i=0; i<=nTotalSize-16; i+=16 )
	{
		v0 = _mm_loadu_si128( (const __m128i*)(pSrcBuffer1) );
		v1 = _mm_loadu_si128( (const __m128i*)(pSrcBuffer2) );

		r = _mm_xor_si128(v0, v1);

		_mm_storeu_si128( (__m128i*)(pDstBuffer), r );
		pSrcBuffer1 += 16;
		pSrcBuffer2 += 16;
		pDstBuffer += 16;
	}

	for( ; i <=nTotalSize-8; i+=8 )
	{
		v0 = _mm_loadl_epi64( (const __m128i*)(pSrcBuffer1) );
		v1 = _mm_loadl_epi64( (const __m128i*)(pSrcBuffer2) );

		r = _mm_xor_si128(v0, v1);

		_mm_storel_epi64( (__m128i*)(pDstBuffer), r );
		pSrcBuffer1 += 8;
		pSrcBuffer2 += 8;
		pDstBuffer += 8;
	}

	for ( ; i<nTotalSize; i++)
	{
		*(pDstBuffer++) = (*pSrcBuffer1++)^(*pSrcBuffer2++);
	}

	return 1;
}


int	CEdgeTriangle::ImageDilate(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage==NULL || pDstImage==NULL) return 0;

	__m128i p1		= _mm_setzero_si128();
	__m128i p2		= _mm_setzero_si128();
	__m128i p3		= _mm_setzero_si128();
	__m128i p4		= _mm_setzero_si128();
	__m128i s		= _mm_setzero_si128();
	__m128i t		= _mm_setzero_si128();
	__m128i u		= _mm_setzero_si128();
	__m128i v		= _mm_setzero_si128();

	register BYTE *pSrcImageX, *pDstImageX;
	register int nShiftOne, nShiftTwo;
	register int nY1X0 = nWidth;
	register int nY2X0 = 2*nWidth;

	register int nLast = (nWidth % 16) ? 6: 2;

	for (int y=0; y<nHeight-2; y++)
	{
		pSrcImageX = pSrcImage + (y*nWidth);
		pDstImageX = pDstImage + ((y+1)*nWidth) + 1;

		*(pDstImageX-1) = 0;

		for (int x=0; x<nWidth; x+=16)
		{
			// get pixel data (y,x), (y,x+16) 
			p1	= _mm_loadu_si128((__m128i*)(pSrcImageX));
			p2	= _mm_loadu_si128((__m128i*)(pSrcImageX+16));

			nShiftOne = _mm_extract_epi8(p2, 0);
			nShiftTwo = _mm_extract_epi8(p2, 1);

			p3 = _mm_srli_si128(p1, 1);
			p3 = _mm_insert_epi8(p3, nShiftOne, 15);
			p4 = _mm_srli_si128(p3, 1);
			p4 = _mm_insert_epi8(p4, nShiftTwo, 15);

			// first line and
			s = _mm_or_si128(p1, p3); // p1 & p3
			s = _mm_or_si128(s, p4);	// p1 & p3 & p4

			// get pixel data (y+1,x), (y+1,x+16) 
			p1	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0));
			p2	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0+16));

			nShiftOne = _mm_extract_epi8(p2, 0);
			nShiftTwo = _mm_extract_epi8(p2, 1);

			p3 = _mm_srli_si128(p1, 1);
			p3 = _mm_insert_epi8(p3, nShiftOne, 15);
			p4 = _mm_srli_si128(p3, 1);
			p4 = _mm_insert_epi8(p4, nShiftTwo, 15);

			// second line and
			t = _mm_or_si128(p1, p3); // p1 & p3
			t = _mm_or_si128(t, p4);	// p1 & p3 & p4

			// get pixel data (y+2,x), (y+2,x+16) 
			p1	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0));
			p2	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0+16));

			nShiftOne = _mm_extract_epi8(p2, 0);
			nShiftTwo = _mm_extract_epi8(p2, 1);

			p3 = _mm_srli_si128(p1, 1);
			p3 = _mm_insert_epi8(p3, nShiftOne, 15);
			p4 = _mm_srli_si128(p3, 1);
			p4 = _mm_insert_epi8(p4, nShiftTwo, 15);

			// second line and
			u = _mm_or_si128(p1, p3); // p1 & p3
			u = _mm_or_si128(u, p4);	// p1 & p3 & p4

			// last result
			v = _mm_or_si128(s, t); // s & t
			v = _mm_or_si128(v, u);	// s & t & u

			_mm_storeu_si128( (__m128i*)(pDstImageX), v);

			pSrcImageX += 16;
			pDstImageX += 16;
		}
	}

	memset(pDstImage, 0, nWidth);
	memset(pDstImage+((nHeight-1)*nWidth), 0, nWidth);

	return 1;
}

int	CEdgeTriangle::ImageSobelEdge(BYTE* pSrcImage, BYTE *pDstImage, int nWidth, int nHeight)
{
	if (pSrcImage==NULL || pDstImage==NULL) return 0;
	
	__m128i zeroData		= _mm_setzero_si128();
	__m128i currentData		= _mm_setzero_si128();
	__m128i sobelData		= _mm_set1_epi16(2);
	__m128i lowUnpack		= _mm_setzero_si128(); // low unpack
	__m128i highUnpack		= _mm_setzero_si128(); // high unpack
	__m128i multiData		= _mm_setzero_si128();
	__m128i TopKernel		= _mm_setzero_si128();
	__m128i BottomKernel	= _mm_setzero_si128();
	__m128i tempData		= _mm_setzero_si128();

	register BYTE *pSrcImageX, *pDstImageX;
	register int nShiftOne, nShiftTwo;
	register int nY0X2 = 2;
	register int nY1X0 = nWidth;
	register int nY1X2 = nWidth + 2;
	register int nY2X0 = 2*nWidth;
	register int nY2X2 = 2*nWidth + 2;
	register int nLast = (nWidth % 8) ? 6: 2;

	for (int y=0; y<nHeight-2; y++)
	{
		pSrcImageX = pSrcImage + (y*nWidth);
		pDstImageX = pDstImage + ((y+1)*nWidth) + 1;

		*(pDstImageX-1) = 0;

		for (int x=0; x<nWidth; x+=8)
		{
			// [1] vertical kernel

			// get pixel data (y+2,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X0));
			tempData	= _mm_unpacklo_epi8(currentData, zeroData);		// low
			highUnpack	= _mm_unpackhi_epi8(currentData, zeroData);		// high

			nShiftOne	= _mm_extract_epi16(highUnpack, 0);
			nShiftTwo	= _mm_extract_epi16(highUnpack, 1);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(tempData, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftOne, 7);

			// mul * 2
			multiData	= _mm_mullo_epi16(highUnpack, sobelData);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(highUnpack, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftTwo, 7);

			BottomKernel = _mm_add_epi16(tempData, multiData);
			BottomKernel = _mm_add_epi16(BottomKernel, highUnpack);		// top kernel value

			// get pixel data (y,x) 
			currentData	= _mm_loadu_si128((__m128i*)(pSrcImageX));
			lowUnpack	= _mm_unpacklo_epi8(currentData, zeroData);		// low
			highUnpack	= _mm_unpackhi_epi8(currentData, zeroData);		// high

			nShiftOne	= _mm_extract_epi16(highUnpack, 0);
			nShiftTwo	= _mm_extract_epi16(highUnpack, 1);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(lowUnpack, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftOne, 7);

			// mul * 2
			multiData	= _mm_mullo_epi16(highUnpack, sobelData);

			// left shift 2byte
			highUnpack	= _mm_srli_si128(highUnpack, 2);
			highUnpack	= _mm_insert_epi16(highUnpack, nShiftTwo, 7);

			TopKernel	= _mm_add_epi16(lowUnpack, multiData);
			TopKernel	= _mm_add_epi16(TopKernel, highUnpack);			// top kernel value

			TopKernel	= _mm_sub_epi16(TopKernel, BottomKernel);		// top + bottom
			TopKernel	= _mm_abs_epi16(TopKernel);						// horizontal result

			// lowUnpack, TopKernel, sobelData, currentData, 

			// [1] Horizontal kernel
			// get pixel data (y+1,x) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X0));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low
			highUnpack		= _mm_mullo_epi16(highUnpack, sobelData);		// mul * 2
			lowUnpack		= _mm_add_epi16(lowUnpack, highUnpack);		// add result

			// get pixel data (y+2,x) 
			//	currentData		= _mm_loadu_si128((__m128i*)(pSrcImage+((y+2)*nWidth)+x));
			//	highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low
			lowUnpack		= _mm_add_epi16(lowUnpack, tempData);		// add result

			// get pixel data (y,x+2) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY0X2));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low
			lowUnpack		= _mm_sub_epi16(lowUnpack, highUnpack);		// sub result

			// get pixel data (y+1,x+2) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY1X2));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low
			highUnpack		= _mm_mullo_epi16(highUnpack, sobelData);		// mul * 2
			lowUnpack		= _mm_sub_epi16(lowUnpack, highUnpack);		// sub result

			// get pixel data (y+2,x+2) 
			currentData		= _mm_loadu_si128((__m128i*)(pSrcImageX+nY2X2));
			highUnpack		= _mm_unpacklo_epi8(currentData, zeroData);		// low
			lowUnpack		= _mm_sub_epi16(lowUnpack, highUnpack);			// sub result

			lowUnpack		= _mm_abs_epi16(lowUnpack);					// abs result
			TopKernel		= _mm_add_epi16(TopKernel, lowUnpack);		// add horizontal + vertical

			TopKernel		= _mm_srai_epi16(TopKernel, 1);				// shift right 1 <add>

			TopKernel		= _mm_packus_epi16(TopKernel, TopKernel);		// last result

			_mm_storel_epi64( (__m128i*)(pDstImageX), TopKernel);

			pSrcImageX += 8;
			pDstImageX += 8;
		}

		*(pDstImageX-nLast) = 0;
	}

	memset(pDstImage, 0, nWidth);
	memset(pDstImage+((nHeight-1)*nWidth), 0, nWidth);

	return 1;
}

int	CEdgeTriangle::ImageThresholding(BYTE* pImage, int nWidth, int nHeight, int nThresValue)
{
	if (pImage==NULL) return 0;

	register BYTE *pBuffer = pImage;

	__m128i _x80		= _mm_set1_epi8('\x80');
	__m128i ThresData	= _mm_set1_epi8(uchar(nThresValue)^0x80);
	__m128i v0, v1;

	register int i;
	register int nTotalSize = nWidth*nHeight;

	for(i=0; i<=nTotalSize-32; i+=32 )
	{
		v0 = _mm_loadu_si128( (const __m128i*)(pBuffer) );
		v1 = _mm_loadu_si128( (const __m128i*)(pBuffer+16) );
		v0 = _mm_cmpgt_epi8( _mm_xor_si128(v0, _x80), ThresData );
		v1 = _mm_cmpgt_epi8( _mm_xor_si128(v1, _x80), ThresData );
		_mm_storeu_si128( (__m128i*)(pBuffer), v0 );
		_mm_storeu_si128( (__m128i*)(pBuffer+16), v1 );
		pBuffer+=32;
	}

	for( ; i <=nTotalSize-8; i+=8 )
	{
		v0 = _mm_loadl_epi64( (const __m128i*)(pBuffer) );
		v0 = _mm_cmpgt_epi8( _mm_xor_si128(v0, _x80), ThresData );
		_mm_storel_epi64( (__m128i*)(pBuffer), v0 );
		pBuffer+=8;
	}

	for (; i<nTotalSize; i++)
	{
		*(pBuffer++) = (*pBuffer>nThresValue) ? 255: 0;
	}

	return 1;
}

int CEdgeTriangle::ImageThinning(BYTE* pImage, int nWidth, int nHeight)
{
	if (pImage==NULL) return 0;

	// Rosenfeld _parallel thinning algorithm from Graphics Gems with some modifications;
	// running calculation of weight number;

	static int pMasks[]={0x80, 0x02, 0x20, 0x08} ;
	BYTE *pKernel = new BYTE[nWidth];

	pKernel[nWidth-1] = 0;                // Used for lower-right pixel 

	int nCount = 1;
	int nPassCount = 0;
	register BYTE *pSubX, *pSubY;

	while (nCount) // Scan image while deletions
	{       
		nCount = 0;  
		nPassCount++;

		for (int i=0 ; i<4 ; i++) 
		{        
			int m = pMasks[i];   

			// set image pointer
			pSubX = pSubY = pImage+nWidth+1;

			// Build initial previous scan buffer.
			int p = (*(pSubX++)!=0);

			pKernel[0] = p;

			for (int x=1; x<nWidth-1; x++) 
			{
				p = ((p<<1)&0x06) | (*(pSubX++)!=0);
				pKernel[x] = p ;
			}

			// Scan image for pixel deletion candidates.

			pSubY += nWidth;

			for (int y=1; y<nHeight-1; y++) 
			{                        
				int q = pKernel[0];

				p = ((q<<3)&0x48) | (*pSubY!=0);
				pKernel[0] = p;
				pSubX = (pSubY+1);

				for (int x=1 ; x<nWidth-1; x++) 
				{
					q = pKernel[x];
					p = ((p<<1)&0x1B6) | ((q<<3)&0x48) | (*(pSubX++)!=0);

					//0x1B6=110110110=2^8 + 2^7 +2^5 + 2^4 + 2^2 + 2^1;
					//0x48=1001000=2^6 + 2^3

					pKernel[x] = p;

					if (((p&m) == 0) && pDeleteArray[p] ) 
					{
						nCount++;
						*(pImage+(y*nWidth)+x) = 0;
					}
				}

				pSubY += nWidth;
			}
		}       
	}

	delete[] pKernel;

	return 1;
}

int	CEdgeTriangle::ImageBlobAnalysis(BYTE *pImage, int nWidth, int nHeight, VectorPixelRegion& vectorRegion, int nBlobMargin)
{
	if (pImage==NULL) return 0;

	int nSizeThres = 8;
	int i, j, y, x;

	for (i=0; i<nHeight; i++)
	{
		*(pImage+(i*nWidth)) = 0;
		*(pImage+(i*nWidth)+(nWidth-1)) = 0;
	}

	for (j=0; j<nWidth; j++)
	{
		*(pImage+j) = 0;
		*(pImage+((nHeight-1)*nWidth)+j) = 0;
	}

	size_t nSize;
	VectorPoint vectorPixel;
	CPixelRegion pixelRegion;
	register BYTE *pSrcImgY = pImage + (1*nWidth) + 1;
	register BYTE *pSrcImgX, *pSubX, *pSubY;

	for (i=1; i<nHeight-1; i++)
	{
		pSrcImgX = pSrcImgY;
		for (j=1; j<nWidth-1; j++)
		{
			if (*pSrcImgX > 200)
			{
				*pSrcImgX = 128;
				vectorPixel.push_back(CPoint(j, i));

				// new pixel region
				pixelRegion.Reset();

				while ((nSize=vectorPixel.size())>0)
				{
					x = vectorPixel[nSize-1].x;
					y = vectorPixel[nSize-1].y;

					// delete end point
					vectorPixel.pop_back();

					// add point to new region
					pixelRegion.vectorPoint.push_back(CPoint(x, y));

					// get current point
					pSubY = pImage + ((y-1)*nWidth) + (x-1);

					for (int sy=-1; sy<2; sy++)
					{
						pSubX = pSubY;
						for (int sx=-1; sx<2; sx++)
						{
							if (*pSubX > 200)
							{
								*pSubX = 128;
								vectorPixel.push_back(CPoint(x+sx, y+sy));
							}
							pSubX++;
						}
						pSubY += nWidth;
					}

					if (pixelRegion.nLeft>x)	pixelRegion.nLeft	= x;
					if (pixelRegion.nRight<x)	pixelRegion.nRight	= x;
					if (pixelRegion.nTop>y)		pixelRegion.nTop	= y;
					if (pixelRegion.nBottom<y)	pixelRegion.nBottom = y;
				}

				vectorPixel.clear();

				// check size
				if (pixelRegion.vectorPoint.size()<nSizeThres) continue;

				vectorRegion.push_back(pixelRegion);
			} // end if
			pSrcImgX++;
		} //end for j
		pSrcImgY += nWidth;
	}// end for i

	if (vectorRegion.size()==0) return 0;

	// sort blob max size
	std::sort(vectorRegion.begin(), vectorRegion.end(), CompareMaxSize);

	return 1;
}