// ImageViewer.cpp : ʵÏÖÎļþ¡£
|
//
|
#include "stdafx.h"
|
#include "ImageViewer.h"
|
|
IMPLEMENT_DYNAMIC(CImageViewer, CWnd)
|
|
CImageViewer::CImageViewer(CWnd* 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)
|
{
|
}
|
|
m_pWICBitmap = nullptr;
|
m_pWICFormatConverter = nullptr;
|
m_pD2DRenderTarget = nullptr;
|
m_pD2DBitmap = nullptr;
|
|
m_nWicBitmapWidthStep = 0;
|
m_nWicBitmapHeight = 0;
|
m_nWicBitmapChannels = 0;
|
m_rtViewRect = CRect(0,0,0,0);
|
m_rtOrgViewRect = CRect(0,0,0,0);
|
|
m_pParentWnd = pParentWnd;
|
m_strViewName = _T("");
|
|
// scroll pos
|
m_nVScroll = 0;
|
m_nHScroll = 0;
|
|
// max scroll pos
|
m_nMaxVScroll = 0;
|
m_nMaxHScroll = 0;
|
|
// image draw
|
m_nViewType = ViewScale_Fit;
|
m_nScaleWidth = 0;
|
m_nScaleHeight = 0;
|
m_dWidthScale = 1.0;
|
m_dHeightScale = 1.0;
|
|
// draw view name
|
m_bDrawViewName = FALSE;
|
m_strViewName = _T("");
|
|
// draw roi
|
m_bDrawRoi = FALSE;
|
m_rtRoiRect.Reset();
|
|
// draw object
|
m_bDrawObject = FALSE;
|
m_listDrawObject.clear();
|
|
// d2d1 cs
|
m_pD2DCriticalSection = new CCriticalSection();
|
|
}
|
|
CImageViewer::~CImageViewer()
|
{
|
SafeDelete(m_pD2DCriticalSection);
|
|
SafeRelease(m_pD2DBitmap);
|
SafeRelease(m_pWICBitmap);
|
SafeRelease(m_pWICFormatConverter);
|
SafeRelease(m_pD2DRenderTarget);
|
SafeRelease(m_pD2DFactory);
|
SafeRelease(m_pWICFactory);
|
|
m_listDrawObject.clear();
|
|
CoUninitialize();
|
}
|
|
|
BEGIN_MESSAGE_MAP(CImageViewer, CWnd)
|
ON_WM_PAINT()
|
ON_WM_HSCROLL()
|
ON_WM_VSCROLL()
|
ON_WM_CREATE()
|
ON_WM_SIZE()
|
ON_WM_CREATE()
|
END_MESSAGE_MAP()
|
|
|
// CImageViewer ÏûÏ¢´¦ÀíÆ÷¡£
|
BOOL CImageViewer::CreateRenderTarget(const CRect& rtRect)
|
{
|
CSingleLock myLock(m_pD2DCriticalSection);
|
myLock.Lock();
|
|
BOOL bSame = (rtRect == m_rtViewRect);
|
if (bSame && (m_pD2DRenderTarget!=nullptr)) return TRUE;
|
|
m_rtViewRect = rtRect;
|
|
// create hwnd render target
|
SafeRelease(m_pD2DRenderTarget);
|
HRESULT hr = m_pD2DFactory->CreateHwndRenderTarget(
|
D2D1::RenderTargetProperties(),
|
D2D1::HwndRenderTargetProperties(this->GetSafeHwnd(), D2D1::SizeU(m_rtViewRect.Width(), m_rtViewRect.Height())),
|
&m_pD2DRenderTarget);
|
|
if (hr!=S_OK)
|
{
|
return FALSE;
|
}
|
|
auto rtSize = m_pD2DRenderTarget->GetSize();
|
m_rtRenderRect = D2D1::RectF(0.0f, 0.0f, rtSize.width, rtSize.height);
|
|
return TRUE;
|
}
|
|
int CImageViewer::CreateWicBitmap(int nWidthStep, int nHeight, int nChannels, BYTE* pBuffer)
|
{
|
CSingleLock myLock(m_pD2DCriticalSection);
|
myLock.Lock();
|
|
if (m_nWicBitmapWidthStep==nWidthStep && m_nWicBitmapHeight==nHeight && m_nWicBitmapChannels==nChannels && m_pWICBitmap!=nullptr) return 1;
|
|
m_nWicBitmapWidthStep = nWidthStep;
|
m_nWicBitmapHeight = nHeight;
|
m_nWicBitmapChannels = nChannels;
|
|
GUID pixelFormat = GUID_WICPixelFormat32bppBGRA;
|
switch(nChannels)
|
{
|
case 1:
|
pixelFormat = GUID_WICPixelFormat8bppGray;
|
break;
|
|
case 3:
|
pixelFormat = GUID_WICPixelFormat24bppBGR;
|
break;
|
|
case 4:
|
pixelFormat = GUID_WICPixelFormat32bppBGRA;
|
break;
|
}
|
|
// create wic bitmap
|
SafeRelease(m_pWICBitmap);
|
HRESULT hr = m_pWICFactory->CreateBitmapFromMemory(
|
m_nWicBitmapWidthStep/m_nWicBitmapChannels,
|
m_nWicBitmapHeight,
|
pixelFormat,
|
m_nWicBitmapWidthStep,
|
m_nWicBitmapWidthStep*m_nWicBitmapHeight,
|
pBuffer,
|
&m_pWICBitmap);
|
|
if (hr!=S_OK)
|
{
|
return 0;
|
}
|
|
|
// create format converter
|
SafeRelease(m_pWICFormatConverter);
|
hr = m_pWICFactory->CreateFormatConverter(&m_pWICFormatConverter);
|
if (hr!=S_OK)
|
{
|
return 0;
|
}
|
|
// initialize format converter
|
hr = m_pWICFormatConverter->Initialize(
|
m_pWICBitmap, // Input source to convert
|
GUID_WICPixelFormat32bppPBGRA, // Destination pixel format
|
WICBitmapDitherTypeNone, // Specified dither pattern
|
NULL, // Specify a particular palette
|
0.f, // Alpha threshold
|
WICBitmapPaletteTypeCustom // Palette translation type
|
);
|
|
if (hr!=S_OK)
|
{
|
return 0;
|
}
|
|
return 2;
|
}
|
|
void CImageViewer::CalculateRect()
|
{
|
switch(m_nViewType)
|
{
|
case ViewScale_Fit:
|
{
|
m_rtDestRect = m_rtRenderRect;
|
m_rtSourceRect = D2D1::RectF(0.0f, 0.0f, (float)GetWidth(), (float)GetHeight());
|
}
|
break;
|
|
case ViewScale_Origin:
|
{
|
int nImageWidth = cv::min(GetWidth(), (int)m_rtRenderRect.right);
|
int nImageHeight = cv::min(GetHeight(), (int)m_rtRenderRect.bottom);
|
m_rtDestRect = D2D1::RectF(0.0f, 0.0f, (float)nImageWidth, (float)nImageHeight);
|
m_rtSourceRect = D2D1::RectF((float)m_nHScroll, (float)m_nVScroll, float(m_nHScroll+nImageWidth), float(m_nVScroll+nImageHeight));
|
}
|
break;
|
|
case ViewScale_Zoom:
|
{
|
int nSrcWidth = GetWidth();
|
int nSrcHeight = GetHeight();
|
int nScaleWidth = int(double(nSrcWidth) * m_dWidthScale + 0.5);
|
int nScaleHeight = int(double(nSrcHeight) * m_dHeightScale + 0.5);
|
if (m_nScaleWidth!=nScaleWidth || m_nScaleHeight!=nScaleHeight) SetViewType(m_nViewType);
|
|
int nImageWidth = cv::min(nScaleWidth, (int)m_rtRenderRect.right);
|
int nImageHeight = cv::min(nScaleHeight, (int)m_rtRenderRect.bottom);
|
m_rtDestRect = D2D1::RectF(0.0f, 0.0f, (float)nImageWidth, (float)nImageHeight);
|
|
if (m_rtViewRect.Width() < nScaleWidth)
|
{
|
m_rtSourceRect.left = FLOAT(int(double(m_nHScroll) / m_dWidthScale));
|
m_rtSourceRect.right = FLOAT(m_rtSourceRect.left + int(double(m_rtOrgViewRect.Width()) / m_dWidthScale));
|
}
|
else
|
{
|
m_rtSourceRect.left = 0.f;
|
m_rtSourceRect.right = FLOAT(nSrcWidth);
|
}
|
|
if (m_rtViewRect.Height() < nScaleHeight)
|
{
|
m_rtSourceRect.top = FLOAT(int(double(m_nVScroll) / m_dHeightScale));
|
m_rtSourceRect.bottom = FLOAT(m_rtSourceRect.top + int(double(m_rtOrgViewRect.Height()) / m_dHeightScale));
|
}
|
else
|
{
|
m_rtSourceRect.top = 0;
|
m_rtSourceRect.bottom = FLOAT(nSrcHeight);
|
}
|
}
|
break;
|
}
|
|
}
|
|
void CImageViewer::OnPaint()
|
{
|
CPaintDC dc(this); // device context for painting
|
|
CRect rect;
|
GetClientRect(rect);
|
|
// create render target
|
if (CreateRenderTarget(rect)==FALSE)
|
{
|
return;
|
}
|
|
// image exist?
|
if (GetImageExist()==FALSE)
|
{
|
m_pD2DRenderTarget->BeginDraw();
|
m_pD2DRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::Gray));
|
m_pD2DRenderTarget->EndDraw();
|
return;
|
}
|
|
// create wic bitmap
|
int nCode = CreateWicBitmap(GetWidthStep(), GetHeight(), GetChannels(), (BYTE*)GetImageBuffer());
|
if (nCode==0)
|
{
|
return;
|
}
|
|
// create d2d bitmap
|
if (nCode==2 && m_pWICFormatConverter && m_pD2DRenderTarget)
|
{
|
SafeRelease(m_pD2DBitmap);
|
HRESULT hr = m_pD2DRenderTarget->CreateBitmapFromWicBitmap(m_pWICFormatConverter, 0, &m_pD2DBitmap);
|
if (hr!=S_OK)
|
{
|
return;
|
}
|
}
|
|
// draw
|
if (m_pD2DRenderTarget && m_pD2DBitmap)
|
{
|
// cal rect
|
CalculateRect();
|
|
m_pD2DRenderTarget->BeginDraw();
|
m_pD2DRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::Gray));
|
|
// set anti alias mode
|
if (m_pD2DRenderTarget->GetAntialiasMode() == D2D1_ANTIALIAS_MODE_ALIASED)
|
{
|
m_pD2DRenderTarget->SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
|
}
|
|
// draw image
|
m_pD2DRenderTarget->DrawBitmap(m_pD2DBitmap, m_rtDestRect, 1.0f, D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, m_rtSourceRect);
|
|
// draw view name
|
if (m_bDrawViewName) DrawViewName();
|
|
// draw object
|
if (m_bDrawObject) DrawObject();
|
|
// draw roi
|
if (m_bDrawRoi) DrawRoi();
|
|
m_pD2DRenderTarget->EndDraw();
|
}
|
|
return;
|
}
|
|
void CImageViewer::DrawObject()
|
{
|
if (m_pD2DRenderTarget==NULL) return;
|
|
for (ListDrawObjectIt it=m_listDrawObject.begin(); it!=m_listDrawObject.end(); it++)
|
{
|
DrawObject(*it);
|
}
|
}
|
|
void CImageViewer::DrawViewName()
|
{
|
|
}
|
|
void CImageViewer::DrawRoi()
|
{
|
D2D1_RECT_F rect = D2D1::RectF( FLOAT(m_rtRoiRect.Left()), FLOAT(m_rtRoiRect.Top()), FLOAT(m_rtRoiRect.Right()), FLOAT(m_rtRoiRect.Bottom()) );
|
if (IntersectsWith(m_rtSourceRect, rect)==FALSE) return;
|
|
float fPenSize = FLOAT(m_rtRoiRect.dPenSize * m_dWidthScale);
|
|
D2D1_RECT_F target;
|
target.left = FLOAT(int(m_rtRoiRect.Left() * m_dWidthScale + 0.5) - m_nHScroll);
|
target.top = FLOAT(int(m_rtRoiRect.Top() * m_dHeightScale + 0.5) - m_nVScroll);
|
target.right = FLOAT(int(m_rtRoiRect.Right() * m_dWidthScale + 0.5) - m_nHScroll);
|
target.bottom = FLOAT(int(m_rtRoiRect.Bottom() * m_dHeightScale + 0.5) - m_nVScroll);
|
|
ID2D1SolidColorBrush *pPen = NULL;
|
HRESULT hr = m_pD2DRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(m_rtRoiRect.nPenColor, FLOAT(m_rtRoiRect.dPenOpacity))),&pPen);
|
|
ID2D1SolidColorBrush *pBrush = NULL;
|
hr = m_pD2DRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(m_rtRoiRect.nBrushColor, FLOAT(m_rtRoiRect.dBrushOpacity))),&pBrush);
|
|
m_pD2DRenderTarget->FillRectangle(target, pBrush);
|
m_pD2DRenderTarget->DrawRectangle(target, pPen, fPenSize);
|
|
SafeRelease(pPen);
|
SafeRelease(pBrush);
|
}
|
|
void CImageViewer::DrawObject(const SDrawObject& object)
|
{
|
D2D1_RECT_F rect = D2D1::RectF( FLOAT(object.Left()), FLOAT(object.Top()), FLOAT(object.Right()), FLOAT(object.Bottom()) );
|
if (IntersectsWith(m_rtSourceRect, rect)==FALSE) return;
|
|
//float fPenSize = FLOAT(object.dPenSize * m_dWidthScale);
|
float fPenSize = FLOAT(object.dPenSize);
|
|
D2D1_RECT_F target;
|
target.left = FLOAT(int(object.Left() * m_dWidthScale + 0.5) - m_nHScroll);
|
target.top = FLOAT(int(object.Top() * m_dHeightScale + 0.5) - m_nVScroll);
|
target.right = FLOAT(int(object.Right() * m_dWidthScale + 0.5) - m_nHScroll);
|
target.bottom = FLOAT(int(object.Bottom() * m_dHeightScale + 0.5) - m_nVScroll);
|
|
float fScaleWidth = FLOAT(GetScaleWidth());
|
float fScaleHeight = FLOAT(GetScaleHeight());
|
|
if (target.left > fScaleWidth) target.left = fScaleWidth;
|
if (target.top > fScaleHeight) target.top = fScaleHeight;
|
if (target.right > fScaleWidth) target.right = fScaleWidth;
|
if (target.bottom > fScaleHeight) target.bottom = fScaleHeight;
|
|
ID2D1SolidColorBrush *pPen = NULL;
|
HRESULT hr = m_pD2DRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(object.nPenColor, FLOAT(object.dPenOpacity))),&pPen);
|
|
ID2D1SolidColorBrush *pBrush = NULL;
|
hr = m_pD2DRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF(object.nBrushColor, FLOAT(object.dBrushOpacity))),&pBrush);
|
|
switch(object.nType)
|
{
|
case DrawObject_Line:
|
{
|
m_pD2DRenderTarget->DrawLine(D2D1::Point2F(target.left, target.top), D2D1::Point2F(target.right, target.bottom), pPen, fPenSize);
|
}
|
break;
|
|
case DrawObject_Rectangle:
|
{
|
m_pD2DRenderTarget->FillRectangle(target, pBrush);
|
m_pD2DRenderTarget->DrawRectangle(target, pPen, fPenSize);
|
}
|
break;
|
|
case DrawObject_Ellipse:
|
{
|
D2D1_ELLIPSE ellipse;
|
ellipse.radiusX = (target.right - target.left) / 2.0f;
|
ellipse.radiusY = (target.bottom - target.top) / 2.0f;
|
ellipse.point = D2D1::Point2F(FLOAT(target.left+ellipse.radiusX), FLOAT(target.top+ellipse.radiusY));
|
m_pD2DRenderTarget->FillEllipse(ellipse, pBrush);
|
m_pD2DRenderTarget->DrawEllipse(ellipse, pPen, fPenSize);
|
}
|
break;
|
|
case DrawObject_Polygon:
|
{
|
ID2D1PathGeometry* pPathGeometry = nullptr;
|
m_pD2DFactory->CreatePathGeometry(&pPathGeometry);
|
|
if (pPathGeometry)
|
{
|
ID2D1GeometrySink* pGeometrySink = nullptr;
|
pPathGeometry->Open(&pGeometrySink);
|
if (pGeometrySink)
|
{
|
D2D1_POINT_2F fb;
|
fb.x = FLOAT(object.vecPolygon[0].dPosX*m_dWidthScale) + target.left;
|
fb.y = FLOAT(object.vecPolygon[0].dPosY*m_dHeightScale) + target.top;
|
|
// Use D2D1_FIGURE_BEGIN_FILLED for filled
|
D2D1_FIGURE_BEGIN fg = D2D1_FIGURE_BEGIN_FILLED;
|
D2D1_FIGURE_END fe = D2D1_FIGURE_END_CLOSED;
|
|
pGeometrySink->BeginFigure(fb, fg);
|
|
int nCount = (int)object.vecPolygon.size();
|
for (int nIdx=1; nIdx<nCount; nIdx++)
|
{
|
D2D1_POINT_2F fu;
|
fu.x = FLOAT(object.vecPolygon[nIdx].dPosX*m_dWidthScale) + target.left;
|
fu.y = FLOAT(object.vecPolygon[nIdx].dPosY*m_dHeightScale) + target.top;
|
pGeometrySink->AddLine(fu);
|
}
|
|
pGeometrySink->EndFigure(fe);
|
|
pGeometrySink->Close();
|
|
SafeRelease(pGeometrySink);
|
}
|
|
m_pD2DRenderTarget->FillGeometry(pPathGeometry, pBrush);
|
m_pD2DRenderTarget->DrawGeometry(pPathGeometry, pPen, fPenSize);
|
SafeRelease(pPathGeometry);
|
}
|
}
|
break;
|
}
|
|
SafeRelease(pPen);
|
SafeRelease(pBrush);
|
}
|
|
BOOL CImageViewer::LoadImage(const CString& strFilename)
|
{
|
if (CImageBuffer::LoadImage(strFilename)==FALSE)
|
{
|
return FALSE;
|
}
|
|
m_nWicBitmapWidthStep = 0;
|
m_nWicBitmapHeight = 0;
|
m_nWicBitmapChannels = 0;
|
|
SetViewType(m_nViewType);
|
|
m_rtRoiRect.dPosX = GetWidth() / 4;
|
m_rtRoiRect.dPosY = GetHeight() / 4;
|
m_rtRoiRect.dSizeX = m_rtRoiRect.dPosX * 2.0;
|
m_rtRoiRect.dSizeY = m_rtRoiRect.dPosY * 2.0;
|
m_rtRoiRect.dPenOpacity = 1.0;
|
m_rtRoiRect.dPenSize = 2;
|
m_rtRoiRect.dBrushOpacity = 0.0;
|
|
return TRUE;
|
}
|
|
void CImageViewer::SetViewType(int nType)
|
{
|
m_nViewType = nType;
|
|
m_nScaleWidth = GetScaleWidth();
|
m_nScaleHeight = GetScaleHeight();
|
|
switch(m_nViewType)
|
{
|
case ViewScale_Origin:
|
if (m_rtOrgViewRect.Width() >= m_nScaleWidth)
|
{
|
m_nMaxHScroll = 0;
|
}
|
else
|
{
|
m_nMaxHScroll = m_nScaleWidth - (m_rtOrgViewRect.Width()+17);
|
if (m_nMaxHScroll < 0)
|
{
|
m_nMaxHScroll = 0;
|
}
|
else
|
{
|
m_nMaxHScroll += 17;
|
}
|
}
|
|
if (m_rtOrgViewRect.Height() >= m_nScaleHeight)
|
{
|
m_nMaxVScroll = 0;
|
}
|
else
|
{
|
m_nMaxVScroll = m_nScaleHeight - (m_rtOrgViewRect.Height()+17);
|
if (m_nMaxVScroll < 0)
|
{
|
m_nMaxVScroll = 0;
|
}
|
else
|
{
|
m_nMaxVScroll += 17;
|
}
|
|
}
|
break;
|
|
case ViewScale_Zoom:
|
m_nMaxHScroll = m_nScaleWidth - (m_rtOrgViewRect.Width()+17);
|
m_nMaxVScroll = m_nScaleHeight - (m_rtOrgViewRect.Height()+17);
|
|
if (m_nMaxVScroll < 0)
|
{
|
m_nMaxVScroll = 0;
|
}
|
else
|
{
|
m_nMaxVScroll += 17;
|
}
|
|
if (m_nMaxHScroll < 0)
|
{
|
m_nMaxHScroll = 0;
|
}
|
else
|
{
|
m_nMaxHScroll += 17;
|
}
|
break;
|
|
case ViewScale_Fit:
|
m_nMaxHScroll = m_nMaxVScroll = 0;
|
break;
|
}
|
|
m_nHScroll = m_nVScroll = 0;
|
|
SetScrollRange(SB_HORZ, 0, m_nMaxHScroll);
|
SetScrollRange(SB_VERT, 0, m_nMaxVScroll);
|
SetScrollPos(SB_HORZ, m_nHScroll);
|
SetScrollPos(SB_VERT, m_nVScroll);
|
|
// update view rect
|
GetClientRect(m_rtViewRect);
|
|
return;
|
}
|
|
int CImageViewer::GetScaleWidth()
|
{
|
CRect rect;
|
int nWidth = GetWidth();
|
|
switch(m_nViewType)
|
{
|
case ViewScale_Origin:
|
m_dWidthScale = 1.0;
|
return nWidth;
|
|
case ViewScale_Zoom:
|
return int(double(nWidth) * m_dWidthScale + 0.5);
|
|
case ViewScale_Fit:
|
if (nWidth!=0)
|
m_dWidthScale = double(m_rtOrgViewRect.Width()) / double(nWidth);
|
return int(double(nWidth) * m_dWidthScale + 0.5);
|
}
|
|
return 0;
|
}
|
|
int CImageViewer::GetScaleHeight()
|
{
|
CRect rect;
|
int nHeight = GetHeight();
|
|
switch(m_nViewType)
|
{
|
case ViewScale_Origin:
|
m_dHeightScale = 1.0;
|
return nHeight;
|
|
case ViewScale_Zoom:
|
return int(double(nHeight) * m_dHeightScale + 0.5);
|
|
case ViewScale_Fit:
|
if (nHeight!=0)
|
m_dHeightScale = double(m_rtOrgViewRect.Height()) / double(nHeight);
|
return int(double(nHeight) * m_dHeightScale + 0.5);
|
}
|
|
return 0;
|
}
|
|
void CImageViewer::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
{
|
switch (nSBCode)
|
{
|
case SB_LEFT: // Scroll to far left.
|
break;
|
case SB_RIGHT: // Scroll to far right.
|
break;
|
case SB_ENDSCROLL: // End scroll.
|
break;
|
case SB_LINELEFT: // Scroll left.
|
if (m_nHScroll > 0)
|
m_nHScroll -= 10; //m_nHScroll--;
|
break;
|
case SB_LINERIGHT: // Scroll right.
|
if (m_nHScroll < m_nMaxHScroll)
|
m_nHScroll += 10; //m_nHScroll++;
|
break;
|
case SB_PAGELEFT: // Scroll one page left.
|
if (5 < m_nMaxHScroll / 256)
|
m_nHScroll -= 40;//m_nHScroll -= 5;
|
else
|
m_nHScroll -= 20;//m_nHScroll -= m_nMaxHScroll / 256;
|
|
if (m_nHScroll < 0)
|
m_nHScroll = 0;
|
break;
|
case SB_PAGERIGHT: // Scroll one page right.
|
if (5 < m_nMaxHScroll / 256)
|
m_nHScroll += 40;//m_nHScroll += 5;
|
else
|
m_nHScroll += 20;//m_nHScroll += m_nMaxHScroll / 256;
|
|
if (m_nHScroll > m_nMaxHScroll)
|
m_nHScroll = m_nMaxHScroll;
|
break;
|
case SB_THUMBPOSITION: // Scroll to absolute position. nPos is the position
|
break;
|
case SB_THUMBTRACK: // Drag scroll box to specified position. nPos is the
|
m_nHScroll = nPos;
|
TRACE(_T("Horz SB_THUMBTRACK : %d\n"), nPos);
|
break;
|
}
|
|
// Set the new position of the thumb (scroll box).
|
SetScrollPos(SB_HORZ, m_nHScroll);
|
|
Invalidate(FALSE);
|
|
__super::OnHScroll(nSBCode, nPos, pScrollBar);
|
}
|
|
|
void CImageViewer::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
{
|
switch (nSBCode)
|
{
|
case SB_BOTTOM: // Scroll to bottom.
|
break;
|
case SB_ENDSCROLL: // End scroll.
|
break;
|
case SB_LINEDOWN: // Scroll one line down.
|
if (m_nVScroll < m_nMaxVScroll)
|
m_nVScroll += 10; //m_nVScroll++;
|
break;
|
case SB_LINEUP: // Scroll one line up.
|
if (m_nVScroll > 0)
|
m_nVScroll -= 10; //m_nVScroll--;
|
break;
|
case SB_PAGEDOWN: // Scroll one page down.
|
if (5 < m_nMaxVScroll / 256)
|
m_nVScroll += 40;//m_nVScroll += 5;
|
else
|
m_nVScroll += 20;//m_nVScroll += (m_nMaxVScroll / 256);
|
|
if (m_nVScroll > m_nMaxVScroll)
|
m_nVScroll = m_nMaxVScroll;
|
break;
|
case SB_PAGEUP: // Scroll one page up.
|
if (5 < m_nMaxVScroll / 256)
|
m_nVScroll -= 40;//m_nVScroll -= 5;
|
else
|
m_nVScroll -= 20;//m_nVScroll -= (m_nMaxVScroll / 256);
|
|
if (m_nVScroll < 0)
|
m_nVScroll = 0;
|
break;
|
case SB_THUMBPOSITION: // Scroll to the absolute position. The current position is provided in nPos.
|
break;
|
case SB_THUMBTRACK: // Drag scroll box to specified position. The current position is provided in nPos.
|
m_nVScroll = nPos;
|
TRACE(_T("Vert SB_THUMBTRACK : %d\n"), nPos);
|
break;
|
case SB_TOP: // Scroll to top.
|
break;
|
}
|
|
// Set the new position of the thumb (scroll box).
|
SetScrollPos(SB_VERT, m_nVScroll);
|
|
Invalidate(FALSE);
|
|
__super::OnVScroll(nSBCode, nPos, pScrollBar);
|
}
|
|
void CImageViewer::SetDrawObject( BOOL bDraw )
|
{
|
m_bDrawObject = bDraw;
|
}
|
|
void CImageViewer::SetDrawRoi( BOOL bDraw )
|
{
|
m_bDrawRoi = bDraw;
|
}
|
|
void CImageViewer::SetWidthScale( double dScale )
|
{
|
m_dWidthScale = dScale;
|
}
|
|
void CImageViewer::SetHeightScale( double dScale )
|
{
|
m_dHeightScale = dScale;
|
}
|
|
void CImageViewer::SetScale( double dScale )
|
{
|
m_dWidthScale = m_dHeightScale = dScale;
|
}
|
|
int CImageViewer::GetViewType() const
|
{
|
return m_nViewType;
|
}
|
|
BOOL CImageViewer::GetDrawObject() const
|
{
|
return m_bDrawObject;
|
}
|
|
BOOL CImageViewer::GetDrawRoi() const
|
{
|
return m_bDrawRoi;
|
}
|
|
double CImageViewer::GetWidthScale( void ) const
|
{
|
return m_dWidthScale;
|
}
|
|
double CImageViewer::GetHeightScale( void ) const
|
{
|
return m_dHeightScale;
|
}
|
|
double CImageViewer::GetScale() const
|
{
|
return (m_dWidthScale+m_dHeightScale) / 2.0;
|
}
|
|
int CImageViewer::GetHScrollPos( void ) const
|
{
|
return m_nHScroll;
|
}
|
|
int CImageViewer::GetVScrollPos( void ) const
|
{
|
return m_nVScroll;
|
}
|
|
void CImageViewer::AddDrawObject( const SDrawObject& drawObject )
|
{
|
m_listDrawObject.push_back(drawObject);
|
}
|
|
void CImageViewer::DeleteAllDrawObject( void )
|
{
|
m_listDrawObject.clear();
|
}
|
|
void CImageViewer::ClearScreen()
|
{
|
CPaintDC dc(this); // device context for painting
|
|
m_pD2DRenderTarget->BeginDraw();
|
m_pD2DRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::Gray));
|
m_pD2DRenderTarget->EndDraw();
|
return;
|
}
|
|
void CImageViewer::OnSize(UINT nType, int cx, int cy)
|
{
|
__super::OnSize(nType, cx, cy);
|
|
|
|
return;
|
}
|
|
|
int CImageViewer::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
{
|
if (__super::OnCreate(lpCreateStruct) == -1)
|
return -1;
|
|
GetClientRect(m_rtOrgViewRect);
|
|
return 0;
|
}
|
|
void CImageViewer::SetDrawViewName( BOOL bDraw )
|
{
|
m_bDrawViewName = bDraw;
|
}
|
|
BOOL CImageViewer::GetDrawViewName() const
|
{
|
return m_bDrawViewName;
|
}
|
|
void CImageViewer::SetViewName( const CString& strValue )
|
{
|
m_strViewName = strValue;
|
}
|
|
void CImageViewer::SetRoiRect( const CRect& rtRect )
|
{
|
m_rtRoiRect.dPosX = rtRect.left;
|
m_rtRoiRect.dPosY = rtRect.top;
|
m_rtRoiRect.dSizeX = rtRect.Width();
|
m_rtRoiRect.dSizeY = rtRect.Height();
|
}
|
|
CString CImageViewer::GetViewName() const
|
{
|
return m_strViewName;
|
}
|
|
CRect CImageViewer::GetRoiRect() const
|
{
|
CRect rect;
|
rect.left = (int) (m_rtRoiRect.dPosX + 0.5);
|
rect.top = (int) (m_rtRoiRect.dPosY + 0.5);
|
rect.right = rect.left + (int) (m_rtRoiRect.dSizeX + 0.5);
|
rect.bottom = rect.top + (int) (m_rtRoiRect.dSizeY + 0.5);
|
return rect;
|
}
|
