#include "stdafx.h"
#include "LineChecker.h"

#include <cmath>
#include <emmintrin.h>
#include <tmmintrin.h>

#define SAVE_PROJECTION_VALUE
int m_nLineCheckerLocalPeakPeriod;


//x 좌표를 기준으로 Local Peak nPeriod 범위( x - nPeriod/2 ~ x + nPeriod/2 ) 내에서 최소값을 찾음
//Input
//  pProjection : Review Image의 Projection Graph
//  x : 탐색 위치
//  nWidth : Projection Graph의 nWidth(side = TOP인 경우 최대 Review Image의 Height)
//Output
//  pPos : 탐색 범위 내 최소값의 좌표
//Return
//  탐색 범위 내 최소값(gray value)
BYTE LocalMinima(int *pProjection, int *pPos, int x, int nWidth, int nPeriod)
{
	if(pProjection == NULL)
	{
		TRACE(_T("LocalMinima : Projection Graph Is Not Allocated\n"));
		return 0;
	}
	if(pPos == NULL)
	{
		TRACE(_T("LocalMinima : pPosition Coordi Is Not Allocated\n"));
		return 0;
	}

	int i = x - nPeriod / 2 ;
	if(i < 0)
		i = 0;
	BYTE local_minima = *(pProjection + i);
	*pPos = i;
	for(; i < x + nPeriod / 2; i++)
	{
		if(i > nWidth - 1) break;
		if(local_minima > *(pProjection + i))
		{
			local_minima = *(pProjection + i);
			*pPos = i;
		}
	}

	return local_minima;
}

//x 좌표를 기준으로 Local Peak nPeriod 범위( x - nPeriod/2 ~ x + nPeriod/2 ) 내에서 최대값을 찾음
//Input
//  pProjection : Review Image의 Projection Graph
//  x : 탐색 위치
//  nWidth : Projection Graph의 nWidth
//Output
//  pos : 탐색 범위 내 최대값의 좌표
//Return
//  탐색 범위 내 최대값(gray value)
BYTE LocalMaxima(int *pProjection, int x, int nWidth, int nPeriod)
{
	if(pProjection == NULL)
	{
		TRACE(_T("LocalMaxima : Projection Graph Is Not Allocated\n"));
		return 0;
	}

	int i = x - nPeriod / 2 ;
	if(i < 0)
		i = 0;
	BYTE local_maxima = *(pProjection + i);
	for(; i < x + nPeriod / 2; i++)
	{
		if(i > nWidth - 1) break;
		if(local_maxima < *(pProjection + i))
			local_maxima = *(pProjection + i);
	}

	return local_maxima;
}

//x 좌표를 기준으로 Local Peak Period 범위( x - period/2 ~ x + period/2 ) 내에서 최소값을 찾음
//Input
//  pProjection : Review Image의 Projection Graph
//  x : 탐색 위치
//  width : Projection Graph의 width(side = TOP인 경우 최대 Review Image의 Height)
//Output
//  pos : 탐색 범위 내 최소값의 좌표
//Return
//  탐색 범위 내 최소값(gray value)
BYTE LocalMinima(int *pProjection, int *pos, int x, int width)
{
	if(pProjection == NULL)
	{
		TRACE(_T("LocalMinima : Projection Graph Is Not Allocated\n"));
		return 0;
	}
	if(pos == NULL)
	{
		TRACE(_T("LocalMinima : Position Coordi Is Not Allocated\n"));
		return 0;
	}

	int i = x - m_nLineCheckerLocalPeakPeriod / 2 ;
	if(i < 0)
		i = 0;
	BYTE local_minima = *(pProjection + i);
	*pos = i;
	for(; i < x + m_nLineCheckerLocalPeakPeriod / 2; i++)
	{
		if(i > width - 1) break;
		if(local_minima > *(pProjection + i))
		{
			local_minima = *(pProjection + i);
			*pos = i;
		}
	}

	return local_minima;
}

//x 좌표를 기준으로 Local Peak Period 범위( x - period/2 ~ x + period/2 ) 내에서 최대값을 찾음
//Input
//  pProjection : Review Image의 Projection Graph
//  x : 탐색 위치
//  width : Projection Graph의 width
//Output
//  pos : 탐색 범위 내 최대값의 좌표
//Return
//  탐색 범위 내 최대값(gray value)
BYTE LocalMaxima(int *pProjection, int x, int width)
{
	if(pProjection == NULL)
	{
		TRACE(_T("LocalMaxima : Projection Graph Is Not Allocated\n"));
		return 0;
	}

	int i = x - m_nLineCheckerLocalPeakPeriod / 2 ;
	if(i < 0)
		i = 0;
	BYTE local_maxima = *(pProjection + i);
	for(; i < x + m_nLineCheckerLocalPeakPeriod / 2; i++)
	{
		if(i > width - 1) break;
		if(local_maxima < *(pProjection + i))
			local_maxima = *(pProjection + i);
	}

	return local_maxima;
}

//x 좌표를 기준으로 Local Peak Period * 2 범위( x - period ~ x + period ) 내에서 저점 2개를 찾음
//dam2의 안쪽 line이 넘쳤을 때 1 line, 넘치지 않았을 때 2 line이 보이기 때문
//즉, dam2의 안쪽 line을 검사하는 메소드
//focus에 따라 2 line이 blur되는 경우가 있어 보완 필요
//Input
//  pProjection : Review Image의 Projection Graph
//  x : 탐색 위치
//  width : Projection Graph의 width
//  threshold : 검사 threshold. localmax - localmin > threshold인 경우 넘치지 않았다고 판정
//  bForward : 탐색 방향. TRUE(좌 > 우, 상 > 하). FALSE(우 > 좌)
//Output
//  pos : dam2의 위치. 검출된 line들의 중간 지점 
//Return
//  dam2 overflow 여부 T/F
BOOL CheckTwoLines(int *pProjection, int x, int width, int threshold, BOOL bForward, int *pos)
{
	if(pProjection == NULL)
	{
		TRACE(_T("CheckTwoLines : Projection Graph Is Not Allocated\n"));
		return FALSE;
	}
	if(pos == NULL)
	{
		TRACE(_T("CheckTwoLines : Position Coordi Is Not Allocated\n"));
		return 0;
	}

	int i;
	int nSearchEnd;
	if(bForward)
	{
		//i = x - LOCAL_PEAK_PERIOD / 2;
		//nSearchEnd = x + LOCAL_PEAK_PERIOD * 9 / 2;
		i = x - m_nLineCheckerLocalPeakPeriod;
		nSearchEnd = x + m_nLineCheckerLocalPeakPeriod;
	}
	else
	{
		//i = x + LOCAL_PEAK_PERIOD / 2;
		//nSearchEnd = x - LOCAL_PEAK_PERIOD * 9 / 2;
		i = x + m_nLineCheckerLocalPeakPeriod;
		nSearchEnd = x - m_nLineCheckerLocalPeakPeriod;
	}
	if(i < 1) i = 1;
	if(nSearchEnd < 1) nSearchEnd = 01;
	if(i > width - 2) i = width - 2; 
	if(nSearchEnd > width - 2) nSearchEnd = width - 2; 
	int nPeakCount = 0;

	*pos = 0;

	if(bForward)
	{
		BOOL bIncreaseSlope = (*(pProjection + i + 1) >= *(pProjection + i - 1));
		i++;
		for(; i < nSearchEnd; i++)
		{
			//if(!(bIncreaseSlope & (*(pDifference_lpf + i) >= 0)))
			if(bIncreaseSlope ^ (*(pProjection + i + 1) >= *(pProjection + i - 1)))//기울기 방향이 바뀌는 시점(Peak)
			{
				if(LocalMaxima(pProjection, i, width) - *(pProjection + i) > threshold)
				{
					nPeakCount++;
					*pos += i;
				}
				bIncreaseSlope = !bIncreaseSlope;
			}
		}
	}
	else
	{
		BOOL bIncreaseSlope = (*(pProjection + i - 1) >= *(pProjection + i + 1));
		i--;
		for(; i >= nSearchEnd; i--)
		{
			//if(!(bIncreaseSlope & (*(pDifference_lpf + i) >= 0)))
			if(bIncreaseSlope ^ (*(pProjection + i - 1) >= *(pProjection + i + 1)))//기울기 방향이 바뀌는 시점(Peak)
			{
				if(LocalMaxima(pProjection, i, width) - *(pProjection + i) > threshold)
				{
					nPeakCount++;
					*pos += i;
				}
				bIncreaseSlope = !bIncreaseSlope;
			}
		}
	}
	if(nPeakCount >= 2)
	{
		*pos /= nPeakCount;
		return TRUE;
	}
	return FALSE;
}

//Color Image를 Gray Buffer로 변환
//Color Channel = 1인 경우는 단순 복사
//Color Channel = 2인 경우는 미구현
//Color Channel = 3, 4인 경우는 r+b+g / 3으로 변환
//Input
//  pImageOrigin : Input Image Buffer(Color Image)
//  nImageWidth : Image Width
//  nImageHeight : Image Height
//  nChannel : Image Color Channel
//  nImageWidthStep : Image Width * Channel + Margin(0 이상). Input Image가 실제 Image보다 큰 Memory를 확보하는 경우 Margin을 제거하기 위해 필요함
//Output
//  pImage : 변환된 Gray Image
//Return
//  변환 성공 여부 T/F. Input Image에 오류가 있는 경우 False
int RGB2GRAY(BYTE* pImage, BYTE* pImageOrigin, int nImageWidth, int nImageHeight, int nChannel, int nImageWidthStep)
{
	if(nImageWidth <= 0 && nImageHeight <= 0)
	{
		TRACE(_T("RGB2GRAY : Input Image Not Loaded\n"));
		return -1; // image not loaded
	}
	if(pImageOrigin == NULL)
	{
		TRACE(_T("RGB2GRAY : Input Image Not Loaded\n"));
		return -1;
	}
	if(pImage == NULL)
	{
		TRACE(_T("RGB2GRAY : Output Image Not Loaded\n"));
		return -1;
	}

	if(nChannel == 1)
	{
		BYTE* temp;
		//for(int y = 0 ; y < nImageHeight; y++)
		//{
		//	temp = pImageOrigin + y * nImageWidth;
		//	memcpy((pImage + y * nImageWidth), temp, sizeof(BYTE) * nImageWidth);
		//}
		memcpy(pImage, pImageOrigin, sizeof(BYTE) * nImageWidth * nImageHeight);
	}
	else
	{
		BYTE* temp;
		//COLORREF rgb;
		for(int y = 0 ; y < nImageHeight; y++)
		{
			temp = pImageOrigin + y * nImageWidthStep;
			for(int x = 0; x < nImageWidth; x++)
			{
				pImage[y * nImageWidth + x] = (*(temp + x * nChannel) + *(temp + x * nChannel + 1) + *(temp + x * nChannel + 2)) / 3;
			}
		}
		//m_ImageBuffer.m_ImageBuffer = temp;
	}

	return 0;
}

//1D Image Matching

//Review Image와 Master Image를 Matching하여 Review Image 내 ROI를 설정함
//Side = Top의 경우 호출됨 => 가로 방향 Projection Graph를 도출하여 세로 방향으로 Matching함
//Matching Method는 Correlation 사용
//Input
//  pImage : Review Image(Gray Image)
//  nImageWidth : Review Image Width
//  nImageHeight : Review Image Height
//  pMaster : Master Image Buffer(Gray Image)
//  nMasterWidth : Master Image Width
//  nMasterHeight : Master Image Height
//Output
//  rtMatch : Matching 결과 ROI(세로 방향으로 Matching하였기 때문에 top, bottom이 Master Image Height만큼 줄어들고, left right는 변함 없음)
//Return
//  Match 성공 여부 T/F
//  Matching Score 0.9 이상인 경우 TRUE(No Reflow와 DAM2 Reflow Matching 시 0.917)
BOOL Match_Vertical(BYTE *pImage, int nImageWidth, int nImageHeight, BYTE *pMaster, int nMasterWidth, int nMasterHeight, CRect *rtMatch)
{
	int *pImageProjection = NULL;
	pImageProjection = new int[nImageHeight];
	int *pMasterProjection = NULL;
	pMasterProjection = new int[nMasterHeight];
	double *pResult = NULL;
	pResult = new double[nImageHeight];

	memset(pImageProjection, 0, sizeof(int) * nImageHeight);
	memset(pMasterProjection, 0, sizeof(int) * nMasterHeight);

	BYTE *pIm = pImage;
	BYTE *pMs = pMaster;

	for(int j = 0; j < nImageWidth; j++)//Review Image Projection
	{
		for(int i = 0; i < nImageHeight; i++)
		{
			pImageProjection[i] += *(pIm + i * nImageWidth + j);
		}
	}
	for(int i = 0; i < nImageHeight; i++)
	{
		pImageProjection[i] /= nMasterWidth;
	}

	for(int j = 0; j < nMasterWidth; j++)//Master Image Projection
	{
		for(int i = 0; i < nMasterHeight; i++)
		{
			pMasterProjection[i] += *(pMs + i * nMasterWidth + j);
		}
	}
	for(int i = 0; i < nMasterHeight; i++)
	{
		pMasterProjection[i] /= nMasterWidth;
	}

	//Match
	double dMasterAvg = 0;
	double dMasterVar;
	double dMasterVarSqSum = 0;

	double dImageAvg = 0;
	double dImageVar;
	double dImageVarSqSum = 0;

	double dNumerSum = 0;
	double dDenomSum = 0;

	int nMaxPos = 0;
	double dMaxScore = 0;

	TRACE(_T("Reflow Match Vertical\n"));
	TRACE(_T("Reflow Match SearchArea(ROI) : (%d, %d) - (%d, %d)\n"), rtMatch->left, rtMatch->top, rtMatch->right, rtMatch->bottom);

	//Master Image Avg
	for(int j = 0; j < nMasterHeight; j++)
	{
		dMasterAvg += pMasterProjection[j];
	}
	dMasterAvg /= nMasterHeight;

	//for(int i = 0; i < (nImageHeight - nMasterHeight); i++)
	for(int i = rtMatch->top; i < (rtMatch->bottom - nMasterHeight); i++)
	{
		dMasterVarSqSum = 0;
		dImageAvg = 0;
		dImageVarSqSum = 0;
		dNumerSum = 0;
		dDenomSum = 0;

		//Avg
		for(int j = 0; j < nMasterHeight; j++)
		{
			dImageAvg += pImageProjection[i + j];
		}
		dImageAvg /= nMasterHeight;

		//Var
		for(int j = 0; j < nMasterHeight; j++)
		{
			dMasterVar = abs(pMasterProjection[j] - dMasterAvg);
			dImageVar = abs(pImageProjection[i + j] - dImageAvg);

			dNumerSum += dMasterVar * dImageVar;
			dMasterVarSqSum += dMasterVar * dMasterVar;
			dImageVarSqSum += dImageVar * dImageVar;
		}
		dDenomSum = sqrt(dMasterVarSqSum * dImageVarSqSum);

		//Denom
		if(dDenomSum != 0)
			pResult[i] = dNumerSum / dDenomSum;
		else
			pResult[i] = 0;

		if(dMaxScore < pResult[i])
		{
			dMaxScore = pResult[i];
			nMaxPos = i;
		}
	}
	TRACE(_T("Reflow Match Matching Result(yCoordi) : %d\n"), nMaxPos);

	if(dMaxScore < 0.9)
	{
		TRACE(_T("Reflow Match Matching Fail : Matching Score = %.2f\n"), dMaxScore * 100);
		if(pImageProjection)
		{
			delete [] pImageProjection;
			pImageProjection = NULL;
		}
		if(pMasterProjection)
		{
			delete [] pMasterProjection;
			pMasterProjection = NULL;
		}
		if(pResult)
		{
			delete [] pResult;
			pResult = NULL;
		}
		return FALSE;
	}

	TRACE(_T("Reflow Match Matching Success : Matching Score = %.2f\n"), dMaxScore * 100);

	//if(nMaxPos == 0 || nMaxPos == nImageHeight - nMasterHeight - 1)
	//{
	rtMatch->top = nMaxPos;
	//}
	//else
	//{
	//	double dNum = pResult[nMaxPos - 1] - pResult[nMaxPos + 1];
	//	double dDenom = pResult[nMaxPos - 1] + pResult[nMaxPos + 1] - 2 * pResult[nMaxPos];
	//	if(dDenom == 0) dDenom = 0.00000001;
	//}
	rtMatch->bottom = nMaxPos + nMasterHeight;
	//rtMatch->left = 0;
	//rtMatch->right = nImageWidth - 1;

	if(pImageProjection)
	{
		delete [] pImageProjection;
		pImageProjection = NULL;
	}
	if(pMasterProjection)
	{
		delete [] pMasterProjection;
		pMasterProjection = NULL;
	}
	if(pResult)
	{
		delete [] pResult;
		pResult = NULL;
	}

	return TRUE;
}

//Review Image와 Master Image를 Matching하여 Review Image 내 ROI를 설정함
//Side = Left, Right의 경우 호출됨 => 세로 방향 Projection Graph를 도출하여 가로 방향으로 Matching함
//Matching Method는 Correlation 사용
//Input
//  pImage : Review Image(Gray Image)
//  nImageWidth : Review Image Width
//  nImageHeight : Review Image Height
//  pMaster : Master Image Buffer(Gray Image)
//  nMasterWidth : Master Image Width
//  nMasterHeight : Master Image Height
//Output
//  rtMatch : Matching 결과 ROI(가로 방향으로 Matching하였기 때문에 left right가 Master Image Height만큼 줄어들고, top, bottom은 변함 없음)
//Return
//  Match 성공 여부 T/F
//  Matching Score 0.9 이상인 경우 TRUE(No Reflow와 DAM2 Reflow Matching 시 0.917)
BOOL Match_Horizontal(BYTE *pImage, int nImageWidth, int nImageHeight, BYTE *pMaster, int nMasterWidth, int nMasterHeight, CRect *rtMatch)
{
	int *pImageProjection = NULL;
	pImageProjection = new int[nImageWidth];
	int *pMasterProjection = NULL;
	pMasterProjection = new int[nMasterWidth];
	double *pResult = NULL;
	pResult = new double[nImageWidth];

	memset(pImageProjection, 0, sizeof(int) * nImageWidth);
	memset(pMasterProjection, 0, sizeof(int) * nMasterWidth);

	BYTE *pIm = pImage;
	BYTE *pMs = pMaster;

	for(int j = 0; j < nImageHeight; j++)//Review Image Projection
	{
		for(int i = 0; i < nImageWidth; i++)
		{
			pImageProjection[i] += *(pIm + j * nImageWidth + i);
		}
	}
	for(int i = 0; i < nImageWidth; i++)
	{
		pImageProjection[i] /= nMasterHeight;
	}

	for(int j = 0; j < nMasterHeight; j++)//Master Image Projection
	{
		for(int i = 0; i < nMasterWidth; i++)
		{
			pMasterProjection[i] += *(pMs + j * nMasterWidth + i);
		}
	}
	for(int i = 0; i < nMasterWidth; i++)
	{
		pMasterProjection[i] /= nMasterHeight;
	}

	//Match
	double dMasterAvg = 0;
	double dMasterVar;
	double dMasterVarSqSum = 0;

	double dImageAvg = 0;
	double dImageVar;
	double dImageVarSqSum = 0;

	double dNumerSum = 0;
	double dDenomSum = 0;

	int nMaxPos = 0;
	double dMaxScore = 0;

	TRACE(_T("Reflow Match Horizontal\n"));
	TRACE(_T("Reflow Match SearchArea(ROI) : (%d, %d) - (%d, %d)\n"), rtMatch->left, rtMatch->top, rtMatch->right, rtMatch->bottom);

	//Master Image Avg
	for(int j = 0; j < nMasterWidth; j++)
	{
		dMasterAvg += pMasterProjection[j];
	}
	dMasterAvg /= nMasterWidth;

	//for(int i = 0; i < (nImageWidth - nMasterWidth); i++)
	for(int i = rtMatch->left; i < (rtMatch->right - nMasterWidth); i++)
	{
		dMasterVarSqSum = 0;
		dImageAvg = 0;
		dImageVarSqSum = 0;
		dNumerSum = 0;
		dDenomSum = 0;

		//Avg
		for(int j = 0; j < nMasterWidth; j++)
		{
			dImageAvg += pImageProjection[i + j];
		}
		dImageAvg /= nMasterWidth;

		//Var
		for(int j = 0; j < nMasterWidth; j++)
		{
			dMasterVar = abs(pMasterProjection[j] - dMasterAvg);
			dImageVar = abs(pImageProjection[i + j] - dImageAvg);

			dNumerSum += dMasterVar * dImageVar;
			dMasterVarSqSum += dMasterVar * dMasterVar;
			dImageVarSqSum += dImageVar * dImageVar;
		}
		dDenomSum = sqrt(dMasterVarSqSum * dImageVarSqSum);

		//Denom
		if(dDenomSum != 0)
			pResult[i] = dNumerSum / dDenomSum;
		else
			pResult[i] = 0;

		if(dMaxScore < pResult[i])
		{
			dMaxScore = pResult[i];
			nMaxPos = i;
		}
	}
	TRACE(_T("Reflow Match Matching Result(xCoordi) : %d\n"), nMaxPos);

	if(dMaxScore < 0.9)
	{
		TRACE(_T("Reflow Match Matching Fail : Matching Score = %.2f\n"), dMaxScore * 100);
		if(pImageProjection)
		{
			delete [] pImageProjection;
			pImageProjection = NULL;
		}
		if(pMasterProjection)
		{
			delete [] pMasterProjection;
			pMasterProjection = NULL;
		}
		if(pResult)
		{
			delete [] pResult;
			pResult = NULL;
		}
		return FALSE;
	}

	TRACE(_T("Reflow Match Matching Success : Matching Score = %.2f\n"), dMaxScore * 100);

	//if(nMaxPos == 0 || nMaxPos == nImageHeight - nMasterHeight - 1)
	//{
	rtMatch->left = nMaxPos;
	//}
	//else
	//{
	//	double dNum = pResult[nMaxPos - 1] - pResult[nMaxPos + 1];
	//	double dDenom = pResult[nMaxPos - 1] + pResult[nMaxPos + 1] - 2 * pResult[nMaxPos];
	//	if(dDenom == 0) dDenom = 0.00000001;
	//}
	rtMatch->right = nMaxPos + nMasterWidth;
	//rtMatch->top = 0;
	//rtMatch->bottom = nImageHeight - 1;

	if(pImageProjection)
	{
		delete [] pImageProjection;
		pImageProjection = NULL;
	}
	if(pMasterProjection)
	{
		delete [] pMasterProjection;
		pMasterProjection = NULL;
	}
	if(pResult)
	{
		delete [] pResult;
		pResult = NULL;
	}

	return TRUE;
}


//2D Image Matching. 속도 문제로 사용하지 않고 있음

//Image의 pixel 값의 제곱의 합을 계산
//Master Image의 제곱의 합을 계산하기 위해 사용
//Input
//  pIn : Image Buffer(Master Image)
//  nSize : Image Size(Master Image Width * Height)
//Return
//  Image Buffer의 Image Size만큼의 pixel 값의 제곱의 합
INT64 GetSquareSumSmallImage(BYTE *pIn, int nSize)
{
	if(pIn == NULL) return -1;

	int i, s = 0;
	INT64 sum = 0;

	__m128i	mmResult, mmResult2;
	__m128i	mmA;
	__m128i	mmAA, mmBB;
	__m128i mmZeroData = _mm_setzero_si128();

	INT64 res64[2];
	mmResult = _mm_setzero_si128();
	for(i = 0; i <= nSize - 16; i += 16)
	{
		mmA = _mm_loadu_si128((__m128i*) (pIn + i));			//load 16 pixels(pSmall[0:15])

		mmAA = _mm_unpackhi_epi8(mmA, mmZeroData);				//byte to short(pSmall[8:15])
		mmResult2 = _mm_madd_epi16(mmAA, mmAA);					//square sum's add(pSmall[8]^2 + pSmall[9]^2 ~ pSmall[14]^2 + pSmall[15]^2)
		mmAA = _mm_unpackhi_epi32(mmResult2, mmZeroData);		//int to int64(pSmall[12]^2 + pSmall[13]^2, pSmall[14]^2 + pSmall[15]^2)
		mmBB = _mm_unpacklo_epi32(mmResult2, mmZeroData);		//int to int64(pSmall[8]^2 + pSmall[9]^2, pSmall[10]^2 + pSmall[11]^2)
		mmResult = _mm_add_epi64(mmAA, mmResult);				//sum(pSmall[12]^2 + pSmall[13]^2 + pSmall[14]^2 + pSmall[15]^2)
		mmResult = _mm_add_epi64(mmBB, mmResult);				//sum(↑ + pSmall[8]^2 + pSmall[9]^2 + pSmall[10]^2 + pSmall[11]^2)

		mmAA = _mm_unpacklo_epi8(mmA, mmZeroData);				//byte to short(pSmall[0:7])
		mmResult2 = _mm_madd_epi16(mmAA, mmAA);					//square sum's add(pSmall[0]^2 + pSmall[1]^2 ~ pSmall[6]^2 + pSmall[7]^2)
		mmAA = _mm_unpackhi_epi32(mmResult2, mmZeroData);		//int to int64(pSmall[4]^2 + pSmall[5]^2, pSmall[6]^2 + pSmall[7]^2)
		mmBB = _mm_unpacklo_epi32(mmResult2, mmZeroData);		//int to int64(pSmall[0]^2 + pSmall[1]^2, pSmall[2]^2 + pSmall[3]^2)
		mmResult = _mm_add_epi64(mmAA, mmResult);				//sum(↑ + pSmall[4]^2 + pSmall[5]^2 + pSmall[6]^2 + pSmall[7]^2)
		mmResult = _mm_add_epi64(mmBB, mmResult);				//sum(↑ + pSmall[0]^2 + pSmall[1]^2 + pSmall[2]^2 + pSmall[3]^2)
	}
	_mm_storeu_si128((__m128i*)res64, mmResult);
	sum = res64[0] + res64[1];

	for( ; i < nSize; i++ )
	{
		s += pIn[i] * pIn[i];
	}

	return sum + s;
}

//GetSquareSumSmallImage와 동일하게 제곱의 합을 계산
//Review Image의 한 Line(Master Image Width만큼)의 제곱의 합을 계산하기 위해 사용
//Master Image Height만큼 합하면 Master Image Size의 Review Image의 제곱의 합을 계산할 수 있음
//Input
//  pIn : Image Buffer(Review Image)
//  nSize : Line Size(Master Image Width)
//Return
//  Image Buffer의 Line Size만큼의 pixel 값의 제곱의 합
INT64 GetSquareSumBigLine(BYTE *pIn, int nSize)		//GetSquareSumSmallImage와 동일
{
	if(pIn == NULL) return -1;

	int i, s = 0;
	INT64 sum = 0;

	__m128i	mmResult, mmResult2;
	__m128i	mmA;
	__m128i	mmAA, mmBB;
	__m128i mmZeroData= _mm_setzero_si128();

	INT64 res64[2];
	mmResult = _mm_setzero_si128();
	for(i = 0; i <= nSize - 16; i += 16)
	{
		mmA = _mm_loadu_si128((__m128i*) (pIn+ i));

		mmAA = _mm_unpackhi_epi8(mmA, mmZeroData);
		mmResult2 = _mm_madd_epi16(mmAA, mmAA);
		mmAA = _mm_unpackhi_epi32(mmResult2, mmZeroData);
		mmBB = _mm_unpacklo_epi32(mmResult2, mmZeroData);
		mmResult = _mm_add_epi64(mmAA, mmResult);
		mmResult = _mm_add_epi64(mmBB, mmResult);

		mmAA = _mm_unpacklo_epi8(mmA, mmZeroData);
		mmResult2 = _mm_madd_epi16(mmAA, mmAA);
		mmAA = _mm_unpackhi_epi32(mmResult2, mmZeroData);
		mmBB = _mm_unpacklo_epi32(mmResult2, mmZeroData);
		mmResult = _mm_add_epi64(mmAA, mmResult);
		mmResult = _mm_add_epi64(mmBB, mmResult);
	}
	_mm_storeu_si128((__m128i*)res64, mmResult);
	sum = res64[0] + res64[1];

	for( ; i < nSize; i++ )
	{
		s += pIn[i] * pIn[i];
	}

	return sum + s;
}

//2 Image의 pixel 값의 곱의 합을 계산
//2 Image의 Correlation을 계산하기 위해 두 Image의 각 pixel의 곱의 합이 필요함
//Input
//  pSmall : Small Image Buffer(Master Image)
//  pBig : Big Image Buffer(Review Image)
//  nSize : Small Image Size(Master Image Width * Height)
//Return
//  Mastrer Image Size만큼의 Master Image와 Review Image의 Pixel 값의 곱의 합
INT64 GetMulSmallBig(BYTE *pSmall, BYTE *pBig, int nSize)
{
	if(pSmall == NULL) return -1;
	if(pBig == NULL) return -1;

	int i, s = 0;
	INT64 sum = 0;

	__m128i	mmResult, mmResult2;
	__m128i	mmA, mmB;
	__m128i	mmAA, mmBB;
	__m128i mmZeroData = _mm_setzero_si128();
	mmResult = _mm_setzero_si128();

	INT64 res64[2];
	for(i = 0; i <= nSize - 16; i += 16)
	{
		mmA = _mm_loadu_si128((__m128i*) (pSmall + i));			//load 16 pixels(pSmall[0:15])
		mmB = _mm_loadu_si128((__m128i*) (pBig + i));			//load 16 pixels(pBig[0:15])

		mmAA = _mm_unpackhi_epi8(mmA, mmZeroData);				//byte to short(pSmall[8:15])
		mmBB = _mm_unpackhi_epi8(mmB, mmZeroData);				//byte to short(pBig[8:15])
		mmResult2 = _mm_madd_epi16(mmAA, mmBB);					//Multiple sum's add(pSmall[8]*pBig[8] + pSmall[9]*pBig[9] ~ pSmall[14]*pBig[14] + pSmall[15]*pBig[15])
		mmAA = _mm_unpackhi_epi32(mmResult2, mmZeroData);		//int to int64(pSmall[12]*pBig[12] + pSmall[13]*pBig[13], pSmall[14]*pBig[14] + pSmall[15]*pBig[15])
		mmBB = _mm_unpacklo_epi32(mmResult2, mmZeroData);		//int to int64(pSmall[8]*pBig[8] + pSmall[9]*pBig[9], pSmall[10]*pBig[10] + pSmall[11]*pBig[11])
		mmResult = _mm_add_epi64(mmAA, mmResult);				//sum(pSmall[12]*pBig[12] + pSmall[13]*pBig[13], pSmall[14]*pBig[14] + pSmall[15]*pBig[15])
		mmResult = _mm_add_epi64(mmBB, mmResult);				//sum(↑ + pSmall[8]*pBig[8] + pSmall[9]*pBig[9], pSmall[10]*pBig[10] + pSmall[11]*pBig[11])

		mmAA = _mm_unpacklo_epi8(mmA, mmZeroData);
		mmBB = _mm_unpacklo_epi8(mmB, mmZeroData);
		mmResult2 = _mm_madd_epi16(mmAA, mmBB);
		mmAA = _mm_unpackhi_epi32(mmResult2, mmZeroData);
		mmBB = _mm_unpacklo_epi32(mmResult2, mmZeroData);
		mmResult = _mm_add_epi64(mmAA, mmResult);
		mmResult = _mm_add_epi64(mmBB, mmResult);
	}
	_mm_storeu_si128((__m128i*)res64, mmResult);
	sum = res64[0] + res64[1];

	for(; i < nSize; i++)
	{
		s += pSmall[i] * pBig[i];
	}

	return sum + s;
}

//Matching 결과 Matching Score가 가장 높은 좌표를 찾음
//Input
//  pMatchResult : Matching Result를 각 좌표마다 저장한 array((Review Image Width - Master Image WIdth) * (Review Image Height - Master Image Height)) 크기
//  nBigWidth : Big Image Width(Review Image)
//  nBigHeight : Big Image Height(Review Image)
//  nSmallWidth : Small Image Width(Master Image)
//  nSmallHeight : Small Image Height(Master Image)
//  MatchResult Array의 Size를 계산하기 위해 각 Image의 크기를 입력받음
//Output
//  x : Review Image 내에서 Matching 된 위치의 x좌표
//  y : Review Image 내에서 Matching 된 위치의 y좌표
//  s : Review Image 내에서 Matching 된 위치의 Matching Score
void SetBestMatchResult(int &x, int &y, double &s, double *pMatchResult, int nBigWidth, int nBigHeight, int nSmallWidth, int nSmallHeight)
{
	if(pMatchResult == NULL)
	{
		TRACE(_T("SetBestMatchResult : Match Result Array Is Not Allocated\n"));
		return;
	}

	int nWidth = nBigWidth - nSmallWidth + 1;
	int nHeight = nBigHeight - nSmallHeight + 1;
	int i, j;

	s = *pMatchResult;

	for(i = 0; i < nHeight; i++)										//MatchResult 중 Max 값 탐색
	{
		for(j = 0; j < nWidth; j++)
		{
			double dTempMatch = *(pMatchResult + i * nWidth + j);
			if(s < dTempMatch)
			{
				s = dTempMatch;
				x = j;
				y = i;
			}
		}
	}
}

//사용되지 않는 메소드
//Matching 결과 Matching Score가 가장 높은 좌표를 찾음
//정수 좌표의 Score(pMatchResult)를 이용하여 선형 보정을 통해 소수 좌표의 x, y 좌표를 찾음
//Input
//  pMatchResult : Matching Result를 각 좌표마다 저장한 array((Review Image Width - Master Image WIdth) * (Review Image Height - Master Image Height)) 크기
//  nBigWidth : Big Image Width(Review Image)
//  nBigHeight : Big Image Height(Review Image)
//  nSmallWidth : Small Image Width(Master Image)
//  nSmallHeight : Small Image Height(Master Image)
//  MatchResult Array의 Size를 계산하기 위해 각 Image의 크기를 입력받음
//Output
//  dOffsetX : Review Image 내에서 Matching 된 위치의 x좌표
//  dOffsetY : Review Image 내에서 Matching 된 위치의 y좌표
//  dScore : Review Image 내에서 Matching 된 위치의 Matching Score
void SetBestMatchResult(double *dOffsetX, double *dOffsetY, double *dScore, double *pMatchResult, int nBigWidth, int nBigHeight, int nSmallWidth, int nSmallHeight)
{
	if(pMatchResult == NULL)
	{
		TRACE(_T("SetBestMatchResult : Match Result Array Is Not Allocated\n"));
		return;
	}
	if(dOffsetX == NULL || dOffsetY == NULL || dScore == NULL)
	{
		TRACE(_T("SetBestMatchResult : Output Value Is Not Allocated\n"));
		return;
	}

	int nWidth = nBigWidth - nSmallWidth + 1;
	int nHeight = nBigHeight - nSmallHeight + 1;
	double dBestMatch = *pMatchResult;
	int i, j;
	int xTemp = 0, yTemp = 0;
	double xBestMatch, yBestMatch;

	for(i = 0; i < nHeight; i++)										//MatchResult 중 Max 값 탐색
	{
		for(j = 0; j < nWidth; j++)
		{
			double dTempMatch = *(pMatchResult + i * nWidth + j);
			if(dBestMatch < dTempMatch)
			{
				dBestMatch = dTempMatch;
				xTemp = j;
				yTemp = i;
			}
		}
	}

	double dBestMatchP, dBestMatchN;
	if(xTemp == 0)
	{
		xBestMatch = xTemp;
	}
	else if(xTemp == nWidth - 1)
	{
		xBestMatch = xTemp;
	}
	else
	{
		dBestMatchP = *(pMatchResult + yTemp * nWidth + xTemp - 1);
		dBestMatchN = *(pMatchResult + yTemp * nWidth + xTemp + 1);
		if(dBestMatch == dBestMatchP)
		{
			xBestMatch = xTemp - 0.5;
		}
		else if(dBestMatch == dBestMatchN)
		{
			xBestMatch = xTemp + 0.5;
		}
		else if(dBestMatchP < dBestMatchN)
		{
			xBestMatch = xTemp + 0.5 - 0.5 * (dBestMatch - dBestMatchN) / (dBestMatch - dBestMatchP);
		}
		else
		{
			xBestMatch = xTemp - 0.5 + 0.5 / (dBestMatch - dBestMatchN) * (dBestMatch - dBestMatchP);
		}
	}

	if(yTemp == 0)
	{
		yBestMatch = yTemp;
	}
	else if(yTemp == nHeight - 1)
	{
		yBestMatch = yTemp;
	}
	else
	{
		dBestMatchP = *(pMatchResult + (yTemp - 1) * nWidth + xTemp);
		dBestMatchN = *(pMatchResult + (yTemp + 1) * nWidth + xTemp);
		if(dBestMatch == dBestMatchP)
		{
			yBestMatch = yTemp - 0.5;
		}
		else if(dBestMatch == dBestMatchN)
		{
			yBestMatch = yTemp + 0.5;
		}
		else if(dBestMatchP < dBestMatchN)
		{
			yBestMatch = yTemp + 0.5 - 0.5 * (dBestMatch - dBestMatchN) / (dBestMatch - dBestMatchP);
		}
		else
		{
			yBestMatch = yTemp - 0.5 + 0.5 / (dBestMatch - dBestMatchN) * (dBestMatch - dBestMatchP);
		}
	}
	*dOffsetX = xBestMatch - (nBigWidth - nSmallWidth) / 2;
	*dOffsetY = yBestMatch - (nBigHeight - nSmallHeight) / 2;
	*dScore = dBestMatch;
}

//Image를 복사하는 메소드. width가 widthBig -> widthSmall로 변경됨.
//Review Image를 Master Image Width만큼 자르기 위해 사용
//Input
//  pIn : Input Image(Review Image)
//  nWidthSmall : Output Image의 Width(Master Image Width)
//  nWidthBig : Input Image의 Width(Review Image Width)
//  nHeightBig : Input Image의 Height(Review Image Height)
//Output
//  pOut : Output Image(Master Image Width만큼 Crop된 Review Image)
void CopyImage(BYTE *pOut, BYTE *pIn, int nWidthSmall, int nWidthBig, int nHeightBig)
{
	if(pOut == NULL)
	{
		TRACE(_T("CopyImage : Output Is Not Allocated\n"));
		return;
	}
	if(pIn == NULL)
	{
		TRACE(_T("CopyImage : Input Is Not Allocated\n"));
		return;
	}

	BYTE *pOutTemp;
	BYTE *pInTemp;
	for(int y = 0; y < nHeightBig; y++)
	{
		pOutTemp = pOut + y * nWidthSmall;
		pInTemp = pIn + y * nWidthBig;

		memcpy(pOutTemp, pInTemp, sizeof(BYTE) * nWidthSmall);
	}
}

//Review Image와 Master Image를 Matching하여 Review Image 내 ROI를 설정함
//2D Matching은 속도가 오래 걸리기 때문에 Top, Bottom을 최대한 줄여서 하는 것이 좋음
//Side = Top의 경우 호출됨
//Matching Method는 Correlation 사용
//Input
//  pImage : Review Image(Gray Image)
//  nImageWidth : Review Image Width
//  nImageHeight : Review Image Height
//  pMaster : Master Image Buffer(Gray Image)
//  nMasterWidth : Master Image Width
//  nMasterHeight : Master Image Height
//Output
//  rtMatch : Matching 결과 ROI
//Return
//  Match 성공 여부 T/F
//  Matching Score 0.9 이상인 경우 TRUE(정확한 Score 기준은 추가 Test가 필요함)
BOOL SecondMatch_Vertical(BYTE *pImage, int nImageWidth, int nImageHeight, BYTE *pMaster, int nMasterWidth, int nMasterHeight, CRect *rtMatch)
{
	if(pImage == NULL)
	{
		TRACE(_T("SecondMatch_Vertical : Review Is Not Allocated\n"));
		return FALSE;
	}
	if(pMaster == NULL)
	{
		TRACE(_T("SecondMatch_Vertical : Master Is Not Allocated\n"));
		return FALSE;
	}
	if(rtMatch == NULL)
	{
		TRACE(_T("SecondMatch_Vertical : ROIRect Is Not Allocated\n"));
		return FALSE;
	}

	int x, y;
	int nMatchHeight = rtMatch->Height();

	double *pMatchResult = NULL;
	pMatchResult = new double[(nImageWidth - nMasterWidth + 1) * (nMatchHeight - nMasterHeight + 1)];		//정수 단위 Match 수행 = Big - Small Size
	INT64 *pBigLineSqSum = NULL;
	pBigLineSqSum = new INT64[nMatchHeight];																//Big Image의 Line 단위 계산 = Big Height
	BYTE *pTempImage = NULL;
	pTempImage = new BYTE[nMasterWidth * (nMatchHeight + nImageWidth / nMasterWidth + 1)];					//Big Image의 Crop = Small Width * Big Height

	CopyImage(pTempImage, pImage + rtMatch->top * nImageWidth, nMasterWidth, nImageWidth, nMatchHeight);

	INT64 *ptBigLineSqSum = pBigLineSqSum;
	INT64 nSmallImageSqSum = GetSquareSumSmallImage(pMaster, nMasterWidth * nMasterHeight);				//Small Image Square Sum
	double dSmallCorrelation = ((nSmallImageSqSum == 0) ? 1.7976931348623158e+308 : 1 / sqrt((double)nSmallImageSqSum));						//Normalize Factor
	BYTE *pBigLine;
	INT64 nBigLineSqSum;

	for(y = 0; y < nMatchHeight; y++)																					//y = Big height ( Big Image의 LineSqSum 계산 )
	{
		pBigLine = pImage + nImageWidth * (y + rtMatch->top);
		nBigLineSqSum = GetSquareSumBigLine(pBigLine, nMasterWidth);													//Big Image Line Square Sum(Small Image Width)
		pBigLineSqSum[y] = nBigLineSqSum;
	}

	//INT64 *pSmallBigImgMul = m_pSmallBigImgMul;
	//INT64 *pBigImgSqSum = m_pBigImgSqSum;
	INT64 nBigImageSqSum;

	for(x = 0; x < nImageWidth - nMasterWidth + 1; x++)														//x = Big width - Small width ( Match Result 계산 )
	{
		nBigImageSqSum = 0;
		BYTE *pImgPointer = pTempImage + x;

		if(x > 0)																												//이전 열 Data 제거, 다음 열 Data 추가
		{
			BYTE *pTempImageIn = pImage + x + nMasterWidth - 1 + rtMatch->top * nImageWidth;									//Big Image Line + Small Width(↑nBigLineSqSum에 포함되지 않은 다음 Pixel)
			BYTE *pTempImageOut = pImgPointer - 1;																				//Big Image Line - 1(↑nBigLineSqSum에 포함된 첫번째 Pixel)
			int nOutPixel = *pTempImageOut;
			pTempImageOut += nMasterWidth;

			for(y = 0; y < nMatchHeight; y++)																			//y = Big height ( Big Image의 LineSqSum 계산 )
			{
				int nInPixel = *pTempImageIn;

				ptBigLineSqSum[y] += (nInPixel + nOutPixel) * (nInPixel - nOutPixel);											//LineSqSum + InPixel^2 - OutPixel^2

				nOutPixel = *pTempImageOut;																						//Big Image Line의 다음 행
				*pTempImageOut = nInPixel;																						//pTempImage[x]에 nInPixel을 대입하여 순환식 구조로 사용

				pTempImageIn += nImageWidth;																			//Big Image의 다음 행
				pTempImageOut += nMasterWidth;																			//pTempImage의 다음 행
			}
		}

		for(y = 0; y < nMasterHeight; y++)																				//y = Small height ( Big Image의 SqSum 계산(Small Image Size) )
		{
			nBigImageSqSum += ptBigLineSqSum[y];																					//Big Image(x, y) Square Sum(Small Image Size)
		}

		pImgPointer = pTempImage + x;																							//pTempImage는 Big Image의 Small Width Crop을 가지고 있음
		for(y = 0; y < nMatchHeight - nMasterHeight + 1; y++)													//y = Big height - Small height ( Match Result 계산 )
		{
			INT64 nSmallBigImgMul = GetMulSmallBig(pMaster, pImgPointer, nMasterWidth * nMasterHeight);	//Small Image와 Big Image의 Pixel의 곱

			if(y > 0)																											//이전 행 Data 제거, 다음 행 Data 추가
			{
				nBigImageSqSum -= ptBigLineSqSum[y - 1];																			//nBigImageSqSum에 포함된 첫번째 Line Square Sum 
				nBigImageSqSum += ptBigLineSqSum[y + nMasterHeight - 1];													//nBigImageSqSum에 포함되지 않은 다음 Line Square Sum
			}

			//pSmallBigImgMul[y] = nSmallBigImgMul;																				//Small Image * Big Image
			//pBigImgSqSum[y] = nBigImageSqSum;																					//Big Image Square Sum

			double dMatchResult = (double)nSmallBigImgMul * dSmallCorrelation / sqrt((double)nBigImageSqSum);					//(Small * Big) / (sqrt(Small * Small) * sqrt(Big * Big))
			pMatchResult[y * (nImageWidth - nMasterWidth + 1) + x] = dMatchResult;							//↑ if(Small = Big) → (Small * Small) / sqrt(Small * Small)^2 = 1
			//double dMatchResult = (double)pSmallBigImgMul[y] * dSmallCorrelation / sqrt((double)pBigImgSqSum[y]);				//(Small * Big) / (sqrt(Small * Small) * sqrt(Big * Big))
			//m_pMatchResult[y * (nImageWidth - nMasterWidth + 1) + x] = dMatchResult;							//↑ if(Small = Big) → (Small * Small) / sqrt(Small * Small)^2 = 1

			pImgPointer += nMasterWidth;																				//pTempImage의 다음 행
		}
	}

	int left;
	int top;
	double score;

	SetBestMatchResult(left, top, score, pMatchResult, nImageWidth, nMatchHeight, nMasterWidth, nMasterHeight);

	if(score < 0.9)
	{
		if(pMatchResult)
		{
			delete [] pMatchResult;
			pMatchResult = NULL;
		}
		if(pBigLineSqSum)
		{
			delete [] pBigLineSqSum;
			pBigLineSqSum = NULL;
		}
		if(pTempImage)
		{
			delete [] pTempImage;
			pTempImage = NULL;
		}
		return FALSE;
	}
	else
	{
		rtMatch->right = left + nMasterWidth;
		rtMatch->left = left;
		rtMatch->bottom = top + rtMatch->top + nMasterHeight;
		rtMatch->top = top + rtMatch->top;

		if(pMatchResult)
		{
			delete [] pMatchResult;
			pMatchResult = NULL;
		}
		if(pBigLineSqSum)
		{
			delete [] pBigLineSqSum;
			pBigLineSqSum = NULL;
		}
		if(pTempImage)
		{
			delete [] pTempImage;
			pTempImage = NULL;
		}
		return TRUE;
	}
}

//Review Image와 Master Image를 Matching하여 Review Image 내 ROI를 설정함
//2D Matching은 속도가 오래 걸리기 때문에 Left, Right를 최대한 줄여서 하는 것이 좋음
//Side = Top의 경우 호출됨
//Matching Method는 Correlation 사용
//Input
//  pImage : Review Image(Gray Image)
//  nImageWidth : Review Image Width
//  nImageHeight : Review Image Height
//  pMaster : Master Image Buffer(Gray Image)
//  nMasterWidth : Master Image Width
//  nMasterHeight : Master Image Height
//Output
//  rtMatch : Matching 결과 ROI
//Return
//  Match 성공 여부 T/F
//  Matching Score 0.9 이상인 경우 TRUE(정확한 Score 기준은 추가 Test가 필요함)
BOOL SecondMatch_Horizontal(BYTE *pImage, int nImageWidth, int nImageHeight, BYTE *pMaster, int nMasterWidth, int nMasterHeight, CRect *rtMatch)
{
	int x, y;
	int nMatchWidth = rtMatch->Width();

	double *pMatchResult = NULL;
	pMatchResult = new double[(nMatchWidth - nMasterWidth + 1) * (nImageHeight - nMasterHeight + 1)];		//정수 단위 Match 수행 = Big - Small Size
	INT64 *pBigLineSqSum = NULL;
	pBigLineSqSum = new INT64[nImageHeight];																//Big Image의 Line 단위 계산 = Big Height
	BYTE *pTempImage = NULL;
	pTempImage = new BYTE[nMasterWidth * (nImageHeight + nImageWidth / nMasterWidth + 1)];					//Big Image의 Crop = Small Width * Big Height

	CopyImage(pTempImage, pImage + rtMatch->left, nMasterWidth, nImageWidth, nImageHeight);

	INT64 *ptBigLineSqSum = pBigLineSqSum;
	INT64 nSmallImageSqSum = GetSquareSumSmallImage(pMaster, nMasterWidth * nMasterHeight);				//Small Image Square Sum
	double dSmallCorrelation = ((nSmallImageSqSum == 0) ? 1.7976931348623158e+308 : 1 / sqrt((double)nSmallImageSqSum));						//Normalize Factor
	BYTE *pBigLine;
	INT64 nBigLineSqSum;

	for(y = 0; y < nImageHeight; y++)																					//y = Big height ( Big Image의 LineSqSum 계산 )
	{
		pBigLine = pImage + nImageWidth * y + rtMatch->left;
		nBigLineSqSum = GetSquareSumBigLine(pBigLine, nMasterWidth);													//Big Image Line Square Sum(Small Image Width)
		pBigLineSqSum[y] = nBigLineSqSum;
	}

	//INT64 *pSmallBigImgMul = m_pSmallBigImgMul;
	//INT64 *pBigImgSqSum = m_pBigImgSqSum;
	INT64 nBigImageSqSum;

	for(x = 0; x < nMatchWidth - nMasterWidth + 1; x++)														//x = Big width - Small width ( Match Result 계산 )
	{
		nBigImageSqSum = 0;
		BYTE *pImgPointer = pTempImage + x;

		if(x > 0)																												//이전 열 Data 제거, 다음 열 Data 추가
		{
			BYTE *pTempImageIn = pImage + x + nMasterWidth - 1 + rtMatch->left;														//Big Image Line + Small Width(↑nBigLineSqSum에 포함되지 않은 다음 Pixel)
			BYTE *pTempImageOut = pImgPointer - 1;																				//Big Image Line - 1(↑nBigLineSqSum에 포함된 첫번째 Pixel)
			int nOutPixel = *pTempImageOut;
			pTempImageOut += nMasterWidth;

			for(y = 0; y < nImageHeight; y++)																			//y = Big height ( Big Image의 LineSqSum 계산 )
			{
				int nInPixel = *pTempImageIn;

				ptBigLineSqSum[y] += (nInPixel + nOutPixel) * (nInPixel - nOutPixel);											//LineSqSum + InPixel^2 - OutPixel^2

				nOutPixel = *pTempImageOut;																						//Big Image Line의 다음 행
				*pTempImageOut = nInPixel;																						//pTempImage[x]에 nInPixel을 대입하여 순환식 구조로 사용

				pTempImageIn += nImageWidth;																			//Big Image의 다음 행
				pTempImageOut += nMasterWidth;																			//pTempImage의 다음 행
			}
		}

		for(y = 0; y < nMasterHeight; y++)																				//y = Small height ( Big Image의 SqSum 계산(Small Image Size) )
		{
			nBigImageSqSum += ptBigLineSqSum[y];																					//Big Image(x, y) Square Sum(Small Image Size)
		}

		pImgPointer = pTempImage + x;																							//pTempImage는 Big Image의 Small Width Crop을 가지고 있음
		for(y = 0; y < nImageHeight - nMasterHeight + 1; y++)													//y = Big height - Small height ( Match Result 계산 )
		{
			INT64 nSmallBigImgMul = GetMulSmallBig(pMaster, pImgPointer, nMasterWidth * nMasterHeight);	//Small Image와 Big Image의 Pixel의 곱

			if(y > 0)																											//이전 행 Data 제거, 다음 행 Data 추가
			{
				nBigImageSqSum -= ptBigLineSqSum[y - 1];																			//nBigImageSqSum에 포함된 첫번째 Line Square Sum 
				nBigImageSqSum += ptBigLineSqSum[y + nMasterHeight - 1];													//nBigImageSqSum에 포함되지 않은 다음 Line Square Sum
			}

			//pSmallBigImgMul[y] = nSmallBigImgMul;																				//Small Image * Big Image
			//pBigImgSqSum[y] = nBigImageSqSum;																					//Big Image Square Sum

			double dMatchResult = (double)nSmallBigImgMul * dSmallCorrelation / sqrt((double)nBigImageSqSum);					//(Small * Big) / (sqrt(Small * Small) * sqrt(Big * Big))
			pMatchResult[y * (nMatchWidth - nMasterWidth + 1) + x] = dMatchResult;							//↑ if(Small = Big) → (Small * Small) / sqrt(Small * Small)^2 = 1
			//double dMatchResult = (double)pSmallBigImgMul[y] * dSmallCorrelation / sqrt((double)pBigImgSqSum[y]);				//(Small * Big) / (sqrt(Small * Small) * sqrt(Big * Big))
			//m_pMatchResult[y * (nImageWidth - nMasterWidth + 1) + x] = dMatchResult;							//↑ if(Small = Big) → (Small * Small) / sqrt(Small * Small)^2 = 1

			pImgPointer += nMasterWidth;																				//pTempImage의 다음 행
		}
	}

	int left;
	int top;
	double score;

	SetBestMatchResult(left, top, score, pMatchResult, nMatchWidth, nImageHeight, nMasterWidth, nMasterHeight);

	if(score < 0.9)
	{
		if(pMatchResult)
		{
			delete [] pMatchResult;
			pMatchResult = NULL;
		}
		if(pBigLineSqSum)
		{
			delete [] pBigLineSqSum;
			pBigLineSqSum = NULL;
		}
		if(pTempImage)
		{
			delete [] pTempImage;
			pTempImage = NULL;
		}
		return FALSE;
	}
	else
	{
		rtMatch->right = left + nMasterWidth + rtMatch->left;
		rtMatch->left = left + rtMatch->left;
		rtMatch->bottom = top + nMasterHeight;
		rtMatch->top = top;

		if(pMatchResult)
		{
			delete [] pMatchResult;
			pMatchResult = NULL;
		}
		if(pBigLineSqSum)
		{
			delete [] pBigLineSqSum;
			pBigLineSqSum = NULL;
		}
		if(pTempImage)
		{
			delete [] pTempImage;
			pTempImage = NULL;
		}
		return TRUE;
	}
}

//검사Threshold가 몇개 설정되었는가 Check
//Threshold 개수에 따라 아래와 같이 사용됨
//1개 : 모든 Line의 Threshold 통일
//2, 3개 : DAM1, DAM2가 각각 1개씩 사용
//4개 : 각 Line별 사용으로 나뉨
//Input
//  rParam : Linecheck_Method에 넘겨준 reflow parameter 정보
//Return
//  Threshold 정상 설정 여부 T/F
BOOL CheckThresholdCount(reflowParam* rParam)
{
	int countTh = 0;
	BOOL checkTh[4];
	BOOL ret = TRUE;
	for(int i = 0; i < 4; i++)
	{
		checkTh[i] = FALSE;
	}
	if(rParam->nDamTh2 > 0){countTh++; checkTh[0] = TRUE;}
	if(rParam->nDamTh2_in > 0){countTh++; checkTh[1] = TRUE;}
	if(rParam->nDamTh1 > 0){countTh++; checkTh[2] = TRUE;}
	if(rParam->nDamTh1_in > 0){countTh++; checkTh[3] = TRUE;}

	if(countTh == 0) return FALSE;
	switch(countTh)
	{
	case 0 :
		ret = FALSE;
		break;
	case 1 : 
		if(checkTh[0]) rParam->nDamTh1 = rParam->nDamTh1_in = rParam->nDamTh2_in = rParam->nDamTh2;
		if(checkTh[1]) rParam->nDamTh1 = rParam->nDamTh1_in = rParam->nDamTh2 = rParam->nDamTh2_in;
		if(checkTh[2]) rParam->nDamTh2 = rParam->nDamTh2_in = rParam->nDamTh1_in = rParam->nDamTh1;
		if(checkTh[3]) rParam->nDamTh2 = rParam->nDamTh2_in = rParam->nDamTh1 = rParam->nDamTh1_in;
		break;
	case 2 : //아이디어가..
		if(checkTh[0] & checkTh[1])
		{
			rParam->nDamTh1 = rParam->nDamTh2;
			rParam->nDamTh1_in = rParam->nDamTh2_in;
		}
		else if(checkTh[2] & checkTh[3])
		{
			rParam->nDamTh2 = rParam->nDamTh1;
			rParam->nDamTh2_in = rParam->nDamTh1_in;
		}
		else
		{
			if(checkTh[0]) rParam->nDamTh2_in = rParam->nDamTh2;
			if(checkTh[1]) rParam->nDamTh2 = rParam->nDamTh2_in;
			if(checkTh[2]) rParam->nDamTh1_in = rParam->nDamTh1;
			if(checkTh[3]) rParam->nDamTh1 = rParam->nDamTh1_in;
		}
		break;
	case 3 : 
		if(!checkTh[0]) rParam->nDamTh2 = rParam->nDamTh2_in;
		if(!checkTh[1]) rParam->nDamTh2_in = rParam->nDamTh2;
		if(!checkTh[2]) rParam->nDamTh1 = rParam->nDamTh1_in;
		if(!checkTh[3]) rParam->nDamTh1_in = rParam->nDamTh1;
		break;
	}


	return ret;
}

//검사에 필요한 Reflow Parameter가 정상적으로 Setting 되었는지 Check
//Input
//  rParam : Linecheck_Method에 넘겨준 reflow parameter 정보
//Return
//  정상 Setting 여부 T/F
BOOL CheckSetting(reflowParam* rParam)
{
	if(rParam == NULL) {TRACE(_T("Reflow Param Is Not Setted\n")); return FALSE;}

	BOOL ret = TRUE;
	if(rParam->pImageBuffer == NULL) {TRACE(_T("Review Image Not Loaded\n")); ret = FALSE;}
	if(rParam->nImageWidth <= 0) {TRACE(_T("Review Image Width Is Not Valid\n")); ret = FALSE;}
	if(rParam->nImageHeight <= 0) {TRACE(_T("Review Image Height Is Not Valid\n")); ret = FALSE;}
	if(rParam->nChannel <= 0 || rParam->nChannel > 4) {TRACE(_T("Review Image Channel Is Not Valid\n")); ret = FALSE;}
	if(rParam->nImageWidthStep <= 0 || rParam->nImageWidthStep < rParam->nImageWidth * rParam->nChannel) {TRACE(_T("Review Image WidthStep Is Not Valid\n")); ret = FALSE;}
	if(rParam->ROI_Rect == NULL) {TRACE(_T("ROI Area Is Not Set\n")); ret = FALSE;}
	if(rParam->nSide < 0 || rParam->nSide > 3) {TRACE(_T("Reflow Side Is Not Vaild\n")); ret = FALSE;}
	if(rParam->nDistance == NULL) {TRACE(_T("DAM Distances Is Not Set\n")); ret = FALSE;}

	if(rParam->pMasterBuffer == NULL) {TRACE(_T("Master Image Not Loaded\n")); ret = FALSE;}
	if(rParam->nMasterWidth <= 0) {TRACE(_T("Master Image Width Is Not Valid\n")); ret = FALSE;}
	if(rParam->nMasterHeight <= 0) {TRACE(_T("Master Image Height Is Not Valid\n")); ret = FALSE;}
	if(rParam->nMasterChannel <= 0 || rParam->nMasterChannel > 4) {TRACE(_T("Master Image Channel Is Not Valid\n")); ret = FALSE;}
	if(rParam->nMasterWidthStep <= 0 || rParam->nMasterWidthStep < rParam->nMasterWidth * rParam->nMasterChannel) {TRACE(_T("Master Image WidthStep Is Not Valid\n")); ret = FALSE;}

	//190216 최홍철 Threshold 4개로 분할
	if(!CheckThresholdCount(rParam)) {TRACE(_T("Invalid Threshold\n")); ret = FALSE;}

	return ret;
}
//
////No Overflow 위치에 선을 그려 peak point의 위치를 보여줌
////Side = Top일 때 호출되며, peak point에 해당하는 가로줄을 그림
////Input
////  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
////  nImageWidth : Review Image Width.
////  nImageHeight : Review Image Height.
////  nChannel : Review Image Color Channel.
////  nImageWidthStep : Review Image Buffer Width Size(Width * Channel + margin)
////  boe_line : No overflow 판정된 DAM Line의 좌표 Array
////Output
////  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
//void Reflow_Line_Paint_Vertical(BYTE *pImageBuffer, int nImageWidth, int nImageHeight, int nChannel, int nImageWidthStep, int *boe_line)
//{
//	if(pImageBuffer == NULL)
//	{
//		TRACE(_T("Reflow_Line_Paint_Vertical : Review Image Is Not Loaded\n"));
//		return;
//	}
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Reflow_Line_Paint_Vertical : Line Coordi Array Is Not Allocated\n"));
//		return;
//	}
//
//	int nLineLength = 30;	//30Pixel 단위로 표시선을 그림
//
//	int nSolidWidth = 20;
//
//	if(nChannel == 1)	//1 Channel(Gray Image)인 경우
//	{
//		BYTE *tempWhite = NULL;
//		tempWhite = new BYTE[nLineLength];
//		memset(tempWhite, 255, sizeof(BYTE) * nLineLength);	//30Pixel 짜리 White Line 생성
//
//		for(int j = 0; j < 4; j++)
//		{
//			int nY = boe_line[j];
//			if(nY <= 0) continue;	//Overflow인 Line인 경우 Skip
//			for(int i = 0; i < nImageWidthStep - nLineLength * 2 * nChannel; i += nLineLength * 2 * nChannel)	//30Pixel단위로 그리고 원래 Image 남겨두고를 반복
//			{
//				for(int k = -nSolidWidth / 2; k < nSolidWidth / 2; k++)
//				{
//					//memcpy((pImageBuffer + (nY - 1) * nImageWidthStep + i), tempWhite, sizeof(BYTE) * nLineLength * nChannel);
//					memcpy((pImageBuffer + (nY + k) * nImageWidthStep + i), tempWhite, sizeof(BYTE) * nLineLength * nChannel);
//					//memcpy((pImageBuffer + (nY + 1) * nImageWidthStep + i), tempWhite, sizeof(BYTE) * nLineLength * nChannel);
//				}
//			}
//		}
//
//		if(tempWhite)
//		{
//			delete [] tempWhite;
//			tempWhite = NULL;
//		}
//	}
//	else	//3, 4Channel(Color Image)인 경우
//	{
//		BYTE *tempWhite = NULL;
//		tempWhite = new BYTE[nLineLength * nChannel];
//		memset(tempWhite, 0, sizeof(BYTE) * nLineLength * nChannel);
//		for(int i = 0; i < nLineLength; i++)
//		{
//			*(tempWhite + i * nChannel + 2) = 255;	//30Pixel 짜리 Red Line 생성
//		}
//
//		for(int j = 0; j < 4; j++)
//		{
//			int nY = boe_line[j];
//			if(nY <= 0) continue;
//			for(int i = 0; i < nImageWidthStep - nLineLength * 2 * nChannel; i += nLineLength * 2 * nChannel)	//30Pixel단위로 그리고 원래 Image 남겨두고를 반복
//			{
//				for(int k = -nSolidWidth / 2; k < nSolidWidth / 2; k++)
//				{
//					//memcpy((pImageBuffer + (nY - 1) * nImageWidthStep + i), tempWhite, sizeof(BYTE) * nLineLength * nChannel);
//					memcpy((pImageBuffer + (nY + k) * nImageWidthStep + i), tempWhite, sizeof(BYTE) * nLineLength * nChannel);
//					//memcpy((pImageBuffer + (nY + 1) * nImageWidthStep + i), tempWhite, sizeof(BYTE) * nLineLength * nChannel);
//				}
//			}
//		}
//
//		if(tempWhite)
//		{
//			delete [] tempWhite;
//			tempWhite = NULL;
//		}
//	}
//}
//
////No Overflow 위치에 선을 그려 peak point의 위치를 보여줌
////Side = Left, Right일 때 호출되며, peak point에 해당하는 세로줄을 그림
////Input
////  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
////  nImageWidth : Review Image Width.
////  nImageHeight : Review Image Height.
////  nChannel : Review Image Color Channel.
////  nImageWidthStep : Review Image Buffer Width Size(Width * Channel + margin)
////  boe_line : No overflow 판정된 DAM Line의 좌표 Array
////Output
////  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
//void Reflow_Line_Paint_Horizontal(BYTE *pImageBuffer, int nImageWidth, int nImageHeight, int nChannel, int nImageWidthStep, int *boe_line)
//{
//	if(pImageBuffer == NULL)
//	{
//		TRACE(_T("Reflow_Line_Paint_Vertical : Review Image Is Not Loaded\n"));
//		return;
//	}
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Reflow_Line_Paint_Vertical : Line Coordi Array Is Not Allocated\n"));
//		return;
//	}
//
//	int nLineLength = 30;	//30Pixel 단위로 표시선을 그림
//	int nCount = 0;
//	BOOL bLine = TRUE;
//
//	int nSolidWidth = 20;
//
//	if(nChannel == 1)	//1 Channel(Gray Image)인 경우
//	{
//		for(int j = 0; j < 4; j++)
//		{
//			nCount = 0;
//			int nX = boe_line[j];
//			if(nX <= 0) continue;	//Overflow인 Line인 경우 Skip
//			for(int i = 0; i < nImageHeight; i++)
//			{
//				if(bLine)
//				{
//					for(int k = -nSolidWidth / 2; k < nSolidWidth / 2; k++)
//					{
//						//*(pImageBuffer + i * nImageWidthStep + (nX - 1) * nChannel) = 255;
//						*(pImageBuffer + i * nImageWidthStep + (nX + k) * nChannel) = 255;
//						//*(pImageBuffer + i * nImageWidthStep + (nX + 1) * nChannel) = 255;
//					}
//				}
//
//				if(++nCount == nLineLength)	//30Pixel단위로 그리고 원래 Image 남겨두고를 반복
//				{
//					nCount = 0;
//					bLine = !bLine;
//				}
//			}
//		}
//	}
//	else	//3, 4Channel(Color Image)인 경우
//	{
//		for(int j = 0; j < 4; j++)
//		{
//			nCount = 0;
//			int nX = boe_line[j];
//			if(nX <= 0) continue;	//Overflow인 Line인 경우 Skip
//			for(int i = 0; i < nImageHeight; i ++)
//			{
//				if(bLine)
//				{
//					for(int k = -nSolidWidth / 2; k < nSolidWidth / 2; k++)
//					{
//					//*(pImageBuffer + i * nImageWidthStep + (nX - 1) * nChannel + 0) = 0;
//					//*(pImageBuffer + i * nImageWidthStep + (nX - 1) * nChannel + 1) = 0;
//					//*(pImageBuffer + i * nImageWidthStep + (nX - 1) * nChannel + 2) = 255;
//					*(pImageBuffer + i * nImageWidthStep + (nX + k) * nChannel + 0) = 0;
//					*(pImageBuffer + i * nImageWidthStep + (nX + k) * nChannel + 1) = 0;
//					*(pImageBuffer + i * nImageWidthStep + (nX + k) * nChannel + 2) = 255;
//					//*(pImageBuffer + i * nImageWidthStep + (nX + 1) * nChannel + 0) = 0;
//					//*(pImageBuffer + i * nImageWidthStep + (nX + 1) * nChannel + 1) = 0;
//					//*(pImageBuffer + i * nImageWidthStep + (nX + 1) * nChannel + 2) = 255;
//					}
//				}
//
//				if(++nCount == nLineLength)	//30Pixel단위로 그리고 원래 Image 남겨두고를 반복
//				{
//					nCount = 0;
//					bLine = !bLine;
//				}
//			}
//		}
//	}
//}

//190214 최홍철 화살표 그리기
//No Overflow 위치에 화살표를 그려 peak point의 위치를 보여줌
//Side = Top일 때 호출되며, peak point의 Left 영역에 화살표를 그림
//Input
//  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
//  nImageWidth : Review Image Width.
//  nImageHeight : Review Image Height.
//  nChannel : Review Image Color Channel.
//  nImageWidthStep : Review Image Buffer Width Size(Width * Channel + margin)
//  boe_line : No overflow 판정된 DAM Line의 좌표 Array
//Output
//  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
void Reflow_Line_Paint_Vertical(BYTE *pImageBuffer, int nImageWidth, int nImageHeight, int nChannel, int nImageWidthStep, int *boe_line)
{
	if(pImageBuffer == NULL)
	{
		TRACE(_T("Reflow_Line_Paint_Vertical : Review Image Is Not Loaded\n"));
		return;
	}
	if(boe_line == NULL)
	{
		TRACE(_T("Reflow_Line_Paint_Vertical : Line Coordi Array Is Not Allocated\n"));
		return;
	}

	const int nSize = 30;
	BYTE pWhite[nSize * nSize];
	memset(pWhite, 0, nSize * nSize * sizeof(BYTE));

	for(int i = 0; i < nSize / 2; i++)
	{
		for(int j = nSize / 4; j < nSize * 3 / 4; j++)
		{
			pWhite[j * nSize + i] = 255;
		}
	}
	for(int i = nSize / 2; i < nSize; i++)
	{
		for(int j = (i - nSize / 2); j < (nSize * 3 / 2 - i); j++)
		{
			pWhite[j * nSize + i] = 255;
		}
	}

	CRect rectArrow(0, -nSize / 2, nSize, nSize / 2);
	CRect rectImage(0, 0, nImageWidth, nImageHeight);

	for(int n = 0; n < 4; n++)
	{
		int nY = boe_line[n];
		if(nY <= 0) continue;	//Overflow인 Line인 경우 Skip
		CRect rectArrow2 = rectArrow;
		rectArrow2.OffsetRect(0, nY);
		CRect rectArrow3;
		rectArrow3.IntersectRect(rectArrow2, rectImage);
		int nXOffset = rectArrow2.Width() - rectArrow3.Width();
		int nYOffset = rectArrow2.Height() - rectArrow3.Height();
		for(int i = rectArrow3.top; i < rectArrow3.bottom; i++)	//30Pixel단위로 그리고 원래 Image 남겨두고를 반복
		{
			for(int j = rectArrow3.left; j < rectArrow3.right; j++)
			{
				BYTE temp = pWhite[(i - rectArrow3.top + nYOffset) * nSize + (j - rectArrow3.left + nXOffset)];
				if(temp > 0)
				{
					*(pImageBuffer + i * nImageWidthStep + j * nChannel) = temp;
					for(int k = 1; k < nChannel; k++)
					{
						*(pImageBuffer + i * nImageWidthStep + j * nChannel + k) = 0;
					}
				}
			}
		}
	}
}

//No Overflow 위치에 화살표를 그려 peak point의 위치를 보여줌
//Side = Left, Right일 때 호출되며, peak point의 Top 영역에 화살표를 그림
//Input
//  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
//  nImageWidth : Review Image Width.
//  nImageHeight : Review Image Height.
//  nChannel : Review Image Color Channel.
//  nImageWidthStep : Review Image Buffer Width Size(Width * Channel + margin)
//  boe_line : No overflow 판정된 DAM Line의 좌표 Array
//Output
//  pImageBuffer : Review Image(Color Image). reflowParam으로 전달 받은 image에 바로 그림
void Reflow_Line_Paint_Horizontal(BYTE *pImageBuffer, int nImageWidth, int nImageHeight, int nChannel, int nImageWidthStep, int *boe_line)
{
	if(pImageBuffer == NULL)
	{
		TRACE(_T("Reflow_Line_Paint_Vertical : Review Image Is Not Loaded\n"));
		return;
	}
	if(boe_line == NULL)
	{
		TRACE(_T("Reflow_Line_Paint_Vertical : Line Coordi Array Is Not Allocated\n"));
		return;
	}

	const int nSize = 30;
	BYTE pWhite[nSize * nSize];
	memset(pWhite, 0, nSize * nSize * sizeof(BYTE));

	for(int i = 0; i < nSize / 2; i++)
	{
		for(int j = nSize / 4; j < nSize * 3 / 4; j++)
		{
			pWhite[i * nSize + j] = 255;
		}
	}
	for(int i = nSize / 2; i < nSize; i++)
	{
		for(int j = (i - nSize / 2); j < (nSize * 3 / 2 - i); j++)
		{
			pWhite[i * nSize + j] = 255;
		}
	}

	CRect rectArrow(-nSize / 2, 0, nSize / 2, nSize);
	CRect rectImage(0, 0, nImageWidth, nImageHeight);

	for(int j = 0; j < 4; j++)
	{
		int nX = boe_line[j];
		if(nX <= 0) continue;	//Overflow인 Line인 경우 Skip
		CRect rectArrow2 = rectArrow;
		rectArrow2.OffsetRect(nX, 0);
		CRect rectArrow3;
		rectArrow3.IntersectRect(rectArrow2, rectImage);
		int nXOffset = rectArrow2.Width() - rectArrow3.Width();
		int nYOffset = rectArrow2.Height() - rectArrow3.Height();
		for(int i = rectArrow3.top; i < rectArrow3.bottom; i++)	//30Pixel단위로 그리고 원래 Image 남겨두고를 반복
		{
			for(int j = rectArrow3.left; j < rectArrow3.right; j++)
			{
				BYTE temp = pWhite[(i - rectArrow3.top + nYOffset) * nSize + (j - rectArrow3.left + nXOffset)];
				if(temp > 0)
				{
					*(pImageBuffer + i * nImageWidthStep + j * nChannel) = temp;
					for(int k = 1; k < nChannel; k++)
					{
						*(pImageBuffer + i * nImageWidthStep + j * nChannel + k) = 0;
					}
				}
			}
		}
	}
}

//Review Program에서 실제로 호출하는 Method
//DAM Line을 분석해서 overflow 여부를 check하는 메소드
//Input
//  rParam : reflow 검사를 수행하기 위한 parameter. Image, threshold, ROI 등이 포함
//  bSetMaster : Master Image가 Setting되었는지 여부 T/F. 제거할 필요가 있음
//Output
//  boe_line : no overflow 판정된 line의 좌표 정보. int[4] 크기가 필요함
//int Linecheck_Method(int* boe_line, reflowParam* rParam, BOOL bSetMaster)
//{
//	m_nLineCheckerLocalPeakPeriod=rParam->nPeakPeriod;
//
//#ifdef SAVE_PROJECTION_VALUE
//	CString temp(PROJECTION_DIR);
//	CreateDirectory(temp, NULL);
//#endif
//	int ret = 0;
//
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method : Line Coordi Array Is Not Allocated\n"));
//		return REFLOW_RESULT_OUTPUT_ARRAY_ERROR;
//	}
//	if(rParam == NULL)
//	{
//		TRACE(_T("Linecheck_Method : Reflow Parameter Is Not Allocated\n"));
//		return REFLOW_RESULT_REFLOWPARAM_SETTING_ERROR;
//	}
//
//	if(!CheckSetting(rParam))
//	{
//		TRACE(_T("Linecheck_Method : Reflow Parameter Is Invalid\n"));
//		return REFLOW_RESULT_REFLOWPARAM_SETTING_ERROR;
//	}
//	if(!bSetMaster)
//	{
//		TRACE(_T("Linecheck_Method : Master Setting Is Invalid\n"));
//		return REFLOW_RESULT_MATCHING_ERROR;
//	}
//	if(rParam->ROI_Rect->left < 0) rParam->ROI_Rect->left = 0;
//	if(rParam->ROI_Rect->right > rParam->nImageWidth - 1) rParam->ROI_Rect->right = rParam->nImageWidth - 1;
//	if(rParam->ROI_Rect->top < 0) rParam->ROI_Rect->top = 0;
//	if(rParam->ROI_Rect->bottom > rParam->nImageHeight - 1) rParam->ROI_Rect->bottom = rParam->nImageHeight - 1;
//
//
//	BYTE *pImage = NULL;	//Review Image Gray 변환
//	pImage = new BYTE[rParam->nImageWidth * rParam->nImageHeight];
//	memset(pImage, 0, sizeof(BYTE)*rParam->nImageWidth * rParam->nImageHeight);
//	if(-1 == RGB2GRAY(pImage, rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep)) 
//	{
//		if(pImage)
//		{
//			delete [] pImage;
//			pImage = NULL;
//		}
//		TRACE(_T("Linecheck_Method : RB2GRAY(Review Image) Fail\n"));
//		return REFLOW_RESULT_IMAGE_LOAD_ERROR;
//	}
//
//	BOOL bMatch = FALSE;
//
//	BYTE *pMaster = NULL;	//Master Image Gray 변환
//	pMaster = new BYTE[rParam->nMasterWidth * rParam->nMasterHeight];
//	memset(pMaster, 0, sizeof(BYTE)*rParam->nMasterWidth * rParam->nMasterHeight);
//	if(-1 == RGB2GRAY(pMaster, rParam->pMasterBuffer, rParam->nMasterWidth, rParam->nMasterHeight, rParam->nMasterChannel, rParam->nMasterWidthStep)) 
//	{
//		if(pImage)
//		{
//			delete [] pImage;
//			pImage = NULL;
//		}
//		if(pMaster)
//		{
//			delete [] pMaster;
//			pMaster = NULL;
//		}
//		TRACE(_T("Linecheck_Method : RB2GRAY(Master Image) Fail\n"));
//		return REFLOW_RESULT_IMAGE_LOAD_ERROR;
//	}
//
//	switch(rParam->nSide)	//Matching을 통한 ROI 영역 설정
//	{
//	case CS_TOP :
//		bMatch = Match_Vertical(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
//		break;
//	case CS_LEFT :
//	case CS_RIGHT :
//		bMatch = Match_Horizontal(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
//		break;
//	}
//
//	if(!bMatch)
//	{
//		//switch(rParam->nSide)
//		//{
//		//case CS_TOP :
//		//	bMatch = SecondMatch_Vertical(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
//		//	break;
//		//case CS_LEFT :
//		//case CS_RIGHT :
//		//	bMatch = SecondMatch_Horizontal(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
//		//	break;
//		//}
//		//if(!bMatch)
//		//{
//			if(pImage)
//			{
//				delete [] pImage;
//				pImage = NULL;
//			}
//			if(pMaster)
//			{
//				delete [] pMaster;
//				pMaster = NULL;
//			}
//			TRACE(_T("Linecheck_Method : Matching Fail\n"));
//			return REFLOW_RESULT_MATCHING_ERROR;
//		//}
//	}
//
//	switch(rParam->nSide)//Review Image의 ROI 내에서 DAM을 탐색하여 overflow 여부 판정
//	{
//	case CS_TOP :
//		ret = Linecheck_Method_Side0(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nDamTh2, rParam->nDamTh2_in, rParam->nDamTh1, rParam->nDamTh1_in, rParam->nDistance);
//		for(int i = 0; i < 4; i++)//ROI Start 좌표를 원점으로 좌표를 계산하기 때문에 ROI Start 좌표를 가산해줌
//		{
//			if(boe_line[i] != 0)
//			{
//				boe_line[i] += rParam->ROI_Rect->top;
//			}
//		}
//		Reflow_Line_Paint_Vertical(rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep, boe_line);
//		break;
//	case CS_LEFT :
//		ret = Linecheck_Method_Side1(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nDamTh2, rParam->nDamTh2_in, rParam->nDamTh1, rParam->nDamTh1_in, rParam->nDistance);
//		for(int i = 0; i < 4; i++)
//		{
//			if(boe_line[i] != 0)
//			{
//				boe_line[i] += rParam->ROI_Rect->left;
//			}
//		}
//		Reflow_Line_Paint_Horizontal(rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep, boe_line);
//		break;
//	case CS_RIGHT :
//		ret = Linecheck_Method_Side2(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nDamTh2, rParam->nDamTh2_in, rParam->nDamTh1, rParam->nDamTh1_in, rParam->nDistance);
//		for(int i = 0; i < 4; i++)
//		{
//			if(boe_line[i] != 0)
//			{
//				boe_line[i] += rParam->ROI_Rect->left;
//			}
//		}
//		Reflow_Line_Paint_Horizontal(rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep, boe_line);
//		break;
//	default :
//		ret = REFLOW_RESULT_REFLOWPARAM_SETTING_ERROR; // Select Wrong Side 
//	}
//
//	if(pImage)
//	{
//		delete [] pImage;
//		pImage = NULL;
//	}
//	if(pMaster)
//	{
//		delete [] pMaster;
//		pMaster = NULL;
//	}


//	return 0;
//}

#define BTOS(x) (x ? "TRUE" : "")

int Linecheck_Method_Side0(int* boe_line, BYTE* pImage, int nImageWidth, int nImageHeight, CRect* ROI_Rect, int thDam2, int thDam2_2, int thDam1, int thDam1_2, int *nDistance,reflowResult* result)
{

	if(boe_line == NULL)
	{
		TRACE(_T("Linecheck_Method_Side0 : Line Coordi Array Is Not Allocated\n"));
		return REFLOW_RESULT_OUTPUT_ARRAY_ERROR;
	}
	if((nImageWidth == 0 && nImageHeight == 0) || pImage == NULL)
	{
		TRACE(_T("Linecheck_Method_Side0 : Review Image Is Not Loaded\n"));
		return REFLOW_RESULT_IMAGE_LOAD_ERROR;
	}
	if(ROI_Rect == NULL || ROI_Rect->IsRectEmpty())
	{
		TRACE(_T("Linecheck_Method_Side0 : ROI Rect Is Not Allocated\n"));
		return REFLOW_RESULT_ROI_SETTING_ERROR;
	}
	if(nDistance == NULL)
	{
		TRACE(_T("Linecheck_Method_Side0 : DAM Position Array Is Not Allocated\n"));
		return REFLOW_RESULT_DAM_SETTING_ERROR;
	}

	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
	if(ROI_Rect->right > nImageWidth - 1) ROI_Rect->right = nImageWidth - 1;
	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
	if(ROI_Rect->bottom > nImageHeight - 1) ROI_Rect->bottom = nImageHeight - 1;

	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return REFLOW_RESULT_ROI_SETTING_ERROR; // roi setting error

	int nMax = 0;
	for(int i = 0; i < 4; i++)
	{
		if(nMax < *(nDistance + i))
			nMax = *(nDistance + i);
	}

	if(ROI_Rect->Height() < nMax) return REFLOW_RESULT_DAM_SETTING_ERROR; // roi length error

	int width;
	int *pProjection = NULL;
	int sumOfImage = 0;
	double avgOfImage = 0;
	int nGrayDiff[4] = {0, };
	BOOL bLineComp[3] = {FALSE, };

	width = ROI_Rect->bottom - ROI_Rect->top + 1;
	pProjection = new int[width + 1];

	int state = 0;
	int temp_sum = 0;
	//int th = 10;
	int line_check = 0;
	bool opposite = false;

	memset(boe_line, 0, 4*sizeof(int));

	for(int i = ROI_Rect->top; i <= ROI_Rect->bottom; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
	{
		int sum = 0;
		for(int j = ROI_Rect->left; j <= ROI_Rect->right; j++)
		{
			sum += *(pImage + j + nImageWidth * i);
		}
		pProjection[i - ROI_Rect->top] = sum / (ROI_Rect->right - ROI_Rect->left + 1);
		sumOfImage += sum;
	}

	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
	int thNormalizeDam2 = thDam2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam2_2 = thDam2_2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam1 = thDam1 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam1_2 = thDam1_2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산

	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
	char s[1024];
	sprintf_s(s, 1023, "%s\\(Side0)Difference.txt", PROJECTION_DIR);
	BOOL bOpen = FALSE;

#ifdef SAVE_PROJECTION_VALUE
	bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
#endif

	if(bOpen)
	{
		f.SeekToEnd();
		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
		f.Write(s, (UINT)strlen(s));
	}

	for(int i = 0; i < 4; i++)
	{
		int pos;
#pragma region normalize factor
		int nMin = LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - nMin;
		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
		if(bOpen)
		{
			f.Write(s, (UINT)strlen(s));
		}
#pragma endregion
		int nmMin,nmMax;

		if(i == 0)
		{


			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDam2_GrayMax =nmMax;
			result->nDam2_GrayMin =nmMin;
			


			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod * 2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod * 2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
			
			result->nDam2_GrayDif = nNormalizeDiff;
			 result->nDam2_GrayTH =thNormalizeDam2;

			//nNormalizeDiff *= 128 / avgOfImage;
			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam2 / 2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam2 = TRUE;
			}

		}
		else if(i == 1)
		{
			//nGrayDiff[i] =  LocalMaxima(pProjection, *(nDistance + i), width, LOCAL_PEAK_PERIOD * 2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, LOCAL_PEAK_PERIOD * 2);
			//if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalizeDam2_2, TRUE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
			//{
			//	boe_line[i] = pos;
			//	line_check++;
			//}

			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);


			result->nDam2_in_GrayMax =nmMax;
			result->nDam2_in_GrayMin =nmMin;

			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam2_in_GrayDif = nNormalizeDiff;
			result->nDam2_in_GrayTH =thNormalizeDam2_2;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam2_2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam2_in = TRUE;
			}
		}
		else if(i == 2)
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			
			result->nDAM1_GrayMax = nmMax;
			result->nDAM1_GrayMin = nmMin ;

			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;


	result->nDam1_GrayDif = nNormalizeDiff;
	result->nDam1_GrayTH =thNormalizeDam1;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam1)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDAM1 = TRUE;
			}
		}
		else
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
		
			
			result->nDam1_in_GrayMax= nmMax;
			result->nDam1_in_GrayMin= nmMin;


			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam1_in_GrayDif = nNormalizeDiff;
			result->nDam1_in_GrayTH =thNormalizeDam1_2;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam1_2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam1_in = TRUE;
			}
		}
	}

	//안쪽 Line 검출 여부를 활용하여 바깥쪽 Line 검출 정보 보정
#ifdef LINE_COMPENSATION
	for(int i = 3; i > 0; i--)
	{
		if(boe_line[i] > 0 && boe_line[i - 1] == 0)
		{
			bLineComp[i - 1] = TRUE;
			int nPos = 0;
			LocalMinima(pProjection, &nPos, *(nDistance + i - 1), width, m_nLineCheckerLocalPeakPeriod);
			boe_line[i - 1] = nPos;
			line_check++;
		}
	}
#else
	//if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
	//{
	//	boe_line[1] = *(nDistance + 1);
	//	line_check++;
	//}
#endif

	sprintf_s(s, 1023, "\r\n");
	if(bOpen)
	{
		f.Write(s, (UINT)strlen(s));
		f.Close();
	}

#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
	CFile file;
	char str[1024];
	sprintf_s(str, 1023, "%s\\Horizontal_Projection_from(%d, %d)_to(%d, %d).csv", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);

	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
	{
		sprintf_s(str, 1023, "Left,%d,Right,%d,Top,%d,Bottom,%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
		file.Write(str, (UINT)strlen(str));

		switch(line_check)
		{
		case 4 :
			sprintf_s(str, 1023, "NoReflow\r\n%d,%d,%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top, boe_line[3] + ROI_Rect->top);
			break;
		case 3 :
			sprintf_s(str, 1023, "DAM1Reflow\r\n%d,%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top);
			break;
		case 2 :
			sprintf_s(str, 1023, "DAM1Reflow\r\n%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top);
			break;
		default :
			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->top);
		}
		file.Write(str, (UINT)strlen(str));

		sprintf_s(str, 1023, "Normalized Threshold,%3d,%3d,%3d,%3d\r\n", thNormalizeDam2, thNormalizeDam2_2, thNormalizeDam1, thNormalizeDam1_2);
		file.Write(str, (UINT)strlen(str));
		sprintf_s(str, 1023, "Gray Difference,%3d,%3d,%3d,%3d\r\n", nGrayDiff[0], nGrayDiff[1], nGrayDiff[2], nGrayDiff[3]);
		file.Write(str, (UINT)strlen(str));
		sprintf_s(str, 1023, "Line Compensation,%s,%s,%s\r\n", BTOS(bLineComp[0]), BTOS(bLineComp[1]), BTOS(bLineComp[2]));
		file.Write(str, (UINT)strlen(str));

		sprintf_s(str, 1023, "Horizontal Projection,difference\r\n");
		file.Write(str, (UINT)strlen(str));

		for(int i = 0; i < width; i++)
		{
			sprintf_s(str, 1023, "%d,%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
			file.Write(str, (UINT)strlen(str));
		}

		file.Close();
	}
#endif

	if(pProjection)
	{
		delete [] pProjection;
		pProjection = NULL;
	}

	return line_check;
}

int Linecheck_Method_Side1(int* boe_line, BYTE* pImage, int nImageWidth, int nImageHeight, CRect* ROI_Rect, int thDam2, int thDam2_2, int thDam1, int thDam1_2, int *nDistance,reflowResult* result)
{
	if(boe_line == NULL)
	{
		TRACE(_T("Linecheck_Method_Side1 : Line Coordi Array Is Not Allocated\n"));
		return REFLOW_RESULT_OUTPUT_ARRAY_ERROR;
	}
	if((nImageWidth == 0 && nImageHeight == 0) || pImage == NULL)
	{
		TRACE(_T("Linecheck_Method_Side1 : Review Image Is Not Loaded\n"));
		return REFLOW_RESULT_IMAGE_LOAD_ERROR;
	}
	if(ROI_Rect == NULL || ROI_Rect->IsRectEmpty())
	{
		TRACE(_T("Linecheck_Method_Side1 : ROI Rect Is Not Allocated\n"));
		return REFLOW_RESULT_ROI_SETTING_ERROR;
	}
	if(nDistance == NULL)
	{
		TRACE(_T("Linecheck_Method_Side1 : DAM Position Array Is Not Allocated\n"));
		return REFLOW_RESULT_DAM_SETTING_ERROR;
	}


	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
	if(ROI_Rect->right > nImageWidth - 1) ROI_Rect->right = nImageWidth - 1;
	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
	if(ROI_Rect->bottom > nImageHeight - 1) ROI_Rect->bottom = nImageHeight - 1;

	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return REFLOW_RESULT_ROI_SETTING_ERROR; // roi setting error

	int nMax = 0;
	for(int i = 0; i < 4; i++)
	{
		if(nMax < *(nDistance + i))
			nMax = *(nDistance + i);
	}

	if(ROI_Rect->Width() < nMax) return REFLOW_RESULT_DAM_SETTING_ERROR; // roi length error

	int width;
	int *pProjection = NULL;
	int sumOfImage = 0;
	double avgOfImage = 0;
	int nGrayDiff[4] = {0, };
	BOOL bLineComp[3] = {FALSE, };

	width = ROI_Rect->right - ROI_Rect->left + 1;
	pProjection = new int[width + 1];

	int state = 0;
	int temp_sum = 0;
	//int th = 10;
	int line_check = 0;
	bool opposite = false;

	memset(boe_line, 0, 4*sizeof(int));

	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
	{
		int sum = 0;
		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
		{
			sum += *(pImage + j * nImageWidth + i);
		}
		pProjection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
		sumOfImage += sum;
	}

	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
	int thNormalizeDam2 = thDam2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam2_2 = thDam2_2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam1 = thDam1 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam1_2 = thDam1_2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산

	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
	char s[1024];
	sprintf_s(s, 1023, "%s\\(Side1)Difference.txt", PROJECTION_DIR);
	BOOL bOpen = FALSE;

#ifdef SAVE_PROJECTION_VALUE
	bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
#endif

	if(bOpen)
	{
		f.SeekToEnd();
		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
		f.Write(s, (UINT)strlen(s));
	}

	for(int i = 0; i < 4; i++)
	{
		int pos;
#pragma region normalize factor
		int nMin = LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - nMin;
		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
		if(bOpen)
		{
			f.Write(s, (UINT)strlen(s));
		}
#pragma endregion
		int nmMax,nmMin;
		if(i == 0)
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDam2_GrayMax = nmMax;
			result->nDam2_GrayMin = nmMin;



			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam2_GrayDif = nNormalizeDiff;
			result->nDam2_GrayTH =thNormalizeDam2;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam2 / 2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam2 = TRUE;
			}
		}
		else if(i == 1)
		{
			//nGrayDiff[i] =  LocalMaxima(pProjection, *(nDistance + i), width, LOCAL_PEAK_PERIOD * 2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, LOCAL_PEAK_PERIOD * 2);
			//if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalizeDam2_2, TRUE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
			//{
			//	boe_line[i] = pos;
			//	line_check++;
			//}
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDam2_in_GrayMax = nmMax;
			result->nDam2_in_GrayMin = nmMin;

			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam2_in_GrayDif = nNormalizeDiff;
			result->nDam2_in_GrayTH =thNormalizeDam2_2;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam2_2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam2_in= TRUE;
			}
		}

		else if(i == 2)
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			
			result->nDAM1_GrayMax = nmMax;
			result->nDAM1_GrayMin = nmMin ;


			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam1_GrayDif = nNormalizeDiff;
			result->nDam1_GrayTH =thNormalizeDam1;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam1)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDAM1= TRUE;
			}
		}
		else
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			
			result->nDam1_in_GrayMax= nmMax;
			result->nDam1_in_GrayMin= nmMin;

			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow

			result->nDam1_in_GrayDif = nNormalizeDiff;
			result->nDam1_in_GrayTH =thNormalizeDam1_2;

			//nNormalizeDiff *= 128 / avgOfImage;
			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam1_2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam1_in = TRUE;
			}
		}
	}
	//안쪽 Line 검출 여부를 활용하여 바깥쪽 Line 검출 정보 보정
#ifdef LINE_COMPENSATION
	for(int i = 3; i > 0; i--)
	{
		if(boe_line[i] > 0 && boe_line[i - 1] == 0)
		{
			bLineComp[i - 1] = TRUE;
			int nPos = 0;
			LocalMinima(pProjection, &nPos, *(nDistance + i - 1), width, m_nLineCheckerLocalPeakPeriod);
			boe_line[i - 1] = nPos;
			line_check++;
		}
	}
#else
	//if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
	//{
	//	boe_line[1] = *(nDistance + 1);
	//	line_check++;
	//}
#endif

	sprintf_s(s, 1023, "\r\n");
	if(bOpen)
	{
		f.Write(s, (UINT)strlen(s));
		f.Close();
	}

#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
	CFile file;
	char str[1024];
	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).csv", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);

	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
	{
		sprintf_s(str, 1023, "Left,%d,Right,%d,Top,%d,Bottom,%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
		file.Write(str, (UINT)strlen(str));

		switch(line_check)
		{
		case 4 :
			sprintf_s(str, 1023, "NoReflow\r\n%d,%d,%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
			break;
		case 3 :
			sprintf_s(str, 1023, "DAM1Reflow\r\n%d,%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
			break;
		case 2 :
			sprintf_s(str, 1023, "DAM1Reflow\r\n%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left);
			break;
		default :
			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->left);
		}
		file.Write(str, (UINT)strlen(str));

		sprintf_s(str, 1023, "Normalized Threshold,%3d,%3d,%3d,%3d\r\n", thNormalizeDam2, thNormalizeDam2_2, thNormalizeDam1, thNormalizeDam1_2);
		file.Write(str, (UINT)strlen(str));
		sprintf_s(str, 1023, "Gray Difference,%3d,%3d,%3d,%3d\r\n", nGrayDiff[0], nGrayDiff[1], nGrayDiff[2], nGrayDiff[3]);
		file.Write(str, (UINT)strlen(str));
		sprintf_s(str, 1023, "Line Compensation,%s,%s,%s\r\n", BTOS(bLineComp[0]), BTOS(bLineComp[1]), BTOS(bLineComp[2]));
		file.Write(str, (UINT)strlen(str));

		sprintf_s(str, 1023, "Vertical Projection,difference,lpf\r\n");
		file.Write(str, (UINT)strlen(str));

		for(int i = 0; i < width; i++)
		{
			sprintf_s(str, 1023, "%d,%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
			file.Write(str, (UINT)strlen(str));
		}

		file.Close();
	}
#endif

	if(pProjection)
	{
		delete [] pProjection;
		pProjection = NULL;
	}

	return line_check;
}

int Linecheck_Method_Side2(int* boe_line, BYTE* pImage, int nImageWidth, int nImageHeight, CRect* ROI_Rect, int thDam2, int thDam2_2, int thDam1, int thDam1_2, int *nDistance,reflowResult* result)
{
	if(boe_line == NULL)
	{
		TRACE(_T("Linecheck_Method_Side2 : Line Coordi Array Is Not Allocated\n"));
		return REFLOW_RESULT_OUTPUT_ARRAY_ERROR;
	}
	if((nImageWidth == 0 && nImageHeight == 0) || pImage == NULL)
	{
		TRACE(_T("Linecheck_Method_Side2 : Review Image Is Not Loaded\n"));
		return REFLOW_RESULT_IMAGE_LOAD_ERROR;
	}
	if(ROI_Rect == NULL || ROI_Rect->IsRectEmpty())
	{
		TRACE(_T("Linecheck_Method_Side2 : ROI Rect Is Not Allocated\n"));
		return REFLOW_RESULT_ROI_SETTING_ERROR;
	}
	if(nDistance == NULL)
	{
		TRACE(_T("Linecheck_Method_Side2 : DAM Position Array Is Not Allocated\n"));
		return REFLOW_RESULT_DAM_SETTING_ERROR;
	}


	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
	if(ROI_Rect->right > nImageWidth - 1) ROI_Rect->right = nImageWidth - 1;
	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
	if(ROI_Rect->bottom > nImageHeight - 1) ROI_Rect->bottom = nImageHeight - 1;

	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return REFLOW_RESULT_ROI_SETTING_ERROR; // roi setting error

	int nMax = 0;
	for(int i = 0; i < 4; i++)
	{
		if(nMax < *(nDistance + i))
			nMax = *(nDistance + i);
	}

	if(ROI_Rect->Width() < nMax) return REFLOW_RESULT_DAM_SETTING_ERROR; // roi length error

	int width;
	int *pProjection = NULL;
	int sumOfImage = 0;
	double avgOfImage = 0;
	int nGrayDiff[4] = {0, };
	BOOL bLineComp[3] = {FALSE, };

	width = ROI_Rect->right - ROI_Rect->left + 1;
	pProjection = new int[width + 1];

	int state = 0;
	int temp_sum = 0;
	//int th = 10;
	int line_check = 0;
	bool opposite = false;

	memset(boe_line, 0, 4*sizeof(int));

	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
	{
		int sum = 0;
		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
		{
			sum += *(pImage + j * nImageWidth + i);
		}
		pProjection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
		sumOfImage += sum;
	}

	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
	int thNormalizeDam2 = thDam2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam2_2 = thDam2_2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam1 = thDam1 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산
	int thNormalizeDam1_2 = thDam1_2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized nThreshold 계산

	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
	char s[1024];
	sprintf_s(s, 1023, "%s\\(Side2)Difference.txt", PROJECTION_DIR);

	BOOL bOpen = FALSE;

#ifdef SAVE_PROJECTION_VALUE
	bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
#endif

	if(bOpen)
	{
		f.SeekToEnd();
		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
		f.Write(s, (UINT)strlen(s));
	}

	for(int i = 0; i < 4; i++)
	{
		int pos;
#pragma region normalize factor
		int nMin = LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - nMin;
		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
		if(bOpen)
		{
			f.Write(s, (UINT)strlen(s));
		}
#pragma endregion

		int nmMax,nmMin;

		if(i == 0)
		{

			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDam2_GrayMax = nmMax;
			result->nDam2_GrayMin = nmMin;

			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam2_GrayDif = nNormalizeDiff;
			result->nDam2_GrayTH =thNormalizeDam2;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam2 / 2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam2 = TRUE;
			}
		}
		else if(i == 1)
		{
			//nGrayDiff[i] =  LocalMaxima(pProjection, *(nDistance + i), width, LOCAL_PEAK_PERIOD * 2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, LOCAL_PEAK_PERIOD * 2);
			//if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalizeDam2_2, FALSE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
			//{
			//	boe_line[i] = pos;
			//	line_check++;
			//}
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDam2_in_GrayMax = nmMax;
			result->nDam2_in_GrayMin = nmMin;

			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam2_in_GrayDif = nNormalizeDiff;
			result->nDam2_in_GrayTH =thNormalizeDam2_2;


			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam2_2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam2_in= TRUE;
			}
		}
		else if(i == 2)
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDAM1_GrayMax = nmMax;
			result->nDAM1_GrayMin = nmMin ;

			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam1_GrayDif = nNormalizeDiff;
			result->nDam1_GrayTH =thNormalizeDam1;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam1)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDAM1 = TRUE;
			}
		}
		else
		{
			nmMax = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);
			nmMin =LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);

			result->nDam1_in_GrayMax= nmMax;
			result->nDam1_in_GrayMin= nmMin;


			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod);	//DAM1. LocalMaxima - LocalMinima가 Normalized nThreshold보다 큰 경우 no overflow
			//nNormalizeDiff *= 128 / avgOfImage;

			result->nDam1_in_GrayDif = nNormalizeDiff;
			result->nDam1_in_GrayTH =thNormalizeDam1_2;

			nGrayDiff[i] = nNormalizeDiff;
			if(nNormalizeDiff > thNormalizeDam1_2)
			{
				boe_line[i] = pos;
				line_check++;
				result->nDam1_in = TRUE;
			}
		}
	}

	//안쪽 Line 검출 여부를 활용하여 바깥쪽 Line 검출 정보 보정
#ifdef LINE_COMPENSATION
	for(int i = 3; i > 0; i--)
	{
		if(boe_line[i] > 0 && boe_line[i - 1] == 0)
		{
			bLineComp[i - 1] = TRUE;
			int nPos = 0;
			LocalMinima(pProjection, &nPos, *(nDistance + i - 1), width, m_nLineCheckerLocalPeakPeriod);
			boe_line[i - 1] = nPos;
			line_check++;
		}
	}
#else
	//if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
	//{
	//	boe_line[1] = *(nDistance + 1);
	//	line_check++;
	//}
#endif

	sprintf_s(s, 1023, "\r\n");
	if(bOpen)
	{
		f.Write(s, (UINT)strlen(s));
		f.Close();
	}

#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
	CFile file;
	char str[1024];
	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).csv", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);

	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
	{
		sprintf_s(str, 1023, "Left,%d,Right,%d,Top,%d,Bottom,%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
		file.Write(str, (UINT)strlen(str));

		switch(line_check)
		{
		case 4 :
			sprintf_s(str, 1023, "NoReflow\r\n%d,%d,%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
			break;
		case 3 :
			sprintf_s(str, 1023, "DAM1Reflow\r\n%d,%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
			break;
		case 2 :
			sprintf_s(str, 1023, "DAM1Reflow\r\n%d,%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left);
			break;
		default :
			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->left);
		}
		file.Write(str, (UINT)strlen(str));

		sprintf_s(str, 1023, "Normalized Threshold,%3d,%3d,%3d,%3d\r\n", thNormalizeDam2, thNormalizeDam2_2, thNormalizeDam1, thNormalizeDam1_2);
		file.Write(str, (UINT)strlen(str));
		sprintf_s(str, 1023, "Gray Difference,%3d,%3d,%3d,%3d\r\n", nGrayDiff[0], nGrayDiff[1], nGrayDiff[2], nGrayDiff[3]);
		file.Write(str, (UINT)strlen(str));
		sprintf_s(str, 1023, "Line Compensation,%s,%s,%s\r\n", BTOS(bLineComp[0]), BTOS(bLineComp[1]), BTOS(bLineComp[2]));
		file.Write(str, (UINT)strlen(str));

		sprintf_s(str, 1023, "Vertical Projection,difference,lpf\r\n");
		file.Write(str, (UINT)strlen(str));

		for(int i = 0; i < width; i++)
		{
			sprintf_s(str, 1023, "%d,%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
			file.Write(str, (UINT)strlen(str));
		}

		file.Close();	
	}
#endif

	if(pProjection)
	{
		delete [] pProjection;
		pProjection = NULL;
	}

	return line_check;
}



















//
//
//int Linecheck_Method_Side0(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int th, int *nDistance)
//{
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side0 : Line Coordi Array Is Not Allocated\n"));
//		return -5;
//	}
//	if((imageWidth == 0 && imageHeight == 0) || pImage == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side0 : Review Image Is Not Loaded\n"));
//		return -1;
//	}
//
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	int nMax = max(*(nDistance + 0), max(*(nDistance + 1), max(*(nDistance + 2), *(nDistance + 3))));
//
//	if(ROI_Rect->Height() < nMax) return -3; // roi length error
//
//	int width;
//	int *pProjection = NULL;
//	int sumOfImage = 0;
//	double avgOfImage = 0;
//
//	width = ROI_Rect->bottom - ROI_Rect->top + 1;
//	pProjection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//
//	memset(boe_line, 0, 4*sizeof(int));
//
//	for(int i = ROI_Rect->top; i <= ROI_Rect->bottom; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->left; j <= ROI_Rect->right; j++)
//		{
//			sum += *(pImage + j + imageWidth * i);
//		}
//		pProjection[i - ROI_Rect->top] = sum / (ROI_Rect->right - ROI_Rect->left + 1);
//		sumOfImage += sum;
//	}
//
//	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
//	int thNormalize = th * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//
//	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
//	char s[1024];
//	sprintf_s(s, 1023, "%s\\(Side0)Difference.txt", PROJECTION_DIR);
//	BOOL bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
//	if(bOpen)
//	{
//		f.SeekToEnd();
//		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
//		f.Write(s, (UINT)strlen(s));
//	}
//
//	for(int i = 0; i < 4; i++)
//	{
//#pragma region normalize factor
//		int nMin = LocalMinima(pProjection, *(nDistance + i), width);
//		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width) - nMin;
//		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
//		if(bOpen)
//		{
//			f.Write(s, (UINT)strlen(s));
//		}
//#pragma endregion
//		int pos;
//
//		if(i == 0)
//		{
//			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod * 2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod * 2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalize / 2)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < thNormalize)	//DAM2 바깥 Line. Line의 너비가 넓어 LocalMaxima를 찾을 수 없어 LocalMinima(Peak Low)를 단순 Gray로 비교
//			//{
//			//	boe_line[i] = pos;
//			//	line_check++;
//			//}
//		}
//		else if(i == 1)
//		{
//			if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalize, TRUE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//		}
//		else 
//		{
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width) - LocalMinima(pProjection, &pos, *(nDistance + i), width);	//DAM1. LocalMaxima - LocalMinima가 Normalized Threshold보다 큰 경우 no overflow
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalize)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < th2)
//			//{
//			//	//boe_line[line_check++] = *(nDistance + i);
//			//	//boe_line[line_check++] = pos;
//			//	boe_line[i] = pos;
//			//	//line_check++;
//			//	line_check |= (int)pow((double)2, i);
//			//}
//		}
//	}
//
//	if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
//	{
//		boe_line[1] = *(nDistance + 1);
//		line_check++;
//	}
//
//	sprintf_s(s, 1023, "\r\n");
//	if(bOpen)
//	{
//		f.Write(s, (UINT)strlen(s));
//		f.Close();
//	}
//
//#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Horizontal_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
//	{
//		sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//		file.Write(str, (UINT)strlen(str));
//
//		switch(line_check)
//		{
//		case 4 :
//			sprintf_s(str, 1023, "NoReflow\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top, boe_line[3] + ROI_Rect->top);
//			break;
//		case 3 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top);
//			break;
//		case 2 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top);
//			break;
//		default :
//			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->top);
//		}
//		file.Write(str, (UINT)strlen(str));
//
//		sprintf_s(str, 1023, "Horizontal Projection\tdifference\r\n");
//		file.Write(str, (UINT)strlen(str));
//
//		for(int i = 0; i < width; i++)
//		{
//			sprintf_s(str, 1023, "%d\t%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
//			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
//			file.Write(str, (UINT)strlen(str));
//		}
//
//		file.Close();
//	}
//#endif
//
//	if(pProjection)
//	{
//		delete [] pProjection;
//		pProjection = NULL;
//	}
//
//	return line_check;
//}
//
//int Linecheck_Method_Side1(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int th, int *nDistance)
//{
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side1 : Line Coordi Array Is Not Allocated\n"));
//		return -5;
//	}
//	if((imageWidth == 0 && imageHeight == 0) || pImage == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side1 : Review Image Is Not Loaded\n"));
//		return -1;
//	}
//
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	int nMax = max(*(nDistance + 0), max(*(nDistance + 1), max(*(nDistance + 2), *(nDistance + 3))));
//
//	if(ROI_Rect->Width() < nMax) return -3; // roi length error
//
//	int width;
//	int *pProjection = NULL;
//	int sumOfImage = 0;
//	double avgOfImage = 0;
//
//	width = ROI_Rect->right - ROI_Rect->left + 1;
//	pProjection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//
//	memset(boe_line, 0, 4*sizeof(int));
//
//	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
//		{
//			sum += *(pImage + j * imageWidth + i);
//		}
//		pProjection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
//		sumOfImage += sum;
//	}
//
//	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
//	int thNormalize = th * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//
//	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
//	char s[1024];
//	sprintf_s(s, 1023, "%s\\(Side1)Difference.txt", PROJECTION_DIR);
//	BOOL bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
//	if(bOpen)
//	{
//		f.SeekToEnd();
//		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
//		f.Write(s, (UINT)strlen(s));
//	}
//
//	for(int i = 0; i < 4; i++)
//	{
//#pragma region normalize factor
//		int nMin = LocalMinima(pProjection, *(nDistance + i), width);
//		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width) - nMin;
//		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
//		if(bOpen)
//		{
//			f.Write(s, (UINT)strlen(s));
//		}
//#pragma endregion
//		int pos;
//
//		if(i == 0)
//		{
//			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalize / 2)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < thNormalize)	//DAM2 바깥 Line. Line의 너비가 넓어 LocalMaxima를 찾을 수 없어 LocalMinima(Peak Low)를 단순 Gray로 비교
//			//{
//			//	boe_line[i] = pos;
//			//	line_check++;
//			//}
//		}
//		else if(i == 1)
//		{
//			if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalize, TRUE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//		}
//		else 
//		{
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width) - LocalMinima(pProjection, &pos, *(nDistance + i), width);	//DAM1. LocalMaxima - LocalMinima가 Normalized Threshold보다 큰 경우 no overflow
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalize)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < th2)
//			//{
//			//	//boe_line[line_check++] = *(nDistance + i);
//			//	//boe_line[line_check++] = pos;
//			//	boe_line[i] = pos;
//			//	//line_check++;
//			//	line_check |= (int)pow((double)2, i);
//			//}
//		}
//	}
//
//	if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
//	{
//		boe_line[1] = *(nDistance + 1);
//		line_check++;
//	}
//
//	sprintf_s(s, 1023, "\r\n");
//	if(bOpen)
//	{
//		f.Write(s, (UINT)strlen(s));
//		f.Close();
//	}
//
//#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
//	{
//		sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//		file.Write(str, (UINT)strlen(str));
//
//		switch(line_check)
//		{
//		case 4 :
//			sprintf_s(str, 1023, "NoReflow\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
//			break;
//		case 3 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
//			break;
//		case 2 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left);
//			break;
//		default :
//			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->left);
//		}
//		file.Write(str, (UINT)strlen(str));
//
//		sprintf_s(str, 1023, "Vertical Projection\tdifference\tlpf\r\n");
//		file.Write(str, (UINT)strlen(str));
//
//		for(int i = 0; i < width; i++)
//		{
//			sprintf_s(str, 1023, "%d\t%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
//			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
//			file.Write(str, (UINT)strlen(str));
//		}
//
//		file.Close();
//	}
//#endif
//
//	if(pProjection)
//	{
//		delete [] pProjection;
//		pProjection = NULL;
//	}
//
//	return line_check;
//}

//int Linecheck_Method_Side2(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int th, int *nDistance)
//{
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side2 : Line Coordi Array Is Not Allocated\n"));
//		return -5;
//	}
//	if((imageWidth == 0 && imageHeight == 0) || pImage == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side2 : Review Image Is Not Loaded\n"));
//		return -1;
//	}
//
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	int nMax = max(*(nDistance + 0), max(*(nDistance + 1), max(*(nDistance + 2), *(nDistance + 3))));
//
//	if(ROI_Rect->Width() < nMax) return -3; // roi length error
//
//	int width;
//	int *pProjection = NULL;
//	int sumOfImage = 0;
//	double avgOfImage = 0;
//
//	width = ROI_Rect->right - ROI_Rect->left + 1;
//	pProjection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//
//	memset(boe_line, 0, 4*sizeof(int));
//
//	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
//		{
//			sum += *(pImage + j * imageWidth + i);
//		}
//		pProjection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
//		sumOfImage += sum;
//	}
//
//	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
//	int thNormalize = th * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//
//	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
//	char s[1024];
//	sprintf_s(s, 1023, "%s\\(Side2)Difference.txt", PROJECTION_DIR);
//
//	BOOL bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
//	if(bOpen)
//	{
//		f.SeekToEnd();
//		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
//		f.Write(s, (UINT)strlen(s));
//	}
//
//	for(int i = 0; i < 4; i++)
//	{
//#pragma region normalize factor
//		int nMin = LocalMinima(pProjection, *(nDistance + i), width);
//		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width) - nMin;
//		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
//		if(bOpen)
//		{
//			f.Write(s, (UINT)strlen(s));
//		}
//#pragma endregion
//		int pos;
//
//		if(i == 0)
//		{
//			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalize / 2)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < thNormalize)	//DAM2 바깥 Line. Line의 너비가 넓어 LocalMaxima를 찾을 수 없어 LocalMinima(Peak Low)를 단순 Gray로 비교
//			//{
//			//	boe_line[i] = pos;
//			//	line_check++;
//			//}
//		}
//		else if(i == 1)
//		{
//			if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalize, FALSE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//		}
//		else 
//		{
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width) - LocalMinima(pProjection, &pos, *(nDistance + i), width);	//DAM1. LocalMaxima - LocalMinima가 Normalized Threshold보다 큰 경우 no overflow
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalize)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < th2)
//			//{
//			//	//boe_line[line_check++] = *(nDistance + i);
//			//	//boe_line[line_check++] = pos;
//			//	boe_line[i] = pos;
//			//	//line_check++;
//			//	line_check |= (int)pow((double)2, i);
//			//}
//		}
//	}
//
//	if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
//	{
//		boe_line[1] = *(nDistance + 1);
//		line_check++;
//	}
//
//	sprintf_s(s, 1023, "\r\n");
//	if(bOpen)
//	{
//		f.Write(s, (UINT)strlen(s));
//		f.Close();
//	}
//
//#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
//	{
//		sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//		file.Write(str, (UINT)strlen(str));
//
//		switch(line_check)
//		{
//		case 4 :
//			sprintf_s(str, 1023, "NoReflow\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
//			break;
//		case 3 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
//			break;
//		case 2 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left);
//			break;
//		default :
//			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->left);
//		}
//		file.Write(str, (UINT)strlen(str));
//
//		sprintf_s(str, 1023, "Vertical Projection\tdifference\tlpf\r\n");
//		file.Write(str, (UINT)strlen(str));
//
//		for(int i = 0; i < width; i++)
//		{
//			sprintf_s(str, 1023, "%d\t%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
//			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
//			file.Write(str, (UINT)strlen(str));
//		}
//
//		file.Close();	
//	}
//#endif
//
//	if(pProjection)
//	{
//		delete [] pProjection;
//		pProjection = NULL;
//	}
//
//	return line_check;
//}


//
//int Linecheck_Method_Side0(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int thDam2, int thDam1, int *nDistance,reflowResult* result)
//{
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side0 : Line Coordi Array Is Not Allocated\n"));
//		return -5;
//	}
//	if((imageWidth == 0 && imageHeight == 0) || pImage == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side0 : Review Image Is Not Loaded\n"));
//		return -1;
//	}
//
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	int nMax = max(*(nDistance + 0), max(*(nDistance + 1), max(*(nDistance + 2), *(nDistance + 3))));
//
//	if(ROI_Rect->Height() < nMax) return -3; // roi length error
//
//	int width;
//	int *pProjection = NULL;
//	int sumOfImage = 0;
//	double avgOfImage = 0;
//
//	width = ROI_Rect->bottom - ROI_Rect->top + 1;
//	pProjection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//
//	memset(boe_line, 0, 4*sizeof(int));
//
//	for(int i = ROI_Rect->top; i <= ROI_Rect->bottom; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->left; j <= ROI_Rect->right; j++)
//		{
//			sum += *(pImage + j + imageWidth * i);
//		}
//		pProjection[i - ROI_Rect->top] = sum / (ROI_Rect->right - ROI_Rect->left + 1);
//		sumOfImage += sum;
//	}
//
//	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
//	int thNormalizeDam2 = thDam2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//	int thNormalizeDam1 = thDam1 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//
//	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
//	char s[1024];
//	sprintf_s(s, 1023, "%s\\(Side0)Difference.txt", PROJECTION_DIR);
//	BOOL bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
//	if(bOpen)
//	{
//		f.SeekToEnd();
//		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
//		f.Write(s, (UINT)strlen(s));
//	}
//
//	for(int i = 0; i < 4; i++)
//	{
//#pragma region normalize factor
//		int nMin = LocalMinima(pProjection, *(nDistance + i), width);
//		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width) - nMin;
//		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
//		if(bOpen)
//		{
//			f.Write(s, (UINT)strlen(s));
//		}
//#pragma endregion
//		int pos;
//
//		if(i == 0)
//		{
//			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod * 2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod * 2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalizeDam2 / 2)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < thNormalize)	//DAM2 바깥 Line. Line의 너비가 넓어 LocalMaxima를 찾을 수 없어 LocalMinima(Peak Low)를 단순 Gray로 비교
//			//{
//			//	boe_line[i] = pos;
//			//	line_check++;
//			//}
//		}
//		else if(i == 1)
//		{
//			if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalizeDam2, TRUE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//		}
//		else 
//		{
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width) - LocalMinima(pProjection, &pos, *(nDistance + i), width);	//DAM1. LocalMaxima - LocalMinima가 Normalized Threshold보다 큰 경우 no overflow
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalizeDam1)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < th2)
//			//{
//			//	//boe_line[line_check++] = *(nDistance + i);
//			//	//boe_line[line_check++] = pos;
//			//	boe_line[i] = pos;
//			//	//line_check++;
//			//	line_check |= (int)pow((double)2, i);
//			//}
//		}
//	}
//
//	if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
//	{
//		boe_line[1] = *(nDistance + 1);
//		line_check++;
//	}
//
//	sprintf_s(s, 1023, "\r\n");
//	if(bOpen)
//	{
//		f.Write(s, (UINT)strlen(s));
//		f.Close();
//	}
//
//#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Horizontal_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
//	{
//		sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//		file.Write(str, (UINT)strlen(str));
//
//		switch(line_check)
//		{
//		case 4 :
//			sprintf_s(str, 1023, "NoReflow\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top, boe_line[3] + ROI_Rect->top);
//			break;
//		case 3 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top);
//			break;
//		case 2 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top);
//			break;
//		default :
//			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->top);
//		}
//		file.Write(str, (UINT)strlen(str));
//
//		sprintf_s(str, 1023, "Horizontal Projection\tdifference\r\n");
//		file.Write(str, (UINT)strlen(str));
//
//		for(int i = 0; i < width; i++)
//		{
//			sprintf_s(str, 1023, "%d\t%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
//			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
//			file.Write(str, (UINT)strlen(str));
//		}
//
//		file.Close();
//	}
//#endif
//
//	if(pProjection)
//	{
//		delete [] pProjection;
//		pProjection = NULL;
//	}
//
//	return line_check;
//}
//
//int Linecheck_Method_Side1(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int thDam2, int thDam1, int *nDistance)
//{
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side1 : Line Coordi Array Is Not Allocated\n"));
//		return -5;
//	}
//	if((imageWidth == 0 && imageHeight == 0) || pImage == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side1 : Review Image Is Not Loaded\n"));
//		return -1;
//	}
//
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	int nMax = max(*(nDistance + 0), max(*(nDistance + 1), max(*(nDistance + 2), *(nDistance + 3))));
//
//	if(ROI_Rect->Width() < nMax) return -3; // roi length error
//
//	int width;
//	int *pProjection = NULL;
//	int sumOfImage = 0;
//	double avgOfImage = 0;
//
//	width = ROI_Rect->right - ROI_Rect->left + 1;
//	pProjection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//
//	memset(boe_line, 0, 4*sizeof(int));
//
//	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
//		{
//			sum += *(pImage + j * imageWidth + i);
//		}
//		pProjection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
//		sumOfImage += sum;
//	}
//
//	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
//	int thNormalizeDam2 = thDam2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//	int thNormalizeDam1 = thDam1 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//
//	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
//	char s[1024];
//	sprintf_s(s, 1023, "%s\\(Side1)Difference.txt", PROJECTION_DIR);
//	BOOL bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
//	if(bOpen)
//	{
//		f.SeekToEnd();
//		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
//		f.Write(s, (UINT)strlen(s));
//	}
//
//	for(int i = 0; i < 4; i++)
//	{
//#pragma region normalize factor
//		int nMin = LocalMinima(pProjection, *(nDistance + i), width);
//		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width) - nMin;
//		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
//		if(bOpen)
//		{
//			f.Write(s, (UINT)strlen(s));
//		}
//#pragma endregion
//		int pos;
//
//		if(i == 0)
//		{
//			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalizeDam2 / 2)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < thNormalize)	//DAM2 바깥 Line. Line의 너비가 넓어 LocalMaxima를 찾을 수 없어 LocalMinima(Peak Low)를 단순 Gray로 비교
//			//{
//			//	boe_line[i] = pos;
//			//	line_check++;
//			//}
//		}
//		else if(i == 1)
//		{
//			if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalizeDam2, TRUE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//		}
//		else 
//		{
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width) - LocalMinima(pProjection, &pos, *(nDistance + i), width);	//DAM1. LocalMaxima - LocalMinima가 Normalized Threshold보다 큰 경우 no overflow
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalizeDam1)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < th2)
//			//{
//			//	//boe_line[line_check++] = *(nDistance + i);
//			//	//boe_line[line_check++] = pos;
//			//	boe_line[i] = pos;
//			//	//line_check++;
//			//	line_check |= (int)pow((double)2, i);
//			//}
//		}
//	}
//
//	if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
//	{
//		boe_line[1] = *(nDistance + 1);
//		line_check++;
//	}
//
//	sprintf_s(s, 1023, "\r\n");
//	if(bOpen)
//	{
//		f.Write(s, (UINT)strlen(s));
//		f.Close();
//	}
//
//#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
//	{
//		sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//		file.Write(str, (UINT)strlen(str));
//
//		switch(line_check)
//		{
//		case 4 :
//			sprintf_s(str, 1023, "NoReflow\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
//			break;
//		case 3 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
//			break;
//		case 2 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left);
//			break;
//		default :
//			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->left);
//		}
//		file.Write(str, (UINT)strlen(str));
//
//		sprintf_s(str, 1023, "Vertical Projection\tdifference\tlpf\r\n");
//		file.Write(str, (UINT)strlen(str));
//
//		for(int i = 0; i < width; i++)
//		{
//			sprintf_s(str, 1023, "%d\t%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
//			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
//			file.Write(str, (UINT)strlen(str));
//		}
//
//		file.Close();
//	}
//#endif
//
//	if(pProjection)
//	{
//		delete [] pProjection;
//		pProjection = NULL;
//	}
//
//	return line_check;
//}
//
//int Linecheck_Method_Side2(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int thDam2, int thDam1, int *nDistance)
//{
//	if(boe_line == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side2 : Line Coordi Array Is Not Allocated\n"));
//		return -5;
//	}
//	if((imageWidth == 0 && imageHeight == 0) || pImage == NULL)
//	{
//		TRACE(_T("Linecheck_Method_Side2 : Review Image Is Not Loaded\n"));
//		return -1;
//	}
//
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	int nMax = max(*(nDistance + 0), max(*(nDistance + 1), max(*(nDistance + 2), *(nDistance + 3))));
//
//	if(ROI_Rect->Width() < nMax) return -3; // roi length error
//
//	int width;
//	int *pProjection = NULL;
//	int sumOfImage = 0;
//	double avgOfImage = 0;
//
//	width = ROI_Rect->right - ROI_Rect->left + 1;
//	pProjection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//
//	memset(boe_line, 0, 4*sizeof(int));
//
//	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)	//Projection Graph 계산 및 Image 전체 밝기 계산
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
//		{
//			sum += *(pImage + j * imageWidth + i);
//		}
//		pProjection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
//		sumOfImage += sum;
//	}
//
//	avgOfImage = (double)sumOfImage / (ROI_Rect->Width() * ROI_Rect->Height());
//	int thNormalizeDam2 = thDam2 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//	int thNormalizeDam1 = thDam1 * avgOfImage / 128 + 0.5;	//Image 전체 밝기를 이용하여 Normalized Threshold 계산
//
//	CFile f;	//Image 전체 밝기와 DAM 위치(Peak Point)의 Minimum 값, Maximum과의 차를 text로 저장
//	char s[1024];
//	sprintf_s(s, 1023, "%s\\(Side2)Difference.txt", PROJECTION_DIR);
//
//	BOOL bOpen = f.Open(CString(s), CFile::modeCreate | CFile::modeNoTruncate | CFile::modeWrite);
//	if(bOpen)
//	{
//		f.SeekToEnd();
//		sprintf_s(s, 1023, "%.5lf\t", avgOfImage);
//		f.Write(s, (UINT)strlen(s));
//	}
//
//	for(int i = 0; i < 4; i++)
//	{
//#pragma region normalize factor
//		int nMin = LocalMinima(pProjection, *(nDistance + i), width);
//		int nDiff = LocalMaxima(pProjection, *(nDistance + i), width) - nMin;
//		sprintf_s(s, 1023, "%d\t%d\t", nMin, nDiff);
//		if(bOpen)
//		{
//			f.Write(s, (UINT)strlen(s));
//		}
//#pragma endregion
//		int pos;
//
//		if(i == 0)
//		{
//			//190104 최홍철 단순 Gray 비교 → 탐색 범위 증가시여 Diff 비교 변경
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2) - LocalMinima(pProjection, &pos, *(nDistance + i), width, m_nLineCheckerLocalPeakPeriod*2);	//DAM2 바깥 Line. Line의 너비가 넓어 탐색 범위를 2배로 넓힘
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalizeDam2 / 2)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < thNormalize)	//DAM2 바깥 Line. Line의 너비가 넓어 LocalMaxima를 찾을 수 없어 LocalMinima(Peak Low)를 단순 Gray로 비교
//			//{
//			//	boe_line[i] = pos;
//			//	line_check++;
//			//}
//		}
//		else if(i == 1)
//		{
//			if(CheckTwoLines(pProjection, *(nDistance + i), width, thNormalizeDam2, FALSE, &pos))	//DAM2 안쪽 Line. overflow와 no overflow의 차이인 line 개수를 분석함
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//		}
//		else 
//		{
//			int nNormalizeDiff = LocalMaxima(pProjection, *(nDistance + i), width) - LocalMinima(pProjection, &pos, *(nDistance + i), width);	//DAM1. LocalMaxima - LocalMinima가 Normalized Threshold보다 큰 경우 no overflow
//			//nNormalizeDiff *= 128 / avgOfImage;
//			if(nNormalizeDiff > thNormalizeDam1)
//			{
//				boe_line[i] = pos;
//				line_check++;
//			}
//			//if(LocalMinima(pProjection, &pos, *(nDistance + i), width) < th2)
//			//{
//			//	//boe_line[line_check++] = *(nDistance + i);
//			//	//boe_line[line_check++] = pos;
//			//	boe_line[i] = pos;
//			//	//line_check++;
//			//	line_check |= (int)pow((double)2, i);
//			//}
//		}
//	}
//
//	if(boe_line[1] == 0 && boe_line[2] > 0)		//Focus 문제로 DAM2의 안쪽 Line이 검출되지 않았을 때 DAM1 바깥쪽 Line 검출 여부를 활용하여 보정
//	{
//		boe_line[1] = *(nDistance + 1);
//		line_check++;
//	}
//
//	sprintf_s(s, 1023, "\r\n");
//	if(bOpen)
//	{
//		f.Write(s, (UINT)strlen(s));
//		f.Close();
//	}
//
//#ifdef SAVE_PROJECTION_VALUE	//Reflow 판정, no overflow line 좌표, Projection Graph 등을 text로 출력
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))
//	{
//		sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//		file.Write(str, (UINT)strlen(str));
//
//		switch(line_check)
//		{
//		case 4 :
//			sprintf_s(str, 1023, "NoReflow\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
//			break;
//		case 3 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
//			break;
//		case 2 :
//			sprintf_s(str, 1023, "DAM1Reflow\r\n%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left);
//			break;
//		default :
//			sprintf_s(str, 1023, "DAM2Reflow\r\n%d\r\n\r\n", boe_line[0] + ROI_Rect->left);
//		}
//		file.Write(str, (UINT)strlen(str));
//
//		sprintf_s(str, 1023, "Vertical Projection\tdifference\tlpf\r\n");
//		file.Write(str, (UINT)strlen(str));
//
//		for(int i = 0; i < width; i++)
//		{
//			sprintf_s(str, 1023, "%d\t%d\r\n", pProjection[i], pProjection[(i + 1) % width] - pProjection[i % width]);
//			//sprintf_s(str, 1023, "%d%d\r\n", i, pProjection[i]);
//			file.Write(str, (UINT)strlen(str));
//		}
//
//		file.Close();	
//	}
//#endif
//
//	if(pProjection)
//	{
//		delete [] pProjection;
//		pProjection = NULL;
//	}
//
//	return line_check;
//}






//현재 알고리즘에서 비사용중인 메소드들

BYTE LocalMinima(int *pProjection, int x, int width)
{
	int i = x - m_nLineCheckerLocalPeakPeriod / 2 ;
	if(i < 0)
		i = 0;
	BYTE local_minima = *(pProjection + i);
	for(; i < x + m_nLineCheckerLocalPeakPeriod / 2; i++)
	{
		if(i > width - 1) break;
		if(local_minima > *(pProjection + i))
			local_minima = *(pProjection + i);
	}

	return local_minima;
}

int LocalMinimaAddr(int *pProjection, int x, int width)
{
	int i = x - m_nLineCheckerLocalPeakPeriod / 2 ;
	if(i < 0)
		i = 0;
	BYTE local_minima = *(pProjection + i);
	int local_minima_addr = i;
	for(; i < x + m_nLineCheckerLocalPeakPeriod / 2; i++)
	{
		if(i > width - 1) break;
		if(local_minima > *(pProjection + i))
		{
			local_minima = *(pProjection + i);
			local_minima_addr = i;
		}
	}

	return local_minima_addr;
}

BOOL CheckTwoLines(int *pDifference_lpf, int *pProjection, int x, int width, int threshold, BOOL bForward)
{
	int i;
	int nSearchEnd;
	if(bForward)
	{
		//i = x - LOCAL_PEAK_PERIOD / 2;
		//nSearchEnd = x + LOCAL_PEAK_PERIOD * 9 / 2;
		i = x - m_nLineCheckerLocalPeakPeriod * 5 / 2;
		nSearchEnd = x + m_nLineCheckerLocalPeakPeriod * 5 / 2;
	}
	else
	{
		//i = x + LOCAL_PEAK_PERIOD / 2;
		//nSearchEnd = x - LOCAL_PEAK_PERIOD * 9 / 2;
		i = x + m_nLineCheckerLocalPeakPeriod * 5 / 2;
		nSearchEnd = x - m_nLineCheckerLocalPeakPeriod * 5 / 2;
	}
	if(i < 0) i = 0;
	if(nSearchEnd < 0) nSearchEnd = 0;
	if(i > width - 1) i = width - 1; 
	if(nSearchEnd > width - 1) nSearchEnd = width - 1; 
	int nPeakCount = 0;

	if(bForward)
	{
		BOOL bIncreaseSlope = (*(pDifference_lpf + i) >= 0);
		i++;
		for(; i < nSearchEnd; i++)
		{
			//if(!(bIncreaseSlope & (*(pDifference_lpf + i) >= 0)))
			if(bIncreaseSlope ^ (*(pDifference_lpf + i) >= 0))
			{
				if(*(pProjection + i) < threshold)
					nPeakCount++;
				bIncreaseSlope = !bIncreaseSlope;
			}
		}
	}
	else
	{
		BOOL bIncreaseSlope = (*(pDifference_lpf + i) >= 0);
		i--;
		for(; i >= nSearchEnd; i--)
		{
			//if(!(bIncreaseSlope & (*(pDifference_lpf + i) >= 0)))
			if(bIncreaseSlope ^ (*(pDifference_lpf + i) >= 0))
			{
				if(*(pProjection + i) < threshold)
					nPeakCount++;
				bIncreaseSlope = !bIncreaseSlope;
			}
		}
	}
	if(nPeakCount >= 2)
	{
		return TRUE;
	}
	return FALSE;
}

CString Reflow_Judge(int LineCheck)
{
	CString ret;
	switch(LineCheck)
	{
	case 4 :
		ret.Format(_T("no Reflow"));
		break;
	case 3 :
	case 2 :
		ret.Format(_T("DAM#1 Reflow"));
		break;
	case -1 :
		ret.Format(_T("Image Load Error"));
		break;
	case -2 :
		ret.Format(_T("ROI Setting Error"));
		break;
	case -3 :
		ret.Format(_T("ROI Length Error"));
		break;
	case -4 :
		ret.Format(_T("Image Match Fail"));
		break;
	case -5:
		ret.Format(_T("Debug File Error"));
		break;
	default :
		ret.Format(_T("DAM#2 Reflow"));
		;
	}

	return ret;
}
//
//int BOE_Linecheck(int* boe_line, reflowParam* rParam, BOOL bSetMaster)
//{
//#ifdef SAVE_PROJECTION_VALUE
//	CString temp(PROJECTION_DIR);
//	CreateDirectory(temp, NULL);
//#endif
//	int ret = 0;
//
//	if(rParam->ROI_Rect->left < 0) rParam->ROI_Rect->left = 0;
//	if(rParam->ROI_Rect->right > rParam->nImageWidth - 1) rParam->ROI_Rect->right = rParam->nImageWidth - 1;
//	if(rParam->ROI_Rect->top < 0) rParam->ROI_Rect->top = 0;
//	if(rParam->ROI_Rect->bottom > rParam->nImageHeight - 1) rParam->ROI_Rect->bottom = rParam->nImageHeight - 1;
//
//	BYTE *pImage = new BYTE[rParam->nImageWidth * rParam->nImageHeight];
//	memset(pImage, 0, sizeof(BYTE)*rParam->nImageWidth * rParam->nImageHeight);
//	if(-1 == RGB2GRAY(pImage, rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep)) 
//	{
//		delete pImage;
//		pImage = NULL;
//		return -1;
//	}
//
//	CRect *rtMatch = new CRect;
//	BOOL bMatch = FALSE;
//	BYTE *pMaster = NULL;
//	if(bSetMaster)
//	{
//		pMaster = new BYTE[rParam->nMasterWidth * rParam->nMasterHeight];
//		memset(pMaster, 0, sizeof(BYTE)*rParam->nMasterWidth * rParam->nMasterHeight);
//		if(-1 == RGB2GRAY(pMaster, rParam->pMasterBuffer, rParam->nMasterWidth, rParam->nMasterHeight, rParam->nMasterChannel, rParam->nMasterWidthStep)) 
//		{
//			delete pMaster;
//			pMaster = NULL;
//			return -1;
//		}
//
//		switch(rParam->nSide)
//		{
//		case CS_TOP :
//			bMatch = Match_Vertical(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
//			break;
//		case CS_LEFT :
//		case CS_RIGHT :
//			bMatch = Match_Horizontal(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
//			break;
//		}
//	}
//	if(!bMatch)
//	{
//		*rtMatch = *rParam->ROI_Rect;
//	}
//
//	switch(rParam->nSide)
//	{
//	case CS_TOP :
//		ret = BOE_Linecheck_Side0(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nBaseTh, rParam->nDamTh2, rParam->nDamTh1, rParam->nBaseline, rParam->nBaseDam2, rParam->nDam2Dist, rParam->nDam12Dist, rParam->nDam1Dist);
//		for(int i = 0; i < ret; i++)
//		{
//			boe_line[i] += rParam->ROI_Rect->top;
//		}
//		break;
//	case CS_LEFT :
//		ret = BOE_Linecheck_Side1(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nBaseTh, rParam->nDamTh2, rParam->nDamTh1, rParam->nBaseline, rParam->nBaseDam2, rParam->nDam2Dist, rParam->nDam12Dist, rParam->nDam1Dist);
//		for(int i = 0; i < ret; i++)
//		{
//			boe_line[i] += rParam->ROI_Rect->left;
//		}
//		break;
//	case CS_RIGHT :
//		ret = BOE_Linecheck_Side2(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nBaseTh, rParam->nDamTh2, rParam->nDamTh1, rParam->nBaseline, rParam->nBaseDam2, rParam->nDam2Dist, rParam->nDam12Dist, rParam->nDam1Dist);
//		for(int i = 0; i < ret; i++)
//		{
//			boe_line[i] += rParam->ROI_Rect->left;
//		}
//		break;
//	default :
//		ret = -5; // Select Wrong Side 
//	}
//
//	if(pImage)
//		delete pImage;
//	pImage = NULL;
//	if(pMaster)
//		delete pMaster;
//	pMaster = NULL;
//	if(rtMatch)
//		delete rtMatch;
//	rtMatch = NULL;
//	return ret;
//}
//
//int BOE_Linecheck_Side0(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int th, int th2, int th3, int dist0, int dist1, int dist2, int dist3, int dist4)
//{
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(imageWidth == 0 && imageHeight == 0) return -1; // image not loaded
//	if(pImage == NULL) return -1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	if(ROI_Rect->Height() < dist0 + dist1 + dist2 + dist3 + dist4) return -3; // roi length error
//
//	int width;
//	int *projection;
//
//	width = ROI_Rect->bottom - ROI_Rect->top + 1;
//	projection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//	int *difference_lpf = new int[width - 2];
//
//	memset(boe_line, 0, 6*sizeof(int));
//	memset(difference_lpf, 0, (width-2)*sizeof(int));
//
//	for(int i = ROI_Rect->top; i <= ROI_Rect->bottom; i++)
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->left; j <= ROI_Rect->right; j++)
//		{
//			sum += *(pImage + j + imageWidth * i);
//		}
//		projection[i - ROI_Rect->top] = sum / (ROI_Rect->right - ROI_Rect->left + 1);
//
//		if(i - ROI_Rect->top - 3 >= 0)
//			difference_lpf[i - ROI_Rect->top - 3] = (projection[i - ROI_Rect->top] - projection[i - ROI_Rect->top - 3]) / 3;
//	}
//
//	for(int i = 0; i < width - 3; i++)
//	{
//		//difference_lpf[i] = (projection[i + 3] - projection[i]) / 3;
//
//		if(line_check > 5) continue;
//		else if(line_check < 2)
//		{
//			if(difference_lpf[i] > 0) 
//			{
//				state++;
//				if(state > 5) state = 5;
//				opposite = false;
//			}
//			else if(difference_lpf[i] < 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//		else if(line_check == 2)
//		{
//			if(difference_lpf[i] < 0) 
//			{
//				state++;
//				if(state > 10) state = 10;
//				opposite = false;
//			}
//			else if(difference_lpf[i] > 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//		else
//		{
//			if(difference_lpf[i] < 0) 
//			{
//				state++;
//				if(state > 5) state = 5;
//				opposite = false;
//			}	
//			else if(difference_lpf[i] > 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//
//		if(state < 0)
//		{
//			state = 0;
//			switch(line_check)
//			{
//			case 0 :
//				if(temp_sum > th)
//				{
//					boe_line[line_check++] = i;
//					//180510 BaseLine Count = 1
//					if(dist0 == 0)
//						boe_line[line_check++] = i;
//				}
//				break;
//			case 1 :
//				if(temp_sum > th && (abs(i - boe_line[line_check - 1]) >= dist0 - 15) && (abs(i - boe_line[line_check - 1]) <= dist0 + 15))
//					boe_line[line_check++] = i;
//				else if(temp_sum > th)
//					boe_line[line_check - 1] = i;
//				break;
//			case 2 :
//				if(-temp_sum > th && LocalMinima(projection, i, width) < th2 && (abs(i - boe_line[line_check - 1]) >= dist1 - 15) && (abs(i - boe_line[line_check - 1]) <= dist1 + 15))
//					boe_line[line_check++] = i;
//				//else if(LocalMaxima(projection, i, width) - LocalMinima(projection, i, width) > th && (abs(i - boe_line[line_check - 1]) >= dist0 - 15) && (abs(i - boe_line[line_check - 1]) <= dist0 + 15))
//				//{
//				//	boe_line[line_check - 2] = boe_line[line_check - 1];
//				//	boe_line[line_check - 1] = LocalMinimaAddr(projection, i, width);
//				//}
//				//else if(LocalMaxima(projection, i, width) - LocalMinima(projection, i, width) > th)
//				//{
//				//	boe_line[line_check - 2] = LocalMinimaAddr(projection, i, width);
//				//	boe_line[line_check - 1] = 0;
//				//	line_check = 1;
//				//	//180510 BaseLine Count = 1
//				//	if(dist0 == 0)
//				//	{
//				//		line_check = 2;
//				//		boe_line[line_check - 1] = boe_line[line_check - 2];
//				//	}
//				//}
//				break;
//			case 3 :	//2 Lines...
//				if(LocalMinima(projection, i, width) < th2 && (abs(i - boe_line[line_check - 1]) >= dist2 - 15) && (abs(i - boe_line[line_check - 1])) <= dist2 + 15)
//				{
//					if(CheckTwoLines(difference_lpf, projection, i, width, th2, TRUE))
//						boe_line[line_check++] = i;
//				}
//				break;
//			case 4 :
//				if(LocalMinima(projection, i, width) < th3 && (abs(i - boe_line[line_check - 1]) >= dist3 - 15) && (abs(i - boe_line[line_check - 1]) <= dist3 + 15))
//					boe_line[line_check++] = i;
//				break;
//			case 5 :
//				if(LocalMinima(projection, i, width) < th3 && (abs(i - boe_line[line_check - 1]) >= dist4 - 15) && (abs(i - boe_line[line_check - 1]) <= dist4 + 15))
//					boe_line[line_check++] = i;
//				break;
//			default :
//				continue;
//			}
//			temp_sum = 0;
//		}
//		else 
//		{
//			if(!opposite) temp_sum += difference_lpf[i];
//		}
//	}
//
//#ifdef SAVE_PROJECTION_VALUE
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Horizontal_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(! file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))	return -1;
//
//	sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//	file.Write(str, (UINT)strlen(str));
//
//	switch(line_check)
//	{
//	case 6 :
//		sprintf_s(str, 1023, "A\r\n%d\t%d\t%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top, boe_line[3] + ROI_Rect->top, boe_line[4] + ROI_Rect->top, boe_line[5] + ROI_Rect->top);
//		break;
//	case 5 :
//		sprintf_s(str, 1023, "B\r\n%d\t%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top, boe_line[3] + ROI_Rect->top, boe_line[4] + ROI_Rect->top);
//		break;
//	case 4 :
//		sprintf_s(str, 1023, "C\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top, boe_line[3] + ROI_Rect->top);
//		break;
//	default :
//		sprintf_s(str, 1023, "D\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->top, boe_line[1] + ROI_Rect->top, boe_line[2] + ROI_Rect->top);
//	}
//	file.Write(str, (UINT)strlen(str));
//
//	sprintf_s(str, 1023, "Horizontal Projection\tdifference\tlpf\r\n");
//	file.Write(str, (UINT)strlen(str));
//
//	for(int i = 0; i < width; i++)
//	{
//		sprintf_s(str, 1023, "%d\t%d\t%d\r\n", projection[i], projection[(i + 1) % width] - projection[i % width], difference_lpf[i % (width - 2)]);
//		//sprintf_s(str, 1023, "%d%d\r\n", i, projection[i]);
//		file.Write(str, (UINT)strlen(str));
//	}
//
//	file.Close();	
//#endif
//
//	free(projection);
//	free(difference_lpf);
//
//	return line_check;
//}
//
//int BOE_Linecheck_Side1(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int th, int th2, int th3, int dist0, int dist1, int dist2, int dist3, int dist4)
//{
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(imageWidth == 0 && imageHeight == 0) return -1; // image not loaded
//	if(pImage == NULL) return -1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	if(ROI_Rect->Width() < dist0 + dist1 + dist2 + dist3 + dist4) return -3; // roi length error
//
//	int width;
//	int *projection;
//
//	width = ROI_Rect->right - ROI_Rect->left + 1;
//	projection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//	int *difference_lpf = new int[width - 2];
//
//	memset(boe_line, 0, 6*sizeof(int));
//	memset(difference_lpf, 0, (width-2)*sizeof(int));
//
//	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
//		{
//			sum += *(pImage + j * imageWidth + i);
//		}
//		projection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
//
//		if(i - ROI_Rect->left - 3 >= 0)
//			difference_lpf[i - ROI_Rect->left - 3] = (projection[i - ROI_Rect->left] - projection[i - ROI_Rect->left - 3]) / 3;
//	}	
//
//
//	for(int i = 0; i < width - 3; i++)
//	{
//		//difference_lpf[i] = (projection[i + 3] - projection[i]) / 3;
//
//		if(line_check > 5) continue;
//		else if(line_check < 2)
//		{
//			if(difference_lpf[i] > 0) 
//			{
//				state++;
//				if(state > 5) state = 5;
//				opposite = false;
//			}
//			else if(difference_lpf[i] < 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//		else if(line_check == 2)
//		{
//			if(difference_lpf[i] < 0) 
//			{
//				state++;
//				if(state > 10) state = 10;
//				opposite = false;
//			}
//			else if(difference_lpf[i] > 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//		else
//		{
//			if(difference_lpf[i] < 0) 
//			{
//				state++;
//				if(state > 5) state = 5;
//				opposite = false;
//			}	
//			else if(difference_lpf[i] > 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//
//		if(state < 0)
//		{
//			state = 0;
//			switch(line_check)
//			{
//			case 0 :
//				if(temp_sum > th)
//				{
//					boe_line[line_check++] = i;
//					//180510 BaseLine Count = 1
//					if(dist0 == 0)
//						boe_line[line_check++] = i;
//				}
//				break;
//			case 1 :
//				if(temp_sum > th && (abs(i - boe_line[line_check - 1]) >= dist0 - 15) && (abs(i - boe_line[line_check - 1]) <= dist0 + 15))
//					boe_line[line_check++] = i;
//				else if(temp_sum > th)
//					boe_line[line_check - 1] = i;
//				break;
//			case 2 :
//				if(-temp_sum > th && LocalMinima(projection, i, width) < th2 && (abs(i - boe_line[line_check - 1]) >= dist1 - 15) && (abs(i - boe_line[line_check - 1]) <= dist1 + 15))
//					boe_line[line_check++] = i;
//				//else if(LocalMaxima(projection, i, width) - LocalMinima(projection, i, width) > th && (abs(i - boe_line[line_check - 1]) >= dist0 - 15) && (abs(i - boe_line[line_check - 1]) <= dist0 + 15))
//				//{
//				//	boe_line[line_check - 2] = boe_line[line_check - 1];
//				//	boe_line[line_check - 1] = LocalMinimaAddr(projection, i, width);
//				//}
//				//else if(LocalMaxima(projection, i, width) - LocalMinima(projection, i, width) > th)
//				//{
//				//	boe_line[line_check - 2] = LocalMinimaAddr(projection, i, width);
//				//	boe_line[line_check - 1] = 0;
//				//	line_check = 1;
//				//	//180510 BaseLine Count = 1
//				//	if(dist0 == 0)
//				//	{
//				//		line_check = 2;
//				//		boe_line[line_check - 1] = boe_line[line_check - 2];
//				//	}
//				//}
//				break;
//			case 3 :
//				if(LocalMinima(projection, i, width) < th2 && (abs(i - boe_line[line_check - 1]) >= dist2 - 15) && (abs(i - boe_line[line_check - 1])) <= dist2 + 15)
//				{
//					if(CheckTwoLines(difference_lpf, projection, i, width, th2, TRUE))
//						boe_line[line_check++] = i;
//				}
//				break;
//			case 4 :
//				if(LocalMinima(projection, i, width) < th3 && (abs(i - boe_line[line_check - 1]) >= dist3 - 15) && (abs(i - boe_line[line_check - 1]) <= dist3 + 15))
//					boe_line[line_check++] = i;
//				break;
//			case 5 :
//				if(LocalMinima(projection, i, width) < th3 && (abs(i - boe_line[line_check - 1]) >= dist4 - 15) && (abs(i - boe_line[line_check - 1]) <= dist4 + 15))
//					boe_line[line_check++] = i;
//				break;
//			default :
//				continue;
//			}
//			temp_sum = 0;
//		}
//		else 
//		{
//			if(!opposite) temp_sum += difference_lpf[i];
//		}
//	}
//
//#ifdef SAVE_PROJECTION_VALUE
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(! file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))	return -1;
//
//	sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//	file.Write(str, (UINT)strlen(str));
//
//	switch(line_check)
//	{
//	case 6 :
//		sprintf_s(str, 1023, "A\r\n%d\t%d\t%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left, boe_line[4] + ROI_Rect->left, boe_line[5] + ROI_Rect->left);
//		break;
//	case 5 :
//		sprintf_s(str, 1023, "B\r\n%d\t%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left, boe_line[4] + ROI_Rect->left);
//		break;
//	case 4 :
//		sprintf_s(str, 1023, "C\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
//		break;
//	default :
//		sprintf_s(str, 1023, "D\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
//	}
//	file.Write(str, (UINT)strlen(str));
//
//	sprintf_s(str, 1023, "Vertical Projection\tdifference\tlpf\r\n");
//	file.Write(str, (UINT)strlen(str));
//
//	for(int i = 0; i < width; i++)
//	{
//		sprintf_s(str, 1023, "%d\t%d\t%d\r\n", projection[i], projection[(i + 1) % width] - projection[i % width], difference_lpf[i % (width - 2)]);
//		//sprintf_s(str, 1023, "%d%d\r\n", i, projection[i]);
//		file.Write(str, (UINT)strlen(str));
//	}
//
//	file.Close();	
//#endif
//
//	free(projection);
//	free(difference_lpf);
//
//	return line_check;
//}
//
//int BOE_Linecheck_Side2(int* boe_line, BYTE* pImage, int imageWidth, int imageHeight, CRect* ROI_Rect, int th, int th2, int th3, int dist0, int dist1, int dist2, int dist3, int dist4)
//{	
//	if(ROI_Rect->left < 0) ROI_Rect->left = 0;
//	if(ROI_Rect->right > imageWidth - 1) ROI_Rect->right = imageWidth - 1;
//	if(ROI_Rect->top < 0) ROI_Rect->top = 0;
//	if(ROI_Rect->bottom > imageHeight - 1) ROI_Rect->bottom = imageHeight - 1;
//
//	if(imageWidth == 0 && imageHeight == 0) return -1; // image not loaded
//	if(pImage == NULL) return -1;
//
//	if(ROI_Rect->right < ROI_Rect->left + 1 || ROI_Rect->bottom < ROI_Rect->top + 1) return -2; // roi setting error
//
//	if(ROI_Rect->Width() < dist0 + dist1 + dist2 + dist3 + dist4) return -3; // roi length error
//
//	int width;
//	int *projection;
//
//	width = ROI_Rect->right - ROI_Rect->left + 1;
//	projection = new int[width + 1];
//
//	int state = 0;
//	int temp_sum = 0;
//	//int th = 10;
//	int line_check = 0;
//	bool opposite = false;
//	int *difference_lpf = new int[width];
//
//	memset(boe_line, 0, 6*sizeof(int));
//	memset(difference_lpf, 0, (width-2)*sizeof(int));
//
//	for(int i = ROI_Rect->left; i <= ROI_Rect->right; i++)
//	{
//		int sum = 0;
//		for(int j = ROI_Rect->top; j <= ROI_Rect->bottom; j++)
//		{
//			sum += *(pImage + j * imageWidth + i);
//		}
//		projection[i - ROI_Rect->left] = sum / (ROI_Rect->bottom - ROI_Rect->top + 1);
//
//		if(i - ROI_Rect->left - 3 >= 0)
//			difference_lpf[i - ROI_Rect->left - 3] = (projection[i - ROI_Rect->left - 3] - projection[i - ROI_Rect->left]) / 3;
//	}	
//
//	for(int i = width - 1; i >= 3; i--)
//	{
//		//difference_lpf[i] = (projection[i - 3] - projection[i]) / 3;
//
//		if(line_check > 5) continue;
//		else if(line_check < 2)
//		{
//			if(difference_lpf[i] > 0) 
//			{
//				state++;
//				if(state > 5) state = 5;
//				opposite = false;
//			}
//			else if(difference_lpf[i] < 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//		else if(line_check == 2)
//		{
//			if(difference_lpf[i] < 0) 
//			{
//				state++;
//				if(state > 10) state = 10;
//				opposite = false;
//			}
//			else if(difference_lpf[i] > 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//		else
//		{
//			if(difference_lpf[i] < 0) 
//			{
//				state++;
//				if(state > 5) state = 5;
//				opposite = false;
//			}	
//			else if(difference_lpf[i] > 0)
//			{
//				state--;
//				opposite = true;
//			}
//			else
//			{
//				state--;
//				if(state < 0) state = 0;
//			}
//		}
//
//		if(state < 0)
//		{
//			state = 0;
//			switch(line_check)
//			{
//			case 0 :
//				if(temp_sum > th)
//				{
//					boe_line[line_check++] = i;
//					//180510 BaseLine Count = 1
//					if(dist0 == 0)
//						boe_line[line_check++] = i;
//				}
//				break;
//			case 1 :
//				if(temp_sum > th && (abs(i - boe_line[line_check - 1]) >= dist0 - 15) && (abs(i - boe_line[line_check - 1]) <= dist0 + 15))
//					boe_line[line_check++] = i;
//				else if(temp_sum > th)
//					boe_line[line_check - 1] = i;
//				break;
//			case 2 :
//				if(LocalMinima(projection, i, width) < th2 && (abs(i - boe_line[line_check - 1]) >= dist1 - 15) && (abs(i - boe_line[line_check - 1]) <= dist1 + 15))
//					boe_line[line_check++] = i;
//				//else if(LocalMaxima(projection, i, width) - LocalMinima(projection, i, width) > th && (abs(i - boe_line[line_check - 1]) >= dist0 - 15) && (abs(i - boe_line[line_check - 1]) <= dist0 + 15))
//				//{
//				//	boe_line[line_check - 2] = boe_line[line_check - 1];
//				//	boe_line[line_check - 1] = LocalMinimaAddr(projection, i, width);
//				//}
//				//else if(LocalMaxima(projection, i, width) - LocalMinima(projection, i, width) > th)
//				//{
//				//	boe_line[line_check - 2] = LocalMinimaAddr(projection, i, width);
//				//	boe_line[line_check - 1] = 0;
//				//	line_check = 1;
//				//	//180510 BaseLine Count = 1
//				//	if(dist0 == 0)
//				//	{
//				//		line_check = 2;
//				//		boe_line[line_check - 1] = boe_line[line_check - 2];
//				//	}
//				//}
//				break;
//			case 3 :
//				if(LocalMinima(projection, i, width) < th2 && (abs(i - boe_line[line_check - 1]) >= dist2 - 15) && (abs(i - boe_line[line_check - 1]) <= dist2 + 15))
//				{
//					if(CheckTwoLines(difference_lpf, projection, i, width, th2, FALSE))
//						boe_line[line_check++] = i;
//				}
//				break;
//			case 4 :
//				if(LocalMinima(projection, i, width) < th3 && (abs(i - boe_line[line_check - 1]) >= dist3 - 15) && (abs(i - boe_line[line_check - 1]) <= dist3 + 15))
//					boe_line[line_check++] = i;
//				break;
//			case 5 :
//				if(LocalMinima(projection, i, width) < th3 && (abs(i - boe_line[line_check - 1]) >= dist4 - 15) && (abs(i - boe_line[line_check - 1]) <= dist4 + 15))
//					boe_line[line_check++] = i;
//				break;
//			default :
//				continue;
//			}
//			temp_sum = 0;
//		}
//		else 
//		{
//			if(!opposite) temp_sum += difference_lpf[i];
//			//else temp_sum -= difference_lpf[i];
//		}
//	}
//
//#ifdef SAVE_PROJECTION_VALUE
//	CFile file;
//	char str[1024];
//	sprintf_s(str, 1023, "%s\\Vertical_Projection_from(%d, %d)_to(%d, %d).txt", PROJECTION_DIR, ROI_Rect->left, ROI_Rect->top, ROI_Rect->right, ROI_Rect->bottom);
//
//	if(! file.Open(CString(str), CFile::modeCreate | CFile::modeWrite))	return -1;
//
//	sprintf_s(str, 1023, "Left\t%d\tRight\t%d\tTop\t%d\tBottom\t%d\r\n", ROI_Rect->left, ROI_Rect->right, ROI_Rect->top, ROI_Rect->bottom);
//	file.Write(str, (UINT)strlen(str));
//
//	switch(line_check)
//	{
//	case 6 :
//		sprintf_s(str, 1023, "A\r\n%d\t%d\t%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left, boe_line[4] + ROI_Rect->left, boe_line[5] + ROI_Rect->left);
//		break;
//	case 5 :
//		sprintf_s(str, 1023, "B\r\n%d\t%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left, boe_line[4] + ROI_Rect->left);
//		break;
//	case 4 :
//		sprintf_s(str, 1023, "C\r\n%d\t%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left, boe_line[3] + ROI_Rect->left);
//		break;
//	default :
//		sprintf_s(str, 1023, "D\r\n%d\t%d\t%d\r\n\r\n", boe_line[0] + ROI_Rect->left, boe_line[1] + ROI_Rect->left, boe_line[2] + ROI_Rect->left);
//	}
//	file.Write(str, (UINT)strlen(str));
//
//	sprintf_s(str, 1023, "Vertical Projection\tdifference\tlpf\r\n");
//	file.Write(str, (UINT)strlen(str));
//
//	for(int i = 0; i < width; i++)
//	{
//		sprintf_s(str, 1023, "%d\t%d\t%d\r\n", projection[i], projection[(i + 1) % width] - projection[i % width], difference_lpf[i % (width - 2)]);
//		//sprintf_s(str, 1023, "%d%d\r\n", i, projection[i]);
//		file.Write(str, (UINT)strlen(str));
//	}
//
//	file.Close();	
//#endif
//
//	free(projection);
//	free(difference_lpf);
//
//	return line_check;
//}

reflowResult Linecheck_New_Method( int* boe_line, reflowParam *rParam, BOOL bSetMaster )
{
	m_nLineCheckerLocalPeakPeriod=rParam->nPeakPeriod;

	reflowResult result;

#ifdef SAVE_PROJECTION_VALUE
	CString temp(PROJECTION_DIR);
	CreateDirectory(temp, NULL);
#endif
	int ret = 0;

	if(boe_line == NULL)
	{
		TRACE(_T("Linecheck_Method : Line Coordi Array Is Not Allocated\n"));
		result.nErrorcode = REFLOW_RESULT_OUTPUT_ARRAY_ERROR;

		return result;
	}
	if(rParam == NULL)
	{
		TRACE(_T("Linecheck_Method : Reflow Parameter Is Not Allocated\n"));
		result.nErrorcode = REFLOW_RESULT_REFLOWPARAM_SETTING_ERROR;

		return result;
	}

	if(!CheckSetting(rParam))
	{
		TRACE(_T("Linecheck_Method : Reflow Parameter Is Invalid\n"));
		result.nErrorcode = REFLOW_RESULT_REFLOWPARAM_SETTING_ERROR;

		return result;
	}
	if(!bSetMaster)
	{
		TRACE(_T("Linecheck_Method : Master Setting Is Invalid\n"));
		result.nErrorcode = REFLOW_RESULT_MATCHING_ERROR;

		return result;
	}
	if(rParam->ROI_Rect->left < 0) rParam->ROI_Rect->left = 0;
	if(rParam->ROI_Rect->right > rParam->nImageWidth - 1) rParam->ROI_Rect->right = rParam->nImageWidth - 1;
	if(rParam->ROI_Rect->top < 0) rParam->ROI_Rect->top = 0;
	if(rParam->ROI_Rect->bottom > rParam->nImageHeight - 1) rParam->ROI_Rect->bottom = rParam->nImageHeight - 1;


	BYTE *pImage = NULL;	//Review Image Gray 변환
	pImage = new BYTE[rParam->nImageWidth * rParam->nImageHeight];
	memset(pImage, 0, sizeof(BYTE)*rParam->nImageWidth * rParam->nImageHeight);
	if(-1 == RGB2GRAY(pImage, rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep)) 
	{
		if(pImage)
		{
			delete [] pImage;
			pImage = NULL;
		}
		TRACE(_T("Linecheck_Method : RB2GRAY(Review Image) Fail\n"));
		result.nErrorcode = REFLOW_RESULT_IMAGE_LOAD_ERROR;

		return result;
	}

	BOOL bMatch = FALSE;

	BYTE *pMaster = NULL;	//Master Image Gray 변환
	pMaster = new BYTE[rParam->nMasterWidth * rParam->nMasterHeight];
	memset(pMaster, 0, sizeof(BYTE)*rParam->nMasterWidth * rParam->nMasterHeight);
	if(-1 == RGB2GRAY(pMaster, rParam->pMasterBuffer, rParam->nMasterWidth, rParam->nMasterHeight, rParam->nMasterChannel, rParam->nMasterWidthStep)) 
	{
		if(pImage)
		{
			delete [] pImage;
			pImage = NULL;
		}
		if(pMaster)
		{
			delete [] pMaster;
			pMaster = NULL;
		}
		TRACE(_T("Linecheck_Method : RB2GRAY(Master Image) Fail\n"));
		result.nErrorcode =  REFLOW_RESULT_IMAGE_LOAD_ERROR;

		return result;
	}

	switch(rParam->nSide)	//Matching을 통한 ROI 영역 설정
	{
	case CS_TOP :
		bMatch = Match_Vertical(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
		break;
	case CS_LEFT :
	case CS_RIGHT :
		bMatch = Match_Horizontal(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
		break;
	}

	if(!bMatch)
	{
		//switch(rParam->nSide)
		//{
		//case CS_TOP :
		//	bMatch = SecondMatch_Vertical(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
		//	break;
		//case CS_LEFT :
		//case CS_RIGHT :
		//	bMatch = SecondMatch_Horizontal(pImage, rParam->nImageWidth, rParam->nImageHeight, pMaster, rParam->nMasterWidth, rParam->nMasterHeight, rParam->ROI_Rect);
		//	break;
		//}
		//if(!bMatch)
		//{
		if(pImage)
		{
			delete [] pImage;
			pImage = NULL;
		}
		if(pMaster)
		{
			delete [] pMaster;
			pMaster = NULL;
		}
		TRACE(_T("Linecheck_Method : Matching Fail\n"));
		result.nErrorcode = REFLOW_RESULT_MATCHING_ERROR;
		return result;
		//}
	}

	switch(rParam->nSide)//Review Image의 ROI 내에서 DAM을 탐색하여 overflow 여부 판정
	{
	case CS_TOP :
		result.nErrorcode = Linecheck_Method_Side0(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nDamTh2, rParam->nDamTh2_in, rParam->nDamTh1, rParam->nDamTh1_in, rParam->nDistance,&result);
		for(int i = 0; i < 4; i++)//ROI Start 좌표를 원점으로 좌표를 계산하기 때문에 ROI Start 좌표를 가산해줌
		{
			if(boe_line[i] != 0)
			{
				boe_line[i] += rParam->ROI_Rect->top;
			}
		}
		Reflow_Line_Paint_Vertical(rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep, boe_line);
		break;
	case CS_LEFT :
		result.nErrorcode = Linecheck_Method_Side1(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nDamTh2, rParam->nDamTh2_in, rParam->nDamTh1, rParam->nDamTh1_in, rParam->nDistance,&result);
		for(int i = 0; i < 4; i++)
		{
			if(boe_line[i] != 0)
			{
				boe_line[i] += rParam->ROI_Rect->left;
			}
		}
		Reflow_Line_Paint_Horizontal(rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep, boe_line);
		break;
	case CS_RIGHT :
		result.nErrorcode = Linecheck_Method_Side2(boe_line, pImage, rParam->nImageWidth, rParam->nImageHeight, rParam->ROI_Rect, rParam->nDamTh2, rParam->nDamTh2_in,rParam->nDamTh1, rParam->nDamTh1_in, rParam->nDistance,&result);
		for(int i = 0; i < 4; i++)
		{
			if(boe_line[i] != 0)
			{
				boe_line[i] += rParam->ROI_Rect->left;
			}
		}
		Reflow_Line_Paint_Horizontal(rParam->pImageBuffer, rParam->nImageWidth, rParam->nImageHeight, rParam->nChannel, rParam->nImageWidthStep, boe_line);
		break;
	default :
		result.nErrorcode =  REFLOW_RESULT_REFLOWPARAM_SETTING_ERROR; // Select Wrong Side 
	}

	if(pImage)
	{
		delete [] pImage;
		pImage = NULL;
	}
	if(pMaster)
	{
		delete [] pMaster;
		pMaster = NULL;
	}
	return result;
}