#include "stdafx.h"
#include "akImageView.h"
#include "akGraph/akGraphUtil.h"

CakImageView::CakImageView()
{
	SetReverseModeY(true);
	{
		CakGraphBase::setAK();
		m_AxisX.m_Size = 80;
		m_AxisX.m_TickGabStep = 1;
		m_AxisX.m_MinorTickNum = 4;
		m_AxisY.m_MinorTickNum = 4;
		//m_AxisX.m_TickGabPixel = 30;
		//m_AxisX.m_FontTick.DeleteObject();
		//m_AxisX.m_FontTick.CreatePointFont(120, _T("Tahoma"));
		//m_AxisX.SetRotateFont(&m_AxisX.m_FontTick, 270);
		m_AxisY.SetRotateFont(&m_AxisY.m_FontTick, 90);
		m_AxisY2.SetRotateFont(&m_AxisY2.m_FontTick, 270);
		SetClossLine(false);
		SetDragStyle(DS_All_HOR);
		m_bGrid = false;

		m_AxisY.m_TickGabPixel = 70;
		m_AxisX.m_Size = 20;
		m_AxisY.m_Size = 20;
		m_AxisY2.m_Size = 20;
		m_Title.m_Size = 20;

		m_AxisX.m_strTitle = "";
		m_AxisY.m_strTitle = "";
		m_Title.m_strTitle = "  ";

		m_MouseMoveInfo.m_nType = 0;
	}
}


CakImageView::~CakImageView()
{
}

void CakImageView::RenderSeries(Graphics* grfx, CDC* pDC)
{
	RenderImage(grfx, pDC);
}

void CakImageView::SetAutoScale()
{
	CakGraphBasic3::SetAutoScale();

	if (1)//±Û¶ó½º Å©±â ¹× ±×¸®±â ¹æÇâ °áÁ¤ ÅÂÇö[2016/3/23]
	{
		double nGlassSizeX = 2400;
		double nGlassSizeY = 2048;

		if (!m_vecImageData.empty())
		{
			nGlassSizeX = m_vecImageData[0]->m_Bits.bmWidth;
			nGlassSizeY = m_vecImageData[0]->m_Bits.bmHeight;
		}

		double dWindowRate = (double)m_rectData.Width() / (double)m_rectData.Height();
		double dValueRate = (double)nGlassSizeX / (double)nGlassSizeY;

		if (dWindowRate < dValueRate)//°¡·ÎÇ® ±âÁØ ÅÂÇö[2016/3/25]
		{
			m_AxisX.m_RangeValueMin = 0;
			m_AxisX.m_RangeValueMax = nGlassSizeX;
			m_AxisY.m_RangeValueMin = 0;
			m_AxisY.m_RangeValueMax = (float)nGlassSizeX*((float)m_rectData.Height() / (float)m_rectData.Width());
			m_AxisY.SetRangePos(nGlassSizeY / 2);
		}
		else //¼¼·ÎÇ®±âÁØ ÅÂÇö[2016/3/25]
		{

			m_AxisX.m_RangeValueMin = 0;
			m_AxisX.m_RangeValueMax = (float)nGlassSizeY*((float)m_rectData.Width() / (float)m_rectData.Height());
			m_AxisY.m_RangeValueMin = 0;
			m_AxisY.m_RangeValueMax = nGlassSizeY;

			m_AxisX.SetRangePos(nGlassSizeX / 2);
		}

		//0,0ÀÌ Áß¾Ó¿¡ ¿Àµµ·Ï [±èÅÂÇö2021/2/16]
		m_AxisX.SetRangePos(0);
		m_AxisY.SetRangePos(0);
	}
}

void CakImageView::SetResize()
{
	double dPosOldX = m_AxisX.m_RangeValueMin + m_AxisX.GetRangeValue() / 2.0;
	double dPosOldY = m_AxisY.m_RangeValueMin + m_AxisY.GetRangeValue() / 2.0;
	CakGraphBasic3::SetAutoScale();

	if (1)//±Û¶ó½º Å©±â ¹× ±×¸®±â ¹æÇâ °áÁ¤ ÅÂÇö[2016/3/23]
	{
		double nGlassSizeX = 2400;
		double nGlassSizeY = 2048;

		if (!m_vecImageData.empty())
		{
			nGlassSizeX = m_vecImageData[0]->m_Bits.bmWidth;
			nGlassSizeY = m_vecImageData[0]->m_Bits.bmHeight;
		}

		double dWindowRate = (double)m_rectData.Width() / (double)m_rectData.Height();
		double dValueRate = (double)nGlassSizeX / (double)nGlassSizeY;

		//double dPosOldX = m_AxisX.m_RangeValueMin + m_AxisX.GetRangeValue() / 2.0;
		//double dPosOldY = m_AxisY.m_RangeValueMin + m_AxisY.GetRangeValue() / 2.0;
		if (dWindowRate < dValueRate)//°¡·ÎÇ® ±âÁØ ÅÂÇö[2016/3/25]
		{
			m_AxisX.m_RangeValueMin = 0;
			m_AxisX.m_RangeValueMax = nGlassSizeX;
			m_AxisY.m_RangeValueMin = 0;
			m_AxisY.m_RangeValueMax = (float)nGlassSizeX*((float)m_rectData.Height() / (float)m_rectData.Width());
			m_AxisY.SetRangePos(nGlassSizeY / 2);


		}
		else //¼¼·ÎÇ®±âÁØ ÅÂÇö[2016/3/25]
		{

			m_AxisX.m_RangeValueMin = 0;
			m_AxisX.m_RangeValueMax = (float)nGlassSizeY*((float)m_rectData.Width() / (float)m_rectData.Height());
			m_AxisY.m_RangeValueMin = 0;
			m_AxisY.m_RangeValueMax = nGlassSizeY;

			m_AxisX.SetRangePos(nGlassSizeX / 2);
		}

		m_AxisX.SetRangePos(dPosOldX);
		m_AxisY.SetRangePos(dPosOldY);
	}
}

void CakImageView::RenderImage(Graphics* grfx, CDC* pDC)
{
	if (m_vecImageData.empty()) return;

	//pDC->SetStretchBltMode(HALFTONE); //<-- ÃÖ´ë È®´ë½Ã ±×¸®´Â ½Ã°£ °ú´Ù ¼Ò¿ä
	pDC->SetStretchBltMode(COLORONCOLOR);// <--ÃÖ´ë È®´ë½Ã À̹ÌÁö Ç¥½Ã ¾ÈµÊ


	CRgn rgn;
	rgn.CreateRectRgnIndirect(CakRectToCRect(m_rectData));
	pDC->SelectClipRgn(&rgn);

	CBitmap* pOldBitmap;
	CDC BitmapDC;
	BitmapDC.CreateCompatibleDC(pDC);

	_DataImage2* pImageData;

	double dAlignX, dAlignY;
	for (int i = 0; i < m_vecImageData.size(); i++)
	{
		dAlignX = dAlignY = 0;

		int x1, x2, y1, y2;
		pImageData = m_vecImageData[i];
		x1 = pImageData->m_nDrawPosX-dAlignX;
		y1 = pImageData->m_nDrawPosY-dAlignY;
		x2 = pImageData->m_nDrawPosX + pImageData->m_Bits.bmWidth;
		y2 = pImageData->m_nDrawPosY + pImageData->m_Bits.bmHeight;


		CakRect rectImage(x1, y1, x2, y2);


		CakRect rectOutRangeTemp, rectOutRange;
		rectOutRangeTemp.left = m_AxisX.m_RangeValueMin;
		rectOutRangeTemp.right = ceil(m_AxisX.m_RangeValueMax);
		rectOutRangeTemp.top = m_AxisY.m_RangeValueMin;
		rectOutRangeTemp.bottom = ceil(m_AxisY.m_RangeValueMax);

		if (rectOutRange.IntersectRect(&rectOutRangeTemp, &rectImage) == FALSE)
		{
			continue;
		}

		pOldBitmap = BitmapDC.SelectObject(&pImageData->m_Bitmap);

		/*< LYW 20211018 - #3684 MOD Start >*/
		m_dOnePixelX =  m_AxisX.GetRangeValue() / (double)m_rectData.Width();
		m_dOnePixelY =  m_AxisY.GetRangeValue() / (double)m_rectData.Height();
		/*< LYW 20211018 - #3684 MOD End >*/
		/*< Origin Code >*/
		//double dOnePixelX = (double)m_rectData.Width() / m_AxisX.GetRangeValue();
		//double dOnePixelY = (double)m_rectData.Height() / m_AxisY.GetRangeValue();

		if (1)//dOnePixelX > 2 && dOnePixelY > 2)
		{
			CakRect rectDraw;
			rectDraw.set(
				GetWindowPosX(rectOutRange.left),
				GetWindowPosY(rectOutRange.top),
				GetWindowPosX(rectOutRange.right),
				GetWindowPosY(rectOutRange.bottom)
			);
			CakRect rectImage;
			rectImage.set(
				rectOutRange.left - x1,
				rectOutRange.top - y1,
				rectOutRange.right - x1,
				rectOutRange.bottom - y1
			);

			if (m_bReverseY == FALSE)
			{
				AKSWAP_INT(rectDraw.top, rectDraw.bottom);
				rectImage.top = pImageData->m_Bits.bmHeight - rectOutRange.bottom + y1;
				rectImage.bottom = rectImage.top + rectOutRange.getHeight();
			}
			if (m_bReverseX == TRUE)
			{
				AKSWAP_INT(rectDraw.left, rectDraw.right);
				rectImage.left = pImageData->m_Bits.bmWidth - rectOutRange.right + x1;
				rectImage.right = rectImage.left + rectOutRange.getWidth();
			}


			pDC->StretchBlt(rectDraw.left, rectDraw.top, rectDraw.Width(), rectDraw.Height(), &BitmapDC,
				rectImage.left, rectImage.top,
				rectImage.getWidth(), rectImage.getHeight(), SRCCOPY);

		}
		else
		{
			//ÁÂÇ¥Ãà ±×´ë·Î ±×¸±¶§ [±èÅÂÇö 2018/12/10]
			/*pDC->StretchBlt(GetWindowPosX(x1), GetWindowPosY(y1), GetWindowPosX(x2)-GetWindowPosX(x1),GetWindowPosY(y2)-GetWindowPosY(y1), &BitmapDC,
				0, 0,
				pImageData->m_Bits.bmWidth, pImageData->m_Bits.bmHeight, SRCCOPY);*/
			pDC->StretchBlt(GetWindowPosX(x1), GetWindowPosY(y1), GetWindowPosX(x2) - GetWindowPosX(x1), GetWindowPosY(y2) - GetWindowPosY(y1), &BitmapDC,
				0, 0,
				pImageData->m_Bits.bmWidth, pImageData->m_Bits.bmHeight, SRCCOPY);
		}


		BitmapDC.SelectObject(pOldBitmap);
		continue;

	}

	BitmapDC.DeleteDC();


	if(m_vecImageData.empty() == FALSE)
	{
		
		pImageData = m_vecImageData[0];
		

		double nGlassSizeX = pImageData->m_Bits.bmWidth;
		double nGlassSizeY = pImageData->m_Bits.bmHeight;


		CBrush BrushGlass, *pOldBrush;
		BrushGlass.CreateSolidBrush(RGB(255, 255, 255));


		CakRectd rectGlass;
		rectGlass.set(0, 0, nGlassSizeX, nGlassSizeY);
		rectGlass.MoveToXY(-nGlassSizeX / 2, -nGlassSizeY / 2);

		//±Û¶ó½º ¿Ü°¢¼± ±×¸®±â ÅÂÇö[2016/3/23]
		{
			pOldBrush = (CBrush*)pDC->SelectObject(&BrushGlass);
			CPen pen;
			pen.CreatePen(PS_SOLID, 1, RGB(64, 191, 79));
			pDC->SelectObject(&pen);

			pDC->MoveTo(GetWindowPosX(rectGlass.left), GetWindowPosY(rectGlass.top));
			pDC->LineTo(GetWindowPosX(rectGlass.right), GetWindowPosY(rectGlass.top));
			pDC->LineTo(GetWindowPosX(rectGlass.right), GetWindowPosY(rectGlass.bottom));
			pDC->LineTo(GetWindowPosX(rectGlass.left), GetWindowPosY(rectGlass.bottom));
			pDC->LineTo(GetWindowPosX(rectGlass.left), GetWindowPosY(rectGlass.top));

			pDC->SelectObject(&pOldBrush);
		}
	}
	pDC->SelectClipRgn(NULL);	

	//DrawROIRect(pDC);
}

void CakImageView::OnMouseInput(akMouseEvent mouseevent, CPoint point)
{
	CakGraphBasic3::OnMouseInput(mouseevent, point);

	switch (mouseevent)
	{
	case MouseMove:
	{
		break;
	}
	case MouseLeftButtonDown:
	{
		if (point.x > -1 && point.x < GetScaleWidth() &&
			point.y > -1 && point.y < GetScaleHeight())
		{
// 			if (m_rectTracker.HitTest(point) < 0)
// 			{
// 				// just to demonstrate CRectTracker::TrackRubberBand
// 				if (m_rectTracker.TrackRubberBand(this, point, TRUE))
// 				{
// 					Invalidate();
// 				}
// 			}
// 			else if (m_rectTracker.Track(this, point, TRUE))
// 			{
// 				Invalidate();
// 			}
		}

		CRect rect;
		this->GetClientRect(rect);
		
		/*< LYW 20211018 - #3684 ADD Start >*/
		CPoint Center;
		Center.x = rect.Width() / 2;
		Center.y = rect.Height() / 2;
		/*< LYW 20211018 - #3684 ADD End >*/

		/*< LYW 20211018 - #3684 MOD Start >*/
		point.x = (point.x - Center.x) * m_dOnePixelX;
		point.y = (point.y - Center.y) * m_dOnePixelY;
		/*< LYW 20211018 - #3684 MOD End >*/
		/*< Origin Code >*/
		GetParent()->PostMessage(UM_FORMMAP_IMAGEMOUSECLICK, static_cast<WPARAM>(0), MAKELPARAM(point.x, point.y));
		/*m_pParentWnd->SendMessage(WM_LBUTTONDOWN, static_cast<WPARAM>(nFlags), MAKELPARAM(point.x, point.y));*/
	}
	break;
	case MouseLeftButtonUp:
	{
		CRect rect;
		this->GetClientRect(rect);

		point.x += m_nHScroll;
		point.y += m_nVScroll;
	/*	m_pParentWnd->SendMessage(WM_LBUTTONUP, static_cast<WPARAM>(nFlags), MAKELPARAM(point.x, point.y));*/

		if (GetTrackerRect(m_rtROIRect))
		{
			m_sROIInfo.nWidthPixel = m_rtROIRect.Width();
			m_sROIInfo.nHeightPixel = m_rtROIRect.Height();
			m_sROIInfo.dDiagonalPixel = sqrt(double(m_sROIInfo.nWidthPixel*m_sROIInfo.nWidthPixel + m_sROIInfo.nHeightPixel*m_sROIInfo.nHeightPixel));

			m_sROIInfo.dWidthRealUM = m_sROIInfo.nWidthPixel * (m_dResolution / m_dWidthScale);
			m_sROIInfo.dHeightRealUM = m_sROIInfo.nHeightPixel * (m_dResolution / m_dHeightScale);
			m_sROIInfo.dDiagonalRealUM = sqrt((m_sROIInfo.dWidthRealUM*m_sROIInfo.dWidthRealUM) + (m_sROIInfo.dHeightRealUM*m_sROIInfo.dHeightRealUM));

			Invalidate(TRUE);
		}
	}
	break;
	}
}

CakDataImage2::CakDataImage2(void)
{
}

CakDataImage2::~CakDataImage2(void)
{
}

int CakDataImage2::SetImageData(char* pFileName, int nImageIndex /*= 0*/)
{
	HBITMAP hBitmap = NULL;
	hBitmap = (HBITMAP)LoadImage(NULL, pFileName, IMAGE_BITMAP, 0, 0,
		LR_LOADFROMFILE | LR_CREATEDIBSECTION | LR_DEFAULTSIZE);

	_DataImage2* pNewImage;

	if (hBitmap)
	{
		pNewImage = new _DataImage2;

		pNewImage->m_Bitmap.Attach(hBitmap);
		pNewImage->m_Bitmap.GetBitmap(&pNewImage->m_Bits);
		pNewImage->m_pBitmapData = (unsigned char*)pNewImage->m_Bits.bmBits;
		pNewImage->m_nDrawPosX = -pNewImage->m_Bits.bmWidth / 2;
		pNewImage->m_nDrawPosY = -pNewImage->m_Bits.bmHeight / 2;
	}
	else
	{
		CImage imgJPG;
		HRESULT ret = imgJPG.Load(pFileName);
		if (ret == S_OK)
		{
			pNewImage = new _DataImage2;
			pNewImage->m_Bitmap.Attach(imgJPG.Detach());
			pNewImage->m_Bitmap.GetBitmap(&pNewImage->m_Bits);
			pNewImage->m_pBitmapData = (unsigned char*)pNewImage->m_Bits.bmBits;
			pNewImage->m_nDrawPosX = -pNewImage->m_Bits.bmWidth / 2;
			pNewImage->m_nDrawPosY = -pNewImage->m_Bits.bmHeight / 2;
		}
		else
		{
			return 0;
		}
	}	
	
	if (m_vecImageData.size() <= nImageIndex)
	{
		m_vecImageData.push_back(pNewImage);
	}
	else
	{
		_DataImage2* pDelImage = m_vecImageData[nImageIndex];
		m_vecImageData[nImageIndex] = pNewImage;
		pDelImage->m_Bitmap.DeleteObject();
		delete pDelImage;
	}
	return 1;
}

int	CakDataImage2::GetScaleWidth()
{
	CRect rect;
	int nWidth;

	//GetClientRect(rect);
	if (nWidth != 0)
		m_dWidthScale = double(rect.Width()) / double(nWidth);
	return int(double(nWidth) * m_dWidthScale + 0.5);
}

int	CakDataImage2::GetScaleHeight()
{
	CRect rect;
	int nHeight;// = GetHeight();

	//GetClientRect(rect);
	if (nHeight != 0)
		m_dHeightScale = double(rect.Height()) / double(nHeight);
	return int(double(nHeight) * m_dHeightScale + 0.5);
}

BOOL CakDataImage2::GetTrackerRect(CRect& rtRect)
{
// 	if (m_rectTracker.m_rect.Width() < 0 || m_rectTracker.m_rect.Height() < 0)
// 	{
// 		return FALSE;
// 	}
// 
// 	rtRect = m_rectTracker.m_rect;

	return TRUE;
}

void CakDataImage2::DrawROIRect(CDC *pDC)
{
	if (m_rtROIRect.Width() == 0 || m_rtROIRect.Height() == 0) return;

	// 	CPen pen, *pOldPen;
	// 	pen.CreatePen(PS_DOT, 1, RGB(255,255,255));
	// 	pOldPen = pDC->SelectObject(&pen);
	// 	pDC->SelectStockObject(NULL_BRUSH);
	// 
	// 	pDC->Rectangle(m_rtROIRect);

	CFont font;
	VERIFY(font.CreateFont(
		15,                        // nHeight
		6,                         // 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);
	pDC->SetTextColor(RGB(255, 255, 0));
	pDC->SetBkColor(RGB(0, 0, 0));
	pDC->SetBkMode(OPAQUE);

	CString strValue = _T("");
	strValue.Format(_T("[Region] %d, %d, %d, %d"), m_rtROIRect.left, m_rtROIRect.top, m_rtROIRect.right, m_rtROIRect.bottom);
	pDC->TextOut(m_rtROIRect.right + 5, m_rtROIRect.top + 5, strValue);

	strValue.Format(_T("[Width] %d pix, %.3lf um"), m_sROIInfo.nWidthPixel, m_sROIInfo.dWidthRealUM);
	pDC->TextOut(m_rtROIRect.right + 5, m_rtROIRect.top + 25, strValue);

	strValue.Format(_T("[Height] %d pix, %.3lf um"), m_sROIInfo.nHeightPixel, m_sROIInfo.dHeightRealUM);
	pDC->TextOut(m_rtROIRect.right + 5, m_rtROIRect.top + 45, strValue);

	strValue.Format(_T("[Diagonal] %.3lf pix, %.3lf um"), m_sROIInfo.dDiagonalPixel, m_sROIInfo.dDiagonalRealUM);
	pDC->TextOut(m_rtROIRect.right + 5, m_rtROIRect.top + 65, strValue);

	strValue.Format(_T("[Resol_X] %.6lf um/pixel"), (m_dResolution / m_dWidthScale));
	pDC->TextOut(m_rtROIRect.right + 5, m_rtROIRect.top + 85, strValue);

	strValue.Format(_T("[Resol_Y] %.6lf um/pixel"), (m_dResolution / m_dHeightScale));
	pDC->TextOut(m_rtROIRect.right + 5, m_rtROIRect.top + 105, strValue);

	pDC->SelectObject(def_font);

}