#include "stdafx.h"
|
#include "EdgeImageViewer.h"
|
|
// CEdgeImageViewer
|
IMPLEMENT_DYNAMIC(CEdgeImageViewer, CStatic)
|
|
CEdgeImageViewer::CEdgeImageViewer()
|
{
|
m_rtWnd = CRect(-1,-1,-1,-1);
|
m_pBmInfo = NULL;
|
m_pBuffer = NULL;
|
m_nFrameWidth = 0;
|
m_nFrameHeight = 0;
|
m_nFrameCount = 0;
|
m_nTotalHeight = 0;
|
m_dPixelSizeX = 1.0;
|
m_dPixelSizeY = 1.0;
|
|
m_dZoom = 1.0;
|
m_ptDisplayStart_pxl = CPoint(0,0);
|
m_ptMousePos_Wnd = CPoint(0,0);
|
m_ptMousePos_Pxl = CPoint(0,0);
|
|
m_MenuStatus.set(MODE_VIEW_INSPECT_AREA);
|
m_MenuStatus.set(MODE_VIEW_NOTCH_AREA);
|
m_MenuStatus.set(MODE_VIEW_NOTCH_MEASURE);
|
m_MenuStatus.set(MODE_VIEW_INSPECT_SIDE_DIMENSION);
|
m_MenuStatus.set(MODE_VIEW_CORNER_AREA);
|
m_MenuStatus.set(MODE_VIEW_MARK_AREA);
|
m_MenuStatus.set(MODE_VIEW_USER_DEFECT_AREA);
|
m_MenuStatus.set(MODE_VIEW_EXCEPTION_AREA);
|
m_MenuStatus.set(MODE_VIEW_START_END_LINE);
|
m_MenuStatus.set(MODE_VIEW_DEFECT);
|
m_MenuStatus.set(MODE_VIEW_MEASURE);
|
m_MenuStatus.reset(MODE_VIEW_FRAME_IDX);
|
|
m_nSideIdx = 0;
|
m_pGlassData = NULL;
|
m_pHardware = NULL;
|
m_pRecipe = NULL;
|
|
#if HALCON_VISION_KEY
|
m_isMouseDown = FALSE;
|
m_ptMouseDown.x = 0;
|
m_ptMouseDown.y = 0;
|
#endif // HALCON_VISION_KEY
|
}
|
|
CEdgeImageViewer::~CEdgeImageViewer()
|
{
|
DeleteBitMap();
|
}
|
|
BEGIN_MESSAGE_MAP(CEdgeImageViewer, CStatic)
|
ON_WM_PAINT()
|
ON_WM_DESTROY()
|
ON_WM_CREATE()
|
ON_WM_MOUSEMOVE()
|
ON_WM_RBUTTONUP()
|
ON_WM_LBUTTONDOWN()
|
ON_WM_LBUTTONDOWN()
|
// ON_WM_LBUTTONUP()
|
// ON_WM_MOUSEACTIVATE()
|
ON_COMMAND(ID_MODE_USER_SELECT , &CEdgeImageViewer::OnUserSelect)
|
ON_COMMAND(ID_MODE_VIEW_INSPECT_ALL , &CEdgeImageViewer::OnViewInspetAll)
|
ON_COMMAND(ID_MODE_VIEW_INSPECT_AREA , &CEdgeImageViewer::OnViewInspectArea)
|
ON_COMMAND(ID_MODE_VIEW_NOTCH_AREA , &CEdgeImageViewer::OnViewInspectNotchArea)
|
ON_COMMAND(ID_MODE_VIEW_NOTCH_MEASURE , &CEdgeImageViewer::OnViewInspectNotchMeasure)
|
ON_COMMAND(ID_MODE_VIEW_INSPECT_SIDE_DIMENSION , &CEdgeImageViewer::OnViewInspectSideDimension)
|
ON_COMMAND(ID_MODE_VIEW_CORNER_AREA , &CEdgeImageViewer::OnViewCornerArea)
|
ON_COMMAND(ID_MODE_VIEW_MARK_AREA , &CEdgeImageViewer::OnViewMarkArea)
|
ON_COMMAND(ID_MODE_VIEW_USER_DEFECT_AREA , &CEdgeImageViewer::OnViewUserDefectArea)
|
ON_COMMAND(ID_MODE_VIEW_EXCEPTION_AREA , &CEdgeImageViewer::OnViewExceptionArea)
|
ON_COMMAND(ID_MODE_VIEW_START_END_LINE , &CEdgeImageViewer::OnViewStartEndLine)
|
ON_COMMAND(ID_MODE_VIEW_DEFECT_ALL , &CEdgeImageViewer::OnViewResultAll)
|
ON_COMMAND(ID_MODE_VIEW_DEFECT , &CEdgeImageViewer::OnViewDefect)
|
ON_COMMAND(ID_MODE_VIEW_MEASURE , &CEdgeImageViewer::OnViewMeasur)
|
ON_COMMAND(ID_MODE_MODIFY_BRUSH_BLACK , &CEdgeImageViewer::OnModifyDrawbrushBlack)
|
ON_COMMAND(ID_MODE_MODIFY_BRUSH_WHITE , &CEdgeImageViewer::OnModifyDrawbrushWhite)
|
ON_COMMAND(ID_MODE_VIEW_FRAME_INDEX , &CEdgeImageViewer::OnViewFrameIdx)
|
ON_WM_LBUTTONUP()
|
END_MESSAGE_MAP()
|
|
int CEdgeImageViewer::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
{
|
if (CWnd::OnCreate(lpCreateStruct) == -1)
|
return -1;
|
|
GetClientRect(m_rtWnd);
|
|
return 0;
|
}
|
|
void CEdgeImageViewer::InitBitMap()
|
{
|
if(m_pBmInfo != NULL)
|
free(m_pBmInfo);
|
|
m_pBmInfo = (BITMAPINFO*)malloc(sizeof(BITMAPINFO)+256*sizeof(RGBQUAD));
|
m_pBmInfo->bmiHeader.biBitCount = 8;
|
m_pBmInfo->bmiHeader.biClrImportant = 256;
|
m_pBmInfo->bmiHeader.biClrUsed = 256;
|
m_pBmInfo->bmiHeader.biCompression = BI_RGB;
|
m_pBmInfo->bmiHeader.biHeight = -m_nFrameHeight;
|
m_pBmInfo->bmiHeader.biPlanes = 1;
|
m_pBmInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
m_pBmInfo->bmiHeader.biSizeImage = m_nFrameWidth * m_nFrameHeight;
|
m_pBmInfo->bmiHeader.biWidth = m_nFrameWidth;
|
m_pBmInfo->bmiHeader.biXPelsPerMeter=0;
|
m_pBmInfo->bmiHeader.biYPelsPerMeter=0;
|
|
for(int i=0; i<256; i++) // Palette number is 256
|
{
|
m_pBmInfo->bmiColors[i].rgbRed= m_pBmInfo->bmiColors[i].rgbGreen = m_pBmInfo->bmiColors[i].rgbBlue = i;
|
m_pBmInfo->bmiColors[i].rgbReserved = 0;
|
}
|
}
|
|
void CEdgeImageViewer::DeleteBitMap()
|
{
|
if(m_pBmInfo == NULL)
|
return;
|
|
free(m_pBmInfo);
|
m_pBmInfo = NULL;
|
}
|
|
void CEdgeImageViewer::OnDestroy()
|
{
|
CWnd::OnDestroy();
|
|
DeleteBitMap();
|
}
|
|
void CEdgeImageViewer::OnContextMenu(CPoint point)
|
{
|
CMenu menu;
|
CMenu popMenu;
|
menu.CreateMenu(); // ÃÖ»óÀ§ »À´ë ¸Þ´º
|
popMenu.CreatePopupMenu(); // Æ˾÷¸Þ´º
|
|
popMenu.AppendMenu(MF_SEPARATOR);
|
popMenu.AppendMenu(MF_STRING, ID_MODE_USER_SELECT, _T("User Select (Mark/Manual Measure)"));
|
popMenu.AppendMenu(MF_SEPARATOR);
|
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_INSPECT_ALL, _T("All"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_INSPECT_AREA, _T("View Inspect Area"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_NOTCH_AREA, _T("View Notch Area"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_NOTCH_MEASURE, _T("View Notch Measure"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_INSPECT_SIDE_DIMENSION, _T("View Side Measure"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_CORNER_AREA, _T("View Corner Area"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_MARK_AREA, _T("View Mark Area"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_USER_DEFECT_AREA, _T("View User Defect Area"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_EXCEPTION_AREA, _T("View Exception Area"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_START_END_LINE, _T("View Start/End Line"));
|
popMenu.AppendMenu(MF_SEPARATOR);
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_DEFECT_ALL, _T("All"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_DEFECT, _T("View Defect"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_MEASURE, _T("View Measure"));
|
popMenu.AppendMenu(MF_SEPARATOR);
|
popMenu.AppendMenu(MF_STRING, ID_MODE_MODIFY_BRUSH_BLACK, _T("Create Black Defect"));
|
popMenu.AppendMenu(MF_STRING, ID_MODE_MODIFY_BRUSH_WHITE, _T("Create White Defect"));
|
popMenu.AppendMenu(MF_SEPARATOR);
|
popMenu.AppendMenu(MF_STRING, ID_MODE_VIEW_FRAME_INDEX, _T("View Frame Idx"));
|
|
|
if(m_MenuStatus[MODE_USER_SELECT])
|
popMenu.CheckMenuItem(ID_MODE_USER_SELECT,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_INSPECT_AREA])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_INSPECT_AREA,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_NOTCH_AREA])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_NOTCH_AREA,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_NOTCH_MEASURE])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_NOTCH_MEASURE,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_INSPECT_SIDE_DIMENSION])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_INSPECT_SIDE_DIMENSION,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_CORNER_AREA])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_CORNER_AREA,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_MARK_AREA])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_MARK_AREA,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_USER_DEFECT_AREA,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_EXCEPTION_AREA])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_EXCEPTION_AREA,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_START_END_LINE])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_START_END_LINE,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_DEFECT])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_DEFECT,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_MEASURE])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_MEASURE,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_MODIFY_BRUSH_BLACK])
|
popMenu.CheckMenuItem(ID_MODE_MODIFY_BRUSH_BLACK,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_MODIFY_BRUSH_WHITE])
|
popMenu.CheckMenuItem(ID_MODE_MODIFY_BRUSH_WHITE,MF_CHECKED);
|
|
if(m_MenuStatus[MODE_VIEW_FRAME_IDX])
|
popMenu.CheckMenuItem(ID_MODE_VIEW_FRAME_INDEX,MF_CHECKED);
|
|
|
|
// All Check
|
bool bAllCheck = true;
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_INSPECT_AREA];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_NOTCH_AREA];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_NOTCH_MEASURE];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_CORNER_AREA];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_MARK_AREA];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_EXCEPTION_AREA];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_START_END_LINE];
|
if(bAllCheck)
|
popMenu.CheckMenuItem(ID_MODE_VIEW_INSPECT_ALL,MF_CHECKED);
|
|
bAllCheck = true;
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_DEFECT];
|
bAllCheck = bAllCheck & m_MenuStatus[MODE_VIEW_MEASURE];
|
if(bAllCheck)
|
popMenu.CheckMenuItem(ID_MODE_VIEW_DEFECT_ALL,MF_CHECKED);
|
|
// ÄÁÅؽºÆ® ¸Þ´º È£Ãâ
|
CRect rect;
|
GetWindowRect(rect);
|
int nX = rect.left + point.x;
|
int nY = rect.top + point.y;
|
|
popMenu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, nX, nY, this);
|
}
|
|
void CEdgeImageViewer::OnMouseMove(UINT nFlags, CPoint point)
|
{
|
m_ptMousePos_Wnd = point;
|
m_ptMousePos_Pxl = GetPxlPos(m_ptMousePos_Wnd);
|
|
if(nFlags & MK_LBUTTON)
|
{
|
ModifyImageBack();
|
|
ModifyImageWhite();
|
}
|
|
if(m_ManualMeasureStatus.bStart == TRUE || m_ManualMeasureStatus.bModifyEnd == TRUE)
|
m_ManualMeasureStatus.ptMeasureEnd = m_ptMousePos_Pxl;
|
else if(m_ManualMeasureStatus.bModifyStart == TRUE)
|
m_ManualMeasureStatus.ptMeasureStart = m_ptMousePos_Pxl;
|
|
UpdateView();
|
CWnd::OnMouseMove(nFlags, point);
|
}
|
|
void CEdgeImageViewer::OnRButtonUp(UINT nFlags, CPoint point)
|
{
|
OnContextMenu(point);
|
CWnd::OnRButtonUp(nFlags, point);
|
}
|
|
void CEdgeImageViewer::OnLButtonDown(UINT nFlags, CPoint point)
|
{
|
CPoint ptWnd = point;
|
|
#if HALCON_VISION_KEY
|
m_isMouseDown = TRUE;
|
if (m_isMouseDown) {
|
CPoint ptPxl = GetPxlPos(ptWnd);
|
m_ptMouseDown = ptPxl;
|
}
|
#endif // HALCON_VISION_KEY
|
|
if(m_MenuStatus[MODE_USER_SELECT] == true)
|
{
|
if(m_ManualMeasureStatus.bStart == FALSE)
|
{
|
CPoint ptPxl = GetPxlPos(ptWnd);
|
|
int nInRange = (int) (10.0 / m_dZoom);
|
|
if( m_ManualMeasureStatus.ptMeasureStart.x > ptPxl.x - nInRange
|
&& m_ManualMeasureStatus.ptMeasureStart.x < ptPxl.x + nInRange
|
&& m_ManualMeasureStatus.ptMeasureStart.y > ptPxl.y - nInRange
|
&& m_ManualMeasureStatus.ptMeasureStart.y < ptPxl.y + nInRange )
|
{
|
if(m_ManualMeasureStatus.bModifyStart)
|
m_ManualMeasureStatus.bModifyStart = FALSE;
|
else
|
m_ManualMeasureStatus.bModifyStart = TRUE;
|
|
}
|
else if(m_ManualMeasureStatus.ptMeasureEnd.x > ptPxl.x - nInRange
|
&& m_ManualMeasureStatus.ptMeasureEnd.x < ptPxl.x + nInRange
|
&& m_ManualMeasureStatus.ptMeasureEnd.y > ptPxl.y - nInRange
|
&& m_ManualMeasureStatus.ptMeasureEnd.y < ptPxl.y + nInRange )
|
{
|
if(m_ManualMeasureStatus.bModifyEnd)
|
m_ManualMeasureStatus.bModifyEnd = FALSE;
|
else
|
m_ManualMeasureStatus.bModifyEnd = TRUE;
|
}
|
else
|
{
|
m_ManualMeasureStatus.bModifyStart = FALSE;
|
m_ManualMeasureStatus.bModifyEnd = FALSE;
|
m_ManualMeasureStatus.bStart = TRUE;
|
|
m_ManualMeasureStatus.ptMeasureStart = ptPxl;
|
}
|
}
|
else
|
{
|
m_ManualMeasureStatus.bStart = FALSE;
|
}
|
}
|
|
CWnd::OnLButtonDown(nFlags, point);
|
}
|
|
void CEdgeImageViewer::OnUserSelect()
|
{
|
m_MenuStatus.flip(MODE_USER_SELECT);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewInspetAll()
|
{
|
bool bCheck = true;
|
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_INSPECT_AREA];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_NOTCH_AREA];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_NOTCH_MEASURE];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_INSPECT_SIDE_DIMENSION];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_CORNER_AREA];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_MARK_AREA];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_EXCEPTION_AREA];
|
bCheck = bCheck && m_MenuStatus[MODE_VIEW_START_END_LINE];
|
|
if(bCheck == false)
|
{
|
m_MenuStatus.set(MODE_VIEW_INSPECT_AREA);
|
m_MenuStatus.set(MODE_VIEW_NOTCH_AREA);
|
m_MenuStatus.set(MODE_VIEW_NOTCH_MEASURE);
|
m_MenuStatus.set(MODE_VIEW_INSPECT_SIDE_DIMENSION);
|
m_MenuStatus.set(MODE_VIEW_CORNER_AREA);
|
m_MenuStatus.set(MODE_VIEW_MARK_AREA);
|
m_MenuStatus.set(MODE_VIEW_USER_DEFECT_AREA);
|
m_MenuStatus.set(MODE_VIEW_EXCEPTION_AREA);
|
m_MenuStatus.set(MODE_VIEW_START_END_LINE);
|
}
|
else
|
{
|
m_MenuStatus.reset(MODE_VIEW_INSPECT_AREA);
|
m_MenuStatus.reset(MODE_VIEW_NOTCH_AREA);
|
m_MenuStatus.reset(MODE_VIEW_NOTCH_MEASURE);
|
m_MenuStatus.reset(MODE_VIEW_INSPECT_SIDE_DIMENSION);
|
m_MenuStatus.reset(MODE_VIEW_CORNER_AREA);
|
m_MenuStatus.reset(MODE_VIEW_MARK_AREA);
|
m_MenuStatus.reset(MODE_VIEW_USER_DEFECT_AREA);
|
m_MenuStatus.reset(MODE_VIEW_EXCEPTION_AREA);
|
m_MenuStatus.reset(MODE_VIEW_START_END_LINE);
|
}
|
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewInspectArea()
|
{
|
m_MenuStatus.flip(MODE_VIEW_INSPECT_AREA);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewInspectNotchArea()
|
{
|
m_MenuStatus.flip(MODE_VIEW_NOTCH_AREA);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewInspectNotchMeasure()
|
{
|
m_MenuStatus.flip(MODE_VIEW_NOTCH_MEASURE);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewInspectSideDimension()
|
{
|
m_MenuStatus.flip(MODE_VIEW_INSPECT_SIDE_DIMENSION);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewCornerArea()
|
{
|
m_MenuStatus.flip(MODE_VIEW_CORNER_AREA);
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnViewMarkArea()
|
{
|
m_MenuStatus.flip(MODE_VIEW_MARK_AREA);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewUserDefectArea()
|
{
|
m_MenuStatus.flip(MODE_VIEW_USER_DEFECT_AREA);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewExceptionArea()
|
{
|
m_MenuStatus.flip(MODE_VIEW_EXCEPTION_AREA);
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnViewStartEndLine()
|
{
|
m_MenuStatus.flip(MODE_VIEW_START_END_LINE);
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnViewResultAll()
|
{
|
bool bCheck = true;
|
|
bCheck = bCheck & m_MenuStatus[MODE_VIEW_DEFECT];
|
bCheck = bCheck & m_MenuStatus[MODE_VIEW_MEASURE];
|
|
if(bCheck == false)
|
{
|
m_MenuStatus.set(MODE_VIEW_DEFECT);
|
m_MenuStatus.set(MODE_VIEW_MEASURE);
|
}
|
else
|
{
|
m_MenuStatus.reset(MODE_VIEW_DEFECT);
|
m_MenuStatus.reset(MODE_VIEW_MEASURE);
|
}
|
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnViewDefect()
|
{
|
m_MenuStatus.flip(MODE_VIEW_DEFECT);
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnViewMeasur()
|
{
|
m_MenuStatus.flip(MODE_VIEW_MEASURE);
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnModifyDrawbrushBlack()
|
{
|
if(m_MenuStatus[MODE_MODIFY_BRUSH_WHITE])
|
m_MenuStatus.reset(MODE_MODIFY_BRUSH_WHITE);
|
|
m_MenuStatus.flip(MODE_MODIFY_BRUSH_BLACK);
|
Invalidate(FALSE);
|
}
|
void CEdgeImageViewer::OnModifyDrawbrushWhite()
|
{
|
if(m_MenuStatus[MODE_MODIFY_BRUSH_BLACK])
|
m_MenuStatus.reset(MODE_MODIFY_BRUSH_BLACK);
|
|
m_MenuStatus.flip(MODE_MODIFY_BRUSH_WHITE);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnViewFrameIdx()
|
{
|
m_MenuStatus.flip(MODE_VIEW_FRAME_IDX);
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::SetImageBuffer(BYTE *pImg, int nWidth, int nHeight, int nFrameCount)
|
{
|
m_pBuffer = pImg;
|
m_nFrameWidth = nWidth;
|
m_nFrameHeight = nHeight;
|
m_nFrameCount = nFrameCount;
|
m_nTotalHeight = nHeight * nFrameCount;
|
|
InitBitMap();
|
}
|
|
void CEdgeImageViewer::SetImageBuffer(BYTE *pImg)
|
{
|
m_pBuffer = pImg;
|
|
Invalidate(FALSE);
|
}
|
|
void CEdgeImageViewer::OnPaint()
|
{
|
CPaintDC dc(this); // device context for painting
|
// TODO: ¿©±â¿¡ ¸Þ½ÃÁö 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
|
// ±×¸®±â ¸Þ½ÃÁö¿¡ ´ëÇؼ´Â CStatic::OnPaint()À»(¸¦) È£ÃâÇÏÁö ¸¶½Ê½Ã¿À.
|
UpdateView();
|
}
|
|
#if HALCON_VISION_KEY
|
void CEdgeImageViewer::UpdataVisionResult(void) {
|
/* code */
|
if (!IsWindowVisible())
|
return;
|
|
if (m_pBuffer == NULL)
|
return;
|
|
CDC* pDC = GetDC();
|
CDC memDC;
|
CBitmap Bitmap;
|
CBitmap* pOldBitmap;
|
|
memDC.CreateCompatibleDC(pDC);
|
Bitmap.CreateCompatibleBitmap(pDC, m_rtWnd.Width(), m_rtWnd.Height());
|
m_pBmInfo->bmiHeader.biWidth = m_nFrameWidth;
|
m_pBmInfo->bmiHeader.biHeight = -int(m_rtWnd.Height() / m_dZoom);
|
m_pBmInfo->bmiHeader.biSizeImage = m_pBmInfo->bmiHeader.biWidth * m_pBmInfo->bmiHeader.biHeight;
|
memDC.SetStretchBltMode(COLORONCOLOR);
|
pOldBitmap = (CBitmap*)memDC.SelectObject(&Bitmap);
|
|
|
// 1. Draw Buffer Image
|
UpdateView_Image(&memDC);
|
|
//2. ÏÔʾÊÓ¾õЧ¹û
|
UpdateView_VisionResult(&memDC);
|
|
|
pDC->BitBlt(0, 0, m_rtWnd.Width(), m_rtWnd.Height(), &memDC, 0, 0, SRCCOPY);
|
memDC.SelectObject(pOldBitmap);
|
Bitmap.DeleteObject();
|
ReleaseDC(&memDC);
|
ReleaseDC(pDC);
|
}
|
|
void CEdgeImageViewer::UpdateView_VisionResult(CDC* memDC) {
|
/* code */
|
if (m_MenuStatus[MODE_VIEW_DEFECT] == false)
|
return;
|
|
DimensionDir eDir = (DimensionDir)(m_nSideIdx);
|
CBlSideData *pSideData = BlVision_GetVisionRecipe()->getSideData(eDir);
|
if (NULL == pSideData) return;
|
|
int nCount = (int)(pSideData->m_vDispVisionResult.size());
|
if (nCount < 1) return;
|
|
if (m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
CPen pen(PS_SOLID, 1, RGB(255, 0, 0));
|
CPen pen_SearchArea(PS_DASH, 1, RGB(255, 0, 255));
|
CPen pen_Line(PS_DASH, 1, RGB(0, 255, 255));
|
|
CBrush brush_Null;
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
CPen* pOldPen = memDC->SelectObject(&pen);
|
CBrush* pOldBrush = (CBrush*)memDC->SelectObject(&brush_Null);
|
|
for (int i = 0; i < nCount; i++) {
|
DispVisionResult inf = pSideData->m_vDispVisionResult[i];
|
int nType = inf.nType;
|
if (0 == nType) { //µã
|
CRect rtMarkPos_pxl = CRect(inf.pointX-31, inf.pointY-31, inf.pointX + 31, inf.pointY + 31);
|
CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
|
CPoint ptMarkPos_wnd = rtMarkPos_wnd.CenterPoint();
|
|
memDC->SelectObject(&pen);
|
CPoint pt = ptMarkPos_wnd;
|
if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
|
memDC->MoveTo(ptMarkPos_wnd.x - 8, ptMarkPos_wnd.y - 8);
|
memDC->LineTo(ptMarkPos_wnd.x + 8, ptMarkPos_wnd.y + 8);
|
memDC->MoveTo(ptMarkPos_wnd.x + 8, ptMarkPos_wnd.y - 8);
|
memDC->LineTo(ptMarkPos_wnd.x - 8, ptMarkPos_wnd.y + 8);
|
}
|
}
|
else if (1 == nType) { //¾ØÐÎ
|
CRect rtMarkPos_pxl = CRect(inf.rectX1, inf.rectY1, inf.rectX2, inf.rectY2);
|
CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkPos_pxl);
|
if (4 == inf.eVision) {
|
memDC->SelectObject(&pen);
|
}
|
else {
|
memDC->SelectObject(&pen_SearchArea);
|
}
|
CPoint pt;
|
pt.x = (int)(0.5 * (rtMarkSearchPos_wnd.left + rtMarkSearchPos_wnd.right));
|
pt.y = (int)(0.5 * (rtMarkSearchPos_wnd.top + rtMarkSearchPos_wnd.bottom));
|
if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
|
memDC->Rectangle(rtMarkSearchPos_wnd);
|
}
|
}
|
else if (2 == nType) { //Ô²
|
CRect rtMarkPos_pxl = CRect(inf.circleX - inf.circleRadius, inf.circleY - inf.circleRadius, inf.circleX + inf.circleRadius, inf.circleY + inf.circleRadius);
|
CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkPos_pxl);
|
memDC->SelectObject(&pen);
|
CPoint pt;
|
pt.x = (int)(0.5 * (rtMarkSearchPos_wnd.left + rtMarkSearchPos_wnd.right));
|
pt.y = (int)(0.5 * (rtMarkSearchPos_wnd.top + rtMarkSearchPos_wnd.bottom));
|
if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
|
memDC->Ellipse(rtMarkSearchPos_wnd);
|
}
|
}
|
else if (3 == nType) { //Ö±Ïß
|
CRect rtMarkPos_pxl = CRect(inf.rectX1 - 31, inf.rectY1 - 31, inf.rectX1 + 31, inf.rectY1 + 31);
|
CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
|
CPoint pt0 = rtMarkPos_wnd.CenterPoint();
|
|
rtMarkPos_pxl = CRect(inf.rectX2 - 31, inf.rectY2 - 31, inf.rectX2 + 31, inf.rectY2 + 31);
|
rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
|
CPoint pt1 = rtMarkPos_wnd.CenterPoint();
|
|
memDC->SelectObject(&pen_Line);
|
|
CPoint pt;
|
pt.x = (int)(0.5 * (pt0.x + pt1.x));
|
pt.y = (int)(0.5 * (pt0.y + pt1.y));
|
if (pt.x > 0 && pt.x < m_rtWnd.right && pt.y > 0 && pt.y < m_rtWnd.bottom) {
|
memDC->MoveTo(pt0.x, pt0.y);
|
memDC->LineTo(pt1.x, pt1.y);
|
}
|
}
|
else if (4 == nType) {
|
CRect rtMarkPos_pxl = CRect(inf.pointX - 31, inf.pointY - 31, inf.pointX + 31, inf.pointY + 31);
|
CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
|
CPoint pt = rtMarkPos_wnd.CenterPoint();
|
|
memDC->SetBkMode(TRANSPARENT);
|
memDC->SetTextColor(RGB(0, 0, 255));
|
memDC->TextOut(pt.x - 80, pt.y, inf.strName);
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
brush_Null.DeleteObject();
|
|
}
|
#endif // HALCON_VISION_KEY
|
|
void CEdgeImageViewer::UpdateView()
|
{
|
if(!IsWindowVisible())
|
return;
|
|
if(m_pBuffer == NULL)
|
return;
|
|
CDC* pDC = GetDC();
|
CDC memDC;
|
CBitmap Bitmap;
|
CBitmap* pOldBitmap;
|
|
memDC.CreateCompatibleDC(pDC);
|
Bitmap.CreateCompatibleBitmap(pDC,m_rtWnd.Width(),m_rtWnd.Height());
|
m_pBmInfo->bmiHeader.biWidth = m_nFrameWidth;
|
m_pBmInfo->bmiHeader.biHeight = -int(m_rtWnd.Height() / m_dZoom);
|
m_pBmInfo->bmiHeader.biSizeImage = m_pBmInfo->bmiHeader.biWidth * m_pBmInfo->bmiHeader.biHeight;
|
memDC.SetStretchBltMode(COLORONCOLOR);
|
pOldBitmap = (CBitmap*)memDC.SelectObject(&Bitmap);
|
|
|
// 1. Draw Buffer Image
|
UpdateView_Image(&memDC);
|
|
// 2. Draw Side Name
|
UpdateView_SideName(&memDC);
|
|
// 3. Draw Mouse Pos Info
|
UpdateView_MousePosInfo(&memDC);
|
|
// 4. Draw Corner : MODE_VIEW_CORNER_AREA
|
UpdateView_Corner(&memDC);
|
|
// 5. Draw Mark : MODE_VIEW_MARK_AREA
|
UpdateView_Mark(&memDC);
|
|
// 6. Draw User Defect Area : MODE_VIEW_USER_DEFECT_AREA
|
UpdateView_UserDefectArea(&memDC);
|
|
// 7. Draw Exception : MODE_VIEW_EXCEPTION_AREA
|
UpdateView_ExceptionArea(&memDC);
|
|
// 8. Draw Inspect : MODE_VIEW_INSPECT_AREA
|
UpdateView_InspectArea(&memDC);
|
|
// 9. Draw Notch : MODE_VIEW_NOTCH_AREA
|
UpdateView_NotchArea(&memDC);
|
|
// 10. Draw Notch Measure : MODE_VIEW_NOTCH_MEASURE
|
UpdateView_NotchMeasure(&memDC);
|
UpdateView_Notch_Circle_Measure(&memDC);
|
|
// 11. Draw Side Dimension : MODE_VIEW_INSPECT_SIDE_DIMENSION
|
UpdateView_MeasureSideDimensionResult(&memDC);
|
|
// 12. Draw Start Line, End Line : MODE_VIEW_START_END_LINE
|
UpdateView_StartEndLine(&memDC);
|
|
// 13. Draw Defect : MODE_VIEW_DEFECT
|
UpdateView_Defect(&memDC);
|
|
// 14. Draw Manual Measure : MODE_USER_SELECT
|
UpdateView_ManualMeasure(&memDC);
|
|
// 15. Frame
|
UpdateView_Frame(&memDC);
|
|
// 16. Mouse Pos
|
UpdateView_MousePoint(&memDC);
|
|
#if HALCON_VISION_KEY
|
//17. ÏÔʾvision Rsult
|
UpdateView_VisionResult(&memDC);
|
#endif // HALCON_VISION_KEY
|
|
|
pDC->BitBlt(0,0,m_rtWnd.Width(),m_rtWnd.Height(),&memDC,0,0,SRCCOPY);
|
memDC.SelectObject(pOldBitmap);
|
Bitmap.DeleteObject();
|
ReleaseDC(&memDC);
|
ReleaseDC(pDC);
|
|
/*
|
if(nOpt == 0 && m_ptOrg.y >= 0)
|
{
|
if(m_bitModeDisplay.at(MODE_MANIFY))
|
DrawMagnify(memDC);
|
|
if(m_bitModeDisplay.at(MODE_PROFILE_X))
|
DrawProfile(memDC,0,m_ptMouseCurrent);
|
|
if(m_bitModeDisplay.at(MODE_PROFILE_Y))
|
DrawProfile(memDC,1,m_ptMouseCurrent);
|
|
if(m_bitModeDisplay.at(MODE_SAVED_X))
|
DrawProfileSaved(memDC,0,m_ptMouseSaved);
|
|
if(m_bitModeDisplay.at(MODE_SAVED_Y))
|
DrawProfile(memDC,1,m_ptMouseSaved);
|
|
if(m_bitModeDisplay.at(MODE_PROJECTION_X))
|
DrawProfile(memDC,2,m_ptMouseCurrent);
|
|
if(m_bitModeDisplay.at(MODE_PROJECTION_Y))
|
DrawProfile(memDC,3,m_ptMouseCurrent);
|
|
|
if(m_bitModeDisplay.at(MODE_DISTANCE_X)
|
|| m_bitModeDisplay.at(MODE_DISTANCE_Y)
|
|| m_bitModeDisplay.at(MODE_DIAGONAL))
|
DrawManualMeasure(memDC);
|
|
// DrawTest(memDC);
|
DrawProcessData(memDC);
|
DrawExpectionAear(memDC);
|
DrawUserDefectArea(memDC);
|
|
|
if(m_bitModeDisplay.at(MODE_MARK_REG))
|
{
|
Draw_TrakerRect(m_refMark.rc,memDC);
|
}
|
else if(((m_bitModeDisplay.at(MODE_USER_DEFECT_AREA)) || (m_bitModeDisplay.at(MODE_COMPARE_PANEL) == true)) && (m_pCompareArea != nullptr))
|
{
|
Draw_CompareRect(m_pCompareArea->rc, memDC);
|
}
|
}
|
*/
|
|
/*
|
memDC.SetBkMode(TRANSPARENT);
|
memDC.SetTextColor(RGB(0,0,255));
|
//memDC.SetTextColor(RGB(45,200,45));
|
CString str;
|
str.Format(_T("%d"),m_ptOrg.y);
|
memDC.TextOut(m_WndRect.Width() - 50,10,str);
|
|
int nTmp = int((m_ptMouseCurrent.y/ m_dZoom) * m_szImg.cx + m_ptOrg.x + (m_ptMouseCurrent.x / m_dZoom));
|
|
int nMaxLine = MAX_LIMIT_LINE * IMAGE_WIDTH;
|
|
if(m_szTotBuffer.cy > 0)
|
{
|
nMaxLine = (m_szTotBuffer.cy-1) * IMAGE_HEIGHT * m_szTotBuffer.cx;
|
}
|
|
if(nTmp > -1 && nTmp < nMaxLine && m_ptOrg.y >= 0 && m_ptOrg.x >= 0 && m_pBuffer != NULL)
|
{
|
str.Format(_T("(%d / %d) [%d]"), m_ptOrg.x + int(m_ptMouseCurrent.x / m_dZoom) , m_ptOrg.y + int(m_ptMouseCurrent.y / m_dZoom)
|
, m_pBuffer[nTmp]);
|
|
memDC.TextOut(10,m_WndRect.Height() - 40,str);
|
}
|
|
*/
|
/*
|
GetDC()->BitBlt(0,0,m_WndRect.Width(),m_WndRect.Height(),&memDC,0,0,SRCCOPY);
|
memDC.SelectObject(pOldBitmap);
|
Bitmap.DeleteObject();
|
ReleaseDC(&memDC);
|
ReleaseDC(pDC);
|
*/
|
}
|
|
void CEdgeImageViewer::UpdateView_Image(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL)
|
return;
|
|
StretchDIBits(memDC->m_hDC, 0 , 0, m_rtWnd.Width(),m_rtWnd.Height(),
|
m_ptDisplayStart_pxl.x,0,int(m_rtWnd.Width()/ m_dZoom),int(m_rtWnd.Height()/ m_dZoom),
|
m_pBuffer,(BITMAPINFO*)m_pBmInfo,DIB_RGB_COLORS,SRCCOPY);
|
}
|
|
void CEdgeImageViewer::UpdateView_SideName(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL)
|
return;
|
|
memDC->SetBkMode(TRANSPARENT);
|
|
CFont newFont;
|
newFont.CreateFont(25 , 15, 0, 0, 900 , FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,_T("Arial"));
|
|
CFont* pOldFont = memDC->SelectObject(&newFont);
|
memDC->SetTextColor(RGB(45,200,45));
|
memDC->TextOut(0,0, g_SideName[m_nSideIdx]);
|
memDC->SetBkMode(OPAQUE);
|
memDC->SelectObject(pOldFont);
|
|
newFont.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_MousePosInfo(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL)
|
return;
|
|
memDC->SetBkMode(TRANSPARENT);
|
memDC->SetTextColor(RGB(0,0,255));
|
|
// CFont newFont;
|
// newFont.CreateFont(25 , 15, 0, 0, 900 , FALSE, FALSE, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,_T("Arial"));
|
|
CString strTemp;
|
strTemp.Format(_T("%d"),m_ptDisplayStart_pxl.y);
|
memDC->TextOut(m_rtWnd.Width() - 50, 10, strTemp);
|
|
if(m_ptMousePos_Pxl.x < 0 || m_nFrameWidth <= m_ptMousePos_Pxl.x)
|
return;
|
|
if(m_ptMousePos_Pxl.y < 0 || m_nTotalHeight <= m_ptMousePos_Pxl.y)
|
return;
|
|
int nYPos = m_ptMousePos_Pxl.y - m_ptDisplayStart_pxl.y; // Recipe View¿¡¼ Scroll ÇÒ ¶§ ¹öÆÛ À§Ä¡¸¦ ¹Ù²Þ;;;
|
|
int nPos = (nYPos * m_nFrameWidth) + m_ptMousePos_Pxl.x;
|
|
if(nPos < 0 || m_nTotalHeight * m_nFrameWidth <= nPos)
|
return;
|
|
strTemp.Format(_T("(%d / %d) [%d]"), m_ptMousePos_Pxl.x, m_ptMousePos_Pxl.y, m_pBuffer[nPos]);
|
memDC->TextOut(10, m_rtWnd.Height() - 45, strTemp);
|
|
#if HALCON_VISION_KEY
|
if ((0 != m_ptMouseDown.x || 0 != m_ptMouseDown.y) && BlVision_GetVisionRecipe()->getVisionSetOpen()) { //Êó±ê¸Ä±ä
|
strTemp.Format(_T("(%d / %d)"), m_ptMouseDown.x, m_ptMouseDown.y);
|
memDC->TextOut(10, m_rtWnd.Height() - 25, strTemp);
|
|
Point2I point, result, topResult, botResult;
|
point.x = m_ptMouseDown.x;
|
point.y = m_ptMouseDown.y;
|
if (BlVision_GetSoftVisionApp()->transformToStandard(m_nSideIdx, point, result, topResult, botResult)) {
|
strTemp.Format(_T("(%d / %d)"), result.x, result.y);
|
memDC->TextOut(110, m_rtWnd.Height() - 25, strTemp);
|
|
strTemp.Format(_T("(%d / %d)"), topResult.x, topResult.y);
|
memDC->TextOut(210, m_rtWnd.Height() - 25, strTemp);
|
|
strTemp.Format(_T("(%d / %d)"), botResult.x, botResult.y);
|
memDC->TextOut(310, m_rtWnd.Height() - 25, strTemp);
|
}
|
}
|
#endif // HALCON_VISION_KEY
|
|
// newFont.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_InspectArea(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_INSPECT_AREA] == FALSE)
|
return;
|
|
CPen pen_SideLine(PS_DASH, 1, RGB(255,127,39));
|
CPen pen_ChamferLine(PS_DASH, 1, RGB(255,255,0));
|
CPen pen_Green(PS_SOLID, 1, RGB(0,220,0));
|
CPen pen_FilterLine(PS_DOT, 1, RGB(0,220,0));
|
|
CBrush brush_Null;
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
CPen* pOldPen = (CPen*) memDC->SelectObject(&pen_SideLine);
|
CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);
|
|
CRect rcTmp,rtRealPos;
|
int nFilterLine;
|
int nChamferLine;
|
|
for(int nFrameIdx = 0; nFrameIdx < MAX_IMAGE_FRAME; nFrameIdx++)
|
{
|
CRect rtArea_Inspect = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtInspectArea[nFrameIdx];
|
int nSideLine = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nSideLineFrame[nFrameIdx];
|
int nSideChamferLine = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nSide_Chamfer_LineFrame[nFrameIdx];
|
|
// Side Line
|
rtRealPos = rtArea_Inspect;
|
nFilterLine = nSideLine;
|
|
if(0 < nFilterLine)
|
{
|
memDC->SelectObject(&pen_SideLine);
|
memDC->MoveTo(int((nFilterLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((nFilterLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom - m_ptDisplayStart_pxl.y) * m_dZoom));
|
}
|
|
if(0 < nSideChamferLine)
|
{
|
memDC->SelectObject(&pen_ChamferLine);
|
memDC->MoveTo(int((nSideChamferLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((nSideChamferLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom - m_ptDisplayStart_pxl.y) * m_dZoom));
|
}
|
|
for(int nInsType = 0; nInsType < MAX_SIDE_INSPECT_TYPE; nInsType++)
|
{
|
CRect rtArea = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtInspectArea_InsType[nInsType][nFrameIdx];
|
int nFilterLine = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nSideFilterLine_InsType[nInsType][nFrameIdx];
|
|
rtRealPos = rtArea;
|
nFilterLine = nFilterLine;
|
|
if(rtRealPos.IsRectEmpty() != TRUE && rtRealPos.IsRectNull() != TRUE)
|
{
|
rcTmp.left = int((rtRealPos.left - m_ptDisplayStart_pxl.x ) * m_dZoom);
|
rcTmp.right = int((rtRealPos.right - m_ptDisplayStart_pxl.x ) * m_dZoom);
|
rcTmp.top = int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom);
|
rcTmp.bottom = int((rtRealPos.bottom - m_ptDisplayStart_pxl.y) * m_dZoom);
|
|
if(rcTmp.top < 0 && rcTmp.bottom > 0 || rcTmp.top > 0 && rcTmp.top < m_rtWnd.bottom +1 || rcTmp.bottom > 0 && rcTmp.bottom < m_rtWnd.bottom +1)
|
{
|
memDC->SelectObject(&pen_Green);
|
memDC->MoveTo(int((rtRealPos.left - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((rtRealPos.right - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((rtRealPos.right - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((rtRealPos.left - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((rtRealPos.left - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom));
|
}
|
|
if(0 < nFilterLine)
|
{
|
memDC->SelectObject(&pen_FilterLine);
|
memDC->MoveTo(int((nFilterLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.top - m_ptDisplayStart_pxl.y) * m_dZoom));
|
memDC->LineTo(int((nFilterLine - m_ptDisplayStart_pxl.x ) * m_dZoom) , int((rtRealPos.bottom - m_ptDisplayStart_pxl.y) * m_dZoom));
|
}
|
}
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
brush_Null.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_NotchArea(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_NOTCH_AREA] == FALSE)
|
return;
|
|
CPen penRed(PS_SOLID, 2, RGB(255,0,0)), *pOldPen;
|
CBrush brush_Null, *pOldBrush;
|
CRect rc,rc1;
|
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
pOldPen = memDC->SelectObject(&penRed);
|
pOldBrush = memDC->SelectObject(&brush_Null);
|
|
memDC->SetTextColor(RGB(0,0,255));
|
|
int nNotchCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCount;
|
|
for(int i=0; i<nNotchCount; i++)
|
{
|
CRect rtNotchArea_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtNotchArea_pxl[i];
|
CRect rtNotchArea_wnd = GetWndPos(rtNotchArea_pxl);
|
|
if(rtNotchArea_wnd.IsRectEmpty() != TRUE && rtNotchArea_wnd.IsRectNull() != TRUE)
|
{
|
memDC->Rectangle(rtNotchArea_wnd);
|
|
CString strTemp;
|
strTemp.Format(_T("Notch Area [%d]"), i+1);
|
memDC->TextOut(rtNotchArea_wnd.left, rtNotchArea_wnd.top - 20, strTemp);
|
}
|
|
// Notch Circle
|
int nNotchCircleCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircleCount[i];
|
|
for(int j=0; j<nNotchCircleCount; j++)
|
{
|
CRect rtNotchCircleArea = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtNotchCircleArea_pxl[i][j];
|
CRect rtNotchCircleArea_wnd = GetWndPos(rtNotchCircleArea);
|
|
if(rtNotchCircleArea_wnd.IsRectEmpty() != TRUE && rtNotchCircleArea_wnd.IsRectNull() != TRUE)
|
{
|
memDC->Rectangle(rtNotchCircleArea_wnd);
|
|
CString strTemp;
|
strTemp.Format(_T("Notch Area [%d] - Notch Circle Area [%d]"), i+1, j+1);
|
memDC->TextOut(rtNotchCircleArea_wnd.left, rtNotchCircleArea_wnd.top - 20, strTemp);
|
}
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
|
brush_Null.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_NotchMeasure(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_NOTCH_MEASURE] == FALSE)
|
return;
|
|
CBrush brush_Ref_Rect;
|
brush_Ref_Rect.CreateSolidBrush(RGB(0,162,232));
|
|
CPen *pOldPen;
|
CPen pen_Dash_Orange(PS_DASHDOTDOT, 1, RGB(250, 150, 0));
|
CPen pen_Solid_Green(PS_SOLID, 1, RGB(0,150,0));
|
CPen pen_Solid_Red(PS_SOLID, 1, RGB(150,0,0));
|
|
CBrush brush_Null, *pOldBrush;
|
CRect rc,rc1;
|
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
pOldPen = memDC->SelectObject(&pen_Solid_Green);
|
pOldBrush = memDC->SelectObject(&brush_Null);
|
|
memDC->SetTextColor(RGB(0,0,255));
|
|
int nNotchCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCount;
|
|
for(int i=0; i<nNotchCount; i++)
|
{
|
for(int j=0; j<MAX_SIDE_NOTCH_MEASURE_COUNT; j++)
|
{
|
CPoint ptRef_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_ptNotch_Reference[i][j];
|
CPoint ptDimension_Edge_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_ptNotch_Dimension_Edge[i][j];
|
CPoint ptChamfer_Edge_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_ptNotch_Chamfer_Edge[i][j];
|
|
CPoint ptRef_wnd = GetWndPos(ptRef_pxl);
|
CPoint ptDimension_Edge_wnd = GetWndPos(ptDimension_Edge_pxl);
|
CPoint ptChamfer_Edge_wnd = GetWndPos(ptChamfer_Edge_pxl);
|
|
CRect rectRef = CRect(ptRef_pxl, ptRef_pxl);
|
rectRef.InflateRect(3, 3);
|
|
memDC->SelectObject(brush_Ref_Rect);
|
memDC->FillRect(&rectRef, &brush_Ref_Rect);
|
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Dimension_Edge_Judge[i][j] != 0)
|
{
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Dimension_Edge_Judge[i][j] == 1)
|
memDC->SelectObject(&pen_Solid_Green);
|
else
|
memDC->SelectObject(&pen_Solid_Red);
|
|
memDC->MoveTo(ptDimension_Edge_wnd.x-5, ptDimension_Edge_wnd.y);
|
memDC->LineTo(ptDimension_Edge_wnd.x+5, ptDimension_Edge_wnd.y);
|
memDC->MoveTo(ptDimension_Edge_wnd.x, ptDimension_Edge_wnd.y-5);
|
memDC->LineTo(ptDimension_Edge_wnd.x, ptDimension_Edge_wnd.y+5);
|
|
memDC->SelectObject(&pen_Dash_Orange);
|
memDC->MoveTo(ptRef_wnd.x,ptRef_wnd.y);
|
memDC->LineTo(ptDimension_Edge_wnd.x,ptDimension_Edge_wnd.y);
|
}
|
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Chamfer_Edge_Judge[i][j] != 0)
|
{
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Chamfer_Edge_Judge[i][j] == 1)
|
memDC->SelectObject(&pen_Solid_Green);
|
else
|
memDC->SelectObject(&pen_Solid_Red);
|
|
memDC->MoveTo(ptChamfer_Edge_wnd.x-5, ptChamfer_Edge_wnd.y);
|
memDC->LineTo(ptChamfer_Edge_wnd.x+5, ptChamfer_Edge_wnd.y);
|
memDC->MoveTo(ptChamfer_Edge_wnd.x, ptChamfer_Edge_wnd.y-5);
|
memDC->LineTo(ptChamfer_Edge_wnd.x, ptChamfer_Edge_wnd.y+5);
|
|
memDC->SelectObject(&pen_Dash_Orange);
|
memDC->MoveTo(ptDimension_Edge_wnd.x,ptDimension_Edge_wnd.y);
|
memDC->LineTo(ptChamfer_Edge_wnd.x,ptChamfer_Edge_wnd.y);
|
}
|
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Dimension_Edge_Judge[i][j] != 0 ||
|
m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Chamfer_Edge_Judge[i][j] != 0)
|
{
|
if(1 < m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Dimension_Edge_Judge[i][j] || 1 < m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotch_Chamfer_Edge_Judge[i][j])
|
memDC->SetTextColor(RGB(255,0,0));
|
else
|
memDC->SetTextColor(RGB(0,255,0));
|
|
CString strTemp;
|
strTemp.Format(_T("%s"), (CString) m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_strNotchMeasure_Comment[i][j]);
|
CRect rtTemp(ptRef_wnd.x + 10, ptRef_wnd.y-10, ptRef_wnd.x + 1024, ptRef_wnd.y + 20);
|
memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
|
}
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
|
brush_Null.DeleteObject();
|
brush_Ref_Rect.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_Notch_Circle_Measure(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_NOTCH_MEASURE] == FALSE)
|
return;
|
|
CBrush brush_Ref_Rect;
|
brush_Ref_Rect.CreateSolidBrush(RGB(0,162,232));
|
|
CPen *pOldPen;
|
CPen pen_Dash_Orange(PS_DASHDOTDOT, 1, RGB(250, 150, 0));
|
CPen pen_Solid_Green(PS_SOLID, 1, RGB(0,150,0));
|
CPen pen_Solid_Red(PS_SOLID, 1, RGB(150,0,0));
|
|
CBrush brush_Null, *pOldBrush;
|
CRect rc,rc1;
|
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
pOldPen = memDC->SelectObject(&pen_Solid_Green);
|
pOldBrush = memDC->SelectObject(&brush_Null);
|
|
memDC->SetTextColor(RGB(0,0,255));
|
|
int nNotchCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCount;
|
|
for(int i=0; i<nNotchCount; i++)
|
{
|
for(int j=0; j<MAX_SIDE_NOTCH_CIRCLE_COUNT; j++)
|
{
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircle_Radius_Judge[i][j] == 0)
|
continue;
|
|
if(m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircle_Radius_Judge[i][j] == 1)
|
memDC->SelectObject(&pen_Solid_Green);
|
else
|
memDC->SelectObject(&pen_Solid_Red);
|
|
CPoint ptCircleCenter_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_ptNotchCircle_Center_pxl[i][j];
|
|
int nCircleRadius_X_pxl = (int)(m_pGlassData->GetSideData((DimensionDir)m_nSideIdx)->m_ptNotchCircle_Radius_Result_X_pxl[i][j]);
|
int nCircleRadius_Y_pxl = (int)(m_pGlassData->GetSideData((DimensionDir)m_nSideIdx)->m_ptNotchCircle_Radius_Result_Y_pxl[i][j]);
|
|
CRect rtCircleArea_pxl = CRect(ptCircleCenter_pxl.x, ptCircleCenter_pxl.y, ptCircleCenter_pxl.x, ptCircleCenter_pxl.y);
|
rtCircleArea_pxl.InflateRect(nCircleRadius_X_pxl, nCircleRadius_Y_pxl);
|
|
CRect rtCircleArea_pxl_wnd = GetWndPos(rtCircleArea_pxl);
|
|
memDC->Ellipse(rtCircleArea_pxl_wnd);
|
|
// Measure Result Text..
|
if(1 < m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nNotchCircle_Radius_Judge[i][j])
|
memDC->SetTextColor(RGB(255,0,0));
|
else
|
memDC->SetTextColor(RGB(0,255,0));
|
|
CRect rtCircleArea = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtNotchCircleArea_pxl[i][j];
|
CPoint ptPos = rtCircleArea.CenterPoint();
|
ptPos.x = rtCircleArea.left;
|
CPoint ptPos_wnd = GetWndPos(ptPos);
|
|
CString strTemp;
|
strTemp.Format(_T("%s"), (CString) m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_strNotchCircle_Radius_Comment[i][j]);
|
CRect rtTemp(ptPos_wnd.x + 10, ptPos_wnd.y-10, ptPos_wnd.x + 1024, ptPos_wnd.y + 20);
|
memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
|
brush_Null.DeleteObject();
|
brush_Ref_Rect.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_Corner(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_CORNER_AREA] == FALSE)
|
return;
|
|
CPen pen(PS_SOLID, 1,RGB(0,255,0));
|
CPen pen_OffsetLine(PS_DOT, 1,RGB(0,255,0));
|
|
CBrush brush_Null;
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
CPen* pOldPen = memDC->SelectObject(&pen);
|
CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);
|
|
CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
|
if(pSideData == NULL)
|
return;
|
|
if(pSideData->m_bTopCorner_Find == TRUE)
|
{
|
CRect rtCornerPos_pxl = pSideData->m_rtTopCornerArea;
|
CRect rtCornerPos_wnd = GetWndPos(rtCornerPos_pxl);
|
|
CRect rtCornerPos_Offset_pxl = pSideData->m_rtTopCornerArea_Offset;
|
CRect rtCornerPos_Offset_wnd = GetWndPos(rtCornerPos_Offset_pxl);
|
CRect rtCornerPos_Ins_pxl = pSideData->m_rtTopCornerArea_Ins;
|
CRect rtCornerPos_Ins_wnd = GetWndPos(rtCornerPos_Ins_pxl);
|
|
if(pSideData->m_nTopCornerShape == 0) // None
|
{
|
memDC->SelectObject(&pen);
|
|
memDC->Rectangle(rtCornerPos_wnd);
|
memDC->Rectangle(rtCornerPos_Ins_wnd);
|
|
memDC->SelectObject(&pen_OffsetLine);
|
memDC->Rectangle(rtCornerPos_Offset_wnd);
|
}
|
else if(pSideData->m_nTopCornerShape == 1) // CCUT
|
{
|
memDC->SelectObject(&pen);
|
|
// Corner LIne
|
memDC->MoveTo(rtCornerPos_wnd.left, rtCornerPos_wnd.bottom);
|
memDC->LineTo(rtCornerPos_wnd.right, rtCornerPos_wnd.top);
|
|
// Ins Line
|
memDC->MoveTo(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.bottom);
|
memDC->LineTo(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.top);
|
|
// Offset Line
|
memDC->SelectObject(&pen_OffsetLine);
|
memDC->MoveTo(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.bottom);
|
memDC->LineTo(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.top);
|
|
CPoint ptPoint,ptDraw;
|
CPen pen2(PS_DASH , 1,RGB(255,0,255));
|
|
if(pSideData->m_bTopCorner_Measure == TRUE)
|
{
|
memDC->SelectObject(&pen2);
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top-20);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].right,pSideData->m_rtTopCornerResult[1].top-20);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].right,pSideData->m_rtTopCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top-10);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].right,pSideData->m_rtTopCornerResult[1].top-10);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 20,pSideData->m_rtTopCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 20,pSideData->m_rtTopCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left,pSideData->m_rtTopCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 10,pSideData->m_rtTopCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtTopCornerResult[1].left - 10,pSideData->m_rtTopCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
if(pSideData->m_bTopCornerMeasureResult == FALSE)
|
memDC->SetTextColor(RGB(255,0,0));
|
else
|
memDC->SetTextColor(RGB(0,255,0));
|
|
CRect rtCircleArea = pSideData->m_rtTopCornerResult[1];
|
CPoint ptPos = rtCircleArea.CenterPoint();
|
ptPos.x = rtCircleArea.left;
|
CPoint ptPos_wnd = GetWndPos(ptPos);
|
|
CString strTemp;
|
strTemp.Format(_T("Corner Width %d um, Height %d um"), pSideData->m_nTopCornerWidth,pSideData->m_nTopCornerHeight);
|
CRect rtTemp(ptPos_wnd.x + 10, ptPos_wnd.y-10, ptPos_wnd.x + 1024, ptPos_wnd.y + 20);
|
memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
if(pSideData->m_bBotCorner_Measure == TRUE)
|
{
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].right,pSideData->m_rtBottomCornerResult[1].bottom + 20);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].right,pSideData->m_rtBottomCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom + 10);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].right,pSideData->m_rtBottomCornerResult[1].bottom + 10);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 20,pSideData->m_rtBottomCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 20,pSideData->m_rtBottomCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left,pSideData->m_rtBottomCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 10,pSideData->m_rtBottomCornerResult[1].top);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->MoveTo(ptDraw.x,ptDraw.y);
|
|
ptPoint = CPoint(pSideData->m_rtBottomCornerResult[1].left - 10,pSideData->m_rtBottomCornerResult[1].bottom);
|
ptDraw = GetWndPos(ptPoint);
|
memDC->LineTo(ptDraw.x,ptDraw.y);
|
|
if(pSideData->m_bBottomMeasureResult == FALSE)
|
memDC->SetTextColor(RGB(255,0,0));
|
else
|
memDC->SetTextColor(RGB(0,255,0));
|
|
CRect rtCircleArea = pSideData->m_rtBottomCornerResult[1];
|
CPoint ptPos = rtCircleArea.CenterPoint();
|
ptPos.x = rtCircleArea.left;
|
CPoint ptPos_wnd = GetWndPos(ptPos);
|
|
CString strTemp;
|
strTemp.Format(_T("Corner Width %d um, Height %d um"), pSideData->m_nBottomCornerWidth,pSideData->m_nBottomCornerHeight);
|
CRect rtTemp(ptPos_wnd.x + 10, ptPos_wnd.y-10, ptPos_wnd.x + 1024, ptPos_wnd.y + 20);
|
memDC->DrawText(strTemp, rtTemp, DT_LEFT | DT_BOTTOM);
|
}
|
}
|
else if(pSideData->m_nTopCornerShape == 2) // RCUT
|
{
|
memDC->SelectObject(&pen);
|
|
// Out Line
|
CRect rtCircle_wnd;
|
rtCircle_wnd.left = rtCornerPos_wnd.left;
|
rtCircle_wnd.top = rtCornerPos_wnd.top;
|
rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_wnd.Width() * 2);
|
rtCircle_wnd.bottom = rtCircle_wnd.top + (rtCornerPos_wnd.Height() * 2);
|
|
CPoint ptCorner_LB = CPoint(rtCornerPos_wnd.left, rtCornerPos_wnd.bottom);
|
CPoint ptCorner_RT = CPoint(rtCornerPos_wnd.right, rtCornerPos_wnd.top);
|
|
memDC->Arc(rtCircle_wnd, ptCorner_RT, ptCorner_LB);
|
|
// Ins Line
|
rtCircle_wnd.left = rtCornerPos_Ins_wnd.left;
|
rtCircle_wnd.top = rtCornerPos_Ins_wnd.top;
|
rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Ins_wnd.Width() * 2);
|
rtCircle_wnd.bottom = rtCircle_wnd.top + (rtCornerPos_Ins_wnd.Height() * 2);
|
|
CPoint ptCorner_Ins_LB = CPoint(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.bottom);
|
CPoint ptCorner_Ins_RT = CPoint(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.top);
|
|
memDC->Arc(rtCircle_wnd, ptCorner_Ins_RT, ptCorner_Ins_LB);
|
|
// Offset Line
|
rtCircle_wnd.left = rtCornerPos_Offset_wnd.left;
|
rtCircle_wnd.top = rtCornerPos_Offset_wnd.top;
|
rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Offset_wnd.Width() * 2);
|
rtCircle_wnd.bottom = rtCircle_wnd.top + (rtCornerPos_Offset_wnd.Height() * 2);
|
|
CPoint ptCorner_Offset_LB = CPoint(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.bottom);
|
CPoint ptCorner_Offset_RT = CPoint(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.top);
|
|
memDC->SelectObject(&pen_OffsetLine);
|
memDC->Arc(rtCircle_wnd, ptCorner_Offset_RT, ptCorner_Offset_LB);
|
}
|
}
|
|
if(pSideData->m_bBotMark_Find == TRUE)
|
{
|
CRect rtCornerPos_pxl = pSideData->m_rtBotCornerArea;
|
CRect rtCornerPos_wnd = GetWndPos(rtCornerPos_pxl);
|
|
CRect rtCornerPos_Offset_pxl = pSideData->m_rtBotCornerArea_Offset;
|
CRect rtCornerPos_Offset_wnd = GetWndPos(rtCornerPos_Offset_pxl);
|
CRect rtCornerPos_Ins_pxl = pSideData->m_rtBotCornerArea_Ins;
|
CRect rtCornerPos_Ins_wnd = GetWndPos(rtCornerPos_Ins_pxl);
|
|
if(pSideData->m_nBotCornerShape == 0) // None
|
{
|
memDC->SelectObject(&pen);
|
|
memDC->Rectangle(rtCornerPos_wnd);
|
memDC->Rectangle(rtCornerPos_Ins_wnd);
|
|
memDC->SelectObject(&pen_OffsetLine);
|
memDC->Rectangle(rtCornerPos_Offset_wnd);
|
}
|
else if(pSideData->m_nBotCornerShape == 1) // CCUT
|
{
|
memDC->SelectObject(&pen);
|
|
// Corner Line
|
memDC->MoveTo(rtCornerPos_wnd.left, rtCornerPos_wnd.top);
|
memDC->LineTo(rtCornerPos_wnd.right, rtCornerPos_wnd.bottom);
|
|
// Ins Line
|
memDC->MoveTo(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.top);
|
memDC->LineTo(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.bottom);
|
|
// Offset Line
|
memDC->SelectObject(&pen_OffsetLine);
|
memDC->MoveTo(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.top);
|
memDC->LineTo(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.bottom);
|
}
|
else if(pSideData->m_nBotCornerShape == 2) // RCUT
|
{
|
memDC->SelectObject(&pen);
|
|
// Out Line
|
CRect rtCircle_wnd;
|
rtCircle_wnd.left = rtCornerPos_wnd.left;
|
rtCircle_wnd.bottom = rtCornerPos_wnd.bottom;
|
rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_wnd.Width() * 2);
|
rtCircle_wnd.top = rtCircle_wnd.bottom - (rtCornerPos_wnd.Height() * 2);
|
|
CPoint ptCorner_LT = CPoint(rtCornerPos_wnd.left, rtCornerPos_wnd.top);
|
CPoint ptCorner_RB = CPoint(rtCornerPos_wnd.right, rtCornerPos_wnd.bottom);
|
|
memDC->Arc(rtCircle_wnd, ptCorner_LT, ptCorner_RB);
|
|
// Ins Line
|
rtCircle_wnd.left = rtCornerPos_Ins_wnd.left;
|
rtCircle_wnd.bottom = rtCornerPos_Ins_wnd.bottom;
|
rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Ins_wnd.Width() * 2);
|
rtCircle_wnd.top = rtCircle_wnd.bottom - (rtCornerPos_Ins_wnd.Height() * 2);
|
|
CPoint ptCorner_Ins_LT = CPoint(rtCornerPos_Ins_wnd.left, rtCornerPos_Ins_wnd.top);
|
CPoint ptCorner_Ins_RB = CPoint(rtCornerPos_Ins_wnd.right, rtCornerPos_Ins_wnd.bottom);
|
|
memDC->Arc(rtCircle_wnd, ptCorner_Ins_LT, ptCorner_Ins_RB);
|
|
// Offset Line
|
rtCircle_wnd.left = rtCornerPos_Offset_wnd.left;
|
rtCircle_wnd.bottom = rtCornerPos_Offset_wnd.bottom;
|
rtCircle_wnd.right = rtCircle_wnd.left + (rtCornerPos_Offset_wnd.Width() * 2);
|
rtCircle_wnd.top = rtCircle_wnd.bottom - (rtCornerPos_Offset_wnd.Height() * 2);
|
|
CPoint ptCorner_Offset_LT = CPoint(rtCornerPos_Offset_wnd.left, rtCornerPos_Offset_wnd.top);
|
CPoint ptCorner_Offset_RB = CPoint(rtCornerPos_Offset_wnd.right, rtCornerPos_Offset_wnd.bottom);
|
|
memDC->SelectObject(&pen_OffsetLine);
|
memDC->Arc(rtCircle_wnd, ptCorner_Offset_LT, ptCorner_Offset_RB);
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(brush_Null);
|
brush_Null.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_Mark(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_MARK_AREA] == FALSE)
|
return;
|
|
CPen pen(PS_SOLID, 1,RGB(0,255,255));
|
CPen pen_SearchArea(PS_DASH, 1,RGB(255,255,0));
|
CPen pen_TopToBotLine(PS_DASH, 1,RGB(255,0,255));
|
|
CBrush brush_Null;
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
CPen* pOldPen = memDC->SelectObject(&pen);
|
CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);
|
|
CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
|
if(pSideData == NULL)
|
return;
|
|
if(pSideData->m_bTopMark_Find == TRUE)
|
{
|
CRect rtMarkPos_pxl = pSideData->m_rtTopMark_FindResult;
|
CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
|
CRect rtMarkSearchPos_pxl = pSideData->m_rtTopMark_SearchArea;
|
CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkSearchPos_pxl);
|
|
CPoint ptMarkPos_wnd = rtMarkPos_wnd.CenterPoint();
|
int nHalfW_wnd = rtMarkPos_wnd.Width() / 2;
|
int nHalfH_wnd = rtMarkPos_wnd.Height() / 2;
|
|
memDC->SelectObject(&pen);
|
memDC->MoveTo(ptMarkPos_wnd.x-nHalfW_wnd , ptMarkPos_wnd.y);
|
memDC->LineTo(ptMarkPos_wnd.x+nHalfW_wnd , ptMarkPos_wnd.y);
|
memDC->MoveTo(ptMarkPos_wnd.x , ptMarkPos_wnd.y-nHalfH_wnd);
|
memDC->LineTo(ptMarkPos_wnd.x , ptMarkPos_wnd.y+nHalfH_wnd);
|
memDC->Rectangle(rtMarkPos_wnd);
|
|
memDC->SelectObject(&pen_SearchArea);
|
memDC->Rectangle(rtMarkSearchPos_wnd);
|
}
|
|
if(pSideData->m_bBotMark_Find == TRUE)
|
{
|
CRect rtMarkPos_pxl = pSideData->m_rtBotMark_FindResult;
|
CRect rtMarkPos_wnd = GetWndPos(rtMarkPos_pxl);
|
CRect rtMarkSearchPos_pxl = pSideData->m_rtBotMark_SearchArea;
|
CRect rtMarkSearchPos_wnd = GetWndPos(rtMarkSearchPos_pxl);
|
|
CPoint ptMarkPos_wnd = rtMarkPos_wnd.CenterPoint();
|
int nHalfW_wnd = rtMarkPos_wnd.Width() / 2;
|
int nHalfH_wnd = rtMarkPos_wnd.Height() / 2;
|
|
memDC->SelectObject(&pen);
|
memDC->MoveTo(ptMarkPos_wnd.x-nHalfW_wnd , ptMarkPos_wnd.y);
|
memDC->LineTo(ptMarkPos_wnd.x+nHalfW_wnd , ptMarkPos_wnd.y);
|
memDC->MoveTo(ptMarkPos_wnd.x , ptMarkPos_wnd.y-nHalfH_wnd);
|
memDC->LineTo(ptMarkPos_wnd.x , ptMarkPos_wnd.y+nHalfH_wnd);
|
memDC->Rectangle(rtMarkPos_wnd);
|
|
memDC->SelectObject(&pen_SearchArea);
|
memDC->Rectangle(rtMarkSearchPos_wnd);
|
}
|
|
if(pSideData->m_bTopMark_Find == TRUE && pSideData->m_bBotMark_Find == TRUE)
|
{
|
|
memDC->SelectObject(&pen_TopToBotLine);
|
CPoint ptTopMark = pSideData->m_ptTopMark_FindResult;
|
CPoint ptBotMark = pSideData->m_ptBotMark_FindResult;
|
CPoint ptTopMark_Wnd = GetWndPos(ptTopMark);
|
CPoint ptBotMark_Wnd = GetWndPos(ptBotMark);
|
memDC->MoveTo(ptTopMark_Wnd.x, ptTopMark_Wnd.y);
|
memDC->LineTo(ptBotMark_Wnd.x, ptBotMark_Wnd.y);
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
brush_Null.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_UserDefectArea(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_USER_DEFECT_AREA] == FALSE)
|
return;
|
|
CPen penRed(PS_SOLID, 2, RGB(255,255,0)), *pOldPen;
|
CBrush hackBrush,*pOldBrush;
|
CRect rc,rc1;
|
hackBrush.CreateHatchBrush(HS_BDIAGONAL, RGB(0,255,255));
|
|
pOldPen = memDC->SelectObject(&penRed);
|
pOldBrush = memDC->SelectObject(&hackBrush);
|
|
memDC->SetTextColor(RGB(0,0,255));
|
|
int nUserDefectAreaCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nUserDefectAreaCount;
|
|
for(int i=0; i<nUserDefectAreaCount; i++)
|
{
|
CRect rtUserDefectArea_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtUserDefectArea_pxl[i];
|
CRect rtUserDefectArea_wnd = GetWndPos(rtUserDefectArea_pxl);
|
|
if(rtUserDefectArea_wnd.IsRectEmpty() != TRUE && rtUserDefectArea_wnd.IsRectNull() != TRUE)
|
{
|
memDC->Rectangle(rtUserDefectArea_wnd);
|
|
CString strTemp;
|
strTemp.Format(_T("User Defect Area [%d]"), i+1);
|
memDC->TextOut(rtUserDefectArea_wnd.left, rtUserDefectArea_wnd.top - 20, strTemp);
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
|
hackBrush.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_ExceptionArea(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_EXCEPTION_AREA] == FALSE)
|
return;
|
|
CPen penRed(PS_SOLID, 2, RGB(255,0,0)), *pOldPen;
|
CBrush hackBrush,*pOldBrush;
|
CRect rc,rc1;
|
hackBrush.CreateHatchBrush(HS_DIAGCROSS, RGB(0,255,255));
|
|
pOldPen = memDC->SelectObject(&penRed);
|
pOldBrush = memDC->SelectObject(&hackBrush);
|
|
memDC->SetTextColor(RGB(0,0,255));
|
|
int nExceptionAreaCount = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_nExceptionAreaCount;
|
|
for(int i=0; i<nExceptionAreaCount; i++)
|
{
|
CRect rtExceptionArea_pxl = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx)->m_rtExceptionArea_pxl[i];
|
CRect rtExceptionArea_wnd = GetWndPos(rtExceptionArea_pxl);
|
|
if(rtExceptionArea_wnd.IsRectEmpty() != TRUE && rtExceptionArea_wnd.IsRectNull() != TRUE)
|
{
|
memDC->Rectangle(rtExceptionArea_wnd);
|
|
CString strTemp;
|
strTemp.Format(_T("Exception Area [%d]"), i+1);
|
memDC->TextOut(rtExceptionArea_wnd.left, rtExceptionArea_wnd.top - 20, strTemp);
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
|
hackBrush.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_StartEndLine(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_START_END_LINE] == FALSE)
|
return;
|
|
CPen pen(PS_SOLID, 2,RGB(0,0,255));
|
CPen pen_PreEndLine(PS_SOLID, 1,RGB(0,255,255));
|
CPen* pOldPen = memDC->SelectObject(&pen);
|
|
memDC->SetTextColor(RGB(0,0,255));
|
|
CString strTmp;
|
int nFrameIndex = m_ptDisplayStart_pxl.y / m_nFrameHeight;
|
|
CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
|
if(pSideData == NULL)
|
return;
|
|
if(pSideData->m_bFindGlassStartLine == TRUE)
|
{
|
if(pSideData->m_nGlassStartLine > 0)
|
{
|
int nDrawLine = int((pSideData->m_nGlassStartLine - m_ptDisplayStart_pxl.y) * m_dZoom);
|
if( nDrawLine > -1 )
|
{
|
memDC->MoveTo(0,nDrawLine);
|
memDC->LineTo(m_rtWnd.Width(),nDrawLine);
|
|
strTmp.Format(_T("Find Start Line"));
|
memDC->TextOut(10,nDrawLine-20,strTmp);
|
}
|
}
|
|
if(pSideData->m_nCenterJudgeArea_Start > 0)
|
{
|
int nDrawLine = int((pSideData->m_nCenterJudgeArea_Start - m_ptDisplayStart_pxl.y) * m_dZoom);
|
if( nDrawLine > -1 )
|
{
|
memDC->MoveTo(0,nDrawLine);
|
memDC->LineTo(m_rtWnd.Width(),nDrawLine);
|
|
strTmp.Format(_T("Judge Area 1"));
|
memDC->TextOut(10,nDrawLine-20,strTmp);
|
}
|
}
|
|
if(pSideData->m_nCenterJudgeArea_End > 0)
|
{
|
int nDrawLine = int((pSideData->m_nCenterJudgeArea_End - m_ptDisplayStart_pxl.y) * m_dZoom);
|
if( nDrawLine > -1 )
|
{
|
memDC->MoveTo(0,nDrawLine);
|
memDC->LineTo(m_rtWnd.Width(),nDrawLine);
|
|
strTmp.Format(_T("Judge Area 2"));
|
memDC->TextOut(10,nDrawLine-20,strTmp);
|
}
|
}
|
|
if(pSideData->m_nPreGlassEndLine > 0)
|
{
|
memDC->SelectObject(&pen_PreEndLine);
|
|
int nDrawLine = int((pSideData->m_nPreGlassEndLine - m_ptDisplayStart_pxl.y) * m_dZoom);
|
if( nDrawLine > -1 )
|
{
|
memDC->MoveTo(0,nDrawLine);
|
memDC->LineTo(m_rtWnd.Width(),nDrawLine);
|
}
|
}
|
}
|
|
if(pSideData->m_bFindGlassEndLine == TRUE)
|
{
|
if(pSideData->m_nGlassEndLine > 0)
|
{
|
memDC->SelectObject(&pen);
|
|
int nDrawLine = int((pSideData->m_nGlassEndLine - m_ptDisplayStart_pxl.y) * m_dZoom);
|
if( nDrawLine > -1 )
|
{
|
memDC->MoveTo(0,nDrawLine);
|
memDC->LineTo(m_rtWnd.Width(),nDrawLine);
|
|
strTmp.Format(_T("Find End Line"));
|
memDC->TextOut(10,nDrawLine+20,strTmp);
|
}
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
}
|
|
void CEdgeImageViewer::UpdateView_Defect(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_DEFECT] == false)
|
return;
|
|
CPen pen_NG(PS_SOLID, 1, RGB(255,0,0));
|
CPen pen_OK(PS_SOLID, 1, RGB(0,255,0));
|
CBrush brush_Null;
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);
|
|
int nDefect = m_pGlassData->GetDefectCount_NG();
|
CDefect* pDefect = NULL;
|
|
CPen* pOldPen = memDC->SelectObject(&pen_NG);
|
|
// Draw NG
|
for(int iDefect = 0; iDefect < m_pGlassData->GetDefectCount_NG(); iDefect++)
|
{
|
pDefect = m_pGlassData->GetDefect_NG(iDefect);
|
|
if(pDefect == NULL)
|
continue;
|
|
if(pDefect->m_DefectInfo.m_nSideIdx != m_nSideIdx)
|
continue;
|
|
CRect rtPos_Wnd = GetWndPos(pDefect->m_DefectInfo.m_rtDefectPos_pxl);
|
|
CRect rtIntersect;
|
rtIntersect.IntersectRect(rtPos_Wnd, m_rtWnd);
|
|
if(rtIntersect.IsRectEmpty() || rtIntersect.IsRectNull())
|
continue;
|
|
memDC->Rectangle(rtIntersect);
|
}
|
|
// Draw OK
|
nDefect = m_pGlassData->GetDefectCount_OK();
|
memDC->SelectObject(&pen_OK);
|
|
for(int iDefect = 0; iDefect < m_pGlassData->GetDefectCount_OK(); iDefect++)
|
{
|
pDefect = m_pGlassData->GetDefect_OK(iDefect);
|
|
if(pDefect == NULL)
|
continue;
|
|
if(pDefect->m_DefectInfo.m_nSideIdx != m_nSideIdx)
|
continue;
|
|
CRect rtPos_Wnd = GetWndPos(pDefect->m_DefectInfo.m_rtDefectPos_pxl);
|
|
CRect rtIntersect;
|
rtIntersect.IntersectRect(rtPos_Wnd, m_rtWnd);
|
|
if(rtIntersect.IsRectEmpty() || rtIntersect.IsRectNull())
|
continue;
|
|
memDC->Rectangle(rtIntersect);
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
brush_Null.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_ManualMeasure(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_USER_SELECT] == false)
|
return;
|
|
CPen pen_Complete(PS_SOLID, 1, RGB(0,255,255));
|
CPen pen_Modify(PS_SOLID, 1, RGB(255,0,0));
|
CPen pen_MeasureLine(PS_DOT, 1, RGB(255,255,0));
|
CPen pen_Measure_Point(PS_SOLID, 1, RGB(255,255,0));
|
|
CPen *pOldPen;
|
|
if(m_ManualMeasureStatus.bModifyStart == TRUE || m_ManualMeasureStatus.bModifyEnd == TRUE || m_ManualMeasureStatus.bStart == TRUE)
|
pOldPen = (CPen*)memDC->SelectObject(&pen_Modify);
|
else
|
pOldPen = (CPen*)memDC->SelectObject(&pen_Complete);
|
|
CPoint ptStart_Wnd = GetWndPos(m_ManualMeasureStatus.ptMeasureStart);
|
CPoint ptEnd_Wnd = GetWndPos(m_ManualMeasureStatus.ptMeasureEnd);
|
int nDistanceX_Wnd = abs(ptStart_Wnd.x - ptEnd_Wnd.x);
|
int nDistanceY_wnd = abs(ptStart_Wnd.y - ptEnd_Wnd.y);
|
|
// Line
|
memDC->MoveTo(0 , ptStart_Wnd.y);
|
memDC->LineTo(m_rtWnd.Width() , ptStart_Wnd.y);
|
memDC->MoveTo(ptStart_Wnd.x , 0);
|
memDC->LineTo(ptStart_Wnd.x , m_rtWnd.Height());
|
memDC->MoveTo(0 , ptEnd_Wnd.y);
|
memDC->LineTo(m_rtWnd.Width() , ptEnd_Wnd.y);
|
memDC->MoveTo(ptEnd_Wnd.x , 0);
|
memDC->LineTo(ptEnd_Wnd.x , m_rtWnd.Height());
|
|
// Measure Line
|
(CPen*)memDC->SelectObject(&pen_MeasureLine);
|
memDC->MoveTo(ptStart_Wnd.x , ptStart_Wnd.y);
|
memDC->LineTo(ptEnd_Wnd.x , ptEnd_Wnd.y);
|
memDC->MoveTo((ptStart_Wnd.x + ptEnd_Wnd.x)/2 , ptStart_Wnd.y);
|
memDC->LineTo((ptStart_Wnd.x + ptEnd_Wnd.x)/2 , ptEnd_Wnd.y);
|
memDC->MoveTo(ptStart_Wnd.x , (ptStart_Wnd.y + ptEnd_Wnd.y)/2);
|
memDC->LineTo(ptEnd_Wnd.x , (ptStart_Wnd.y + ptEnd_Wnd.y)/2);
|
memDC->MoveTo(ptStart_Wnd.x - 5, ptStart_Wnd.y - 5);
|
memDC->LineTo(ptStart_Wnd.x + 5, ptStart_Wnd.y + 5);
|
memDC->MoveTo(ptStart_Wnd.x + 5, ptStart_Wnd.y - 5);
|
memDC->LineTo(ptStart_Wnd.x - 5, ptStart_Wnd.y + 5);
|
memDC->MoveTo(ptEnd_Wnd.x - 5, ptEnd_Wnd.y - 5);
|
memDC->LineTo(ptEnd_Wnd.x + 5, ptEnd_Wnd.y + 5);
|
memDC->MoveTo(ptEnd_Wnd.x + 5, ptEnd_Wnd.y - 5);
|
memDC->LineTo(ptEnd_Wnd.x - 5, ptEnd_Wnd.y + 5);
|
|
// Circle Line
|
CRect rtCircle;
|
rtCircle.left = ptStart_Wnd.x - nDistanceX_Wnd;
|
rtCircle.top = ptStart_Wnd.y - nDistanceY_wnd;
|
rtCircle.right = rtCircle.left + (nDistanceX_Wnd * 2);
|
rtCircle.bottom = rtCircle.top + (nDistanceY_wnd * 2);
|
memDC->Arc(rtCircle, CPoint(rtCircle.left, rtCircle.CenterPoint().y), CPoint(rtCircle.left, rtCircle.CenterPoint().y));
|
|
/* ¿µ¿ª ¾ÈÀÇ 1/4 ¿ø¸¸ º¸ÀÌ°í ½ÍÀ»¶§..
|
if((ptEnd_Wnd.x < ptStart_Wnd.x && ptEnd_Wnd.y < ptStart_Wnd.y) || (ptEnd_Wnd.x > ptStart_Wnd.x && ptEnd_Wnd.y > ptStart_Wnd.y))
|
memDC->Arc(rtCircle, CPoint(rtCircle.CenterPoint().x, ptEnd_Wnd.y), CPoint(ptEnd_Wnd.x, rtCircle.CenterPoint().y));
|
else
|
memDC->Arc(rtCircle, CPoint(ptEnd_Wnd.x, rtCircle.CenterPoint().y), CPoint(rtCircle.CenterPoint().x, ptEnd_Wnd.y));
|
*/
|
|
// Start, End Point
|
(CPen*)memDC->SelectObject(&pen_Measure_Point);
|
if(m_ManualMeasureStatus.bModifyStart) m_ManualMeasureStatus.nTextPos = 0;
|
else if(m_ManualMeasureStatus.bModifyEnd || m_ManualMeasureStatus.bStart) m_ManualMeasureStatus.nTextPos = 1;
|
else;
|
|
CRect rtArea_Wnd(ptStart_Wnd.x, ptStart_Wnd.y, ptEnd_Wnd.x, ptEnd_Wnd.y);
|
rtArea_Wnd.NormalizeRect();
|
|
memDC->SetBkMode(TRANSPARENT);
|
memDC->SetTextColor(RGB(255,0,0));
|
|
int nDistanceX_pxl = abs(m_ManualMeasureStatus.ptMeasureStart.x - m_ManualMeasureStatus.ptMeasureEnd.x);
|
double dDistanceX_mm = nDistanceX_pxl * m_dPixelSizeX / 1000.0;
|
|
int nDistanceY_pxl = abs(m_ManualMeasureStatus.ptMeasureStart.y - m_ManualMeasureStatus.ptMeasureEnd.y);
|
double dDistanceY_mm = nDistanceY_pxl * m_dPixelSizeY / 1000.0;
|
|
double dDistanceD_mm = sqrtf(float(dDistanceX_mm *dDistanceX_mm + dDistanceY_mm*dDistanceY_mm));
|
double dAngleD_degree = (dDistanceY_mm == 0) ? 0.0 : VIEWER_ToDegree(atan2(dDistanceX_mm, dDistanceY_mm));
|
|
CString strTemp;
|
memDC->SetTextColor(RGB(255,0,0));
|
strTemp.Format(_T("X : %4.3f mm [%d pixel]"), dDistanceX_mm , nDistanceX_pxl);
|
memDC->TextOut( rtArea_Wnd.right + 5, rtArea_Wnd.bottom, strTemp);
|
|
memDC->SetTextColor(RGB(0,255,0));
|
strTemp.Format(_T("Y : %4.3f mm [%d pixel]"), dDistanceY_mm, nDistanceY_pxl);
|
memDC->TextOut( rtArea_Wnd.right + 5, rtArea_Wnd.bottom + 15 ,strTemp);
|
|
memDC->SetTextColor(RGB(0,255,255));
|
strTemp.Format(_T("D : %4.3f mm [%4.3f degree] "), dDistanceD_mm, dAngleD_degree);
|
memDC->TextOut( rtArea_Wnd.right + 5, rtArea_Wnd.bottom + 30 ,strTemp);
|
|
memDC->SelectObject(pOldPen);
|
memDC->SetROP2(R2_COPYPEN);
|
}
|
|
void CEdgeImageViewer::UpdateView_MeasureSideDimensionResult(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL || m_pGlassData == NULL)
|
return;
|
|
CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) m_nSideIdx);
|
|
if(pSideData == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_INSPECT_SIDE_DIMENSION] == FALSE)
|
return;
|
|
COLORREF colorOK = RGB(0,255,0);
|
COLORREF colorNG = RGB(255,0,0);
|
|
CPen pen_OK(PS_SOLID, 1, colorOK);
|
CPen pen_NG(PS_SOLID, 1, colorNG);
|
|
CBrush brush_Null;
|
brush_Null.CreateStockObject(NULL_BRUSH);
|
|
CPen* pOldPen = (CPen*) memDC->SelectObject(&pen_OK);
|
CBrush* pOldBrush = (CBrush*) memDC->SelectObject(&brush_Null);
|
|
CString strComment;
|
|
for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_DIMENSION_MEASURE_COUNT; nMeasureIdx++)
|
{
|
// Dimension
|
int nMeasureResult = pSideData->m_nSideMeasure_CutLine_Status[nMeasureIdx];
|
|
if(nMeasureResult != 0)
|
{
|
if(nMeasureResult == 1)
|
{
|
memDC->SetTextColor(colorOK);
|
memDC->SelectObject(&pen_OK);
|
}
|
else
|
{
|
memDC->SetTextColor(colorNG);
|
memDC->SelectObject(&pen_NG);
|
}
|
|
CPoint ptAlignLine = pSideData->m_ptSideMeasure_Start[nMeasureIdx];
|
CPoint ptAlignLine_wnd = GetWndPos(ptAlignLine);
|
CPoint ptCutLine = pSideData->m_ptSideMeasure_CutLine[nMeasureIdx];
|
CPoint ptCutLine_wnd = GetWndPos(ptCutLine);
|
|
memDC->MoveTo(ptAlignLine_wnd.x-5 , ptAlignLine_wnd.y-5);
|
memDC->LineTo(ptAlignLine_wnd.x+5 , ptAlignLine_wnd.y+5);
|
memDC->MoveTo(ptAlignLine_wnd.x+5 , ptAlignLine_wnd.y-5);
|
memDC->LineTo(ptAlignLine_wnd.x-5 , ptAlignLine_wnd.y+5);
|
|
strComment.Format(_T("S_D_[%d] : %4.3f mm"), nMeasureIdx+1, pSideData->m_dSideMeasrue_CutLine_Result_mm[nMeasureIdx]);
|
memDC->TextOut( ptAlignLine_wnd.x + 5, ptAlignLine_wnd.y + 5, strComment);
|
|
memDC->MoveTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y-5);
|
memDC->LineTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y+5);
|
memDC->MoveTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y-5);
|
memDC->LineTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y+5);
|
|
memDC->MoveTo(ptAlignLine_wnd.x , ptAlignLine_wnd.y);
|
memDC->LineTo(ptCutLine_wnd.x , ptCutLine_wnd.y);
|
}
|
|
// Chamfer
|
nMeasureResult = pSideData->m_nSideMeasure_ChamferLine_Status[nMeasureIdx];
|
|
if(nMeasureResult != 0)
|
{
|
if(nMeasureResult == 1)
|
{
|
memDC->SetTextColor(colorOK);
|
memDC->SelectObject(&pen_OK);
|
}
|
else
|
{
|
memDC->SetTextColor(colorNG);
|
memDC->SelectObject(&pen_NG);
|
}
|
|
CPoint ptCutLine = pSideData->m_ptSideMeasure_CutLine[nMeasureIdx];
|
CPoint ptCutLine_wnd = GetWndPos(ptCutLine);
|
CPoint ptChamferLine = pSideData->m_ptSideMeasure_ChamferLine[nMeasureIdx];
|
CPoint ptChamferLine_wnd = GetWndPos(ptChamferLine);
|
|
memDC->MoveTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y-5);
|
memDC->LineTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y+5);
|
memDC->MoveTo(ptCutLine_wnd.x+5 , ptCutLine_wnd.y-5);
|
memDC->LineTo(ptCutLine_wnd.x-5 , ptCutLine_wnd.y+5);
|
|
memDC->MoveTo(ptChamferLine_wnd.x-5 , ptChamferLine_wnd.y-5);
|
memDC->LineTo(ptChamferLine_wnd.x+5 , ptChamferLine_wnd.y+5);
|
memDC->MoveTo(ptChamferLine_wnd.x+5 , ptChamferLine_wnd.y-5);
|
memDC->LineTo(ptChamferLine_wnd.x-5 , ptChamferLine_wnd.y+5);
|
|
strComment.Format(_T("S_C_[%d] : %4.3f mm"), nMeasureIdx+1, pSideData->m_dSideMeasrue_Chamfer_Result_mm[nMeasureIdx]);
|
memDC->TextOut( ptChamferLine_wnd.x + 5, ptChamferLine_wnd.y + 5, strComment);
|
|
memDC->MoveTo(ptCutLine_wnd.x , ptCutLine_wnd.y);
|
memDC->LineTo(ptCutLine_wnd.x , ptChamferLine_wnd.y);
|
}
|
}
|
|
memDC->SelectObject(pOldPen);
|
memDC->SelectObject(pOldBrush);
|
brush_Null.DeleteObject();
|
}
|
|
void CEdgeImageViewer::UpdateView_Frame(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL)
|
return;
|
|
if(m_MenuStatus[MODE_VIEW_FRAME_IDX] == FALSE)
|
return;
|
|
COLORREF color = RGB(255,150,0);
|
|
CPen pen(PS_SOLID, 1,color);
|
|
CPen* pOldPen = (CPen*) memDC->SelectObject(&pen);
|
|
memDC->SetTextColor(color);
|
|
CString strTemp;
|
|
for(int i=0; i<m_nFrameCount; i++)
|
{
|
int nY_pxl = i * m_nFrameHeight;
|
|
int nY_Wnd = GetWndPosY(nY_pxl);
|
|
if(0 <= nY_Wnd && nY_Wnd < m_rtWnd.Height())
|
{
|
memDC->MoveTo(0, nY_Wnd);
|
memDC->LineTo(5, nY_Wnd);
|
|
strTemp.Format(_T("Frame [%d]"), i);
|
memDC->TextOut(10,nY_Wnd+2,strTemp);
|
}
|
|
}
|
|
memDC->SelectObject(pOldPen);
|
}
|
|
void CEdgeImageViewer::UpdateView_MousePoint(CDC* memDC)
|
{
|
if(m_pBuffer == NULL || memDC == NULL)
|
return;
|
|
#if HALCON_VISION_KEY
|
if (m_MenuStatus[MODE_VIEW_DEFECT] == false)
|
return;
|
|
if (!BlVision_GetVisionRecipe()->getVisionSetOpen())
|
return;
|
#endif // HALCON_VISION_KEY
|
|
CPen pen_Mouse_Point(PS_SOLID, 1, RGB(255, 0, 255));
|
|
CPen *pOldPen;
|
pOldPen = (CPen*)memDC->SelectObject(&pen_Mouse_Point);
|
|
CPoint ptMousePos_Wnd = GetWndPos(m_ptMousePos_Pxl);
|
|
// Line
|
memDC->MoveTo(ptMousePos_Wnd.x - 5, ptMousePos_Wnd.y);
|
memDC->LineTo(ptMousePos_Wnd.x + 5, ptMousePos_Wnd.y);
|
memDC->MoveTo(ptMousePos_Wnd.x, ptMousePos_Wnd.y - 5);
|
memDC->LineTo(ptMousePos_Wnd.x, ptMousePos_Wnd.y + 5);
|
|
#if HALCON_VISION_KEY
|
CPoint ptMarkPos_wnd = GetWndPos(m_ptMouseDown);
|
if (ptMarkPos_wnd.x > 0 && ptMarkPos_wnd.x < m_rtWnd.right && ptMarkPos_wnd.y > 0 && ptMarkPos_wnd.y < m_rtWnd.bottom) {
|
memDC->MoveTo(ptMarkPos_wnd.x - 12, ptMarkPos_wnd.y - 12);
|
memDC->LineTo(ptMarkPos_wnd.x + 12, ptMarkPos_wnd.y + 12);
|
memDC->MoveTo(ptMarkPos_wnd.x + 12, ptMarkPos_wnd.y - 12);
|
memDC->LineTo(ptMarkPos_wnd.x - 12, ptMarkPos_wnd.y + 12);
|
}
|
#endif // HALCON_VISION_KEY
|
|
memDC->SelectObject(pOldPen);
|
}
|
|
CRect CEdgeImageViewer::GetManualMeasureRect()
|
{
|
bool bManualMeasure = m_MenuStatus[MODE_USER_SELECT];
|
|
if(bManualMeasure == false)
|
return CRect(-1,-1,-1,-1);
|
|
CPoint ptStart = m_ManualMeasureStatus.ptMeasureStart;
|
CPoint ptEnd = m_ManualMeasureStatus.ptMeasureEnd;
|
|
CRect rtMeasureArea;
|
rtMeasureArea.left = ptStart.x;
|
rtMeasureArea.top = ptStart.y;
|
rtMeasureArea.right = ptEnd.x;
|
rtMeasureArea.bottom = ptEnd.y;
|
|
rtMeasureArea.NormalizeRect();
|
|
return rtMeasureArea;
|
}
|
|
void CEdgeImageViewer::SetDisplayPos(CPoint ptDisplayStart_pxl)
|
{
|
// CPoint ptTemp = ptDisplayStart_pxl;
|
|
// int nViewWidth_pxl = m_rtWnd.Width() / m_dZoom;
|
// int nViewHeight_pxl = m_rtWnd.Height() / m_dZoom;
|
|
m_ptDisplayStart_pxl = ptDisplayStart_pxl;
|
|
Invalidate(FALSE);
|
|
}
|
|
void CEdgeImageViewer::SetZoom(double dZoom)
|
{
|
m_dZoom = dZoom;
|
|
Invalidate(FALSE);
|
}
|
|
double CEdgeImageViewer::GetZoom()
|
{
|
return m_dZoom;
|
}
|
|
void CEdgeImageViewer::SetViewOption(eModeEdgeImageViewer emOption)
|
{
|
if((int) emOption < 0 || MAX_DISPLAY_SET <= emOption)
|
return;
|
|
m_MenuStatus.set(emOption);
|
Invalidate();
|
}
|
|
void CEdgeImageViewer::ResetViewOption(eModeEdgeImageViewer emOption)
|
{
|
if((int) emOption < 0 || MAX_DISPLAY_SET <= emOption)
|
return;
|
|
m_MenuStatus.reset(emOption);
|
Invalidate();
|
}
|
|
void CEdgeImageViewer::ModifyImageBack()
|
{
|
if(m_MenuStatus[MODE_MODIFY_BRUSH_BLACK] == false)
|
return;
|
|
for(int nY = m_ptMousePos_Pxl.y -20 ; nY < m_ptMousePos_Pxl.y + 20 ; nY++)
|
{
|
for(int nX = m_ptMousePos_Pxl.x -8; nX < m_ptMousePos_Pxl.x + 8 ; nX++)
|
{
|
int nX_pxl = nX;
|
int nY_pxl = nY - m_ptDisplayStart_pxl.y; // Recipe View¿¡¼ Scroll ÇÒ ¶§ ¹öÆÛ À§Ä¡¸¦ ¹Ù²Þ;;;
|
|
if(nX_pxl < 0 || m_nFrameWidth <= nX_pxl)
|
continue;
|
|
if(nY_pxl < 0 || m_nTotalHeight <= nY_pxl)
|
continue;
|
|
m_pBuffer[nY_pxl * m_nFrameWidth + nX_pxl] = 5;
|
}
|
}
|
}
|
|
void CEdgeImageViewer::ModifyImageWhite()
|
{
|
if(m_MenuStatus[MODE_MODIFY_BRUSH_WHITE] == false)
|
return;
|
|
for(int nY = m_ptMousePos_Pxl.y -20 ; nY < m_ptMousePos_Pxl.y + 20 ; nY++)
|
{
|
for(int nX = m_ptMousePos_Pxl.x -8; nX < m_ptMousePos_Pxl.x + 8 ; nX++)
|
{
|
int nX_pxl = nX;
|
int nY_pxl = nY - m_ptDisplayStart_pxl.y; // Recipe View¿¡¼ Scroll ÇÒ ¶§ ¹öÆÛ À§Ä¡¸¦ ¹Ù²Þ;;;
|
|
if(nX_pxl < 0 || m_nFrameWidth <= nX_pxl)
|
continue;
|
|
if(nY_pxl < 0 || m_nTotalHeight <= nY_pxl)
|
continue;
|
|
m_pBuffer[nY_pxl * m_nFrameWidth + nX_pxl] = 250;
|
}
|
}
|
}
|
|
int CEdgeImageViewer::GetWndPosX(int nX_pxl)
|
{
|
return (int) ((nX_pxl - m_ptDisplayStart_pxl.x) * m_dZoom);
|
}
|
|
int CEdgeImageViewer::GetWndPosY(int nY_pxl)
|
{
|
return (int) ((nY_pxl - m_ptDisplayStart_pxl.y) * m_dZoom);
|
}
|
|
CPoint CEdgeImageViewer::GetWndPos(CPoint ptPxl)
|
{
|
CPoint ptReturn;
|
|
ptReturn.x = (int) ((ptPxl.x - m_ptDisplayStart_pxl.x) * m_dZoom);
|
ptReturn.y = (int) ((ptPxl.y - m_ptDisplayStart_pxl.y) * m_dZoom);
|
|
return ptReturn;
|
}
|
|
CRect CEdgeImageViewer::GetWndPos(CRect rtPxl)
|
{
|
CRect rtReturn;
|
|
CPoint ptLT = GetWndPos(rtPxl.TopLeft());
|
CPoint ptRB = GetWndPos(rtPxl.BottomRight());
|
|
rtReturn.left = ptLT.x;
|
rtReturn.top = ptLT.y;
|
rtReturn.right = ptRB.x;
|
rtReturn.bottom = ptRB.y;
|
|
return rtReturn;
|
}
|
|
int CEdgeImageViewer::GetPixlPosX(int nX_Wnd)
|
{
|
return (int) ((((double) nX_Wnd) / m_dZoom) + m_ptDisplayStart_pxl.x);
|
}
|
|
int CEdgeImageViewer::GetPixlPosY(int nY_Wnd)
|
{
|
return (int) ((((double) nY_Wnd) / m_dZoom) + m_ptDisplayStart_pxl.y);
|
}
|
|
CPoint CEdgeImageViewer::GetPxlPos(CPoint ptWnd)
|
{
|
CPoint ptReturn;
|
|
ptReturn.x = (int) ((((double) ptWnd.x) / m_dZoom) + m_ptDisplayStart_pxl.x);
|
ptReturn.y = (int) ((((double) ptWnd.y) / m_dZoom) + m_ptDisplayStart_pxl.y);
|
|
return ptReturn;
|
}
|
|
CRect CEdgeImageViewer::GetPxlPos(CRect rtWnd)
|
{
|
CRect rtReturn;
|
|
CPoint ptLT = GetPxlPos(rtWnd.TopLeft());
|
CPoint ptRB = GetPxlPos(rtWnd.BottomRight());
|
|
rtReturn.left = ptLT.x;
|
rtReturn.top = ptLT.y;
|
rtReturn.right = ptRB.x;
|
rtReturn.bottom = ptRB.y;
|
|
return rtReturn;
|
}
|
|
#if HALCON_VISION_KEY
|
void CEdgeImageViewer::OnLButtonUp(UINT nFlags, CPoint point)
|
{
|
// TODO: ÔÚ´ËÌí¼ÓÏûÏ¢´¦Àí³ÌÐò´úÂëºÍ/»òµ÷ÓÃĬÈÏÖµ
|
m_isMouseDown = FALSE;
|
|
CWnd::OnLButtonUp(nFlags, point);
|
}
|
#endif // HALCON_VISION_KEY
|
