_commandEntries
#include "StdAfx.h"
#include "CHGlassDefectMap/GlassDefectMap.h"

#define SafeRelease(T)		if(T)	{T->Release(); T = 0; }
#define SafeDelete(T)		if(T)	{delete T; T = 0; }


int GetDirX(int nDir1, int nDir2)
{
	if ( (nDir1==MODT_LeftTop) || (nDir1==MODT_LeftBottom) )
	{
		if ( (nDir2==MODT_LeftTop) || (nDir2==MODT_LeftBottom) )
		{
			return 1;
		}
		return 0;
	}

	if ( (nDir2==MODT_RightTop) || (nDir2==MODT_RightBottom) )
	{
		return 1;
	}
	return 0;
}

int GetDirY(int nDir1, int nDir2)
{
	if ( (nDir1==MODT_LeftTop) || (nDir1==MODT_RightTop) )
	{
		if ( (nDir2==MODT_LeftTop) || (nDir2==MODT_RightTop) )
		{
			return 1;
		}
		return 0;
	}

	if ( (nDir2==MODT_LeftBottom) || (nDir2==MODT_RightBottom) )
	{
		return 1;
	}
	return 0;
}


// CGlassDefectMapWnd

IMPLEMENT_DYNAMIC(CGlassDefectMap, CWnd)

CGlassDefectMap::CGlassDefectMap(CWnd* pParentWnd) : m_pParentWnd(pParentWnd)
{
	CoInitialize(0);

	HRESULT hr = S_OK;

	// create wic factory
	hr = ::CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&m_pWICFactory));
	if (hr!=S_OK)
	{
	}

	// create d2d factory
	hr = ::D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pD2DFactory);
	if (hr!=S_OK) 
	{
	}

	// create direct write factory
	hr = ::DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), (IUnknown**)&m_pDWFactroy);
	if (hr!=S_OK) 
	{
	}

	m_pLayerDefect			= nullptr;
	m_pLayerCell			= nullptr;
	m_pLayerGlass			= nullptr;
	m_pRenderTargetHwnd		= nullptr;

	m_bDrawGlass			= TRUE;
	m_bDrawCell			= TRUE;
	m_bDrawDefect			= TRUE;

	m_nMapDrawType			= MDT_Auto;
	m_fMapZoomLevel			= 0.9f;
	m_ptMapPoint			= CPoint(0,0);
	m_nMapBackColor			= MakeColor(0,255,255,255);

	m_fMapTranslation		= D2D1::SizeF(0.0f, 0.0f);
	m_fMapScale				= D2D1::SizeF(1.0f, 1.0f);
	m_fMapPoint				= D2D1::Point2F(0.0f, 0.0f);

	m_vecDrawData_Cell.push_back(CDrawData_Cell());

	m_matTransform			= D2D1::Matrix3x2F::Identity();
}

CGlassDefectMap::~CGlassDefectMap(void)
{
	SafeRelease(m_pLayerDefect);
	SafeRelease(m_pLayerCell);
	SafeRelease(m_pLayerGlass);

	SafeRelease(m_pRenderTargetHwnd);
	SafeRelease(m_pDWFactroy);
	SafeRelease(m_pD2DFactory);
	SafeRelease(m_pWICFactory);

	CoUninitialize();
}

BEGIN_MESSAGE_MAP(CGlassDefectMap, CWnd)
	ON_WM_PAINT()
	ON_WM_CREATE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
END_MESSAGE_MAP()

void CGlassDefectMap::InitGlassDefectMap()
{
	if (m_pD2DFactory==nullptr || m_pWICFactory==nullptr) return;

	CRect rect;
	GetClientRect(rect);

	// set size
	m_uRenderTargetHwndSize		= D2D1::SizeU(rect.Width(), rect.Height());
	m_fRenderTargetHwndSize		= D2D1::SizeF(FLOAT(rect.Width()), FLOAT(rect.Height()));
	m_pxRenderTargetHwndSize	= D2D1::SizeU(m_uRenderTargetHwndSize.width * 4, m_uRenderTargetHwndSize.height * 4);
	m_rtRenderTargetHwndRect	= D2D1::RectF( 0.f, 0.f, m_fRenderTargetHwndSize.width, m_fRenderTargetHwndSize.height );

	// create hwnd render target
	SafeRelease(m_pRenderTargetHwnd);
	HRESULT hr = m_pD2DFactory->CreateHwndRenderTarget(D2D1::RenderTargetProperties(), ::D2D1::HwndRenderTargetProperties(this->GetSafeHwnd(), m_uRenderTargetHwndSize), &m_pRenderTargetHwnd);
	if (hr!=S_OK) 
	{
		return;
	}
	
	return;
}

void CGlassDefectMap::DrawGlassLayer(ID2D1RenderTarget *pRenderTarget, const D2D1_RECT_F* pDestRect)
{
	if (pRenderTarget==nullptr) return;

	if (m_pLayerGlass==nullptr) UpdateGlassLayer(pRenderTarget);

	if (m_pLayerGlass==nullptr) return;

	pRenderTarget->DrawBitmap(m_pLayerGlass, pDestRect);
}

void CGlassDefectMap::DrawCellLayer(ID2D1RenderTarget *pRenderTarget, const D2D1_RECT_F* pDestRect)
{
	if (pRenderTarget==nullptr) return;

	if (m_pLayerCell==nullptr) UpdateCellLayer(pRenderTarget);

	if (m_pLayerCell==nullptr) return;

	pRenderTarget->DrawBitmap(m_pLayerCell, pDestRect);
}

void CGlassDefectMap::DrawDefectLayer(ID2D1RenderTarget *pRenderTarget, const D2D1_RECT_F* pDestRect)
{
	if (pRenderTarget==nullptr) return;

	if (m_pLayerDefect==nullptr) UpdateDefectLayer(pRenderTarget);

	if (m_pLayerDefect==nullptr) return;

	pRenderTarget->DrawBitmap(m_pLayerDefect, pDestRect);
}

void CGlassDefectMap::UpdateDrawData(ID2D1RenderTarget *pRenderTarget, const CDrawData* pDrawData, float fScale)
{
	// set rect
	D2D1_RECT_F rect = D2D1::RectF(pDrawData->fLeft, pDrawData->fTop, pDrawData->fRight, pDrawData->fBottom);

	// create pen
	ID2D1SolidColorBrush *pPen = NULL;
	HRESULT hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(pDrawData->nPenColor, pDrawData->fPenOpacity)), &pPen);
	if (hr!=S_OK) 
	{
		return;
	}

	// create brush
	ID2D1SolidColorBrush *pBrush = NULL;
	hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(pDrawData->nBrushColor, pDrawData->fBrushOpacity)), &pBrush);
	if (hr!=S_OK) 
	{
		SafeRelease(pPen);
		return;
	}

	pRenderTarget->FillRectangle(rect, pBrush);

	float fPenSize = pDrawData->fPenSize / fScale;
	pRenderTarget->DrawRectangle(rect, pPen, fPenSize);

	SafeRelease(pPen);
	SafeRelease(pBrush);
}


void CGlassDefectMap::UpdateGlassCorner( ID2D1RenderTarget *pRenderTarget, const CDrawData_Glass* pDataGlass, const D2D1_SIZE_F& fScale)
{
	ID2D1PathGeometry* pPathGeometry = nullptr;
	HRESULT hr = m_pD2DFactory->CreatePathGeometry(&pPathGeometry);
	if (hr!=S_OK)
	{
		return;
	}

	ID2D1GeometrySink* pGeometrySink = nullptr;
	hr = pPathGeometry->Open(&pGeometrySink);
	if (hr!=S_OK)
	{
		SafeRelease(pPathGeometry);
		return;
	}

	int nDirX = GetDirX(pDataGlass->nOriginDir, pDataGlass->nCornerDir);
	int nDirY = GetDirY(pDataGlass->nOriginDir, pDataGlass->nCornerDir);

	float fCornerWidth = pDataGlass->fCornerSize / fabs(fScale.width);
	float fCornerHeight = pDataGlass->fCornerSize / fabs(fScale.height);

	// Use D2D1_FIGURE_BEGIN_FILLED for filled
	D2D1_FIGURE_BEGIN fg = D2D1_FIGURE_BEGIN_FILLED;
	D2D1_FIGURE_END fe = D2D1_FIGURE_END_CLOSED;


	switch(pDataGlass->nCornerDir)
	{
	case MODT_LeftTop:
		pGeometrySink->BeginFigure(D2D1::Point2F(0.0f, 0.0f), fg);
		pGeometrySink->AddLine(D2D1::Point2F(fCornerWidth, 0.0f));
		pGeometrySink->AddLine(D2D1::Point2F(0.0f, fCornerHeight));
		break;

	case MODT_RightTop:
		pGeometrySink->BeginFigure(D2D1::Point2F(pDataGlass->fGlassWidth, 0.0f), fg);
		pGeometrySink->AddLine(D2D1::Point2F(pDataGlass->fGlassWidth-fCornerWidth, 0.0f));
		pGeometrySink->AddLine(D2D1::Point2F(pDataGlass->fGlassWidth, fCornerHeight));
		break;

	case MODT_LeftBottom:
		pGeometrySink->BeginFigure(D2D1::Point2F(0.0f, pDataGlass->fGlassHeight), fg);
		pGeometrySink->AddLine(D2D1::Point2F(fCornerWidth, pDataGlass->fGlassHeight));
		pGeometrySink->AddLine(D2D1::Point2F(0.0f, pDataGlass->fGlassHeight-fCornerHeight));
		break;

	case MODT_RightBottom:
		pGeometrySink->BeginFigure(D2D1::Point2F(pDataGlass->fGlassWidth, pDataGlass->fGlassHeight), fg);
		pGeometrySink->AddLine(D2D1::Point2F(pDataGlass->fGlassWidth-fCornerWidth, pDataGlass->fGlassHeight));
		pGeometrySink->AddLine(D2D1::Point2F(pDataGlass->fGlassWidth, pDataGlass->fGlassHeight-fCornerHeight));
		break;

	default:
		SafeRelease(pPathGeometry);
		SafeRelease(pGeometrySink);
		return;
	}

	pGeometrySink->EndFigure(fe);
	pGeometrySink->Close();
	SafeRelease(pGeometrySink);

	ID2D1SolidColorBrush *pBrush = NULL;
	hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(pDataGlass->nCornerColor, 1.0f)), &pBrush);
	if (hr!=S_OK)
	{
		SafeRelease(pPathGeometry)
		return;
	}

	pRenderTarget->FillGeometry(pPathGeometry, pBrush);

	SafeRelease(pBrush);
	SafeRelease(pPathGeometry);
}

void CGlassDefectMap::UpdateGlassRuler( ID2D1RenderTarget *pRenderTarget, const CDrawData_Glass* pDataGlass, const D2D1_SIZE_F& fScale)
{
	int nWidthCount = int( (pDataGlass->fGlassWidth / pDataGlass->fRulerWidth) + 0.5f) + 1;
	int nHeightCount = int( (pDataGlass->fGlassHeight / pDataGlass->fRulerHeight) + 0.5f) + 1;

	ID2D1SolidColorBrush *pPenStart = NULL;
	HRESULT hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(MakeColor(0,0,0,0), 1.0f)), &pPenStart);
	if (hr!=S_OK)
	{
		return;
	}

	ID2D1SolidColorBrush *pPenMiddle = NULL;
	hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(pDataGlass->nPenColor, 1.0f)), &pPenMiddle);
	if (hr!=S_OK)
	{
		SafeRelease(pPenStart);
		return;
	}


	D2D1_POINT_2F pt1, pt2, pt3, pt4;
	CString str = _T("");

	float fTextWidth	= 14.0f / fabs(fScale.width);
	float fTextHeight	= 5.0f / fabs(fScale.height);
	float fGabWidth		= 5.0f / fabs(fScale.width);
	float fGabHeight	= 5.0f / fabs(fScale.height);
	float fPenWidth		= pDataGlass->fRulerStrokeWidth / fabs(fScale.width);

	float fFontSize = 25.f;
	IDWriteTextFormat *pTextFormat = NULL;
	hr = m_pDWFactroy->CreateTextFormat(
		L"Calibri",
		0,
		DWRITE_FONT_WEIGHT_REGULAR,
		DWRITE_FONT_STYLE_NORMAL,
		DWRITE_FONT_STRETCH_MEDIUM,
		fFontSize,
		L"en-us",
		&pTextFormat
		);
	if (hr!=S_OK)
	{
		SafeRelease(pPenStart);
		return;
	}

	// x dir
	pt1.y = 0.f; 
	pt2.y = pDataGlass->fGlassHeight;
	pt3.y = -fGabHeight;

	for (int nIdx=0; nIdx<nWidthCount; nIdx++)
	{
		pt3.x = pt2.x = pt1.x = (FLOAT(nIdx) * pDataGlass->fRulerWidth);

		if (pt1.x > pDataGlass->fGlassWidth) continue;

		if (nIdx==0)
		{
			pRenderTarget->DrawLine(pt1, pt2, pPenStart, fPenWidth);
		}
		else
		{
			pRenderTarget->DrawLine(pt1, pt2, pPenMiddle, fPenWidth);
		}

		pRenderTarget->DrawLine(pt1, pt3, pPenStart, fPenWidth);

#ifdef X
		str.Format(_T("%d"), (int)pt1.x);
		IDWriteTextLayout *pTextLayout = NULL;
		HRESULT hr = m_pDWFactroy->CreateTextLayout(str, wcslen(str), pTextFormat, fTextWidth*2.0f, fTextHeight, &pTextLayout);
#else
		USES_CONVERSION;
		str.Format(_T("%d"), (int)pt1.x);
		WCHAR *wcstr = T2W(str.GetBuffer());
		IDWriteTextLayout *pTextLayout = NULL;
		HRESULT hr = m_pDWFactroy->CreateTextLayout(wcstr, wcslen(wcstr), pTextFormat, fTextWidth*2.0f, fTextHeight, &pTextLayout);
#endif
		if (hr!=S_OK) continue;

		pTextLayout->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);

		pt4 = pt3;
		pt4.x -= fTextWidth;
		pt4.y -= fTextHeight* 4.f;

		pRenderTarget->DrawTextLayout(pt4, pTextLayout, pPenStart);

		SafeRelease(pTextLayout);
	}

	// y dir
	pt1.x = 0.0f;
	pt2.x = pDataGlass->fGlassWidth;
	pt3.x = -fGabWidth;
	for (int nIdx=0; nIdx<nHeightCount; nIdx++)
	{
		pt3.y = pt2.y = pt1.y = (FLOAT(nIdx) * pDataGlass->fRulerHeight);

		if (pt1.y > pDataGlass->fGlassHeight) continue;

		if (nIdx==0)
		{
			pRenderTarget->DrawLine(pt1, pt2, pPenStart, fPenWidth);
		}
		else
		{
			pRenderTarget->DrawLine(pt1, pt2, pPenMiddle, fPenWidth);
		}

		pRenderTarget->DrawLine(pt1, pt3, pPenStart, fPenWidth);

#ifdef X
		str.Format(_T("%d"), (int)pt1.y);
		IDWriteTextLayout *pTextLayout = NULL;
		HRESULT hr = m_pDWFactroy->CreateTextLayout(str, wcslen(str), pTextFormat, fTextWidth*2.0f, fTextHeight, &pTextLayout);
#else
		USES_CONVERSION;
		str.Format(_T("%d"), (int)pt1.y);
		WCHAR *wcstr1 = T2W(str.GetBuffer());
		IDWriteTextLayout *pTextLayout = NULL;
		HRESULT hr = m_pDWFactroy->CreateTextLayout(wcstr1, wcslen(wcstr1), pTextFormat, fTextWidth*2.0f, fTextHeight, &pTextLayout);
#endif
		if (hr!=S_OK) continue;

		pTextLayout->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);

		pt4 = pt3;
		pt4.x -= (fTextWidth * 2.f);
		pt4.y -= fTextHeight * 1.5f;

		pRenderTarget->DrawTextLayout(pt4, pTextLayout, pPenStart);

		SafeRelease(pTextLayout);

	}

	SafeRelease(pTextFormat); // ¸É¹ö·Î Ãß°¡ÇÊ¿ä
	SafeRelease(pPenStart);
	SafeRelease(pPenMiddle);
}


void CGlassDefectMap::UpdateGlassLayer(ID2D1RenderTarget *pRenderTarget)
{
	// create render target
	ID2D1BitmapRenderTarget	*pRenderTargetBitmap = nullptr;
	HRESULT  hr = pRenderTarget->CreateCompatibleRenderTarget(m_fRenderTargetHwndSize, m_pxRenderTargetHwndSize, &pRenderTargetBitmap);
	if (hr!=S_OK)
	{
		return;
	}
	
	// begin
	pRenderTargetBitmap->BeginDraw();

	// transform
	pRenderTargetBitmap->SetTransform(m_matTransform);

	if (pRenderTargetBitmap->GetAntialiasMode() != D2D1_ANTIALIAS_MODE_PER_PRIMITIVE) 
	{
		pRenderTargetBitmap->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
	}

	// update draw data
	UpdateDrawData(pRenderTargetBitmap, &m_DrawData_Glass, m_fMapScale.width);

	// update glass ruler
	UpdateGlassRuler(pRenderTargetBitmap, &m_DrawData_Glass, m_fMapScale);

	// update glass corner
	D2D1_MATRIX_3X2_F matTransform;
	CalCornerTransformMatrix(m_fMapTranslation, m_fMapScale, m_fMapPoint, m_fRenderTargetHwndSize, &m_DrawData_Glass, matTransform);
	pRenderTargetBitmap->SetTransform(matTransform);

	UpdateGlassCorner(pRenderTargetBitmap, &m_DrawData_Glass, m_fMapScale);

	pRenderTargetBitmap->EndDraw();

	// get bitmap
	SafeRelease(m_pLayerGlass);
	hr = pRenderTargetBitmap->GetBitmap(&m_pLayerGlass);

	// release render target
	SafeRelease(pRenderTargetBitmap);
}



void CGlassDefectMap::UpdateCellLayer(ID2D1RenderTarget *pRenderTarget)
{
	// create render target
	ID2D1BitmapRenderTarget	*pRenderTargetBitmap = nullptr;
	HRESULT  hr = pRenderTarget->CreateCompatibleRenderTarget(m_fRenderTargetHwndSize, m_pxRenderTargetHwndSize, &pRenderTargetBitmap);
	if (hr!=S_OK)
	{
		return;
	}

	// begin
	pRenderTargetBitmap->BeginDraw();

	// transform
	pRenderTargetBitmap->SetTransform(m_matTransform);

	if (pRenderTargetBitmap->GetAntialiasMode() == D2D1_ANTIALIAS_MODE_ALIASED) 
	{
		pRenderTargetBitmap->SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
	}

	// update draw data
	for (constVectorDrawData_CellIt it=m_vecDrawData_Cell.begin(); it!=m_vecDrawData_Cell.end(); it++)
	{
		const CDrawData_Cell *pDrawData = static_cast<const CDrawData_Cell *>(&(*it));
		if (pDrawData==NULL) continue;

		UpdateDrawData(pRenderTargetBitmap, pDrawData, m_fMapScale.width);
	}
	
	// end
	pRenderTargetBitmap->EndDraw();

	// get bitmap
	SafeRelease(m_pLayerCell);
	pRenderTargetBitmap->GetBitmap(&m_pLayerCell);

	// release render target
	SafeRelease(pRenderTargetBitmap);
}

void CGlassDefectMap::UpdateDefectLayer(ID2D1RenderTarget *pRenderTarget)
{
// 	if (m_pRenderTargetBitmap==nullptr) return;
// 
// 	// clear
// 	m_pRenderTargetBitmap->Clear();
// 
// 	// transform
// 	m_pRenderTargetBitmap->SetTransform(m_matTransform);
// 
// 	// draw
// 
// 	// get
// 	SafeRelease(m_pLayerDefect);
// 	m_pRenderTargetBitmap->GetBitmap( &m_pLayerDefect );
}

/*
void CGlassDefectMap::CalculateMapScale(const D2D1_SIZE_F& fViewSize, const int nDrawType, const float fZoomLevel, const CDrawData_Glass *pDataGlass, D2D1_SIZE_F& fMapScale, D2D1_MATRIX_3X2_F& matMapScale)
{
	matMapScale = D2D1::SizeF(0.0f, 0.0f);

	float fScaleX	= fViewSize.width / pDataGlass->fGlassWidth;
	float fScaleY	= fViewSize.height / pDataGlass->fGlassHeight;

	// 1. cal scale
	switch(nDrawType)
	{
	case MDT_Auto:
		{
			if (fScaleX < fScaleY)
			{
				fMapScale = D2D1::SizeF(fScaleX, fScaleX);
			}
			else
			{
				fMapScale = D2D1::SizeF(fScaleY, fScaleY);
			}
		}
		break;

	case MDT_Horiz:
		{
			fMapScale	= D2D1::SizeF(fScaleX, fScaleX);
		}
		break;

	case MDT_Vert:
		{
			fMapScale	= D2D1::SizeF(fScaleY, fScaleY);
		}
		break;

	case MDT_Fit:
		fMapScale.width		= fScaleX;
		fMapScale.height	= fScaleY;
		break;
	}

	// 2. cal zoom
	fMapScale.width *= fZoomLevel;
	fMapScale.height *= fZoomLevel;


}
*/

void CGlassDefectMap::CalTransformMatrix()
{
	m_matTransform = D2D1::Matrix3x2F::Identity();

	m_fMapTranslation	= D2D1::SizeF(0.0f, 0.0f);
	m_fMapScale			= D2D1::SizeF(1.0f, 1.0f);

	float fViewWidth = m_fRenderTargetHwndSize.width;
	float fViewHeight = m_fRenderTargetHwndSize.height;

	// 1. cal scale
	int nDrawType = m_nMapDrawType;
	switch(nDrawType)
	{
	case MDT_Auto:
		{
			float fMapScaleX	= fViewWidth / m_DrawData_Glass.fGlassWidth;
			float fMapScaleY	= fViewHeight / m_DrawData_Glass.fGlassHeight;

			if (fMapScaleX < fMapScaleY)
			{
				nDrawType	= MDT_Horiz;
				m_fMapScale	= D2D1::SizeF(fMapScaleX, fMapScaleX);
			}
			else
			{
				nDrawType	= MDT_Vert;
				m_fMapScale	= D2D1::SizeF(fMapScaleY, fMapScaleY);
			}
		}
		break;

	case MDT_Horiz:
		{
			float fMapScaleX = fViewWidth / m_DrawData_Glass.fGlassWidth;
			m_fMapScale	= D2D1::SizeF(fMapScaleX, fMapScaleX);
		}
		break;

	case MDT_Vert:
		{
			float fMapScaleY = fViewHeight / m_DrawData_Glass.fGlassHeight;
			m_fMapScale	= D2D1::SizeF(fMapScaleY, fMapScaleY);
		}
		break;

	case MDT_Fit:
		m_fMapScale.width	= fViewWidth / m_DrawData_Glass.fGlassWidth;
		m_fMapScale.height	= fViewHeight / m_DrawData_Glass.fGlassHeight;
		break;
	}

	// 2. cal zoom
	m_fMapScale.width *= m_fMapZoomLevel;
	m_fMapScale.height *= m_fMapZoomLevel;

	// 3. cal trans
	switch(m_DrawData_Glass.nOriginDir)
	{
	case MODT_LeftTop:
 		m_fMapTranslation.width = ( fViewWidth - (m_DrawData_Glass.fGlassWidth * m_fMapScale.width) ) / 2.f ;
 		m_fMapTranslation.height = ( fViewHeight - (m_DrawData_Glass.fGlassHeight * m_fMapScale.height) ) / 2.f ;
		m_fMapScale.width *= 1.0f;
		m_fMapScale.height *= 1.0f;
		break;

	case MODT_RightTop:
		m_fMapTranslation.width = fViewWidth - ( fViewWidth - (m_DrawData_Glass.fGlassWidth * m_fMapScale.width) ) / 2.f ;
		m_fMapTranslation.height= ( fViewHeight - (m_DrawData_Glass.fGlassHeight * m_fMapScale.height) ) / 2.f ;
		m_fMapScale.width *= -1.0f;
		m_fMapScale.height *= 1.0f;
		break;

	case MODT_LeftBottom:
		m_fMapTranslation.width = ( fViewWidth - (m_DrawData_Glass.fGlassWidth * m_fMapScale.width) ) / 2.f ;
		m_fMapTranslation.height = fViewHeight - ( fViewHeight - (m_DrawData_Glass.fGlassHeight * m_fMapScale.height) ) / 2.f ;
		m_fMapScale.width *= 1.0f;
		m_fMapScale.height *= -1.0f;
		break;

	case MODT_RightBottom:
		m_fMapTranslation.width = fViewWidth - ( fViewWidth - (m_DrawData_Glass.fGlassWidth * m_fMapScale.width) ) / 2.f ;
		m_fMapTranslation.height = fViewHeight - ( fViewHeight - (m_DrawData_Glass.fGlassHeight * m_fMapScale.height) ) / 2.f ;
		m_fMapScale.width *= -1.0f;
		m_fMapScale.height *= -1.0f;
		break;

	default:
		return;
	}

	// 4. cal dx, dy
// 	m_fMapPoint.x -= FLOAT(m_ptMapPoint.x) / m_fMapScale.width;
// 	m_fMapPoint.y -= FLOAT(m_ptMapPoint.y) / m_fMapScale.height;
	D2D1_MATRIX_3X2_F	matTranslation = D2D1::Matrix3x2F::Translation(m_fMapTranslation);
	D2D1_MATRIX_3X2_F	matScale = D2D1::Matrix3x2F::Scale(m_fMapScale, m_fMapPoint);

	// 5. cal transform matrix
	m_matTransform = matScale * matTranslation;
}

void CGlassDefectMap::CalCornerTransformMatrix(const D2D1_SIZE_F& fTrans, const D2D1_SIZE_F& fScale, const D2D1_POINT_2F& fPoint, const D2D1_SIZE_F& fViewSize, const CDrawData_Glass *pDataGlass, D2D1_MATRIX_3X2_F& matTransform)
{
	D2D1_SIZE_F fMapTranslation	= fTrans;
	D2D1_SIZE_F fMapScale		= fScale;
	D2D1_POINT_2F fMapPoint		= fPoint;

	// 1. abs scale
	fMapScale.width = fabs(fMapScale.width);
	fMapScale.height = fabs(fMapScale.height);

	// 2. cal trans
	fMapTranslation.width = ( fViewSize.width - (pDataGlass->fGlassWidth * fMapScale.width) ) / 2.f ;
	fMapTranslation.height = ( fViewSize.height - (pDataGlass->fGlassHeight * fMapScale.height) ) / 2.f ;


	// 3. cal dx, dy
	// 	m_fMapPoint.x -= FLOAT(m_ptMapPoint.x) / m_fMapScale.width;
	// 	m_fMapPoint.y -= FLOAT(m_ptMapPoint.y) / m_fMapScale.height;
	D2D1_MATRIX_3X2_F	matTranslation = D2D1::Matrix3x2F::Translation(fMapTranslation);
	D2D1_MATRIX_3X2_F	matScale = D2D1::Matrix3x2F::Scale(fMapScale, fMapPoint);

	// 4. cal transform matrix
	matTransform = matScale * matTranslation;
}

void CGlassDefectMap::OnPaint()
{
	if (m_pRenderTargetHwnd==nullptr) return;

		CalTransformMatrix();

	m_pRenderTargetHwnd->BeginDraw();
	m_pRenderTargetHwnd->SetTransform(D2D1::Matrix3x2F::Identity());
	m_pRenderTargetHwnd->Clear(D2D1::ColorF(D2D1::ColorF(m_nMapBackColor, 1.0f)));

	if (m_pRenderTargetHwnd->GetAntialiasMode() != D2D1_ANTIALIAS_MODE_PER_PRIMITIVE) 
	{
		m_pRenderTargetHwnd->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
	}


	
	if (m_bDrawGlass) DrawGlassLayer(m_pRenderTargetHwnd, &m_rtRenderTargetHwndRect);

 	if (m_bDrawCell) DrawCellLayer(m_pRenderTargetHwnd, &m_rtRenderTargetHwndRect);

	if (m_bDrawDefect) DrawDefectLayer(m_pRenderTargetHwnd, &m_rtRenderTargetHwndRect);

	ID2D1SolidColorBrush *pPen = NULL;
	HRESULT hr = m_pRenderTargetHwnd->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(MakeColor(0,60,60,60), 1.0f)), &pPen);
	if (hr==S_OK)
	{
		m_pRenderTargetHwnd->DrawRectangle(m_rtRenderTargetHwndRect, pPen, 1.0);
		SafeRelease(pPen);
	}

	m_pRenderTargetHwnd->EndDraw();
}

void CGlassDefectMap::SetDrawData_Glass( const CDrawData_Glass& dataGlass )
{
	m_DrawData_Glass = dataGlass;
}

void CGlassDefectMap::SetMapZoomLevel( float fLevel )
{
	if (m_fMapZoomLevel == fLevel) return;
	m_fMapZoomLevel = fLevel;
	ReleaseAllLayers();
}

void CGlassDefectMap::SetMapCenterPoint( const CPoint& ptPoint )
{
	if (m_ptMapPoint == ptPoint) return;
	m_ptMapPoint = ptPoint;
	ReleaseAllLayers();
}

void CGlassDefectMap::SetParentWnd( CWnd* pParentWnd )
{
	m_pParentWnd = pParentWnd;
}

void CGlassDefectMap::SetMapDefaultValue()
{
	if (m_fMapZoomLevel==1.0f && m_ptMapPoint==CPoint(0,0)) return;
	m_fMapZoomLevel = 1.0f;
	m_ptMapPoint = CPoint(0,0);
	ReleaseAllLayers();
}

void CGlassDefectMap::ReleaseAllLayers()
{
	SafeRelease(m_pLayerGlass);
	SafeRelease(m_pLayerCell);
	SafeRelease(m_pLayerDefect);

	Invalidate(FALSE);
}

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

	InitGlassDefectMap();

	return 0;
}


void CGlassDefectMap::OnLButtonDown(UINT nFlags, CPoint point)
{
	if (m_pParentWnd==NULL) return;

	CRect rect;
	this->GetClientRect(rect);
	if (rect.PtInRect(point))
	{
		m_pParentWnd->SendMessage(WM_LBUTTONDOWN, static_cast<WPARAM>(nFlags), MAKELPARAM(point.x, point.y));
	}

	CWnd::OnLButtonDown(nFlags, point);
}


void CGlassDefectMap::OnLButtonUp(UINT nFlags, CPoint point)
{
	CRect rect;
	this->GetClientRect(rect);
	if (rect.PtInRect(point))
	{
		m_pParentWnd->SendMessage(WM_LBUTTONUP, static_cast<WPARAM>(nFlags), MAKELPARAM(point.x, point.y));
	}

	CWnd::OnLButtonUp(nFlags, point);
}


void CGlassDefectMap::OnMouseMove(UINT nFlags, CPoint point)
{
	CRect rect;
	this->GetClientRect(rect);
	if (rect.PtInRect(point))
	{
		m_pParentWnd->SendMessage(WM_MOUSEMOVE, static_cast<WPARAM>(nFlags), MAKELPARAM(point.x, point.y));
	}

	CWnd::OnMouseMove(nFlags, point);
}

void CGlassDefectMap::SetMapBackColor( UINT nColor )
{
	m_nMapBackColor = nColor;
	Invalidate(FALSE);
}