#pragma once

#include "RANSAC_LineFittingAlgorithm.h"
#include "EdgeProc.h"
#include "EdgeFind.h"
#include "ChamferInspect.h"
#include <map>
#include <vector>

using namespace std;

enum	SPLINE_ERR_MSG{ERR_SPLINE_EMPTYMASTER=1,ERR_SPLINE_EDGEPROCESS,ERR_SPLINE_LABELPROCESS,ERR_SPLINE_LABELCOUNT,ERR_SPLINE_INDEXFIND
,ERR_SPLINE_LABELPOSITION,ERR_SPLINE_POSITIONNULL,ERR_SPLINE_INS_CNT_SHORT,ERR_SPLINE_IMAGE_NULL,ERR_SPLINE_IMAGE_NULL_02
,ERR_SPLINE_IMAGE_NULL_03,SPLINE_INS_SUCESS};

#define MAX_SPLINE_DEFECT_COUNT		1000

class CSplinePoint
{
public:
	CSplinePoint()		{ Reset(); }	
	void Reset()
	{
		origin = rotate = CPoint(0,0);		
		dThick = dTheta = 0.;
		bFind = FALSE;
	}

	CPoint	origin;
	CPoint	rotate;
	double	dThick;
	double	dTheta;
	BOOL	bFind;
};

class CImagePoint
{
public:
	CImagePoint()		{ Reset(); }	
	void Reset()
	{
		imgPos = originPos = CPoint(0,0);	
		dTheta = 0.;
		nInsWidth = 0;
	}

	CPoint	imgPos;
	CPoint	originPos;
	double	dTheta;
	int		nInsWidth;
};

class CResultDefect
{
public:
	CResultDefect()		{ Reset(); }	
	void Reset()
	{
		dThick = 0.;
		rectDefect = CRect(0,0,0,0);
	}

	CRect		rectDefect;
	double		dThick;
};

class CDetectPoint
{
public:
	CDetectPoint()		{ Reset(); }	
	void Reset()
	{
		orgX = orgY = 0.;
		imgX = imgY = 0.;
		dTheta = dDist = 0.;
		bFind = FALSE;
	}

	double	orgX,orgY;
	double	imgX,imgY;
	double	dTheta;
	double	dDist;
	BOOL    bFind;
};

struct SortOrginYPos : public std::binary_function<pair<int,CSplinePoint>, pair<int,CSplinePoint>, bool>
{
	bool operator()(const pair<int,CSplinePoint> & lhs, const pair<int,CSplinePoint> & rhs)
	{
		return lhs.second.origin.y > rhs.second.origin.y;
	}
};

enum SPLINECHIP_INS_METHOD{METHOD_INS_LINE=0,METHOD_INT_ROUND};
enum MAKE_IMAGE_METHOD{MAKE_METHOD_LINEAR=0,MAKE_METHOD_REGRESSION,MAKE_METHOD_NONE};
enum SPLINE_INS_DIR{SPLINE_INS_DIRECTION_X=0,SPLINE_INS_DIRECTION_Y,SPLINE_INS_DIRECTION_NONE};

typedef struct  _CHIP_INS_REGION
{
public:
	_CHIP_INS_REGION()		{ Reset(); }	
	void Reset()
	{
		bUse = FALSE;
		nStartX = nEndX = nThres = nFindThres = nSkipDist = nInsRange = 0;
		emMethod = MAKE_METHOD_NONE;
		emDir = SPLINE_INS_DIRECTION_NONE;
		nCornerYSize = -1;
	}

	BOOL		bUse;
	int			nStartX;
	int			nEndX;
	int			nCornerYSize;
	int			nThres;
	int			nFindThres;
	int			nSkipDist;
	int			nInsRange;
	MAKE_IMAGE_METHOD emMethod;
	SPLINE_INS_DIR	emDir;
}CHIP_INS_REGION;

#define		SPLINE_RESULT_DATA_CNT  2
#define		SPLINE_RANGE_RESULT_CNT 5

class AFX_EXT_CLASS CSplineModel
{
public:
	CSplineModel(void);		
	virtual ~CSplineModel(void);

public:
	BOOL		CopyModelData(CSplineModel *pSpline);
	BOOL		WriteModelData(CString strFile,CString strRecipe,CString strCut,std::multimap<int, CSplinePoint> *pPoint,CPoint pointOffset);
	BOOL		WriteCSVData(CString strFile,CPoint *pPoint,int nCnt,CPoint pointOffset);
	BOOL		ReadModelData(CString strFile,CString strRecipe);
	BOOL		IsLoadMasterImg(){return m_bLoadMasterImg;}
	CString		GetLoadModelRecipe(){return m_strLoadModel;}
	CSize		GetMasterDataSize(){return CSize(m_pointMasterMax.x,m_pointMasterMax.y);}
	std::multimap<int, CPoint> *GetMasterData(){return &m_mapMasterPos;}
	CPoint		GetptMasterMax(){return m_pointMasterMax;}
	CPoint		GetptMasterMin(){return m_pointMasterMin;}
	void		ClearModelData();

protected:
	BOOL		AdjustTilt(std::multimap<int, CSplinePoint> *pPos);
	double		GetTilt(std::multimap<int, CSplinePoint> *pPos,double &dCenX,double &dCenY);	

protected:
	BOOL		m_bLoadMasterImg;
	CString		m_strLoadModel;
	CPoint		m_pointMasterMax,m_pointMasterMin;	
	std::multimap<int, CPoint> m_mapMasterPos;	
};

class CSISBuffer;
class AFX_EXT_CLASS CSplineInspect
{
public:
	CSplineInspect(void);	
	CSplineInspect(CSISBuffer *lpBuffer);
	virtual ~CSplineInspect(void);

public:
	SPLINE_ERR_MSG	InspectSpline(CSISBuffer &pImg,CRect &rectCrop,int nDetDist,int nThres,BOOL bFlip,BOOL bSaveImg,BOOL bSaveDebug);
	double			InspectSplineChip(CSISBuffer pImg,int nPosLeft,CHIP_INS_REGION &insRegion,double dRes,int nJudgeThick,COwnerBuffer &pRes
		,BOOL bFlip,int iReg,BOOL bSaveDebug,SPLINECHIP_INS_METHOD enOpt=METHOD_INT_ROUND);

	// ¼öÁ¤ ¹öÀü
	double			InspectSplineChip_New(CSISBuffer pImg,int nPosLeft,CHIP_INS_REGION &insRegion,double dRes,int nJudgeThick
		,BOOL bFlip,int iReg,BOOL bSaveDebug,SPLINECHIP_INS_METHOD enOpt=METHOD_INT_ROUND);
	int			InspectChipBin_New(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns);
	BOOL		Blob_OpenCV(CSISBuffer* pOriginImg, COwnerBuffer* pBinImage, CRect rtInsRect, std::vector<CChipBlob>* vecBlobList, ChipResionType s_RegionType,DefectPosType s_DefectPos, int nMinSize, int nSideFilter, BOOL bROIOffset=TRUE);
	int			FilteringDefect_New(CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns,double dRes,int nJudge,CRect &insRect,BOOL bFlip);

public:	
	CChipBlob	*GetResultDefect(){return m_ResultDefect;}
	int			GetResultDefectCount(){return m_nDefectCount;}
	double		*GetResultData(){return m_dResultData;}	
	double		*GetRangeData(){return m_dRangeResult;}
	CSISBuffer	*GetSplineOrgImg(){return (CSISBuffer*)&m_insSplineOrg;}
	CSISBuffer	*GetSplineResImg(){return (CSISBuffer*)&m_insSplineRes;}

	BOOL		FindCADLine();
	BOOL		LabelingProcess();
	BOOL		LabelingCounting();
	BOOL		LabelFiltering(int nFilterCnt);
	int			GetRectInLabelMaxIndex(CRect &rect);
	BOOL		GetLabelPosition(int nIdx);
	std::multimap<int, CSplinePoint>	*GetSplinePos(){return &m_mapSplinePos;}
	CPoint		GetSplineOffset(){return CPoint(m_nSplineOffsetX,m_nSplineOffsetY);}
	BOOL		CheckBuffer();
	BOOL		CheckRange(int x,int y,CSISBuffer *buffer);	
	void		ContourTracing(int cy, int cx, int labelindex, int tracingdirection);
	BOOL		CheckRectToBuffer(CRect &rect);
	BOOL		Tracer(int *cy, int *cx, int *tracingdirection);
	void		ReleaseBuffer();
	BOOL		SetImage(CSISBuffer *lpBuffer);
	void		SetMasterModelData(CSplineModel *pMaster){m_pSpModel=pMaster;}

protected:
	void		ReleaseBlob();
	void		ResetValue();	
	BOOL		FindForeLine(CSISBuffer &pBuffer,int *nForeLine,double &dTheta);
	BOOL		ShiftNRotateImage(CSISBuffer pOrg,CSISBuffer pBin,COwnerBuffer &pProcess,COwnerBuffer &pProcImg,int *nForeLine,double dTheta,CPoint &pPosImg);
	BOOL		DistInspection(CEdgeProc &EdgeProc,CSISBuffer &pTgt,double *dResult,double *dRangeRes);
	int			GetSplineValue(CEdgeProc &glassFind,CSISBuffer pOrg,double dXPos,double dYPos);	
	void		MakeSplineResultImage(COwnerBuffer &pRes,CSISBuffer &pProcess);
	BOOL		AdjustTilt(std::multimap<int, CSplinePoint> *pPos);
	double		GetTilt(std::multimap<int, CSplinePoint> *pPos,double &dCenX,double &dCenY);	

protected:
	BOOL		CopyRectImg(LPBYTE pOrg,LPBYTE pTgt,CSize szImg,CRect &rectIns);
	BOOL		MakeCADLine(CHIP_INS_REGION & insRegion,std::multimap<int, CPoint> &mapData,CPoint &pointMin,CPoint &pointMax,SPLINECHIP_INS_METHOD enOpt=METHOD_INT_ROUND);
	double		GetCAD2ImgOffset(std::multimap<int, CPoint> &mapData,CSISBuffer pBin,CPoint pointMin,CPoint pointMax,int nGap=30);
	void		MakeInspectResultImage(CSISBuffer &pRes,std::multimap<int, CSplinePoint> &mapIns);
	void		MakeInspectResultImage(CSISBuffer &pRes,std::multimap<int, CPoint> &mapIns);
	void		MakeSplineDebugImg(COwnerBuffer &pRes,std::multimap<int, CPoint> *pMaster,std::multimap<int, CSplinePoint> *pData);	
	BOOL		MakeInspectLine(std::multimap<int, CPoint> &mapData,std::multimap<int, CSplinePoint> &mapIns,double dYPos,SPLINECHIP_INS_METHOD enOpt=METHOD_INT_ROUND);	
	double		InspectChip(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns);
	int			InspectChipBin(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns);
	int			InspectChipBin_Diagonal(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns);

	int			FilteringDefect(CHIP_INS_REGION &insRegion,std::multimap<int, CSplinePoint> &mapIns,double dRes,int nJudge,CRect &insRect,BOOL bFlip);
	double		FindThick(CEdgeProc &EdgeProc,CSISBuffer pOrg,CRect &insRect,CPoint pointSet,CPoint &pointRotate,double dTheta,int nDetThres);
	int			AnalysisThick(CEdgeProc &EdgeProc,CRect rectImg,double dRes,int nJudgeThick,double dAvgThick,BOOL bFlip,std::multimap<int, CSplinePoint> &mapIns);	

public:		
	double		m_dImageTheta;
	CPoint		m_pointPosLeft;
	CPoint		m_pointDiffImg;	
	CSplineModel	*m_pSpModel;
	std::multimap<int, CSplinePoint> m_mapSplinePos;
	CChipBlob	m_ResultDefect[MAX_SPLINE_DEFECT_COUNT];
	double		m_dRangeResult[SPLINE_RANGE_RESULT_CNT];
	int			m_nDefectCount;
	CSize			m_szImageOrg;
	double		m_dResultData[SPLINE_RESULT_DATA_CNT];	
	COwnerBuffer	m_insSplineOrg,m_insSplineRes;
	CChamferInspect		m_ChamferIns;
	
	int				m_nSplineOffsetX;
	int				m_nSplineOffsetY;
	int				m_nCCCount;
	CSISBuffer		*m_lpBuffer;	
	int				**m_pLabelMap;
	int				m_nMaxContourIdx;
	int				m_nMaxContourCount;
	int				**m_pContourMap;
	int				*m_pContourCnt;
};