1. 修复离线测试设置错误的扫描个数，应该设置的是需要扫描的个数（非相机个数）

mrDarker

2025-08-16 1e751a5eb3c23d932b5de94456b5a8741f28c7cc

 EdgeInspector_App/DlgSideDimensionSetting.cpp

@@ -53,52 +53,98 @@
void CDlgSideDimensionSetting::SetDlgRecipe(CGlassRecipe* pDlgRecipe)
{
   m_pDlgRecipe = pDlgRecipe;

   UpdateRecipe(FALSE);
}

void CDlgSideDimensionSetting::UpdateRecipe(BOOL bGetData)
{
   // Title
   if(m_pSelectSideIdx != NULL)
   {
      CString strTemp;
      strTemp.Format(_T("[%s] Dim. Setting"), g_SideName[(int) *(m_pSelectSideIdx)]);
      SetDlgItemText(IDC_STATIC_TITLE, strTemp);

      strTemp.Format(_T("Top Corner [%s] Dim. Setting"), g_SideName[(int) *(m_pSelectSideIdx)]);
      SetDlgItemText(IDC_STATIC_TITLE_TOP_CORNER, strTemp);

      strTemp.Format(_T("Bot Corner [%s] Dim. Setting"), g_SideName[(int) *(m_pSelectSideIdx)]);
      SetDlgItemText(IDC_STATIC_TITLE_BOT_CORNER, strTemp);
   }

   if(bGetData == FALSE)
   {
   if(bGetData == FALSE) {
      Fill_SideDimensionSetting(bGetData);
      Fill_TopCornerDimensionSetting(bGetData);
      Fill_BotCornerDimensionSetting(bGetData);
   }
   else
   {
   else {
      Fill_SideDimensionSetting(bGetData);
      Fill_TopCornerDimensionSetting(bGetData);
      Fill_BotCornerDimensionSetting(bGetData);
   }
}

void CDlgSideDimensionSetting::RefreshSideUI(BOOL bReinitGrid /*=TRUE*/)
{
   if (!m_pSelectSideIdx) { 
      return;
   }

   const int nSideIdx = *m_pSelectSideIdx;
   const DimensionDir eDim = (DimensionDir)nSideIdx;
   m_bIsRipSide = (DIMENSION_A_RIP == eDim) || (DIMENSION_B_RIP == eDim) || (DIMENSION_C_RIP == eDim) || (DIMENSION_D_RIP == eDim);

   CString strTemp;
   strTemp.Format(_T("[%s] Dim. Setting"), g_SideName[nSideIdx]);
   SetDlgItemText(IDC_STATIC_TITLE, strTemp);

   strTemp.Format(_T("Top Corner [%s] Dim. Setting"), g_SideName[nSideIdx]);
   SetDlgItemText(IDC_STATIC_TITLE_TOP_CORNER, strTemp);

   strTemp.Format(_T("Bot Corner [%s] Dim. Setting"), g_SideName[nSideIdx]);
   SetDlgItemText(IDC_STATIC_TITLE_BOT_CORNER, strTemp);

   if (CWnd* p = GetDlgItem(IDC_BUTTON_CAL)) {
      p->EnableWindow(!m_bIsRipSide);
   }

   if (CWnd* p = GetDlgItem(IDC_BUTTON_GET_SIDE_RESULT)) {
      p->EnableWindow(!m_bIsRipSide);
   }

   if (bReinitGrid) {
      Init_SideDimensionSetting();
   }
}

void CDlgSideDimensionSetting::Init_SideDimensionSetting()
{
   if (m_SideDimensionSetting.GetSafeHwnd() == NULL)
   if (m_SideDimensionSetting.GetSafeHwnd() == NULL) {
      return;
   }

   int nRows = 1;
   int nCols = 9 + 3;
   if (m_pSelectSideIdx == nullptr) {
      return;
   }

   int nFixRows = 1;
   int nFixCols = 0;
   int nRowIdx = 0;
   int nColIdx = 0;
   auto ScaleX = [&](int px)->int {
      HDC hdc = ::GetDC(m_hWnd);
      const int dpi = GetDeviceCaps(hdc, LOGPIXELSX);
      ::ReleaseDC(m_hWnd, hdc);
      return MulDiv(px, dpi, 96);
   };

   struct ColDef { int w; LPCTSTR name; };
   static const ColDef kColsRip[] = {
      { 90, _T("No.") },
      { 100, _T("Start Line To Y(um)") },
      { 100, _T("Use Dim.") },
   };
   static const ColDef kColsNormal[] = {
      { 90, _T("No.") },
      { 70, _T("Top Mark To Y(um)") },
      { 70, _T("Use Dim.") },
      { 70, _T("Thres") },
      { 70, _T("Std(mm)") },
      { 70, _T("Min(mm)") },
      { 70, _T("Max(mm)") },
      { 70, _T("Off(mm)") },
      { 70, _T("Use Chamfer") },
      { 70, _T("Std(mm)") },
      { 70, _T("Min(mm)") },
      { 70, _T("Max(mm)") },
   };
   const ColDef* cols = m_bIsRipSide ? kColsRip : kColsNormal;
   const int nCols = m_bIsRipSide ? (int)_countof(kColsRip) : (int)_countof(kColsNormal);
   const int nRows = 1;
   const int nFixRows = 1;
   const int nFixCols = 0;

   m_SideDimensionSetting.DeleteAllItems();
   m_SideDimensionSetting.SetVirtualMode(FALSE);
@@ -112,15 +158,12 @@
   m_SideDimensionSetting.SetFixedRowCount(nFixRows);
   m_SideDimensionSetting.SetFixedColumnCount(nFixCols);

   CFont *pFont = m_SideDimensionSetting.GetFont();
   if (pFont)
   {
      LOGFONT lf;
      pFont->GetLogFont(&lf);
   if (CFont* pFont = m_SideDimensionSetting.GetFont()) {
      LOGFONT lf{}; pFont->GetLogFont(&lf);
      lf.lfItalic = 0;
      lf.lfHeight = 14;
      lf.lfWeight = FW_BOLD;
      _tcscpy_s(lf.lfFaceName, _T("Arial"));
      lf.lfHeight = 14;

      m_SideDimensionSetting.GetDefaultCell(FALSE, TRUE)->SetFont(&lf);
      m_SideDimensionSetting.GetDefaultCell(TRUE, FALSE)->SetFont(&lf);
@@ -128,31 +171,10 @@
      m_SideDimensionSetting.GetDefaultCell(TRUE, TRUE)->SetFont(&lf);
   }

   // Col
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 90);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("No."));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 100);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Top Mark To Y(um)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Use Dim."));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Thres"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Std(mm)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Min(mm)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Max(mm)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Off(mm)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Use Chamfer"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Std(mm)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Min(mm)"));
   m_SideDimensionSetting.SetColumnWidth(nColIdx, 70);
   m_SideDimensionSetting.SetItemText(nRowIdx, nColIdx++, _T("Max(mm)"));
   for (int c = 0; c < nCols; ++c) {
      m_SideDimensionSetting.SetColumnWidth(c, ScaleX(cols[c].w));
      m_SideDimensionSetting.SetItemText(0, c, cols[c].name);
   }

   m_SideDimensionSetting.SetFixedRowSelection(FALSE);
   m_SideDimensionSetting.SetFixedColumnSelection(FALSE);
@@ -165,145 +187,147 @@

void CDlgSideDimensionSetting::Fill_SideDimensionSetting(BOOL bGetData)
{
   if(m_SideDimensionSetting.GetSafeHwnd() == NULL)
   if (m_SideDimensionSetting.GetSafeHwnd() == NULL) {
      return;
   }

   if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
   if (m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL) {
      return;
   }

   int nSideIdx = *(m_pSelectSideIdx);

   if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
   if (nSideIdx < 0 || nSideIdx >= eRcp_SideRD_End) {
      return;
   }

   int c = 0;
   const int COL_NO = c++;
   const int COL_TOPMARK_Y = c++;
   const int COL_USE_DIM = c++;

   int COL_THRES = -1, COL_STD = -1, COL_MIN = -1, COL_MAX = -1, COL_OFF = -1;
   int COL_CHAMFER_USE = -1, COL_CH_STD = -1, COL_CH_MIN = -1, COL_CH_MAX = -1;

   if (!m_bIsRipSide) {
      COL_THRES = c++;
      COL_STD = c++;
      COL_MIN = c++;
      COL_MAX = c++;
      COL_OFF = c++;
      COL_CHAMFER_USE = c++;
      COL_CH_STD = c++;
      COL_CH_MIN = c++;
      COL_CH_MAX = c++;
   }

   // 单元格读写封装
   auto SetCell = [&](int r, int col, LPCTSTR s) { m_SideDimensionSetting.SetItemText(r, col, s); };
   auto SetCellInt = [&](int r, int col, int v) { CString t; t.Format(_T("%d"), v); SetCell(r, col, t); };
   auto SetCellDouble = [&](int r, int col, double v, int prec = 3) { CString t; t.Format(_T("%.*f"), prec, v); SetCell(r, col, t); };
   auto SetCellBool = [&](int r, int col, BOOL b) { CString t; t.Format(_T("%d"), b ? 1 : 0); SetCell(r, col, t); };
   auto GetCellStr = [&](int r, int col)->CString { CString s = m_SideDimensionSetting.GetItemText(r, col); s.Trim(); return s; };
   auto GetCellInt = [&](int r, int col, int def = 0)->int { CString s = GetCellStr(r, col); return s.IsEmpty() ? def : _wtoi(s); };
   auto GetCellDouble = [&](int r, int col, double def = 0.0)->double { CString s = GetCellStr(r, col); return s.IsEmpty() ? def : _wtof(s); };
   auto GetCellBool = [&](int r, int col)->BOOL { return GetCellInt(r, col, 0) ? TRUE : FALSE; };

   m_SideDimensionSetting.SetRedraw(FALSE);
   CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

   CString strTemp;
   int nRow = 0;
   int nCol = 0;

   if(bGetData == FALSE)
   {
      int nDimensionCount = pParam->m_nSideDimensionCount;

   if (!bGetData) {
      const int nDimensionCount = max(0, min(pParam->m_nSideDimensionCount, MAX_SIDE_DIMENSION_MEASURE_COUNT));
      m_SideDimensionSetting.SetRowCount(nDimensionCount + 1);

      for(int i=0; i<nDimensionCount; i++)
      {
         nRow = i + 1;
         nCol = 0;
      for (int i = 0; i < nDimensionCount; ++i) {
         const int r = i + 1;

         // 1. No.
         strTemp.Format(_T("S_D/C_%d"), i + 1);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
         // 1) No.
         CString no; no.Format(_T("S_D/C_%d"), i + 1);
         SetCell(r, COL_NO, no);

         // 2. Top Mark To Distance Y (um)
         strTemp.Format(_T("%d"), pParam->m_nSideDimensionPos_TopMarkToDistance_um[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
         // 2) Top Mark To Distance Y (um)
         SetCellInt(r, COL_TOPMARK_Y, pParam->m_nSideDimensionPos_TopMarkToDistance_um[i]);

         // 3. Use Dimension
         strTemp.Format(_T("%d"), (int) pParam->m_bSideDimension_Use[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
         // 3) Use Dimension (0/1)
         SetCellBool(r, COL_USE_DIM, pParam->m_bSideDimension_Use[i]);

         // 4. Thres
         strTemp.Format(_T("%.d"), pParam->m_nSideDimensionSpec_Thres[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
         if (!m_bIsRipSide) {
            // 4) Thres
            SetCellInt(r, COL_THRES, pParam->m_nSideDimensionSpec_Thres[i]);

         // 5. Std
         strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Std[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
            // 5-7) Std/Min/Max
            SetCellDouble(r, COL_STD, pParam->m_dSideDimensionSpec_mm_Std[i]);
            SetCellDouble(r, COL_MIN, pParam->m_dSideDimensionSpec_mm_Min[i]);
            SetCellDouble(r, COL_MAX, pParam->m_dSideDimensionSpec_mm_Max[i]);

         // 6. Min
         strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Min[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
            // 8) Offset
            SetCellDouble(r, COL_OFF, pParam->m_dSideDimensionSpec_mm_Off[i]);

         // 7. Max
         strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Max[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
            // 9) Chamfer Use
            SetCellBool(r, COL_CHAMFER_USE, pParam->m_bSideChamfer_Use[i]);

         // 8. Offset
         strTemp.Format(_T("%.3f"), pParam->m_dSideDimensionSpec_mm_Off[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

         // 9. Chamfer
         strTemp.Format(_T("%d"), (int) pParam->m_bSideChamfer_Use[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

         // 10. Std
         strTemp.Format(_T("%.3f"), pParam->m_dSideChamfer_Spec_mm_Std[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

         // 11. Min
         strTemp.Format(_T("%.3f"), pParam->m_dSideChamfer_Spec_mm_Min[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);

         // 12. Max
         strTemp.Format(_T("%.3f"), pParam->m_dSideChamfer_Spec_mm_Max[i]);
         m_SideDimensionSetting.SetItemText(nRow, nCol++, strTemp);
            // 10-12) Chamfer Std/Min/Max
            SetCellDouble(r, COL_CH_STD, pParam->m_dSideChamfer_Spec_mm_Std[i]);
            SetCellDouble(r, COL_CH_MIN, pParam->m_dSideChamfer_Spec_mm_Min[i]);
            SetCellDouble(r, COL_CH_MAX, pParam->m_dSideChamfer_Spec_mm_Max[i]);
         }
      }

      m_SideDimensionSetting.Invalidate();
   }
   else
   {
      int nDimensionCount = m_SideDimensionSetting.GetRowCount() - 1;
			
   else {
      int nDimensionCount = max(0, m_SideDimensionSetting.GetRowCount() - 1);
      nDimensionCount = min(nDimensionCount, MAX_SIDE_DIMENSION_MEASURE_COUNT);
      pParam->m_nSideDimensionCount = nDimensionCount;

      for(int i=0; i<nDimensionCount; i++)
      {
         nRow = i + 1;
         nCol = 1;
      for (int i = 0; i < nDimensionCount; ++i) {
         const int r = i + 1;
         int col = COL_TOPMARK_Y;

         // 1. No.
         // 2) Top Mark To Distance Y (um)
         pParam->m_nSideDimensionPos_TopMarkToDistance_um[i] = GetCellInt(r, col++, pParam->m_nSideDimensionPos_TopMarkToDistance_um[i]);

         // 2. Top Mark To Distance Y (um)
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_nSideDimensionPos_TopMarkToDistance_um[i] = _wtoi(strTemp);
         // 3) Use Dimension
         pParam->m_bSideDimension_Use[i] = GetCellBool(r, col++);

         // 3. Use Dimension
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_bSideDimension_Use[i] = (_wtoi(strTemp) == 0) ? FALSE : TRUE;
         if (!m_bIsRipSide) {
            // 4) Thres
            pParam->m_nSideDimensionSpec_Thres[i] = GetCellInt(r, col++, pParam->m_nSideDimensionSpec_Thres[i]);

         // 4. Thres
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_nSideDimensionSpec_Thres[i] = _wtoi(strTemp);
            // 5-7) Std/Min/Max
            pParam->m_dSideDimensionSpec_mm_Std[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Std[i]);
            pParam->m_dSideDimensionSpec_mm_Min[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Min[i]);
            pParam->m_dSideDimensionSpec_mm_Max[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Max[i]);

         // 5. Std
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideDimensionSpec_mm_Std[i] = _wtof(strTemp);
            // 8) Offset
            pParam->m_dSideDimensionSpec_mm_Off[i] = GetCellDouble(r, col++, pParam->m_dSideDimensionSpec_mm_Off[i]);

         // 6. Min
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideDimensionSpec_mm_Min[i] = _wtof(strTemp);
            // 9) Chamfer Use
            pParam->m_bSideChamfer_Use[i] = GetCellBool(r, col++);

         // 7. Max
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideDimensionSpec_mm_Max[i] = _wtof(strTemp);
            // 10-12) Chamfer Std/Min/Max
            pParam->m_dSideChamfer_Spec_mm_Std[i] = GetCellDouble(r, col++, pParam->m_dSideChamfer_Spec_mm_Std[i]);
            pParam->m_dSideChamfer_Spec_mm_Min[i] = GetCellDouble(r, col++, pParam->m_dSideChamfer_Spec_mm_Min[i]);
            pParam->m_dSideChamfer_Spec_mm_Max[i] = GetCellDouble(r, col++, pParam->m_dSideChamfer_Spec_mm_Max[i]);
         }
      }

         // 8. Offset
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideDimensionSpec_mm_Off[i] = _wtof(strTemp);
      for (int k = nDimensionCount; k < MAX_SIDE_DIMENSION_MEASURE_COUNT; ++k) {
         pParam->m_nSideDimensionPos_TopMarkToDistance_um[k] = 0;
         pParam->m_bSideDimension_Use[k] = FALSE;

         // 9. Chamfer
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_bSideChamfer_Use[i] = (_wtoi(strTemp) == 0) ? FALSE : TRUE;
         pParam->m_nSideDimensionSpec_Thres[k] = 0;
         pParam->m_dSideDimensionSpec_mm_Std[k] = 0.0;
         pParam->m_dSideDimensionSpec_mm_Min[k] = 0.0;
         pParam->m_dSideDimensionSpec_mm_Max[k] = 0.0;
         pParam->m_dSideDimensionSpec_mm_Off[k] = 0.0;

         // 10. Std
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideChamfer_Spec_mm_Std[i] = _wtof(strTemp);

         // 11. Min
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideChamfer_Spec_mm_Min[i] = _wtof(strTemp);

         // 12. Max
         strTemp = m_SideDimensionSetting.GetItemText(nRow, nCol++);
         pParam->m_dSideChamfer_Spec_mm_Max[i] = _wtof(strTemp);
         pParam->m_bSideChamfer_Use[k] = FALSE;
         pParam->m_dSideChamfer_Spec_mm_Std[k] = 0.0;
         pParam->m_dSideChamfer_Spec_mm_Min[k] = 0.0;
         pParam->m_dSideChamfer_Spec_mm_Max[k] = 0.0;
      }
   }
}

   m_SideDimensionSetting.SetRedraw(TRUE);
   m_SideDimensionSetting.Invalidate(FALSE);
}

void CDlgSideDimensionSetting::Fill_SideDimensionSetting_CurrentResult()
{
@@ -904,25 +928,28 @@

void CDlgSideDimensionSetting::ClickButtonAdd()
{
   if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
   if (m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL) {
      return;
   }

   int nSideIdx = *(m_pSelectSideIdx);

   if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
   if (nSideIdx < 0 || eRcp_SideRD_End <= nSideIdx) {
      return;
   }

   CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

   int nAddIdx = pParam->m_nSideDimensionCount;

   if(nAddIdx < 0 || MAX_SIDE_DIMENSION_MEASURE_COUNT <= nAddIdx)
   {
   if(nAddIdx < 0 || MAX_SIDE_DIMENSION_MEASURE_COUNT <= nAddIdx) {
      CString strMsg;
      strMsg.Format(_T("Max Dimension Measure Count : %d ea"), MAX_SIDE_DIMENSION_MEASURE_COUNT);
      AfxMessageBox(strMsg);
      return;
   }

   UpdateRecipe(TRUE);

   pParam->m_nSideDimensionPos_TopMarkToDistance_um[nAddIdx] = 0;
   pParam->m_dSideDimensionSpec_mm_Min[nAddIdx] = 0;
@@ -936,13 +963,15 @@

void CDlgSideDimensionSetting::ClickButtonDel()
{
   if(m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL)
   if (m_pDlgRecipe == NULL || m_pSelectSideIdx == NULL) {
      return;
   }

   int nSideIdx = *(m_pSelectSideIdx);

   if(nSideIdx < 0 || eRcp_SideRD_End <=  nSideIdx)
   if (nSideIdx < 0 || eRcp_SideRD_End <= nSideIdx) {
      return;
   }

   CSIDE_PARM* pParam = &m_pDlgRecipe->m_SideParam[nSideIdx];

@@ -951,17 +980,18 @@
   CCellID FocusedID = m_SideDimensionSetting.GetFocusCell();
   int nDelIdx = FocusedID.row - 1;

   if(nDelIdx < 0 || nSideDimensionCount <= nDelIdx)
   {
   if(nDelIdx < 0 || nSideDimensionCount <= nDelIdx) {
      AfxMessageBox(_T("Select Error"));
      return;
   }

   UpdateRecipe(TRUE);

   int nPosIdx = 0;
   for(int i=0; i<MAX_DIMENSION_COUNT; i++)
   {
      if(i == nDelIdx)
   for(int i=0; i<MAX_DIMENSION_COUNT; i++) {
      if (i == nDelIdx) {
         continue;
      }

      pParam->m_nSideDimensionPos_TopMarkToDistance_um[nPosIdx] = pParam->m_nSideDimensionPos_TopMarkToDistance_um[i];
      pParam->m_dSideDimensionSpec_mm_Min[nPosIdx] = pParam->m_dSideDimensionSpec_mm_Min[i];