//==================================================================================
// DIPM.h : Declaration of DIPM
//==================================================================================

#ifndef __EDGE_DIPM__
#define __EDGE_DIPM__

//#include "stdafx.h"
#include "cv.h"
#include "highgui.h"
#include "opencv.hpp"
#include "core.hpp"
#include <math.h>
#include <map>
#include <list>
#include <vector>

//Define DLL IM/EXPORTs

#ifndef DLLEXPORT
#define DLLEXPORT		__declspec(dllexport)
#endif

#ifndef DLLIMPORT
#define DLLIMPORT		__declspec(dllimport)
#endif

////////////////////////////////////////////////////////////////////////////////////
// MACRO definitions

#define align_4byte(in) ((in + 3)/4)*4

// Memory allocation MACRO for compatible with windows SDK
#define memalloc(flags, cb)		(GlobalLock(GlobalAlloc((flags),(cb))))
#define memfree(lp)	\
		(GlobalUnlock((HGLOBAL)GlobalHandle(lp)),(BOOL)GlobalFree((HGLOBAL)GlobalHandle(lp)))

////////////////////////////////////////////////////////////////////////////////////
// Constant definitions

#define ROUND(a)				(a+0.5)
#define FLOOR(a)				(a)

// Numerical MACRO's
#define	M_PI					acos(-1.0)
#define M_RADIAN(x)				(((M_PI)*(x))/180.0)
#define M_DEGREE(x)				(((180.0)*(x))/M_PI)

#ifndef RANGEIN
#define RANGEIN(a, r1, r2)		(((a>=r1)&&(a<=r2)) ? (1) : (0))
#endif

// Logical MACRO's
#define MINIMUM(a, b)			((a)<(b) ? (a) : (b))
#define MAXIMUM(a, b)			((a)>(b) ? (a) : (b))
#define MIDDLE(a, b, c)			(((a>b)&&(a<c)) ? (1) : (0))

enum	enGradientMask{GM_Sobel, GM_Prewitt, GM_Roberts};

struct sPoint {
	double x, y;
};

struct sLine {
	double mx, my;
	double sx, sy;
};

typedef struct rtiTEMP_RESULT
{
	float		 fRat;
	CvPoint2D32f pt;
}TEMP_RESULT;

typedef  struct _rtiTEMP_MATCH_DATA
{
	double dMaxRate;
	double dMinRate;
	double dPt_X;
	double dPt_Y;

	_rtiTEMP_MATCH_DATA(void)
	{
		dMaxRate = 0.0;
		dMinRate = 0.0;
		dPt_X = 0.0;
		dPt_Y = 0.0;
	}
}TEMP_MATCH_DATA;

enum ChipPair	{CHIPDEFPAIR_NOTDEFINE = 0, CHIPDEFPAIR_PPAIR, CHIPDEFPAIR_MPAIR, CHIPDEFPAIR_SIDE, CHIPDEFPAIR_LARGE, CHIPDEFPAIR_UNPAIR };
enum ChipType	{CHIPDEFTYPE_BLACK = 0, CHIPDEFTYPE_WHITE, CHIPDEFTYPE_MIXED, CHIPDEFTYPE_NODEFECT, CHIPDEFTYPE_DELETE};
enum ChipResionType	{CHIPREGTYPE_LEFT = 0, CHIPREGTYPE_RIGHT, CHIPREGTYPE_RIGHT_WHITE, CHIPREGTYPE_NONE};
enum DefectPosType	{INS_DEFECT_CRACK = 0, INS_DEFECT_BROKEN, INS_DEFECT_CHIP, INS_DEFECT_CHAMFER,INS_DEFECT_BURR,INS_DEFECT_NONE};
enum ChipPosType	{CHIPPOSTYPE_BIN = 0, CHIPPOSTYPE_CEN, CHIPPOSTYPE_SP,CHIPPOSTYPE_NONE};

// Directional information
#define IM_NEGATIVE				101
#define IM_POSITIVE				102
#define IM_HORIZONTAL			103
#define IM_VERTICAL				104
#define IM_LEFT					105
#define IM_RIGHT				106

//Gray level
#define IM_BLACK				0
#define IM_WHITE				255

//Image
#ifndef _IMAGE_
#define _IMAGE_
typedef struct ImImage {
	unsigned char	*buf;
	int	cu;
	int	cv;
} IMAGE;
#endif

//Position in 2D
#ifndef _IMPOS2D_
#define _IMPOS2D_
typedef struct ImPos2D {
	double		u;
	double		v;
} IMPOS2D;
#endif

//Region of interest (ROI)
#ifndef _ROI_
#define _ROI_
typedef struct ImRoi {
	int	u1;
	int	v1;
	int	u2;
	int	v2;
} ROI, *LPROI;
#endif

class CChipBlob
{
public:	
	ChipResionType	s_RegionType;
	ChipPair	s_DefectPair;
	ChipType	s_DefectType;
	ChipPosType	s_DefectPosType;
	DefectPosType s_DefectJudgeType;
	int			s_nIndex;
	int			s_nDefectArea;
	int			s_nDefectX;
	int			s_nDefectY;
	int			s_xLevelSrcMax;
	int			s_yLevelSrcMax;
	int			s_nDefectRScale;
	CRect		s_DefectRect;
	short		s_sDefectPeak;

	short		s_sLevelSrcMin;
	short		s_sLevelSrcMax;
	short		s_sLevelSrcAvg;
	short		s_sLevelRefMin;
	short		s_sLevelRefMax;
	short		s_sLevelRefAvg;
	short		s_sLevelDiffMin;
	short		s_sLevelDiffMax;
	short		s_sLevelDiffAvg;
	int			s_nLevelSrcSum;
	int			s_nLevelRefSum;
	int			s_nLevelDiffSum;
	short		s_sThreshold;	
	BOOL		s_bRemoved;
	double		s_dThick;
	BOOL		s_bCornerChip;

	CPoint		s_ptVertex[8];

	CChipBlob()
	{
		Reset();
	}
	void Reset()
	{		
		s_RegionType		= CHIPREGTYPE_NONE;
		s_DefectPair		= CHIPDEFPAIR_NOTDEFINE;
		s_DefectType		= CHIPDEFTYPE_NODEFECT;
		s_DefectJudgeType   = INS_DEFECT_NONE;
		s_nIndex			= 0;
		s_nDefectArea		= 0;
		s_nDefectX			= 0;
		s_nDefectY			= 0;
		s_nDefectRScale		= 0;
		// 20080525 ÀÌÁØÈñ
		s_DefectRect.SetRect(INT_MAX, INT_MAX, 0, 0);
		s_sDefectPeak		= 0;

		s_sLevelSrcMin		= 2048;
		s_sLevelSrcMax		= 0;
		s_xLevelSrcMax		= 0;
		s_yLevelSrcMax		= 0;
		s_sLevelSrcAvg		= 0;
		s_sLevelRefMin		= 2048;
		s_sLevelRefMax		= 0;
		s_sLevelRefAvg		= 0;
		s_sLevelDiffMin		= 2048;
		s_sLevelDiffMax		= 0;
		s_sLevelDiffAvg		= 0;
		s_nLevelSrcSum		= 0;	
		s_nLevelRefSum		= 0;
		s_nLevelDiffSum		= 0;

		s_sThreshold		= 0;
		s_dThick			= 0.;
		s_bCornerChip		= FALSE;

		// 20080525 ÀÌÁØÈñ
		s_ptVertex[0]		= MAKELONG(32760, 32760);
		s_ptVertex[1]		= MAKELONG(32760, 0);
		s_ptVertex[2]		= MAKELONG(32760, 32760);
		s_ptVertex[3]		= MAKELONG(0, 32760);
		s_ptVertex[4]		= MAKELONG(0, 32760);
		s_ptVertex[5]		= MAKELONG(0, 0);
		s_ptVertex[6]		= MAKELONG(32760, 0);
		s_ptVertex[7]		= MAKELONG(0, 0);

		s_bRemoved			= FALSE;
	}

	void SetDefectPair(ChipPair DP)
	{
		if (s_DefectPair < DP)
			s_DefectPair = DP;
	}

	// ´ëÀÔ¿¬»êÀÚ ¿À¹ö·Îµù.
	CChipBlob& operator=(const CChipBlob& rhs)
	{
		if(this != &rhs)
		{			
			s_RegionType		= rhs.s_RegionType;
			s_DefectPair		= rhs.s_DefectPair;
			s_DefectType		= rhs.s_DefectType;
			s_DefectJudgeType	= rhs.s_DefectJudgeType;
			s_nIndex			= rhs.s_nIndex;
			s_nDefectArea		= rhs.s_nDefectArea;
			s_nDefectX			= rhs.s_nDefectX;
			s_nDefectY			= rhs.s_nDefectY;
			s_nDefectRScale		= rhs.s_nDefectRScale;
			s_DefectRect		= rhs.s_DefectRect;
			s_sDefectPeak		= rhs.s_sDefectPeak;

			s_sLevelSrcMin		= rhs.s_sLevelSrcMin;
			s_sLevelSrcMax		= rhs.s_sLevelSrcMax;
			s_xLevelSrcMax		= rhs.s_xLevelSrcMax;
			s_yLevelSrcMax		= rhs.s_yLevelSrcMax;
			s_sLevelSrcAvg		= rhs.s_sLevelSrcAvg;
			s_sLevelRefMin		= rhs.s_sLevelRefMin;
			s_sLevelRefMax		= rhs.s_sLevelRefMax;
			s_sLevelRefAvg		= rhs.s_sLevelRefAvg;
			s_sLevelDiffMin		= rhs.s_sLevelDiffMin;
			s_sLevelDiffMax		= rhs.s_sLevelDiffMax;
			s_sLevelDiffAvg		= rhs.s_sLevelDiffAvg;
			s_nLevelSrcSum		= rhs.s_nLevelSrcSum;
			s_nLevelRefSum		= rhs.s_nLevelRefSum;
			s_nLevelDiffSum		= rhs.s_nLevelDiffSum;

			s_sThreshold		= rhs.s_sThreshold;
			s_dThick			= rhs.s_dThick;
			s_bCornerChip		= rhs.s_bCornerChip;

			int i;
			for(i= 0; i< 8; i++)
			{
				s_ptVertex[i]= rhs.s_ptVertex[i];
			}		
			s_bRemoved			= rhs.s_bRemoved;
		}
		return *this;
	}

	// + ¿¬»êÀÚ ¿À¹ö·Îµù.
	CChipBlob operator+(const CChipBlob& rhs)
	{
		if (s_DefectPair < rhs.s_DefectPair)
			s_DefectPair = rhs.s_DefectPair;

		s_nDefectArea += rhs.s_nDefectArea;

		if (s_ptVertex[0].x >= rhs.s_ptVertex[0].x)	// LT
			s_ptVertex[0] = rhs.s_ptVertex[0];
		if (s_ptVertex[1].x >= rhs.s_ptVertex[1].x)	// LB
			s_ptVertex[1] = rhs.s_ptVertex[1];
		if (s_ptVertex[2].y >= rhs.s_ptVertex[2].y)	// TL
			s_ptVertex[2] = rhs.s_ptVertex[2];
		if (s_ptVertex[3].y >= rhs.s_ptVertex[3].y)	// TR
			s_ptVertex[3] = rhs.s_ptVertex[3];
		if (s_ptVertex[4].x <= rhs.s_ptVertex[4].x)	// RT
			s_ptVertex[4] = rhs.s_ptVertex[4];
		if (s_ptVertex[5].x <= rhs.s_ptVertex[5].x)	// RB
			s_ptVertex[5] = rhs.s_ptVertex[5];
		if (s_ptVertex[6].y <= rhs.s_ptVertex[6].y)	// BL
			s_ptVertex[6] = rhs.s_ptVertex[6];
		if (s_ptVertex[7].y <= rhs.s_ptVertex[7].y)	// BR
			s_ptVertex[7] = rhs.s_ptVertex[7];

		s_nDefectRScale = (s_nDefectRScale + rhs.s_nDefectRScale);
		if (s_DefectRect.left > rhs.s_DefectRect.left)
			s_DefectRect.left = rhs.s_DefectRect.left;
		if (s_DefectRect.top > rhs.s_DefectRect.top)
			s_DefectRect.top = rhs.s_DefectRect.top;
		if (s_DefectRect.right < rhs.s_DefectRect.right)
			s_DefectRect.right = rhs.s_DefectRect.right;
		if (s_DefectRect.bottom < rhs.s_DefectRect.bottom)
			s_DefectRect.bottom = rhs.s_DefectRect.bottom;
		if (s_sDefectPeak < rhs.s_sDefectPeak)
			s_sDefectPeak		= rhs.s_sDefectPeak;

		s_nDefectX = (s_DefectRect.right + s_DefectRect.left) / 2;
		s_nDefectY = (s_DefectRect.bottom + s_DefectRect.top) / 2;

		if (s_sLevelSrcMin > rhs.s_sLevelSrcMin)
			s_sLevelSrcMin		= rhs.s_sLevelSrcMin;
		if (s_sLevelSrcMax < rhs.s_sLevelSrcMax)
		{
			s_sLevelSrcMax		= rhs.s_sLevelSrcMax;
			s_xLevelSrcMax		= rhs.s_xLevelSrcMax;
			s_yLevelSrcMax		= rhs.s_yLevelSrcMax;
		}
		s_sLevelSrcAvg			= (s_sLevelSrcAvg + rhs.s_sLevelSrcAvg) / 2;
		if (s_sLevelRefMin > rhs.s_sLevelRefMin)
			s_sLevelRefMin		= rhs.s_sLevelRefMin;
		if (s_sLevelRefMax < rhs.s_sLevelRefMax)
			s_sLevelRefMax		= rhs.s_sLevelRefMax;
		s_sLevelRefAvg			= (s_sLevelRefAvg + rhs.s_sLevelRefAvg) / 2;
		if (s_sLevelDiffMin > rhs.s_sLevelDiffMin)
			s_sLevelDiffMin		= rhs.s_sLevelDiffMin;
		if (s_sLevelDiffMax < rhs.s_sLevelDiffMax)
			s_sLevelDiffMax		= rhs.s_sLevelDiffMax;
		s_sLevelDiffAvg			= (s_sLevelDiffAvg + rhs.s_sLevelDiffAvg) / 2;
		s_nLevelSrcSum		+= rhs.s_nLevelSrcSum;
		s_nLevelRefSum		+= rhs.s_nLevelRefSum;
		s_nLevelDiffSum		+= rhs.s_nLevelDiffSum;

		if (s_sThreshold < rhs.s_sThreshold)
			s_sThreshold		= rhs.s_sThreshold;

		if(s_dThick < rhs.s_dThick)
			s_dThick = rhs.s_dThick;

		s_bCornerChip			|= rhs.s_bCornerChip;

		return *this;
	}

};

class CChipPair
{
public:		
	ChipPair	s_DefectPair;
	ChipType	s_DefectType;
	ChipResionType	s_RegionType;
	DefectPosType	s_DefectPosType;
	float		s_fDefectPeak;
	int			s_nDefectX;
	int			s_nDefectY;
	int			s_nGraySrc;
	int			s_nGrayRef;	
	double		s_dThick;
	BOOL		s_bCornerChip;

	CChipPair()
	{
		Reset();
	}
	void Reset()
	{		
		s_DefectPair = CHIPDEFPAIR_NOTDEFINE;
		s_DefectType = CHIPDEFTYPE_NODEFECT;
		s_RegionType = CHIPREGTYPE_NONE;
		s_DefectPosType = INS_DEFECT_NONE;
		s_fDefectPeak = 0.0;
		s_nDefectX = 0;
		s_nDefectY = 0;
		s_nGraySrc = 0;
		s_nGrayRef = 0;
		s_dThick = 0.;
		s_bCornerChip = FALSE;
	}
	void SetPeak(int nPeak, int nKernelThres, int nCalcPixel)
	{
		s_fDefectPeak= static_cast<float>(abs(nPeak));
		s_fDefectPeak -= static_cast<float>(nKernelThres);
		s_fDefectPeak /= static_cast<float>(nCalcPixel);
	}

	// º¹»ç »ý¼ºÀÚ.
	CChipPair(const CChipPair& rhs)
	{
		if(this != &rhs)
		{		
			s_DefectPair		= rhs.s_DefectPair;
			s_DefectType		= rhs.s_DefectType;
			s_fDefectPeak		= rhs.s_fDefectPeak;
			s_nDefectX			= rhs.s_nDefectX;
			s_nDefectY			= rhs.s_nDefectY;
			s_nGraySrc			= rhs.s_nGraySrc;
			s_nGrayRef			= rhs.s_nGrayRef;	
			s_RegionType		= rhs.s_RegionType;	
			s_dThick			= rhs.s_dThick;	
			s_bCornerChip		= rhs.s_bCornerChip;
			s_DefectPosType		= rhs.s_DefectPosType;
		}
	}

	// ´ëÀÔ¿¬»êÀÚ ¿À¹ö·Îµù.
	CChipPair& operator=(const CChipPair& rhs)
	{
		if(this != &rhs)
		{		
			s_DefectPair		= rhs.s_DefectPair;
			s_DefectType		= rhs.s_DefectType;
			s_fDefectPeak		= rhs.s_fDefectPeak;
			s_nDefectX			= rhs.s_nDefectX;
			s_nDefectY			= rhs.s_nDefectY;
			s_nGraySrc			= rhs.s_nGraySrc;
			s_nGrayRef			= rhs.s_nGrayRef;
			s_RegionType		= rhs.s_RegionType;	
			s_dThick			= rhs.s_dThick;
			s_bCornerChip		= rhs.s_bCornerChip;
		}
		return *this;
	}
};

#endif

// End of FV_DIPM.h
////////////////////////////////////////////////////////////////////////////////////