#include "stdafx.h"
#include "EdgeImageViewer.h"

// CEdgeImageViewer
IMPLEMENT_DYNAMIC(CEdgeImageViewer, CStatic)
	
CEdgeImageViewer::CEdgeImageViewer()
{
	m_rtWnd				= CRect(-1,-1,-1,-1);
	m_pBmInfo			= NULL;
	m_pBuffer			= NULL;
	m_nFrameWidth		= 0;
	m_nFrameHeight		= 0;
	m_nFrameCount		= 0;
	m_nTotalHeight		= 0;
	m_dPixelSizeX		= 1.0;
	m_dPixelSizeY		= 1.0;

	m_dZoom = 1.0;
	m_ptDisplayStart_pxl = CPoint(0,0);
	m_ptMousePos_Wnd = CPoint(0,0);
	m_ptMousePos_Pxl = CPoint(0,0);

	m_MenuStatus.set(MODE_VIEW_INSPECT_AREA);
	m_MenuStatus.set(MODE_VIEW_NOTCH_AREA);
	m_MenuStatus.set(MODE_VIEW_NOTCH_MEASURE);
	m_MenuStatus.set(MODE_VIEW_INSPECT_SIDE_DIMENSION);
	m_MenuStatus.set(MODE_VIEW_CORNER_AREA);
	m_MenuStatus.set(MODE_VIEW_MARK_AREA);
	m_MenuStatus.set(MODE_VIEW_USER_DEFECT_AREA);
	m_MenuStatus.set(MODE_VIEW_EXCEPTION_AREA);
	m_MenuStatus.set(MODE_VIEW_START_END_LINE);
	m_MenuStatus.set(MODE_VIEW_DEFECT);
	m_MenuStatus.set(MODE_VIEW_MEASURE);
	m_MenuStatus.reset(MODE_VIEW_FRAME_IDX);
	
	m_nSideIdx = 0;
	m_pGlassData = NULL;
	m_pHardware = NULL;
	m_pRecipe = NULL;

#if HALCON_VISION_KEY
	m_isMouseDown = FALSE;
	m_ptMouseDown.x = 0;
	m_ptMouseDown.y = 0;
#endif // HALCON_VISION_KEY
}

CEdgeImageViewer::~CEdgeImageViewer()
{
	DeleteBitMap();
}

BEGIN_MESSAGE_MAP(CEdgeImageViewer, CStatic)
	ON_WM_PAINT()
	ON_WM_DESTROY()
	ON_WM_CREATE()
	ON_WM_MOUSEMOVE()
	ON_WM_RBUTTONUP()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONDOWN()
	// ON_WM_LBUTTONUP()
	// ON_WM_MOUSEACTIVATE()
	ON_COMMAND(ID_MODE_USER_SELECT					, &CEdgeImageViewer::OnUserSelect)
	ON_COMMAND(ID_MODE_VIEW_INSPECT_ALL				, &CEdgeImageViewer::OnViewInspetAll)
	ON_COMMAND(ID_MODE_VIEW_INSPECT_AREA			, &CEdgeImageViewer::OnViewInspectArea)
	ON_COMMAND(ID_MODE_VIEW_NOTCH_AREA				, &CEdgeImageViewer::OnViewInspectNotchArea)
	ON_COMMAND(ID_MODE_VIEW_NOTCH_MEASURE			, &CEdgeImageViewer::OnViewInspectNotchMeasure)
	ON_COMMAND(ID_MODE_VIEW_INSPECT_SIDE_DIMENSION	, &CEdgeImageViewer::OnViewInspectSideDimension)
	ON_COMMAND(ID_MODE_VIEW_CORNER_AREA				, &CEdgeImageViewer::OnViewCornerArea)
	ON_COMMAND(ID_MODE_VIEW_MARK_AREA				, &CEdgeImageViewer::OnViewMarkArea)
	ON_COMMAND(ID_MODE_VIEW_USER_DEFECT_AREA		, &CEdgeImageViewer::OnViewUserDefectArea)
	ON_COMMAND(ID_MODE_VIEW_EXCEPTION_AREA			, &CEdgeImageViewer::OnViewExceptionArea)
	ON_COMMAND(ID_MODE_VIEW_START_END_LINE			, &CEdgeImageViewer::OnViewStartEndLine)
	ON_COMMAND(ID_MODE_VIEW_DEFECT_ALL				, &CEdgeImageViewer::OnViewResultAll)
	ON_COMMAND(ID_MODE_VIEW_DEFECT					, &CEdgeImageViewer::OnViewDefect)
	ON_COMMAND(ID_MODE_VIEW_MEASURE					, &CEdgeImageViewer::OnViewMeasur)
	ON_COMMAND(ID_MODE_MODIFY_BRUSH_BLACK			, &CEdgeImageViewer::OnModifyDrawbrushBlack)
	ON_COMMAND(ID_MODE_MODIFY_BRUSH_WHITE			, &CEdgeImageViewer::OnModifyDrawbrushWhite)
	ON_COMMAND(ID_MODE_VIEW_FRAME_INDEX				, &CEdgeImageViewer::OnViewFrameIdx)
	ON_WM_LBUTTONUP()
END_MESSAGE_MAP()

int CEdgeImageViewer::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	GetClientRect(m_rtWnd);

	return 0;
}

void CEdgeImageViewer::InitBitMap()
{
	if(m_pBmInfo != NULL)
		free(m_pBmInfo);

	m_pBmInfo = (BITMAPINFO*)malloc(sizeof(BITMAPINFO)+256*sizeof(RGBQUAD));
	m_pBmInfo->bmiHeader.biBitCount			= 8; 
	m_pBmInfo->bmiHeader.biClrImportant		= 256;
	m_pBmInfo->bmiHeader.biClrUsed			= 256;
	m_pBmInfo->bmiHeader.biCompression		= BI_RGB;
	m_pBmInfo->bmiHeader.biHeight			= -m_nFrameHeight;
	m_pBmInfo->bmiHeader.biPlanes			= 1;
	m_pBmInfo->bmiHeader.biSize				= sizeof(BITMAPINFOHEADER);
	m_pBmInfo->bmiHeader.biSizeImage		= m_nFrameWidth * m_nFrameHeight; 
	m_pBmInfo->bmiHeader.biWidth			= m_nFrameWidth; 
	m_pBmInfo->bmiHeader.biXPelsPerMeter=0;
	m_pBmInfo->bmiHeader.biYPelsPerMeter=0;
	
	for(int i=0; i<256; i++) // Palette number is 256
	{
		m_pBmInfo->bmiColors[i].rgbRed= m_pBmInfo->bmiColors[i].rgbGreen = m_pBmInfo->bmiColors[i].rgbBlue = i; 
		m_pBmInfo->bmiColors[i].rgbReserved = 0;
	}
}

void CEdgeImageViewer::DeleteBitMap()
{
	if(m_pBmInfo == NULL)
		return;

	free(m_pBmInfo);
	m_pBmInfo = NULL;
}

void CEdgeImageViewer::OnDestroy()
{
	CWnd::OnDestroy();

	DeleteBitMap();
}

void CEdgeImageViewer::OnContextMenu(CPoint point)
{
	CMenu menu;
	CMenu popMenu;
	menu.CreateMenu();  // ÃÖ»óÀ§ »À´ë ¸Þ´º
	popMenu.CreatePopupMenu();  // Æ˾÷¸Þ´º

	popMenu.AppendMenu(MF_SEPARATOR);
	popMenu.AppendMenu(MF_STRING, ID_MODE_USER_SELECT,					_T("User Select (Mark/Manual Measure)"));
	popMenu.AppendMenu(MF_SEPARATOR);

	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_INSPECT_ALL,				_T("All"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_INSPECT_AREA,			_T("View Inspect Area"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_NOTCH_AREA,				_T("View Notch Area"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_NOTCH_MEASURE,			_T("View Notch Measure"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_INSPECT_SIDE_DIMENSION,	_T("View Side Measure"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_CORNER_AREA,				_T("View Corner Area"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_MARK_AREA,				_T("View Mark Area"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_USER_DEFECT_AREA,		_T("View User Defect Area"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_EXCEPTION_AREA,			_T("View Exception Area"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_START_END_LINE,			_T("View Start/End Line"));
	popMenu.AppendMenu(MF_SEPARATOR);
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_DEFECT_ALL,				_T("All"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_DEFECT,					_T("View Defect"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_MEASURE,					_T("View Measure"));
	popMenu.AppendMenu(MF_SEPARATOR);
	popMenu.AppendMenu(MF_STRING, ID_MODE_MODIFY_BRUSH_BLACK,			_T("Create Black Defect"));
	popMenu.AppendMenu(MF_STRING, ID_MODE_MODIFY_BRUSH_WHITE,			_T("Create White Defect"));
	popMenu.AppendMenu(MF_SEPARATOR);
	popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_FRAME_INDEX,				_T("View Frame Idx"));
	

	if(m_MenuStatus[MODE_USER_SELECT])
		popMenu.CheckMenuItem(ID_MODE_USER_SELECT,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_INSPECT_AREA])
		popMenu.CheckMenuItem(ID_MODE_VIEW_INSPECT_AREA,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_NOTCH_AREA])
		popMenu.CheckMenuItem(ID_MODE_VIEW_NOTCH_AREA,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_NOTCH_MEASURE])
		popMenu.CheckMenuItem(ID_MODE_VIEW_NOTCH_MEASURE,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_INSPECT_SIDE_DIMENSION])
		popMenu.CheckMenuItem(ID_MODE_VIEW_INSPECT_SIDE_DIMENSION,MF_CHECKED);	

	if(m_MenuStatus[MODE_VIEW_CORNER_AREA])
		popMenu.CheckMenuItem(ID_MODE_VIEW_CORNER_AREA,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_MARK_AREA])
		popMenu.CheckMenuItem(ID_MODE_VIEW_MARK_AREA,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA])
		popMenu.CheckMenuItem(ID_MODE_VIEW_USER_DEFECT_AREA,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_EXCEPTION_AREA])
		popMenu.CheckMenuItem(ID_MODE_VIEW_EXCEPTION_AREA,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_START_END_LINE])
		popMenu.CheckMenuItem(ID_MODE_VIEW_START_END_LINE,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_DEFECT])
		popMenu.CheckMenuItem(ID_MODE_VIEW_DEFECT,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_MEASURE])
		popMenu.CheckMenuItem(ID_MODE_VIEW_MEASURE,MF_CHECKED);

	if(m_MenuStatus[MODE_MODIFY_BRUSH_BLACK])
		popMenu.CheckMenuItem(ID_MODE_MODIFY_BRUSH_BLACK,MF_CHECKED);

	if(m_MenuStatus[MODE_MODIFY_BRUSH_WHITE])
		popMenu.CheckMenuItem(ID_MODE_MODIFY_BRUSH_WHITE,MF_CHECKED);

	if(m_MenuStatus[MODE_VIEW_FRAME_IDX])
		popMenu.CheckMenuItem(ID_MODE_VIEW_FRAME_INDEX,MF_CHECKED);

	

	// All Check
	bool bAllCheck = true;
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_INSPECT_AREA];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_NOTCH_AREA];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_NOTCH_MEASURE];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_CORNER_AREA];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_MARK_AREA];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_EXCEPTION_AREA];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_START_END_LINE];
	if(bAllCheck)
		popMenu.CheckMenuItem(ID_MODE_VIEW_INSPECT_ALL,MF_CHECKED);

	bAllCheck = true;
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_DEFECT];
	bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_MEASURE];
	if(bAllCheck)
		popMenu.CheckMenuItem(ID_MODE_VIEW_DEFECT_ALL,MF_CHECKED);

	// ÄÁÅؽºÆ® ¸Þ´º È£Ãâ
	CRect rect;
	GetWindowRect(rect);
	int nX = rect.left + point.x;
	int nY = rect.top + point.y;

	popMenu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, nX, nY, this);
}

void CEdgeImageViewer::OnMouseMove(UINT nFlags, CPoint point)
{
	m_ptMousePos_Wnd = point;
	m_ptMousePos_Pxl = GetPxlPos(m_ptMousePos_Wnd);

	if(nFlags & MK_LBUTTON)
	{
		ModifyImageBack();

		ModifyImageWhite();
	}

	if(m_ManualMeasureStatus.bStart == TRUE || m_ManualMeasureStatus.bModifyEnd == TRUE)
		m_ManualMeasureStatus.ptMeasureEnd = m_ptMousePos_Pxl;
	else if(m_ManualMeasureStatus.bModifyStart == TRUE)
		m_ManualMeasureStatus.ptMeasureStart = m_ptMousePos_Pxl;

	UpdateView();
	CWnd::OnMouseMove(nFlags, point);
}

void CEdgeImageViewer::OnRButtonUp(UINT nFlags, CPoint point)
{
	OnContextMenu(point);
	CWnd::OnRButtonUp(nFlags, point);
}

void CEdgeImageViewer::OnLButtonDown(UINT nFlags, CPoint point)
{
	CPoint ptWnd = point;

#if HALCON_VISION_KEY
	m_isMouseDown = TRUE;
	if (m_isMouseDown) {
		CPoint ptPxl = GetPxlPos(ptWnd);
		m_ptMouseDown = ptPxl;
	}
#endif // HALCON_VISION_KEY

	if(m_MenuStatus[MODE_USER_SELECT] == true)
	{
		if(m_ManualMeasureStatus.bStart == FALSE)
		{
			CPoint ptPxl = GetPxlPos(ptWnd);

			int nInRange = (int) (10.0 / m_dZoom);

			if( m_ManualMeasureStatus.ptMeasureStart.x      > ptPxl.x - nInRange 
				&&  m_ManualMeasureStatus.ptMeasureStart.x  < ptPxl.x + nInRange
				&&  m_ManualMeasureStatus.ptMeasureStart.y  > ptPxl.y - nInRange 
				&&  m_ManualMeasureStatus.ptMeasureStart.y  < ptPxl.y + nInRange )
			{
				if(m_ManualMeasureStatus.bModifyStart)
					m_ManualMeasureStatus.bModifyStart	= FALSE;
				else
					m_ManualMeasureStatus.bModifyStart	= TRUE;

			}
			else if(m_ManualMeasureStatus.ptMeasureEnd.x  >  ptPxl.x - nInRange 
				&&	m_ManualMeasureStatus.ptMeasureEnd.x  <  ptPxl.x + nInRange
				&&  m_ManualMeasureStatus.ptMeasureEnd.y  >  ptPxl.y - nInRange 
				&&  m_ManualMeasureStatus.ptMeasureEnd.y  <  ptPxl.y + nInRange )
			{
				if(m_ManualMeasureStatus.bModifyEnd)
					m_ManualMeasureStatus.bModifyEnd	= FALSE;
				else
					m_ManualMeasureStatus.bModifyEnd	= TRUE;
			}
			else
			{
				m_ManualMeasureStatus.bModifyStart		= FALSE;
				m_ManualMeasureStatus.bModifyEnd		= FALSE;
				m_ManualMeasureStatus.bStart			= TRUE;

				m_ManualMeasureStatus.ptMeasureStart	= ptPxl;
			}
		}
		else
		{
			m_ManualMeasureStatus.bStart				= FALSE;
		}
	}

	CWnd::OnLButtonDown(nFlags, point);
}

void CEdgeImageViewer::OnUserSelect()
{
	m_MenuStatus.flip(MODE_USER_SELECT);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewInspetAll()
{
	bool bCheck = true;

	bCheck = bCheck && m_MenuStatus[MODE_VIEW_INSPECT_AREA];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_NOTCH_AREA];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_NOTCH_MEASURE];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_INSPECT_SIDE_DIMENSION];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_CORNER_AREA];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_MARK_AREA];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_EXCEPTION_AREA];
	bCheck = bCheck && m_MenuStatus[MODE_VIEW_START_END_LINE];

	if(bCheck == false)
	{
		m_MenuStatus.set(MODE_VIEW_INSPECT_AREA);
		m_MenuStatus.set(MODE_VIEW_NOTCH_AREA);
		m_MenuStatus.set(MODE_VIEW_NOTCH_MEASURE);
		m_MenuStatus.set(MODE_VIEW_INSPECT_SIDE_DIMENSION);
		m_MenuStatus.set(MODE_VIEW_CORNER_AREA);
		m_MenuStatus.set(MODE_VIEW_MARK_AREA);
		m_MenuStatus.set(MODE_VIEW_USER_DEFECT_AREA);
		m_MenuStatus.set(MODE_VIEW_EXCEPTION_AREA);
		m_MenuStatus.set(MODE_VIEW_START_END_LINE);
	}
	else
	{
		m_MenuStatus.reset(MODE_VIEW_INSPECT_AREA);
		m_MenuStatus.reset(MODE_VIEW_NOTCH_AREA);
		m_MenuStatus.reset(MODE_VIEW_NOTCH_MEASURE);
		m_MenuStatus.reset(MODE_VIEW_INSPECT_SIDE_DIMENSION);
		m_MenuStatus.reset(MODE_VIEW_CORNER_AREA);
		m_MenuStatus.reset(MODE_VIEW_MARK_AREA);
		m_MenuStatus.reset(MODE_VIEW_USER_DEFECT_AREA);
		m_MenuStatus.reset(MODE_VIEW_EXCEPTION_AREA);
		m_MenuStatus.reset(MODE_VIEW_START_END_LINE);
	}

	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewInspectArea()
{
	m_MenuStatus.flip(MODE_VIEW_INSPECT_AREA);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewInspectNotchArea()
{
	m_MenuStatus.flip(MODE_VIEW_NOTCH_AREA);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewInspectNotchMeasure()
{
	m_MenuStatus.flip(MODE_VIEW_NOTCH_MEASURE);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewInspectSideDimension()
{
	m_MenuStatus.flip(MODE_VIEW_INSPECT_SIDE_DIMENSION);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewCornerArea()
{
	m_MenuStatus.flip(MODE_VIEW_CORNER_AREA);
	Invalidate(FALSE);
}
void CEdgeImageViewer::OnViewMarkArea()
{
	m_MenuStatus.flip(MODE_VIEW_MARK_AREA);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewUserDefectArea()
{
	m_MenuStatus.flip(MODE_VIEW_USER_DEFECT_AREA);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewExceptionArea()
{
	m_MenuStatus.flip(MODE_VIEW_EXCEPTION_AREA);
	Invalidate(FALSE);
}
void CEdgeImageViewer::OnViewStartEndLine()
{
	m_MenuStatus.flip(MODE_VIEW_START_END_LINE);
	Invalidate(FALSE);
}
void CEdgeImageViewer::OnViewResultAll()
{
	bool bCheck = true;

	bCheck = bCheck & m_MenuStatus[MODE_VIEW_DEFECT];
	bCheck = bCheck & m_MenuStatus[MODE_VIEW_MEASURE];

	if(bCheck == false)
	{
		m_MenuStatus.set(MODE_VIEW_DEFECT);
		m_MenuStatus.set(MODE_VIEW_MEASURE);
	}
	else
	{
		m_MenuStatus.reset(MODE_VIEW_DEFECT);
		m_MenuStatus.reset(MODE_VIEW_MEASURE);
	}

	Invalidate(FALSE);
}
void CEdgeImageViewer::OnViewDefect()
{
	m_MenuStatus.flip(MODE_VIEW_DEFECT);
	Invalidate(FALSE);
}
void CEdgeImageViewer::OnViewMeasur()
{
	m_MenuStatus.flip(MODE_VIEW_MEASURE);
	Invalidate(FALSE);
}
void CEdgeImageViewer::OnModifyDrawbrushBlack()
{
	if(m_MenuStatus[MODE_MODIFY_BRUSH_WHITE])
		m_MenuStatus.reset(MODE_MODIFY_BRUSH_WHITE);

	m_MenuStatus.flip(MODE_MODIFY_BRUSH_BLACK);
	Invalidate(FALSE);
}
void CEdgeImageViewer::OnModifyDrawbrushWhite()
{
	if(m_MenuStatus[MODE_MODIFY_BRUSH_BLACK])
		m_MenuStatus.reset(MODE_MODIFY_BRUSH_BLACK);

	m_MenuStatus.flip(MODE_MODIFY_BRUSH_WHITE);
	Invalidate(FALSE);
}

void CEdgeImageViewer::OnViewFrameIdx()
{
	m_MenuStatus.flip(MODE_VIEW_FRAME_IDX);
	Invalidate(FALSE);
}

void CEdgeImageViewer::SetImageBuffer(BYTE *pImg, int nWidth, int nHeight, int nFrameCount)
{
	m_pBuffer			= pImg;
	m_nFrameWidth		= nWidth;
	m_nFrameHeight		= nHeight;
	m_nFrameCount		= nFrameCount;
	m_nTotalHeight		= nHeight * nFrameCount;

	InitBitMap();
}

void CEdgeImageViewer::SetImageBuffer(BYTE *pImg)
{
	m_pBuffer = pImg;

	Invalidate(FALSE);
}

void CEdgeImageViewer::OnPaint()
{
	CPaintDC dc(this); // device context for painting
	// TODO: ¿©±â¿¡ ¸Þ½ÃÁö 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	// ±×¸®±â ¸Þ½ÃÁö¿¡ ´ëÇؼ­´Â CStatic::OnPaint()À»(¸¦) È£ÃâÇÏÁö ¸¶½Ê½Ã¿À.
	UpdateView();
}

#if HALCON_VISION_KEY
void CEdgeImageViewer::UpdataVisionResult(void) {
	/* code */
	if (!IsWindowVisible())
		return;

	if (m_pBuffer == NULL)
		return;

	CDC*		pDC = GetDC();
	CDC			memDC;
	CBitmap		Bitmap;
	CBitmap*	pOldBitmap;

	memDC.CreateCompatibleDC(pDC);
	Bitmap.CreateCompatibleBitmap(pDC, m_rtWnd.Width(), m_rtWnd.Height());
	m_pBmInfo->bmiHeader.biWidth = m_nFrameWidth;
	m_pBmInfo->bmiHeader.biHeight = -int(m_rtWnd.Height() / m_dZoom);
	m_pBmInfo->bmiHeader.biSizeImage = m_pBmInfo->bmiHeader.biWidth * m_pBmInfo->bmiHeader.biHeight;
	memDC.SetStretchBltMode(COLORONCOLOR);
	pOldBitmap = (CBitmap*)memDC.SelectObject(&Bitmap);


	// 1. Draw Buffer Image
	UpdateView_Image(&memDC);

	//2. ÏÔʾÊÓ¾õЧ¹û
	UpdateView_VisionResult(&memDC);


	pDC->BitBlt(0, 0, m_rtWnd.Width(), m_rtWnd.Height(), &memDC, 0, 0, SRCCOPY);
	memDC.SelectObject(pOldBitmap);
	Bitmap.DeleteObject();
	ReleaseDC(&memDC);
	ReleaseDC(pDC);
}

void CEdgeImageViewer::UpdateView_VisionResult(CDC* memDC) {
	/* code */
	if (m_MenuStatus[MODE_VIEW_DEFECT] == false)
		return;

	DimensionDir eDir = (DimensionDir)(m_nSideIdx);
	CBlSideData *pSideData = BlVision_GetVisionRecipe()->getSideData(eDir);
	if (NULL == pSideData) return;

	int nCount = (int)(pSideData->m_vDispVisionResult.size());
	if (nCount < 1) return;

	if (m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	CPen pen(PS_SOLID, 1, RGB(255, 0, 0));
	CPen pen_SearchArea(PS_DASH, 1, RGB(255, 0, 255));
	CPen pen_Line(PS_DASH, 1, RGB(0, 255, 255));

	CBrush brush_Null;
	brush_Null.CreateStockObject(NULL_BRUSH);

	CPen* pOldPen = memDC->SelectObject(&pen);
	CBrush* pOldBrush = (CBrush*)memDC->SelectObject(&brush_Null);

	for (int i = 0; i < nCount; i++) {
		DispVisionResult inf = pSideData->m_vDispVisionResult[i];
		int nType = inf.nType;
		if (0 == nType) {   //µã
			CRect rtMarkPos_pxl = CRect(inf.pointX-31, inf.pointY-31, inf.pointX + 31, inf.pointY + 31);
			CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
			CPoint ptMarkPos_wnd = rtMarkPos_wnd.CenterPoint();

			memDC->SelectObject(&pen);
			CPoint pt = ptMarkPos_wnd;
			if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
				memDC->MoveTo(ptMarkPos_wnd.x - 8, ptMarkPos_wnd.y - 8);
				memDC->LineTo(ptMarkPos_wnd.x + 8, ptMarkPos_wnd.y + 8);
				memDC->MoveTo(ptMarkPos_wnd.x + 8, ptMarkPos_wnd.y - 8);
				memDC->LineTo(ptMarkPos_wnd.x - 8, ptMarkPos_wnd.y + 8);
			}
		}
		else if (1 == nType) {   //¾ØÐÎ
			CRect rtMarkPos_pxl = CRect(inf.rectX1, inf.rectY1, inf.rectX2, inf.rectY2);
			CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkPos_pxl);
			if (4 == inf.eVision) {
				memDC->SelectObject(&pen);
			}
			else {
				memDC->SelectObject(&pen_SearchArea);
			}
			CPoint pt;
			pt.x = (int)(0.5 * (rtMarkSearchPos_wnd.left + rtMarkSearchPos_wnd.right));
			pt.y = (int)(0.5 * (rtMarkSearchPos_wnd.top + rtMarkSearchPos_wnd.bottom));
			if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
				memDC->Rectangle(rtMarkSearchPos_wnd);
			}
		}
		else if (2 == nType) {   //Ô²
			CRect rtMarkPos_pxl = CRect(inf.circleX - inf.circleRadius, inf.circleY - inf.circleRadius, inf.circleX + inf.circleRadius, inf.circleY + inf.circleRadius);
			CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkPos_pxl);
			memDC->SelectObject(&pen);
			CPoint pt;
			pt.x = (int)(0.5 * (rtMarkSearchPos_wnd.left + rtMarkSearchPos_wnd.right));
			pt.y = (int)(0.5 * (rtMarkSearchPos_wnd.top + rtMarkSearchPos_wnd.bottom));
			if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
				memDC->Ellipse(rtMarkSearchPos_wnd);
			}
		}
		else if (3 == nType) {   //Ö±Ïß
			CRect rtMarkPos_pxl = CRect(inf.rectX1 - 31, inf.rectY1 - 31, inf.rectX1 + 31, inf.rectY1 + 31);
			CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
			CPoint pt0 = rtMarkPos_wnd.CenterPoint();

			rtMarkPos_pxl = CRect(inf.rectX2 - 31, inf.rectY2 - 31, inf.rectX2 + 31, inf.rectY2 + 31);
			rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
			CPoint pt1 = rtMarkPos_wnd.CenterPoint();

			memDC->SelectObject(&pen_Line);

			CPoint pt;
			pt.x = (int)(0.5 * (pt0.x + pt1.x));
			pt.y = (int)(0.5 * (pt0.y + pt1.y));
			if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
				memDC->MoveTo(pt0.x, pt0.y);
				memDC->LineTo(pt1.x, pt1.y);
			}
		}
		else if (4 == nType) {
			CRect rtMarkPos_pxl = CRect(inf.pointX - 31, inf.pointY - 31, inf.pointX + 31, inf.pointY + 31);
			CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
			CPoint pt = rtMarkPos_wnd.CenterPoint();

			memDC->SetBkMode(TRANSPARENT);
			memDC->SetTextColor(RGB(0, 0, 255));
			memDC->TextOut(pt.x - 80, pt.y, inf.strName);
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);
	brush_Null.DeleteObject();

}
#endif // HALCON_VISION_KEY

void CEdgeImageViewer::UpdateView()
{
	if(!IsWindowVisible())
		return;

	if(m_pBuffer == NULL)
		return;

	CDC*		pDC = GetDC();
	CDC			memDC;
	CBitmap		Bitmap;
	CBitmap*	pOldBitmap;

	memDC.CreateCompatibleDC(pDC);
	Bitmap.CreateCompatibleBitmap(pDC,m_rtWnd.Width(),m_rtWnd.Height());
	m_pBmInfo->bmiHeader.biWidth     = m_nFrameWidth;
	m_pBmInfo->bmiHeader.biHeight    = -int(m_rtWnd.Height() / m_dZoom);
	m_pBmInfo->bmiHeader.biSizeImage =  m_pBmInfo->bmiHeader.biWidth * m_pBmInfo->bmiHeader.biHeight;
	memDC.SetStretchBltMode(COLORONCOLOR);
	pOldBitmap = (CBitmap*)memDC.SelectObject(&Bitmap);


	// 1. Draw Buffer Image
	UpdateView_Image(&memDC);

	// 2. Draw Side Name
	UpdateView_SideName(&memDC);

	// 3. Draw Mouse Pos Info
	UpdateView_MousePosInfo(&memDC);

	// 4. Draw Corner : MODE_VIEW_CORNER_AREA
	UpdateView_Corner(&memDC);

	// 5. Draw Mark : MODE_VIEW_MARK_AREA
	UpdateView_Mark(&memDC);

	// 6. Draw User Defect Area : MODE_VIEW_USER_DEFECT_AREA
	UpdateView_UserDefectArea(&memDC);

	// 7. Draw Exception : MODE_VIEW_EXCEPTION_AREA
	UpdateView_ExceptionArea(&memDC);
	
	// 8. Draw Inspect : MODE_VIEW_INSPECT_AREA
	UpdateView_InspectArea(&memDC);

	// 9. Draw Notch : MODE_VIEW_NOTCH_AREA
	UpdateView_NotchArea(&memDC);

	// 10. Draw Notch Measure : MODE_VIEW_NOTCH_MEASURE
	UpdateView_NotchMeasure(&memDC);
	UpdateView_Notch_Circle_Measure(&memDC);

	// 11. Draw Side Dimension : MODE_VIEW_INSPECT_SIDE_DIMENSION
	UpdateView_MeasureSideDimensionResult(&memDC);

	// 12. Draw Start Line, End Line : MODE_VIEW_START_END_LINE
	UpdateView_StartEndLine(&memDC);

	// 13. Draw Defect : MODE_VIEW_DEFECT
	UpdateView_Defect(&memDC);

	// 14. Draw Manual Measure : MODE_USER_SELECT
	UpdateView_ManualMeasure(&memDC);

	// 15. Frame
	UpdateView_Frame(&memDC);

	// 16. Mouse Pos
	UpdateView_MousePoint(&memDC);

#if HALCON_VISION_KEY
	//17. ÏÔʾvision Rsult
	UpdateView_VisionResult(&memDC);
#endif // HALCON_VISION_KEY


	pDC->BitBlt(0,0,m_rtWnd.Width(),m_rtWnd.Height(),&memDC,0,0,SRCCOPY);
	memDC.SelectObject(pOldBitmap);
	Bitmap.DeleteObject();
	ReleaseDC(&memDC);
	ReleaseDC(pDC);

	/*
	if(nOpt == 0 && m_ptOrg.y >= 0)
	{
		if(m_bitModeDisplay.at(MODE_MANIFY))
			DrawMagnify(memDC);

		if(m_bitModeDisplay.at(MODE_PROFILE_X))
			DrawProfile(memDC,0,m_ptMouseCurrent);

		if(m_bitModeDisplay.at(MODE_PROFILE_Y))
			DrawProfile(memDC,1,m_ptMouseCurrent);

		if(m_bitModeDisplay.at(MODE_SAVED_X))
			DrawProfileSaved(memDC,0,m_ptMouseSaved);

		if(m_bitModeDisplay.at(MODE_SAVED_Y))
			DrawProfile(memDC,1,m_ptMouseSaved);

		if(m_bitModeDisplay.at(MODE_PROJECTION_X))
			DrawProfile(memDC,2,m_ptMouseCurrent);

		if(m_bitModeDisplay.at(MODE_PROJECTION_Y))
			DrawProfile(memDC,3,m_ptMouseCurrent);


		if(m_bitModeDisplay.at(MODE_DISTANCE_X)
			|| m_bitModeDisplay.at(MODE_DISTANCE_Y)
			|| m_bitModeDisplay.at(MODE_DIAGONAL))
			DrawManualMeasure(memDC);

		// DrawTest(memDC);
		DrawProcessData(memDC);
		DrawExpectionAear(memDC);
		DrawUserDefectArea(memDC);


		if(m_bitModeDisplay.at(MODE_MARK_REG))
		{
			Draw_TrakerRect(m_refMark.rc,memDC);
		}
		else if(((m_bitModeDisplay.at(MODE_USER_DEFECT_AREA)) || (m_bitModeDisplay.at(MODE_COMPARE_PANEL) == true)) && (m_pCompareArea != nullptr))
		{
			Draw_CompareRect(m_pCompareArea->rc, memDC);
		}
	}
	*/

	/*
	memDC.SetBkMode(TRANSPARENT);
	memDC.SetTextColor(RGB(0,0,255));
	//memDC.SetTextColor(RGB(45,200,45));
	CString str;
	str.Format(_T("%d"),m_ptOrg.y);
	memDC.TextOut(m_WndRect.Width() - 50,10,str);

	int nTmp = int((m_ptMouseCurrent.y/ m_dZoom) * m_szImg.cx + m_ptOrg.x + (m_ptMouseCurrent.x / m_dZoom));

	int			nMaxLine = MAX_LIMIT_LINE * IMAGE_WIDTH;

	if(m_szTotBuffer.cy > 0)
	{
		nMaxLine = (m_szTotBuffer.cy-1) * IMAGE_HEIGHT  * m_szTotBuffer.cx;
	}

	if(nTmp > -1 && nTmp < nMaxLine && m_ptOrg.y >= 0 && m_ptOrg.x >= 0 && m_pBuffer != NULL)
	{
		str.Format(_T("(%d / %d) [%d]"),  m_ptOrg.x + int(m_ptMouseCurrent.x / m_dZoom) , m_ptOrg.y + int(m_ptMouseCurrent.y / m_dZoom)
			, m_pBuffer[nTmp]);

		memDC.TextOut(10,m_WndRect.Height() - 40,str);
	}

	*/
	/*
	GetDC()->BitBlt(0,0,m_WndRect.Width(),m_WndRect.Height(),&memDC,0,0,SRCCOPY);
	memDC.SelectObject(pOldBitmap);
	Bitmap.DeleteObject();
	ReleaseDC(&memDC);
	ReleaseDC(pDC);
	*/
}

void CEdgeImageViewer::UpdateView_Image(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL)
		return;

	StretchDIBits(memDC->m_hDC, 0 , 0, m_rtWnd.Width(),m_rtWnd.Height(),
		m_ptDisplayStart_pxl.x,0,int(m_rtWnd.Width()/ m_dZoom),int(m_rtWnd.Height()/ m_dZoom),
		m_pBuffer,(BITMAPINFO*)m_pBmInfo,DIB_RGB_COLORS,SRCCOPY);
}

void CEdgeImageViewer::UpdateView_SideName(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL)
		return;

	memDC->SetBkMode(TRANSPARENT);

	CFont newFont;
	newFont.CreateFont(25 , 15, 0, 0, 900 , FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,_T("Arial"));

	CFont* pOldFont = memDC->SelectObject(&newFont);
	memDC->SetTextColor(RGB(45,200,45));
	memDC->TextOut(0,0, g_SideName[m_nSideIdx]);
	memDC->SetBkMode(OPAQUE);
	memDC->SelectObject(pOldFont);

	newFont.DeleteObject();
}

void CEdgeImageViewer::UpdateView_MousePosInfo(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL)
		return;

	memDC->SetBkMode(TRANSPARENT);
	memDC->SetTextColor(RGB(0,0,255));

	// CFont newFont;
	// newFont.CreateFont(25 , 15, 0, 0, 900 , FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,_T("Arial"));

	CString strTemp;
	strTemp.Format(_T("%d"),m_ptDisplayStart_pxl.y);
	memDC->TextOut(m_rtWnd.Width() - 50, 10, strTemp);

	if(m_ptMousePos_Pxl.x < 0 || m_nFrameWidth <= m_ptMousePos_Pxl.x)
		return;

	if(m_ptMousePos_Pxl.y < 0 || m_nTotalHeight <= m_ptMousePos_Pxl.y)
		return;

	int nYPos = m_ptMousePos_Pxl.y - m_ptDisplayStart_pxl.y;	// Recipe View¿¡¼­ Scroll ÇÒ ¶§ ¹öÆÛ À§Ä¡¸¦ ¹Ù²Þ;;;

	int nPos = (nYPos * m_nFrameWidth) + m_ptMousePos_Pxl.x;

	if(nPos < 0 || m_nTotalHeight * m_nFrameWidth <= nPos)
		return;

	strTemp.Format(_T("(%d / %d) [%d]"), m_ptMousePos_Pxl.x, m_ptMousePos_Pxl.y, m_pBuffer[nPos]);
	memDC->TextOut(10, m_rtWnd.Height() - 45, strTemp);

#if HALCON_VISION_KEY
	if ((0 != m_ptMouseDown.x || 0 != m_ptMouseDown.y) && BlVision_GetVisionRecipe()->getVisionSetOpen()) {    //Êó±ê¸Ä±ä
		strTemp.Format(_T("(%d / %d)"), m_ptMouseDown.x, m_ptMouseDown.y);
		memDC->TextOut(10, m_rtWnd.Height() - 25, strTemp);

		Point2I point, result, topResult, botResult;
		point.x = m_ptMouseDown.x;
		point.y = m_ptMouseDown.y;
		if (BlVision_GetSoftVisionApp()->transformToStandard(m_nSideIdx, point, result, topResult, botResult)) {
			strTemp.Format(_T("(%d / %d)"), result.x, result.y);
			memDC->TextOut(110, m_rtWnd.Height() - 25, strTemp);

			strTemp.Format(_T("(%d / %d)"), topResult.x, topResult.y);
			memDC->TextOut(210, m_rtWnd.Height() - 25, strTemp);

			strTemp.Format(_T("(%d / %d)"), botResult.x, botResult.y);
			memDC->TextOut(310, m_rtWnd.Height() - 25, strTemp);
		}
	}
#endif // HALCON_VISION_KEY

	// newFont.DeleteObject();
}

void CEdgeImageViewer::UpdateView_InspectArea(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_INSPECT_AREA] == FALSE)
		return;

	CPen pen_SideLine(PS_DASH, 1, RGB(255,127,39));
	CPen pen_ChamferLine(PS_DASH, 1, RGB(255,255,0));
	CPen pen_Green(PS_SOLID, 1, RGB(0,220,0));
	CPen pen_FilterLine(PS_DOT, 1, RGB(0,220,0));

	CBrush brush_Null;
	brush_Null.CreateStockObject(NULL_BRUSH);

	CPen* pOldPen = (CPen*) memDC->SelectObject(&pen_SideLine);
	CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);

	CRect rcTmp,rtRealPos;
	int nFilterLine;
	int nChamferLine;

	for(int nFrameIdx = 0; nFrameIdx < MAX_IMAGE_FRAME; nFrameIdx++)
	{
		CRect rtArea_Inspect = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtInspectArea[nFrameIdx];
		int nSideLine = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nSideLineFrame[nFrameIdx];
		int nSideChamferLine = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nSide_Chamfer_LineFrame[nFrameIdx];

		// Side Line
		rtRealPos = rtArea_Inspect;
		nFilterLine = nSideLine;

		if(0 < nFilterLine)
		{
			memDC->SelectObject(&pen_SideLine);
			memDC->MoveTo(int((nFilterLine  - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top	- m_ptDisplayStart_pxl.y) * m_dZoom));
			memDC->LineTo(int((nFilterLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom	- m_ptDisplayStart_pxl.y) * m_dZoom));
		}

		if(0 < nSideChamferLine)
		{
			memDC->SelectObject(&pen_ChamferLine);
			memDC->MoveTo(int((nSideChamferLine  - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top	- m_ptDisplayStart_pxl.y) * m_dZoom));
			memDC->LineTo(int((nSideChamferLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom	- m_ptDisplayStart_pxl.y) * m_dZoom));
		}
		
		for(int nInsType = 0; nInsType < MAX_SIDE_INSPECT_TYPE; nInsType++)
		{
			CRect rtArea = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtInspectArea_InsType[nInsType][nFrameIdx];
			int nFilterLine = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nSideFilterLine_InsType[nInsType][nFrameIdx];

			rtRealPos = rtArea;
			nFilterLine = nFilterLine;

			if(rtRealPos.IsRectEmpty() != TRUE && rtRealPos.IsRectNull() != TRUE)
			{
				rcTmp.left		= int((rtRealPos.left   - m_ptDisplayStart_pxl.x )	* m_dZoom);
				rcTmp.right		= int((rtRealPos.right  - m_ptDisplayStart_pxl.x )	* m_dZoom);
				rcTmp.top		= int((rtRealPos.top	- m_ptDisplayStart_pxl.y)	* m_dZoom);
				rcTmp.bottom	= int((rtRealPos.bottom	- m_ptDisplayStart_pxl.y)	* m_dZoom);

				if(rcTmp.top < 0 && rcTmp.bottom > 0 || rcTmp.top > 0 && rcTmp.top < m_rtWnd.bottom +1 || rcTmp.bottom > 0 && rcTmp.bottom < m_rtWnd.bottom +1)
				{
					memDC->SelectObject(&pen_Green);
					memDC->MoveTo(int((rtRealPos.left  - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top	- m_ptDisplayStart_pxl.y) * m_dZoom));
					memDC->LineTo(int((rtRealPos.right - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top	- m_ptDisplayStart_pxl.y) * m_dZoom));
					memDC->LineTo(int((rtRealPos.right - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom	- m_ptDisplayStart_pxl.y) * m_dZoom));
					memDC->LineTo(int((rtRealPos.left  - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom	- m_ptDisplayStart_pxl.y) * m_dZoom));
					memDC->LineTo(int((rtRealPos.left  - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top	- m_ptDisplayStart_pxl.y) * m_dZoom));
				}

				if(0 < nFilterLine)
				{
					memDC->SelectObject(&pen_FilterLine);
					memDC->MoveTo(int((nFilterLine  - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top	- m_ptDisplayStart_pxl.y) * m_dZoom));
					memDC->LineTo(int((nFilterLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom	- m_ptDisplayStart_pxl.y) * m_dZoom));
				}
			}
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);
	brush_Null.DeleteObject();
}

void CEdgeImageViewer::UpdateView_NotchArea(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_NOTCH_AREA] == FALSE)
		return;

	CPen   penRed(PS_SOLID, 2, RGB(255,0,0)), *pOldPen;
	CBrush brush_Null, *pOldBrush;
	CRect rc,rc1;

	brush_Null.CreateStockObject(NULL_BRUSH);

	pOldPen		= memDC->SelectObject(&penRed);
	pOldBrush   = memDC->SelectObject(&brush_Null);

	memDC->SetTextColor(RGB(0,0,255));

	int nNotchCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCount;

	for(int i=0; i<nNotchCount; i++)
	{
		CRect rtNotchArea_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtNotchArea_pxl[i];
		CRect rtNotchArea_wnd = GetWndPos(rtNotchArea_pxl);

		if(rtNotchArea_wnd.IsRectEmpty() != TRUE && rtNotchArea_wnd.IsRectNull() != TRUE)
		{
			memDC->Rectangle(rtNotchArea_wnd);

			CString strTemp;
			strTemp.Format(_T("Notch Area [%d]"), i+1);
			memDC->TextOut(rtNotchArea_wnd.left, rtNotchArea_wnd.top - 20, strTemp);
		}

		// Notch Circle
		int nNotchCircleCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircleCount[i];

		for(int j=0; j<nNotchCircleCount; j++)
		{
			CRect rtNotchCircleArea = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtNotchCircleArea_pxl[i][j];
			CRect rtNotchCircleArea_wnd = GetWndPos(rtNotchCircleArea);

			if(rtNotchCircleArea_wnd.IsRectEmpty() != TRUE && rtNotchCircleArea_wnd.IsRectNull() != TRUE)
			{
				memDC->Rectangle(rtNotchCircleArea_wnd);

				CString strTemp;
				strTemp.Format(_T("Notch Area [%d] - Notch Circle Area [%d]"), i+1, j+1);
				memDC->TextOut(rtNotchCircleArea_wnd.left, rtNotchCircleArea_wnd.top - 20, strTemp);
			}
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);

	brush_Null.DeleteObject();
}

void CEdgeImageViewer::UpdateView_NotchMeasure(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL || m_pGlassData->GetSideData((DimensionDir)m_nSideIdx) == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_NOTCH_MEASURE] == FALSE)
		return;

	CBrush brush_Ref_Rect;
	brush_Ref_Rect.CreateSolidBrush(RGB(0,162,232));	

	CPen	*pOldPen;
	CPen   pen_Dash_Orange(PS_DASHDOTDOT, 1, RGB(250, 150, 0));
	CPen   pen_Solid_Green(PS_SOLID, 1, RGB(0,150,0));
	CPen   pen_Solid_Red(PS_SOLID, 1, RGB(150,0,0));

	CBrush brush_Null, *pOldBrush;
	CRect rc,rc1;

	brush_Null.CreateStockObject(NULL_BRUSH);

	pOldPen		= memDC->SelectObject(&pen_Solid_Green);
	pOldBrush   = memDC->SelectObject(&brush_Null);

	memDC->SetTextColor(RGB(0,0,255));

	CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir)m_nSideIdx);
	int nNotchCount = pSideData->m_nNotchCount;

	for(int i=0; i<nNotchCount; i++)
	{
		for(int j=0; j<MAX_SIDE_NOTCH_MEASURE_COUNT; j++)
		{
			CPoint ptRef_pxl = pSideData->m_ptNotch_Reference[i][j];
			CPoint ptDimension_Edge_pxl = pSideData->m_ptNotch_Dimension_Edge[i][j];
			CPoint ptChamfer_Edge_pxl = pSideData->m_ptNotch_Chamfer_Edge[i][j];

			CPoint ptRef_wnd = GetWndPos(ptRef_pxl);
			CPoint ptDimension_Edge_wnd = GetWndPos(ptDimension_Edge_pxl);
			CPoint ptChamfer_Edge_wnd = GetWndPos(ptChamfer_Edge_pxl);

			CRect rectRef = CRect(ptRef_pxl, ptRef_pxl);
			rectRef.InflateRect(3, 3);

			memDC->SelectObject(brush_Ref_Rect);
			memDC->FillRect(&rectRef, &brush_Ref_Rect);

			if(pSideData->m_nNotch_Dimension_Edge_Judge[i][j] != 0)
			{
				if(pSideData->m_nNotch_Dimension_Edge_Judge[i][j] == 1)
					memDC->SelectObject(&pen_Solid_Green);
				else
					memDC->SelectObject(&pen_Solid_Red);

				memDC->MoveTo(ptDimension_Edge_wnd.x-5, ptDimension_Edge_wnd.y);
				memDC->LineTo(ptDimension_Edge_wnd.x+5, ptDimension_Edge_wnd.y);
				memDC->MoveTo(ptDimension_Edge_wnd.x,   ptDimension_Edge_wnd.y-5);
				memDC->LineTo(ptDimension_Edge_wnd.x,   ptDimension_Edge_wnd.y+5);

				memDC->SelectObject(&pen_Dash_Orange);
				memDC->MoveTo(ptRef_wnd.x,ptRef_wnd.y);
				memDC->LineTo(ptDimension_Edge_wnd.x,ptDimension_Edge_wnd.y);
			}

			if(pSideData->m_nNotch_Chamfer_Edge_Judge[i][j] != 0)
			{
				if(pSideData->m_nNotch_Chamfer_Edge_Judge[i][j] == 1)
					memDC->SelectObject(&pen_Solid_Green);
				else
					memDC->SelectObject(&pen_Solid_Red);

				memDC->MoveTo(ptChamfer_Edge_wnd.x-5, ptChamfer_Edge_wnd.y);
				memDC->LineTo(ptChamfer_Edge_wnd.x+5, ptChamfer_Edge_wnd.y);
				memDC->MoveTo(ptChamfer_Edge_wnd.x,   ptChamfer_Edge_wnd.y-5);
				memDC->LineTo(ptChamfer_Edge_wnd.x,   ptChamfer_Edge_wnd.y+5);

				memDC->SelectObject(&pen_Dash_Orange);
				memDC->MoveTo(ptDimension_Edge_wnd.x,ptDimension_Edge_wnd.y);
				memDC->LineTo(ptChamfer_Edge_wnd.x,ptChamfer_Edge_wnd.y);
			}

			if(pSideData->m_nNotch_Dimension_Edge_Judge[i][j] != 0 || pSideData->m_nNotch_Chamfer_Edge_Judge[i][j] != 0)
			{
				if(1 < pSideData->m_nNotch_Dimension_Edge_Judge[i][j] || 1 < pSideData->m_nNotch_Chamfer_Edge_Judge[i][j])
					memDC->SetTextColor(RGB(255,0,0));
				else
					memDC->SetTextColor(RGB(0,255,0));

				CString strTemp;
				strTemp.Format(_T("%s"), (CString)pSideData->m_strNotchMeasure_Comment[i][j]);
				CRect rtTemp(ptRef_wnd.x + 10, ptRef_wnd.y-10, ptRef_wnd.x + 1024, ptRef_wnd.y + 20);
				memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
			}
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);

	brush_Null.DeleteObject();
	brush_Ref_Rect.DeleteObject();
}

void CEdgeImageViewer::UpdateView_Notch_Circle_Measure(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_NOTCH_MEASURE] == FALSE)
		return;

	CBrush brush_Ref_Rect;
	brush_Ref_Rect.CreateSolidBrush(RGB(0,162,232));	

	CPen	*pOldPen;
	CPen   pen_Dash_Orange(PS_DASHDOTDOT, 1, RGB(250, 150, 0));
	CPen   pen_Solid_Green(PS_SOLID, 1, RGB(0,150,0));
	CPen   pen_Solid_Red(PS_SOLID, 1, RGB(150,0,0));

	CBrush brush_Null, *pOldBrush;
	CRect rc,rc1;

	brush_Null.CreateStockObject(NULL_BRUSH);

	pOldPen		= memDC->SelectObject(&pen_Solid_Green);
	pOldBrush   = memDC->SelectObject(&brush_Null);

	memDC->SetTextColor(RGB(0,0,255));

	int nNotchCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCount;

	for(int i=0; i<nNotchCount; i++)
	{
		for(int j=0; j<MAX_SIDE_NOTCH_CIRCLE_COUNT; j++)
		{
			if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircle_Radius_Judge[i][j] == 0)
				continue;

			if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircle_Radius_Judge[i][j] == 1)
				memDC->SelectObject(&pen_Solid_Green);
			else
				memDC->SelectObject(&pen_Solid_Red);

			CPoint ptCircleCenter_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_ptNotchCircle_Center_pxl[i][j];
			
			int nCircleRadius_X_pxl = (int)(m_pGlassData->GetSideData((DimensionDir)m_nSideIdx)->m_ptNotchCircle_Radius_Result_X_pxl[i][j]);
			int nCircleRadius_Y_pxl = (int)(m_pGlassData->GetSideData((DimensionDir)m_nSideIdx)->m_ptNotchCircle_Radius_Result_Y_pxl[i][j]);

			CRect rtCircleArea_pxl = CRect(ptCircleCenter_pxl.x, ptCircleCenter_pxl.y, ptCircleCenter_pxl.x, ptCircleCenter_pxl.y);
			rtCircleArea_pxl.InflateRect(nCircleRadius_X_pxl, nCircleRadius_Y_pxl);

			CRect rtCircleArea_pxl_wnd = GetWndPos(rtCircleArea_pxl);

			memDC->Ellipse(rtCircleArea_pxl_wnd);

			// Measure Result Text..
			if(1 < m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircle_Radius_Judge[i][j])
				memDC->SetTextColor(RGB(255,0,0));
			else
				memDC->SetTextColor(RGB(0,255,0));

			CRect rtCircleArea = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtNotchCircleArea_pxl[i][j];
			CPoint ptPos = rtCircleArea.CenterPoint();
			ptPos.x = rtCircleArea.left;
			CPoint ptPos_wnd = GetWndPos(ptPos);

			CString strTemp;
			strTemp.Format(_T("%s"), (CString) m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_strNotchCircle_Radius_Comment[i][j]);
			CRect rtTemp(ptPos_wnd.x + 10, ptPos_wnd.y-10, ptPos_wnd.x + 1024, ptPos_wnd.y + 20);
			memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);

	brush_Null.DeleteObject();
	brush_Ref_Rect.DeleteObject();
}

void CEdgeImageViewer::UpdateView_Corner(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_CORNER_AREA] == FALSE)
		return;

	CPen pen(PS_SOLID, 1,RGB(0,255,0));
	CPen pen_OffsetLine(PS_DOT, 1,RGB(0,255,0));

	CBrush brush_Null;
	brush_Null.CreateStockObject(NULL_BRUSH);

	CPen* pOldPen = memDC->SelectObject(&pen);
	CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);

	CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
	if(pSideData == NULL)
		return;

	if(pSideData->m_bTopCorner_Find == TRUE)
	{
		CRect rtCornerPos_pxl = pSideData->m_rtTopCornerArea;
		CRect rtCornerPos_wnd = GetWndPos(rtCornerPos_pxl);
		
		CRect rtCornerPos_Offset_pxl = pSideData->m_rtTopCornerArea_Offset;
		CRect rtCornerPos_Offset_wnd = GetWndPos(rtCornerPos_Offset_pxl);
		CRect rtCornerPos_Ins_pxl = pSideData->m_rtTopCornerArea_Ins;
		CRect rtCornerPos_Ins_wnd = GetWndPos(rtCornerPos_Ins_pxl);

		if(pSideData->m_nTopCornerShape == 0)		// None
		{
			memDC->SelectObject(&pen);

			memDC->Rectangle(rtCornerPos_wnd);
			memDC->Rectangle(rtCornerPos_Ins_wnd);

			memDC->SelectObject(&pen_OffsetLine);
			memDC->Rectangle(rtCornerPos_Offset_wnd);
		}
		else if(pSideData->m_nTopCornerShape == 1)	// CCUT
		{
			memDC->SelectObject(&pen);
			
			// Corner LIne
			memDC->MoveTo(rtCornerPos_wnd.left, rtCornerPos_wnd.bottom);
			memDC->LineTo(rtCornerPos_wnd.right, rtCornerPos_wnd.top);

			// Ins Line
			memDC->MoveTo(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.bottom);
			memDC->LineTo(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.top);

			// Offset Line
			memDC->SelectObject(&pen_OffsetLine);
			memDC->MoveTo(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.bottom);
			memDC->LineTo(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.top);

			CPoint		ptPoint,ptDraw;
			CPen		pen2(PS_DASH , 1,RGB(255,0,255));

			if(pSideData->m_bTopCorner_Measure == TRUE)
			{				
				memDC->SelectObject(&pen2);
				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top-20);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);				

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].right,pSideData->m_rtTopCornerResult[1].top-20);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].right,pSideData->m_rtTopCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top-10);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].right,pSideData->m_rtTopCornerResult[1].top-10);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 20,pSideData->m_rtTopCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 20,pSideData->m_rtTopCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 10,pSideData->m_rtTopCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 10,pSideData->m_rtTopCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				if(pSideData->m_bTopCornerMeasureResult == FALSE)
					memDC->SetTextColor(RGB(255,0,0));
				else
					memDC->SetTextColor(RGB(0,255,0));

				CRect rtCircleArea = pSideData->m_rtTopCornerResult[1];
				CPoint ptPos = rtCircleArea.CenterPoint();
				ptPos.x = rtCircleArea.left;
				CPoint ptPos_wnd = GetWndPos(ptPos);

				CString strTemp;
				strTemp.Format(_T("Corner Width %d um, Height %d um"), pSideData->m_nTopCornerWidth,pSideData->m_nTopCornerHeight);
				CRect rtTemp(ptPos_wnd.x + 10, ptPos_wnd.y-10, ptPos_wnd.x + 1024, ptPos_wnd.y + 20);
				memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
			}

			//////////////////////////////////////////////////////////////////////////
			if(pSideData->m_bBotCorner_Measure == TRUE)
			{
				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].right,pSideData->m_rtBottomCornerResult[1].bottom + 20);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].right,pSideData->m_rtBottomCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom + 10);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].right,pSideData->m_rtBottomCornerResult[1].bottom + 10);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 20,pSideData->m_rtBottomCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 20,pSideData->m_rtBottomCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 10,pSideData->m_rtBottomCornerResult[1].top);
				ptDraw = GetWndPos(ptPoint);
				memDC->MoveTo(ptDraw.x,ptDraw.y);

				ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 10,pSideData->m_rtBottomCornerResult[1].bottom);
				ptDraw = GetWndPos(ptPoint);
				memDC->LineTo(ptDraw.x,ptDraw.y);

				if(pSideData->m_bBottomMeasureResult == FALSE)
					memDC->SetTextColor(RGB(255,0,0));
				else
					memDC->SetTextColor(RGB(0,255,0));

				CRect rtCircleArea = pSideData->m_rtBottomCornerResult[1];
				CPoint ptPos = rtCircleArea.CenterPoint();
				ptPos.x = rtCircleArea.left;
				CPoint ptPos_wnd = GetWndPos(ptPos);

				CString strTemp;
				strTemp.Format(_T("Corner Width %d um, Height %d um"), pSideData->m_nBottomCornerWidth,pSideData->m_nBottomCornerHeight);
				CRect rtTemp(ptPos_wnd.x + 10, ptPos_wnd.y-10, ptPos_wnd.x + 1024, ptPos_wnd.y + 20);
				memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
			}			
		}
		else if(pSideData->m_nTopCornerShape == 2)	// RCUT
		{
			memDC->SelectObject(&pen);

			// Out Line
			CRect rtCircle_wnd;
			rtCircle_wnd.left = rtCornerPos_wnd.left;
			rtCircle_wnd.top = rtCornerPos_wnd.top;
			rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_wnd.Width() * 2);
			rtCircle_wnd.bottom = rtCircle_wnd.top + (rtCornerPos_wnd.Height() * 2);

			CPoint ptCorner_LB = CPoint(rtCornerPos_wnd.left, rtCornerPos_wnd.bottom);
			CPoint ptCorner_RT = CPoint(rtCornerPos_wnd.right, rtCornerPos_wnd.top);

			memDC->Arc(rtCircle_wnd, ptCorner_RT, ptCorner_LB);

			// Ins Line
			rtCircle_wnd.left = rtCornerPos_Ins_wnd.left;
			rtCircle_wnd.top = rtCornerPos_Ins_wnd.top;
			rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Ins_wnd.Width() * 2);
			rtCircle_wnd.bottom = rtCircle_wnd.top + (rtCornerPos_Ins_wnd.Height() * 2);

			CPoint ptCorner_Ins_LB = CPoint(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.bottom);
			CPoint ptCorner_Ins_RT = CPoint(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.top);

			memDC->Arc(rtCircle_wnd, ptCorner_Ins_RT, ptCorner_Ins_LB);

			// Offset Line
			rtCircle_wnd.left = rtCornerPos_Offset_wnd.left;
			rtCircle_wnd.top = rtCornerPos_Offset_wnd.top;
			rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Offset_wnd.Width() * 2);
			rtCircle_wnd.bottom = rtCircle_wnd.top + (rtCornerPos_Offset_wnd.Height() * 2);

			CPoint ptCorner_Offset_LB = CPoint(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.bottom);
			CPoint ptCorner_Offset_RT = CPoint(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.top);

			memDC->SelectObject(&pen_OffsetLine);
			memDC->Arc(rtCircle_wnd, ptCorner_Offset_RT, ptCorner_Offset_LB);
		}
	}

	if(pSideData->m_bBotMark_Find == TRUE)
	{
		CRect rtCornerPos_pxl = pSideData->m_rtBotCornerArea;
		CRect rtCornerPos_wnd = GetWndPos(rtCornerPos_pxl);

		CRect rtCornerPos_Offset_pxl = pSideData->m_rtBotCornerArea_Offset;
		CRect rtCornerPos_Offset_wnd = GetWndPos(rtCornerPos_Offset_pxl);
		CRect rtCornerPos_Ins_pxl = pSideData->m_rtBotCornerArea_Ins;
		CRect rtCornerPos_Ins_wnd = GetWndPos(rtCornerPos_Ins_pxl);

		if(pSideData->m_nBotCornerShape == 0)		// None
		{
			memDC->SelectObject(&pen);

			memDC->Rectangle(rtCornerPos_wnd);
			memDC->Rectangle(rtCornerPos_Ins_wnd);

			memDC->SelectObject(&pen_OffsetLine);
			memDC->Rectangle(rtCornerPos_Offset_wnd);
		}
		else if(pSideData->m_nBotCornerShape == 1)	// CCUT
		{
			memDC->SelectObject(&pen);

			// Corner Line
			memDC->MoveTo(rtCornerPos_wnd.left, rtCornerPos_wnd.top);
			memDC->LineTo(rtCornerPos_wnd.right, rtCornerPos_wnd.bottom);

			// Ins Line
			memDC->MoveTo(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.top);
			memDC->LineTo(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.bottom);

			// Offset Line
			memDC->SelectObject(&pen_OffsetLine);
			memDC->MoveTo(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.top);
			memDC->LineTo(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.bottom);
		}
		else if(pSideData->m_nBotCornerShape == 2)	// RCUT
		{
			memDC->SelectObject(&pen);

			// Out Line
			CRect rtCircle_wnd;
			rtCircle_wnd.left = rtCornerPos_wnd.left;
			rtCircle_wnd.bottom = rtCornerPos_wnd.bottom;
			rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_wnd.Width() * 2);
			rtCircle_wnd.top = rtCircle_wnd.bottom - (rtCornerPos_wnd.Height() * 2);

			CPoint ptCorner_LT = CPoint(rtCornerPos_wnd.left, rtCornerPos_wnd.top);
			CPoint ptCorner_RB = CPoint(rtCornerPos_wnd.right, rtCornerPos_wnd.bottom);

			memDC->Arc(rtCircle_wnd, ptCorner_LT, ptCorner_RB);

			// Ins Line
			rtCircle_wnd.left = rtCornerPos_Ins_wnd.left;
			rtCircle_wnd.bottom = rtCornerPos_Ins_wnd.bottom;
			rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Ins_wnd.Width() * 2);
			rtCircle_wnd.top = rtCircle_wnd.bottom - (rtCornerPos_Ins_wnd.Height() * 2);

			CPoint ptCorner_Ins_LT = CPoint(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.top);
			CPoint ptCorner_Ins_RB = CPoint(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.bottom);

			memDC->Arc(rtCircle_wnd, ptCorner_Ins_LT, ptCorner_Ins_RB);

			// Offset Line
			rtCircle_wnd.left = rtCornerPos_Offset_wnd.left;
			rtCircle_wnd.bottom = rtCornerPos_Offset_wnd.bottom;
			rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Offset_wnd.Width() * 2);
			rtCircle_wnd.top = rtCircle_wnd.bottom - (rtCornerPos_Offset_wnd.Height() * 2);

			CPoint ptCorner_Offset_LT = CPoint(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.top);
			CPoint ptCorner_Offset_RB = CPoint(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.bottom);

			memDC->SelectObject(&pen_OffsetLine);
			memDC->Arc(rtCircle_wnd, ptCorner_Offset_LT, ptCorner_Offset_RB);
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(brush_Null);
	brush_Null.DeleteObject();
}

void CEdgeImageViewer::UpdateView_Mark(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_MARK_AREA] == FALSE)
		return;

	CPen pen(PS_SOLID, 1,RGB(0,255,255));
	CPen pen_SearchArea(PS_DASH, 1,RGB(255,255,0));
	CPen pen_TopToBotLine(PS_DASH, 1,RGB(255,0,255));

	CBrush brush_Null;
	brush_Null.CreateStockObject(NULL_BRUSH);

	CPen* pOldPen = memDC->SelectObject(&pen);
	CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);

	CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
	if(pSideData == NULL)
		return;

	if(pSideData->m_bTopMark_Find == TRUE)
	{
		CRect rtMarkPos_pxl = pSideData->m_rtTopMark_FindResult;
		CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
		CRect rtMarkSearchPos_pxl = pSideData->m_rtTopMark_SearchArea;
		CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkSearchPos_pxl);

		CPoint ptMarkPos_wnd = rtMarkPos_wnd.CenterPoint();
		int nHalfW_wnd = rtMarkPos_wnd.Width() / 2;
		int nHalfH_wnd = rtMarkPos_wnd.Height() / 2;

		memDC->SelectObject(&pen);
		memDC->MoveTo(ptMarkPos_wnd.x-nHalfW_wnd	, ptMarkPos_wnd.y);
		memDC->LineTo(ptMarkPos_wnd.x+nHalfW_wnd	, ptMarkPos_wnd.y);
		memDC->MoveTo(ptMarkPos_wnd.x	, ptMarkPos_wnd.y-nHalfH_wnd);
		memDC->LineTo(ptMarkPos_wnd.x	, ptMarkPos_wnd.y+nHalfH_wnd);
		memDC->Rectangle(rtMarkPos_wnd);

		memDC->SelectObject(&pen_SearchArea);
		memDC->Rectangle(rtMarkSearchPos_wnd);
	}

	if(pSideData->m_bBotMark_Find == TRUE)
	{
		CRect rtMarkPos_pxl = pSideData->m_rtBotMark_FindResult;
		CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
		CRect rtMarkSearchPos_pxl = pSideData->m_rtBotMark_SearchArea;
		CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkSearchPos_pxl);

		CPoint ptMarkPos_wnd = rtMarkPos_wnd.CenterPoint();
		int nHalfW_wnd = rtMarkPos_wnd.Width() / 2;
		int nHalfH_wnd = rtMarkPos_wnd.Height() / 2;

		memDC->SelectObject(&pen);
		memDC->MoveTo(ptMarkPos_wnd.x-nHalfW_wnd	, ptMarkPos_wnd.y);
		memDC->LineTo(ptMarkPos_wnd.x+nHalfW_wnd	, ptMarkPos_wnd.y);
		memDC->MoveTo(ptMarkPos_wnd.x	, ptMarkPos_wnd.y-nHalfH_wnd);
		memDC->LineTo(ptMarkPos_wnd.x	, ptMarkPos_wnd.y+nHalfH_wnd);
		memDC->Rectangle(rtMarkPos_wnd);

		memDC->SelectObject(&pen_SearchArea);
		memDC->Rectangle(rtMarkSearchPos_wnd);
	}

	if(pSideData->m_bTopMark_Find == TRUE && pSideData->m_bBotMark_Find == TRUE)
	{
		
		memDC->SelectObject(&pen_TopToBotLine);
		CPoint ptTopMark = pSideData->m_ptTopMark_FindResult;
		CPoint ptBotMark = pSideData->m_ptBotMark_FindResult;
		CPoint ptTopMark_Wnd = GetWndPos(ptTopMark);
		CPoint ptBotMark_Wnd = GetWndPos(ptBotMark);
		memDC->MoveTo(ptTopMark_Wnd.x, ptTopMark_Wnd.y);
		memDC->LineTo(ptBotMark_Wnd.x, ptBotMark_Wnd.y);		
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);
	brush_Null.DeleteObject();
}

void CEdgeImageViewer::UpdateView_UserDefectArea(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA] == FALSE)
		return;

	CPen   penRed(PS_SOLID, 2, RGB(255,255,0)), *pOldPen;
	CBrush hackBrush,*pOldBrush;
	CRect rc,rc1;
	hackBrush.CreateHatchBrush(HS_BDIAGONAL, RGB(0,255,255));

	pOldPen		= memDC->SelectObject(&penRed);
	pOldBrush   = memDC->SelectObject(&hackBrush);

	memDC->SetTextColor(RGB(0,0,255));

	int nUserDefectAreaCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nUserDefectAreaCount;

	for(int i=0; i<nUserDefectAreaCount; i++)
	{
		CRect rtUserDefectArea_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtUserDefectArea_pxl[i];
		CRect rtUserDefectArea_wnd = GetWndPos(rtUserDefectArea_pxl);

		if(rtUserDefectArea_wnd.IsRectEmpty() != TRUE && rtUserDefectArea_wnd.IsRectNull() != TRUE)
		{
			memDC->Rectangle(rtUserDefectArea_wnd);

			CString strTemp;
			strTemp.Format(_T("User Defect Area [%d]"), i+1);
			memDC->TextOut(rtUserDefectArea_wnd.left, rtUserDefectArea_wnd.top - 20, strTemp);
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);

	hackBrush.DeleteObject();
}

void CEdgeImageViewer::UpdateView_ExceptionArea(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_EXCEPTION_AREA] == FALSE)
		return;

	CPen   penRed(PS_SOLID, 2, RGB(255,0,0)), *pOldPen;
	CBrush hackBrush,*pOldBrush;
	CRect rc,rc1;
	hackBrush.CreateHatchBrush(HS_DIAGCROSS, RGB(0,255,255));

	pOldPen		= memDC->SelectObject(&penRed);
	pOldBrush   = memDC->SelectObject(&hackBrush);

	memDC->SetTextColor(RGB(0,0,255));

	int nExceptionAreaCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nExceptionAreaCount;

	for(int i=0; i<nExceptionAreaCount; i++)
	{
		CRect rtExceptionArea_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtExceptionArea_pxl[i];
		CRect rtExceptionArea_wnd = GetWndPos(rtExceptionArea_pxl);

		if(rtExceptionArea_wnd.IsRectEmpty() != TRUE && rtExceptionArea_wnd.IsRectNull() != TRUE)
		{
			memDC->Rectangle(rtExceptionArea_wnd);

			CString strTemp;
			strTemp.Format(_T("Exception Area [%d]"), i+1);
			memDC->TextOut(rtExceptionArea_wnd.left, rtExceptionArea_wnd.top - 20, strTemp);
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);

	hackBrush.DeleteObject();
}

void CEdgeImageViewer::UpdateView_StartEndLine(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_START_END_LINE] == FALSE)
		return;

	CPen pen(PS_SOLID, 2,RGB(0,0,255));
	CPen pen_PreEndLine(PS_SOLID, 1,RGB(0,255,255));
	CPen* pOldPen = memDC->SelectObject(&pen);

	memDC->SetTextColor(RGB(0,0,255));

	CString strTmp;
	int nFrameIndex =  m_ptDisplayStart_pxl.y / m_nFrameHeight;

	CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
	if(pSideData == NULL)
		return;

	if(pSideData->m_bFindGlassStartLine == TRUE)
	{
		if(pSideData->m_nGlassStartLine > 0)
		{
			int nDrawLine =  int((pSideData->m_nGlassStartLine - m_ptDisplayStart_pxl.y) * m_dZoom);
			if( nDrawLine > -1 ) 
			{
				memDC->MoveTo(0,nDrawLine);
				memDC->LineTo(m_rtWnd.Width(),nDrawLine);

				strTmp.Format(_T("Find Start Line"));
				memDC->TextOut(10,nDrawLine-20,strTmp);
			}
		}

		if(pSideData->m_nCenterJudgeArea_Start > 0)
		{
			int nDrawLine =  int((pSideData->m_nCenterJudgeArea_Start - m_ptDisplayStart_pxl.y) * m_dZoom);
			if( nDrawLine > -1 ) 
			{
				memDC->MoveTo(0,nDrawLine);
				memDC->LineTo(m_rtWnd.Width(),nDrawLine);

				strTmp.Format(_T("Judge Area 1"));
				memDC->TextOut(10,nDrawLine-20,strTmp);
			}
		}

		if(pSideData->m_nCenterJudgeArea_End > 0)
		{
			int nDrawLine =  int((pSideData->m_nCenterJudgeArea_End - m_ptDisplayStart_pxl.y) * m_dZoom);
			if( nDrawLine > -1 ) 
			{
				memDC->MoveTo(0,nDrawLine);
				memDC->LineTo(m_rtWnd.Width(),nDrawLine);

				strTmp.Format(_T("Judge Area 2"));
				memDC->TextOut(10,nDrawLine-20,strTmp);
			}
		}

		if(pSideData->m_nPreGlassEndLine > 0)
		{
			memDC->SelectObject(&pen_PreEndLine);

			int nDrawLine =  int((pSideData->m_nPreGlassEndLine - m_ptDisplayStart_pxl.y) * m_dZoom);
			if( nDrawLine > -1 ) 
			{
				memDC->MoveTo(0,nDrawLine);
				memDC->LineTo(m_rtWnd.Width(),nDrawLine);
			}
		}
	}

	if(pSideData->m_bFindGlassEndLine == TRUE)
	{
		if(pSideData->m_nGlassEndLine > 0)
		{
			memDC->SelectObject(&pen);

			int nDrawLine =  int((pSideData->m_nGlassEndLine - m_ptDisplayStart_pxl.y) * m_dZoom);
			if( nDrawLine > -1 ) 
			{
				memDC->MoveTo(0,nDrawLine);
				memDC->LineTo(m_rtWnd.Width(),nDrawLine);

				strTmp.Format(_T("Find End Line"));
				memDC->TextOut(10,nDrawLine+20,strTmp);
			}
		}
	}

	memDC->SelectObject(pOldPen);
}

void CEdgeImageViewer::UpdateView_Defect(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_DEFECT] == false)
		return;

	CPen pen_NG(PS_SOLID, 1, RGB(255,0,0));
	CPen pen_OK(PS_SOLID, 1, RGB(0,255,0));
	CBrush brush_Null;
	brush_Null.CreateStockObject(NULL_BRUSH);
	CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);

	int			nDefect = m_pGlassData->GetDefectCount_NG();
	CDefect*	pDefect = NULL;

	CPen* pOldPen = memDC->SelectObject(&pen_NG);

	// Draw NG
	for(int iDefect = 0; iDefect < m_pGlassData->GetDefectCount_NG(); iDefect++)
	{
		pDefect = m_pGlassData->GetDefect_NG(iDefect);

		if(pDefect == NULL)
			continue;

		if(pDefect->m_DefectInfo.m_nSideIdx != m_nSideIdx)
			continue;

		CRect rtPos_Wnd = GetWndPos(pDefect->m_DefectInfo.m_rtDefectPos_pxl);
		
		CRect rtIntersect;
		rtIntersect.IntersectRect(rtPos_Wnd, m_rtWnd);

		if(rtIntersect.IsRectEmpty() || rtIntersect.IsRectNull())
			continue;

		memDC->Rectangle(rtIntersect);
	}

	// Draw OK
	nDefect = m_pGlassData->GetDefectCount_OK();
	memDC->SelectObject(&pen_OK);

	for(int iDefect = 0; iDefect < m_pGlassData->GetDefectCount_OK(); iDefect++)
	{
		pDefect = m_pGlassData->GetDefect_OK(iDefect);

		if(pDefect == NULL)
			continue;

		if(pDefect->m_DefectInfo.m_nSideIdx != m_nSideIdx)
			continue;

		CRect rtPos_Wnd = GetWndPos(pDefect->m_DefectInfo.m_rtDefectPos_pxl);

		CRect rtIntersect;
		rtIntersect.IntersectRect(rtPos_Wnd, m_rtWnd);

		if(rtIntersect.IsRectEmpty() || rtIntersect.IsRectNull())
			continue;

		memDC->Rectangle(rtIntersect);
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);
	brush_Null.DeleteObject();
}

void CEdgeImageViewer::UpdateView_ManualMeasure(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL)
		return;

	if(m_MenuStatus[MODE_USER_SELECT] == false)
		return;

	CPen pen_Complete(PS_SOLID, 1, RGB(0,255,255));
	CPen pen_Modify(PS_SOLID, 1, RGB(255,0,0));
	CPen pen_MeasureLine(PS_DOT, 1, RGB(255,255,0));
	CPen pen_Measure_Point(PS_SOLID, 1, RGB(255,255,0));

	CPen *pOldPen;

	if(m_ManualMeasureStatus.bModifyStart == TRUE || m_ManualMeasureStatus.bModifyEnd == TRUE || m_ManualMeasureStatus.bStart == TRUE)
		pOldPen = (CPen*)memDC->SelectObject(&pen_Modify);
	else																				
		pOldPen = (CPen*)memDC->SelectObject(&pen_Complete);

	CPoint ptStart_Wnd = GetWndPos(m_ManualMeasureStatus.ptMeasureStart);
	CPoint ptEnd_Wnd = GetWndPos(m_ManualMeasureStatus.ptMeasureEnd);
	int nDistanceX_Wnd = abs(ptStart_Wnd.x - ptEnd_Wnd.x);
	int nDistanceY_wnd = abs(ptStart_Wnd.y - ptEnd_Wnd.y);

	// Line
	memDC->MoveTo(0					, ptStart_Wnd.y);
	memDC->LineTo(m_rtWnd.Width()	, ptStart_Wnd.y);
	memDC->MoveTo(ptStart_Wnd.x 		, 0);
	memDC->LineTo(ptStart_Wnd.x			, m_rtWnd.Height());
	memDC->MoveTo(0					, ptEnd_Wnd.y);
	memDC->LineTo(m_rtWnd.Width()	, ptEnd_Wnd.y);
	memDC->MoveTo(ptEnd_Wnd.x 			, 0);
	memDC->LineTo(ptEnd_Wnd.x			, m_rtWnd.Height());

	// Measure Line
	(CPen*)memDC->SelectObject(&pen_MeasureLine);
	memDC->MoveTo(ptStart_Wnd.x , ptStart_Wnd.y);
	memDC->LineTo(ptEnd_Wnd.x	, ptEnd_Wnd.y);
	memDC->MoveTo((ptStart_Wnd.x + ptEnd_Wnd.x)/2 , ptStart_Wnd.y);
	memDC->LineTo((ptStart_Wnd.x + ptEnd_Wnd.x)/2 , ptEnd_Wnd.y);
	memDC->MoveTo(ptStart_Wnd.x , (ptStart_Wnd.y + ptEnd_Wnd.y)/2);
	memDC->LineTo(ptEnd_Wnd.x , (ptStart_Wnd.y + ptEnd_Wnd.y)/2);
	memDC->MoveTo(ptStart_Wnd.x - 5, ptStart_Wnd.y - 5);
	memDC->LineTo(ptStart_Wnd.x + 5, ptStart_Wnd.y + 5);
	memDC->MoveTo(ptStart_Wnd.x + 5, ptStart_Wnd.y - 5);
	memDC->LineTo(ptStart_Wnd.x - 5, ptStart_Wnd.y + 5);
	memDC->MoveTo(ptEnd_Wnd.x - 5, ptEnd_Wnd.y - 5);
	memDC->LineTo(ptEnd_Wnd.x + 5, ptEnd_Wnd.y + 5);
	memDC->MoveTo(ptEnd_Wnd.x + 5, ptEnd_Wnd.y - 5);
	memDC->LineTo(ptEnd_Wnd.x - 5, ptEnd_Wnd.y + 5);

	// Circle Line
	CRect rtCircle;
	rtCircle.left = ptStart_Wnd.x - nDistanceX_Wnd;
	rtCircle.top = ptStart_Wnd.y - nDistanceY_wnd;
	rtCircle.right = rtCircle.left + (nDistanceX_Wnd * 2);
	rtCircle.bottom = rtCircle.top + (nDistanceY_wnd * 2);
	memDC->Arc(rtCircle, CPoint(rtCircle.left, rtCircle.CenterPoint().y), CPoint(rtCircle.left, rtCircle.CenterPoint().y));

	/* ¿µ¿ª ¾ÈÀÇ 1/4 ¿ø¸¸ º¸ÀÌ°í ½ÍÀ»¶§..
	if((ptEnd_Wnd.x < ptStart_Wnd.x && ptEnd_Wnd.y < ptStart_Wnd.y) || (ptEnd_Wnd.x > ptStart_Wnd.x && ptEnd_Wnd.y > ptStart_Wnd.y))
		memDC->Arc(rtCircle, CPoint(rtCircle.CenterPoint().x, ptEnd_Wnd.y), CPoint(ptEnd_Wnd.x, rtCircle.CenterPoint().y));
	else
		memDC->Arc(rtCircle, CPoint(ptEnd_Wnd.x, rtCircle.CenterPoint().y), CPoint(rtCircle.CenterPoint().x, ptEnd_Wnd.y));
	*/

	// Start, End Point
	(CPen*)memDC->SelectObject(&pen_Measure_Point);
	if(m_ManualMeasureStatus.bModifyStart)										m_ManualMeasureStatus.nTextPos = 0;
	else if(m_ManualMeasureStatus.bModifyEnd || m_ManualMeasureStatus.bStart)	m_ManualMeasureStatus.nTextPos = 1;
	else;

	CRect rtArea_Wnd(ptStart_Wnd.x, ptStart_Wnd.y, ptEnd_Wnd.x, ptEnd_Wnd.y);
	rtArea_Wnd.NormalizeRect();

	memDC->SetBkMode(TRANSPARENT);
	memDC->SetTextColor(RGB(255,0,0));

	int nDistanceX_pxl = abs(m_ManualMeasureStatus.ptMeasureStart.x - m_ManualMeasureStatus.ptMeasureEnd.x);
	double dDistanceX_mm = nDistanceX_pxl * m_dPixelSizeX / 1000.0;

	int nDistanceY_pxl = abs(m_ManualMeasureStatus.ptMeasureStart.y - m_ManualMeasureStatus.ptMeasureEnd.y);
	double dDistanceY_mm = nDistanceY_pxl * m_dPixelSizeY / 1000.0;

	double dDistanceD_mm = sqrtf(float(dDistanceX_mm *dDistanceX_mm + dDistanceY_mm*dDistanceY_mm));
	double dAngleD_degree = (dDistanceY_mm == 0) ? 0.0 : VIEWER_ToDegree(atan2(dDistanceX_mm, dDistanceY_mm));

	CString strTemp;
	memDC->SetTextColor(RGB(255,0,0));
	strTemp.Format(_T("X : %4.3f mm [%d pixel]"), dDistanceX_mm , nDistanceX_pxl);
	memDC->TextOut( rtArea_Wnd.right + 5, rtArea_Wnd.bottom, strTemp);

	memDC->SetTextColor(RGB(0,255,0));
	strTemp.Format(_T("Y : %4.3f mm [%d pixel]"), dDistanceY_mm, nDistanceY_pxl);
	memDC->TextOut( rtArea_Wnd.right + 5, rtArea_Wnd.bottom + 15 ,strTemp);

	memDC->SetTextColor(RGB(0,255,255));
	strTemp.Format(_T("D : %4.3f mm [%4.3f degree] "), dDistanceD_mm, dAngleD_degree);
	memDC->TextOut( rtArea_Wnd.right + 5, rtArea_Wnd.bottom + 30 ,strTemp);

	memDC->SelectObject(pOldPen);
	memDC->SetROP2(R2_COPYPEN); 
}

void CEdgeImageViewer::UpdateView_MeasureSideDimensionResult(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
		return;

	CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);

	if(pSideData == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_INSPECT_SIDE_DIMENSION] == FALSE)
		return;

	COLORREF colorOK = RGB(0,255,0);
	COLORREF colorNG = RGB(255,0,0);

	CPen pen_OK(PS_SOLID, 1, colorOK);
	CPen pen_NG(PS_SOLID, 1, colorNG);

	CBrush brush_Null;
	brush_Null.CreateStockObject(NULL_BRUSH);

	CPen* pOldPen = (CPen*) memDC->SelectObject(&pen_OK);
	CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);

	CString strComment;

	for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_DIMENSION_MEASURE_COUNT; nMeasureIdx++)
	{
		// Dimension
		int nMeasureResult = pSideData->m_nSideMeasure_CutLine_Status[nMeasureIdx];

		if(nMeasureResult != 0)
		{
			if(nMeasureResult == 1)	
			{
				memDC->SetTextColor(colorOK);
				memDC->SelectObject(&pen_OK);
			}
			else					
			{
				memDC->SetTextColor(colorNG);
				memDC->SelectObject(&pen_NG);
			}

			CPoint ptAlignLine = pSideData->m_ptSideMeasure_Start[nMeasureIdx];
			CPoint ptAlignLine_wnd = GetWndPos(ptAlignLine);
			CPoint ptCutLine = pSideData->m_ptSideMeasure_CutLine[nMeasureIdx];
			CPoint ptCutLine_wnd = GetWndPos(ptCutLine);

			memDC->MoveTo(ptAlignLine_wnd.x-5 , ptAlignLine_wnd.y-5);
			memDC->LineTo(ptAlignLine_wnd.x+5 , ptAlignLine_wnd.y+5);
			memDC->MoveTo(ptAlignLine_wnd.x+5 , ptAlignLine_wnd.y-5);
			memDC->LineTo(ptAlignLine_wnd.x-5 , ptAlignLine_wnd.y+5);

			strComment.Format(_T("S_D_[%d] : %4.3f mm"), nMeasureIdx+1, pSideData->m_dSideMeasrue_CutLine_Result_mm[nMeasureIdx]);
			memDC->TextOut( ptAlignLine_wnd.x + 5, ptAlignLine_wnd.y + 5, strComment);

			memDC->MoveTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y-5);
			memDC->LineTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y+5);
			memDC->MoveTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y-5);
			memDC->LineTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y+5);

			memDC->MoveTo(ptAlignLine_wnd.x , ptAlignLine_wnd.y);
			memDC->LineTo(ptCutLine_wnd.x , ptCutLine_wnd.y);
		}

		// Chamfer
		nMeasureResult = pSideData->m_nSideMeasure_ChamferLine_Status[nMeasureIdx];

		if(nMeasureResult != 0)
		{
			if(nMeasureResult == 1)	
			{
				memDC->SetTextColor(colorOK);
				memDC->SelectObject(&pen_OK);
			}
			else					
			{
				memDC->SetTextColor(colorNG);
				memDC->SelectObject(&pen_NG);
			}

			CPoint ptCutLine = pSideData->m_ptSideMeasure_CutLine[nMeasureIdx];
			CPoint ptCutLine_wnd = GetWndPos(ptCutLine);
			CPoint ptChamferLine = pSideData->m_ptSideMeasure_ChamferLine[nMeasureIdx];
			CPoint ptChamferLine_wnd = GetWndPos(ptChamferLine);

			memDC->MoveTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y-5);
			memDC->LineTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y+5);
			memDC->MoveTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y-5);
			memDC->LineTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y+5);

			memDC->MoveTo(ptChamferLine_wnd.x-5 , ptChamferLine_wnd.y-5);
			memDC->LineTo(ptChamferLine_wnd.x+5 , ptChamferLine_wnd.y+5);
			memDC->MoveTo(ptChamferLine_wnd.x+5 , ptChamferLine_wnd.y-5);
			memDC->LineTo(ptChamferLine_wnd.x-5 , ptChamferLine_wnd.y+5);

			strComment.Format(_T("S_C_[%d] : %4.3f mm"), nMeasureIdx+1, pSideData->m_dSideMeasrue_Chamfer_Result_mm[nMeasureIdx]);
			memDC->TextOut( ptChamferLine_wnd.x + 5, ptChamferLine_wnd.y + 5, strComment);

			memDC->MoveTo(ptCutLine_wnd.x , ptCutLine_wnd.y);
			memDC->LineTo(ptCutLine_wnd.x , ptChamferLine_wnd.y);
		}
	}

	memDC->SelectObject(pOldPen);
	memDC->SelectObject(pOldBrush);
	brush_Null.DeleteObject();
}

void CEdgeImageViewer::UpdateView_Frame(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL)
		return;

	if(m_MenuStatus[MODE_VIEW_FRAME_IDX] == FALSE)
		return;

	COLORREF color = RGB(255,150,0);

	CPen pen(PS_SOLID, 1,color);

	CPen* pOldPen = (CPen*) memDC->SelectObject(&pen);

	memDC->SetTextColor(color);

	CString strTemp;

	for(int i=0; i<m_nFrameCount; i++)
	{
		int nY_pxl = i * m_nFrameHeight;

		int nY_Wnd = GetWndPosY(nY_pxl);

		if(0 <= nY_Wnd && nY_Wnd < m_rtWnd.Height())
		{
			memDC->MoveTo(0, nY_Wnd);
			memDC->LineTo(5, nY_Wnd);

			strTemp.Format(_T("Frame [%d]"), i);
			memDC->TextOut(10,nY_Wnd+2,strTemp);
		}

	}

	memDC->SelectObject(pOldPen);
}

void CEdgeImageViewer::UpdateView_MousePoint(CDC* memDC)
{
	if(m_pBuffer == NULL || memDC == NULL)
		return;

#if HALCON_VISION_KEY
	if (m_MenuStatus[MODE_VIEW_DEFECT] == false)
		return;

	if (!BlVision_GetVisionRecipe()->getVisionSetOpen())
		return;
#endif // HALCON_VISION_KEY

	CPen pen_Mouse_Point(PS_SOLID, 1, RGB(255, 0, 255));

	CPen *pOldPen;
	pOldPen = (CPen*)memDC->SelectObject(&pen_Mouse_Point);

	CPoint ptMousePos_Wnd = GetWndPos(m_ptMousePos_Pxl);

	// Line
	memDC->MoveTo(ptMousePos_Wnd.x - 5, ptMousePos_Wnd.y);
	memDC->LineTo(ptMousePos_Wnd.x + 5, ptMousePos_Wnd.y);
	memDC->MoveTo(ptMousePos_Wnd.x, ptMousePos_Wnd.y - 5);
	memDC->LineTo(ptMousePos_Wnd.x, ptMousePos_Wnd.y + 5);

#if HALCON_VISION_KEY
	CPoint ptMarkPos_wnd = GetWndPos(m_ptMouseDown);
	if (ptMarkPos_wnd.x > 0 && ptMarkPos_wnd.x < m_rtWnd.right && ptMarkPos_wnd.y > 0 && ptMarkPos_wnd.y < m_rtWnd.bottom) {
		memDC->MoveTo(ptMarkPos_wnd.x - 12, ptMarkPos_wnd.y - 12);
		memDC->LineTo(ptMarkPos_wnd.x + 12, ptMarkPos_wnd.y + 12);
		memDC->MoveTo(ptMarkPos_wnd.x + 12, ptMarkPos_wnd.y - 12);
		memDC->LineTo(ptMarkPos_wnd.x - 12, ptMarkPos_wnd.y + 12);
	}
#endif // HALCON_VISION_KEY

	memDC->SelectObject(pOldPen);
}

CRect CEdgeImageViewer::GetManualMeasureRect()
{
	bool bManualMeasure = m_MenuStatus[MODE_USER_SELECT];

	if(bManualMeasure == false)
		return CRect(-1,-1,-1,-1);

	CPoint ptStart = m_ManualMeasureStatus.ptMeasureStart;
	CPoint ptEnd = m_ManualMeasureStatus.ptMeasureEnd;

	CRect rtMeasureArea;
	rtMeasureArea.left = ptStart.x;
	rtMeasureArea.top = ptStart.y;
	rtMeasureArea.right = ptEnd.x;
	rtMeasureArea.bottom = ptEnd.y;

	rtMeasureArea.NormalizeRect();

	return rtMeasureArea;
}

void CEdgeImageViewer::SetDisplayPos(CPoint ptDisplayStart_pxl)
{
	// CPoint ptTemp = ptDisplayStart_pxl;

	// int nViewWidth_pxl = m_rtWnd.Width() / m_dZoom;
	// int nViewHeight_pxl = m_rtWnd.Height() / m_dZoom;

	m_ptDisplayStart_pxl = ptDisplayStart_pxl;

	Invalidate(FALSE);

}

void CEdgeImageViewer::SetZoom(double dZoom)
{
	m_dZoom = dZoom;

	Invalidate(FALSE);
}

double CEdgeImageViewer::GetZoom()
{
	return m_dZoom;
}

void CEdgeImageViewer::SetViewOption(eModeEdgeImageViewer emOption)
{
	if((int) emOption < 0 || MAX_DISPLAY_SET <= emOption)
		return;

	m_MenuStatus.set(emOption);
	Invalidate();
}

void CEdgeImageViewer::ResetViewOption(eModeEdgeImageViewer emOption)
{
	if((int) emOption < 0 || MAX_DISPLAY_SET <= emOption)
		return;

	m_MenuStatus.reset(emOption);
	Invalidate();
}

void CEdgeImageViewer::ModifyImageBack()
{
	if(m_MenuStatus[MODE_MODIFY_BRUSH_BLACK] == false)
		return;

	for(int nY = m_ptMousePos_Pxl.y -20 ; nY < m_ptMousePos_Pxl.y + 20 ; nY++)
	{
		for(int nX = m_ptMousePos_Pxl.x -8; nX < m_ptMousePos_Pxl.x + 8 ; nX++)
		{
			int nX_pxl = nX;
			int nY_pxl = nY - m_ptDisplayStart_pxl.y;	// Recipe View¿¡¼­ Scroll ÇÒ ¶§ ¹öÆÛ À§Ä¡¸¦ ¹Ù²Þ;;;

			if(nX_pxl < 0 || m_nFrameWidth <= nX_pxl)
				continue;

			if(nY_pxl < 0 || m_nTotalHeight <= nY_pxl)
				continue;

			m_pBuffer[nY_pxl * m_nFrameWidth  + nX_pxl] = 5;
		}
	}
}

void CEdgeImageViewer::ModifyImageWhite()
{
	if(m_MenuStatus[MODE_MODIFY_BRUSH_WHITE] == false)
		return;

	for(int nY = m_ptMousePos_Pxl.y -20 ; nY < m_ptMousePos_Pxl.y + 20 ; nY++)
	{
		for(int nX = m_ptMousePos_Pxl.x -8; nX < m_ptMousePos_Pxl.x + 8 ; nX++)
		{
			int nX_pxl = nX;
			int nY_pxl = nY - m_ptDisplayStart_pxl.y;	// Recipe View¿¡¼­ Scroll ÇÒ ¶§ ¹öÆÛ À§Ä¡¸¦ ¹Ù²Þ;;;

			if(nX_pxl < 0 || m_nFrameWidth <= nX_pxl)
				continue;

			if(nY_pxl < 0 || m_nTotalHeight <= nY_pxl)
				continue;

			m_pBuffer[nY_pxl * m_nFrameWidth  + nX_pxl] = 250;
		}
	}
}

int CEdgeImageViewer::GetWndPosX(int nX_pxl)
{
	return (int) ((nX_pxl - m_ptDisplayStart_pxl.x) * m_dZoom);
}

int CEdgeImageViewer::GetWndPosY(int nY_pxl)
{
	return (int) ((nY_pxl - m_ptDisplayStart_pxl.y) * m_dZoom);
}

CPoint CEdgeImageViewer::GetWndPos(CPoint ptPxl)
{
	CPoint ptReturn;

	ptReturn.x = (int) ((ptPxl.x - m_ptDisplayStart_pxl.x) * m_dZoom);
	ptReturn.y = (int) ((ptPxl.y - m_ptDisplayStart_pxl.y) * m_dZoom);

	return ptReturn;
}

CRect CEdgeImageViewer::GetWndPos(CRect rtPxl)
{
	CRect rtReturn;

	CPoint ptLT = GetWndPos(rtPxl.TopLeft());
	CPoint ptRB = GetWndPos(rtPxl.BottomRight());

	rtReturn.left = ptLT.x;
	rtReturn.top = ptLT.y;
	rtReturn.right = ptRB.x;
	rtReturn.bottom = ptRB.y;

	return rtReturn;
}

int CEdgeImageViewer::GetPixlPosX(int nX_Wnd)
{
	return (int) ((((double) nX_Wnd) / m_dZoom) + m_ptDisplayStart_pxl.x);
}

int CEdgeImageViewer::GetPixlPosY(int nY_Wnd)
{
	return (int) ((((double) nY_Wnd) / m_dZoom) + m_ptDisplayStart_pxl.y);
}

CPoint CEdgeImageViewer::GetPxlPos(CPoint ptWnd)
{
	CPoint ptReturn;

	ptReturn.x = (int) ((((double) ptWnd.x) / m_dZoom) + m_ptDisplayStart_pxl.x);
	ptReturn.y = (int) ((((double) ptWnd.y) / m_dZoom) + m_ptDisplayStart_pxl.y);

	return ptReturn;
}

CRect CEdgeImageViewer::GetPxlPos(CRect rtWnd)
{
	CRect rtReturn;

	CPoint ptLT = GetPxlPos(rtWnd.TopLeft());
	CPoint ptRB = GetPxlPos(rtWnd.BottomRight());

	rtReturn.left = ptLT.x;
	rtReturn.top = ptLT.y;
	rtReturn.right = ptRB.x;
	rtReturn.bottom = ptRB.y;

	return rtReturn;
}

#if HALCON_VISION_KEY
void CEdgeImageViewer::OnLButtonUp(UINT nFlags, CPoint point)
{
	// TODO: ÔÚ´ËÌí¼ÓÏûÏ¢´¦Àí³ÌÐò´úÂëºÍ/»òµ÷ÓÃĬÈÏÖµ
	m_isMouseDown = FALSE;

	CWnd::OnLButtonUp(nFlags, point);
}
#endif // HALCON_VISION_KEY