|
// ReveiwHistoryDlg.cpp: 구현 파일
|
//
|
|
#include "stdafx.h"
|
#include "ReveiwHistory.h"
|
#include "ReveiwHistoryDlg.h"
|
#include "PathSettingDlg.h"
|
#include "DitGlassRawStruct.h"
|
#include "afxdialogex.h"
|
#include "GlassRawCPJT.h"
|
#include "akGridCtrl/GridCellCheck.h"
|
#include "akImageView.h"
|
#include <algorithm>
|
|
#ifdef _DEBUG
|
#define new DEBUG_NEW
|
#endif
|
|
// 응용 프로그램 정보에 사용되는 CAboutDlg 대화 상자입니다.
|
|
class CAboutDlg : public CDialogEx
|
{
|
public:
|
CAboutDlg();
|
|
// 대화 상자 데이터입니다.
|
#ifdef AFX_DESIGN_TIME
|
enum { IDD = IDD_ABOUTBOX };
|
#endif
|
|
protected:
|
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 지원입니다.
|
|
// 구현입니다.
|
protected:
|
DECLARE_MESSAGE_MAP()
|
};
|
|
CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
|
{
|
}
|
|
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
|
{
|
CDialogEx::DoDataExchange(pDX);
|
}
|
|
BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
|
END_MESSAGE_MAP()
|
|
// CReveiwHistoryDlg 대화 상자
|
|
CReveiwHistoryDlg::CReveiwHistoryDlg(CWnd* pParent /*=nullptr*/)
|
: CDialogEx(IDD_DLG_REVIEWHISTORY, pParent)
|
, m_nFileCount(0)
|
{
|
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
|
|
AddVecFileHeader();
|
AddVecGlassHeader();
|
AddVecDefectHeader();
|
|
m_nSelectedRow = 0;
|
m_nSelectedCol = 0;
|
m_nCount = 0;
|
m_nGlassSelect = 0;
|
m_bDefectAll = false;
|
m_bFirst = false;
|
m_nSizeDefect = 0;
|
m_nSizeImage = 0;
|
m_nDefectCount = 0;
|
m_nImageCount = 0;
|
m_nCellCount = 0;
|
m_bAsending = FALSE;
|
|
for (int i = 0; i < 105; i++)
|
{
|
m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nCellSize[i] = 0;
|
m_nCellSizeTemp[i] = m_nCellSize[i];
|
m_nImageSize[i] = 0;
|
}
|
}
|
|
void CReveiwHistoryDlg::DoDataExchange(CDataExchange* pDX)
|
{
|
CDialogEx::DoDataExchange(pDX);
|
DDX_Control(pDX, IDC_SLIDER_IMG, m_sldImg);
|
DDX_Control(pDX, IDC_EDIT_COUNT, m_ctrCount);
|
DDX_Control(pDX, IDC_CHK_All_DEFECT, m_chkAllDefect);
|
DDX_Control(pDX, IDC_CHK_REVIEW_DEFECT, m_chkReviewDefect);
|
DDX_Control(pDX, IDC_CHK_MUTI, m_chkMuti);
|
DDX_Control(pDX, IDC_CHK_SINGLE, m_chkSingle);
|
DDX_Control(pDX, IDC_STATIC_IMG_REVIEW, m_ctrReviewImage);
|
DDX_Text(pDX, IDC_EDIT_FILE_COUNT, m_nFileCount);
|
DDX_Control(pDX, IDC_EDIT_FILE_COUNT, m_ctlFileCount);
|
DDX_Control(pDX, IDC_PROGRESS_LOAD, m_ctlProgress);
|
}
|
|
BEGIN_MESSAGE_MAP(CReveiwHistoryDlg, CDialogEx)
|
ON_WM_SYSCOMMAND()
|
ON_WM_PAINT()
|
ON_WM_QUERYDRAGICON()
|
ON_WM_DESTROY()
|
ON_WM_SIZE()
|
ON_WM_HSCROLL()
|
ON_BN_CLICKED(IDC_BUTTON_MAPVIEW_FIT, &CReveiwHistoryDlg::OnBnClickedButtonMapviewFit)
|
ON_MESSAGE(UM_FORMMAP_DEFECTSELECT, OnMapDefectSelected)
|
ON_MESSAGE(UM_FORMMAP_DEFECTMOUSEOVER, OnMapDefectMouseOver)
|
ON_COMMAND(ID_OPTION_PATHSETTING, &CReveiwHistoryDlg::OnOptionPathsetting)
|
ON_COMMAND(ID_VIEW_ALLDEFECT, &CReveiwHistoryDlg::OnViewAlldefect)
|
ON_COMMAND(ID_VIEW_REVIEWDEFECT, &CReveiwHistoryDlg::OnViewReviewdefect)
|
ON_COMMAND(ID_ALIGN_VIEW, &CReveiwHistoryDlg::OnAlignView)
|
ON_BN_CLICKED(IDC_BTN_FIND_BIN, &CReveiwHistoryDlg::OnBnClickedBtnFindBin)
|
ON_EN_CHANGE(IDC_EDIT_COUNT, &CReveiwHistoryDlg::OnChangeEditCount)
|
ON_BN_CLICKED(IDC_BUTTON3, &CReveiwHistoryDlg::OnBnClickedButton3)
|
ON_BN_CLICKED(IDC_CHK_All_DEFECT, &CReveiwHistoryDlg::OnClickedChkAllDefect)
|
ON_BN_CLICKED(IDC_CHK_MUTI, &CReveiwHistoryDlg::OnClickedChkMuti)
|
ON_BN_CLICKED(IDC_CHK_REVIEW_DEFECT, &CReveiwHistoryDlg::OnClickedChkReviewDefect)
|
ON_BN_CLICKED(IDC_CHK_SINGLE, &CReveiwHistoryDlg::OnClickedChkSingle)
|
ON_EN_CHANGE(IDC_EDIT_FILE_COUNT, &CReveiwHistoryDlg::OnChangeEditFileCount)
|
END_MESSAGE_MAP()
|
|
// CReveiwHistoryDlg 메시지 처리기
|
|
BOOL CReveiwHistoryDlg::OnInitDialog()
|
{
|
CDialogEx::OnInitDialog();
|
|
// 시스템 메뉴에 "정보..." 메뉴 항목을 추가합니다.
|
|
// IDM_ABOUTBOX는 시스템 명령 범위에 있어야 합니다.
|
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
|
ASSERT(IDM_ABOUTBOX < 0xF000);
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
if (pSysMenu != nullptr)
|
{
|
BOOL bNameValid;
|
CString strAboutMenu;
|
bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
|
ASSERT(bNameValid);
|
if (!strAboutMenu.IsEmpty())
|
{
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
|
}
|
}
|
|
// 이 대화 상자의 아이콘을 설정합니다. 응용 프로그램의 주 창이 대화 상자가 아닐 경우에는
|
// 프레임워크가 이 작업을 자동으로 수행합니다.
|
SetIcon(m_hIcon, TRUE); // 큰 아이콘을 설정합니다.
|
SetIcon(m_hIcon, FALSE); // 작은 아이콘을 설정합니다.
|
|
GetDlgItem(IDC_STATIC_FORMATIONMAP2)->GetWindowRect(m_picture_rect);
|
GetDlgItem(IDC_STATIC_IMG_INSPECTOR)->GetWindowRect(m_picture_rect2);
|
|
ScreenToClient(m_picture_rect);
|
ScreenToClient(m_picture_rect2);
|
|
GetDlgItem(IDC_STATIC_IMG_ALIGN1)->GetWindowRect(m_Align_rect);
|
GetDlgItem(IDC_STATIC_IMG_ALIGN2)->GetWindowRect(m_Align_rect2);
|
|
ScreenToClient(m_Align_rect);
|
ScreenToClient(m_Align_rect2);
|
|
m_ImageView.CreateGraph(this, m_picture_rect);
|
m_ImageView.SetAutoScale();
|
|
|
// TODO: 여기에 추가 초기화 작업을 추가합니다.
|
if (1)
|
{
|
CRect rectTemp;
|
GetDlgItem(IDC_STATIC_FORMATIONMAP)->GetWindowRect(rectTemp);
|
ScreenToClient(rectTemp);
|
|
m_FormationMap.CreateGraph(this, rectTemp);
|
}
|
|
m_WndArrange.setParentWnd(this);
|
m_WndArrange.addChildWnd(&m_FormationMap, WA_RESIZE_WIDTH | WA_RESIZE_HEIGHT);
|
|
GetDlgItem(IDC_STATIC_FORMATIONMAP)->BringWindowToTop();
|
|
LOG(Dbg, _T("[Processe] Review History Start"));
|
|
CreateUserDirectory();
|
CreateUserClass();
|
|
InitGridReviewLIst(&m_gridReviewList, IDC_STATIC_GRID_GLASS);
|
InitGridDefectLIst(&m_gridDefectInfo, IDC_STATIC_GRID_DEFECT);
|
InitGridGlassLIst(&m_gridGlassInfo, IDC_STATIC_GRID_GLASS_INFO);
|
|
OnViewReviewdefect();
|
|
m_chkReviewDefect.SetCheck(TRUE);
|
m_chkSingle.SetCheck(TRUE);
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
m_ConfigOption.m_nMaxDataNumCell = 200;
|
m_ConfigOption.m_nMaxDataNumDefect = 50000;
|
|
if (m_Server.CreateServer(m_ConfigOption.m_nMaxDataNumCell, m_ConfigOption.m_nMaxDataNumDefect) == FALSE)
|
{
|
LOG(Dbg, _T("[Processe]서버 생성 실패 종료 합니다."));
|
exit(0);
|
}
|
|
m_pGlassRawMaker = NULL;
|
m_ConfigOption.m_nSelectRawType = 3;
|
OnCbnSelchangeComboRawtype();
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
SlideInit();
|
Imagenoload();
|
|
m_ctlProgress.SetRange(0, 100);
|
m_ctlProgress.ShowWindow(FALSE);
|
|
return TRUE; // 포커스를 컨트롤에 설정하지 않으면 TRUE를 반환합니다.
|
}
|
|
void CReveiwHistoryDlg::OnDestroy()
|
{
|
CDialogEx::OnDestroy();
|
|
DestroyUserClass();
|
|
m_Filelistfont.DeleteObject();
|
m_Defectfont.DeleteObject();
|
|
LOG(Dbg, _T("[Processe] Review History End"));
|
}
|
|
void CReveiwHistoryDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
{
|
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
|
{
|
CAboutDlg dlgAbout;
|
dlgAbout.DoModal();
|
}
|
else
|
{
|
CDialogEx::OnSysCommand(nID, lParam);
|
}
|
}
|
|
// 대화 상자에 최소화 단추를 추가할 경우 아이콘을 그리려면
|
// 아래 코드가 필요합니다. 문서/뷰 모델을 사용하는 MFC 응용 프로그램의 경우에는
|
// 프레임워크에서 이 작업을 자동으로 수행합니다.
|
|
void CReveiwHistoryDlg::OnPaint()
|
{
|
CPaintDC dc(this); // 그리기를 위한 디바이스 컨텍스트입니다.
|
|
if (IsIconic())
|
{
|
SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
|
|
// 클라이언트 사각형에서 아이콘을 가운데에 맞춥니다.
|
int cxIcon = GetSystemMetrics(SM_CXICON);
|
int cyIcon = GetSystemMetrics(SM_CYICON);
|
CRect rect;
|
GetClientRect(&rect);
|
int x = (rect.Width() - cxIcon + 1) / 2;
|
int y = (rect.Height() - cyIcon + 1) / 2;
|
|
// 아이콘을 그립니다.
|
dc.DrawIcon(x, y, m_hIcon);
|
}
|
else
|
{
|
// if (!m_ReviewImage.IsNull())
|
// {
|
// dc.SetStretchBltMode(COLORONCOLOR);
|
// // 그림을 Picture Control 크기로 화면에 출력한다.
|
// m_ReviewImage.Draw(dc, m_picture_rect);
|
// }
|
//LYW 20210825 #3486 ADD START
|
if (!m_DefectRotateImage.IsNull())
|
{
|
dc.SetStretchBltMode(COLORONCOLOR);
|
// 그림을 Picture Control 크기로 화면에 출력한다.
|
m_DefectRotateImage.Draw(dc, m_picture_rect2);
|
}
|
//LYW 20210825 #3486 ADD END
|
else if (!m_DefectImage.IsNull())
|
{
|
dc.SetStretchBltMode(COLORONCOLOR);
|
// 그림을 Picture Control 크기로 화면에 출력한다.
|
m_DefectImage.Draw(dc, m_picture_rect2);
|
}
|
|
if (!m_AlignFirst.IsNull())
|
{
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_AlignFirst.Draw(dc, m_Align_rect);
|
}
|
if (!m_AlignSecend.IsNull())
|
{
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_AlignSecend.Draw(dc, m_Align_rect2);
|
}
|
CDialogEx::OnPaint();
|
}
|
}
|
|
// 사용자가 최소화된 창을 끄는 동안에 커서가 표시되도록 시스템에서
|
// 이 함수를 호출합니다.
|
HCURSOR CReveiwHistoryDlg::OnQueryDragIcon()
|
{
|
return static_cast<HCURSOR>(m_hIcon);
|
}
|
|
BOOL CReveiwHistoryDlg::PreTranslateMessage(MSG * pMsg)
|
{
|
POINT pt;
|
|
pt.x = GET_X_LPARAM(pMsg->lParam);
|
pt.y = GET_Y_LPARAM(pMsg->lParam);
|
|
switch (pMsg->message)
|
{
|
case WM_MOUSEHWHEEL:
|
{
|
|
}
|
break;
|
case WM_MOUSEMOVE:
|
{
|
|
}
|
break;
|
case WM_LBUTTONDOWN:
|
{
|
|
// if (m_picture_rect.left < pt.x && m_picture_rect.right > pt.x && m_picture_rect.top < pt.y && m_picture_rect.bottom > pt.y)
|
// {
|
// if (m_pParentWnd == NULL || !GetImageExist()) return;
|
//
|
// if (pt.x > -1 && pt.x < GetScaleWidth() &&
|
// pt.y > -1 && pt.y < GetScaleHeight())
|
// {
|
// if (m_rectTracker.HitTest(pt) < 0)
|
// {
|
// // just to demonstrate CRectTracker::TrackRubberBand
|
// if (m_rectTracker.TrackRubberBand(this, pt, TRUE))
|
// {
|
// Invalidate();
|
// }
|
// }
|
// else if (m_rectTracker.Track(this, pt, TRUE))
|
// {
|
// Invalidate();
|
// }
|
// }
|
//
|
// CRect rect;
|
// this->GetClientRect(rect);
|
//
|
// pt.x += m_nHScroll;
|
// pt.y += m_nVScroll;
|
// m_pParentWnd->SendMessage(WM_LBUTTONDOWN, static_cast<WPARAM>(nFlags), MAKELPARAM(pt.x, pt.y));
|
// }
|
}
|
break;
|
case WM_LBUTTONUP:
|
{
|
// int a = 1;
|
// return 0;
|
// if (m_picture_rect.left < pt.x && m_picture_rect.right > pt.x && m_picture_rect.top < pt.y && m_picture_rect.bottom > pt.y)
|
// {
|
// if (m_pParentWnd == NULL) return;
|
//
|
// CRect rect;
|
// this->GetClientRect(rect);
|
//
|
// pt.x += m_nHScroll;
|
// pt.y += m_nVScroll;
|
// m_pParentWnd->SendMessage(WM_LBUTTONUP, static_cast<WPARAM>(nFlags), MAKELPARAM(pt.x, pt.y));
|
//
|
// if (GetTrackerRect(m_rtROIRect))
|
// {
|
// m_sROIInfo.nWidthPixel = m_rtROIRect.Width();
|
// m_sROIInfo.nHeightPixel = m_rtROIRect.Height();
|
// m_sROIInfo.dDiagonalPixel = sqrt(double(m_sROIInfo.nWidthPixel*m_sROIInfo.nWidthPixel + m_sROIInfo.nHeightPixel*m_sROIInfo.nHeightPixel));
|
//
|
// m_sROIInfo.dWidthRealUM = m_sROIInfo.nWidthPixel * (m_dResolution / m_dWidthScale);
|
// m_sROIInfo.dHeightRealUM = m_sROIInfo.nHeightPixel * (m_dResolution / m_dHeightScale);
|
// m_sROIInfo.dDiagonalRealUM = sqrt((m_sROIInfo.dWidthRealUM*m_sROIInfo.dWidthRealUM) + (m_sROIInfo.dHeightRealUM*m_sROIInfo.dHeightRealUM));
|
//
|
// Invalidate(TRUE);
|
// }
|
// }
|
//Drow 정보를 보낸다.
|
}
|
break;
|
case WM_KEYDOWN:
|
{
|
if (pMsg->wParam == VK_RETURN)
|
return TRUE;
|
else if (pMsg->wParam == VK_ESCAPE)
|
return TRUE;
|
}
|
break;
|
}
|
|
return __super::PreTranslateMessage(pMsg);
|
}
|
|
void CReveiwHistoryDlg::CreateUserDirectory()
|
{
|
CString str;
|
|
str.Format(_T("%s\\Config\\"), GetExePath());
|
CreateDirectory(str, NULL);
|
|
str.Format(_T("%s\\Log\\"), GetExePath());
|
CreateDirectory(str, NULL);
|
|
LOG(Dbg, _T("[Processe] CreateUserDirectory"));
|
}
|
|
void CReveiwHistoryDlg::CreateUserClass()
|
{
|
CPathSettingDlg::CreateClass();
|
CPathSettingDlg::GetMgr()->Create(this);
|
CPathSettingDlg::GetMgr()->PathSettingLoad();
|
|
CAlignDlg::CreateClass();
|
CAlignDlg::GetMgr()->Create(this);
|
|
akDefectFormation::CreateClass();
|
|
LOG(Dbg, _T("[Processe] CreateUserClass"));
|
}
|
|
void CReveiwHistoryDlg::DestroyUserClass()
|
{
|
CPathSettingDlg::GetMgr()->DestroyWindow();
|
CPathSettingDlg::DestroyClass();
|
|
CAlignDlg::GetMgr()->DestroyWindow();
|
CAlignDlg::DestroyClass();
|
|
akDefectFormation::DestroyClass();
|
|
LOG(Dbg, _T("[Processe] DestroyUserClass"));
|
}
|
|
|
void CReveiwHistoryDlg::AddVecFileHeader()
|
{
|
m_vecStrGridReviewHeader.push_back(" NO ");
|
m_vecStrGridReviewHeader.push_back(" Time ");
|
m_vecStrGridReviewHeader.push_back("열기");
|
m_vecStrGridReviewHeader.push_back("PPID");
|
m_vecStrGridReviewHeader.push_back("GLASS ID");
|
m_vecStrGridReviewHeader.push_back("총 결함 갯수");
|
m_vecStrGridReviewHeader.push_back("리뷰 갯수");
|
m_vecStrGridReviewHeader.push_back("Judge");
|
m_vecStrGridReviewHeader.push_back("File Name");
|
}
|
void CReveiwHistoryDlg::AddVecGlassHeader()
|
{
|
m_vecStrGridGlassHeader.push_back("No");
|
m_vecStrGridGlassHeader.push_back("PPID");
|
m_vecStrGridGlassHeader.push_back("Glass ID");
|
m_vecStrGridGlassHeader.push_back("총 결함 갯수");
|
m_vecStrGridGlassHeader.push_back("리뷰 결함 갯수");
|
m_vecStrGridGlassHeader.push_back("Glass Judge");
|
m_vecStrGridGlassHeader.push_back("Lot ID");
|
m_vecStrGridGlassHeader.push_back("Slot ID");
|
m_vecStrGridGlassHeader.push_back("Slot Number");
|
m_vecStrGridGlassHeader.push_back("Cell Number");
|
m_vecStrGridGlassHeader.push_back("Glass Height");
|
m_vecStrGridGlassHeader.push_back("Glass Width");
|
}
|
void CReveiwHistoryDlg::AddVecDefectHeader()
|
{
|
m_vecStrGridDefectHeader.push_back("No");
|
m_vecStrGridDefectHeader.push_back("Idx");
|
m_vecStrGridDefectHeader.push_back("Loc");
|
m_vecStrGridDefectHeader.push_back("Classification");
|
m_vecStrGridDefectHeader.push_back("Code");
|
m_vecStrGridDefectHeader.push_back("Type");
|
m_vecStrGridDefectHeader.push_back("SubType");
|
m_vecStrGridDefectHeader.push_back("Length");
|
m_vecStrGridDefectHeader.push_back("XSize(um)");
|
m_vecStrGridDefectHeader.push_back("YSize(um)");
|
m_vecStrGridDefectHeader.push_back("Area(um)");
|
m_vecStrGridDefectHeader.push_back("Zone");
|
m_vecStrGridDefectHeader.push_back("DMax");
|
m_vecStrGridDefectHeader.push_back("DMin");
|
m_vecStrGridDefectHeader.push_back("DAvg");
|
m_vecStrGridDefectHeader.push_back("Peak");
|
m_vecStrGridDefectHeader.push_back("Step");
|
m_vecStrGridDefectHeader.push_back("Cam");
|
m_vecStrGridDefectHeader.push_back("Scan");
|
m_vecStrGridDefectHeader.push_back("RMax");
|
m_vecStrGridDefectHeader.push_back("RMin");
|
m_vecStrGridDefectHeader.push_back("RAvg");
|
m_vecStrGridDefectHeader.push_back("Xpos(mm)");
|
m_vecStrGridDefectHeader.push_back("Ypos(mm)");
|
m_vecStrGridDefectHeader.push_back("CellX(mm)");
|
m_vecStrGridDefectHeader.push_back("CellY(mm)");
|
m_vecStrGridDefectHeader.push_back("ScrtRatio");
|
m_vecStrGridDefectHeader.push_back("Density");
|
m_vecStrGridDefectHeader.push_back("MergeState");
|
}
|
|
void CReveiwHistoryDlg::SlideInit()
|
{
|
m_sldImg.SetRange(-1, -1);
|
m_sldImg.SetPos(-1);
|
m_sldImg.SetLineSize(3);
|
m_sldImg.SetPageSize(10);
|
|
int nPos = m_sldImg.GetPos();
|
CString strPos;
|
strPos.Format(_T("%d"), nPos);
|
m_ctrCount.SetWindowText(strPos);
|
|
CString strCount;
|
m_ctlFileCount.SetWindowText("100");
|
m_ctlFileCount.GetWindowText(strCount);
|
|
m_nFileCount = _ttoi(strCount);
|
}
|
|
void CReveiwHistoryDlg::InitGridReviewLIst(CakGridCtrl* pGrid, UINT nRectCtrlID)
|
{
|
std::vector<CString>* pVecHeader = &m_vecStrGridReviewHeader;
|
|
CRect rectGrid;
|
GetDlgItem(nRectCtrlID)->GetWindowRect(&rectGrid);
|
ScreenToClient(&rectGrid);
|
pGrid->Create(rectGrid, this, nRectCtrlID);
|
pGrid->GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
|
pGrid->GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
|
pGrid->GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
|
pGrid->SetFixedBkColor(GRID_FIX_COLOR);
|
pGrid->SetGridLines(GVL_BOTH);
|
|
pGrid->SetVirtualMode(FALSE);
|
pGrid->SetCallbackFunc(NULL, 0);
|
pGrid->AllowReorderColumn(FALSE);
|
pGrid->EnableDragRowMode(FALSE);
|
|
pGrid->SetColumnCount((int)pVecHeader->size());
|
pGrid->SetDoubleBuffering(TRUE);
|
pGrid->SetRowCount(2);
|
pGrid->SetFixedRowCount(1);
|
pGrid->SetFixedColumnCount(0);
|
|
pGrid->SetEditable(FALSE);
|
pGrid->EnableSelection(TRUE);
|
pGrid->SetFixedRowSelection(TRUE);
|
pGrid->SetHeaderSort(FALSE);
|
|
// fill it up with stuff
|
pGrid->SetEditable(TRUE);
|
pGrid->EnableDragAndDrop(TRUE);
|
|
int nRowIdx, nColIdx, nRows, nCols, nFixRows, nFixCols;
|
CString strTemp;
|
|
GV_ITEM Item;
|
nRowIdx = 0;
|
nColIdx = 0;
|
Item.mask = GVIF_TEXT;
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T(" No "));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T(" Time "));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("열기"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("PPID"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("GLASS ID"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("총 결함 갯수"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("리뷰 갯수"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("Judge"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = nRowIdx++;
|
Item.col = nColIdx;
|
strTemp.Format(_T("File Name"));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
Item.row = 1;
|
Item.col = 0;
|
strTemp.Format(_T(" "));
|
Item.strText = strTemp;
|
pGrid->SetItem(&Item);
|
|
pGrid->SetCellType(1, 0, RUNTIME_CLASS(CGridCellCheck));
|
|
pGrid->AutoSize();
|
pGrid->Invalidate();
|
|
m_WndArrange.setParentWnd(this);
|
m_WndArrange.addChildWnd(&m_gridReviewList, WA_RESIZE_WIDTH | WA_RESIZE_HEIGHT);
|
}
|
|
void CReveiwHistoryDlg::InitGridGlassLIst(CakGridCtrl* pGrid, UINT nRectCtrlID)
|
{
|
std::vector<CString>* pVecHeader = &m_vecStrGridGlassHeader;
|
|
CRect rectGrid;
|
GetDlgItem(nRectCtrlID)->GetWindowRect(&rectGrid);
|
ScreenToClient(&rectGrid);
|
pGrid->Create(rectGrid, this, nRectCtrlID);
|
|
pGrid->GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
|
pGrid->GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
|
pGrid->GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
|
pGrid->SetFixedBkColor(GRID_FIX_COLOR);
|
pGrid->SetGridLines(GVL_BOTH);
|
|
pGrid->SetVirtualMode(TRUE);
|
pGrid->SetCallbackFunc(NULL, 0);
|
pGrid->AllowReorderColumn(FALSE);
|
pGrid->EnableDragRowMode(FALSE);
|
|
pGrid->SetColumnCount((int)pVecHeader->size());
|
pGrid->SetDoubleBuffering(TRUE);
|
pGrid->SetRowCount(2);
|
pGrid->SetFixedRowCount(1);
|
pGrid->SetFixedColumnCount(0);
|
|
pGrid->SetEditable(FALSE);
|
pGrid->EnableSelection(TRUE);
|
pGrid->SetFixedRowSelection(TRUE);
|
pGrid->SetHeaderSort(FALSE);
|
|
// fill it up with stuff
|
pGrid->SetEditable(TRUE);
|
pGrid->EnableDragAndDrop(TRUE);
|
|
pGrid->AutoSize();
|
pGrid->Invalidate();
|
|
m_WndArrange.setParentWnd(this);
|
m_WndArrange.addChildWnd(&m_gridGlassInfo, WA_RESIZE_WIDTH | WA_RESIZE_HEIGHT);
|
}
|
|
void CReveiwHistoryDlg::InitGridDefectLIst(CakGridCtrl* pGrid, UINT nRectCtrlID)
|
{
|
std::vector<CString>* pVecHeader = &m_vecStrGridDefectHeader;
|
|
CRect rectGrid;
|
GetDlgItem(nRectCtrlID)->GetWindowRect(&rectGrid);
|
ScreenToClient(&rectGrid);
|
pGrid->Create(rectGrid, this, nRectCtrlID);
|
|
pGrid->GetDefaultCell(TRUE, FALSE)->SetBackClr(GRID_FIX_COLOR);
|
pGrid->GetDefaultCell(FALSE, TRUE)->SetBackClr(GRID_FIX_COLOR);
|
pGrid->GetDefaultCell(FALSE, FALSE)->SetBackClr(GRID_COLOR);
|
pGrid->SetFixedBkColor(GRID_FIX_COLOR);
|
pGrid->SetGridLines(GVL_BOTH);
|
|
pGrid->SetVirtualMode(TRUE);
|
pGrid->SetCallbackFunc(NULL, 0);
|
pGrid->AllowReorderColumn(FALSE);
|
pGrid->EnableDragRowMode(FALSE);
|
|
pGrid->SetColumnCount((int)pVecHeader->size());
|
pGrid->SetDoubleBuffering(TRUE);
|
pGrid->SetRowCount(2);
|
pGrid->SetFixedRowCount(1);
|
pGrid->SetFixedColumnCount(0);
|
|
pGrid->SetEditable(FALSE);
|
pGrid->EnableSelection(TRUE);
|
pGrid->SetFixedRowSelection(TRUE);
|
pGrid->SetHeaderSort(FALSE);
|
|
// fill it up with stuff
|
pGrid->SetEditable(TRUE);
|
pGrid->EnableDragAndDrop(TRUE);
|
|
pGrid->AutoSize();
|
pGrid->Invalidate();
|
|
m_WndArrange.setParentWnd(this);
|
m_WndArrange.addChildWnd(&m_gridDefectInfo, WA_RESIZE_WIDTH | WA_RESIZE_HEIGHT);
|
}
|
|
BOOL CReveiwHistoryDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
|
{
|
if (m_gridReviewList.GetSafeHwnd() && wParam == (WPARAM)m_gridReviewList.GetDlgCtrlID())
|
{
|
*pResult = 1;
|
GV_DISPINFO *pDispInfo = (GV_DISPINFO*)lParam;
|
if (GVN_GETDISPINFO == pDispInfo->hdr.code)
|
{
|
getDispInfoGlass(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);
|
|
return TRUE;
|
}
|
else if (NM_CLICK == pDispInfo->hdr.code)
|
{
|
if (pDispInfo->item.row == 0)
|
{
|
m_gridReviewList.Refresh();
|
}
|
else if (pDispInfo->item.row > 0)
|
{
|
CGridCellCheck* pCellCheck = NULL;
|
pCellCheck = (CGridCellCheck*)m_gridReviewList.GetCell(pDispInfo->item.row, 0);
|
BOOL bMultiCheck = pCellCheck->GetCheck();
|
|
if (m_nCount == pDispInfo->item.row)
|
{
|
if (m_chkSingle.GetCheck())
|
{
|
if (pCellCheck != NULL)
|
{
|
pCellCheck->SetCheck(FALSE);
|
}
|
}
|
else
|
{
|
if (pCellCheck != NULL)
|
{
|
pCellCheck->SetCheck(!bMultiCheck);
|
}
|
}
|
return TRUE;
|
}
|
m_nCount = pDispInfo->item.row;
|
m_nGlassSelect = pDispInfo->item.row;
|
|
CGridCellCheck* pCellCheck2 = NULL;
|
pCellCheck2 = (CGridCellCheck*)m_gridReviewList.GetCell(m_nGlassSelect, 0);
|
BOOL bMultiCheck2 = pCellCheck->GetCheck();
|
|
if (m_chkSingle.GetCheck())
|
{
|
if (pCellCheck != NULL)
|
{
|
pCellCheck->SetCheck(FALSE);
|
}
|
GlassInfoRest();
|
BinFileOpen(pDispInfo->item.row);
|
}
|
else if(m_chkMuti.GetCheck())
|
{
|
if (bMultiCheck2 == TRUE)
|
{
|
// if (MultiSelectCheck(pDispInfo->item.row))
|
// {
|
//if(pDispInfo->item.row)
|
bool bCheck = false;
|
for (int i = 0; i < 105; i++)
|
{
|
if (m_nSelectFile[i] == pDispInfo->item.row)
|
{
|
bCheck = true;
|
}
|
}
|
if (!bCheck)
|
{
|
InitSelectGlass(pDispInfo->item.row);
|
BinFileOpen(pDispInfo->item.row);
|
}
|
/* }*/
|
}
|
else if(bMultiCheck == FALSE)
|
{
|
MultiSelectCheck(pDispInfo->item.row);
|
SetScrollSetting();
|
}
|
}
|
}
|
// if (!m_chkSingle.GetCheck())
|
// {
|
// for (int i = 0; i < MAX_COUNT + 1; i++)
|
// {
|
// for (int iCol = 0; iCol < m_gridReviewList.GetColumnCount(); iCol++)
|
// {
|
// m_gridReviewList.SetItemState(m_nSelectFile[i], iCol, LVIS_SELECTED);
|
// }
|
// }
|
// m_gridReviewList.Invalidate();
|
// }
|
m_nSelectedCol = pDispInfo->item.col;
|
}
|
else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
|
{
|
GV_CACHEHINT *pCacheHint = (GV_CACHEHINT*)pDispInfo;
|
}
|
}
|
else if (m_gridGlassInfo.GetSafeHwnd() && wParam == (WPARAM)m_gridGlassInfo.GetDlgCtrlID())
|
{
|
*pResult = 1;
|
GV_DISPINFO *pDispInfo = (GV_DISPINFO*)lParam;
|
if (GVN_GETDISPINFO == pDispInfo->hdr.code)
|
{
|
getDispInfoGlassInfo(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);
|
return TRUE;
|
}
|
else if (NM_CLICK == pDispInfo->hdr.code)
|
{
|
//멀티 모드 일때 선택한 놈의 cell 값을 보여 준다
|
if (!m_chkSingle.GetCheck())
|
{
|
SelectCell(pDispInfo->item.row);
|
}
|
}
|
|
else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
|
{
|
GV_CACHEHINT *pCacheHint = (GV_CACHEHINT*)pDispInfo;
|
}
|
}
|
else if (m_gridDefectInfo.GetSafeHwnd() && wParam == (WPARAM)m_gridDefectInfo.GetDlgCtrlID())
|
{
|
*pResult = 1;
|
GV_DISPINFO *pDispInfo = (GV_DISPINFO*)lParam;
|
if (GVN_GETDISPINFO == pDispInfo->hdr.code)
|
{
|
getDispInfoDefect(pDispInfo->item.col, pDispInfo->item.row, &pDispInfo->item.strText);
|
|
return TRUE;
|
}
|
else if (NM_CLICK == pDispInfo->hdr.code)
|
{
|
if (pDispInfo->item.row == 0)
|
{
|
SortListDefect(pDispInfo->item.col);
|
m_gridDefectInfo.Refresh();
|
}
|
else if (pDispInfo->item.row > 0)
|
{
|
if (pDispInfo->item.row <= m_Formation.m_vecDefects.size())
|
{
|
_akDefect* pDefectInfo = &m_Formation.m_vecDefects[pDispInfo->item.row - 1];
|
|
m_FormationMap.setSelectDefect(pDefectInfo->m_nDefectID);
|
//ImageShow(pDefectInfo->m_nDefectID);
|
if (!m_bDefectAll)
|
{
|
ImageShow(pDispInfo->item.row - 1);
|
}
|
else
|
{
|
ImageShow(pDefectInfo->m_nDefectID);
|
}
|
//멀티 모델일 때와 아닐 때 구분을 하자
|
//정렬 순서를 사용자가 원하는 순으로 하자
|
if (!m_bDefectAll)
|
{
|
m_sldImg.SetPos(pDispInfo->item.row - 1);
|
|
int nPos = m_sldImg.GetPos();
|
CString strPos;
|
strPos.Format(_T("%d"), nPos);
|
m_ctrCount.SetWindowText(strPos);
|
}
|
}
|
}
|
m_nSelectedCol = pDispInfo->item.col;
|
}
|
|
else if (GVN_ODCACHEHINT == pDispInfo->hdr.code)
|
{
|
GV_CACHEHINT *pCacheHint = (GV_CACHEHINT*)pDispInfo;
|
}
|
}
|
|
return CDialog::OnNotify(wParam, lParam, pResult);
|
}
|
|
void CReveiwHistoryDlg::getDispInfoGlass(int nCol, int nRow, CString* pStrData)
|
{
|
if (nRow < 0) return;
|
|
if (nRow == 0)
|
{
|
*pStrData = m_vecStrGridReviewHeader[nCol];
|
}
|
else
|
{
|
CString strItem;
|
int nDataIndex = nRow - 1;
|
|
if (nDataIndex >= m_vecStrGridReviewList.size()) return;
|
|
_akReviewHeader* pDefectInfo = &m_Formation.m_vecHeader[nRow - 1];
|
|
switch (nCol)
|
{
|
case 0: strItem.Format("%d", nRow); break;
|
case 1: strItem.Format("%s", pDefectInfo->m_strFileTime); break;
|
case 2: strItem.Format("%s", pDefectInfo->m_strLoading); break;
|
case 3: strItem.Format("%s", pDefectInfo->m_strPPID); break;
|
case 4: strItem.Format("%s", pDefectInfo->m_strGlassID); break;
|
case 5: strItem.Format("%d", pDefectInfo->m_nDefectIdx); break;
|
case 6: strItem.Format("%d", pDefectInfo->m_nReviewIdx); break;
|
case 7: strItem.Format("%s", pDefectInfo->m_strJudge); break;
|
case 8: strItem.Format("%s", pDefectInfo->m_strFileName); break;
|
}
|
*pStrData = strItem;
|
}
|
}
|
|
void CReveiwHistoryDlg::getDispInfoGlassInfo(int nCol, int nRow, CString* pStrData)
|
{
|
if (nRow < 0) return;
|
|
if (nRow == 0) //header
|
{
|
*pStrData = m_vecStrGridGlassHeader[nCol];
|
}
|
else
|
{
|
CString strItem;
|
int nDataIndex = nRow - 1;
|
|
if (nDataIndex >= m_Formation.m_vecGlassInfo.size()) return;
|
|
_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[nRow - 1];
|
|
if (pGlassInfo == NULL) return;
|
|
switch (nCol)
|
{
|
case 0: strItem.Format("%d", pGlassInfo->m_nGlassSelect); break; //"No");
|
case 1: strItem.Format("%s", pGlassInfo->m_strPPID); break; //"GlassID");
|
case 2: strItem.Format("%s", pGlassInfo->m_strGlassID); break; //PPID
|
case 3: strItem.Format("%d", pGlassInfo->m_nDefectNum); break; //LOT ID
|
case 4: strItem.Format("%d", pGlassInfo->m_nReviewNum); break; //SLOT ID
|
case 5: strItem.Format("%s", pGlassInfo->m_strGlassJudge); break; //Glass Judge
|
case 6: strItem.Format("%s", pGlassInfo->m_strLotID); break; //SLOT NUMBER
|
case 7: strItem.Format("%s", pGlassInfo->m_strSLotID); break; //Cell NUmber
|
case 8: strItem.Format("%d", pGlassInfo->m_nSlot_No); break; //Defect Count
|
case 9: strItem.Format("%d", pGlassInfo->m_nCellNum); break; //Glass size H
|
case 10: strItem.Format("%d", pGlassInfo->m_nGlassSizeHeight); break; //Glass Judge
|
case 11: strItem.Format("%d", pGlassInfo->m_nGlassSizeWidth); break; //Glass size W
|
}
|
*pStrData = strItem;
|
}
|
}
|
|
void CReveiwHistoryDlg::getDispInfoDefect(int nCol, int nRow, CString* pStrData)
|
{
|
if (nRow < 0) return;
|
|
if (nRow == 0) //header
|
{
|
*pStrData = m_vecStrGridDefectHeader[nCol];
|
}
|
else
|
{
|
int nDataIndex = nRow - 1;
|
int iRow = m_nSelectedRow;
|
|
if (nDataIndex >= m_Formation.m_vecDefects.size())
|
{
|
return;
|
}
|
|
_akDefect* pDefectInfo = &m_Formation.m_vecDefects[nRow - 1];
|
|
if (pDefectInfo == NULL)
|
return;
|
|
CString strItem;
|
|
switch (nCol)
|
{
|
case 0: strItem.Format("%d", nRow); break;
|
case 1: strItem.Format("%d", pDefectInfo->m_nDefectID); break;
|
case 2:
|
{
|
strItem = _T("");
|
if (pDefectInfo->m_sDefectLoc == DefectLoc_Pattern)
|
strItem = "Pat";
|
else if (pDefectInfo->m_sDefectLoc == DefectLoc_PAD)
|
strItem = "PAD";
|
else if (pDefectInfo->m_sDefectLoc == DefectLoc_C2C)
|
strItem = "C2C";
|
else if (pDefectInfo->m_sDefectLoc == DefectLoc_Crack)
|
strItem = "Crk";
|
else if (pDefectInfo->m_sDefectLoc == DefectLoc_ASG)
|
strItem = "ASG";
|
else if (pDefectInfo->m_sDefectLoc == DefectLoc_BM)
|
strItem = "BM";
|
else
|
strItem = "Pat";
|
}
|
break;
|
case 3: strItem = pDefectInfo->m_strDefectType; break;
|
case 4: strItem.Format("%s", pDefectInfo->m_strDefectCode); break;
|
case 5:
|
{
|
if (pDefectInfo->m_DefectType == DefectType_RBlack)
|
strItem.Format("RB");
|
else if (pDefectInfo->m_DefectType == DefectType_RWhite)
|
strItem.Format("RW");
|
else if (pDefectInfo->m_DefectType == DefectType_TBlack)
|
strItem.Format("TB");
|
else if (pDefectInfo->m_DefectType == DefectType_TWhite)
|
strItem.Format("TW");
|
else
|
strItem = "UN";
|
}
|
break;
|
case 6:
|
{
|
strItem = _T("");
|
|
if (pDefectInfo->m_DefectSubType == DefectSubType_MC) // Common 05 M/N/C/S/K/*
|
strItem = "MC";
|
else if (pDefectInfo->m_DefectSubType == DefectSubType_Mask)
|
strItem = "MD";
|
else if (pDefectInfo->m_DefectSubType == DefectSubType_Common)
|
strItem = "CD";
|
else if (pDefectInfo->m_DefectSubType == DefectSubType_NoDefect)
|
strItem = "NO";
|
else
|
strItem = "N";
|
}
|
break;
|
case 7: strItem.Format("%d", pDefectInfo->m_nDefectRScale); break;
|
case 8:
|
{
|
strItem = _T("");
|
strItem.Format("% 7d", pDefectInfo->m_nUMSizeX);
|
}
|
break;
|
case 9:
|
{
|
strItem = _T("");
|
strItem.Format("% 7d", pDefectInfo->m_nUMSizeY);
|
}
|
break;
|
case 10:
|
strItem.Format("%d", pDefectInfo->m_nUMSize);
|
break;
|
case 11:
|
{
|
int nValue = 0;
|
for (int i = 105; i >= 0; i--)
|
{
|
if (pDefectInfo->m_sZonePixelCount[i] > 0)
|
nValue += 1;
|
if (i > 0)
|
nValue = nValue << 1;
|
}
|
|
strItem.Format("%04X", nValue);
|
}
|
break;
|
case 12: strItem.Format("%d", pDefectInfo->m_nLevelSrcMax); break;
|
case 13: strItem.Format("%d", pDefectInfo->m_nLevelSrcMin); break;
|
case 14: strItem.Format("%d", pDefectInfo->m_nLevelSrcAvg); break;
|
case 15: strItem.Format("%d", pDefectInfo->m_sDefectPeak); break;
|
case 16:
|
{
|
strItem.Format("%s", pDefectInfo->m_strStackFirst);
|
}
|
break;
|
case 17:
|
{
|
strItem = _T("");
|
strItem.Format("% 4d", pDefectInfo->m_nCameraID);
|
}
|
break;
|
case 18: strItem.Format("%d", pDefectInfo->m_nScanIdx); break;
|
case 19: strItem.Format("%d", pDefectInfo->m_nLevelRefMax); break;
|
case 20: strItem.Format("%d", pDefectInfo->m_nLevelRefMin); break;
|
case 21: strItem.Format("%d", pDefectInfo->m_nLevelRefAvg); break;
|
case 22:
|
{
|
CString str;
|
strItem = _T(" ");
|
str.Format("%5.3f", (double)pDefectInfo->m_nUMCenterAlignX / 1000.0);
|
strItem.Insert(9 - str.GetLength(), str);
|
strItem.TrimRight(" ");
|
}
|
break;
|
case 23:
|
{
|
CString str;
|
strItem = _T(" ");
|
str.Format("% 5.3f", (double)pDefectInfo->m_nUMCenterAlignY / 1000.0);
|
strItem.Insert(9 - str.GetLength(), str);
|
strItem.TrimRight(" ");
|
}
|
break;
|
case 24:
|
{
|
CString str;
|
strItem = _T(" ");
|
|
// Panel x축, y축은 글라스와 반대 [6/9/2017 bhs]
|
if (1)//g_pBasic->GetScanCoordination() == SC_XCoord)
|
str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellX / 1000.0);
|
else
|
str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellY / 1000.0);
|
|
strItem.Insert(9 - str.GetLength(), str);
|
strItem.TrimRight(" ");
|
}
|
break;
|
case 25:
|
{
|
CString str;
|
strItem = _T(" ");
|
|
// Panel x축, y축은 글라스와 반대 [6/9/2017 bhs]
|
if (1)//g_pBasic->GetScanCoordination() == SC_XCoord)
|
str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellY / 1000.0);
|
else
|
str.Format("% 5.3f", (double)pDefectInfo->m_nUMCellX / 1000.0);
|
|
strItem.Insert(9 - str.GetLength(), str);
|
strItem.TrimRight(" ");
|
}
|
break;
|
case 26: strItem.Format("%d", pDefectInfo->m_nScratchRatio); break;
|
case 27: strItem.Format("%d", pDefectInfo->m_nDensity); break;
|
case 28: strItem.Format("%d", pDefectInfo->m_bMergeState); break;
|
}
|
|
*pStrData = strItem;
|
}
|
}
|
|
LRESULT CReveiwHistoryDlg::OnMapDefectSelected(WPARAM wParam, LPARAM lParam)
|
{
|
int nSelectMode = static_cast<int>(lParam);
|
int nSelectDefect = static_cast<int>(wParam);
|
|
if (nSelectMode == 0)
|
{
|
setDefectShow(nSelectDefect, 1);
|
//ImageShow(nSelectDefect);
|
|
if (m_Formation.m_vecImage.size() < 0) return 0;
|
|
for (int i = 0; i < m_Formation.m_vecImage.size(); i++)
|
{
|
if (m_Formation.m_vecImage[i].m_nDefectID == nSelectDefect)
|
{
|
ImageShow(i);
|
break;
|
}
|
}
|
|
if (!m_bDefectAll)
|
{
|
m_sldImg.SetPos(m_nSelectedRow - 1);
|
|
int nPos = m_sldImg.GetPos();
|
CString strPos;
|
strPos.Format(_T("%d"), nPos);
|
m_ctrCount.SetWindowText(strPos);
|
}
|
}
|
else if (nSelectMode == 1)
|
{
|
CAlignDlg* lpDlg = CAlignDlg::GetMgr();
|
m_pDlgAlign->setFormShow(nSelectDefect, 1);
|
}
|
|
return 0;
|
}
|
|
LRESULT CReveiwHistoryDlg::OnListDefectSelected(WPARAM wParam, LPARAM lParam)
|
{
|
int nSelectDefect = static_cast<int>(wParam);
|
int nMode = static_cast<int>(lParam);
|
|
m_FormationMap.setSelectDefect(nSelectDefect);
|
|
return 0;
|
}
|
|
LRESULT CReveiwHistoryDlg::OnMapDefectMouseOver(WPARAM wParam, LPARAM lParam)
|
{
|
int nSelectDefect = static_cast<int>(wParam);
|
int nMode = static_cast<int>(lParam);
|
|
return 0;
|
}
|
|
void CReveiwHistoryDlg::OnBnClickedButtonMapviewFit()
|
{
|
m_FormationMap.SetAutoScale();
|
}
|
|
void CReveiwHistoryDlg::OnSize(UINT nType, int cx, int cy)
|
{
|
CDialogEx::OnSize(nType, cx, cy);
|
|
m_WndArrange.process(cx, cy);
|
m_FormationMap.SetAutoScale();
|
m_ImageView.SetResize();
|
}
|
|
void CReveiwHistoryDlg::OnOptionPathsetting()
|
{
|
// TODO: 여기에 명령 처리기 코드를 추가합니다.
|
CPathSettingDlg::GetMgr()->PathSettingLoad();
|
CPathSettingDlg* lpDlg = CPathSettingDlg::GetMgr();
|
lpDlg->ShowWindow(SW_SHOW);
|
|
LOG(Dbg, _T("[Processe] PathSetting Click"));
|
}
|
|
|
void CReveiwHistoryDlg::OnViewAlldefect()
|
{
|
// TODO: 여기에 명령 처리기 코드를 추가합니다.
|
CMenu *hMenu = GetMenu();
|
if (hMenu->GetMenuState(ID_VIEW_ALLDEFECT, MF_BYCOMMAND) != MF_CHECKED)
|
{
|
hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_CHECKED);
|
hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_UNCHECKED);
|
m_bDefectAll = true;
|
}
|
else
|
{
|
hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_CHECKED);
|
hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_UNCHECKED);
|
m_bDefectAll = false;
|
}
|
|
if (m_chkSingle.GetCheck())
|
{
|
GlassInfoRest();
|
BinFileOpen(m_nCount);
|
}
|
else
|
{
|
for(int i=0; i< 105; i++)
|
{
|
int nSelect = m_nSelectFile[i];
|
BinFileOpen(nSelect);
|
}
|
}
|
}
|
|
|
void CReveiwHistoryDlg::OnViewReviewdefect()
|
{
|
// TODO: 여기에 명령 처리기 코드를 추가합니다.
|
CMenu *hMenu = GetMenu();
|
if (hMenu->GetMenuState(ID_VIEW_REVIEWDEFECT, MF_BYCOMMAND) != MF_CHECKED)
|
{
|
hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_CHECKED);
|
hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_UNCHECKED);
|
m_bDefectAll = false;
|
}
|
else
|
{
|
hMenu->CheckMenuItem(ID_VIEW_REVIEWDEFECT, MF_UNCHECKED);
|
hMenu->CheckMenuItem(ID_VIEW_ALLDEFECT, MF_CHECKED);
|
m_bDefectAll = true;
|
}
|
|
if (m_chkSingle.GetCheck())
|
{
|
GlassInfoRest();
|
BinFileOpen(m_nCount);
|
}
|
else
|
{
|
BinFileOpen(m_nCount);
|
}
|
}
|
|
void CReveiwHistoryDlg::OnAlignView()
|
{
|
// TODO: 여기에 명령 처리기 코드를 추가합니다.
|
CRect rectWindow;
|
GetClientRect(&rectWindow);
|
ClientToScreen(&rectWindow);
|
|
CAlignDlg* lpDlg = CAlignDlg::GetMgr();
|
|
lpDlg->SetWindowPos(NULL, rectWindow.right + 5, rectWindow.top - 50, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
|
lpDlg->ShowWindow(SW_SHOW);
|
lpDlg->DrawnoImage();
|
}
|
|
void CReveiwHistoryDlg::FileTime(CString strPath)
|
{
|
HANDLE h_File = CreateFile(_T(strPath), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (h_File != INVALID_HANDLE_VALUE)
|
{
|
//** create_time : 생성 날짜, access_time : 마지막 접근날짜, write_time : 마지막 수정 날짜
|
FILETIME create_time, access_time, write_time;
|
//** System Time 취득
|
GetFileTime(h_File, &create_time, &access_time, &write_time);
|
|
//** SystemTime은 UTC형식(Universal Time Coordinated)이기 때문에 그냥 사용 불가능
|
//** 지역시간으로 변경(일반적인 시간 계산법 2015/11/09 21:18:35)
|
SYSTEMTIME write_system_time, write_local_time;
|
FileTimeToSystemTime(&write_time, &write_system_time);
|
|
//** write_local_time변수에 변환되어 저장됨
|
//** 저장된 형태는 WORD형(short)
|
//** wYear, wMonth, wDay, wHour, wMinute, wSecond를 활용하여 사용하면 됨
|
SystemTimeToTzSpecificLocalTime(NULL, &write_system_time, &write_local_time);
|
|
int nYear, nMonth, nDay, nHour, nMinute, nSecond;
|
nYear = write_local_time.wYear;
|
nMonth = write_local_time.wMonth;
|
nDay = write_local_time.wDay;
|
nHour = write_local_time.wHour;
|
nMinute = write_local_time.wMinute;
|
nSecond = write_local_time.wSecond;
|
CString strTime;
|
strTime.Format("%04d-%02d-%02d-%02d-%02d-%02d", nYear, nMonth, nDay, nHour, nMinute, nSecond);
|
|
m_vecStrGridTimeList.push_back(strTime);
|
}
|
}
|
|
CgrmGlassRawData g_RawData;
|
void CReveiwHistoryDlg::OpenFileHeader(CString strPath, CString strFullPath)
|
{
|
if (strPath == "") return;
|
|
CgrmGlassRawData* pRawData = &g_RawData;
|
|
if (m_vecStrGridReviewList.size() < 1) return;
|
|
CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
|
CString strBinPath;
|
strBinPath = pReivewSetting->GetBinPath();
|
|
pRawData->ImportGlassRaw(m_Server.GetGlassRawInfo(), NULL);
|
|
strcpy_s(pRawData->GetGlassData()->m_strFileName,64, strPath.GetBuffer());
|
strcpy_s(pRawData->GetGlassData()->m_strPath,256, strBinPath.GetBuffer());
|
|
BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(pRawData);
|
|
m_Formation.AddDefectHeaderTemp();
|
_akReviewHeader* pDefectInfo = &m_Formation.m_vecHeaderTemp[m_Formation.m_vecHeaderTemp.size() - 1];
|
|
pDefectInfo->m_nReviewIdx = 0;
|
pDefectInfo->m_strFileTime = m_vecStrGridTimeList[m_Formation.m_vecHeaderTemp.size() - 1];
|
pDefectInfo->m_strFileName = m_vecStrGridReviewList[m_Formation.m_vecHeaderTemp.size() - 1];
|
pDefectInfo->m_strFilePath = strFullPath;
|
|
if (bRetReadBin == FALSE)
|
{
|
pDefectInfo->m_nDefectIdx = 0;
|
pDefectInfo->m_strGlassID = "";
|
pDefectInfo->m_strPPID = "";
|
pDefectInfo->m_nReviewIdx = 0;
|
pDefectInfo->m_strJudge = "";
|
pDefectInfo->m_strLoading = "X";
|
|
return;
|
}
|
|
pDefectInfo->m_strLoading = "O";
|
|
//pRawData->ExportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());
|
|
int nDataCount = pRawData->GetGlassData()->m_nDefectNum;
|
|
_grmDefectData* pDefect;
|
_grmGlassData* pGlass;
|
|
CString strTemp;
|
CString strReviewImageName;
|
for (int i = 0; i < pRawData->GetGlassData()->m_nDefectNum; i++)
|
{
|
pDefect = pRawData->GetDefectData(i);//m_Server.GetDefectData(i);
|
pGlass = pRawData->GetGlassData(); //m_Server.GetGlassData();
|
|
pDefectInfo->m_nDefectIdx = pGlass->m_nDefectNum;
|
pDefectInfo->m_strGlassID = pGlass->m_strGlassID;
|
pDefectInfo->m_strPPID = pGlass->m_strPPID;
|
pDefectInfo->m_strJudge = pGlass->m_strGlassJudge;
|
|
|
strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
|
if (strReviewImageName == "" || strReviewImageName == "*")
|
{
|
continue;
|
}
|
else
|
{
|
pDefectInfo->m_nReviewIdx = pDefectInfo->m_nReviewIdx + 1;
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::BinFileOpen(int nCount)
|
{
|
BOOL bNewFile = TRUE;
|
if (nCount < 1) return;
|
|
if (m_vecStrGridReviewPath.size() <= 0) return;
|
|
if (m_vecStrGridReviewPath[nCount-1] == m_strRawFilePath) bNewFile = FALSE;
|
|
if (m_Formation.m_vecHeader.size() < 1) return;
|
|
CString strFileName = m_vecStrGridReviewList[nCount-1];
|
CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
|
CString strBinPath;
|
strBinPath = pReivewSetting->GetBinPath();
|
|
CgrmGlassRawData RawData;
|
|
RawData.ImportGlassRaw(m_Server.GetGlassRawInfo(), NULL);
|
|
strcpy(RawData.GetGlassData()->m_strFileName, strFileName.GetBuffer());
|
strcpy(RawData.GetGlassData()->m_strPath, strBinPath.GetBuffer());
|
|
BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(&RawData);
|
|
CGridCellCheck* pCellCheck = NULL;
|
pCellCheck = (CGridCellCheck*)m_gridReviewList.GetCell(nCount, 0);
|
|
if (bRetReadBin == FALSE)
|
{
|
AfxMessageBox(_T("로드 실패 하였습니다."), MB_OK | MB_ICONERROR);
|
m_FormationMap.SetAutoScale();
|
LOG(Dbg, _T("[Processe] File Open False"));
|
pCellCheck->SetCheck(FALSE);
|
Imagenoload();
|
return;
|
}
|
|
if (bNewFile && m_chkSingle.GetCheck())
|
{
|
m_FormationMap.m_vecCellRect.clear();
|
m_FormationMap.m_vecTempCellRect.clear();
|
m_FormationMap.clear();
|
m_Formation.Clear();
|
m_Formation.m_vecTempDefects.clear();
|
m_Formation.m_vecTempImage.clear();
|
SetScrollRest();
|
}
|
else if (bNewFile && !m_chkSingle.GetCheck())
|
{
|
if (m_bFirst)
|
{
|
m_bFirst = false;
|
m_FormationMap.m_vecCellRect.clear();
|
}
|
m_FormationMap.clear();
|
m_Formation.m_vecFormation.clear();
|
SetScrollRest();
|
}
|
else if (!bNewFile && !m_chkSingle.GetCheck())
|
{
|
m_FormationMap.clear();
|
m_Formation.m_vecFormation.clear();
|
SetScrollRest();
|
}
|
else
|
{
|
m_FormationMap.clear();
|
m_Formation.m_vecDefects.clear();
|
m_Formation.m_vecFormation.clear();
|
m_Formation.m_vecImage.clear();
|
SetScrollRest();
|
}
|
|
RawData.ExportGlassRaw(m_Server.GetGlassRawInfo(), (char*)m_Server.GetGlassData());
|
|
int nDataCount = RawData.GetGlassData()->m_nDefectNum;
|
int nCellCount = RawData.GetGlassData()->m_nCellNum;
|
|
m_strRawFilePath = m_vecStrGridReviewPath[nCount-1];
|
|
_grmGlassData* pGlass = m_Server.GetGlassData();
|
|
m_FormationMap.m_dGlassSizeWidth = pGlass->m_nGlassSizeWidth / 1000;
|
m_FormationMap.m_dGlassSizeHeight = pGlass->m_nGlassSizeHeight / 1000;
|
|
if (m_bDefectAll == false && m_chkSingle.GetCheck())
|
{
|
AddVecDataDefct(nDataCount);
|
}
|
else if (m_bDefectAll == false && !m_chkSingle.GetCheck())
|
{
|
if(m_Formation.m_vecTempDefects.size() > 0)
|
{
|
int nCount2;
|
nCount2 = MultiInsert(nCount, nDataCount);
|
if (nCount2 == -1)
|
{
|
AddVecDataDefct2(nDataCount);
|
}
|
}
|
else
|
{
|
AddVecDataDefct2(nDataCount);
|
}
|
/*AddVecDataDefct2(nDataCount, nCount);*/
|
}
|
else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
|
{
|
if (m_Formation.m_vecTempDefects.size() > 0)
|
{
|
int nCount2;
|
nCount2 = MultiInsert(nCount, nDataCount);
|
if (nCount2 == -1)
|
{
|
AddVecDataDefectAll2(nDataCount);
|
}
|
}
|
else
|
{
|
AddVecDataDefectAll2(nDataCount);
|
}
|
/*AddVecDataDefectAll2(nDataCount, nCount);*/
|
}
|
else
|
{
|
AddVecDataDefectAll(nDataCount);
|
}
|
|
AddVecDataImage(nDataCount);
|
AddVecCellData(nCellCount);
|
AddVecGlassData(nCount);
|
|
AddVecDateSorting(nDataCount);
|
AddVecImageSorting(nDataCount);
|
AddVecCellSorting(nCellCount);
|
|
m_gridDefectInfo.SetRowCount(m_Formation.m_vecDefects.size() + 1);
|
m_gridDefectInfo.Invalidate();
|
|
m_gridGlassInfo.SetRowCount(m_Formation.m_vecGlassInfo.size() + 1);
|
m_gridGlassInfo.Invalidate();
|
|
int nDefectSize = 0;
|
int nImageSize = 0;
|
int nCellSize = 0;
|
int nNext = MAX_COUNT;
|
|
if (m_chkSingle.GetCheck())
|
{
|
m_nDefectSize[0] = GetDefectCount();//m_Formation.m_vecDefects.size();
|
m_nImageSize[0] = GetImageCount();//m_Formation.m_vecImage.size();
|
m_nCellSize[0] = GetCellCount();
|
|
m_nCellSizeTemp[0] = m_nCellSize[0];
|
|
m_nImageCount = 0;
|
m_nDefectCount = 0;
|
m_nCellCount = 0;
|
}
|
else
|
{
|
|
for (int i = 0; i <= MAX_COUNT; i++)
|
{
|
nDefectSize = GetDefectCount();
|
nImageSize = GetImageCount();
|
nCellSize = GetCellCount();
|
|
//1.값을 순서대로 넣는다
|
if (nDefectSize > 0 || nImageSize > 0 || nCellSize > 0)
|
{
|
if (m_nDefectSize[i] == 0 && m_nImageSize[i] == 0 && m_nCellSize[i] == 0)
|
{
|
m_nDefectSize[i] = GetDefectCount();//m_Formation.m_vecDefects.size();
|
m_nImageSize[i] = GetImageCount();//m_Formation.m_vecImage.size();
|
m_nCellSize[i] = GetCellCount();
|
|
m_nImageCount = 0;
|
m_nDefectCount = 0;
|
m_nCellCount = 0;
|
break;
|
}
|
}
|
//2.마지막 값이면 2번째가 첫번째로 올린 후 넣는다.
|
if (nNext == i)
|
{
|
for (int j = 0; j < MAX_COUNT; j++)
|
{
|
m_nDefectSize[j] = m_nDefectSize[j + 1];
|
m_nImageSize[j] = m_nImageSize[j + 1];
|
m_nCellSize[j] = m_nCellSize[j + 1];
|
m_nCellSizeTemp[j] = m_nCellSize[j];
|
}
|
m_nDefectSize[i] = GetDefectCount();//m_Formation.m_vecDefects.size();
|
m_nImageSize[i] = GetImageCount();//m_Formation.m_vecImage.size();
|
m_nCellSize[i] = GetCellCount();
|
|
m_nCellSizeTemp[i] = m_nCellSize[i];
|
|
m_nImageCount = 0;
|
m_nDefectCount = 0;
|
m_nCellCount = 0;
|
}
|
//3.중간에 값이 빠지면 중간 번째 값을 올린 후 넣는다.
|
|
|
// if (i != 0) //i가 0 이 아니면 count를 높인다.
|
// {
|
// nDefectSize += m_nDefectSize[i];
|
// nImageSize += m_nImageSize[i];
|
// nCellSize += m_nCellSize[i];
|
// }
|
// else if (i == 0 && m_nDefectSize[0] > 0) //i가 0인데 디펙이 있으면 카운터를 높인다.
|
// {
|
// nDefectSize += m_nDefectSize[i];
|
// nImageSize += m_nImageSize[i];
|
// nCellSize += m_nCellSize[i];
|
// }
|
|
// if (m_nDefectSize[0] == 0)
|
// {
|
// m_nDefectSize[i] = GetDefectCount();//m_Formation.m_vecDefects.size();
|
// m_nImageSize[i] = GetImageCount();//m_Formation.m_vecImage.size();
|
// m_nCellSize[i] = GetCellCount();
|
//
|
// m_nImageCount = 0;
|
// m_nDefectCount = 0;
|
// m_nCellCount = 0;
|
// break;
|
// }
|
// else if(i != 0 && m_nDefectSize[i] == 0)
|
// {
|
// m_nDefectSize[i] = GetDefectCount(); //m_Formation.m_vecDefects.size() - nDefectSize;
|
// m_nImageSize[i] = GetImageCount(); //m_Formation.m_vecImage.size() - nImageSize;
|
// m_nCellSize[i] = GetCellCount();
|
//
|
// m_nImageCount = 0;
|
// m_nDefectCount = 0;
|
// m_nCellCount = 0;
|
// break;
|
// }
|
}
|
}
|
|
m_FormationMap.m_pDefectFormation = &m_Formation;
|
m_DefectDisplayOption.m_nShowLabel = -1;
|
m_FormationMap.m_pDefectDisplayOption = &m_DefectDisplayOption;
|
|
CAlignDlg* lpDlg = CAlignDlg::GetMgr();
|
lpDlg->m_pDefectFormation = &m_Formation;
|
lpDlg->m_pDefectDisplayOption = &m_DefectDisplayOption;
|
|
if(bNewFile) m_FormationMap.SetAutoScale();
|
else m_FormationMap.ReDraw(TRUE);
|
|
int nDefectNum = m_Server.GetGlassData()->m_nDefectNum;
|
int nNoneGroupDefect = m_Formation.m_vecImage.size();
|
|
if (m_Formation.m_vecImage.size() > 0)
|
{
|
SetScrollSetting();
|
}
|
}
|
|
void CReveiwHistoryDlg::OnCbnSelchangeComboRawtype()
|
{
|
CGlassRawBase* pNewRawMaker = NULL;
|
|
pNewRawMaker = new CGlassRawCPJT;
|
|
if (m_pGlassRawMaker) delete m_pGlassRawMaker;
|
|
m_pGlassRawMaker = pNewRawMaker;
|
|
m_ConfigOption.m_nSelectRawType = 3;
|
|
}
|
|
void CReveiwHistoryDlg::OnBnClickedBtnFindBin()
|
{
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
|
|
m_vecStrGridReviewList.clear();
|
m_vecStrGridTimeList.clear();
|
m_vecStrGridReviewPath.clear();
|
m_Formation.m_vecHeader.clear();
|
m_FormationMap.clear();
|
m_Formation.Clear();
|
GlassInfoRest();
|
|
// m_ProgressFile.ModifyStyle(0, PBS_MARQUEE);
|
// m_ProgressFile.ShowWindow(TRUE);
|
// pProgressBar->SetMarquee(TRUE, 30);
|
|
|
CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
|
CString strBinPath;
|
strBinPath = pReivewSetting->GetBinPath();
|
|
if (strBinPath == "")
|
{
|
return;
|
}
|
strBinPath += _T("\\*.*");
|
|
CFileFind finder;
|
BOOL bWorking = finder.FindFile(strBinPath);
|
|
// CakFileUtil akFile;
|
// akFile.FindFile(strBinPath.GetBuffer());
|
// VECFINDDATA* pVecFindData = akFile.getFindData();
|
//
|
// for (int i = 0; i < pVecFindData->size(); i++)
|
// {
|
// _DefectList akDefect;
|
// m_vecStrDefectList.push_back(akDefect);
|
// _DefectList* pDefectList = &m_vecStrDefectList[i];
|
//
|
//
|
// TRACE("Craete Time : %d, %s \n", (*pVecFindData)[i].time_create, (*pVecFindData)[i].name);
|
// pDefectList->m_nFileTime = (*pVecFindData)[i].time_create;
|
// pDefectList->m_strFileName = (*pVecFindData)[i].name;
|
// // m_vecStrGridReviewList.push_back((*pVecFindData)[i].name);
|
// // m_vecStrGridTimeList.push_back((*pVecFindData)[i].time_create;
|
// OpenFileHeader((*pVecFindData)[i].name);
|
// }
|
|
|
|
CString fileName;
|
CString DirName;
|
int nCount = 1;
|
m_ctlProgress.ShowWindow(TRUE);
|
int nPersent = 0;
|
|
while (bWorking)
|
{
|
m_ctlProgress.SetPos(nPersent);
|
nPersent++;
|
|
if (nPersent >= 100)
|
{
|
nPersent = 0;
|
}
|
|
//다음 파일 / 폴더 가 존재하면다면 TRUE 반환
|
bWorking = finder.FindNextFile();
|
//파일 일때
|
if (finder.IsArchived())
|
{
|
//파일의 이름
|
CString _fileName = finder.GetFileName();
|
|
// 현재폴더 상위폴더 썸네일파일은 제외
|
if (_fileName == _T(".") ||
|
_fileName == _T("..") ||
|
_fileName == _T("Thumbs.db")) continue;
|
|
CString strFindName = ".bin";
|
CString strFileName, strFileName2;
|
strFileName = _fileName.Right(4); //bin 파일만
|
|
if (strFileName.Compare(strFindName) == 0)
|
{
|
/*if(nCount > m_nFileCount) break; //count 여기서 말고 전체 파일을 다 읽은 후에 다시 소팅하자*/
|
m_vecStrGridReviewList.push_back(_fileName);
|
strFileName2 = strBinPath.Left(strBinPath.GetLength() - 3);
|
strFileName2 += _fileName;
|
m_vecStrGridReviewPath.push_back(strFileName2);
|
FileTime(strFileName2);
|
OpenFileHeader(_fileName, strFileName2);
|
/*nCount++;*/
|
}
|
}
|
}
|
|
//여기에서 재 소팅 후에 필요한 만큼만 넣자
|
{
|
//vec를 정렬 한다.
|
SortFileList(1);
|
//갯수만큼만 복사를 한다
|
//복사한 것을 넣는다.
|
|
}
|
CGridCellCheck* pCellCheck = NULL;
|
//
|
// m_gridReviewList.SetCellType(1, 0, RUNTIME_CLASS(CGridCellCheck));
|
//
|
m_gridReviewList.SetRowCount(m_Formation.m_vecHeader.size() + 1);
|
|
{
|
GV_ITEM Item;
|
int nRowIdx = 0;
|
int nColIdx = 0;
|
CString strTemp;
|
Item.mask = GVIF_TEXT;
|
|
_akReviewHeader *pReview = NULL;
|
|
for (int i = 0; i < m_Formation.m_vecHeader.size(); i++)
|
{
|
m_gridReviewList.SetCellType(i + 1, 0, RUNTIME_CLASS(CGridCellCheck));
|
|
// pCellCheck = (CGridCellCheck*)m_ctrlGridGlassList.GetCell(nRowIdx, nColIdx);
|
//
|
// pCellCheck->SetCheck();
|
|
nColIdx = 0;
|
pReview = &m_Formation.m_vecHeader[i];
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%d"), i + 1);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%s"), pReview->m_strFileTime);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%s"), pReview->m_strLoading);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%s"), pReview->m_strPPID);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%s"), pReview->m_strGlassID);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%d"), pReview->m_nDefectIdx);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%d"), pReview->m_nReviewIdx);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%s"), pReview->m_strJudge);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
|
Item.row = i + 1;
|
Item.col = nColIdx++;
|
strTemp.Format(_T("%s"), pReview->m_strFileName);
|
Item.strText = strTemp;
|
m_gridReviewList.SetItem(&Item);
|
}
|
|
}
|
m_gridReviewList.Invalidate();
|
|
m_ctlProgress.ShowWindow(FALSE);
|
}
|
|
void CReveiwHistoryDlg::ShowProgressBar()
|
{
|
|
}
|
|
void CReveiwHistoryDlg::setDefectShow(int nDefectID, BOOL bEnsureVisible)
|
{
|
const int nDefectCol = 1;
|
|
if (nDefectID >= 0)
|
{
|
int sajfklwe;
|
sajfklwe = m_gridDefectInfo.GetColumnCount();
|
if (m_nSelectedRow > m_gridDefectInfo.GetColumnCount())
|
{
|
m_nSelectedRow = 0;
|
}
|
|
if(!m_bDefectAll)
|
{
|
if (m_nSelectedRow > m_Formation.m_vecImage.size())
|
{
|
m_nSelectedRow = 0;
|
}
|
}
|
int iRow = m_nSelectedRow;
|
|
for (int iCol = 0; iCol < m_gridDefectInfo.GetColumnCount(); iCol++)
|
{
|
m_gridDefectInfo.SetItemState(iRow, iCol, m_gridDefectInfo.GetItemState(iRow, iCol) & ~GVIS_SELECTED);
|
}
|
}
|
|
for (int i = 0; i < m_Formation.m_vecDefects.size(); i++)
|
{
|
_akDefect* pDefectInfo = &m_Formation.m_vecDefects[i];
|
|
if (pDefectInfo == NULL)
|
return;
|
|
if (pDefectInfo->m_nDefectID == nDefectID)
|
{
|
int iRow = i + 1;
|
for (int iCol = 0; iCol < m_gridDefectInfo.GetColumnCount(); iCol++)
|
{
|
m_gridDefectInfo.SetItemState(iRow, iCol, LVIS_SELECTED);
|
}
|
m_nSelectedRow = iRow;
|
if (bEnsureVisible)
|
{
|
m_gridDefectInfo.EnsureVisible(iRow, m_nSelectedCol);
|
}
|
break;
|
}
|
}
|
|
m_gridDefectInfo.Invalidate();
|
}
|
|
void CReveiwHistoryDlg::ImageShow(int nDefectID)
|
{
|
CPaintDC dc(this);
|
|
if (nDefectID < 0) return;
|
|
m_DefectImage.Destroy();
|
m_ReviewImage.Destroy();
|
//LYW 20210825 #3486 ADD START
|
m_DefectRotateImage.Destroy();
|
//LYW 20210825 #3486 ADD END
|
|
m_AlignFirst.Destroy();
|
m_AlignSecend.Destroy();
|
|
CString DeftectPath, DeftectPath2, AlignPath, AlignPath2;
|
CFileStatus FileOn;
|
TCHAR chFilePath[256] = { 0, };
|
GetModuleFileName(NULL, chFilePath, 256);
|
if (chFilePath == NULL || chFilePath == "") return;
|
|
CString strFolderPath(chFilePath);
|
strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));
|
|
strFolderPath = strFolderPath + "\\no-image.png";
|
|
|
//DefectData가 지금 선택된 DefectData를 가져 온다. 이거 수정...
|
|
// _grmDefectData* pDefect = m_Server.GetDefectData(nDefectID);
|
// _grmGlassData* pGlass = m_Server.GetGlassData();
|
int nIndex = 0;
|
//디펙 인덱스와 같은 놈을 찾아라
|
for (int i = 0; i < m_Formation.m_vecImage.size(); i++)
|
{
|
_akReviewList* pImage = NULL;
|
pImage = &m_Formation.m_vecImage[i];
|
|
if (!m_bDefectAll)
|
{
|
nIndex = nDefectID;
|
break;
|
}
|
else
|
{
|
if (pImage->m_nDefectID == nDefectID)
|
{
|
nIndex = i;
|
break;
|
}
|
}
|
}
|
_akReviewList* pImageInfo = &m_Formation.m_vecImage[nIndex];
|
//몇 번째 인지 던진다.
|
|
CString wekfjlwe = pImageInfo->m_strReviewImageName;
|
CString wjkflwe = pImageInfo->m_strAoiImageName;
|
CString jkefawlj = pImageInfo->m_strReviewImagePath;
|
//해당 count를 호출 한다.
|
//파일 이미지를 불러 온다
|
//표현한다.
|
|
|
/* if (pGlass == NULL) return;*/
|
|
//_akReviewList* pDfect2 = &m_Formation.m_vecImage[nDefectID];
|
|
// CString wefjklwef;
|
// wefjklwef = pDfect2->m_strRevewImageName;
|
|
CString strReviewImageName, strInspectorName, strReviewImagePath, strAlignName, strAlignName2;
|
// strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
// strInspectorName = pDefect->m_strAoiImageName;
|
// strReviewImagePath = pDefect->m_ReviewDefect.m_strRevImagePath;
|
|
/* pDefect->m_ReviewDefect.m_strRevImagePath*/
|
|
strReviewImageName = wekfjlwe;
|
strInspectorName = wjkflwe;
|
strReviewImagePath = jkefawlj;
|
strAlignName = pImageInfo->m_strAlignFirst; //Glass 값 가져와라
|
strAlignName2 = pImageInfo->m_strAlignSecond;
|
|
// strAlignName.Format(_T("1.jpg"));
|
// strAlignName2.Format(_T("2.jpg"));
|
|
CString strReviewPath;
|
CString strInspectorPath;
|
CString strAlignPath;
|
|
CPathSettingDlg* lpDlg = CPathSettingDlg::GetMgr();
|
strInspectorPath = lpDlg->GetInspectorPath();
|
strReviewPath = lpDlg->GetReviewPath();
|
strAlignPath = lpDlg->GetAlignPath();
|
|
DeftectPath.Format(_T("%s\\%s\\%s"), strReviewPath, strReviewImagePath, strReviewImageName);
|
//DeftectPath2.Format(_T("%s\\%s"), strInspectorPath, strInspectorName);
|
if (strInspectorName == "*" || strInspectorName == "**" || strInspectorName == "***") strInspectorName = "";
|
DeftectPath2.Format(_T("%s\\%s\\%s"), strInspectorPath, pImageInfo->m_strGlassID, strInspectorName);
|
|
AlignPath.Format(_T("%s\\%s\\%s"), strAlignPath, pImageInfo->m_strGlassID, strAlignName);
|
AlignPath2.Format(_T("%s\\%s\\%s"), strAlignPath, pImageInfo->m_strGlassID, strAlignName2);
|
|
if (CFile::GetStatus(DeftectPath, FileOn) && strReviewImageName != "") //파일이 있을 때
|
{
|
CString strTest;
|
strTest = DeftectPath;
|
strcpy(m_strConfigFile, strTest.GetBuffer(0));
|
m_ImageView.SetImageData(m_strConfigFile);
|
m_ImageView.ReDraw();
|
// m_ReviewImage.Load(DeftectPath);
|
// HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), DeftectPath,
|
// IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
//
|
//
|
// InvalidateRect(m_picture_rect, FALSE);
|
// dc.SetStretchBltMode(COLORONCOLOR);
|
// m_ReviewImage.Draw(dc, m_picture_rect);
|
}
|
else
|
{
|
CString strTest;
|
strTest = strFolderPath;
|
strcpy(m_strConfigFile, strTest.GetBuffer(0));
|
m_ImageView.SetImageData(m_strConfigFile);
|
m_ImageView.ReDraw();
|
|
// m_ReviewImage.Load(strFolderPath);
|
// HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
|
// IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
//
|
// InvalidateRect(m_picture_rect, FALSE);
|
// dc.SetStretchBltMode(COLORONCOLOR);
|
// m_ReviewImage.Draw(dc, m_picture_rect);
|
}
|
|
if (CFile::GetStatus(DeftectPath2, FileOn) && strInspectorName != "") //파일이 있을 때
|
{
|
m_DefectImage.Load(DeftectPath2);
|
//LYW 20210825 #3486 ADD START
|
m_DefectRotateImage.Create(m_DefectImage.GetWidth(), m_DefectImage.GetHeight(), m_DefectImage.GetBPP(), 0);
|
ImageRotate(m_DefectImage, m_DefectRotateImage);
|
//LYW 20210825 #3486 ADD END
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), DeftectPath2,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
|
InvalidateRect(m_picture_rect2, FALSE);
|
dc.SetStretchBltMode(COLORONCOLOR);
|
//LYW 20210825 #3486 MOD START
|
m_DefectRotateImage.Draw(dc, m_picture_rect2);
|
//LYW 20210825 #3486 MOD END
|
//original
|
//m_DefectImage.Draw(dc, m_picture_rect2);
|
}
|
else
|
{
|
m_DefectImage.Load(strFolderPath);
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
InvalidateRect(m_picture_rect2, FALSE);
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_DefectImage.Draw(dc, m_picture_rect2);
|
}
|
|
if (CFile::GetStatus(AlignPath, FileOn) && strAlignName != "") //파일이 있을 때
|
{
|
m_AlignFirst.Load(AlignPath);
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), AlignPath,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
|
InvalidateRect(m_Align_rect, FALSE);
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_AlignFirst.Draw(dc, m_Align_rect);
|
}
|
else
|
{
|
m_AlignFirst.Load(strFolderPath);
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
InvalidateRect(m_Align_rect, FALSE);
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_AlignFirst.Draw(dc, m_Align_rect);
|
}
|
|
if (CFile::GetStatus(AlignPath2, FileOn) && strAlignName2 != "") //파일이 있을 때
|
{
|
m_AlignSecend.Load(AlignPath2);
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), AlignPath2,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
|
InvalidateRect(m_Align_rect2, FALSE);
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_AlignSecend.Draw(dc, m_Align_rect2);
|
}
|
else
|
{
|
m_AlignSecend.Load(strFolderPath);
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
InvalidateRect(m_Align_rect2, FALSE);
|
dc.SetStretchBltMode(COLORONCOLOR);
|
m_AlignSecend.Draw(dc, m_Align_rect2);
|
}
|
}
|
|
void CReveiwHistoryDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
{
|
// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
|
if (IDC_SLIDER_IMG == pScrollBar->GetDlgCtrlID())
|
{
|
int nCount = m_sldImg.GetPos();
|
|
CString strPos;
|
strPos.Format(_T("%d"), nCount);
|
m_ctrCount.SetWindowText(strPos);
|
|
if (nCount > -1)
|
{
|
if (m_Formation.m_vecImage.size() <= 0)
|
{
|
SetScrollRest();
|
return;
|
}
|
_akReviewList* pImageInfo = &m_Formation.m_vecImage[nCount];
|
|
m_FormationMap.setSelectDefect(pImageInfo->m_nDefectID);
|
//ImageShow(pImageInfo->m_nDefectID);
|
setDefectShow(pImageInfo->m_nDefectID, 1);
|
}
|
}
|
}
|
|
|
void CReveiwHistoryDlg::OnChangeEditCount()
|
{
|
// TODO: RICHEDIT 컨트롤인 경우, 이 컨트롤은
|
// CDialogEx::OnInitDialog() 함수를 재지정
|
//하고 마스크에 OR 연산하여 설정된 ENM_CHANGE 플래그를 지정하여 CRichEditCtrl().SetEventMask()를 호출하지 않으면
|
// 이 알림 메시지를 보내지 않습니다.
|
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
|
CString strPos;
|
m_ctrCount.GetWindowText(strPos);
|
|
if (strPos == "") return;
|
|
int nPos = _ttoi(strPos);
|
|
if (nPos < -1)
|
{
|
m_ctrCount.SetWindowText(0);
|
nPos = 0;
|
}
|
else if (nPos > m_Formation.m_vecImage.size()-1)
|
{
|
nPos = m_Formation.m_vecImage.size() - 1;
|
CString strCount;
|
strCount.Format(_T("%d"),nPos);
|
m_ctrCount.SetWindowText(strCount);
|
}
|
|
m_sldImg.SetPos(nPos);
|
|
if (nPos > -1)
|
{
|
if (m_Formation.m_vecImage.size() <= 0)
|
{
|
SetScrollRest();
|
return;
|
}
|
_akReviewList* pImageInfo = &m_Formation.m_vecImage[nPos];
|
|
m_FormationMap.setSelectDefect(pImageInfo->m_nDefectID);
|
//ImageShow(pImageInfo->m_nDefectID/*nPos*/);
|
ImageShow(nPos);
|
setDefectShow(pImageInfo->m_nDefectID, 1);
|
}
|
}
|
|
void CReveiwHistoryDlg::SetScrollSetting()
|
{
|
if (m_Formation.m_vecImage.size() <= 0) return;
|
_akReviewList* pImageInfo = &m_Formation.m_vecImage[m_Formation.m_vecImage.size() - 1];
|
|
int nMinRange = m_Formation.m_vecImage.size()*0.03, nMaxRange = m_Formation.m_vecImage.size()*0.1;
|
|
if (nMinRange <= 0) nMinRange = 1;
|
if (nMaxRange <= 0) nMaxRange = 1;
|
|
m_sldImg.SetRange(0, m_Formation.m_vecImage.size()-1); //범위 설정 최대 이미지 갯수
|
m_sldImg.SetPos(0); //현재 포지션
|
m_sldImg.SetLineSize(nMinRange); //이동할 범위 3%
|
m_sldImg.SetPageSize(nMaxRange); //페이지 업다운 이동 범위 범위 10%
|
|
int nPos = m_sldImg.GetPos();
|
CString strPos;
|
strPos.Format(_T("%d"), nPos);
|
m_ctrCount.SetWindowText(strPos);
|
}
|
|
void CReveiwHistoryDlg::SetScrollRest()
|
{
|
m_sldImg.SetRange(-1, -1);
|
m_sldImg.SetPos(-1);
|
m_sldImg.SetLineSize(3);
|
m_sldImg.SetPageSize(10);
|
|
int nPos = m_sldImg.GetPos();
|
CString strPos;
|
strPos.Format(_T("%d"), nPos);
|
m_ctrCount.SetWindowText(strPos);
|
}
|
|
void CReveiwHistoryDlg::OnBnClickedButton3()
|
{
|
// // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
// CPaintDC dc(this);
|
// HDC hMemDC;
|
//
|
// hMemDC = CreateCompatibleDC(dc);
|
//
|
// m_DefectImage.Destroy();
|
//
|
// CString DeftectPath;
|
// CFileStatus FileOn;
|
// TCHAR chFilePath[256] = { 0, };
|
// GetModuleFileName(NULL, chFilePath, 256);
|
// CString strFolderPath(chFilePath);
|
// strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));
|
//
|
// strFolderPath = strFolderPath + "\\no-image.png";
|
// m_DefectImage.Load(strFolderPath);
|
//
|
// HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
|
// IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
//
|
// InvalidateRect(m_picture_rect, FALSE);
|
//
|
// dc.SetStretchBltMode(COLORONCOLOR);
|
// //StretchBlt(dc, 500, 400, 300, 200, hMemDC, 105, 105, 120, 123, SRCCOPY);
|
// //m_DefectImage.StretchBlt(dc, 0, 0, 100, 100, SRCCOPY);
|
// m_DefectImage.StretchBlt(dc, 0, 0, 500, 200, SRCCOPY);
|
// m_DefectImage.Draw(dc, m_picture_rect);
|
}
|
|
|
void CReveiwHistoryDlg::OnClickedChkAllDefect()
|
{
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
if (m_chkAllDefect.GetCheck())
|
{
|
if (IDYES == AfxMessageBox(_T("정렬한 값이 모두 초기화 됩니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkAllDefect.SetCheck(TRUE);
|
m_chkReviewDefect.SetCheck(FALSE);
|
OnViewAlldefect();
|
}
|
else
|
{
|
m_chkAllDefect.SetCheck(FALSE);
|
m_chkReviewDefect.SetCheck(TRUE);
|
}
|
}
|
else
|
{
|
if (IDYES == AfxMessageBox(_T("정렬한 값이 모두 초기화 됩니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkAllDefect.SetCheck(FALSE);
|
m_chkReviewDefect.SetCheck(TRUE);
|
OnViewReviewdefect();
|
}
|
else
|
{
|
m_chkAllDefect.SetCheck(TRUE);
|
m_chkReviewDefect.SetCheck(FALSE);
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::OnClickedChkReviewDefect()
|
{
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
if (m_chkReviewDefect.GetCheck())
|
{
|
if (IDYES == AfxMessageBox(_T("정렬한 값이 모두 초기화 됩니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkAllDefect.SetCheck(FALSE);
|
m_chkReviewDefect.SetCheck(TRUE);
|
OnViewAlldefect();
|
}
|
else
|
{
|
m_chkAllDefect.SetCheck(TRUE);
|
m_chkReviewDefect.SetCheck(FALSE);
|
}
|
}
|
else
|
{
|
if (IDYES == AfxMessageBox(_T("정렬한 값이 모두 초기화 됩니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkAllDefect.SetCheck(TRUE);
|
m_chkReviewDefect.SetCheck(FALSE);
|
OnViewReviewdefect();
|
}
|
else
|
{
|
m_chkAllDefect.SetCheck(FALSE);
|
m_chkReviewDefect.SetCheck(TRUE);
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::OnClickedChkMuti()
|
{
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
if (m_chkMuti.GetCheck())
|
{
|
if (IDYES == AfxMessageBox(_T("선택한 항목 모두가 지워 집니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkSingle.SetCheck(FALSE);
|
m_chkMuti.SetCheck(TRUE);
|
|
GlassInfoRest();
|
for (int i = 0; i < 105; i++)
|
{
|
m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nCellSize[i] = 0;
|
m_nImageSize[i] = 0;
|
m_nCellSizeTemp[i] = m_nCellSize[i];
|
}
|
m_Formation.Clear();
|
m_bFirst = true;
|
}
|
else
|
{
|
m_chkSingle.SetCheck(TRUE);
|
m_chkMuti.SetCheck(FALSE);
|
}
|
}
|
else
|
{
|
if (IDYES == AfxMessageBox(_T("선택한 항목 모두가 지워 집니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkSingle.SetCheck(TRUE);
|
m_chkMuti.SetCheck(FALSE);
|
GlassInfoRest();
|
}
|
else
|
{
|
m_chkSingle.SetCheck(FALSE);
|
m_chkMuti.SetCheck(TRUE);
|
GlassInfoRest();
|
for (int i = 0; i < 105; i++)
|
{
|
m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nCellSize[i] = 0;
|
m_nImageSize[i] = 0;
|
m_nCellSizeTemp[i] = m_nCellSize[i];
|
}
|
m_Formation.Clear();
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::OnClickedChkSingle()
|
{
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
if (m_chkSingle.GetCheck())
|
{
|
if (IDYES == AfxMessageBox(_T("선택한 항목 모두가 지워 집니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkMuti.SetCheck(FALSE);
|
m_chkSingle.SetCheck(TRUE);
|
GlassInfoRest();
|
|
int nRow = 0;
|
nRow = m_gridReviewList.GetRowCount();
|
for (int i = 1; i < nRow; i++)
|
{
|
CGridCellCheck* pCellCheck = NULL;
|
pCellCheck = (CGridCellCheck*)m_gridReviewList.GetCell(i, 0);
|
pCellCheck->SetCheck(FALSE);
|
}
|
m_gridReviewList.Refresh();
|
}
|
else
|
{
|
m_chkSingle.SetCheck(FALSE);
|
m_chkMuti.SetCheck(TRUE);
|
GlassInfoRest();
|
for (int i = 0; i < 105; i++)
|
{
|
m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nCellSize[i] = 0;
|
m_nImageSize[i] = 0;
|
m_nCellSizeTemp[i] = m_nCellSize[i];
|
}
|
}
|
}
|
else
|
{
|
if (IDYES == AfxMessageBox(_T("선택한 항목 모두가 지워 집니다"), MB_YESNO | MB_ICONWARNING))
|
{
|
m_chkMuti.SetCheck(TRUE);
|
m_chkSingle.SetCheck(FALSE);
|
GlassInfoRest();
|
for (int i = 0; i < 105; i++)
|
{
|
m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nCellSize[i] = 0;
|
m_nImageSize[i] = 0;
|
m_nCellSizeTemp[i] = m_nCellSize[i];
|
}
|
m_bFirst = true;
|
}
|
else
|
{
|
m_chkMuti.SetCheck(FALSE);
|
m_chkSingle.SetCheck(TRUE);
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::Imagenoload()
|
{
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
CPaintDC dc(this);
|
|
// m_ReviewImage.Destroy();
|
m_DefectImage.Destroy();
|
//LYW 20210825 #3486 ADD START
|
m_DefectRotateImage.Destroy();
|
//LYW 20210825 #3486 ADD END
|
m_AlignFirst.Destroy();
|
m_AlignSecend.Destroy();
|
|
CString DeftectPath;
|
CFileStatus FileOn;
|
TCHAR chFilePath[256] = { 0, };
|
GetModuleFileName(NULL, chFilePath, 256);
|
CString strFolderPath(chFilePath);
|
strFolderPath = strFolderPath.Left(strFolderPath.ReverseFind('\\'));
|
|
strFolderPath = strFolderPath + "\\no-image.png";
|
|
strcpy(m_strConfigFile, strFolderPath.GetBuffer(0));
|
|
m_ImageView.SetImageData(m_strConfigFile);
|
// m_ReviewImage.Load(strFolderPath);
|
m_DefectImage.Load(strFolderPath);
|
m_AlignFirst.Load(strFolderPath);
|
m_AlignSecend.Load(strFolderPath);
|
|
HBITMAP hBmp = (HBITMAP)::LoadImage(AfxGetInstanceHandle(), strFolderPath,
|
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
|
|
// InvalidateRect(m_picture_rect, FALSE);
|
InvalidateRect(m_picture_rect2, FALSE);
|
InvalidateRect(m_Align_rect, FALSE);
|
InvalidateRect(m_Align_rect2, FALSE);
|
|
dc.SetStretchBltMode(COLORONCOLOR);
|
|
m_ImageView.ReDraw();
|
// m_ReviewImage.Draw(dc, m_picture_rect);
|
m_DefectImage.Draw(dc, m_picture_rect2);
|
m_AlignFirst.Draw(dc, m_Align_rect);
|
m_AlignSecend.Draw(dc, m_Align_rect2);
|
}
|
|
//LYW 20210825 #3486 ADD START
|
void CReveiwHistoryDlg::ImageRotate(CImage & SrcImage, CImage & DstImage, double degree/* = 180.0 */)
|
{
|
int Height = SrcImage.GetHeight(); // 세로 길이 저장
|
int Width = SrcImage.GetWidth(); // 가로 길이 저장
|
int new_x, new_y;
|
int R, G, B;
|
int center_x = (SrcImage.GetWidth() / 2); // 회전 중심점
|
int center_y = (SrcImage.GetHeight() / 2); // 회전 중심점
|
|
double seta = 3.14 / (180.0 / degree); // 라디안
|
double CosSeta = cos(seta);
|
double SinSeta = sin(seta);
|
|
for (int y = 0; y < Height; y++)
|
{
|
for (int x = 0; x < Width; x++)
|
{
|
new_x = (int)((x - center_x) * CosSeta - (y - center_y) * SinSeta + center_x);
|
new_y = (int)((x - center_x) * SinSeta + (y - center_y) * CosSeta + center_y);
|
|
if ((new_x < 0) || (new_x > Width) || (new_y < 0) || (new_y > Height))
|
//이미지 범위를 벗어나면 0 값
|
{
|
R = 0;
|
G = 0;
|
B = 0;
|
}
|
else
|
{
|
R = GetRValue(SrcImage.GetPixel(new_x, new_y));
|
G = GetGValue(SrcImage.GetPixel(new_x, new_y));
|
B = GetBValue(SrcImage.GetPixel(new_x, new_y));
|
}
|
DstImage.SetPixel((int)x, (int)y, RGB(R, G, B));
|
new_x = 0; new_y = 0;
|
}
|
}
|
|
}
|
//LYW 20210825 #3486 ADD END
|
|
void CReveiwHistoryDlg::OnChangeEditFileCount()
|
{
|
// TODO: RICHEDIT 컨트롤인 경우, 이 컨트롤은
|
// CDialogEx::OnInitDialog() 함수를 재지정
|
//하고 마스크에 OR 연산하여 설정된 ENM_CHANGE 플래그를 지정하여 CRichEditCtrl().SetEventMask()를 호출하지 않으면
|
// 이 알림 메시지를 보내지 않습니다.
|
|
// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
|
CString strCount;
|
m_ctlFileCount.GetWindowText(strCount);
|
m_nFileCount = _ttoi(strCount);
|
}
|
|
BOOL CReveiwHistoryDlg::GetCheckFileLoad(int nCount)
|
{
|
BOOL bNewFile = TRUE;
|
if (nCount == 0) return FALSE;
|
|
if (m_vecStrGridReviewPath.size() <= 0) return FALSE;
|
|
if (m_vecStrGridReviewPath[nCount - 1] == m_strRawFilePath) bNewFile = FALSE;
|
|
if (m_vecStrGridReviewList.size() < 1) return FALSE;
|
|
CString strFileName = m_vecStrGridReviewList[nCount - 1];
|
CPathSettingDlg* pReivewSetting = CPathSettingDlg::GetMgr();
|
CString strBinPath;
|
strBinPath = pReivewSetting->GetBinPath();
|
|
CgrmGlassRawData RawData;
|
|
RawData.ImportGlassRaw(m_Server.GetGlassRawInfo(), NULL);
|
|
strcpy(RawData.GetGlassData()->m_strFileName, strFileName.GetBuffer());
|
strcpy(RawData.GetGlassData()->m_strPath, strBinPath.GetBuffer());
|
|
BOOL bRetReadBin = m_pGlassRawMaker->ReadBinFile(&RawData);
|
|
if (bRetReadBin == FALSE)
|
{
|
m_FormationMap.SetAutoScale();
|
LOG(Dbg, _T("[Processe] File Open False"));
|
Imagenoload();
|
return FALSE;
|
}
|
return TRUE;
|
}
|
|
void CReveiwHistoryDlg::GlassInfoRest()
|
{
|
m_Formation.m_vecGlassInfo.clear();
|
|
for (int i = 0; i < 105; i++)
|
{
|
m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nImageSize[i] = 0;
|
}
|
m_gridGlassInfo.SetRowCount(2);
|
m_gridGlassInfo.Invalidate();
|
}
|
|
BOOL CReveiwHistoryDlg::MultiSelectCheck(int nSelectCount)
|
{
|
if (nSelectCount <= 0) return FALSE;
|
|
//if (m_Formation.m_vecGlassInfo.size() > MAX_COUNT) return FALSE;
|
|
int nDefectSize = 0;
|
int nImageSize = 0;
|
int nCellSize = 0;
|
|
for (int i = 0; i < MAX_COUNT+1; i++)
|
{
|
nDefectSize += m_nDefectSize[i];
|
nImageSize += m_nImageSize[i];
|
nCellSize += m_nCellSize[i];
|
|
if (nSelectCount == m_nSelectFile[i])
|
{
|
for (int j = 0; j < m_Formation.m_vecGlassInfo.size(); j++)
|
{
|
_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[j];
|
|
if (pGlassInfo->m_nGlassSelect == m_nSelectFile[i])
|
{
|
m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin() + j);
|
|
if (i == 0)
|
{
|
m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
|
m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
|
m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[i]);
|
m_nCellSize[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nImageSize[i] = 0;
|
}
|
else if (i != 0 && m_nDefectSize[i] == 0)
|
{
|
|
}
|
else if (i != 0 && m_nDefectSize[i] > 0)
|
{
|
if (m_Formation.m_vecDefects.size() == nDefectSize)
|
{
|
m_Formation.m_vecDefects.clear();
|
//m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
|
}
|
// else
|
// {
|
// m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin() + nDefectSize-1, m_Formation.m_vecDefects.begin() + nDefectSize-1 + m_nDefectSize[i]);
|
// }
|
if (m_Formation.m_vecImage.size() == nImageSize)
|
{
|
m_Formation.m_vecImage.clear();
|
//m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
|
}
|
// else
|
// {
|
// m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin() + nImageSize-1, m_Formation.m_vecImage.begin() + nImageSize-1 + m_nImageSize[i]);
|
// }
|
if (m_FormationMap.m_vecCellRect.size() == nCellSize)
|
{
|
m_FormationMap.m_vecCellRect.clear();
|
//m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[i]);
|
}
|
// else
|
// {
|
// m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin() + nCellSize, m_FormationMap.m_vecCellRect.begin() + nCellSize + m_nCellSize[i]);
|
// }
|
|
int nCellCount = 0;
|
int nDefectCount = 0;
|
int nImageCount = 0;
|
|
/* int nCount = 0;*/
|
int nCellCount2 = m_nCellSize[i];
|
int nDefectCount2 = m_nDefectSize[i];
|
int nImageCount2 = m_nImageSize[i];
|
|
int nCellCount3 = 0;
|
int nDefectCount3 = 0;
|
int nImageCount3 = 0;
|
|
|
m_nCellSize[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nImageSize[i] = 0;
|
|
|
|
for (int k = 0; k < MAX_COUNT; k++)
|
{
|
// if (m_nCellSize[k] != 0)
|
// {
|
// nCount++;
|
// }
|
nCellCount = m_nCellSize[k];
|
nDefectCount = m_nDefectSize[k];
|
nImageCount = m_nImageSize[k];
|
|
if (k == 0)
|
{
|
nCellCount3 = 0;
|
nDefectCount3 = 0;
|
nImageCount3 = 0;
|
}
|
else
|
{
|
nCellCount3 += m_nCellSize[k];
|
nDefectCount3 += m_nDefectSize[k];
|
nImageCount3 += m_nImageSize[k];
|
}
|
}
|
|
m_Formation.m_vecDefects.clear();
|
for (int j = 0; j < nDefectSize - nDefectCount2; j++)
|
{
|
_akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[j];
|
double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
m_Formation.m_vecDefects[j] = m_Formation.m_vecTempDefects[j];
|
//디펙 시작 크기 만큼만 복사 한다
|
}
|
if (m_nDefectSize[i + 1] != 0)
|
{
|
int nCount = m_Formation.m_vecDefects.size();
|
for (int j = 0; j < m_Formation.m_vecTempDefects.size() - nDefectSize; j++)
|
{
|
_akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[nDefectSize + j];
|
double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
m_Formation.m_vecDefects[nCount + j] = m_Formation.m_vecTempDefects[nDefectSize +j];
|
}
|
}
|
|
m_Formation.m_vecImage.clear();
|
for (int j = 0; j < nImageSize - nImageCount2; j++)
|
{
|
m_Formation.AddDefectImage();
|
m_Formation.m_vecImage[j] = m_Formation.m_vecTempImage[j];
|
//디펙 시작 크기 만큼만 복사 한다
|
}
|
if (m_nImageSize[i + 1] != 0)
|
{
|
int nCount = m_Formation.m_vecImage.size();
|
for (int j = 0; j < m_Formation.m_vecTempImage.size() - nImageSize; j++)
|
{
|
m_Formation.AddDefectImage();
|
m_Formation.m_vecImage[nCount + j] = m_Formation.m_vecTempImage[nImageSize + j];
|
}
|
}
|
|
m_FormationMap.m_vecCellRect.clear();
|
for (int j = 0; j < nCellSize - nCellCount2; j++)
|
{
|
m_FormationMap.AddCell();
|
m_FormationMap.m_vecCellRect[j] = m_FormationMap.m_vecTempCellRect[j];
|
//디펙 시작 크기 만큼만 복사 한다
|
}
|
|
if (m_nCellSize[i + 1] != 0)
|
{
|
int nCount = m_FormationMap.m_vecCellRect.size();
|
for (int j = 0; j < m_FormationMap.m_vecTempCellRect.size() - nCellSize; j++)
|
{
|
m_FormationMap.AddCell();
|
m_FormationMap.m_vecCellRect[nCount + j] = m_FormationMap.m_vecTempCellRect[nCellSize + j];
|
}
|
}
|
}
|
|
m_nSelectFile[i] = 0;
|
|
// for (int i = 0; i < MAX_COUNT + 1; i++)
|
// {
|
// for (int iCol = 0; iCol < m_gridReviewList.GetColumnCount(); iCol++)
|
// {
|
// m_gridReviewList.SetItemState(m_nSelectFile[i], iCol, LVIS_SELECTED);
|
// }
|
// }
|
//
|
// m_gridReviewList.Invalidate();
|
|
// int nSelect = i;
|
// bool bMax = false;
|
// for (nSelect; nSelect < MAX_COUNT; nSelect++)
|
// {
|
// m_nSelectFile[nSelect] = m_nSelectFile[nSelect + 1];
|
// bMax = true;
|
// }
|
// if (bMax)
|
// {
|
// m_nSelectFile[nSelect] = 0;
|
// }
|
// m_nDefectSize[i] = 0;
|
// m_nImageSize[i] = 0;
|
/* m_nCellSize[i] = 0;*/
|
// for (j = 0; j < MAX_COUNT; j++)
|
// {
|
// if (i <= j)
|
// {
|
// m_nCellSize[j] = m_nCellSize[j + 1];
|
// }
|
// }
|
AddVecCellSorting(0);
|
AddVecDateSorting(0);
|
m_gridGlassInfo.SetRowCount(m_Formation.m_vecGlassInfo.size() + 1);
|
m_gridDefectInfo.SetRowCount(m_Formation.m_vecDefects.size() + 1);
|
m_FormationMap.ReDraw(TRUE);
|
return FALSE;
|
}
|
}
|
}
|
}
|
|
if (m_Formation.m_vecGlassInfo.size() >= MAX_COUNT + 1) // 1 base
|
{
|
m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin());
|
|
if (m_nDefectSize[0] != 0)
|
{
|
m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[0]);
|
}
|
if (m_nImageSize[0] != 0)
|
{
|
m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[0]);
|
}
|
if (m_nCellSize[0] != 0)
|
{
|
m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[0]);
|
}
|
}
|
return TRUE;
|
}
|
|
int CReveiwHistoryDlg::MultiInsert(int nSelectCount, int nDataCount)
|
{
|
if (nSelectCount <= 0) return FALSE;
|
|
//if (m_Formation.m_vecGlassInfo.size() > MAX_COUNT) return FALSE;
|
|
if (m_Formation.m_vecGlassInfo.size() >= MAX_COUNT+1) //1base
|
{
|
m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin());
|
|
if (m_nDefectSize[0] != 0)
|
{
|
m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[0]);
|
}
|
if (m_nImageSize[0] != 0)
|
{
|
m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[0]);
|
}
|
if (m_nCellSize[0] != 0)
|
{
|
m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[0]);
|
}
|
}
|
|
int nDefectSize = 0;
|
int nImageSize = 0;
|
int nCellSize = 0;
|
|
for (int i = 0; i < MAX_COUNT; i++)
|
{
|
nDefectSize += m_nDefectSize[i];
|
nImageSize += m_nImageSize[i];
|
nCellSize += m_nCellSize[i];
|
|
if (nSelectCount == m_nSelectFile[i])
|
{
|
for (int j = 0; j < m_Formation.m_vecGlassInfo.size(); j++)
|
{
|
_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[j];
|
|
if (pGlassInfo->m_nGlassSelect == m_nSelectFile[i])
|
{
|
m_Formation.m_vecGlassInfo.erase(m_Formation.m_vecGlassInfo.begin() + j);
|
|
if (i == 0)
|
{
|
m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
|
m_Formation.m_vecDefects.clear();
|
m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
|
m_Formation.m_vecImage.clear();
|
m_FormationMap.m_vecCellRect.erase(m_FormationMap.m_vecCellRect.begin(), m_FormationMap.m_vecCellRect.begin() + m_nCellSize[i]);
|
|
if (m_bDefectAll == false && !m_chkSingle.GetCheck())
|
{
|
AddVecDataDefct2(nDataCount/*, nCount*/);
|
}
|
else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
|
{
|
AddVecDataDefectAll2(nDataCount/*, nCount*/);
|
}
|
}
|
else if (i != 0 && m_nDefectSize[i] == 0)
|
{
|
if (m_bDefectAll == false && !m_chkSingle.GetCheck())
|
{
|
AddVecDataDefct2(nDataCount/*, nCount*/);
|
}
|
else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
|
{
|
AddVecDataDefectAll2(nDataCount/*, nCount*/);
|
}
|
}
|
else if (i != 0 && m_nDefectSize[i] > 0)
|
{
|
if (m_Formation.m_vecDefects.size() == nDefectSize)
|
{
|
m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin(), m_Formation.m_vecDefects.begin() + m_nDefectSize[i]);
|
}
|
// else
|
// {
|
Sleep(1);
|
//n개 까지만 복사 한다. 클리어 후 에
|
m_Formation.m_vecDefects.clear();
|
for (int j = 0; j < nDefectSize-m_nDefectSize[i]; j++)
|
{
|
_akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[j];
|
double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
m_Formation.m_vecDefects[j] = m_Formation.m_vecTempDefects[j];
|
//디펙 시작 크기 만큼만 복사 한다
|
}
|
//생성된 디펙을 추가 한다
|
if (m_bDefectAll == false && !m_chkSingle.GetCheck())
|
{
|
AddVecDataDefct2(nDataCount/*, nCount*/);
|
}
|
else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
|
{
|
AddVecDataDefectAll2(nDataCount/*, nCount*/);
|
}
|
|
// Sleep(1);
|
//
|
// //추가한 디펙 뒤에 붙여 넣는다
|
// if (m_nDefectSize[i + 1] != 0)
|
// {
|
// for (int j = 0; j < m_nDefectSize[i + 1]; j++)
|
// {
|
// int nCount = m_nDefectSize[i - 1];
|
// _akDefect *pDefectInfo = &m_Formation.m_vecTempDefects[nDefectSize + j];
|
// double dDefectPosX = pDefectInfo->m_nUMCenterAlignX / 1000.0;
|
// double dDefectPosY = pDefectInfo->m_nUMCenterAlignY / 1000.0;
|
//
|
// m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
// m_Formation.m_vecDefects[nCount + j] = m_Formation.m_vecTempDefects[nDefectSize + j];
|
// }
|
// }
|
|
Sleep(1);
|
m_Formation.m_vecImage.clear();
|
for (int j = 0; j < nImageSize - m_nImageSize[i]; j++)
|
{
|
m_Formation.AddDefectImage();
|
m_Formation.m_vecImage[j] = m_Formation.m_vecTempImage[j];
|
//디펙 시작 크기 만큼만 복사 한다
|
}
|
if (m_nImageSize[i + 1] != 0)
|
{
|
int nSize = m_Formation.m_vecTempImage.size() - m_Formation.m_vecImage.size();
|
//시작 부터 끝까지 복사를 한다
|
for (int j = 0; j < nSize; j++)
|
{
|
int nCount = m_nImageSize[i - 1];
|
|
m_Formation.AddDefectImage();
|
m_Formation.m_vecImage[nCount + j] = m_Formation.m_vecTempImage[nCount + j];
|
}
|
}
|
|
Sleep(1);
|
m_FormationMap.m_vecCellRect.clear();
|
for (int j = 0; j < nCellSize - m_nCellSize[i]; j++)
|
{
|
m_FormationMap.AddCell();
|
m_FormationMap.m_vecCellRect[j] = m_FormationMap.m_vecTempCellRect[j];
|
//디펙 시작 크기 만큼만 복사 한다
|
}
|
if (m_nCellSize[i + 1] != 0)
|
{
|
int nSize = m_FormationMap.m_vecTempCellRect.size() - m_FormationMap.m_vecCellRect.size();
|
for (int j = 0; j < nSize; j++)
|
{
|
int nCount = m_nCellSize[i - 1];
|
|
m_FormationMap.AddCell();
|
m_FormationMap.m_vecCellRect[nCount + j] = m_FormationMap.m_vecTempCellRect[nCount + j];
|
//m_FormationMap.m_vecCellRect[nCount + j] = m_FormationMap.m_vecTempCellRect[nCellSize + j];
|
}
|
}
|
|
//m_Formation.m_vecDefects.erase(m_Formation.m_vecDefects.begin() + nDefectSize, m_Formation.m_vecDefects.begin() + nDefectSize + m_nDefectSize[i]);
|
|
// if (m_Formation.m_vecImage.size() == nImageSize)
|
// {
|
// m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin(), m_Formation.m_vecImage.begin() + m_nImageSize[i]);
|
// }
|
// else
|
// {
|
// m_Formation.m_vecImage.erase(m_Formation.m_vecImage.begin() + nImageSize, m_Formation.m_vecImage.begin() + nImageSize + m_nImageSize[i]);
|
// }
|
}
|
|
//m_nSelectFile[i] = 0;
|
m_nDefectSize[i] = 0;
|
m_nImageSize[i] = 0;
|
m_nCellSize[i] = 0;
|
// for (j = 0; j < MAX_COUNT; j++)
|
// {
|
// if (i <= j)
|
// {
|
// m_nCellSize[j] = m_nCellSize[j + 1];
|
// }
|
// }
|
|
if (m_Formation.m_vecGlassInfo.size() > 0)
|
{
|
m_gridGlassInfo.SetRowCount(m_Formation.m_vecGlassInfo.size() + 1);
|
m_gridDefectInfo.SetRowCount(m_Formation.m_vecDefects.size() + 1);
|
return i;
|
}
|
else
|
{
|
m_gridGlassInfo.SetRowCount(2);
|
m_gridDefectInfo.SetRowCount(2);
|
return i;
|
}
|
return i;
|
}
|
}
|
}
|
}
|
|
// if (m_bDefectAll == false && !m_chkSingle.GetCheck())
|
// {
|
// AddVecDataDefct2(nDataCount/*, nCount*/);
|
// }
|
// else if (m_bDefectAll == true && !m_chkSingle.GetCheck())
|
// {
|
// AddVecDataDefectAll2(nDataCount/*, nCount*/);
|
// }
|
return -1;
|
}
|
|
void CReveiwHistoryDlg::InitSelectGlass(int nSelectCount)
|
{
|
int nCountMax = MAX_COUNT+1;
|
bool bMax = false;
|
for (int i = 0; i < MAX_COUNT+1; i++)
|
{
|
if (nSelectCount != m_nSelectFile[i] && m_nSelectFile[i] == 0)
|
{
|
if (!GetCheckFileLoad(nSelectCount)) return;
|
m_nSelectFile[i] = nSelectCount;
|
bMax = true;
|
break;
|
}
|
}
|
if (!bMax)
|
{
|
for (int j = 0; j < MAX_COUNT; j++)
|
{
|
if (!GetCheckFileLoad(nSelectCount)) return;
|
m_nSelectFile[j] = m_nSelectFile[j + 1];
|
}
|
m_nSelectFile[MAX_COUNT] = nSelectCount;
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecDataImage(int nDataCount)
|
{
|
for (int i = 0; i < nDataCount; i++)
|
{
|
_grmDefectData* pDefect = m_Server.GetDefectData(i);
|
_grmGlassData* pGlass = m_Server.GetGlassData();
|
|
CString strTemp;
|
int nInfoCount = 0;
|
|
CString strReviewImageName;
|
strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
|
if (strReviewImageName == "" || strReviewImageName == "*")
|
{
|
continue;
|
}
|
else
|
{
|
m_Formation.AddDefectImage();
|
SetImageCount();
|
_akReviewList* pImageInfo = &m_Formation.m_vecImage[m_Formation.m_vecImage.size() - 1];
|
|
pImageInfo->m_nDefectID = pDefect->m_nDefectID;
|
strcpy(pImageInfo->m_strAoiImageName, pDefect->m_strAoiImageName);
|
pImageInfo->m_nDefectIdx = pDefect->m_nDefectIdx;
|
pImageInfo->m_strReviewImageName = strReviewImageName;
|
|
strcpy(pImageInfo->m_strAoiImagePath, pDefect->m_strAoiImagePath);
|
strcpy(pImageInfo->m_strReviewImagePath, pDefect->m_ReviewDefect.m_strRevImagePath);
|
strcpy(pImageInfo->m_strAlignFirst, pGlass->m_strAlignFirst);
|
strcpy(pImageInfo->m_strAlignSecond, pGlass->m_strAlignSecond);
|
pImageInfo->m_strGlassID = pGlass->m_strGlassID;
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecDataDefct(int nDataCount)
|
{
|
for (int i = 0; i < nDataCount; i++)
|
{
|
_grmDefectData* pDefect = m_Server.GetDefectData(i);
|
|
int nInfoCount = 0;
|
|
CString strReviewImageName;
|
strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
|
if (strReviewImageName == "" || strReviewImageName == "*")
|
{
|
continue;
|
}
|
else
|
{
|
double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
SetDefectCount();
|
_akDefect* pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
|
|
pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
|
pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
|
strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
|
strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
|
pDefectInfo->m_DefectType = pDefect->m_DefectType;
|
pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
|
pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
|
pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
|
pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
|
pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
|
memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
|
pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
|
pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
|
pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
|
pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
|
strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
|
pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
|
pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
|
pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
|
pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
|
pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
|
pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
|
pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
|
pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
|
pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
|
pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
|
pDefectInfo->m_nDensity = pDefect->m_nDensity;
|
pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
|
pDefectInfo->m_nShotIdx = pDefect->m_ReviewDefect.m_nShotIndex;
|
pDefectInfo->m_nModelIdx = pDefect->m_ReviewDefect.m_nModuleIndex;
|
|
for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecDataDefectAll(int nDataCount)
|
{
|
for (int i = 0; i < nDataCount; i++)
|
{
|
_grmDefectData* pDefect = m_Server.GetDefectData(i);
|
int nInfoCount = 0;
|
|
double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
SetDefectCount();
|
_akDefect* pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
|
|
pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
|
pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
|
strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
|
strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
|
pDefectInfo->m_DefectType = pDefect->m_DefectType;
|
pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
|
pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
|
pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
|
pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
|
pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
|
memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
|
pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
|
pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
|
pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
|
pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
|
strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
|
pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
|
pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
|
pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
|
pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
|
pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
|
pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
|
pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
|
pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
|
pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
|
pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
|
pDefectInfo->m_nDensity = pDefect->m_nDensity;
|
pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
|
|
CString strReviewImageName;
|
strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
|
if (strReviewImageName == "" || strReviewImageName == "*")
|
{
|
pDefectInfo->m_nShotIdx = -1;
|
pDefectInfo->m_nModelIdx = -1;
|
}
|
else
|
{
|
pDefectInfo->m_nShotIdx = pDefect->m_ReviewDefect.m_nShotIndex;
|
pDefectInfo->m_nModelIdx = pDefect->m_ReviewDefect.m_nModuleIndex;
|
}
|
|
|
for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecDataDefct2(int nDataCount/*, int nRawCount*/)
|
{
|
// int nCount = MultiInsert(m_nCount, nDataCount);
|
|
// if(nCount < 0) return;
|
//
|
for (int i = 0; i < nDataCount; i++)
|
{
|
_grmDefectData* pDefect = m_Server.GetDefectData(i);
|
|
int nInfoCount = 0;
|
|
CString strReviewImageName;
|
strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
|
if (strReviewImageName == "" || strReviewImageName == "*")
|
{
|
continue;
|
}
|
else
|
{
|
double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
SetDefectCount();
|
|
_akDefect* pDefectInfo = NULL;
|
|
// if (nCount == 0)
|
// {
|
pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
|
// }
|
// else
|
// {
|
// //중간에 값 삽입
|
// pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
|
// //pDefectInfo = &m_Formation.m_vecDefects[nCount + i];
|
// }
|
|
pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
|
pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
|
strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
|
strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
|
pDefectInfo->m_DefectType = pDefect->m_DefectType;
|
pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
|
pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
|
pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
|
pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
|
pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
|
memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
|
pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
|
pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
|
pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
|
pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
|
strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
|
pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
|
pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
|
pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
|
pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
|
pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
|
pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
|
pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
|
pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
|
pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
|
pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
|
pDefectInfo->m_nDensity = pDefect->m_nDensity;
|
pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
|
|
for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecDataDefectAll2(int nDataCount/*, int nRawCount*/)
|
{
|
for (int i = 0; i < nDataCount; i++)
|
{
|
_grmDefectData* pDefect = m_Server.GetDefectData(i);
|
|
int nInfoCount = 0;
|
|
CString strReviewImageName;
|
strReviewImageName = pDefect->m_ReviewDefect.m_strRevImageName;
|
|
double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
SetDefectCount();
|
|
_akDefect* pDefectInfo = NULL;
|
|
pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
|
|
pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
|
pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
|
strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
|
strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
|
pDefectInfo->m_DefectType = pDefect->m_DefectType;
|
pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
|
pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
|
pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
|
pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
|
pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
|
memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
|
pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
|
pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
|
pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
|
pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
|
strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
|
pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
|
pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
|
pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
|
pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
|
pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
|
pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
|
pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
|
pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
|
pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
|
pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
|
pDefectInfo->m_nDensity = pDefect->m_nDensity;
|
pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
|
|
for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
|
}
|
|
// for (int i = 0; i < nDataCount; i++)
|
// {
|
// _grmDefectData* pDefect = m_Server.GetDefectData(i);
|
// int nInfoCount = 0;
|
//
|
// double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
|
// double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
|
//
|
// m_Formation.AddDefect(dDefectPosX, dDefectPosY);
|
// SetDefectCount();
|
//
|
// _akDefect* pDefectInfo = NULL;
|
//
|
// // if (nCount == 0)
|
// // {
|
// pDefectInfo = &m_Formation.m_vecDefects[m_Formation.m_vecDefects.size() - 1];
|
// // }
|
// // else
|
// // {
|
// // pDefectInfo = &m_Formation.m_vecDefects[nCount + i];
|
// // }
|
//
|
// //m_Formation.m_vecDefects.insert(m_Formation.m_vecDefects.begin() + 1400, pDefect->m_nDefectID);
|
//
|
// pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
|
// pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
|
// strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
|
// strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
|
// pDefectInfo->m_DefectType = pDefect->m_DefectType;
|
// pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
|
// pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
|
// pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
|
// pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
|
// pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
|
// memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
|
// pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
|
// pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
|
// pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
|
// pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
|
// strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
|
// pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
|
// pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
|
// pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
|
// pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
|
// pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
|
// pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
|
// pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
|
// pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
|
// pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
|
// pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
|
// pDefectInfo->m_nDensity = pDefect->m_nDensity;
|
// pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
|
//
|
// for (int j = 0; j < nInfoCount; j++) pDefectInfo->m_strInfos[j].Trim();
|
// }
|
}
|
|
void CReveiwHistoryDlg::AddVecGlassData(int nCount)
|
{
|
m_Formation.AddGlassInfo();
|
|
_grmGlassData* pGlass = m_Server.GetGlassData();
|
_akGlassInfo* pGlassInfo = &m_Formation.m_vecGlassInfo[m_Formation.m_vecGlassInfo.size() - 1];
|
|
pGlassInfo->m_nGlassSelect = nCount;
|
pGlassInfo->m_strPPID = pGlass->m_strPPID;
|
pGlassInfo->m_strGlassID = pGlass->m_strGlassID;
|
pGlassInfo->m_nDefectNum = pGlass->m_nDefectNum;
|
pGlassInfo->m_nReviewNum = GetImageCount();
|
pGlassInfo->m_strGlassJudge = pGlass->m_strGlassJudge;
|
pGlassInfo->m_strLotID = pGlass->m_strLotID;
|
pGlassInfo->m_strSLotID = pGlass->m_strSLotID;
|
pGlassInfo->m_nSlot_No = pGlass->m_nSlot_No;
|
pGlassInfo->m_nCellNum = pGlass->m_nCellNum;
|
pGlassInfo->m_nGlassSizeHeight = pGlass->m_nGlassSizeHeight;
|
pGlassInfo->m_nGlassSizeWidth = pGlass->m_nGlassSizeWidth;
|
}
|
|
void CReveiwHistoryDlg::AddVecCellData(int nCellCount)
|
{
|
for (int i = 0; i < nCellCount; i++)
|
{
|
SetCellCount();
|
CakRectd rectCell;
|
_grmCellData* pCellData = m_Server.GetCellData(i);
|
rectCell.left = pCellData->m_rectCellLeft / 1000.0;
|
rectCell.top = pCellData->m_rectCellTop / 1000.0;
|
rectCell.right = pCellData->m_rectCellRight / 1000.0;
|
rectCell.bottom = pCellData->m_rectCellBottom / 1000.0;
|
m_FormationMap.m_vecCellRect.push_back(rectCell);
|
}
|
}
|
|
void CReveiwHistoryDlg::SortListDefect(int nCol)
|
{
|
if (nCol == 0)
|
return;
|
|
/* if (m_pDefectFormation == NULL) return;*/
|
|
m_bAsending = !m_bAsending;
|
|
_akDefect *pDefect;
|
std::vector< std::pair<CString, _akDefect*> > vecString;
|
std::vector< std::pair<double, _akDefect*> > vecValue;
|
CString strValue;
|
double dValue;
|
short sValue[16];
|
|
for (int i = 0; i < m_Formation.m_vecTempDefects.size(); i++)
|
{
|
pDefect = &m_Formation.m_vecTempDefects[i];
|
|
switch (nCol)
|
{
|
case 1: dValue = pDefect->m_nDefectID; break;
|
case 2: dValue = pDefect->m_sDefectLoc; break;
|
case 3: strValue = pDefect->m_strDefectType; break;
|
case 4: strValue = pDefect->m_strDefectCode; break;
|
case 5: dValue = pDefect->m_DefectType; break;
|
case 6: dValue = pDefect->m_DefectSubType; break;
|
case 7: dValue = pDefect->m_nDefectRScale; break;
|
case 8: dValue = pDefect->m_nUMSizeX; break;
|
case 9: dValue = pDefect->m_nUMSizeY; break;
|
case 10: dValue = pDefect->m_nUMSize; break;
|
//case 11: memcpy(sValue, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount)); break;
|
case 12: dValue = pDefect->m_nLevelSrcMax; break;
|
case 13: dValue = pDefect->m_nLevelSrcMin; break;
|
case 14: dValue = pDefect->m_nLevelSrcAvg; break;
|
case 15: dValue = pDefect->m_sDefectPeak; break;
|
case 16: strValue = pDefect->m_strStackFirst; break;
|
case 17: dValue = pDefect->m_nCameraID; break;
|
case 18: dValue = pDefect->m_nScanIdx; break;
|
case 19: dValue = pDefect->m_nLevelRefMax; break;
|
case 20: dValue = pDefect->m_nLevelRefMin; break;
|
case 21: dValue = pDefect->m_nLevelRefAvg; break;
|
case 22: dValue = pDefect->m_nUMCenterAlignX; break;
|
case 23: dValue = pDefect->m_nUMCenterAlignY; break;
|
case 24: dValue = pDefect->m_nUMCellX; break;
|
case 25: dValue = pDefect->m_nUMCellY; break;
|
case 26: dValue = pDefect->m_nScratchRatio; break;
|
case 27: dValue = pDefect->m_nDensity; break;
|
case 28: dValue = pDefect->m_bMergeState; break;
|
}
|
|
if (strValue.IsEmpty() == FALSE) vecString.push_back(std::make_pair(strValue, pDefect));
|
else vecValue.push_back(std::make_pair(dValue, pDefect));
|
}
|
|
if (!vecString.empty())
|
{
|
if (m_bAsending == TRUE) //오름 차순
|
std::sort(vecString.begin(), vecString.end(), std::greater< std::pair<CString, _akDefect*> >());
|
else //내림 차순
|
std::sort(vecString.begin(), vecString.end(), std::less< std::pair<CString, _akDefect*> >());
|
|
m_Formation.m_vecDefects.clear();
|
std::vector< std::pair<CString, _akDefect*> >::iterator itVec;
|
|
for (itVec = vecString.begin(); itVec != vecString.end(); ++itVec)
|
{
|
m_Formation.m_vecDefects.push_back(*itVec->second);
|
}
|
}
|
else//if (!vecString.empty())
|
{
|
if (m_bAsending == TRUE)
|
std::sort(vecValue.begin(), vecValue.end(), std::greater< std::pair<double, _akDefect*> >());
|
else
|
std::sort(vecValue.begin(), vecValue.end(), std::less< std::pair<double, _akDefect*> >());
|
|
m_Formation.m_vecDefects.clear();
|
std::vector< std::pair<double, _akDefect*> >::iterator itVec;
|
|
for (itVec = vecValue.begin(); itVec != vecValue.end(); ++itVec)
|
{
|
m_Formation.m_vecDefects.push_back(*itVec->second);
|
}
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecDateSorting(int nDataCount)
|
{
|
m_Formation.m_vecTempDefects.clear();
|
|
for (int i = 0; i < m_Formation.m_vecDefects.size(); i++)
|
{
|
_akDefect* pDefect = &m_Formation.m_vecDefects[i];
|
|
double dDefectPosX = pDefect->m_nUMCenterAlignX / 1000.0;
|
double dDefectPosY = pDefect->m_nUMCenterAlignY / 1000.0;
|
|
m_Formation.AddDefectTemp(dDefectPosX, dDefectPosY);
|
_akDefect* pDefectInfo = &m_Formation.m_vecTempDefects[i];
|
|
pDefectInfo->m_nDefectID = pDefect->m_nDefectID;
|
pDefectInfo->m_sDefectLoc = pDefect->m_sDefectLoc;
|
strcpy(pDefectInfo->m_strDefectType, pDefect->m_strDefectType);
|
strcpy(pDefectInfo->m_strDefectCode, pDefect->m_strDefectCode);
|
pDefectInfo->m_DefectType = pDefect->m_DefectType;
|
pDefectInfo->m_DefectSubType = pDefect->m_DefectSubType;
|
pDefectInfo->m_nDefectRScale = pDefect->m_nDefectRScale;
|
pDefectInfo->m_nUMSizeX = pDefect->m_nUMSizeX;
|
pDefectInfo->m_nUMSizeY = pDefect->m_nUMSizeY;
|
pDefectInfo->m_nUMSize = pDefect->m_nUMSize;
|
memcpy(pDefectInfo->m_sZonePixelCount, pDefect->m_sZonePixelCount, sizeof(pDefect->m_sZonePixelCount));
|
pDefectInfo->m_nLevelSrcMax = pDefect->m_nLevelSrcMax;
|
pDefectInfo->m_nLevelSrcMin = pDefect->m_nLevelSrcMin;
|
pDefectInfo->m_nLevelSrcAvg = pDefect->m_nLevelSrcAvg;
|
pDefectInfo->m_sDefectPeak = pDefect->m_sDefectPeak;
|
strcpy(pDefectInfo->m_strStackFirst, pDefect->m_strStackFirst);
|
pDefectInfo->m_nCameraID = pDefect->m_nCameraID;
|
pDefectInfo->m_nScanIdx = pDefect->m_nScanIdx;
|
pDefectInfo->m_nLevelRefMax = pDefect->m_nLevelRefMax;
|
pDefectInfo->m_nLevelRefMin = pDefect->m_nLevelRefMin;
|
pDefectInfo->m_nLevelRefAvg = pDefect->m_nLevelRefAvg;
|
pDefectInfo->m_nUMCenterAlignX = pDefect->m_nUMCenterAlignX;
|
pDefectInfo->m_nUMCenterAlignY = pDefect->m_nUMCenterAlignY;
|
pDefectInfo->m_nUMCellX = pDefect->m_nUMCellX;
|
pDefectInfo->m_nUMCellY = pDefect->m_nUMCellY;
|
pDefectInfo->m_nScratchRatio = pDefect->m_nScratchRatio;
|
pDefectInfo->m_nDensity = pDefect->m_nDensity;
|
pDefectInfo->m_bMergeState = pDefect->m_bMergeState;
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecImageSorting(int nDataCount)
|
{
|
m_Formation.m_vecTempImage.clear();
|
|
for (int i = 0; i < m_Formation.m_vecImage.size(); i++)
|
{
|
_akReviewList* pDefect = &m_Formation.m_vecImage[i];
|
|
m_Formation.AddDefectImageTemp();
|
|
_akReviewList* pImageInfo = &m_Formation.m_vecTempImage[i];
|
|
pImageInfo->m_nDefectID = pDefect->m_nDefectID;
|
strcpy(pImageInfo->m_strAoiImageName, pDefect->m_strAoiImageName);
|
pImageInfo->m_nDefectIdx = pDefect->m_nDefectIdx;
|
pImageInfo->m_strReviewImageName = pDefect->m_strReviewImageName;
|
|
strcpy(pImageInfo->m_strAoiImagePath, pDefect->m_strAoiImagePath);
|
strcpy(pImageInfo->m_strReviewImagePath, pDefect->m_strReviewImagePath);
|
|
strcpy(pImageInfo->m_strAlignFirst, pDefect->m_strAlignFirst);
|
strcpy(pImageInfo->m_strAlignSecond, pDefect->m_strAlignSecond);
|
}
|
}
|
|
void CReveiwHistoryDlg::AddVecCellSorting(int nCellCount)
|
{
|
m_FormationMap.m_vecTempCellRect.clear();
|
|
for (int i = 0; i < m_FormationMap.m_vecCellRect.size(); i++)
|
{
|
m_FormationMap.AddCellData();
|
m_FormationMap.m_vecTempCellRect[i] = m_FormationMap.m_vecCellRect[i];
|
}
|
}
|
|
void CReveiwHistoryDlg::SelectCell(int nDataCount)
|
{
|
m_FormationMap.m_vecCellRect.clear();
|
|
if (nDataCount < 1) return;
|
|
int nCellCount = 0;
|
int nCount = 0;
|
int nCount2 = 0;
|
int nCount3 = 0;
|
|
if (nCount == nDataCount) return;
|
|
if (m_Formation.m_vecGlassInfo.size() == 0) return;
|
|
_akGlassInfo* pGlass2 = &m_Formation.m_vecGlassInfo[nDataCount-1];
|
|
nCount2 = pGlass2->m_nCellNum;
|
|
for (int i = 0; i < nDataCount; i++)
|
{
|
if (i == 0)
|
{
|
nCount3 = 0;
|
}
|
else
|
{
|
_akGlassInfo* pGlass = &m_Formation.m_vecGlassInfo[i-1];
|
nCount3 += pGlass->m_nCellNum;
|
}
|
}
|
|
CakRectd rectCell;
|
|
if (m_FormationMap.m_vecTempCellRect.size() - 1 < nCount3) return;
|
|
for (int i = 0; i < nCount2; i++)
|
{
|
CakRectd* pCellData = &m_FormationMap.m_vecTempCellRect[nCount3 + i];
|
rectCell.left = pCellData->left;
|
rectCell.top = pCellData->top;
|
rectCell.right = pCellData->right;
|
rectCell.bottom = pCellData->bottom;
|
m_FormationMap.m_vecCellRect.push_back(rectCell);
|
}
|
|
// for (int i = 0; i < MAX_COUNT+1; i++)
|
// {
|
// if (nCount == nDataCount) break;
|
//
|
// if (m_nCellSize[i] != 0)
|
// {
|
// nCount++;
|
// }
|
// nCellCount = m_nCellSize[i];
|
// nCount2 = i;
|
//
|
// if (i == 0)
|
// {
|
// nCount3 = 0;
|
// }
|
// else
|
// {
|
// nCount3 += m_nCellSize[i-1];
|
// }
|
// }
|
m_FormationMap.ReDraw(TRUE);
|
}
|
|
void CReveiwHistoryDlg::SortFileList(int nCol)
|
{
|
if (nCol == 0)
|
return;
|
|
_akReviewHeader *pReviewHeader;
|
std::vector< std::pair<CString, _akReviewHeader*> > vecString;
|
std::vector< std::pair<double, _akReviewHeader*> > vecValue;
|
CString strValue;
|
double dValue;
|
short sValue[16];
|
|
for (int i = 0; i < m_Formation.m_vecHeaderTemp.size(); i++)
|
{
|
pReviewHeader = &m_Formation.m_vecHeaderTemp[i];
|
|
switch (nCol)
|
{
|
case 1: strValue = pReviewHeader->m_strFileTime; break;
|
case 2: strValue = pReviewHeader->m_strLoading; break;
|
case 3: strValue = pReviewHeader->m_strPPID; break;
|
case 4: strValue = pReviewHeader->m_strGlassID; break;
|
case 5: dValue = pReviewHeader->m_nDefectIdx; break;
|
case 6: dValue = pReviewHeader->m_nReviewIdx; break;
|
case 7: strValue = pReviewHeader->m_strJudge; break;
|
case 8: strValue = pReviewHeader->m_strFileName; break;
|
}
|
|
if (strValue.IsEmpty() == FALSE) vecString.push_back(std::make_pair(strValue, pReviewHeader));
|
else vecValue.push_back(std::make_pair(dValue, pReviewHeader));
|
}
|
|
if (!vecString.empty())
|
{
|
std::sort(vecString.begin(), vecString.end(), std::greater< std::pair<CString, _akReviewHeader*> >());
|
|
m_Formation.m_vecHeader.clear();
|
std::vector< std::pair<CString, _akReviewHeader*> >::iterator itVec;
|
// /*if(nCount > m_nFileCount) break; //count 여기서 말고 전체 파일을 다 읽은 후에 다시 소팅하자*/
|
int nCount = 1;
|
for (itVec = vecString.begin(); itVec != vecString.end(); ++itVec)
|
{
|
if(nCount > m_nFileCount) break;
|
m_Formation.m_vecHeader.push_back(*itVec->second);
|
nCount++;
|
}
|
}
|
else
|
{
|
std::sort(vecValue.begin(), vecValue.end(), std::greater< std::pair<double, _akReviewHeader*> >());
|
|
m_Formation.m_vecHeader.clear();
|
std::vector< std::pair<double, _akReviewHeader*> >::iterator itVec;
|
int nCount = 1;
|
for (itVec = vecValue.begin(); itVec != vecValue.end(); ++itVec)
|
{
|
if (nCount > m_nFileCount) break;
|
m_Formation.m_vecHeader.push_back(*itVec->second);
|
nCount++;
|
}
|
}
|
|
_akReviewHeader *pReview;
|
m_vecStrGridReviewPath.clear();
|
m_vecStrGridReviewList.clear();
|
|
GV_ITEM Item;
|
int nRowIdx = 0;
|
int nColIdx = 0;
|
CString strTemp;
|
Item.mask = GVIF_TEXT;
|
|
for(int i=0; i< m_Formation.m_vecHeader.size(); i++)
|
{
|
pReview = &m_Formation.m_vecHeader[i];
|
m_vecStrGridReviewPath.push_back(pReview->m_strFilePath);
|
m_vecStrGridReviewList.push_back(pReview->m_strFileName);
|
}
|
m_Formation.m_vecHeaderTemp.clear();
|
}
|
