// Glass.h: interface for the CGlass class.
//
//////////////////////////////////////////////////////////////////////

#pragma once

#include <vector>
#include "DefectStorage.h"
#include "GlassRecipe.h"
#include "HardwareSettings.h"
#include "InspectDefect.h"

typedef struct _JUDGE_CUTAREA
{
	int					nScanIdx;	
	double				dThick;
	double				dyCoordi;
	CAMERA_DIR			enCamDir;
	DimensionDir		enDir;

	_JUDGE_CUTAREA()
	{
		Reset();
	}
	void Reset()
	{
		nScanIdx = 0;		
		dThick = dyCoordi = 0.;
		enCamDir = CAMDIR_NONE;
	}
} JUDGE_CUTAREA, *pJUDGE_CUTAREA;

typedef struct _JUDGE_SPLINE
{
	int			iType;
	int			nDetRange;
	BOOL		bUp;
	double		dAvg;
	double		dMax;
	double		dRangeVal[5];

	_JUDGE_SPLINE()
	{
		Reset();
	}
	void Reset()
	{
		iType = -1;
		nDetRange = 0;
		bUp = TRUE;
		dAvg = dMax = 0;
		ZeroMemory(dRangeVal,sizeof(double)*5);
	}
} JUDGE_SPLINE, *pJUDGE_SPLINE;

typedef struct _JUDGE_NOTCH
{
	CAMERA_DIR		Camdir;
	DimensionDir	enDir;
	double		dAvg;
	double		dMax;
	int			nDetRange;
	double		dRangeVal[5];
	double		dAvgThick;
	BOOL		bAvgThick;
	int			nNotchDx;
	int			nNotchDy;

	_JUDGE_NOTCH()
	{
		Reset();
	}
	void Reset()
	{
		Camdir = CAMDIR_NONE;
		enDir = DIMENSION_NONE;
		nDetRange = 0;
		dAvg = dMax = dAvgThick = 0;
		ZeroMemory(dRangeVal,sizeof(double)*5);
		bAvgThick = FALSE;
		nNotchDx = nNotchDy = 0;
	}
} JUDGE_NOTCH, *pJUDGE_NOTCH;

typedef struct _JUDGE_DIMENSION
{	
	CAMERA_DIR			Camdir;
	DimensionDir		enDir;
	double				dSize;
	double				dXPos,dYPos;

	_JUDGE_DIMENSION()
	{
		Reset();
	}
	void Reset()
	{
		Camdir = CAMDIR_NONE;
		enDir = DIMENSION_NONE;
		dSize = dXPos = dYPos = 0.;
	}
} JUDGE_DIMENSION, *pJUDGE_DIMENSION;

typedef struct _INS_PROFILE_RESULT_INFO
{		
	short					nProfileData[MAX_PROFILE_SETTING_COUNT];
	short					nChamferUp[MAX_PROFILE_SETTING_COUNT];
	short					nChamferDn[MAX_PROFILE_SETTING_COUNT];
	

	_INS_PROFILE_RESULT_INFO()
	{
		Reset();
	}
	void Reset()
	{		
		ZeroMemory(nProfileData,sizeof(short)*MAX_PROFILE_SETTING_COUNT);
		ZeroMemory(nChamferUp,sizeof(short)*MAX_PROFILE_SETTING_COUNT);
		ZeroMemory(nChamferDn,sizeof(short)*MAX_PROFILE_SETTING_COUNT);

	}
} INS_PROFILE_RESULT_INFO, *pINS_PROFILE_RESULT_INFO;

typedef struct _CHAMFER_RESULT
{		
	int				iIndex;
	int				iCam;
	int				iScan;
	int				iSide;
	int				iFrame;
	int				nUp;
	BOOL			bChamferJudge;	
	int				nGlassLeft;
	int				nGlassRight;
	int				nChamferThick;		
	int				nChamferCalThick;
	BOOL			bUseJudge;
	int				nJudgeReference;
	int				nJudgePlusChamfer;
	int				nJudgeMinusChamfer;	
	CvPoint2D32f	ptFull;
	CvPoint2D32f	ptChamferLine;
	CvPoint2D32f	ptCADLine;
	CvPoint2D32f	ptGlassLine;

	_CHAMFER_RESULT()
	{
		Reset();
	}
	void Reset()
	{		
		iIndex = iCam = iScan = iSide = iFrame = nUp = 0;
		bChamferJudge = TRUE;		
		nGlassLeft = nGlassRight = nChamferThick = nChamferCalThick = 0;	
		bUseJudge = TRUE;
		nJudgeReference = nJudgePlusChamfer = nJudgeMinusChamfer = 0;
		ptChamferLine.x = ptChamferLine.y = ptCADLine.x = ptCADLine.y = 0;	
		ptFull.x = ptFull.y = 0;
		ptGlassLine.x = ptGlassLine.y= 0;	
	}
} CHAMFER_RESULT, *pCHAMFER_RESULT;

typedef struct _PROFILE_RESULT
{	
	int				iIndex;
	int				iCam;
	int				iScan;
	int				iSide;
	int				iFrame;
	BOOL			bProfileJudge;
	int				nProfileDiff;
	BOOL			bUseJudge;	
	int				nJudgePlus;
	int				nJudgeMinus;	
	CvPoint2D32f			ptFullImg;
	CvPoint2D32f			ptGlassLine;
	CvPoint2D32f			ptGlassAlign;
	CvPoint2D32f			ptGlassStart;		

	_PROFILE_RESULT()
	{
		Reset();
	}
	void Reset()
	{		
		bProfileJudge = TRUE;
		bUseJudge = TRUE;
		iIndex = iCam = iScan = iSide = iFrame = 0;
		nProfileDiff = 0;
		nJudgePlus = nJudgeMinus = 0;
		ptFullImg.x = ptFullImg.y = ptGlassLine.x = ptGlassLine.y = 0;	
		ptGlassAlign.x = ptGlassAlign.y = ptGlassStart.x = ptGlassStart.y = 0;					
	}
} PROFILE_RESULT, *pPROFILE_RESULT;

typedef struct _PROFILE_RCUT_PROCESSDATA
{	
	int				iIndex;
	int				iCam;
	int				iScan;
	int				iSide;
	int				iFrame;
	double			dCenterX;
	double			dCenterY;
	double			dCADLineX;
	double			dCADLineY;
	double			dRadius;
	double			dPixelRadius;
	CvPoint2D32f			ptGlass;
	CvPoint2D32f			ptChamfer;


	_PROFILE_RCUT_PROCESSDATA()
	{
		Reset();
	}
	void Reset()
	{			
		iIndex = iCam = iScan = iSide = iFrame = 0;
		dCenterX = dCenterY = dCADLineX = dCADLineY = dRadius = dPixelRadius = 0;
		ptGlass.x = ptGlass.y = ptChamfer.x = ptChamfer.y = 0;		
		
	}
} PROFILE_RCUT_PROCESSDATA, *pPROFILE_RCUT_PROCESSDATA;

typedef struct _PROFILECHAMFER_RESULT_DATA
{		
	PROFILE_RESULT				ProfileData[MAX_PROFILE_SETTING_COUNT];
	CHAMFER_RESULT				ResultChamfer[MAX_PROFILE_SETTING_COUNT][2];
	PROFILE_RCUT_PROCESSDATA	RCutProcessData[MAX_PROFILE_SETTING_COUNT];

	_PROFILECHAMFER_RESULT_DATA()
	{
		Reset();
	}
	void Reset()
	{		
		ZeroMemory(ProfileData,sizeof(PROFILE_RESULT)*MAX_PROFILE_SETTING_COUNT);	
		ZeroMemory(RCutProcessData,sizeof(PROFILE_RCUT_PROCESSDATA)*MAX_PROFILE_SETTING_COUNT);
		ZeroMemory(ResultChamfer,sizeof(CHAMFER_RESULT)*MAX_PROFILE_SETTING_COUNT*2);
	}
} PROFILECHAMFER_RESULT_DATA, *pPROFILECHAMFER_RESULT_DATA;

typedef struct _INS_EDGE_RESULT_INFO
{	
	int						nGlassEdgeXPos[2];				// Glass X pos
	int						nGlassStartLine;						// CELL ½ÃÀÛ
	int						nGlassStartFrame;
	int						nGlassEndLine;						// CELL ³¡
	int						nGlassEndFrame;
	int						nPreGlassEndLine;						// CELL ³¡
	int						nPreGlassEndFrame;

	BOOL					bSpline[2];
	BOOL					bMark[MAX_MARKER_COUNT];					// ¸¶Å© ã±â ¼º°ø¿©ºÎ
	CvPoint2D32f			ptMark[MAX_MARKER_COUNT];					// ¸¶Å© À§Ä¡
	CRect					rtMark[MAX_MARKER_COUNT];					// ¸¶Å© ã´Â À§Ä¡

	CRect					rtChamfer;

	short					nCompRefFrame[MAX_IMAGE_FRAME];
	short					nGrindframe[3][MAX_IMAGE_FRAME];			// ¿¬¸¶ LINE
	short					nGrindData[MAX_IMAGE_FRAME];				// ½ÇÁ¦ ¿¬¸¶·®	
	int						nMarkToEdge_X[MAX_MARKER_COUNT];	
	int						nMarkToEdge_Y[MAX_MARKER_COUNT];	
	CRect					rcCorner[MAX_MARKER_COUNT];		

	_INS_EDGE_RESULT_INFO()
	{
		Reset();
	}
	void Reset()
	{
		ZeroMemory(bSpline,sizeof(BOOL)*2);
		ZeroMemory(bMark,sizeof(BOOL)*MAX_MARKER_COUNT);
		ZeroMemory(ptMark,sizeof(CvPoint2D32f)*MAX_MARKER_COUNT);
		ZeroMemory(rtMark,sizeof(CRect)*MAX_MARKER_COUNT);
		nGlassStartLine = nGlassEndLine = nPreGlassEndLine = nPreGlassEndFrame = nGlassEndFrame = nGlassStartFrame = -1;
		ZeroMemory(nCompRefFrame,sizeof(short)*MAX_IMAGE_FRAME);
		ZeroMemory(nGrindframe,sizeof(short)*MAX_IMAGE_FRAME*3);
		ZeroMemory(nGrindData,sizeof(short)*MAX_IMAGE_FRAME);
		ZeroMemory(rcCorner,sizeof(CRect)*MAX_MARKER_COUNT);
		ZeroMemory(nMarkToEdge_X,sizeof(int)*MAX_MARKER_COUNT);
		ZeroMemory(nMarkToEdge_Y,sizeof(int)*MAX_MARKER_COUNT);	
		ZeroMemory(nGlassEdgeXPos,sizeof(nGlassEdgeXPos));	
		rtChamfer = CRect(0,0,0,0);		
	}
} INS_EDGE_RESULT_INFO, *pINS_EDGE_RESULT_INFO;

class CGlass_Data
{
public:	
	CGlass_Data(void);
	virtual ~CGlass_Data();

	void					ResetGlass();	
	void					ResetDefect();
	BOOL					SetDefect(CInspectDefect* pDefect);
	CInspectDefect*			GetDefect(int nDefecIdx);
	MapDefect*				GetMapDefect()			{ return &m_MapDefect; }
	int						GetTotalDefectCount()	{ return m_nCurDefectIdx;}
	int						GetJudgeDefectCount() { return m_nJudgeDefectCount;}
	
	//////////////////////////////////////////////////////////////////////////
	// Glass Data
	BOOL					SetHardwareRecipe(CHardwareSettings *pHardware){m_pHardwareSetting = pHardware;}	
	void					SetGlassRecipe(CGlassRecipe *pRecipe){m_pGlassRecipe=pRecipe;}
	CGlassRecipe*			GetGlassRecipe()		{ return m_pGlassRecipe; }
	CHardwareSettings*		GetHardwareRecipe()		{ return m_pHardwareSetting;}
	CINSPECT_INFO_PARM*		GetInsRecipe()			{ return &GetGlassRecipe()->m_InspectInfoParm;}

	BOOL					GetInsUseCheck(EM_INS_TYPE emIns);	

	void					SetLoadingTime();
	void					SetUnloadingTime();
	void					SetScanStartTime();
	void					SetScanEndTime();	
	CString					GetLoadingTime()		{ return m_strLoadingTime; }
	CString					GetUnloadingTime()		{ return m_strUnloadingTime; }
	CString					GetScanStartTime()		{ return m_strScanStartTime; }
	CString					GetScanEndTime()		{ return m_strScanEndTime; }		
	CString					GetScanEndTimeFileName(){ return m_strScanEndTimeFileName; }		
	CString					GetLoadingTimeFileName(){ return m_strLoadingTimeFileName; }		
	CString					GetLoadingDayFileName(){ return m_strLoadingDayFileName; }
	
	INS_EDGE_RESULT_INFO	*GetEdgeResultInfo(DimensionDir eDim){return &m_EdgeResultInfo[eDim];}
	INS_PROFILE_RESULT_INFO	*GetProfileResultInfo(){return &m_stProfileResult;}
	short					*GetGlassResultInfo(){return m_nGlassResult;}
	PROFILECHAMFER_RESULT_DATA	*GetProfileInspectData(){return &m_ProfileInspectData;}	
	void					SetProfileChamferInspectData(int nIndex,int nUp,CHAMFER_RESULT *pChamferResult);
	void					SetProfileInspectData(int nIndex,PROFILE_RESULT *pProfileResult);
	void					SetRCutProfileInspectData(int nIndex,PROFILE_RCUT_PROCESSDATA *pProfileResult);
	BOOL					GetProfileInspectIndex(int iSide,int &nIndex,int &nSize,CString &str);
	BOOL					GetProfileRCutInspectIndex(int iSide,int &nIndex,int &nSize,CString &str);

	void					GetStageTheta(int iStage,short &nLongTheta,short &nShortTheta);
	void					SetStageTheta(int iStage,BOOL bLong,short nTheta);

	BOOL					IsPostProcStart()		{return m_bPostProcessing;}
	void					SetPostProc(BOOL bSet)	{m_bPostProcessing = bSet;}

	void					SetScanStart(BOOL bStart);
	BOOL					GetScanStart(){return m_bScanStart;}
	void					SetScanEnd(int nScanIdx,BOOL bIsEnd);
	BOOL					GetScanEnd(int nScanIdx);
	void					SetScanStartCount(int nCount){m_nStartCount=nCount;}
	int						GetScanStartCount(){return m_nStartCount;}	
	int						GetScanEndCameraCount();
	void					SetScanEndCamera(int iCam,int iScan);

protected:
	//////////////////////////////////////////////////////////////////////////
	CGlassRecipe			*m_pGlassRecipe;			// Glass Recipe
	CHardwareSettings		*m_pHardwareSetting;		// Hardware Setting
	MapDefect				m_MapDefect;			// °áÇÔÁ¤º¸
	int						m_nCurDefectIdx;
	int						m_nJudgeDefectCount;
	CRITICAL_SECTION		m_csGlassDefect;			
	
	CString					m_strLoadingTime;
	CString					m_strUnloadingTime;
	CString					m_strScanStartTime;
	CString					m_strScanEndTime;		
	//park
	CString					m_strScanEndTimeFileName;
	CString					m_strGlassResult;
	CString					m_strLoadingTimeFileName;
	CString					m_strLoadingDayFileName;

	// Stage theta º¸Á¤
	short					m_nStageLongTheta[2];
	short					m_nStageShortTheta[2];	
		
	INS_EDGE_RESULT_INFO	m_EdgeResultInfo[MAX_DIMENSION_COUNT];
	INS_PROFILE_RESULT_INFO	m_stProfileResult;
	short					m_nGlassResult[11];
	PROFILECHAMFER_RESULT_DATA	m_ProfileInspectData;
	
	BOOL					m_bScanEndCamera[MAX_CAMERA_COUNT][MAX_SCAN_COUNT];
	BOOL					m_bScanStart;
	BOOL					m_bScanEnd[MAX_SCAN_COUNT];
	BOOL					m_bPostProcessing;
	CCriticalSection		m_csProfileData;
	int						m_nStartCount;	
	CCriticalSection		m_csInsEnd;	

public:
	// Side
	BOOL					m_bOnly_Profile_NG;
	int						m_nSide_Profile_NG_Count[MAX_DIMENSION_COUNT];
	int						m_nSide_Profile_NG_Max_Diff[MAX_DIMENSION_COUNT];
};