Ongoing90 #3662 CF AOI Review 전설비 알람 발생 조치

LYW

2021-11-09 9ad2aa59da822e9d30c5e0cd677025fe6e12df95

 ReviewHistory/ReveiwHistory/ReveiwHistoryDlg.cpp

@@ -12,6 +12,7 @@
#include "akGridCtrl/GridCellCheck.h"
#include "akImageView.h"
#include <algorithm>
#include "MacroFile.h"

#ifdef _DEBUG
#define new DEBUG_NEW
@@ -54,6 +55,12 @@
CReveiwHistoryDlg::CReveiwHistoryDlg(CWnd* pParent /*=nullptr*/)
   : CDialogEx(IDD_DLG_REVIEWHISTORY, pParent)
   , m_nFileCount(0)
   , m_nEditCamIdx(0)
   , m_nEditScanIdx(0)
   , m_dEditOffsetX(0)
   , m_dEditOffsetY(0)
   , m_strGantryIdx(_T(""))
   , m_TextLastSaveOffsetTime(_T(""))
{
   m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

@@ -73,6 +80,15 @@
   m_nImageCount = 0;
   m_nCellCount = 0;
   m_bAsending = FALSE;
   /*< LYW 20211018 - #3684 ADD Start >*/
   m_dCurDefectIdx = 0;
   m_dCurDefectID = 0;
   /*< LYW 20211018 - #3684 ADD End >*/
   /*< LYW 20211029 - #3684 ADD Start >*/
   DWORD  dwThreadId = 0;
   HANDLE hThread = CreateThread(NULL, 0, RunThreadReviewHistory, this, 0, &dwThreadId);
   m_ThreadId = dwThreadId;
   /*< LYW 20211029 - #3684 ADD End >*/

   for (int i = 0; i < 105; i++)
   {
@@ -83,6 +99,13 @@
      m_nImageSize[i] = 0;
   }
}

/*< LYW 20211029 - #3684 ADD Start >*/
CReveiwHistoryDlg::~CReveiwHistoryDlg(void)
{
   PostThreadMessage(m_ThreadId, WM_QUIT, 0, 0);
}
/*< LYW 20211029 - #3684 ADD End >*/

void CReveiwHistoryDlg::DoDataExchange(CDataExchange* pDX)
{
@@ -97,6 +120,12 @@
   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);
   DDX_Text(pDX, IDC_EDIT_OFFSET_CAM_IDX, m_nEditCamIdx);
   DDX_Text(pDX, IDC_EDIT_OFFSET_SCAN_IDX, m_nEditScanIdx);
   DDX_Text(pDX, IDC_EDIT_OFFSET_X, m_dEditOffsetX);
   DDX_Text(pDX, IDC_EDIT_OFFSET_Y, m_dEditOffsetY);
   DDX_Text(pDX, IDC_EDIT_DFFSET_GANTRY_IDX, m_strGantryIdx);
   DDX_Text(pDX, IDC_STATIC_LAST_SAVE_OFFSET_TIME, m_TextLastSaveOffsetTime);
}

BEGIN_MESSAGE_MAP(CReveiwHistoryDlg, CDialogEx)
@@ -109,6 +138,8 @@
   ON_BN_CLICKED(IDC_BUTTON_MAPVIEW_FIT, &CReveiwHistoryDlg::OnBnClickedButtonMapviewFit)
   ON_MESSAGE(UM_FORMMAP_DEFECTSELECT, OnMapDefectSelected)
   ON_MESSAGE(UM_FORMMAP_DEFECTMOUSEOVER, OnMapDefectMouseOver)
   ON_MESSAGE(UM_WARNING_OFFSET, OnDisplayWarning)
   ON_MESSAGE(UM_FORMMAP_IMAGEMOUSECLICK, OnImageClick)
   ON_COMMAND(ID_OPTION_PATHSETTING, &CReveiwHistoryDlg::OnOptionPathsetting)
   ON_COMMAND(ID_VIEW_ALLDEFECT, &CReveiwHistoryDlg::OnViewAlldefect)
   ON_COMMAND(ID_VIEW_REVIEWDEFECT, &CReveiwHistoryDlg::OnViewReviewdefect)
@@ -121,6 +152,9 @@
   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)
   ON_WM_KEYDOWN()
   ON_BN_CLICKED(IDC_BUTTON_OFFSET_APPLY, &CReveiwHistoryDlg::OnBnClickedButtonOffsetApply)
   ON_BN_CLICKED(IDC_BUTTON_OFFSET_SAVE, &CReveiwHistoryDlg::OnBnClickedButtonOffsetSave)
END_MESSAGE_MAP()

// CReveiwHistoryDlg 메시지 처리기
@@ -219,6 +253,11 @@

   m_ctlProgress.SetRange(0, 100);
   m_ctlProgress.ShowWindow(FALSE);

   /*< LYW 20211025 - #3684 ADD Start >*/
   InitDataInfo();
   PostThreadMessage(m_ThreadId, UM_THREAD_LOADING_OFFSET, 0, 0);
   /*< LYW 20211025 - #3684 ADD End >*/

   return TRUE;  // 포커스를 컨트롤에 설정하지 않으면 TRUE를 반환합니다.
}
@@ -738,7 +777,7 @@

         return TRUE;
      }
      else if (NM_CLICK == pDispInfo->hdr.code)
      else if (NM_CLICK == pDispInfo->hdr.code || LVN_ITEMCHANGING == pDispInfo->hdr.code)
      {
         if (pDispInfo->item.row == 0)
         {
@@ -864,7 +903,7 @@

         return TRUE;
      }
      else if (NM_CLICK == pDispInfo->hdr.code)
      else if (NM_CLICK == pDispInfo->hdr.code || LVN_ITEMCHANGING == pDispInfo->hdr.code)
      {
         if (pDispInfo->item.row == 0)
         {
@@ -878,6 +917,7 @@
               _akDefect* pDefectInfo = &m_Formation.m_vecDefects[pDispInfo->item.row - 1];

               m_FormationMap.setSelectDefect(pDefectInfo->m_nDefectID);
					
               //ImageShow(pDefectInfo->m_nDefectID);
               if (!m_bDefectAll)
               {
@@ -1209,6 +1249,12 @@
   return 0;
}

LRESULT CReveiwHistoryDlg::OnDisplayWarning(WPARAM wParam, LPARAM lParam)
{
   AfxMessageBox(_T("선택하신 리뷰 데이터는 지금 적용된 OFFSET 데이터 이전의 데이터 입니다. 확실한 경우가 아니라면 OFFSET 셋팅을 금해주십시오."), MB_OK | MB_ICONWARNING);
   return 0;
}

LRESULT CReveiwHistoryDlg::OnListDefectSelected(WPARAM wParam, LPARAM lParam)
{
   int nSelectDefect = static_cast<int>(wParam);
@@ -1218,6 +1264,62 @@

   return 0;
}

/*< LYW 20211018 - #3684 ADD Start >*/
LRESULT CReveiwHistoryDlg::OnImageClick(WPARAM wParam, LPARAM lParam)
{
   CPathSettingDlg* lpDlg = CPathSettingDlg::GetMgr();
   if (lpDlg == NULL) return 0;
	
   _akDefect         *pDefect;
    pDefect = &m_Formation.m_vecDefects[m_dCurDefectIdx];
   if (pDefect == NULL) return 0;

   CPoint Point;
   Point.x = GET_X_LPARAM(lParam);
   Point.y = GET_Y_LPARAM(lParam);

   int dOffsetDrectionX;
   int dOffsetDrectionY;

   if (lpDlg->m_comboDirectionX.GetCurSel() == 1) dOffsetDrectionX = -1;
   else dOffsetDrectionX = 1;

   if (lpDlg->m_comboDirectionY.GetCurSel() == 1) dOffsetDrectionY = -1;
   else dOffsetDrectionY = 1;

   if (pDefect->m_nDefectID == m_dCurDefectID)
   {
      m_nEditCamIdx = pDefect->m_nCameraID;
      m_nEditScanIdx = pDefect->m_nScanIdx;
      m_nCurModelIdx = pDefect->m_nModelIdx;
      if (m_nCurModelIdx == 0)
      {
         m_strGantryIdx = _T("Left");
         m_dEditOffsetX = (double)(dOffsetDrectionX * (Point.x / 5)) / 1000;
         m_dEditOffsetY = (double)-(dOffsetDrectionY * (Point.y / 5)) / 1000;
      }
      else if (m_nCurModelIdx == 1)
      {
         m_strGantryIdx = _T("Right");
         m_dEditOffsetX = (double)-(dOffsetDrectionX * (Point.x / 5)) / 1000;
         m_dEditOffsetY = (double)-(dOffsetDrectionY * (Point.y / 5)) / 1000;
      }
      else AfxMessageBox(_T("겐트리 인덱스가 비정상 입니다."), MB_OK | MB_ICONWARNING);
   }

   else
   {
      if (IDOK == AfxMessageBox(_T("이미지 인덱스가 일치하지 않습니다."), MB_OK | MB_ICONWARNING))
      {
         return 0;
      }
   }

   UpdateData(FALSE);
   return 0;
}
/*< LYW 20211018 - #3684 ADD End >*/

LRESULT CReveiwHistoryDlg::OnMapDefectMouseOver(WPARAM wParam, LPARAM lParam)
{
@@ -1357,6 +1459,8 @@
      nSecond = write_local_time.wSecond;
      CString strTime;
      strTime.Format("%04d-%02d-%02d-%02d-%02d-%02d", nYear, nMonth, nDay, nHour, nMinute, nSecond);

      CloseHandle(h_File);
      
      m_vecStrGridTimeList.push_back(strTime);
   }
@@ -1474,6 +1578,12 @@
      Imagenoload();
      return;
   }

   /*< LYW 20211028 - #3684 ADD Start >*/
   CString strBinFileName;
   strBinFileName.Format("%s\\%s", strBinPath, strFileName);
   m_CurrentResultFileTime = GetCurrentResultFileTime(strBinFileName);
   /*< LYW 20211028 - #3684 ADD End >*/

   if (bNewFile && m_chkSingle.GetCheck())
   {
@@ -1700,6 +1810,12 @@
   {
      SetScrollSetting();
   }
   /*< LYW 20211028 - #3684 ADD Start >*/
   if (m_LastSaveOffsetTime >= m_CurrentResultFileTime)
   {
      PostThreadMessage(m_ThreadId, UM_THREAD_WARNING_OFFSET, 0, 0);
   }
   /*< LYW 20211028 - #3684 ADD End >*/
}

void CReveiwHistoryDlg::OnCbnSelchangeComboRawtype()
@@ -2021,6 +2137,13 @@
      }
   }
   _akReviewList* pImageInfo = &m_Formation.m_vecImage[nIndex];
   m_dCurDefectID = pImageInfo->m_nDefectID;
    m_dCurDefectIdx = nIndex;
//    _akDefect         *pDefect;
//    pDefect = &m_Formation.m_vecDefects[nIndex];
//    m_dCurDefectCam = pDefect->m_nCameraID;
//    m_dCurDefectModuleIdx = pDefect->m_nModelIdx;
//    m_dCurDefectScan = pDefect->m_nScanIdx;
   //몇 번째 인지 던진다.

   CString wekfjlwe = pImageInfo->m_strReviewImageName;
@@ -2560,8 +2683,10 @@
   int center_y = (SrcImage.GetHeight() / 2); // 회전 중심점

   double seta = 3.14 / (180.0 / degree); // 라디안
   double CosSeta = cos(seta);
   double SinSeta = sin(seta);
   double CosSeta = -1;
   double SinSeta = 0;
//    double CosSeta = cos(seta);
//    double SinSeta = sin(seta);

   for (int y = 0; y < Height; y++)
   {
@@ -2603,6 +2728,63 @@
   m_ctlFileCount.GetWindowText(strCount);
   m_nFileCount = _ttoi(strCount);
}

/*< LYW 20211028 - #3684 ADD Start >*/
void CReveiwHistoryDlg::UpdateLastSaveOffsetTime(CString FileName)
{

   HANDLE h_file = CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

   FILETIME create_time, access_time, write_time;
   GetFileTime(h_file, &create_time, &access_time, &write_time);

   SYSTEMTIME access_system_time;
   FileTimeToSystemTime(&access_time, &access_system_time);

   SYSTEMTIME access_system_Local_time;
   SystemTimeToTzSpecificLocalTime(NULL, &access_system_time, &access_system_Local_time);

   CTime FIleTime(access_system_Local_time);
   m_LastSaveOffsetTime = FIleTime;

   CloseHandle(h_file);

   m_TextLastSaveOffsetTime.Format(_T("%04d/%02d/%02d/%02d:%02d:%02d"), m_LastSaveOffsetTime.GetYear(), m_LastSaveOffsetTime.GetMonth(), 
      m_LastSaveOffsetTime.GetDay(), m_LastSaveOffsetTime.GetHour(), m_LastSaveOffsetTime.GetMinute(), m_LastSaveOffsetTime.GetSecond());

   UpdateData(FALSE);
}
CTime CReveiwHistoryDlg::GetCurrentResultFileTime(CString FileName)
{
   HANDLE h_file = CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

   if (h_file != INVALID_HANDLE_VALUE)
   {
      FILETIME create_time, access_time, write_time;
      GetFileTime(h_file, &create_time, &access_time, &write_time);

      SYSTEMTIME access_system_time;
      FileTimeToSystemTime(&access_time, &access_system_time);

      SYSTEMTIME access_system_Local_time;
      SystemTimeToTzSpecificLocalTime(NULL, &access_system_time, &access_system_Local_time);

      CloseHandle(h_file);

      CTime FIleTime(access_system_Local_time);
      m_CurrentResultFileTime = FIleTime;

      return m_CurrentResultFileTime;
   }
	
   else
   {
      return CTime::GetCurrentTime();
   }


}
/*< LYW 20211028 - #3684 ADD End >*/

BOOL CReveiwHistoryDlg::GetCheckFileLoad(int nCount)
{
@@ -3828,3 +4010,385 @@
   }
   m_Formation.m_vecHeaderTemp.clear();
}


void CReveiwHistoryDlg::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
   // TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.

   CDialogEx::OnKeyDown(nChar, nRepCnt, nFlags);
}

/*< LYW 20211025 - #3684 ADD Start >*/
void CReveiwHistoryDlg::OnBnClickedButtonOffsetApply()
{
   // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
   ApplyOffset(m_nCurModelIdx, m_nEditCamIdx, m_nEditScanIdx, m_dEditOffsetX, m_dEditOffsetY);
}


void CReveiwHistoryDlg::OnBnClickedButtonOffsetSave()
{
   // TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
   SaveOffset();
}

BOOL CReveiwHistoryDlg::LoadOffset(CString strFilePath)
{
   //dBarValue = 0;
   CMacroFile macroFile;

   if (!macroFile.Read(strFilePath))
      return FALSE;

   UpdateLastSaveOffsetTime(strFilePath);

   macroFile.GetItem(_T("CAMERA_COUNT"), m_nCameraCount, 0);
   macroFile.GetItem(_T("SCAN_COUNT"), m_nScanCount, 0);
   macroFile.GetItem(_T("XPOS_COUNT"), m_XposCount, 0);
   CString strItem = _T("");
   double dXoffset = 0;
   double dYoffset = 0;
   double dXMin = 0;
   double dXMAX = 0;

   double dValue = 0;
   dValue = 2 * CAM_MAX_COUNT*SCAN_MAX_COUNT;
   dValue = 1600 / dValue;

   for (int nModuleidx = 0; nModuleidx < 2; nModuleidx++)
   {
      for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
      {
         for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
         {

            for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
            {

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_X"), nModuleidx, nCamidx, nScanidx, nXposIndex);
               macroFile.GetItem(strItem, dXoffset);


               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_Y"), nModuleidx, nCamidx, nScanidx, nXposIndex);
               macroFile.GetItem(strItem, dYoffset);

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MIN"), nModuleidx, nCamidx, nScanidx, nXposIndex);
               macroFile.GetItem(strItem, dXMin);

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MAN"), nModuleidx, nCamidx, nScanidx, nXposIndex);
               macroFile.GetItem(strItem, dXMAX);

               SetInputOffSet(nModuleidx, nCamidx, nScanidx, nXposIndex, dXoffset, dYoffset, dXMin, dXMAX);

            }
            //IncressProcessBar(dValue);
         }
      }
   }

   return TRUE;

}

BOOL CReveiwHistoryDlg::SaveOffset()
{
   //dBarValue = 0;

   CString strForderPath;
   CString strFileName;
   CTime time = CTime::GetCurrentTime();
   /*< LYW 20211028 - #3684 ADD Start >*/
   m_LastSaveOffsetTime = time;
   /*< LYW 20211028 - #3684 ADD End >*/
   strFileName.Format(_T("ReviewOffSet_%04d%02d%02d%02d%02d%02d.cfg"), time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
   strForderPath.Format(_T("%s%s"), REVIEW_OFFSET_BACKUP_FORDER_PATH, strFileName);

   CopyFile(REVIEW_OFFSET_CONFIGFILE_FULL_PATHNAME, strForderPath, FALSE);

   BOOL bReturn = FALSE;
   CString strTemp;
   int nTemp;
   double dTemp;

   CMacroFile macroFile;
   macroFile.Clear();

   CString strItem = _T("");


   strItem.Format(_T("CAMERA_COUNT"));
   macroFile.SetItem(strItem, m_nCameraCount);

   strItem.Format(_T("SCAN_COUNT"));
   macroFile.SetItem(strItem, m_nScanCount);

   strItem.Format(_T("XPOS_COUNT"));
   macroFile.SetItem(strItem, m_XposCount);


   CString strData;
   double dData = 0;
   for (int nModuleidx = 0; nModuleidx < 2; nModuleidx++)
   {
      for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
      {
         for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
         {

            for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
            {

               OffSetInfo pOffSet = GetOffSetInfo(nModuleidx, nCamidx, nScanidx, nXposIndex);

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_X"), nModuleidx, nCamidx, nScanidx);
               dData = pOffSet.dXoffSetValue;
               macroFile.SetItem(strItem, dData);

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_Y"), nModuleidx, nCamidx, nScanidx);
               dData = pOffSet.dYoffSetValue;
               macroFile.SetItem(strItem, dData);

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MIN"), nModuleidx, nCamidx, nScanidx);
               dData = pOffSet.dXposMin;
               macroFile.SetItem(strItem, dData);

               strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MAN"), nModuleidx, nCamidx, nScanidx);
               dData = pOffSet.dXposMax;
               macroFile.SetItem(strItem, dData);
            }
            //IncressProcessBar(5);
         }
      }
   }

   CString strFilePath;
   strFilePath.Format(_T("%s%s"), REVIEW_OFFSET_CONFIGFILE_PATH, REVIEW_OFFSET_CONFIGFILE_NAME);

   bReturn = macroFile.Write(strFilePath);

   if (bReturn)
   {
      /*< LYW 20211028 - #3684 ADD Start >*/
      UpdateLastSaveOffsetTime(strFilePath);
      AfxMessageBox(_T("OFFSET SAVE SUCCESS"), MB_OK | MB_ICONASTERISK);
      /*< LYW 20211028 - #3684 ADD End >*/
   }
   else AfxMessageBox(_T("OFFSET SAVE FAIL"), MB_OK | MB_ICONHAND);

   return bReturn;
}

BOOL CReveiwHistoryDlg::ApplyOffset(int nModuleidx, int nCamIndex, int ScanIndex, double dXOffsetValue, double dYOffsetValue)
{
   if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
   {
      return FALSE;
   }

   if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
   {
      return FALSE;
   }


   if (nModuleidx == 0)
   {
      VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
      VecOffSetData* pData = &pScandata->at(ScanIndex);
      OffSetInfo* pOffSetData = &pData->at(0);
      if (pOffSetData->bCheckSave == TRUE)
      {
         AfxMessageBox(_T("이미 저장한 OFFSET 입니다. 다시 셋팅을 원하시면 프로그램을 재시작 해주세요"), MB_OK | MB_ICONWARNING);
         return FALSE;
      }
      else
      {
         pOffSetData->dXoffSetValue += dXOffsetValue;
         pOffSetData->dYoffSetValue += dYOffsetValue;
         pOffSetData->bCheckSave = TRUE;
      }
   }
   else if (nModuleidx == 1)
   {
      VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
      VecOffSetData* pData = &pScandata->at(ScanIndex);
      OffSetInfo* pOffSetData = &pData->at(0);
      if (pOffSetData->bCheckSave == TRUE)
      {
         AfxMessageBox(_T("이미 저장한 OFFSET 입니다. 다시 셋팅을 원하시면 프로그램을 재시작 해주세요"), MB_OK | MB_ICONWARNING);
         return FALSE;
      }
      else
      {
         pOffSetData->dXoffSetValue += dXOffsetValue;
         pOffSetData->dYoffSetValue += dYOffsetValue;
         pOffSetData->bCheckSave = TRUE;
      }
   }
   else
   {
      return FALSE;
   }
}

BOOL CReveiwHistoryDlg::SetInputOffSet(int nModuleidx, int nCamIndex, int ScanIndex, int nXposIndex, double dXOffsetValue, double dYOffsetValue, double dXposMin, double dXposMax, BOOL bCheckSave/* = 0*/)
{
   if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
   {
      return FALSE;
   }

   if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
   {
      return FALSE;
   }


   if (nModuleidx == 0)
   {
      VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
      VecOffSetData* pData = &pScandata->at(ScanIndex);
      OffSetInfo* pOffSetData = &pData->at(nXposIndex);
      pOffSetData->dXoffSetValue = dXOffsetValue;
      pOffSetData->dYoffSetValue = dYOffsetValue;
      pOffSetData->dXposMin = dXposMin;
      pOffSetData->dXposMax = dXposMax;
      pOffSetData->bCheckSave = bCheckSave;

   }
   else if (nModuleidx == 1)
   {
      VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
      VecOffSetData* pData = &pScandata->at(ScanIndex);
      OffSetInfo* pOffSetData = &pData->at(nXposIndex);
      pOffSetData->dXoffSetValue = dXOffsetValue;
      pOffSetData->dYoffSetValue = dYOffsetValue;
      pOffSetData->dXposMin = dXposMin;
      pOffSetData->dXposMax = dXposMax;
      pOffSetData->bCheckSave = bCheckSave;
   }
   else
   {
      return FALSE;
   }
}

void CReveiwHistoryDlg::InitDataInfo()
{
   //미리 공간 할당
   for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
   {

      VecOffSetScanData pVecScanData;
      for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
      {
         VecOffSetData     pVecData;
         for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
         {

            OffSetInfo pInfo;
            pInfo.nXposIndex = nXposIndex;
            pInfo.nScanIndex = nScanidx;
            pInfo.nCamIndex = nCamidx;
            pVecData.push_back(pInfo);

         }
         pVecScanData.push_back(pVecData);

      }

      m_vecOffSetCameraInfo.push_back(pVecScanData);
   }

   for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
   {

      VecOffSetScanData pVecScanData;
      for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
      {
         VecOffSetData     pVecData;
         for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
         {

            OffSetInfo pInfo;
            pInfo.nXposIndex = nXposIndex;
            pInfo.nScanIndex = nScanidx;
            pInfo.nCamIndex = nCamidx;
            pVecData.push_back(pInfo);

         }
         pVecScanData.push_back(pVecData);

      }

      m_vecOffSetCameraInfo2.push_back(pVecScanData);
   }

}

OffSetInfo CReveiwHistoryDlg::GetOffSetInfo(int nModuleidx, int nCamIndex, int ScanIndex, int nXposIndex)
{
   OffSetInfo pOFF;
   if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
   {
      return pOFF;
   }

   if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
   {
      return pOFF;
   }


   if (nModuleidx == 0)
   {
      VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
      VecOffSetData* pData = &pScandata->at(ScanIndex);
      OffSetInfo* pOffSetData = &pData->at(nXposIndex);

      return *pOffSetData;
   }
   else if (nModuleidx == 1)
   {
      VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
      VecOffSetData* pData = &pScandata->at(ScanIndex);
      OffSetInfo* pOffSetData = &pData->at(nXposIndex);
      return *pOffSetData;
   }
   else
   {
      return pOFF;
   }
}
/*< LYW 20211025 - #3684 ADD End >*/

/*< LYW 20211029 - #3684 ADD Start >*/
DWORD RunThreadReviewHistory(LPVOID param)
{
   MSG msg;
   CString strPath = _T("");
   CReveiwHistoryDlg* pDlg = (CReveiwHistoryDlg*)param;
   while (GetMessage(&msg, NULL, 0, 0))
   {
      //CString* pstrLog = reinterpret_cast<CString*>(msg.wParam);
      switch (msg.message)
      {
      case UM_THREAD_WARNING_OFFSET:
			
         Sleep(100);
         pDlg->PostMessage(UM_WARNING_OFFSET);
         break;

      case UM_THREAD_LOADING_OFFSET:
         strPath.Format(_T("%s%s"), REVIEW_OFFSET_CONFIGFILE_PATH, REVIEW_OFFSET_CONFIGFILE_NAME);
         pDlg->LoadOffset(strPath);
         break;

      default:
         break;
      }
   }
   return 0;
}
/*< LYW 20211029 - #3684 ADD End >*/