#include "StdAfx.h"
#include "PairStorage.h"



CPairStorage::CPairStorage(void)
{
	m_nPairSpace= m_maxPair= m_nPair= -1;
	m_pPairDefect= NULL;

	m_lFirstIndex= NULL;
	m_bMerged= NULL;
	m_bTemp= NULL;
}

CPairStorage::~CPairStorage(void)
{
	if(m_pPairDefect)
		delete[] m_pPairDefect;
	if(m_lFirstIndex)
		delete[] m_lFirstIndex;
	if(m_bMerged)
		delete[] m_bMerged;
	if(m_bTemp)
		delete[] m_bTemp;
}


// ¹öÆÛÀÇ »çÀÌÁî¿¡ »ó°ü¾øÀÌ minus À妽º·Îµµ Á¢±Ù °¡´ÉÇÑ ±â´É ¹öÆÛ.
class CSISBufferSudo
{
protected:
	BYTE * m_pData;
	int m_Width, m_DataWidth;
	int m_Height;
public:
	CSISBufferSudo(){m_pData= NULL; SetSize(0, 0);};
	CSISBufferSudo(BYTE* pData_, int w, int h)
		: m_pData(pData_)
	{		SetSize(w, h);	}
	void SetBuffer(BYTE* pData, int w, int h)
	{
		m_pData= pData;
		SetSize(w, h);
	}
	virtual BOOL SetSize(int w, int h)
	{
		m_Width= w;
		m_Height= h;
		m_DataWidth= ChangeDataWidth(w);//(m_Width+ 3)/4*4;
		return TRUE;
	}
	BYTE* GetDataAddress(int x, int y){return m_pData+ GetDataWidth()*y+ x;};
	double GetDiff32(int x, int y, double xPitch);
	double	GetDiff23(int x, int y, double yPitch);	

	double GetXDiff22(int x, int y, double xPitch);
	double GetYDiff22(int x, int y, double yPitch);

	double GetXDiff(int x, int y, double xPitch);
	double GetYDiff(int x, int y, double yPitch);

	int GetDataWidth(){ return m_DataWidth;}
	static int ChangeDataWidth(int width){return (width+ 3)/4*4;}
};

double CSISBufferSudo::GetXDiff(int x, int y, double xPitch)
{
	double ret;
	double xRef= x+ xPitch;
	int iRef= (int)xRef;
	double r2= xRef- iRef;
	double r1= 1- r2;

	BYTE	*pData= GetDataAddress(x, y);
	BYTE	*pData2= GetDataAddress(iRef, y);

	ret= *pData;

	ret-= ((double)(*pData2)*r1+ *(pData2+1)*r2);

	return ret;
}

double CSISBufferSudo::GetYDiff(int x, int y, double yPitch)
{
	double ret;
	double yRef= y+ yPitch;
	int iRef= (int)yRef;
	double r2= yRef- iRef;
	double r1= 1- r2;

	BYTE	*pData= GetDataAddress(x, y);
	BYTE	*pData2= GetDataAddress(x, iRef);

	ret= *pData;

	ret-= ((double)(*pData2)*r1);
	pData2+= GetDataWidth();
	ret-= ((double)(*pData2)*r2);

	return ret;
}

double CSISBufferSudo::GetXDiff22(int x, int y, double xPitch)
{
	double ret;
	double xRef= x+ xPitch;
	int iRef= (int)xRef;
	double r2= xRef- iRef;
	double r1= 1- r2;

	BYTE	*pData= GetDataAddress(x, y);
	BYTE	*pData2= GetDataAddress(iRef, y);

	ret= *pData+ *(pData+ 1);
	pData+= GetDataWidth();
	ret+= *pData+ *(pData+ 1);

	ret-= ((double)(*pData2)*r1+ *(pData2+ 1)+ *(pData2+2)*r2);
	pData2+= GetDataWidth();
	ret-= ((double)(*pData2)*r1+ *(pData2+ 1)+ *(pData2+2)*r2);

	return ret;
}

double CSISBufferSudo::GetYDiff22(int x, int y, double yPitch)
{
	double ret;
	double yRef= y+ yPitch;
	int iRef= (int)yRef;
	double r2= yRef- iRef;
	double r1= 1- r2;

	BYTE	*pData= GetDataAddress(x, y);
	BYTE	*pData2= GetDataAddress(x, iRef);

	ret= *pData+ *(pData+ 1);
	pData+= GetDataWidth();
	ret+= *pData+ *(pData+ 1);

	ret-= ((double)((*pData2)+ *(pData2+ 1))*r1);
	pData2+= GetDataWidth();
	ret-= ((double)((*pData2)+ *(pData2+ 1)));
	pData2+= GetDataWidth();
	ret-= ((double)((*pData2)+ *(pData2+ 1))*r2);

	return ret;
}

double CSISBufferSudo::GetDiff32(int x, int y, double xPitch)
{
	double		ret;
	double	xRef= x+ xPitch;
	int		iRef= (int) xRef;
	double	pb= xRef- iRef;
	double	pa= 1- pb;
	BYTE	*pData= GetDataAddress(x, y);
	BYTE	*pData2= GetDataAddress(iRef, y);

	ret= *pData+ *(pData+ 1)+ *(pData+2);
	pData+= GetDataWidth();
	ret+= *pData+ *(pData+ 1)+ *(pData+2);

	ret-= ((double)(*pData2)*pa+ *(pData2+ 1)+ *(pData2+2)+ (*(pData2+3))*pb);
	pData2+= GetDataWidth();
	ret-= ((double)(*pData2)*pa+ *(pData2+ 1)+ *(pData2+2)+ (*(pData2+3))*pb);

	return ret;
}

double CSISBufferSudo::GetDiff23(int x, int y, double yPitch)
{
	double		ret;
	double	yRef= y+ yPitch;
	int		iRef= (int) yRef;
	double	pb= yRef- iRef;
	double	pa= 1- pb;
	BYTE	*pData= GetDataAddress(x, y);
	BYTE	*pData2= GetDataAddress(x, iRef);

	ret= *pData+ *(pData+1);
	pData+= GetDataWidth();
	ret+= *pData+ *(pData+1);
	pData+= GetDataWidth();
	ret+= *pData+ *(pData+1);

	ret-= ((double)(*pData2)*pa+ (*(pData2+1))*pa);
	pData2+= GetDataWidth();
	ret-= *pData2+ *(pData2+1);
	pData2+= GetDataWidth();
	ret-= *pData2+ *(pData2+1);
	pData2+= GetDataWidth();
	ret-= ((double)(*pData2)*pb+ (*(pData2+1))*pb);

	return ret;
}

void CPairStorage::ShadowFly()
{
	// ShadowDefect(UnpairDefect)À» ¸ðµÎ ³¯¸°´Ù. ³ªÁß¿¡ ¾î¼À¿¡¼­ ÆĶó¹ÌÅÍ·Î ¹Þ¾Æ¼­ ó¸®ÇÏÀå.
	CDefectPair *pPair;
	int x;

	for(x = 0; x < m_nPair; x++)
	{
		pPair= m_pPairDefect+ x;
		if(pPair->s_DefectPair == DEFPAIR_UNPAIR)
		{
			pPair->s_DefectType= DEFTYPE_DELETE;
		}
	}
}

void CPairStorage::TotalResetPairStorage()
{
	m_nPair= 0;
	int i;
	for(i= 0; i< m_maxPair; i++)
	{
		m_pPairDefect[i].Reset();
	}
}

void CPairStorage::ResetPairStorage()
{
	int i;
	int nPair;

	if(m_nPairSpace < m_nPair)
		nPair= m_nPairSpace;
	else
		nPair= m_nPair;

	for(i= 0; i< nPair; i++)
	{
		m_pPairDefect[i].Reset();
	}
	m_nPair= 0;
}

int	CPairStorage::InitPairStorage(int maxPair)
{
	if(maxPair <= m_nPairSpace)
	{
		m_maxPair= maxPair;
		return m_maxPair;
	}

	if(m_pPairDefect != NULL)
	{
		delete[] m_pPairDefect;
	}
	int	PairSapce= maxPair+ 16;

	if(m_lFirstIndex)
		delete[] m_lFirstIndex;
	if(m_bMerged)
		delete[] m_bMerged;
	if(m_bTemp)
		delete[] m_bTemp;

	m_lFirstIndex= new long[PairSapce];
	m_bMerged= new BOOL[PairSapce];
	m_bTemp= new BOOL[PairSapce];

	// 16°³ÀÇ ¿©ºÐÀ» µÐ´Ù..¿Ö? ³»¸É..
	m_pPairDefect= new CDefectPair[PairSapce];

	if(m_pPairDefect == NULL)
	{
		m_maxPair= m_nPairSpace= 0;
		return m_maxPair;
	}


	m_maxPair= m_nPairSpace= maxPair;

	TotalResetPairStorage();// ÃʱâÈ­ ½Ã°£ ´ÜÃàÀ» À§ÇØ TotalReset °è¿­ ÇÔ¼ö Ãß°¡.

	return m_maxPair;
}



int CPairStorage::FalseFilter_Vert()
{
	if(m_Param.m_bUsePixelFilter == FALSE)	return 0;

	int iPair, ip;
	CDefectPair *pPair, *pp;
	int	x, y;

	for(iPair= 0; iPair < m_nPair; iPair++)
	{
		pPair= m_pPairDefect+ iPair;
		x= pPair->s_nDefectX;
		y= pPair->s_nDefectY;
		for(ip= iPair+ 1; ip < m_nPair; ip)
		{
			pp= m_pPairDefect+ ip;
			if(y == pp->s_nDefectY)
			{

			}
		}
	}
	return 0;
}

int CPairStorage::FalseFilter_Hori()
{
	if(m_Param.m_bUsePixelFilter == FALSE)	return 0;

	int iPair, ip;
	CDefectPair *pPair, *pp;
	int	x, y;
//	int	ids[1000];
	int count;

	for(iPair= 0; iPair < m_nPair; iPair++)
	{
		pPair= m_pPairDefect+ iPair;
		x= pPair->s_nDefectX;
		y= pPair->s_nDefectY+ 1;
		count= 0;
		for(ip= iPair+ 1; ip < m_nPair; ip)
		{
			pp= m_pPairDefect+ ip;
			if(y < pp->s_nDefectY)
			{
				break;
			}
			count++;
		}
	}
	return 0;
}

void CPairStorage::Filtering_Hori()
{
	if(m_Param.m_bUsePixelFilter == FALSE)	return;

	int iPair;
	CDefectPair *pPair;
	if(m_Param.m_bPairFilter == TRUE)
	{
		if(m_Param.m_bOnlyJumpFilter == TRUE)
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(! MarginFilter_Hori(pPair))
					pPair->s_DefectType= DEFTYPE_DELETE;
				else if(! JumpFilter_Hori(pPair))
				{
					pPair->s_DefectType= DEFTYPE_DELETE;
				}
			}
		}else
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(! MarginFilter_Hori(pPair))
					pPair->s_DefectType= DEFTYPE_DELETE;
				else if(! CrossFilter_Vert(pPair))
				{
					pPair->s_DefectType= DEFTYPE_DELETE;
				}
			}
		}
	}else
	{
		if(m_Param.m_bOnlyJumpFilter == TRUE)
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(pPair->s_DefectPair == DEFPAIR_UNPAIR)
				{
					if(! MarginFilter_Hori(pPair))
						pPair->s_DefectType= DEFTYPE_DELETE;
					else if(! JumpFilter_Hori(pPair))
					{
						pPair->s_DefectType= DEFTYPE_DELETE;
					}
				}
			}
		}else
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(pPair->s_DefectPair == DEFPAIR_UNPAIR)
				{
					if(! MarginFilter_Hori(pPair))
						pPair->s_DefectType= DEFTYPE_DELETE;
					else if(! CrossFilter_Vert(pPair))
					{
						pPair->s_DefectType= DEFTYPE_DELETE;
					}
				}
			}
		}
	}
};

void CPairStorage::Filtering_Vert_Temp()
{
	if(m_Param.m_bUsePixelFilter == FALSE)	return;

}

void CPairStorage::CorrectDefGray()			// µðÆå pixelÀÇ ¹à±â °ª ¿Ö°î º¸Á¤(¿Ö°îÀÌÀ¯:¼­ºêÇȼ¿, m*n ¿¬»ê)
{
	int iPair;
	CDefectPair *pPair;

	if(NULL == m_Param.s_lpBuffer)
		return;

	for(iPair= 0; iPair < m_nPair; iPair++)
	{
		pPair= m_pPairDefect+ iPair;

		pPair->s_fDefectPeak = abs(pPair->s_nGraySrc - pPair->s_nGrayRef) - abs(pPair->s_nThresold);
		pPair->s_nGraySrc= *(m_Param.s_lpBuffer+ m_Param.s_nFrameWidth*pPair->s_nDefectY+ pPair->s_nDefectX);
	}
}

void CPairStorage::Filtering_Vert()
{
	int iPair;
	CDefectPair *pPair;

	if(m_Param.m_bUsePixelFilter == FALSE)
	{
		for(iPair= 0; iPair < m_nPair; iPair++)
		{
			pPair= m_pPairDefect+ iPair;
			if(! OneFilter_Vert(pPair))
			{
				pPair->s_DefectType= DEFTYPE_DELETE;
			}
		}

		return;
	}

	if(m_Param.m_bPairFilter == TRUE)
	{
		if(m_Param.m_bOnlyJumpFilter == TRUE)
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(! JumpFilter_Vert(pPair))
				{
					
					pPair->s_DefectType= DEFTYPE_DELETE;
				}
			}
		}else
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(! CrossFilter_Hori(pPair))
				{
					pPair->s_DefectType= DEFTYPE_DELETE;
				}
			}
		}
	}else
	{
		if(m_Param.m_bOnlyJumpFilter == TRUE)
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(pPair->s_DefectPair == DEFPAIR_UNPAIR)
				{
					if(! JumpFilter_Vert(pPair))
					{
						pPair->s_DefectType= DEFTYPE_DELETE;
					}
				}
			}
		}else
		{
			for(iPair= 0; iPair < m_nPair; iPair++)
			{
				pPair= m_pPairDefect+ iPair;
				if(pPair->s_DefectPair == DEFPAIR_UNPAIR)
				{
					if(! CrossFilter_Hori(pPair))
					{
						pPair->s_DefectType= DEFTYPE_DELETE;
					}
				}
			}
		}
	}
}


BOOL ContainY(CRect &rect, int y)
{
	if(rect.top > y)	return FALSE;
	if(rect.bottom < y)	return FALSE;
	return TRUE;
}
BOOL ContainX(CRect &rect, int x)
{
	if(rect.left > x)	return FALSE;
	if(rect.right < x)	return FALSE;
	return TRUE;
}
//JumpCheck
BOOL CPairStorage::JumpFilter_Hori(CDefectPair *pPair)
{
	double pitch= m_Param.GetRealConvPitch() * 2;
	int iPitch= (int)pitch;

	CSISBufferSudo buffer(m_Param.s_lpBuffer, m_Param.s_nFrameWidth, m_Param.s_nFrameHeight);
	int diff;

	if(pPair->s_nDefectX+ iPitch + 1 >= m_Param.s_RectConv.right)
	{
		pitch= -pitch;
	}

	// pitch °ªÀÌ °Ë»ç ¹üÀ§¸¦ ¹þ¾î³ª¸é ÇÊÅ͸µÇÒ ¼ö ¾ø´Ù.
	if(ContainX(m_Param.s_RectConv, pPair->s_nDefectX+ pitch) == FALSE)	return FALSE;

	int nThreshold;
	if(m_Param.m_ConvMode == ConvMode_Pixel)
	{
		if(m_Param.m_pFilterThBlack == NULL)
			nThreshold= pPair->s_nThresold;
		else
			nThreshold= m_Param.GetFilterThreshold(pPair->s_nZone, max(pPair->s_nGraySrc, pPair->s_nGrayRef), pPair->s_DefectType);
		diff= abs((int)buffer.GetXDiff(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}else
	{
		nThreshold= pPair->s_nThresold * m_Param.s_nConvWidth * m_Param.s_nConvHeight;
		diff= abs((int)buffer.GetXDiff22(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}

	if(diff > nThreshold)
	{
		return TRUE;
	}

	return FALSE;
}

#include <vector>
#include <algorithm>
class CSIS
{
	int count;
public:
	CSIS(){count= 0;}
	int operator ()(int a)
	{
		return ++count;
	}
};


class CPairFilter
{
	CSISBufferSudo m_Buffer;
public:
	CPairFilter(BYTE* pData, int w, int h)
	{
		m_Buffer.SetBuffer(pData, w, h);

		CSIS mosis;

		int *pInt= new int[100];

		std::for_each(pInt, pInt+ 100, mosis);
	}

	BOOL JumpFilter();
};

BOOL CPairStorage::JumpFilter_Vert(CDefectPair *pPair)
{
	if(! OneFilter_Vert(pPair)) return FALSE;// ÇÊÅ͸µÀÌ µÇ¾úÀ¸¸é ´õÀÌ»ó ÁøÇà ÇÊ¿ä ¾øÀ½..


	double pitch= m_Param.GetRealScanPitch() * 2;
	int iPitch= (int)pitch;


	CSISBufferSudo buffer(m_Param.s_lpBuffer, m_Param.s_nFrameWidth, m_Param.s_nFrameHeight);
	int diff;


	if(pPair->s_nDefectY+ iPitch+ 1 >= m_Param.s_RectConv.bottom)
	{
		pitch= -pitch;
	}

	// pitch °ªÀÌ °Ë»ç ¹üÀ§¸¦ ¹þ¾î³ª¸é ÇÊÅ͸µÇÒ ¼ö ¾ø´Ù. °áÇÔÀÌ µÈ´Ù.
	if(ContainY(m_Param.s_RectConv, pPair->s_nDefectY+ pitch) == FALSE)	return TRUE;

	int nThreshold;
	if(m_Param.m_ConvMode == ConvMode_Pixel)
	{
		if(m_Param.m_pFilterThBlack == NULL)
			nThreshold= pPair->s_nThresold;
		else
			nThreshold= m_Param.GetFilterThreshold(pPair->s_nZone, max(pPair->s_nGraySrc, pPair->s_nGrayRef), pPair->s_DefectType);
		diff= abs((int)buffer.GetYDiff(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}else
	{
		nThreshold= pPair->s_nThresold * m_Param.s_nConvWidth * m_Param.s_nConvHeight;
		diff= abs((int)buffer.GetYDiff22(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}

	if(diff > nThreshold)
	{
		return TRUE;// »ì¾Æ ³²¾Æ µðÆåÀÌ µÈ´Ù..
	}

	return FALSE;
}

BOOL CPairStorage::MarginFilter_Hori(CDefectPair *pPair)
{
	if(m_Param.m_bUseMarginFilter == FALSE)	return TRUE;	// TRUE means pPair is true defect. (this filter doesn't have any effect.)
	double pitch;
	int		edgeTh= 0;

	int		x= pPair->s_nDefectX;
	int		bReverse= TRUE;
	int		nSign=	1;
	CRect	rectFilter;

	if(m_Param.s_RectFilter.Height() < 1)
	{
		rectFilter			= m_Param.s_RectConv;
		rectFilter.left		= 0;
		rectFilter.right	= m_Param.s_nFrameWidth;
	}else
		rectFilter= m_Param.s_RectFilter;

	pitch= m_Param.GetRealConvPitch();

	if(pPair->s_DefectPos == DEFPOS_LEFT)
	{
		if(x- pitch- 3 <rectFilter.left)
		{
			x= x+ pitch+ 0.5;
			pitch= -pitch;
			edgeTh= m_Param.m_EdgeFilterTh;
		}else
		{
			x= x- int(pitch+0.5);
		}
		nSign= -1;
	}else if(pPair->s_DefectPos == DEFPOS_RIGHT)
	{
		if(x+ pitch+ 3 > rectFilter.right)
		{
			pitch= -pitch;
			edgeTh= m_Param.m_EdgeFilterTh;
		}else
		{
		}
	}else
	{
		return TRUE;// »ì¾Æ ³²¾Æ µðÆåÀÌ µÈ´Ù..
	}

	int iPitch= (int)pitch;

	CSISBufferSudo buffer(m_Param.s_lpBuffer, m_Param.s_nFrameWidth, m_Param.s_nFrameHeight);
	int diff;
	int nThreshold;
	if(m_Param.m_ConvMode == ConvMode_Pixel)
	{
		if(m_Param.m_pFilterThBlack == NULL)
			nThreshold= pPair->s_nThresold;
		else
			nThreshold= m_Param.GetFilterThreshold(pPair->s_nZone, max(pPair->s_nGraySrc, pPair->s_nGrayRef), pPair->s_DefectType);
		nThreshold+= edgeTh;
		diff= buffer.GetXDiff(x, pPair->s_nDefectY, pitch);		// s, y => src, pitch= ref;
	}else
	{
		nThreshold= pPair->s_nThresold;
		nThreshold+= edgeTh;
		nThreshold= nThreshold * m_Param.s_nConvWidth * m_Param.s_nConvHeight;
		diff= buffer.GetXDiff22(x, pPair->s_nDefectY, pitch);	// s, y => src, pitch= ref;
	}

	diff= nSign*diff;	// src & ref distinguish.
	if(pPair->s_DefectType == DEFTYPE_BLACK)
	{
		return -diff > nThreshold;
	}
	return diff > nThreshold;	// if reutrn(true), the defect is  a real defect. if not, that defect is not a defect.


// 	if(abs(diff) > nThreshold)
// 	{
// 		return TRUE;// »ì¾Æ ³²¾Æ µðÆåÀÌ µÈ´Ù..
// 	}
// 
// 	return FALSE;
}

BOOL CPairStorage::OneFilter_Vert(CDefectPair *pPair)
{
	double pitch;
	int		edgeTh= 0;

	int		y= pPair->s_nDefectY;
	int		bReverse= TRUE;
	CRect	rectFilter;

	if(m_Param.s_RectFilter.Height() < 1)
		rectFilter= m_Param.s_RectConv;
	else
		rectFilter= m_Param.s_RectFilter;

 	if(m_Param.m_pPitch16 != NULL)
 		pitch= (double)m_Param.m_pPitch16[y/16]/16;
	else
		pitch= m_Param.GetRealScanPitch();

	if(pPair->s_DefectPos == DEFPOS_LEFT)
	{
		if(y- pitch- 3 <rectFilter.top)
		{
			y= y+ pitch+ 0.5;
			pitch= -pitch;
			edgeTh= m_Param.m_EdgeFilterTh;
		}else
		{
			y= y- int(pitch+0.5);			
		}
	}else if(pPair->s_DefectPos == DEFPOS_RIGHT)
	{
		if(y+ pitch+ 3 > rectFilter.bottom)
		{
			pitch= -pitch;
			edgeTh= m_Param.m_EdgeFilterTh;
		}else
		{
			;
		}
	}else
	{
		return TRUE;// »ì¾Æ ³²¾Æ µðÆåÀÌ µÈ´Ù..
	}


	int iPitch= (int)pitch;

	CSISBufferSudo buffer(m_Param.s_lpBuffer, m_Param.s_nFrameWidth, m_Param.s_nFrameHeight);
	int diff;

	// pitch °ªÀÌ °Ë»ç ¹üÀ§¸¦ ¹þ¾î³ª¸é ÇÊÅ͸µÇÒ ¼ö ¾ø´Ù.
// 	if(ContainY(m_Param.s_RectFilter, y+ pitch) == FALSE)
// 	{
//		AfxMessageBox("over");
// 		return FALSE;// µðÆåÀ» Áö¿î´Ù. °¡°áÇÔ ¶§¹®¿¡.. ÀÌ Á¶°ÇÀº ¸¸Á·ÇÏ¸é ¾ÈµÇ´Â... 3ÁֱⰡ µÇ¾î¾ß Çϴϱî.
// 	}

	int nThreshold;
	if(m_Param.m_ConvMode == ConvMode_Pixel)
	{
		if(m_Param.m_pFilterThBlack == NULL)
			nThreshold= pPair->s_nThresold;
		else
			nThreshold= m_Param.GetFilterThreshold(pPair->s_nZone, max(pPair->s_nGraySrc, pPair->s_nGrayRef), pPair->s_DefectType);
		nThreshold+= edgeTh;
		diff= abs((int)buffer.GetYDiff(pPair->s_nDefectX, y, pitch));
	}else
	{
		nThreshold= pPair->s_nThresold;
		nThreshold+= edgeTh;
		nThreshold= nThreshold * m_Param.s_nConvWidth * m_Param.s_nConvHeight;
		diff= abs((int)buffer.GetYDiff22(pPair->s_nDefectX, y, pitch));
	}

//	if(pPair->s_DefectType == DEFTYPE_BLACK)
	{
		if(diff > nThreshold)
		{
			return TRUE;// »ì¾Æ ³²¾Æ µðÆåÀÌ µÈ´Ù..
		}
	}

	return FALSE;// µðÆåÀ» Áö¿î´Ù.
}


BOOL CPairStorage::CrossFilter_Hori(CDefectPair *pPair)
{
	if(! OneFilter_Vert(pPair)) return FALSE;// ÇÊÅ͸µÀÌ µÇ¾úÀ¸¸é ´õÀÌ»ó ÁøÇà ÇÊ¿ä ¾øÀ½..

	double pitch= m_Param.GetRealConvPitch();
	int iPitch= (int)pitch;



	if(m_Param.s_RectConv.Width() < pitch*2)
	{
		return JumpFilter_Vert(pPair);
	}

	CSISBufferSudo buffer(m_Param.s_lpBuffer, m_Param.s_nFrameWidth, m_Param.s_nFrameHeight);
	int diff;


	if(pPair->s_nDefectX+ iPitch+ 1 >= m_Param.s_RectConv.right)
	{
		pitch= -pitch;
	}

	int nThreshold;
	if(m_Param.m_ConvMode == ConvMode_Pixel)
	{
		if(m_Param.m_pFilterThBlack == NULL)
			nThreshold= pPair->s_nThresold;
		else
			nThreshold= m_Param.GetFilterThreshold(pPair->s_nZone, max(pPair->s_nGraySrc, pPair->s_nGrayRef), pPair->s_DefectType);
		diff= abs((int)buffer.GetXDiff(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}else
	{
		nThreshold= pPair->s_nThresold * m_Param.s_nConvWidth * m_Param.s_nConvHeight;
		diff= abs((int)buffer.GetXDiff22(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}


	if(diff > nThreshold)
	{
		return TRUE;
	}

	return FALSE;
}

BOOL CPairStorage::CrossFilter_Vert(CDefectPair *pPair)
{
	double pitch= m_Param.GetRealScanPitch();
	int iPitch= (int)pitch;


	if(m_Param.s_RectConv.Height() < pitch*2)
	{
		return JumpFilter_Hori(pPair);
	}

	CSISBufferSudo buffer(m_Param.s_lpBuffer, m_Param.s_nFrameWidth, m_Param.s_nFrameHeight);
	int diff;

	//BOE ½áŧ·¯¹öÆÛ¿¡¼­ Á׾ ¼öÁ¤
	if(pPair->s_nDefectY+ iPitch+ 2 >= m_Param.s_RectConv.bottom) //if(pPair->s_nDefectY+ iPitch+ 1 >= m_Param.s_RectConv.bottom)
	{
		pitch= -pitch;
	}

	int nThreshold;
	if(m_Param.m_ConvMode == ConvMode_Pixel)
	{
		if(m_Param.m_pFilterThBlack == NULL)
			nThreshold= pPair->s_nThresold;
		else
		nThreshold= m_Param.GetFilterThreshold(pPair->s_nZone, max(pPair->s_nGraySrc, pPair->s_nGrayRef), pPair->s_DefectType);

		diff= abs((int)buffer.GetYDiff(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}else
	{
		nThreshold= pPair->s_nThresold * m_Param.s_nConvWidth * m_Param.s_nConvHeight;
		diff= abs((int)buffer.GetYDiff22(pPair->s_nDefectX, pPair->s_nDefectY, pitch));
	}

	if(diff > nThreshold)
	{
		return TRUE;
	}

// 	if(pPair->s_DefectType == DEFTYPE_BLACK)
// 	{
// 		if(diff < -nThreshold)
// 		{
// 			return TRUE;
// 		}
// 		return FALSE;
// 	}else if(pPair->s_DefectType == DEFTYPE_WHITE)
// 	{
// 		if(diff > nThreshold)
// 		{
// 			return TRUE;
// 		}
// 		return FALSE;
// 	}

	return FALSE;
}



//////////////////////////////////////////////////////////////////////////
DIT_RESULT CPairStorage::PairingPlus_Pixel(double dPitchsize)
{
	//////////////////////////////////////////////////////////////////////////
	//MMX¿¡¼­ thresholding±îÁöÇÏ°í ³ª¿À´Â °áÇÔÀÇ pointÁ¤º¸´Â pair·Î ³ª¿À¹Ç·Î 
	//½ÇÁ¦ ÇÑ°³ÀÇ pointÁ¤º¸¸¦ °Å¸£´Â °úÁ¤ÀÌ ÇÊ¿äÇÏ´Ù.
	dPitchsize+=0.5;
	int i, j, nLenX;
	BOOL ignore = FALSE;
	int left, right;
	left= m_Param.s_RectConv.left+ static_cast<LONG>(dPitchsize);
	right= m_Param.s_RectConv.right- static_cast<LONG>(dPitchsize * 2);

	CDefectPair *pPairDefect= m_pPairDefect+m_nPair;

	for(i = 0; i < m_nPixel; i++)
	{
		if (m_pPixelType[i] == DEFTYPE_DELETE || m_pPixelType[i] == DEFTYPE_NODEFECT)
			continue;

		// ¿ÞÂÊ °Ë»ç ¿µ¿ª ¿¹¿Üó¸®.
		ignore = FALSE;
		if (m_pPixelX[i] < left)
		{
			// °æ°è¿¡¼­ÀÇ Paring °Ë»ç.
			for(j = i + 1; j < m_nPixel; j++)
			{
				if (m_pPixelType[j] == DEFTYPE_DELETE || m_pPixelType[j] == DEFTYPE_NODEFECT)
					continue;
				if (m_pPixelY[j] != m_pPixelY[i])	// ´õÀÌ»ó ºñ±³ÇÒ ÇÊ¿ä ¾ø´Ù.
					break;
				if (m_pPixelType[i] == m_pPixelType[j])
					continue;
				nLenX = m_pPixelX[j] - (m_pPixelX[i] + static_cast<int>(dPitchsize));
				if(nLenX != 0)//if (nLenX > 1 || nLenX < -1)
					continue;

				// ÇÑ ÇÇÄ¡ ¿À¸¥ÂÊ¿¡ °áÇÔÀÌ ÀÖ´Â °æ¿ì DEFPOS_LEFT_PAIR·Î ÆÇÁ¤
				pPairDefect->s_DefectPos		= DEFPOS_LEFT;
				pPairDefect->s_DefectPair		= DEFPAIR_PPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[j];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[j];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[j]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
				pPairDefect->s_nGraySrc		= m_pGraySrc[j];
				pPairDefect->s_nGrayRef		= m_pGrayCmp[j];
				pPairDefect->s_fDefectPeak	= m_pPixelValue[j];
				pPairDefect->s_nZone			= m_pZoneID[j];
				pPairDefect->s_nThresold		= m_pZoneTh[j];


				m_pPixelType[j] = DEFTYPE_DELETE;	// ÇÇÄ¡ ¿À¸¥ÂÊ °áÇÔÀº ´õÀÌ»ó »ý°¢ÇÒ ÇÊ¿äµµ ¾ø´Ù.
				m_nPair++;
				pPairDefect++;

				ignore = TRUE;
				break;
			}
			if (ignore == FALSE)		// Pair °¡ ¾Æ´Ñ °æ¿ì DEFPOS_LEFT_UNPAIR·Î ÆÇÁ¤. ÀÌÈÄ Classify¿¡¼­ ÀçÁ¶Á¤.
			{
				pPairDefect->s_DefectPos		= DEFPOS_LEFT;
				pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[i];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[i];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[i]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
				pPairDefect->s_nGraySrc		= m_pGraySrc[i];
				pPairDefect->s_nGrayRef		= m_pGrayCmp[i];
				pPairDefect->s_fDefectPeak	= m_pPixelValue[i];
				pPairDefect->s_nZone			= m_pZoneID[i];
				pPairDefect->s_nThresold		= m_pZoneTh[i];
				pPairDefect->s_nDefectX					= m_pPixelX[i];
				m_nPair++;
				pPairDefect++;
			}
		}
		// °¡¿îµ¥ °Ë»ç¿µ¿ªÀÏ ¶§ ó¸®.
		else if (m_pPixelX[i] <= right)
		{
			for(j = i + 1; j < m_nPixel; j++)
			{
				if (m_pPixelType[j] == DEFTYPE_DELETE || m_pPixelType[j] == DEFTYPE_NODEFECT)
					continue;
				if (m_pPixelY[j] != m_pPixelY[i])	// ´õÀÌ»ó ºñ±³ÇÒ ÇÊ¿ä ¾ø´Ù.
					break;
				if (m_pPixelType[i] == m_pPixelType[j])
					continue;
				nLenX = m_pPixelX[j] - (m_pPixelX[i] + static_cast<int>(dPitchsize));
				if(nLenX != 0)//if (nLenX > 1 || nLenX < -1)	// ÇÑ ÇÇÄ¡ ¿À¸¥ÂÊ¿¡ °áÇÔÀÌ ÀÖ´Â °æ¿ì DEFPOS_LEFT_PAIR·Î ÆÇÁ¤
					continue;

				// ÇÑ ÇÇÄ¡ ÀÌÈÄ¿¡ µðÆåÀÌ ÀÖÀ¸¸é Pairing.
				pPairDefect->s_DefectPos		= DEFPOS_CENTER;
				pPairDefect->s_DefectPair		= DEFPAIR_PPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[j];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[j];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[j]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
				pPairDefect->s_nGraySrc		= m_pGraySrc[j];
				pPairDefect->s_nGrayRef		= m_pGrayCmp[j];
				pPairDefect->s_fDefectPeak	= m_pPixelValue[j];
				pPairDefect->s_nZone			= m_pZoneID[j];
				pPairDefect->s_nThresold		= m_pZoneTh[j];

				m_pPixelType[j] = DEFTYPE_DELETE;	// ÇÇÄ¡ ¿À¸¥ÂÊ °áÇÔÀº ´õÀÌ»ó »ý°¢ÇÒ ÇÊ¿äµµ ¾ø´Ù.
				m_nPair++;
				pPairDefect++;

				ignore = TRUE;
				break;
			}
// 			if (ignore == FALSE)		// Pair °¡ ¾Æ´Ñ °æ¿ì.
// 			{
// 				pPairDefect->s_DefectPos		= DEFPOS_CENTER;
// 				pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
// 				pPairDefect->s_nDefectX		= m_pPixelX[i];	// Add Margin
// 				pPairDefect->s_nDefectY		= m_pPixelY[i];
// 				pPairDefect->s_DefectType		= (DefectType)m_pPixelType[i];	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
// 				pPairDefect->s_nGraySrc		= m_pGraySrc[i];
// 				pPairDefect->s_nGrayRef		= m_pGrayCmp[i];
// 				pPairDefect->s_fDefectPeak	= m_pPixelValue[i];
// 				pPairDefect->s_nZone			= m_pZoneID[i];
// 				pPairDefect->s_nThresold		= m_pZoneTh[i];
// 				m_nPair++;
// 				pPairDefect++;
// 			}
		}
		// ¿À¸¥ÂÊ ¿µ¿ª¿¡¼­ ¿ÞÂÊ¿¡ DefectÀÌ ÀÖÀ¸¸é PairingÀÌ µÈ °áÇÔÀÌ´Ù.
		else
		{
			pPairDefect->s_DefectPos		= DEFPOS_RIGHT;
			pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
			pPairDefect->s_nDefectX		= m_pPixelX[i]+ static_cast<int>(dPitchsize);	// Add Margin
			pPairDefect->s_nDefectY		= m_pPixelY[i];
			if(m_pPixelType[i] == 0)
				m_pPixelType[i]= 1;
			else
				m_pPixelType[i]= 0;
			pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[i]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
			pPairDefect->s_nGraySrc		= m_pGraySrc[i];
			pPairDefect->s_nGrayRef		= m_pGrayCmp[i];
			pPairDefect->s_fDefectPeak	= m_pPixelValue[i];
			pPairDefect->s_nZone			= m_pZoneID[i];
			pPairDefect->s_nThresold		= m_pZoneTh[i];
			m_nPair++;
			pPairDefect++;
		}
	}

	return DIT_CONV_SUCCESS;
}

DIT_RESULT CPairStorage::PairingMinus_Pixel(double dPitchsize)
{
	// -2Pitch Pairing
	// ÀÛµ¿ ¿À·ù·Î ±â´É Á¤Áö. 2011.01.12 2011.01.12
	return DIT_CONV_SUCCESS;

	// °áÇÔÀÌ Pair·Î ÀÖÀ» °æ¿ì¸¦ ó¸®. 1Pitchº¸´Ù Å©°í 2Pitchº¸´Ù ÀÛÀº °áÇÔ °ËÃâ.dPitchsize
	dPitchsize+= 0.5;
	int i, j, nLenX, nLenY;

	for(i = 0; i < m_nPair; i++)
	{
		//////////////////////////////////////////////////////////////////////////
		// CENTER
		if (m_pPairDefect[i].s_DefectPos != DEFPOS_CENTER && m_pPairDefect[i].s_DefectPos != DEFPOS_RIGHT)
			continue;

		if (m_pPairDefect[i].s_DefectPair != DEFPAIR_UNPAIR)
			continue;

		// +Pitch µ¿ÀÏÇÑ °áÇÔÀÌ ÀÖ´Â °æ¿ì, °áÇÔÀÌ ÇÇÄ¡º¸´Ù Ä¿¼­ -2Pitch¿¡ UNPAIR°¡ ÀÖ´Â °æ¿ì, ¿ø·¡ UNPAIR·Î °ËÃâµÈ °æ¿ì.
		// -nPitch ºÎÅÍ °è¼Ó °áÇÔÀÎ °æ¿ì.
		// -2Pitch ¶û ºñ±³.
		for(j = i - 1; j >= 0; j--)
		{
			nLenX = m_pPairDefect[j].s_nDefectX - (m_pPairDefect[i].s_nDefectX - static_cast<int>(dPitchsize * 2));
			nLenY = m_pPairDefect[j].s_nDefectY - m_pPairDefect[i].s_nDefectY;

			if (nLenY < 0)
				break;

			if (abs(nLenX) > 2 || nLenY > 0)
				continue;

			// -2Pitch°¡ Origin PairÀÎ °æ¿ì´Â -1Pitch¿Í -2Pitch °¡ °áÇÔ TypeÀÌ ´Ù¸£´Ù.
			if (m_pPairDefect[j].s_DefectPair == DEFPAIR_PPAIR)
			{
				if (m_pPairDefect[i].s_DefectType == m_pPairDefect[j].s_DefectType)
				{
					m_pPairDefect[i].s_DefectType = static_cast<DefectType>((m_pPairDefect[j].s_DefectType + 1) % 2);
					m_pPairDefect[i].s_nDefectX -= static_cast<int>(dPitchsize);
					m_pPairDefect[i].s_DefectPair = DEFPAIR_MPAIR;
				}
			}
			else if (m_pPairDefect[j].s_DefectPair == DEFPAIR_MPAIR)
			{
				if (m_pPairDefect[i].s_DefectType != m_pPairDefect[j].s_DefectType)
				{
					m_pPairDefect[i].s_DefectType = m_pPairDefect[j].s_DefectType;
					m_pPairDefect[i].s_nDefectX -= static_cast<int>(dPitchsize);
					m_pPairDefect[i].s_DefectPair = DEFPAIR_MPAIR;
				}
			}
		}
	}

	return DIT_CONV_SUCCESS;
}

DIT_RESULT	CPairStorage::PairingMinus_Vert(double dPitchsize)
{
	// °áÇÔÀÌ Pair·Î ÀÖÀ» °æ¿ì¸¦ ó¸®. 1Pitchº¸´Ù Å©°í 2Pitchº¸´Ù ÀÛÀº °áÇÔ °ËÃâ.dPitchsize
	// ÀÛµ¿ ¿À·ù·Î ±â´É Á¤Áö. 2011.01.12
	return DIT_CONV_SUCCESS;
	dPitchsize+= 0.5;
	int i, j, nLenX, nLenY;

	for(i = 0; i < m_nPair; i++)
	{
		//////////////////////////////////////////////////////////////////////////
		// CENTER
		if (m_pPairDefect[i].s_DefectPos != DEFPOS_CENTER && m_pPairDefect[i].s_DefectPos != DEFPOS_RIGHT)
			continue;

		if (m_pPairDefect[i].s_DefectPair != DEFPAIR_UNPAIR)
			continue;

		// +Pitch µ¿ÀÏÇÑ °áÇÔÀÌ ÀÖ´Â °æ¿ì, °áÇÔÀÌ ÇÇÄ¡º¸´Ù Ä¿¼­ -2Pitch¿¡ UNPAIR°¡ ÀÖ´Â °æ¿ì, ¿ø·¡ UNPAIR·Î °ËÃâµÈ °æ¿ì.
		// -nPitch ºÎÅÍ °è¼Ó °áÇÔÀÎ °æ¿ì.
		// -2Pitch ¶û ºñ±³.
		for(j = i - 1; j >= 0; j--)
		{
			nLenX = m_pPairDefect[j].s_nDefectX - m_pPairDefect[i].s_nDefectX ;
			nLenY = m_pPairDefect[j].s_nDefectY - (m_pPairDefect[i].s_nDefectY- static_cast<int>(dPitchsize * 2));

			//	if (nLenX < 0)
			//		break;

			if (abs(nLenY) > 2 || nLenX > 0)
				continue;

			// -2Pitch°¡ Origin PairÀÎ °æ¿ì´Â -1Pitch¿Í -2Pitch °¡ °áÇÔ TypeÀÌ ´Ù¸£´Ù.
			if (m_pPairDefect[j].s_DefectPair == DEFPAIR_PPAIR)
			{
				if (m_pPairDefect[i].s_DefectType == m_pPairDefect[j].s_DefectType)
				{
					m_pPairDefect[i].s_DefectType = static_cast<DefectType>((m_pPairDefect[j].s_DefectType + 1) % 2);
					m_pPairDefect[i].s_nDefectY -= static_cast<int>(dPitchsize);
					m_pPairDefect[i].s_DefectPair = DEFPAIR_MPAIR;
				}
			}
			else if (m_pPairDefect[j].s_DefectPair == DEFPAIR_MPAIR)
			{
				if (m_pPairDefect[i].s_DefectType != m_pPairDefect[j].s_DefectType)
				{
					m_pPairDefect[i].s_DefectType = m_pPairDefect[j].s_DefectType;
					m_pPairDefect[i].s_nDefectY -= static_cast<int>(dPitchsize);
					m_pPairDefect[i].s_DefectPair = DEFPAIR_MPAIR;
				}
			}
		}
	}

	return DIT_CONV_SUCCESS;
}

DIT_RESULT	CPairStorage::PairingPlus_Vert(double dPitchsize)
{	
	//////////////////////////////////////////////////////////////////////////
	//MMX¿¡¼­ thresholding±îÁöÇÏ°í ³ª¿À´Â °áÇÔÀÇ pointÁ¤º¸´Â pair·Î ³ª¿À¹Ç·Î 
	//½ÇÁ¦ ÇÑ°³ÀÇ pointÁ¤º¸¸¦ °Å¸£´Â °úÁ¤ÀÌ ÇÊ¿äÇÏ´Ù.
	dPitchsize+=0.5;
	int i, j, nLenY;
	BOOL ignore = FALSE;
	int top,bottom;
	top= m_Param.s_RectConv.top+ static_cast<LONG>(dPitchsize);
	bottom= m_Param.s_RectConv.bottom- static_cast<LONG>(dPitchsize);
	CDefectPair *pPairDefect= m_pPairDefect+m_nPair;	

	for(i = 0; i < m_nPixel; i++)
	{
		if (m_pPixelType[i] == DEFTYPE_DELETE || m_pPixelType[i] == DEFTYPE_NODEFECT)
			continue;

		// ¿ÞÂÊ °Ë»ç ¿µ¿ª ¿¹¿Üó¸®.
		ignore = FALSE;
		if (m_pPixelY[i] < top)
		{
			// °æ°è¿¡¼­ÀÇ Paring °Ë»ç.
			for(j = i + 1; j < m_nPixel; j++)
			{
				if (m_pPixelType[j] == DEFTYPE_DELETE || m_pPixelType[j] == DEFTYPE_NODEFECT)
					continue;						
				if (m_pPixelType[i] == m_pPixelType[j])
					continue;
				if(m_pPixelX[j] != m_pPixelX[i])
					continue;
				nLenY = m_pPixelY[j] - (m_pPixelY[i] + static_cast<int>(dPitchsize));				
				if(nLenY != 0)//if (nLenY > 1 || nLenY < -1)
					continue;

				// ÇÑ ÇÇÄ¡ ¾Æ·¡ÂÊ¿¡ °áÇÔÀÌ ÀÖ´Â °æ¿ì DEFPOS_LEFT_PAIR·Î ÆÇÁ¤
				pPairDefect->s_DefectPos		= DEFPOS_LEFT;
				pPairDefect->s_DefectPair		= DEFPAIR_PPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[j];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[j];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[j]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0						


				m_pPixelType[j] = DEFTYPE_DELETE;	// ÇÇÄ¡ ¿À¸¥ÂÊ °áÇÔÀº ´õÀÌ»ó »ý°¢ÇÒ ÇÊ¿äµµ ¾ø´Ù.
				m_nPair++;
				pPairDefect++;

				ignore = TRUE;
				break;
			}
			if (ignore == FALSE)		// Pair °¡ ¾Æ´Ñ °æ¿ì DEFPOS_LEFT_UNPAIR·Î ÆÇÁ¤. ÀÌÈÄ Classify¿¡¼­ ÀçÁ¶Á¤.
			{
				pPairDefect->s_DefectPos		= DEFPOS_LEFT;
				pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[i];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[i];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[i]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0

				m_nPair++;
				pPairDefect++;
			}
		}
		// °¡¿îµ¥ °Ë»ç¿µ¿ªÀÏ ¶§ ó¸®.
		else// if (m_pPixelY[i] <= bottom)
		{
			for(j = i + 1; j < m_nPixel; j++)
			{
				if (m_pPixelType[j] == DEFTYPE_DELETE || m_pPixelType[j] == DEFTYPE_NODEFECT)
					continue;			
				if (m_pPixelType[i] == m_pPixelType[j])
					continue;
				if(m_pPixelX[j] != m_pPixelX[i])
					continue;				
				nLenY = m_pPixelY[j] - (m_pPixelY[i] + static_cast<int>(dPitchsize));				
				if(nLenY != 0)//if (nLenY > 1 || nLenY < -1)
					continue;

				// ÇÑ ÇÇÄ¡ ÀÌÈÄ¿¡ µðÆåÀÌ ÀÖÀ¸¸é Pairing.
				pPairDefect->s_DefectPos		= DEFPOS_CENTER;
				pPairDefect->s_DefectPair		= DEFPAIR_PPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[j];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[j];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[j]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0

				m_pPixelType[j] = DEFTYPE_DELETE;	// ÇÇÄ¡ ¿À¸¥ÂÊ °áÇÔÀº ´õÀÌ»ó »ý°¢ÇÒ ÇÊ¿äµµ ¾ø´Ù.
				m_nPair++;
				pPairDefect++;

				ignore = TRUE;
				break;
			}
			if (ignore == FALSE)		// Pair °¡ ¾Æ´Ñ °æ¿ì.
			{
				pPairDefect->s_DefectPos		= DEFPOS_CENTER;
				pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[i];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[i];
				pPairDefect->s_DefectType		= (DefectType)m_pPixelType[i];	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0

				m_nPair++;
				pPairDefect++;
			}
		}
	}

	return DIT_CONV_SUCCESS;

}

//////////////////////////////////////////////////////////////////////////
DIT_RESULT CPairStorage::PairingPlus_Float(double dPitchsize)
{
	//////////////////////////////////////////////////////////////////////////
	//MMX¿¡¼­ thresholding±îÁöÇÏ°í ³ª¿À´Â °áÇÔÀÇ pointÁ¤º¸´Â pair·Î ³ª¿À¹Ç·Î 
	//½ÇÁ¦ ÇÑ°³ÀÇ pointÁ¤º¸¸¦ °Å¸£´Â °úÁ¤ÀÌ ÇÊ¿äÇÏ´Ù.
	int pitch= (int)(dPitchsize+ 0.5);
	dPitchsize+=0.5;
	int i, j, nLenX;
	BOOL ignore = FALSE;
	int left, right;
	left= m_Param.s_RectConv.left+ static_cast<LONG>(dPitchsize);
	right= m_Param.s_RectConv.right- static_cast<LONG>(dPitchsize * 2);
	CDefectPair *pPairDefect= m_pPairDefect+m_nPair;

	for(i = 0; i < m_nPixel; i++)
	{
		if (m_pPixelType[i] == DEFTYPE_DELETE || m_pPixelType[i] == DEFTYPE_NODEFECT)
			continue;

		// ¿ÞÂÊ °Ë»ç ¿µ¿ª ¿¹¿Üó¸®.
		ignore = FALSE;
		if (m_pPixelX[i] < left)
		{
			// °æ°è¿¡¼­ÀÇ Paring °Ë»ç.
			for(j = i + 1; j < m_nPixel; j++)
			{
				if (m_pPixelType[j] == DEFTYPE_DELETE || m_pPixelType[j] == DEFTYPE_NODEFECT)
					continue;
				if (m_pPixelY[j] != m_pPixelY[i])	// ´õÀÌ»ó ºñ±³ÇÒ ÇÊ¿ä ¾ø´Ù.
					break;
				if (m_pPixelType[i] == m_pPixelType[j])
					continue;
				nLenX = m_pPixelX[j] - (m_pPixelX[i] + static_cast<int>(dPitchsize));
				if(nLenX != 0)
					continue;
				//if (nLenX > 1 || nLenX < -1)
				//	continue;

				// ÇÑ ÇÇÄ¡ ¿À¸¥ÂÊ¿¡ °áÇÔÀÌ ÀÖ´Â °æ¿ì DEFPOS_LEFT_PAIR·Î ÆÇÁ¤
				pPairDefect->s_DefectPos	= DEFPOS_LEFT;
				pPairDefect->s_DefectPair	= DEFPAIR_PPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[j];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[j];
				pPairDefect->s_DefectType	= static_cast<DefectType>(m_pPixelType[j]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0	
				pPairDefect->s_fDefectPeak	= m_pPixelValue[j];


				m_pPixelType[j] = DEFTYPE_DELETE;	// ÇÇÄ¡ ¿À¸¥ÂÊ °áÇÔÀº ´õÀÌ»ó »ý°¢ÇÒ ÇÊ¿äµµ ¾ø´Ù.
				m_nPair++;
				pPairDefect++;

				ignore = TRUE;
				break;
			}
			if (ignore == FALSE)		// Pair °¡ ¾Æ´Ñ °æ¿ì DEFPOS_LEFT_UNPAIR·Î ÆÇÁ¤. ÀÌÈÄ Classify¿¡¼­ ÀçÁ¶Á¤.
			{
				pPairDefect->s_DefectPos		= DEFPOS_LEFT;
				pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[i];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[i];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[i]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
				pPairDefect->s_fDefectPeak	= m_pPixelValue[i];
				
				m_nPair++;
				pPairDefect++;
			}
		}
		// °¡¿îµ¥ °Ë»ç¿µ¿ªÀÏ ¶§ ó¸®.
		else if (m_pPixelX[i] <= right)
		{
			for(j = i + 1; j < m_nPixel; j++)
			{
				if (m_pPixelType[j] == DEFTYPE_DELETE || m_pPixelType[j] == DEFTYPE_NODEFECT)
					continue;
				if (m_pPixelY[j] != m_pPixelY[i])	// ´õÀÌ»ó ºñ±³ÇÒ ÇÊ¿ä ¾ø´Ù.
					break;
				if (m_pPixelType[i] == m_pPixelType[j])
					continue;
				nLenX = m_pPixelX[j] - (m_pPixelX[i] + static_cast<int>(dPitchsize));
				if(nLenX != 0)
					continue;
				if (nLenX > 1 || nLenX < -1)	// ÇÑ ÇÇÄ¡ ¿À¸¥ÂÊ¿¡ °áÇÔÀÌ ÀÖ´Â °æ¿ì DEFPOS_LEFT_PAIR·Î ÆÇÁ¤
					continue;

				// ÇÑ ÇÇÄ¡ ÀÌÈÄ¿¡ µðÆåÀÌ ÀÖÀ¸¸é Pairing.
				pPairDefect->s_DefectPos		= DEFPOS_CENTER;
				pPairDefect->s_DefectPair		= DEFPAIR_PPAIR;
				pPairDefect->s_nDefectX		= m_pPixelX[j];	// Add Margin
				pPairDefect->s_nDefectY		= m_pPixelY[j];
				pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[j]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
				pPairDefect->s_fDefectPeak	= m_pPixelValue[j];

				m_pPixelType[j] = DEFTYPE_DELETE;	// ÇÇÄ¡ ¿À¸¥ÂÊ °áÇÔÀº ´õÀÌ»ó »ý°¢ÇÒ ÇÊ¿äµµ ¾ø´Ù.
				m_nPair++;
				pPairDefect++;

				ignore = TRUE;
				break;
			}
// 			if (ignore == FALSE)		// Pair °¡ ¾Æ´Ñ °æ¿ì.
// 			{
// 				pPairDefect->s_DefectPos		= DEFPOS_CENTER;
// 				pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
// 				pPairDefect->s_nDefectX		= m_pPixelX[i];	// Add Margin
// 				pPairDefect->s_nDefectY		= m_pPixelY[i];
// 				pPairDefect->s_DefectType		= (DefectType)m_pPixelType[i];	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
// 				pPairDefect->s_fDefectPeak	= m_pPixelValue[i];
// 
// 				m_nPair++;
// 				pPairDefect++;
// 			}
		}		// ¿À¸¥ÂÊ ¿µ¿ª¿¡¼­ ¿ÞÂÊ¿¡ DefectÀÌ ÀÖÀ¸¸é PairingÀÌ µÈ °áÇÔÀÌ´Ù.
		else
		{
			pPairDefect->s_DefectPos		= DEFPOS_RIGHT;
			pPairDefect->s_DefectPair		= DEFPAIR_UNPAIR;
			pPairDefect->s_nDefectY		= m_pPixelY[i];
			pPairDefect->s_nDefectX		= m_pPixelX[i]+ pitch;	// Add Margin
			if(m_pPixelType[i] == 0)
				m_pPixelType[i]= 1;
			else
				m_pPixelType[i]= 0;
			pPairDefect->s_DefectType		= static_cast<DefectType>(m_pPixelType[i]);	//½ÇÁ¦¹é°áÇÔÀº1,Èæ°áÇÔÀº0
			pPairDefect->s_fDefectPeak	= m_pPixelValue[i];

			m_nPair++;
			pPairDefect++;
		}

	}

	return DIT_CONV_SUCCESS;
}

DIT_RESULT CPairStorage::PairingMinus_Float(double dPitchsize)
{
	// -2Pitch Pairing
	// ÀÛµ¿ ¿À·ù·Î ±â´É Á¤Áö. 2011.01.12
	return DIT_CONV_SUCCESS;

	// °áÇÔÀÌ Pair·Î ÀÖÀ» °æ¿ì¸¦ ó¸®. 1Pitchº¸´Ù Å©°í 2Pitchº¸´Ù ÀÛÀº °áÇÔ °ËÃâ.dPitchsize
	dPitchsize+= 0.5;
	int i, j, nLenX, nLenY;

	for(i = 0; i < m_nPair; i++)
	{
		//////////////////////////////////////////////////////////////////////////
		// CENTER
		if (m_pPairDefect[i].s_DefectPos != DEFPOS_CENTER && m_pPairDefect[i].s_DefectPos != DEFPOS_RIGHT)
			continue;

		if (m_pPairDefect[i].s_DefectPair != DEFPAIR_UNPAIR)
			continue;

		// +Pitch µ¿ÀÏÇÑ °áÇÔÀÌ ÀÖ´Â °æ¿ì, °áÇÔÀÌ ÇÇÄ¡º¸´Ù Ä¿¼­ -2Pitch¿¡ UNPAIR°¡ ÀÖ´Â °æ¿ì, ¿ø·¡ UNPAIR·Î °ËÃâµÈ °æ¿ì.
		// -nPitch ºÎÅÍ °è¼Ó °áÇÔÀÎ °æ¿ì.
		// -2Pitch ¶û ºñ±³.
		for(j = i - 1; j >= 0; j--)
		{
			nLenX = m_pPairDefect[j].s_nDefectX - (m_pPairDefect[i].s_nDefectX - static_cast<int>(dPitchsize * 2));
			nLenY = m_pPairDefect[j].s_nDefectY - m_pPairDefect[i].s_nDefectY;

			if (nLenY < 0)
				break;

			if (abs(nLenX) > 2 || nLenY > 0)
				continue;

			// -2Pitch°¡ Origin PairÀÎ °æ¿ì´Â -1Pitch¿Í -2Pitch °¡ °áÇÔ TypeÀÌ ´Ù¸£´Ù.
			if (m_pPairDefect[j].s_DefectPair == DEFPAIR_PPAIR)
			{
				if (m_pPairDefect[i].s_DefectType == m_pPairDefect[j].s_DefectType)
				{
					m_pPairDefect[i].s_DefectType = static_cast<DefectType>((m_pPairDefect[j].s_DefectType + 1) % 2);
					m_pPairDefect[i].s_nDefectX -= static_cast<int>(dPitchsize);
					m_pPairDefect[i].s_DefectPair = DEFPAIR_MPAIR;
				}
			}
			else if (m_pPairDefect[j].s_DefectPair == DEFPAIR_MPAIR)
			{
				if (m_pPairDefect[i].s_DefectType != m_pPairDefect[j].s_DefectType)
				{
					m_pPairDefect[i].s_DefectType = m_pPairDefect[j].s_DefectType;
					m_pPairDefect[i].s_nDefectX -= static_cast<int>(dPitchsize);
					m_pPairDefect[i].s_DefectPair = DEFPAIR_MPAIR;
				}
			}
		}
	}

	return DIT_CONV_SUCCESS;
}