// DefectMap.cpp : 구현 파일입니다.
//

#include "stdafx.h"
#include "ReviewSystem.h"
#include "CHImageControls/CHBufferDC.h"
#include "DefectMap.h"
#include "CHReviewSetting/SystemInfo.h"
#include "DlgDefectFilter.h"

using namespace CHReviewResult;

// CDefectMap

IMPLEMENT_DYNAMIC(CDefectMap, CWnd)

CDefectMap::CDefectMap(CWnd *pParentWnd)
{
	m_pParentWnd = pParentWnd;
	m_nDefectSize		= DEFECT_SIZE;
	m_nReviewSize		= REVIEW_SIZE;

	nGlassMax = -1;
	nGlassMin = -1;
	nOffSetMode = FALSE;
	nCamIndex = -1;
	nCamSacnIndex = -1;

	m_nDefectOffsetX = 0;
	m_nDefectOffsetY = 0;
	m_nDefectCenterX = 0;
	m_nDefectCenterY = 0;
	m_nRectTop = 0;
	m_nRectRight = 0;
	m_nRectBottom = 0;
	m_nRectLeft = 0;
	
	m_dSizeRatioX = 0.0;
	m_dSizeRatioY = 0.0;

	m_nOriginSizeX = 0;
	m_nOriginSizeY = 0;

	Reset();
}

CDefectMap::~CDefectMap()
{
	m_memDC.DeleteDC();
}

void CDefectMap::Reset()
{
	m_rtViewRect		= CRect(0,0,0,0);
	
	m_nReviewIndex		= -1;
	m_pDefectFilter		= NULL;
	m_pGlassResult		= NULL;
	m_pVecReviewResult	= NULL;
	m_dSizeRatioX		= 0;
	m_dSizeRatioY		= 0;
	m_nOriginX			= 0;
	m_nOriginY			= 0;
	m_nOriginDir		= 0;
	m_nCornerCutDir		= 0;
	m_clkPoint			= CPoint(0,0);
	m_nDrawDirX			= 1;
	m_nDrawDirY			= 1;

	m_bDrawCollision = TRUE;

	m_nSelectedIndex	= -1;


	m_RowColor[0]		= RGB(245, 152, 177);
	m_RowColor[1]		= RGB(162, 162, 0);
	m_RowColor[2]		= RGB(220,20,220);
	m_RowColor[3]		= RGB(20,220,220);
	m_RowColor[4]       = RGB(220, 20, 80);
	for (int i=0; i<5; i++)
	{
		m_pDefectPen[i].CreatePen(PS_SOLID, 1, m_RowColor[i]); 
		m_pDefectBrush[i].CreateSolidBrush(m_RowColor[i]); 
	}

	m_nPlanIndex		= 0;
	m_bHistoryEnable = TRUE;

	m_nPointX = 0;
	m_nPointY = 0;
	m_sDelta = 0;
	m_dDefectZoom = 1.0;
	m_dRevDefectZoom = 1.0;
	/*m_nHistoryCount = 0;*/
}

BEGIN_MESSAGE_MAP(CDefectMap, CWnd)
	ON_WM_PAINT()
	ON_WM_LBUTTONDOWN()
	ON_WM_RBUTTONDOWN()
	ON_WM_RBUTTONUP()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_RBUTTONDBLCLK()
	ON_WM_MOUSEWHEEL()
	ON_WM_MOUSEMOVE()
	ON_MESSAGE(UM_UPDATE_DEFECT_MAP, &CDefectMap::OnUpdateDefectMap)
	ON_MESSAGE(UM_REVIEW_RESULT_UPDATE, &CDefectMap::OnReviewResultUpdate)
	ON_MESSAGE(UM_UPDATE_DEFECT_MAP_DEFAULT, &CDefectMap::OnUpdateDefectMapDefault)
	ON_MESSAGE(UM_WSI_RESULT_UPDATE, &CDefectMap::OnReviewResultUpdate)
	ON_MESSAGE(UM_UPDATE_DEFECT_MAP2, &CDefectMap::OnUpdateDefectMap2)
	ON_MESSAGE(UM_HISTORY_MOUSEWHELL, &CDefectMap::OnHistoryWhell) //taek 새로 그리기
END_MESSAGE_MAP()

// CDefectMap 메시지 처리기입니다.

void CDefectMap::UpdateReviewResult(CDC *pDC)
{
	if (m_rtViewRect.Width()==0 || m_rtViewRect.Height()==0 || pDC==NULL) return;

	if (m_pDefectFilter)
	{
		// review defect
		if (m_pDefectFilter->pDraw[MapDrawReviewDefect] && m_pDefectFilter->pDraw[MapDrawReviewPath])	
		{
			DrawReviewDefectPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawReviewDefect]) DrawReviewDefect(pDC);
			if (m_pDefectFilter->pDraw[MapDrawReviewPath])	DrawReviewPath(pDC);
		}

		// user point
		if (m_pDefectFilter->pDraw[MapDrawUserPoint] && m_pDefectFilter->pDraw[MapDrawUserPath])	
		{
			DrawUserPointPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawUserPoint])	DrawUserPoint(pDC);
			if (m_pDefectFilter->pDraw[MapDrawUserPath])	DrawUserPath(pDC);
		}

		// user point
		if (m_pDefectFilter->pDraw[MapDrawUserPoint] && m_pDefectFilter->pDraw[MapDrawUserPath])	
		{
			DrawReflowPointPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawUserPoint])	DrawReflowPoint(pDC);
			if (m_pDefectFilter->pDraw[MapDrawUserPath])	DrawReflowPath(pDC);
		}

		// wsi defect
		if (m_pDefectFilter->pDraw[MapDrawWsiDefect] && m_pDefectFilter->pDraw[MapDrawWsiPath])	
		{
			DrawWsiDefectPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawWsiDefect]) DrawWsiDefect(pDC);
			if (m_pDefectFilter->pDraw[MapDrawWsiPath]) DrawWsiPath(pDC);
		}

		// measure point
		if (m_pDefectFilter->pDraw[MapDrawMeasurePoint] && m_pDefectFilter->pDraw[MapDrawMeasurePath])	
		{
			DrawMeasurePointPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawMeasurePoint]) DrawMeasurePoint(pDC);
			if (m_pDefectFilter->pDraw[MapDrawMeasurePath]) DrawMeasurePath(pDC);
		}
		
		// WsiReflow Point
		if(m_nPlanIndex == 5) 
		{
			if (m_pDefectFilter->pDraw[MapDrawWsiReflowDefect] && m_pDefectFilter->pDraw[MapDrawWsiReflowPath])	
			{
				DrawWsiReflowPointPath(pDC);
			}
			else
			{
				if (m_pDefectFilter->pDraw[MapDrawWsiReflowDefect]) DrawWsiReflowPoint(pDC);
				if (m_pDefectFilter->pDraw[MapDrawWsiReflowPath]) DrawWsiReflowPath(pDC);
			}
		}

		// wsi defect
		if (m_pDefectFilter->pDraw[MapDrawWsiUserDefect] && m_pDefectFilter->pDraw[MapDrawWsiUserPath])
		{
			DrawUserWsiDefectPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawWsiUserDefect]) DrawUserWsiDefect(pDC);
			if (m_pDefectFilter->pDraw[MapDrawWsiUserPath]) DrawUserWsiPath(pDC);
		}

		if (m_bDrawCollision)
			DrawCollisionRange(pDC, m_rtViewRect);

	}
}


void CDefectMap::UpdateReviewResult2(CDC *pDC)
{
	if (m_rtViewRect.Width() == 0 || m_rtViewRect.Height() == 0 || pDC == NULL) return;

	if (m_pDefectFilter)
	{
		// review defect
		if (m_pDefectFilter->pDraw[MapDrawReviewDefect] && m_pDefectFilter->pDraw[MapDrawReviewPath])
		{
			DrawReviewDefectPath(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawReviewDefect]) DrawReviewDefect2(pDC);
			if (m_pDefectFilter->pDraw[MapDrawReviewPath])	DrawReviewPath2(pDC);
		}

		// user point
		if (m_pDefectFilter->pDraw[MapDrawUserPoint] && m_pDefectFilter->pDraw[MapDrawUserPath])
		{
			DrawUserPointPath2(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawUserPoint])	DrawUserPoint2(pDC);
			if (m_pDefectFilter->pDraw[MapDrawUserPath])	DrawUserPath2(pDC);
		}

		// user point
		if (m_pDefectFilter->pDraw[MapDrawUserPoint] && m_pDefectFilter->pDraw[MapDrawUserPath])
		{
			DrawReflowPointPath2(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawUserPoint])	DrawReflowPoint2(pDC);
			if (m_pDefectFilter->pDraw[MapDrawUserPath])	DrawReflowPath2(pDC);
		}

		// wsi defect
		if (m_pDefectFilter->pDraw[MapDrawWsiDefect] && m_pDefectFilter->pDraw[MapDrawWsiPath])
		{
			DrawWsiDefectPath2(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawWsiDefect]) DrawWsiDefect2(pDC);
			if (m_pDefectFilter->pDraw[MapDrawWsiPath]) DrawWsiPath2(pDC);
		}

		// measure point
		if (m_pDefectFilter->pDraw[MapDrawMeasurePoint] && m_pDefectFilter->pDraw[MapDrawMeasurePath])
		{
			DrawMeasurePointPath2(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawMeasurePoint]) DrawMeasurePoint2(pDC);
			if (m_pDefectFilter->pDraw[MapDrawMeasurePath]) DrawMeasurePath2(pDC);
		}

		// WsiReflow Point
		if (m_nPlanIndex == 5)
		{
			if (m_pDefectFilter->pDraw[MapDrawWsiReflowDefect] && m_pDefectFilter->pDraw[MapDrawWsiReflowPath])
			{
				DrawWsiReflowPointPath2(pDC);
			}
			else
			{
				if (m_pDefectFilter->pDraw[MapDrawWsiReflowDefect]) DrawWsiReflowPoint2(pDC);
				if (m_pDefectFilter->pDraw[MapDrawWsiReflowPath]) DrawWsiReflowPath2(pDC);
			}
		}

		// wsi defect
		if (m_pDefectFilter->pDraw[MapDrawWsiUserDefect] && m_pDefectFilter->pDraw[MapDrawWsiUserPath])
		{
			DrawUserWsiDefectPath2(pDC);
		}
		else
		{
			if (m_pDefectFilter->pDraw[MapDrawWsiUserDefect]) DrawUserWsiDefect2(pDC);
			if (m_pDefectFilter->pDraw[MapDrawWsiUserPath]) DrawUserWsiPath2(pDC);
		}

		if (m_bDrawCollision)
			DrawCollisionRange2(pDC, m_rtViewRect);

	}
}

void CDefectMap::UpdateDefectMap()
{
	if (m_rtViewRect.Width()==0 || m_rtViewRect.Height()==0) return;

	CClientDC dc(this);
	GetClientRect(&m_rtViewRect);

	CDC         MemDC;
	CBitmap     BitMap;

	// 도화지를 현재 스크린 DC와 일치 시킨다.
	BitMap.CreateCompatibleBitmap(&dc, m_rtViewRect.Width(), m_rtViewRect.Height());

	// 가상 화면 DC를 현재 스크린 DC와 일치 시킨다.
	MemDC.CreateCompatibleDC(&dc);

	// 가상 화면 DC 에 도화지를 깐다.
	MemDC.SelectObject(&BitMap);

	DrawGlass(&MemDC, m_rtViewRect);

	DrawCornerCut(&MemDC);

	if (m_pDefectFilter)
	{
		if (m_pDefectFilter->pDraw[MapDrawCell]) DrawCell(&MemDC);
		
		if (!m_bHistoryEnable)
		{
			if (m_pDefectFilter->pDraw[MapDrawDefect]) DrawDefect(&MemDC); //History 일때만 빼자 taek 210308
		}

		

		// update review result
		UpdateReviewResult(&MemDC);
	}

	DCtoIplImage(&MemDC, m_rtViewRect);

	// 삭제
	BitMap.DeleteObject();
	MemDC.DeleteDC();

	Invalidate(TRUE);
	m_bHistoryEnable = FALSE;
}

void CDefectMap::UpdateDefectMap2()
{
	if (m_rtViewRect.Width() == 0 || m_rtViewRect.Height() == 0) return;

	CClientDC dc(this);
	GetClientRect(&m_rtViewRect);

	CDC         MemDC;
	CBitmap     BitMap;

	// 도화지를 현재 스크린 DC와 일치 시킨다.
	BitMap.CreateCompatibleBitmap(&dc, m_rtViewRect.Width(), m_rtViewRect.Height());

	// 가상 화면 DC를 현재 스크린 DC와 일치 시킨다.
	MemDC.CreateCompatibleDC(&dc);

	// 가상 화면 DC 에 도화지를 깐다.
	MemDC.SelectObject(&BitMap);

	DrawGlass(&MemDC, m_rtViewRect);

	DrawCornerCut(&MemDC);

	if (m_pDefectFilter)
	{
		if (m_pDefectFilter->pDraw[MapDrawCell]) DrawCell(&MemDC);

		//stack 옵션으로 붙여 넣기

 		if (m_bHistoryEnable)
 		{
 			if (m_pDefectFilter->pDraw[MapDrawDefect]) DrawDefect(&MemDC); 
 		}
 			   
		// update review result
		UpdateReviewResult(&MemDC);
	}

	DCtoIplImage(&MemDC, m_rtViewRect);

	// 삭제
	BitMap.DeleteObject();
	MemDC.DeleteDC();

	Invalidate(TRUE);
}

void CDefectMap::UpdateDefectMap3()
{
	if (m_rtViewRect.Width() == 0 || m_rtViewRect.Height() == 0) return;

	CClientDC dc(this);
	GetClientRect(&m_rtViewRect);

	CDC         MemDC;
	CBitmap     BitMap;

	// 도화지를 현재 스크린 DC와 일치 시킨다.
	BitMap.CreateCompatibleBitmap(&dc, m_rtViewRect.Width(), m_rtViewRect.Height());

	// 가상 화면 DC를 현재 스크린 DC와 일치 시킨다.
	MemDC.CreateCompatibleDC(&dc);

	// 가상 화면 DC 에 도화지를 깐다.
	MemDC.SelectObject(&BitMap);

	/*RectChange(m_rtViewRect);*/

	DrawGlass(&MemDC, m_rtViewRect);
	DrawCornerCut(&MemDC);

	if (m_pDefectFilter)
	{
		if (m_pDefectFilter->pDraw[MapDrawCell]) DrawCell2(&MemDC);

		//stack 옵션으로 붙여 넣기

		if (m_bHistoryEnable)
		{
			if (m_pDefectFilter->pDraw[MapDrawDefect]) DrawDefect2(&MemDC);
		}

		// update review result
		UpdateReviewResult2(&MemDC);
	}

	DCtoIplImage(&MemDC, m_rtViewRect);

	// 삭제
	BitMap.DeleteObject();
	MemDC.DeleteDC();

	Invalidate(TRUE);
}

void CDefectMap::UpdateHistoryDefectMap()
{
	if (m_rtViewRect.Width()==0 || m_rtViewRect.Height()==0) return;

	CDC *pDC = GetDC();

	DrawGlass(pDC, m_rtViewRect);
	DrawCornerCut(pDC);
	DrawCell(pDC);
	DrawDefect(pDC);
	DrawReviewDefectPath(pDC);
	DrawClickedPoint(pDC);
	DrawReviewImg(pDC);

	DCtoIplImage(pDC, m_rtViewRect);
	ReleaseDC(pDC);
	Invalidate(TRUE);
}

void CDefectMap::UpdateDefectFilter(const SDefectFilter* pDefectFilter)
{
	this->PostMessage(UM_DEFECT_FILTER_UPDATE);
}

void CDefectMap::UpdateProcessStatus(int nLineType, int nMachineType, int nProcessStatus, const CGlassResult* pGlassResult)
{
	this->SendMessage(UM_PROCESS_STATUS_UPDATE);
}

void CDefectMap::UpdateMotorPosition(int nModuleIndex, BOOL bSelected, const SMotorPosition* pMotorPosition)
{
	this->PostMessage(UM_MOTOR_POSITION_UPDATE);
}

void CDefectMap::UpdateReviewResult(int nModuleIndex, const CGlassResult* pGlassResult, int nPlanIndex)
{
	if (m_pGlassResult!=pGlassResult) return;
	
	m_nPlanIndex = nPlanIndex;

	this->PostMessage(UM_REVIEW_RESULT_UPDATE);
}

void CDefectMap::SetOffsetmodeparma(BOOL bMode, int nCamidx, int nScanidx, double nXpos, double nYpos)
{
	nOffSetMode = bMode;
	nCamIndex= nScanidx;
	 nCamSacnIndex = nScanidx;
	 nGlassMax = nXpos;
	 nGlassMin = nYpos;
}

void CDefectMap::OnPaint()
{
	CCHBufferDC *pDC = new CCHBufferDC(this); // device context for painting

	CRect rtCurrentRect;
	GetClientRect(rtCurrentRect);

	if (GetImageExist())
	{
		pDC->SelectStockObject(GRAY_BRUSH);
		pDC->Rectangle(rtCurrentRect);
		ShowImage(pDC->m_hDC, rtCurrentRect);
	}
	else
	{
		pDC->SelectStockObject(GRAY_BRUSH);
		pDC->Rectangle(rtCurrentRect);

		CFont font;
		VERIFY(font.CreateFont(
			35,                        // nHeight
			15,                         // nWidth
			0,                         // nEscapement
			0,                         // nOrientation
			FW_NORMAL,                 // nWeight
			FALSE,                     // bItalic
			FALSE,                     // bUnderline
			0,                         // cStrikeOut
			ANSI_CHARSET,              // nCharSet
			OUT_DEFAULT_PRECIS,        // nOutPrecision
			CLIP_DEFAULT_PRECIS,       // nClipPrecision
			DEFAULT_QUALITY,           // nQuality
			DEFAULT_PITCH | FF_SWISS,  // nPitchAndFamily
			_T("Arial")));                 // lpszFacename

		// Do something with the font just created...
		CFont* def_font = pDC->SelectObject(&font);
		pDC->SetTextColor(RGB(255, 255, 255));
		pDC->SetBkMode(TRANSPARENT);

		int strValue = 10 * 15 / 2;

		pDC->TextOut(rtCurrentRect.Width() / 2 - strValue, rtCurrentRect.Height() / 2 - 20, _T("Defect Map"));
		pDC->SelectObject(def_font);
	}

	CPen newPen;
	CPen selectPen;

	CPen* pOldPen;
	CBrush newBrush(RGB(255, 228, 0));
	CBrush* pOldBrush;

	newPen.CreatePen(PS_SOLID, 3, RGB(0, 0, 255));
	selectPen.CreatePen(PS_SOLID, 3, RGB(255, 0, 0));
	pOldBrush = pDC->SelectObject(&newBrush);
	for (int i = 0; i < (int)m_vecCameraPosX.size(); i++)
	{
		if (m_vecCameraType[i] == 0)
			pOldPen = pDC->SelectObject(&selectPen);
		else
			pOldPen = pDC->SelectObject(&newPen);

		pDC->Ellipse(m_vecCameraPosX[i] - 3, m_vecCameraPosY[i] - 3, m_vecCameraPosX[i] + 3, m_vecCameraPosY[i] + 3);
	}

	delete pDC;
}

void CDefectMap::SetGlassInfo(int nSizeX, int nSizeY, int nCornerCutDir, int nGlassOriginDir)
{
	CPaintDC dc(this); // device context for painting

	m_memDC.DeleteDC();
	m_memDC.CreateCompatibleDC(&dc);

	GetClientRect(m_rtViewRect);

	m_nRectLeft = m_rtViewRect.left;
	m_nRectRight = m_rtViewRect.right;
	m_nRectTop = m_rtViewRect.top;
	m_nRectBottom = m_rtViewRect.bottom;

	m_bitmap.DeleteObject();
	m_bitmap.CreateCompatibleBitmap(&dc, m_rtViewRect.Width(), m_rtViewRect.Height()); 

	m_nCornerCutDir = nCornerCutDir;
	m_nOriginDir = nGlassOriginDir;

	int nMapRectWidth = m_rtViewRect.Width();
	int nMapRectHeight = m_rtViewRect.Height();

	switch(m_nOriginDir) 
	{
	case GlassOriginDir_LeftTop:
		m_nOriginX = 0;
		m_nOriginY = 0;
		break;
	case GlassOriginDir_RightTop:
		m_nOriginX = nMapRectWidth;
		m_nOriginY = 0;
		break;
	case GlassOriginDir_LeftBottom:
		m_nOriginX = 0;
		m_nOriginY = nMapRectHeight;
		break;
	case GlassOriginDir_RightBottom:
		m_nOriginX = nMapRectWidth;
		m_nOriginY = nMapRectHeight;
		break;
	default:
		m_nOriginX = nMapRectWidth;
		m_nOriginY = nMapRectHeight;
		break;
	}

	// 센터 좌표계일 경우 원점 및 방향 변경
	if(m_pGlassResult != NULL)
	{
		if(m_pGlassResult->GetGlassCenterCoordinate())
		{
			m_nOriginX = nMapRectWidth/2;
			m_nOriginY = nMapRectHeight/2;

			switch(m_nOriginDir) 
			{
			case GlassOriginDir_LeftTop:
				m_nDrawDirX = 1;
				m_nDrawDirY = 1;
				break;
			case GlassOriginDir_RightTop:
				m_nDrawDirX = -1;
				m_nDrawDirY = 1;
				break;
			case GlassOriginDir_LeftBottom:
				m_nDrawDirX = 1;
				m_nDrawDirY = -1;
				break;
			case GlassOriginDir_RightBottom:
				m_nDrawDirX = -1;
				m_nDrawDirY = -1;
				break;
			default:
				m_nDrawDirX = 1;
				m_nDrawDirY = 1;
				break;
			}
		}
	}

	m_dSizeRatioX = double(nSizeX) / double(m_rtViewRect.Width());
	m_dSizeRatioY = double(nSizeY) / double(m_rtViewRect.Height());

	// 변환 좌표계일 경우 x,y 좌표 변환
	if(m_pGlassResult != NULL)
	{
		if(m_pGlassResult->GetGlassInverseCoordinate())
		{
			m_dSizeRatioX = double(nSizeY) / double(m_rtViewRect.Width());
			m_dSizeRatioY = double(nSizeX) / double(m_rtViewRect.Height());
		}
	}

	if (!m_bHistoryEnable)
	{
		SetRationX(m_dSizeRatioX);
		SetRationY(m_dSizeRatioY);

		SetOriginX(m_nOriginX);
		SetOriginY(m_nOriginY);
	}

	CBitmap* pbmOld = m_memDC.SelectObject(&m_bitmap);
	DrawGlass(&m_memDC, m_rtViewRect);
	m_memDC.SelectObject(pbmOld);

	Invalidate(FALSE);
}

void CDefectMap::SetGlassInfo2(int nSizeX, int nSizeY, int nCornerCutDir, int nGlassOriginDir)
{
	CPaintDC dc(this); // device context for painting

	m_memDC.DeleteDC();
	m_memDC.CreateCompatibleDC(&dc);

	GetClientRect(m_rtViewRect);

	m_bitmap.DeleteObject();
	m_bitmap.CreateCompatibleBitmap(&dc, m_rtViewRect.Width(), m_rtViewRect.Height());

	m_nCornerCutDir = nCornerCutDir;
	m_nOriginDir = nGlassOriginDir;

	int nMapRectWidth = m_rtViewRect.Width();
	int nMapRectHeight = m_rtViewRect.Height();

	switch (m_nOriginDir)
	{
	case GlassOriginDir_LeftTop:
		m_nOriginX = 0;
		m_nOriginY = 0;
		break;
	case GlassOriginDir_RightTop:
		m_nOriginX = nMapRectWidth;
		m_nOriginY = 0;
		break;
	case GlassOriginDir_LeftBottom:
		m_nOriginX = 0;
		m_nOriginY = nMapRectHeight;
		break;
	case GlassOriginDir_RightBottom:
		m_nOriginX = nMapRectWidth;
		m_nOriginY = nMapRectHeight;
		break;
	default:
		m_nOriginX = nMapRectWidth;
		m_nOriginY = nMapRectHeight;
		break;
	}

	// 센터 좌표계일 경우 원점 및 방향 변경
	if (m_pGlassResult != NULL)
	{
		if (m_pGlassResult->GetGlassCenterCoordinate())
		{
			m_nOriginX = nMapRectWidth / 2;
			m_nOriginY = nMapRectHeight / 2;

			switch (m_nOriginDir)
			{
			case GlassOriginDir_LeftTop:
				m_nDrawDirX = 1;
				m_nDrawDirY = 1;
				break;
			case GlassOriginDir_RightTop:
				m_nDrawDirX = -1;
				m_nDrawDirY = 1;
				break;
			case GlassOriginDir_LeftBottom:
				m_nDrawDirX = 1;
				m_nDrawDirY = -1;
				break;
			case GlassOriginDir_RightBottom:
				m_nDrawDirX = -1;
				m_nDrawDirY = -1;
				break;
			default:
				m_nDrawDirX = 1;
				m_nDrawDirY = 1;
				break;
			}
		}
	}

	/*RectChange(m_rtViewRect);*/

	double dResizeX = (double(nSizeX) * m_dRevDefectZoom);
	double dResizeValueX = double(nSizeX) - dResizeX;
	dResizeValueX = dResizeValueX * 2;

	double dResizeY = (double(nSizeY) * m_dRevDefectZoom);
	double dResizeValueY = double(nSizeY) - dResizeY;
	dResizeValueY = dResizeValueY * 2;
	
	m_dSizeRatioX = ((double(nSizeX)/* - dResizeValueX*/) / double(m_rtViewRect.Width()));
	m_dSizeRatioY = ((double(nSizeY)/* - dResizeValueY*/) / double(m_rtViewRect.Height()));

// 	double dSizeRationX, dSizeRationY;
// 
// 	dSizeRationX = m_dOrignSizeRatioX - m_dSizeRatioX;
// 	dSizeRationY = m_dOrignSizeRatioY - m_dSizeRatioY;
// 
// 	m_dSizeRatioX = m_dOrignSizeRatioX + dSizeRationX;
// 	m_dSizeRatioY = m_dOrignSizeRatioY + dSizeRationY;

	// 변환 좌표계일 경우 x,y 좌표 변환
	if (m_pGlassResult != NULL)
	{
		if (m_pGlassResult->GetGlassInverseCoordinate())
		{
			m_dSizeRatioX = double(nSizeY) / double(m_rtViewRect.Width());
			m_dSizeRatioY = double(nSizeX) / double(m_rtViewRect.Height());
		}
	}

	CBitmap* pbmOld = m_memDC.SelectObject(&m_bitmap);
/*	GetClientRect(m_rtViewRect);*/
	DrawGlass(&m_memDC, m_rtViewRect);
	m_memDC.SelectObject(pbmOld);

	Invalidate(FALSE);
}

void CDefectMap::DrawGlass(CDC *pDC, const CRect& rtRect)
{
	CBrush newBrush(RGB(211,239,245));
	CBrush* pOldBrush = NULL;
	pOldBrush = pDC->SelectObject(&newBrush);
	pDC->SelectStockObject(BLACK_PEN);
	pDC->Rectangle(rtRect);
	pDC->SelectObject(pOldBrush);
}

void CDefectMap::RectChange(const CRect& rtRect)
{
	m_nRectLeft = m_rtViewRect.left;
	m_nRectRight = m_rtViewRect.right;
	m_nRectTop = m_rtViewRect.top;
	m_nRectBottom = m_rtViewRect.bottom;

	//10,805,10,390
	int minX, minY, maxX, maxY;
	minX = (int)((m_rtViewRect.left*m_dRevDefectZoom) + m_nDefectOffsetX + (m_rtViewRect.Width() / 2));
	maxX = (int)((m_rtViewRect.right*m_dRevDefectZoom) + m_nDefectOffsetX + (m_rtViewRect.Width() / 2));
	minY = (int)(m_rtViewRect.Height() / 2 - m_rtViewRect.top * m_dRevDefectZoom + m_nDefectOffsetY);
	maxY = (int)(m_rtViewRect.Height() / 2 - m_rtViewRect.bottom * m_dRevDefectZoom + m_nDefectOffsetY);


// 	m_rtViewRect.right = (m_nRectRight * m_dRevDefectZoom + m_nDefectOffsetX); //max
// 	m_rtViewRect.bottom = (m_nRectBottom * m_dRevDefectZoom + m_nDefectOffsetY); //max
// 	m_rtViewRect.left = m_nRectRight - m_rtViewRect.right;//(int)(m_nRectLeft* m_dDefectZoom + m_nDefectOffsetX); //min
// 	m_rtViewRect.top = m_nRectBottom - m_rtViewRect.bottom;//(int)(m_nRectTop * m_dDefectZoom + m_nDefectOffsetY); //min
}

void CDefectMap::DrawCollisionRange(CDC* pDC, const CRect& rtRect)
{
	// draw Collision range
	if (m_pGlassResult && m_pGlassResult->GetCollisionPosX1() > 0 && m_pGlassResult->GetCollisionPosX2() > 0)
	{
		int nStartPos1X, nStartPos2X, nEndPos1Y, nEndPos2Y;
		CReviewResult reviewResult;

		CPen reviewPen;
		CPen reviewedPen;
		CPen pathPen;

		CPen *pOldPen = NULL;
		CBrush* pOldBrush = NULL;

		CBrush reviewBrush(RGB(255, 255, 0));
		CBrush reviewedBrush(RGB(255, 0, 0));

		reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
		reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
		pathPen.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));

		pOldPen = pDC->SelectObject(&pathPen);


		nStartPos1X = m_pGlassResult->GetCollisionPosX1();
		nStartPos2X = m_pGlassResult->GetCollisionPosX2();

		CRect rtRange = rtRect;

		nEndPos1Y = 0;
		nEndPos2Y = 2940;

		TransformGlass2Map(nStartPos1X, nEndPos1Y);

		pDC->MoveTo(nStartPos1X, rtRange.top);
		pDC->LineTo(nStartPos1X, rtRange.bottom);

		TransformGlass2Map(nStartPos2X, nEndPos1Y);

		pDC->MoveTo(nStartPos2X, rtRange.top);
		pDC->LineTo(nStartPos2X, rtRange.bottom);

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);


		pDC->SelectObject(pOldPen);
}
#if 0
	// draw Collision range
	if (m_pGlassResult && m_pGlassResult->GetCollisionDistanceX()>0)
	{
		CBrush brBrush(RGB(111,139,145));
		CBrush *pOldBrush = pDC->SelectObject(&brBrush);
		
		int nOldROP = pDC->GetROP2();
		pDC->SetROP2(R2_XORPEN);

		int nDistance = int( double(m_pGlassResult->GetCollisionDistanceX() / 2) / m_dSizeRatioX );
		CRect rtRange	= rtRect;
		rtRange.left	= (rtRect.Width() / 2) - nDistance;
		rtRange.right	= (rtRect.Width() / 2) + nDistance;

		pDC->Rectangle(rtRange);
		pDC->SelectObject(pOldBrush);

		pDC->SetROP2(nOldROP);

	}
#endif
}

void CDefectMap::DrawCollisionRange2(CDC* pDC, const CRect& rtRect)
{
	// draw Collision range
	if (m_pGlassResult && m_pGlassResult->GetCollisionPosX1() > 0 && m_pGlassResult->GetCollisionPosX2() > 0)
	{
		int nStartPos1X, nStartPos2X, nEndPos1Y, nEndPos2Y;
		CReviewResult reviewResult;

		CPen reviewPen;
		CPen reviewedPen;
		CPen pathPen;

		CPen *pOldPen = NULL;
		CBrush* pOldBrush = NULL;

		CBrush reviewBrush(RGB(255, 255, 0));
		CBrush reviewedBrush(RGB(255, 0, 0));

		reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
		reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
		pathPen.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));

		pOldPen = pDC->SelectObject(&pathPen);


		nStartPos1X = m_pGlassResult->GetCollisionPosX1();
		nStartPos2X = m_pGlassResult->GetCollisionPosX2();

		CRect rtRange = rtRect;

		nEndPos1Y = 0;
		nEndPos2Y = 2940;

		TransformGlass2Map2(nStartPos1X, nEndPos1Y);

		pDC->MoveTo(nStartPos1X, rtRange.top);
		pDC->LineTo(nStartPos1X, rtRange.bottom);

		TransformGlass2Map2(nStartPos2X, nEndPos1Y);

		pDC->MoveTo(nStartPos2X, rtRange.top);
		pDC->LineTo(nStartPos2X, rtRange.bottom);

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);


		pDC->SelectObject(pOldPen);
	}
#if 0
	// draw Collision range
	if (m_pGlassResult && m_pGlassResult->GetCollisionDistanceX() > 0)
	{
		CBrush brBrush(RGB(111, 139, 145));
		CBrush *pOldBrush = pDC->SelectObject(&brBrush);

		int nOldROP = pDC->GetROP2();
		pDC->SetROP2(R2_XORPEN);

		int nDistance = int(double(m_pGlassResult->GetCollisionDistanceX() / 2) / m_dSizeRatioX);
		CRect rtRange = rtRect;
		rtRange.left = (rtRect.Width() / 2) - nDistance;
		rtRange.right = (rtRect.Width() / 2) + nDistance;

		pDC->Rectangle(rtRange);
		pDC->SelectObject(pOldBrush);

		pDC->SetROP2(nOldROP);

	}
#endif
}

void CDefectMap::DrawUserWsiDefect(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	//const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorUserWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{

				if (its->nResultCode != ReviewResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserWsiDefect2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	//const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorUserWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{

				if (its->nResultCode != ReviewResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map2(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserWsiPath(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorUserWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (itt + 1 != ittEnd)
				{
					itt++;
					nStartPosX = its->nUMOriginX;
					nStartPosY = its->nUMOriginY;
					nEndPosX = itt->nUMOriginX;
					nEndPosY = itt->nUMOriginY;
					TransformGlass2Map(nStartPosX, nStartPosY);
					TransformGlass2Map(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserWsiPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorUserWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (itt + 1 != ittEnd)
				{
					itt++;
					nStartPosX = its->nUMOriginX;
					nStartPosY = its->nUMOriginY;
					nEndPosX = itt->nUMOriginX;
					nEndPosY = itt->nUMOriginY;
					TransformGlass2Map2(nStartPosX, nStartPosY);
					TransformGlass2Map2(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserWsiDefectPath(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorUserWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (itt + 1 != ittEnd)
				{
					itt++;
					nStartPosX = its->nUMOriginX;
					nStartPosY = its->nUMOriginY;
					nEndPosX = itt->nUMOriginX;
					nEndPosY = itt->nUMOriginY;
					TransformGlass2Map(nStartPosX, nStartPosY);
					TransformGlass2Map(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			// select defect pen
			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);

			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (its->nResultCode != WsiResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserWsiDefectPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorUserWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (itt + 1 != ittEnd)
				{
					itt++;
					nStartPosX = its->nUMOriginX;
					nStartPosY = its->nUMOriginY;
					nEndPosX = itt->nUMOriginX;
					nEndPosY = itt->nUMOriginY;
					TransformGlass2Map2(nStartPosX, nStartPosY);
					TransformGlass2Map2(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			// select defect pen
			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);

			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (its->nResultCode != WsiResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map2(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

int CDefectMap::TransX(double x)
{
	int asjdkflwef;
	asjdkflwef = (int)(x * m_dDefectZoom + m_nDefectOffsetX + m_rtViewRect.right / 2);
	return (int)(x * m_dDefectZoom + m_nDefectOffsetX + m_rtViewRect.right / 2);
}

int CDefectMap::TransY(double y)
{
	int ajfklwef;
	ajfklwef = (int)(m_rtViewRect.bottom / 2 - y * m_dDefectZoom + m_nDefectOffsetY);
	return (int)(m_rtViewRect.bottom / 2 - y * m_dDefectZoom + m_nDefectOffsetY);
}

int CDefectMap::TransX(int x)
{
	double d = (double)x;
	return TransX(d);
}

int CDefectMap::TransY(int y)
{
	double d = (double)y;
	return TransY(d);
}

void CDefectMap::DrawCornerCut(CDC* pDC)
{	
	CPen newPen(PS_SOLID, 1, RGB(255,0,0));
	CBrush BrushCCut(RGB(255,0,0));
	CPen* pOldPen;
	CBrush* pOldBrush;
	CPoint pointCornerCut[3];
	int nCornerCutSize;

	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&BrushCCut);
	nCornerCutSize = 10;

	switch (m_nCornerCutDir)
	{
	case GLASS_CORNERCUT_LEFT_TOP:
		pointCornerCut[0] = CPoint(m_rtViewRect.left + 1, m_rtViewRect.top + 1);
		pointCornerCut[1] = CPoint(m_rtViewRect.left + nCornerCutSize + 1, m_rtViewRect.top + 1);
		pointCornerCut[2] = CPoint(m_rtViewRect.left + 1, m_rtViewRect.top + nCornerCutSize + 1);
		break;
	case GLASS_CORNERCUT_RIGHT_TOP:
		pointCornerCut[0] = CPoint(m_rtViewRect.right + 1, m_rtViewRect.top + 1);
		pointCornerCut[1] = CPoint(m_rtViewRect.right - nCornerCutSize + 1, m_rtViewRect.top + 1);
		pointCornerCut[2] = CPoint(m_rtViewRect.right + 1, m_rtViewRect.top + nCornerCutSize + 1);
		break;
	case GLASS_CORNERCUT_LEFT_BOTTOM:
		pointCornerCut[0] = CPoint(m_rtViewRect.left + 1, m_rtViewRect.bottom - 1);
		pointCornerCut[1] = CPoint(m_rtViewRect.left + 1, m_rtViewRect.bottom - nCornerCutSize - 1);
		pointCornerCut[2] = CPoint(m_rtViewRect.left + nCornerCutSize + 1, m_rtViewRect.bottom - 1);
		break;
	case GLASS_CORNERCUT_RIGHT_BOTTOM:
		pointCornerCut[0] = CPoint(m_rtViewRect.right - 1, m_rtViewRect.bottom - 1);
		pointCornerCut[1] = CPoint(m_rtViewRect.right - nCornerCutSize - 1, m_rtViewRect.bottom - 1);
		pointCornerCut[2] = CPoint(m_rtViewRect.right - 1, m_rtViewRect.bottom - nCornerCutSize - 1);
		break;
	default:
		break;
	}

	pDC->Polygon(pointCornerCut, 3);
}

void CDefectMap::DrawCell(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CPen newPen;
	CPen* pOldPen;
	CBrush newBrush(RGB(144,214,243));
	CBrush* pOldBrush;
	pOldBrush = pDC->SelectObject(&newBrush);
	newPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&newBrush);

	int nTextWidth = 5;
	int nTextHeight = 10;

	CFont font;
	VERIFY(font.CreateFont(
		nTextHeight,                        // nHeight
		nTextWidth,                         // nWidth
		0,                         // nEscapement
		0,                         // nOrientation
		FW_NORMAL,                 // nWeight
		FALSE,                     // bItalic
		FALSE,                     // bUnderline
		0,                         // cStrikeOut
		ANSI_CHARSET,              // nCharSet
		OUT_DEFAULT_PRECIS,        // nOutPrecision
		CLIP_DEFAULT_PRECIS,       // nClipPrecision
		DEFAULT_QUALITY,           // nQuality
		DEFAULT_PITCH | FF_SWISS,  // nPitchAndFamily
		_T("Arial")));                 // lpszFacename

	CFont* def_font = pDC->SelectObject(&font);
	pDC->SetTextColor(RGB(44,114,143));
	pDC->SetBkMode(TRANSPARENT);

	if(m_pGlassResult == NULL) return ;

	const VectorCellResult* pVecCellResult = m_pGlassResult->GetVectorCellResult();
	if(pVecCellResult == NULL || !pVecCellResult->size()) return ;
	int nCellResultCount = m_pGlassResult->GetCellResultCount();
	if(nCellResultCount <= 0) return ;
	if(pVecCellResult->empty()) return ;
	int nCellID_Length = 3;
	for (constVectorCellResultIt it=pVecCellResult->begin(); it!=pVecCellResult->end(); it++)
	{
		nStartPosX = it->nUMOriginX;
		nStartPosY = it->nUMOriginY;

		nEndPosX = nStartPosX + (it->nUMOriginWidth)*m_nDrawDirX;
		nEndPosY = nStartPosY + (it->nUMOriginHeight)*m_nDrawDirY;

		TransformGlass2Map(nStartPosX, nStartPosY);
		TransformGlass2Map(nEndPosX, nEndPosY);

		CRect rtRect(nStartPosX, nStartPosY, nEndPosX, nEndPosY);

		pDC->Rectangle(nStartPosX, nStartPosY, nEndPosX, nEndPosY);

		nStartPosX = nStartPosX + ( (nEndPosX-nStartPosX) / 2 ) - ((nCellID_Length/2+1)*nTextWidth);
		nStartPosY = nStartPosY + ( (nEndPosY-nStartPosY) / 2 ) - (nTextHeight/2);

		pDC->TextOut(nStartPosX, nStartPosY, it->strCellID);
	}	
	
	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
}

int CDefectMap::FilterDefect(const SDefectFilter& defectFilter, const CDefectResult* pDefectResult)
{
	switch(defectFilter.nOptionType)
	{
	case DefectType_Optic:
		if ( defectFilter.bOpticDkBr && (pDefectResult->nOpticType == DEFECT_OPTIC_DKBR) )
		{
			return 2;
		}
		if ( defectFilter.bOpticDark && (pDefectResult->nOpticType & DEFECT_OPTIC_DARK) )
		{
			return 0;
		}
		if ( defectFilter.bOpticBright && (pDefectResult->nOpticType & DEFECT_OPTIC_BRIGHT) )
		{
			return 1;
		}
		break;

	case DefectType_Gray:
		if ( defectFilter.bGrayBlack && (pDefectResult->nGrayType == DEFECT_GRAY_BLACK) )
		{
			return 0;
		}
		if ( defectFilter.bGrayWhite && (pDefectResult->nGrayType == DEFECT_GRAY_WHITE) )
		{
			return 1;
		}
		break;

	case DefectType_Stack:
		if (defectFilter.bStackTD && (pDefectResult->nStackType == DEFECT_STACK_TD))
		{
			return 0;
		}

		if (defectFilter.bStackSD && (pDefectResult->nStackType == DEFECT_STACK_SD))
		{
 			return 1;
		} //taek

		if (defectFilter.bStackPD && (pDefectResult->nStackType == DEFECT_STACK_PD))
		{
			return 2;
		}

		if (defectFilter.bStackSP && (pDefectResult->nStackType == DEFECT_STACK_SP))
		{
			return 3;
		}

		break;

	case DefectType_Size:
		if (defectFilter.bSizeSmall && (pDefectResult->nSizeType == DEFECT_SIZE_SMALL))
		{
			return 0;
		}

		if (defectFilter.bSizeMedium && (pDefectResult->nSizeType == DEFECT_SIZE_MEDIUM))
		{
			return 1;
		}

		if (defectFilter.bSizeLarge && (pDefectResult->nSizeType == DEFECT_SIZE_LARGE))
		{
			return 2;
		}

		if (defectFilter.bSizeHuge && (pDefectResult->nSizeType == DEFECT_SIZE_HUGE))
		{
			return 3;
		}
		break;

	case DefectType_Judge:
		if (defectFilter.bJudgeOK && (pDefectResult->nJudgeType == DEFECT_JUDGE_CPJT_OK))
		{
			return 0;
		}

		if (defectFilter.bJudgeTR && (pDefectResult->nJudgeType == DEFECT_JUDGE_CPJT_TR))
		{
			return 1;
		}

		if (defectFilter.bJudgePR && (pDefectResult->nJudgeType == DEFECT_JUDGE_CPJT_PR))
		{
			return 2;
		}
		break;

	case DefectType_Process:
		if (defectFilter.bProcessNormal && (pDefectResult->nProcessType == DEFECT_PROCESS_NORMAL))
		{
			return 0;
		}

		if (defectFilter.bProcessMask && (pDefectResult->nProcessType == DEFECT_PROCESS_MASK))
		{
			return 1;
		}

		if (defectFilter.bProcessMask && (pDefectResult->nProcessType == DEFECT_PROCESS_MASK))
		{
			return 2;
		}

		if (defectFilter.bProcessCrack && (pDefectResult->nProcessType == DEFECT_PROCESS_CRACK))
		{
			return 3;
		}
		break;

	case DefectType_Position:
		if (defectFilter.bPositionFront && (pDefectResult->nDefectPos == DEFECT_POSITION_FRONT))
		{
			return 0;
		}

		if (defectFilter.bPositionBack && (pDefectResult->nDefectPos == DEFECT_POSITION_BACK))
		{
			return 1;
		}
		break;

	}

	return -1;
}

int CDefectMap::FilterDefect(const SDefectFilter* pDefectFilter, const CDefectResult* pDefectResult)
{
	return FilterDefect(*pDefectFilter, pDefectResult);
}

int CDefectMap::FilterDefectPos(const SDefectFilter& defectFilter, const SReviewResult* pSReviewResult)
{
	switch(defectFilter.nOptionType)
	{
	case DefectType_Optic:
		if ( defectFilter.bOpticDkBr )
		{
			return 2;
		}
		if ( defectFilter.bOpticDark )
		{
			return 0;
		}
		if ( defectFilter.bOpticBright )
		{
			return 1;
		}
		break;

	case DefectType_Gray:
		if ( defectFilter.bGrayBlack )
		{
			return 0;
		}
		if ( defectFilter.bGrayWhite )
		{
			return 1;
		}
		break;

	case DefectType_Stack:
		if (defectFilter.bStackTD )
		{
			return 0;
		}

		if (defectFilter.bStackSD )
		{
			return 1;
		}

		if (defectFilter.bStackPD )
		{
			return 2;
		}

 		if (defectFilter.bStackSP)
 		{
 			return 3;
		} //taek

		break;

	case DefectType_Size:
		if (defectFilter.bSizeSmall )
		{
			return 0;
		}

		if (defectFilter.bSizeMedium )
		{
			return 1;
		}

		if (defectFilter.bSizeLarge )
		{
			return 2;
		}

		if (defectFilter.bSizeHuge )
		{
			return 3;
		}
		break;

	case DefectType_Judge:
		if (defectFilter.bJudgeOK )
		{
			return 0;
		}

		if (defectFilter.bJudgeTR )
		{
			return 1;
		}

		if (defectFilter.bJudgePR )
		{
			return 2;
		}
		break;

	case DefectType_Process:
		if (defectFilter.bProcessNormal )
		{
			return 0;
		}

		if (defectFilter.bProcessMask )
		{
			return 1;
		}

		if (defectFilter.bProcessMask )
		{
			return 2;
		}

		if (defectFilter.bProcessCrack )
		{
			return 3;
		}
		break;
	case DefectType_Position:
		if (defectFilter.bPositionFront && (pSReviewResult->nDefectPos == DEFECT_POSITION_FRONT))
		{
			return 0;
		}

		if (defectFilter.bPositionBack && (pSReviewResult->nDefectPos == DEFECT_POSITION_BACK))
		{
			return 1;
		}
		break;

	}

	return -1;
}

int CDefectMap::FilterDefectPos(const SDefectFilter* pDefectFilter, const SReviewResult* pSReviewResult)
{
	return FilterDefectPos(*pDefectFilter, pSReviewResult);
}

void CDefectMap::DrawDefect(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	int nPosX, nPosY;
	CDefectResult* pDefectResult = NULL;
	CPen newPen;
	CPen* pOldPen;
	CBrush newBrush(RGB(255,0,0));//RGB(255,0,221)
	CBrush* pOldBrush;
	
	newPen.CreatePen(PS_SOLID, 1,RGB(255,0,0)); 
	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&newBrush);

	int nColorIdx = 0;

	const MapDefectResult *pMapDefectResult = m_pGlassResult->GetMapDefectResult();
	if(pMapDefectResult == NULL) return ;

// 	int nReviewResult = m_pGlassResult->GetReviewResultCount();
// 	if(!nReviewResult) return ;
		
	for(constMapDefectResultIt it=pMapDefectResult->begin();it!=pMapDefectResult->end();it++)
	{
		pDefectResult = static_cast<CDefectResult*>(it->second);

		if(pDefectResult == NULL) continue;

		nColorIdx = FilterDefect(m_pDefectFilter, pDefectResult);

		if (nColorIdx==-1) 
		{
			continue;
		}

		pOldPen = pDC->SelectObject(&m_pDefectPen[nColorIdx]);
		pDC->SelectStockObject(BLACK_PEN);
		pOldBrush = pDC->SelectObject(&m_pDefectBrush[nColorIdx]);

		nPosX = pDefectResult->nUMOriginX;
		nPosY = pDefectResult->nUMOriginY;
		TransformGlass2Map(nPosX, nPosY);

		pDC->Rectangle(nPosX - m_nDefectSize, nPosY - m_nDefectSize, nPosX + m_nDefectSize, nPosY + m_nDefectSize);
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
}

void CDefectMap::DrawCell2(CDC * pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CPen newPen;
	CPen* pOldPen;
	CBrush newBrush(RGB(144, 214, 243));
	CBrush* pOldBrush;
	pOldBrush = pDC->SelectObject(&newBrush);
	newPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&newBrush);

	int nTextWidth = 5;
	int nTextHeight = 10;

	CFont font;
	VERIFY(font.CreateFont(
		nTextHeight,                        // nHeight
		nTextWidth,                         // nWidth
		0,                         // nEscapement
		0,                         // nOrientation
		FW_NORMAL,                 // nWeight
		FALSE,                     // bItalic
		FALSE,                     // bUnderline
		0,                         // cStrikeOut
		ANSI_CHARSET,              // nCharSet
		OUT_DEFAULT_PRECIS,        // nOutPrecision
		CLIP_DEFAULT_PRECIS,       // nClipPrecision
		DEFAULT_QUALITY,           // nQuality
		DEFAULT_PITCH | FF_SWISS,  // nPitchAndFamily
		_T("Arial")));                 // lpszFacename

	CFont* def_font = pDC->SelectObject(&font);
	pDC->SetTextColor(RGB(44, 114, 143));
	pDC->SetBkMode(TRANSPARENT);

	if (m_pGlassResult == NULL) return;

	const VectorCellResult* pVecCellResult = m_pGlassResult->GetVectorCellResult();
	if (pVecCellResult == NULL || !pVecCellResult->size()) return;
	int nCellResultCount = m_pGlassResult->GetCellResultCount();
	if (nCellResultCount <= 0) return;
	if (pVecCellResult->empty()) return;
	int nCellID_Length = 3;
	for (constVectorCellResultIt it = pVecCellResult->begin(); it != pVecCellResult->end(); it++)
	{
		nStartPosX = it->nUMOriginX;
		nStartPosY = it->nUMOriginY;

		nEndPosX = nStartPosX + (it->nUMOriginWidth)*m_nDrawDirX;
		nEndPosY = nStartPosY + (it->nUMOriginHeight)*m_nDrawDirY;

 		TransformGlass2Map2(nStartPosX, nStartPosY);
 		TransformGlass2Map2(nEndPosX, nEndPosY);

		CRect rtRect(nStartPosX, nStartPosY, nEndPosX, nEndPosY);

		pDC->Rectangle(TransX(nStartPosX), TransY(nStartPosY), TransX(nEndPosX), TransY(nEndPosY));
		//pDC->Rectangle(TransX(nStartPosX), TransY(nStartPosY), TransX(nEndPosX), TransY(nEndPosY));

		nStartPosX = nStartPosX + ((nEndPosX - nStartPosX) / 2) - ((nCellID_Length / 2 + 1)*nTextWidth);
		nStartPosY = nStartPosY + ((nEndPosY - nStartPosY) / 2) - (nTextHeight / 2);

		pDC->TextOut(nStartPosX, nStartPosY, it->strCellID);
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
}

void CDefectMap::DrawDefect2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nPosX, nPosY;
	CDefectResult* pDefectResult = NULL;
	CPen newPen;
	CPen* pOldPen;
	CBrush newBrush(RGB(255, 0, 0));//RGB(255,0,221)
	CBrush* pOldBrush;

	newPen.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&newBrush);

	int nColorIdx = 0;

	const MapDefectResult *pMapDefectResult = m_pGlassResult->GetMapDefectResult();
	if (pMapDefectResult == NULL) return;

	// 	int nReviewResult = m_pGlassResult->GetReviewResultCount();
	// 	if(!nReviewResult) return ;

	for (constMapDefectResultIt it = pMapDefectResult->begin(); it != pMapDefectResult->end(); it++)
	{
		pDefectResult = static_cast<CDefectResult*>(it->second);

		if (pDefectResult == NULL) continue;

		nColorIdx = FilterDefect(m_pDefectFilter, pDefectResult);

		if (nColorIdx == -1)
		{
			continue;
		}

		pOldPen = pDC->SelectObject(&m_pDefectPen[nColorIdx]);
		pDC->SelectStockObject(BLACK_PEN);
		pOldBrush = pDC->SelectObject(&m_pDefectBrush[nColorIdx]);

		nPosX = pDefectResult->nUMOriginX;
		nPosY = pDefectResult->nUMOriginY;
		TransformGlass2Map(nPosX, nPosY);

		pDC->Rectangle(nPosX - m_nDefectSize, nPosY - m_nDefectSize, nPosX + m_nDefectSize, nPosY + m_nDefectSize);
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
}

void CDefectMap::DrawMeasurePoint(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nPosX, nPosY;
	CPen newPen;
	CPen* pOldPen;
	CBrush newBrush(RGB(0,0,0));
	CBrush* pOldBrush;

	newPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&newBrush);

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorMeasureResult();
	if (pVecReviewResult==NULL) return;

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt pits = pReviewResult->m_vecSReviewResult.begin();

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			
			if(its->nReviewType == ReviewType_Measure)
			{
				nPosX = its->nUMOriginX;
				nPosY = its->nUMOriginY;

				TransformGlass2Map(nPosX, nPosY);
			
				pDC->Rectangle(nPosX - 2, nPosY - 2, nPosX + 2, nPosY + 2);
			}

			if(its != pits)
			{
				nPosX = pits->nUMOriginX;
				nPosY = pits->nUMOriginY;
				TransformGlass2Map(nPosX, nPosY);

				pDC->MoveTo(nPosX, nPosY);

				nPosX = its->nUMOriginX;
				nPosY = its->nUMOriginY;
				TransformGlass2Map(nPosX, nPosY);

				pDC->LineTo(nPosX, nPosY);

				pits = its;
			}

		}
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
}

void CDefectMap::DrawMeasurePoint2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nPosX, nPosY;
	CPen newPen;
	CPen* pOldPen;
	CBrush newBrush(RGB(0, 0, 0));
	CBrush* pOldBrush;

	newPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pOldPen = pDC->SelectObject(&newPen);
	pOldBrush = pDC->SelectObject(&newBrush);

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorMeasureResult();
	if (pVecReviewResult == NULL) return;

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt pits = pReviewResult->m_vecSReviewResult.begin();

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{

			if (its->nReviewType == ReviewType_Measure)
			{
				nPosX = its->nUMOriginX;
				nPosY = its->nUMOriginY;

				TransformGlass2Map2(nPosX, nPosY);

				pDC->Rectangle(nPosX - 2, nPosY - 2, nPosX + 2, nPosY + 2);
			}

			if (its != pits)
			{
				nPosX = pits->nUMOriginX;
				nPosY = pits->nUMOriginY;
				TransformGlass2Map2(nPosX, nPosY);

				pDC->MoveTo(nPosX, nPosY);

				nPosX = its->nUMOriginX;
				nPosY = its->nUMOriginY;
				TransformGlass2Map2(nPosX, nPosY);

				pDC->LineTo(nPosX, nPosY);

				pits = its;
			}

		}
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
}

void CDefectMap::DrawCamera(VectorInteger& vectorType, VectorInteger& vectorPosX, VectorInteger& vectorPosY)
{
	int i, nCount;

	nCount = (int)vectorPosX.size();

	for(i = 0; i < nCount; i++)
	{
		TransformGlass2Map(vectorPosX[i], vectorPosY[i]);
	}
	
	m_vecCameraType = vectorType;
	m_vecCameraPosX = vectorPosX;
	m_vecCameraPosY = vectorPosY;

	Invalidate(FALSE);
}

void CDefectMap::DrawUserPoint(CDC *pDC)//유저
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorUserResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserPoint2(CDC *pDC)//유저
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorUserResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReviewDefect(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			/*if (nOffSetMode ==TRUE)
			{
				if (nGlassMax>nStartPosX &&nGlassMin < nStartPosX)
				{
					if (its->nAOICameraIdx == nCamIndex)
					{

						if (its->nAOIScanIdx==nCamSacnIndex)
						{

						}
						else
						{
							continue;
						}
					}
					else
					{
						continue;
					}

				}
				else
				{
					continue;
				}

			}*/
			

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReviewDefect2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorUserResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);

}

void CDefectMap::DrawUserPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorUserResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);

}

void CDefectMap::DrawMeasurePath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorMeasureResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawMeasurePath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorMeasureResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReviewPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReviewPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserPointPath(CDC *pDC)//UserDefect그리기
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorUserResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		// m_vecSReviewResult 개수가 0일 경우에 대한 예외처리 [2017.6.26 bhs]
		if (itt == ittEnd) continue;

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{

			if (its->nResultCode>ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawUserPointPath2(CDC *pDC)//UserDefect그리기
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorUserResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		// m_vecSReviewResult 개수가 0일 경우에 대한 예외처리 [2017.6.26 bhs]
		if (itt == ittEnd) continue;

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{

			if (its->nResultCode > ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReflowPoint(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReflowResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReflowPoint2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReflowResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReflowPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReflowResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);

}

void CDefectMap::DrawReflowPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReflowResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);

}

void CDefectMap::DrawReflowPointPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReflowResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	// 20181128 smok. Reflow defect 표시부 추가 

	CPen reviewdPenResult0;
	CPen reviewdPenResult1;
	CPen reviewdPenResult2;
	CPen reviewdPenResult3;
	CPen reviewdPenResult4;
	CPen reviewdPenResult5;

	reviewdPenResult0.CreatePen(PS_SOLID, 1, RGB(0,0,0));
	reviewdPenResult1.CreatePen(PS_SOLID, 1, RGB(0,0,0));
	reviewdPenResult2.CreatePen(PS_SOLID, 1, RGB(0,0,0));
	reviewdPenResult3.CreatePen(PS_SOLID, 1, RGB(0,0,0));
	reviewdPenResult4.CreatePen(PS_SOLID, 1, RGB(0,0,0));
	reviewdPenResult5.CreatePen(PS_SOLID, 1, RGB(0,0,0));

	CBrush reviewdBrushResult0(RGB(0,255,0));
	CBrush reviewdBrushResult1(RGB(0,0,255));
	CBrush reviewdBrushResult2(RGB(128, 0,128));
	CBrush reviewdBrushResult3(RGB(255,255,0));
	CBrush reviewdBrushResult4(RGB(255,0,0));
	CBrush reviewdBrushResult5(RGB(0,0,0));
	//////////////////////////////////////////////////

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		// m_vecSReviewResult 개수가 0일 경우에 대한 예외처리 [2017.6.26 bhs]
		if (itt == ittEnd) continue;

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{

			if (its->nResultCode>ReviewResult_None)
			{
				switch (its->nReflow_Result)
				{
				case 0:
					pOldPen = pDC->SelectObject(&reviewdPenResult0);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult0);
					break;

				case 1:
					pOldPen = pDC->SelectObject(&reviewdPenResult1);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult1);
					break;

				case 2:
					pOldPen = pDC->SelectObject(&reviewdPenResult2);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult2);
					break;

				case 3:
					pOldPen = pDC->SelectObject(&reviewdPenResult3);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult3);
					break;

				case 4:
					pOldPen = pDC->SelectObject(&reviewdPenResult4);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult4);
					break;
				default:
					pOldPen = pDC->SelectObject(&reviewdPenResult5);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult5);
					break;
				}
//				pOldPen = pDC->SelectObject(&reviewedPen);
//				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReflowPointPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReflowResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	// 20181128 smok. Reflow defect 표시부 추가 

	CPen reviewdPenResult0;
	CPen reviewdPenResult1;
	CPen reviewdPenResult2;
	CPen reviewdPenResult3;
	CPen reviewdPenResult4;
	CPen reviewdPenResult5;

	reviewdPenResult0.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewdPenResult1.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewdPenResult2.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewdPenResult3.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewdPenResult4.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewdPenResult5.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));

	CBrush reviewdBrushResult0(RGB(0, 255, 0));
	CBrush reviewdBrushResult1(RGB(0, 0, 255));
	CBrush reviewdBrushResult2(RGB(128, 0, 128));
	CBrush reviewdBrushResult3(RGB(255, 255, 0));
	CBrush reviewdBrushResult4(RGB(255, 0, 0));
	CBrush reviewdBrushResult5(RGB(0, 0, 0));
	//////////////////////////////////////////////////

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		// m_vecSReviewResult 개수가 0일 경우에 대한 예외처리 [2017.6.26 bhs]
		if (itt == ittEnd) continue;

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{

			if (its->nResultCode > ReviewResult_None)
			{
				switch (its->nReflow_Result)
				{
				case 0:
					pOldPen = pDC->SelectObject(&reviewdPenResult0);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult0);
					break;

				case 1:
					pOldPen = pDC->SelectObject(&reviewdPenResult1);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult1);
					break;

				case 2:
					pOldPen = pDC->SelectObject(&reviewdPenResult2);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult2);
					break;

				case 3:
					pOldPen = pDC->SelectObject(&reviewdPenResult3);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult3);
					break;

				case 4:
					pOldPen = pDC->SelectObject(&reviewdPenResult4);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult4);
					break;
				default:
					pOldPen = pDC->SelectObject(&reviewdPenResult5);
					pOldBrush = pDC->SelectObject(&reviewdBrushResult5);
					break;
				}
				//				pOldPen = pDC->SelectObject(&reviewedPen);
				//				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawMeasurePointPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorMeasureResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;
	
	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;
	
	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));
	
	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{

			if (its->nResultCode>ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawMeasurePointPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorMeasureResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{

			if (its->nResultCode > ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReviewDefectPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;
	
	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;
	
	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));
	
	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt;
		constVectorSReviewResultIt ittEnd;
		if (pReviewResult->GetSReviewResultCount()>0)
		{
			itt = pReviewResult->m_vecSReviewResult.begin();
			ittEnd = pReviewResult->m_vecSReviewResult.end();
		}
		else
		{
			continue;
		}
		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{

			if (its->nResultCode>ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawReviewDefectPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(12, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt;
		constVectorSReviewResultIt ittEnd;
		if (pReviewResult->GetSReviewResultCount() > 0)
		{
			itt = pReviewResult->m_vecSReviewResult.begin();
			ittEnd = pReviewResult->m_vecSReviewResult.end();
		}
		else
		{
			continue;
		}
		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{

			if (its->nResultCode > ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiDefect(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	if (pCamera)
	{
		for(constVectorReviewResultIt it=pCamera->begin();it!=pCamera->end();it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));
			
			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult==NULL) continue;

			for(constVectorSReviewResultIt its=pResult->begin(); its!=pResult->end();its++)
			{

				if (its->nResultCode!=ReviewResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiDefect2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{

				if (its->nResultCode != ReviewResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map2(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	if (pCamera)
	{
		for(constVectorReviewResultIt it=pCamera->begin();it!=pCamera->end();it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult==NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for(constVectorSReviewResultIt its=pResult->begin(); its!=pResult->end();its++)
			{
				if(itt+1 != ittEnd)
				{
					itt++;
					nStartPosX	= its->nUMOriginX;
					nStartPosY	= its->nUMOriginY;
					nEndPosX	= itt->nUMOriginX;
					nEndPosY	= itt->nUMOriginY;
					TransformGlass2Map(nStartPosX, nStartPosY);
					TransformGlass2Map(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (itt + 1 != ittEnd)
				{
					itt++;
					nStartPosX = its->nUMOriginX;
					nStartPosY = its->nUMOriginY;
					nEndPosX = itt->nUMOriginX;
					nEndPosY = itt->nUMOriginY;
					TransformGlass2Map2(nStartPosX, nStartPosY);
					TransformGlass2Map2(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiDefectPath(CDC *pDC)
{
	if (m_pGlassResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 
	
	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	if (pCamera)
	{
		for(constVectorReviewResultIt it=pCamera->begin();it!=pCamera->end();it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult==NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for(constVectorSReviewResultIt its=pResult->begin(); its!=pResult->end();its++)
			{
				if(itt+1 != ittEnd)
				{
					itt++;
					nStartPosX	= its->nUMOriginX;
					nStartPosY	= its->nUMOriginY;
					nEndPosX	= itt->nUMOriginX;
					nEndPosY	= itt->nUMOriginY;
					TransformGlass2Map(nStartPosX, nStartPosY);
					TransformGlass2Map(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			// select defect pen
			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);

			for(constVectorSReviewResultIt its=pResult->begin(); its!=pResult->end();its++)
			{
				if (its->nResultCode!=WsiResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiDefectPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	const VectorReviewResult *pCamera = m_pGlassResult->GetVectorWsiResult();
	if (pCamera)
	{
		for (constVectorReviewResultIt it = pCamera->begin(); it != pCamera->end(); it++)
		{
			const CReviewResult *pWsiResult = static_cast<const CReviewResult*>(&(*it));

			const VectorSReviewResult* pResult = pWsiResult->GetVectorSReviewResult();

			if (pResult == NULL) continue;

			constVectorSReviewResultIt itt = pResult->begin();
			constVectorSReviewResultIt ittEnd = pResult->end();

			// select path pen
			pOldPen = pDC->SelectObject(&pathPen);
			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (itt + 1 != ittEnd)
				{
					itt++;
					nStartPosX = its->nUMOriginX;
					nStartPosY = its->nUMOriginY;
					nEndPosX = itt->nUMOriginX;
					nEndPosY = itt->nUMOriginY;
					TransformGlass2Map2(nStartPosX, nStartPosY);
					TransformGlass2Map2(nEndPosX, nEndPosY);

					pDC->MoveTo(nStartPosX, nStartPosY);
					pDC->LineTo(nEndPosX, nEndPosY);
				}
			}

			// select defect pen
			pOldPen = pDC->SelectObject(&reviewPen);
			pOldBrush = pDC->SelectObject(&reviewBrush);

			for (constVectorSReviewResultIt its = pResult->begin(); its != pResult->end(); its++)
			{
				if (its->nResultCode != WsiResult_None)
				{
					pOldPen = pDC->SelectObject(&reviewedPen);
					pOldBrush = pDC->SelectObject(&reviewedBrush);
				}
				else
				{
					pOldPen = pDC->SelectObject(&reviewPen);
					pOldBrush = pDC->SelectObject(&reviewBrush);
				}

				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;

				TransformGlass2Map2(nStartPosX, nStartPosY);

				pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
			}
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawClickedPoint(CDC *pDC)
{
	if (m_pGlassResult == NULL)		return;

	CPen pen;
	pen.CreatePen(PS_SOLID, 2, RGB(0,0,0)); 

	pDC->SelectObject(pen);
	pDC->SelectStockObject(NULL_BRUSH);

	pDC->RoundRect(m_clkPoint.x - 6, m_clkPoint.y - 6, m_clkPoint.x + 6, m_clkPoint.y + 6, m_clkPoint.x, m_clkPoint.y);
}

void CDefectMap::DrawReviewImg(CDC *pDC)
{
	if (m_pGlassResult == NULL)		return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorReviewResult();
	if (pVecReviewResult==NULL) return;

	CPen pen;
	pen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 

	pDC->SelectObject(pen);
	pDC->SelectStockObject(NULL_BRUSH);

	int nPosX, nPosY = 0;

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			nPosX	= its->nUMOriginX;
			nPosY	= its->nUMOriginY;
			TransformGlass2Map(nPosX, nPosY);

			pDC->Rectangle(nPosX - 4, nPosY - 4, nPosX + 4, nPosY + 4);
		}
	}
}

void CDefectMap::DrawDefectPoint(int nPosX, int nPosY, COLORREF nColor)
{
	CDC* pDC = GetDC();

	TransformGlass2Map(nPosX, nPosY);

	CPen newPen;
	CBrush NewBrush(nColor);
	newPen.CreatePen(PS_SOLID, 1, nColor); 
	CBitmap*pbmOld = pDC->SelectObject(&m_bitmap);
	CPen* pOldPen = pDC->SelectObject(&newPen);
	CBrush* pOldBrush = pDC->SelectObject(&NewBrush);

	pDC->Rectangle(nPosX - m_nDefectSize, nPosY - m_nDefectSize, nPosX + m_nDefectSize, nPosY + m_nDefectSize);

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pbmOld); 

	ReleaseDC(pDC);

	/*TransformGlass2Map(nPosX, nPosY);

	CBrush NewBrush(nColor);
	CBitmap*pbmOld = m_memDC.SelectObject(&m_bitmap);
	CBrush* pOldBrush = m_memDC.SelectObject(&NewBrush);
	
	m_memDC.Rectangle(nPosX - 2, nPosY - 2, nPosX + 2, nPosY + 2);
	
	m_memDC.SelectObject(pOldBrush);
	m_memDC.SelectObject(pbmOld); 

	Invalidate(FALSE);*/
}

void CDefectMap::DrawDefectPoint2(int nPosX, int nPosY, COLORREF nColor)
{
	CDC* pDC = GetDC();
	int nOriginPosX, nOriginPosY, nTempPosX, nTempPosY;

// 	TransformGlass2Map2(nPosX, nPosY);
// 	nOriginPosX = nPosX;
// 	nOriginPosY = nPosY;
// 	TransformMap2Glass2(nPosX, nPosY);
	TransformGlass2Map(nPosX, nPosY);

// 	nTempPosX = nPosX;
// 	nTempPosY = nPosY;
// 
// 	nTempPosX = nOriginPosX - nTempPosX;
// 	nTempPosY = nOriginPosY - nTempPosY;
// 	nPosX = nOriginPosX + nTempPosX;
// 	nPosY = nOriginPosY + nTempPosY;

	CPen newPen;
	CBrush NewBrush(nColor);
	newPen.CreatePen(PS_SOLID, 1, nColor);
	CBitmap*pbmOld = pDC->SelectObject(&m_bitmap);
	CPen* pOldPen = pDC->SelectObject(&newPen);
	CBrush* pOldBrush = pDC->SelectObject(&NewBrush);

	pDC->Rectangle(nPosX - m_nDefectSize, nPosY - m_nDefectSize, nPosX + m_nDefectSize, nPosY + m_nDefectSize);

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pbmOld);

	ReleaseDC(pDC);
}

void CDefectMap::SetGlassResult(const CGlassResult* pGlassResult)
{
	if(pGlassResult == NULL) return;

	m_pGlassResult = pGlassResult;

	//SetGlassInfo(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);

	//PostMessage(UM_UPDATE_DEFECT_MAP, NULL, NULL);
}

void CDefectMap::SetGlassResult2(const CGlassResult* pGlassResult, BOOL bHistory)
{
	if (pGlassResult == NULL) return;

	m_pGlassResult = pGlassResult;
	m_bHistoryEnable = bHistory;

	//SetGlassInfo(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);

	//PostMessage(UM_UPDATE_DEFECT_MAP, NULL, NULL);
}

void CDefectMap::TransformGlass2Map(int& nUMGlassPosX, int& nUMGlassPosY)
{
	// 변환 좌표계일 경우 x,y 좌표 변환
	if(m_pGlassResult != NULL)
	{
		if(m_pGlassResult->GetGlassInverseCoordinate())
		{
			int nTemp = nUMGlassPosX;
			nUMGlassPosX = nUMGlassPosY;
			nUMGlassPosY = nTemp;
		}
	}

	switch(m_nOriginDir) 
	{
	case GlassOriginDir_LeftTop:
		nUMGlassPosX = m_nOriginX + (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY + (int)(nUMGlassPosY / m_dSizeRatioY);
		break;
	case GlassOriginDir_RightTop:
		nUMGlassPosX = m_nOriginX - (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY + (int)(nUMGlassPosY / m_dSizeRatioY);
		break;
	case GlassOriginDir_LeftBottom:
		nUMGlassPosX = m_nOriginX + (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY - (int)(nUMGlassPosY / m_dSizeRatioY);
		break;
	case GlassOriginDir_RightBottom:
		nUMGlassPosX = m_nOriginX - (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY - (int)(nUMGlassPosY / m_dSizeRatioY);		
		break;

	default:
		nUMGlassPosX = 0;
		nUMGlassPosY = 0;
		break;
	}
}

void CDefectMap::TransformGlass2Map2(int& nUMGlassPosX, int& nUMGlassPosY)
{
	// 변환 좌표계일 경우 x,y 좌표 변환
	if (m_pGlassResult != NULL)
	{
		if (m_pGlassResult->GetGlassInverseCoordinate())
		{
			int nTemp = nUMGlassPosX;
			nUMGlassPosX = nUMGlassPosY;
			nUMGlassPosY = nTemp;
		}
	}

	switch (m_nOriginDir)
	{
	case GlassOriginDir_LeftTop:
		nUMGlassPosX = m_nOriginSizeX + (int)(nUMGlassPosX / m_dOrignSizeRatioX);
		nUMGlassPosY = m_nOriginSizeY + (int)(nUMGlassPosY / m_dOrignSizeRatioY);
		break;
	case GlassOriginDir_RightTop:
		nUMGlassPosX = m_nOriginSizeX - (int)(nUMGlassPosX / m_dOrignSizeRatioX);
		nUMGlassPosY = m_nOriginSizeY + (int)(nUMGlassPosY / m_dOrignSizeRatioY);
		break;
	case GlassOriginDir_LeftBottom:
		nUMGlassPosX = m_nOriginSizeX + (int)(nUMGlassPosX / m_dOrignSizeRatioX);
		nUMGlassPosY = m_nOriginSizeY - (int)(nUMGlassPosY / m_dOrignSizeRatioY);
		break;
	case GlassOriginDir_RightBottom:
		nUMGlassPosX = m_nOriginSizeX - (int)(nUMGlassPosX / m_dOrignSizeRatioX);
		nUMGlassPosY = m_nOriginSizeY - (int)(nUMGlassPosY / m_dOrignSizeRatioY);
		break;

	default:
		nUMGlassPosX = 0;
		nUMGlassPosY = 0;
		break;
	}
}

void CDefectMap::TransformGlass2Map3(int& nUMGlassPosX, int& nUMGlassPosY)
{
	// 변환 좌표계일 경우 x,y 좌표 변환
	if (m_pGlassResult != NULL)
	{
		if (m_pGlassResult->GetGlassInverseCoordinate())
		{
			int nTemp = nUMGlassPosX;
			nUMGlassPosX = nUMGlassPosY;
			nUMGlassPosY = nTemp;
		}
	}

	switch (m_nOriginDir)
	{
	case GlassOriginDir_LeftTop:
		nUMGlassPosX = m_nOriginX + (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY + (int)(nUMGlassPosY / m_dSizeRatioY);
		break;
	case GlassOriginDir_RightTop:
		nUMGlassPosX = m_nOriginX - (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY + (int)(nUMGlassPosY / m_dSizeRatioY);
		break;
	case GlassOriginDir_LeftBottom:
		nUMGlassPosX = m_nOriginX + (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY - (int)(nUMGlassPosY / m_dSizeRatioY);

		// 		nUMGlassPosX = 275;
		// 		nUMGlassPosY = 258;

			//nUMMapPosX = (int)((nUMMapPosX - m_nOriginX) * m_dSizeRatioX);
			//nUMMapPosY = (int)((m_nOriginY - nUMMapPosY) * m_dSizeRatioY);
		// 		test1 = (int)(((test1 + asdfjklwe) - m_nOriginX) * m_dOrignSizeRatioX);
		// 		test2 = (int)((m_nOriginY - (test2 - sajdfklwje)) * m_dOrignSizeRatioY);
		// 		nUMMapPosX = (int)((nUMMapPosX - m_nOriginX + asdfjklwe) * m_dSizeRatioX);
		// 		nUMMapPosY = (int)((m_nOriginY - (nUMMapPosY - sajdfklwje)) * m_dSizeRatioY);

		break;
	case GlassOriginDir_RightBottom:
		nUMGlassPosX = m_nOriginX - (int)(nUMGlassPosX / m_dSizeRatioX);
		nUMGlassPosY = m_nOriginY - (int)(nUMGlassPosY / m_dSizeRatioY);
		break;

	default:
		nUMGlassPosX = 0;
		nUMGlassPosY = 0;
		break;
	}
}

void CDefectMap::TransformMap2Glass(int& nUMMapPosX, int& nUMMapPosY)
{
	switch(m_nOriginDir) 
	{
	case GlassOriginDir_LeftTop:
		nUMMapPosX = (int)((nUMMapPosX - m_nOriginX) * m_dSizeRatioX);
		nUMMapPosY = (int)((nUMMapPosY - m_nOriginY) * m_dSizeRatioY);
		break;
	case GlassOriginDir_RightTop:
		nUMMapPosX = (int)((m_nOriginX - nUMMapPosX) * m_dSizeRatioX) ;
		nUMMapPosY = (int)((nUMMapPosY - m_nOriginY) * m_dSizeRatioY);
		break;
	case GlassOriginDir_LeftBottom:
		nUMMapPosX = (int)((nUMMapPosX - m_nOriginX) * m_dSizeRatioX);
		nUMMapPosY = (int)((m_nOriginY - nUMMapPosY) * m_dSizeRatioY);
		break;
	case GlassOriginDir_RightBottom:
		nUMMapPosX = (int)((m_nOriginX - nUMMapPosX) * m_dSizeRatioX);
		nUMMapPosY = (int)((m_nOriginY - nUMMapPosY) * m_dSizeRatioY);
		break;
	default:
		nUMMapPosX = 0;
		nUMMapPosY = 0;
		break;
	}

	// 변환 좌표계일 경우 x,y 좌표 변환
	if(m_pGlassResult != NULL)
	{
		if(m_pGlassResult->GetGlassInverseCoordinate())
		{
			int nTemp = nUMMapPosX;
			nUMMapPosX = nUMMapPosY;
			nUMMapPosY = nTemp;
		}
	}
}

void CDefectMap::TransformMap2Glass2(int& nUMMapPosX, int& nUMMapPosY)
{
	int nRectHalfLeft = m_rtViewRect.left;
	int nRectHalfTop = m_rtViewRect.top;

	switch (m_nOriginDir)
	{
	case GlassOriginDir_LeftTop:
		nUMMapPosX = (int)((nUMMapPosX - m_nOriginX) * m_dSizeRatioX);
		nUMMapPosY = (int)((nUMMapPosY - m_nOriginY) * m_dSizeRatioY);
		break;
	case GlassOriginDir_RightTop:
		nUMMapPosX = (int)((m_nOriginX - nUMMapPosX) * m_dSizeRatioX);
		nUMMapPosY = (int)((nUMMapPosY - m_nOriginY) * m_dSizeRatioY);
		break;
	case GlassOriginDir_LeftBottom:
		nUMMapPosX = (int)(((nUMMapPosX /*+ nRectHalfLeft*/) - m_nOriginX) * m_dSizeRatioX);
		nUMMapPosY = (int)((m_nOriginY - (nUMMapPosY /*- nRectHalfTop*/)) * m_dSizeRatioY);

		break;
	case GlassOriginDir_RightBottom:
		nUMMapPosX = (int)((m_nOriginX - nUMMapPosX) * m_dSizeRatioX);
		nUMMapPosY = (int)((m_nOriginY - nUMMapPosY) * m_dSizeRatioY);
		break;
	default:
		nUMMapPosX = 0;
		nUMMapPosY = 0;
		break;
	}

	// 변환 좌표계일 경우 x,y 좌표 변환
	if (m_pGlassResult != NULL)
	{
		if (m_pGlassResult->GetGlassInverseCoordinate())
		{
			int nTemp = nUMMapPosX;
			nUMMapPosX = nUMMapPosY;
			nUMMapPosY = nTemp;
		}
	}
}

void CDefectMap::OnLButtonDblClk(UINT nFlags, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	int nPosX = point.x;
	int nPosY = point.y;
	TransformMap2Glass(nPosX, nPosY);

	if(m_pParentWnd)
	{
		m_pParentWnd->PostMessage(UM_DBLCLK_DEFECT_MAP, nPosX, nPosY);
	}

	CWnd::OnLButtonDblClk(nFlags, point);

	return;

	// for ReviewerHistory.exe
	if(m_pGlassResult == NULL)			return;

	const MapDefectResult *pMapDefectResult = m_pGlassResult->GetMapDefectResult();
	if (pMapDefectResult==NULL) return;	

	MapDefectResult mapDefectResult;
	mapDefectResult.clear();

	CDefectResult* pDefect = NULL;
	for(constMapDefectResultIt it=pMapDefectResult->begin();it!=pMapDefectResult->end();it++)
	{
		pDefect = static_cast<CDefectResult*>(it->second);
		nPosX = pDefect->nUMOriginX;
		nPosY = pDefect->nUMOriginY;

		TransformGlass2Map(nPosX, nPosY);

		CPoint viewPoint;
		viewPoint.x = nPosX;
		viewPoint.y = nPosY;

		if(IsValideClickedPoint(viewPoint, point, GLASS_MAP_CLK_RANGE))
		{
			int nClickX = point.x;
			int nClickY = point.y;
			
			TransformMap2Glass(nClickX, nClickY);

			int nXValue = abs(pDefect->nUMOriginX - nClickX);
			int nYValue = abs(pDefect->nUMOriginY - nClickY);

			mapDefectResult.insert(std::make_pair(nXValue + nYValue, pDefect));		// X, Y 좌표 떨어진 절대값 픽셀을 기준으로 Key 값으로 삽입.
		}
	}

	if(mapDefectResult.size() > 0)				// 자동으로 Key 가 작은 값이 맨 앞으로 정렬 됨.
	{
		constMapDefectResultIt it = mapDefectResult.begin();
		pDefect = static_cast<CDefectResult*>(it->second);

		nPosX = pDefect->nUMOriginX;
		nPosY = pDefect->nUMOriginY;

		TransformGlass2Map(nPosX, nPosY);

		CPoint viewPoint;
		viewPoint.x = nPosX;
		viewPoint.y = nPosY;

		m_clkPoint = viewPoint;		

		m_pParentWnd->PostMessage(UWM_SEND_DEFECTMAP_EVENT, (WPARAM)pDefect, NULL);
		UpdateHistoryDefectMap();
	}
	//

	CWnd::OnLButtonDblClk(nFlags, point);
}


void CDefectMap::OnMouseMove(UINT nFlags, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	m_pMousePt.x = point.x;
	m_pMousePt.y = point.y;
	CWnd::OnMouseMove(nFlags, point);
}

BOOL CDefectMap::OnMouseWheel(UINT nFlags, short zDelta, CPoint point)
{
	int nPosX = point.x;
	int nPosY = point.y;

	TransformMap2Glass2(nPosX, nPosY);

	m_nPointX = nPosX;
	m_nPointY = nPosY;
	m_sDelta = zDelta;

	if (m_pParentWnd)
	{
		m_pParentWnd->PostMessage(UM_MOUSEWHEEL_DEFECT_MAP, m_sDelta, NULL);
		return TRUE;
	}

	return FALSE;
}

void CDefectMap::OnLButtonDown(UINT nFlags, CPoint point)
{
	int nPosX = point.x;
	int nPosY = point.y;
	TransformMap2Glass2(nPosX, nPosY);
	double aaa;
	aaa = m_dDefectZoom;
	if (m_pParentWnd)
	{
		m_pParentWnd->PostMessage(UM_LBDOWN_DEFECT_MAP2, nPosX, nPosY);
	}

	CWnd::OnLButtonDown(nFlags, point);

	return;
}

void CDefectMap::OnRButtonDblClk(UINT nFlags, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	int nPosX = point.x;
	int nPosY = point.y;

	TransformMap2Glass(nPosX, nPosY);

	if(m_pParentWnd)
	{
		m_pParentWnd->PostMessage(UM_DBRCLK_DEFECT_MAP, nPosX, nPosY);
	}

	CWnd::OnRButtonDblClk(nFlags, point);
}

void CDefectMap::OnRButtonDown(UINT nFlags, CPoint point)
{
// 	m_pMouseDwPt.x = point.x;
// 	m_pMouseDwPt.y = point.y;
	CWnd::OnRButtonDown(nFlags, point);
}

void CDefectMap::OnRButtonUp(UINT nFlags, CPoint point)
{
// 	m_pMouseUpPt.x = point.x;
// 	m_pMouseUpPt.y = point.y;
// 
// 	m_nDefectOffsetX = (m_pMouseDwPt.x + m_pMouseUpPt.x)/10;
// 	m_nDefectOffsetY = (m_pMouseDwPt.y + m_pMouseUpPt.y)/10;
// 
// 
// 	SetGlassInfo2(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);
// 
// 	UpdateDefectMap3();

	CWnd::OnRButtonUp(nFlags, point);
}


void CDefectMap::SetDisplayClickedPoint(const CDefectResult* pDefectResult)
{

	int nPosX, nPosY;
	nPosX = pDefectResult->nUMOriginX;
	nPosY = pDefectResult->nUMOriginY;

	TransformGlass2Map(nPosX, nPosY);
	m_clkPoint.x = nPosX;
	m_clkPoint.y = nPosY;

	UpdateHistoryDefectMap();
}

void CDefectMap::ClearDefectMap(void)
{
	m_clkPoint = NULL;

	UpdateHistoryDefectMap();
}

BOOL CDefectMap::IsValideClickedPoint(const CPoint origPoint, CPoint compPoint, int nRange)
{
	int nXValue = abs(origPoint.x - compPoint.x);
	int nYValue = abs(origPoint.y - compPoint.y);

	return ((nXValue < nRange && nYValue < nRange) ? TRUE : FALSE);
}

LRESULT	CDefectMap::OnUpdateDefectMap(WPARAM wParam, LPARAM lParam)
{
	if (m_pGlassResult==NULL) return 0;

	SetGlassInfo(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);

	UpdateDefectMap();

	return 1;
}

LRESULT	CDefectMap::OnUpdateDefectMap2(WPARAM wParam, LPARAM lParam)
{
	if (m_pGlassResult == NULL) return 0;


	SetGlassInfo(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);
	//글라스의 값을 가지고 있자

	UpdateDefectMap2();

	return 1;
}


LRESULT	CDefectMap::OnReviewResultUpdate(WPARAM wParam, LPARAM lParam)
{
	if (m_pGlassResult==NULL) return 0;

	CDC *pDC = GetDC();

	UpdateReviewResult(pDC);

	ReleaseDC(pDC);

	return 1;
}
LRESULT CDefectMap::OnUpdateDefectMapDefault(WPARAM wParam, LPARAM lParam)
{
	if (m_pGlassResult)
	{
		//SetGlassInfo(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);

		UpdateDefectMap();
	}
	else
	{
		GetClientRect(m_rtViewRect);

		if (m_rtViewRect.Width()==0 || m_rtViewRect.Height()==0) return 0;

		CDC *pDC = GetDC();

		DrawGlass(pDC, m_rtViewRect);

		DrawCornerCut(pDC);

		DCtoIplImage(pDC, m_rtViewRect);

		ReleaseDC(pDC);

		Invalidate(TRUE);
	}

	return 1;
}
LRESULT CDefectMap::OnHistoryWhell(WPARAM wParam, LPARAM lParam)
{
	if (m_pGlassResult == NULL)
	{
		return FALSE;
	}

	SetGlassInfo2(m_pGlassResult->m_nGlassSizeX, m_pGlassResult->m_nGlassSizeY, m_pGlassResult->m_nCornerCutDir, m_pGlassResult->m_nOriginDir);
	UpdateDefectMap2();

	return 1;
}

void CDefectMap::DrawWsiReflowPoint( CDC *pDC )
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorWsiReflowResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiReflowPoint2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorWsiReflowResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (its->nResultCode > ReviewResult_Process_Fail)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}

	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiReflowPath( CDC *pDC )
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorWsiReflowResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255,255,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiReflowPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorWsiReflowResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt = pReviewResult->m_vecSReviewResult.begin();
		constVectorSReviewResultIt ittEnd = pReviewResult->m_vecSReviewResult.end();

		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);

		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiReflowPointPath( CDC *pDC )
{
	if (m_pGlassResult==NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorWsiReflowResult();
	if (pVecReviewResult==NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255,255,0));
	CBrush reviewedBrush(RGB(255,0,0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0,0,0)); 
	pathPen.CreatePen(PS_DOT, 1, RGB(0,0,255)); 

	for(constVectorReviewResultIt it=pVecReviewResult->begin();it!=pVecReviewResult->end();it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt;
		constVectorSReviewResultIt ittEnd;
		if (pReviewResult->GetSReviewResultCount()>0)
		{
			itt = pReviewResult->m_vecSReviewResult.begin();
			ittEnd = pReviewResult->m_vecSReviewResult.end();
		}
		else
		{
			continue;
		}
		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0) 
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{
			if(itt+1 != ittEnd)
			{
				itt++;
				nStartPosX	= its->nUMOriginX;
				nStartPosY	= its->nUMOriginY;
				nEndPosX	= itt->nUMOriginX;
				nEndPosY	= itt->nUMOriginY;
				TransformGlass2Map(nStartPosX, nStartPosY);
				TransformGlass2Map(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for(constVectorSReviewResultIt its=pReviewResult->m_vecSReviewResult.begin(); its!=pReviewResult->m_vecSReviewResult.end();its++)
		{

			if (its->nResultCode>ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}

void CDefectMap::DrawWsiReflowPointPath2(CDC *pDC)
{
	if (m_pGlassResult == NULL) return;

	const VectorReviewResult *pVecReviewResult = m_pGlassResult->GetVectorWsiReflowResult();
	if (pVecReviewResult == NULL) return;

	int nStartPosX, nStartPosY, nEndPosX, nEndPosY;
	CReviewResult reviewResult;

	CPen reviewPen;
	CPen reviewedPen;
	CPen pathPen;

	CPen *pOldPen = NULL;
	CBrush* pOldBrush = NULL;

	CBrush reviewBrush(RGB(255, 255, 0));
	CBrush reviewedBrush(RGB(255, 0, 0));

	reviewPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	reviewedPen.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
	pathPen.CreatePen(PS_DOT, 1, RGB(0, 0, 255));

	for (constVectorReviewResultIt it = pVecReviewResult->begin(); it != pVecReviewResult->end(); it++)
	{
		const CReviewResult *pReviewResult = static_cast<const CReviewResult*>(&(*it));

		constVectorSReviewResultIt itt;
		constVectorSReviewResultIt ittEnd;
		if (pReviewResult->GetSReviewResultCount() > 0)
		{
			itt = pReviewResult->m_vecSReviewResult.begin();
			ittEnd = pReviewResult->m_vecSReviewResult.end();
		}
		else
		{
			continue;
		}
		const SReviewResult *pSReviewResult = static_cast<const SReviewResult*>(&(*itt));
		int nDraw = FilterDefectPos(m_pDefectFilter, pSReviewResult);
		if (nDraw < 0)
		{
			continue;
		}

		// select path pen
		pOldPen = pDC->SelectObject(&pathPen);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{
			if (itt + 1 != ittEnd)
			{
				itt++;
				nStartPosX = its->nUMOriginX;
				nStartPosY = its->nUMOriginY;
				nEndPosX = itt->nUMOriginX;
				nEndPosY = itt->nUMOriginY;
				TransformGlass2Map2(nStartPosX, nStartPosY);
				TransformGlass2Map2(nEndPosX, nEndPosY);

				pDC->MoveTo(nStartPosX, nStartPosY);
				pDC->LineTo(nEndPosX, nEndPosY);
			}
		}

		// select defect pen
		pOldPen = pDC->SelectObject(&reviewPen);
		pOldBrush = pDC->SelectObject(&reviewBrush);
		for (constVectorSReviewResultIt its = pReviewResult->m_vecSReviewResult.begin(); its != pReviewResult->m_vecSReviewResult.end(); its++)
		{

			if (its->nResultCode > ReviewResult_None)
			{
				pOldPen = pDC->SelectObject(&reviewedPen);
				pOldBrush = pDC->SelectObject(&reviewedBrush);
			}
			else
			{
				pOldPen = pDC->SelectObject(&reviewPen);
				pOldBrush = pDC->SelectObject(&reviewBrush);
			}

			nStartPosX = its->nUMOriginX;
			nStartPosY = its->nUMOriginY;

			TransformGlass2Map2(nStartPosX, nStartPosY);

			pDC->Ellipse(nStartPosX - m_nReviewSize, nStartPosY - m_nReviewSize, nStartPosX + m_nReviewSize, nStartPosY + m_nReviewSize);
		}
	}

	pDC->SelectObject(pOldPen);
}