1. 侧面检校验报警 2. 输入配方参数执行

mrDarker

2025-08-11 bd9942d185fb25b35b0c6e089e5763d45e5c83ce

 EdgeInspector_App/Process/InspectCamera.cpp

@@ -424,6 +424,458 @@
      }
   }
#endif // HALCON_VISION_KEY

   MeasureSideEdge_EI(eDim);
}

BOOL CInspectCamera::MeasureSideEdge_EI(DimensionDir eDim) {
   /* code */
   bool bExec = (DIMENSION_A_RIP == eDim) || (DIMENSION_B_RIP == eDim) || (DIMENSION_C_RIP == eDim) || (DIMENSION_D_RIP == eDim);
   if (!bExec) return FALSE;
   CSide_Data* pSideData = m_pGlassData->GetSideData(eDim);

   //查找边界
   CFrameBufferController* pFrameBufferController = m_pGrabber->GetFrameBuffer();
   int imgWidth = pFrameBufferController->GetFrameWidth();

   //获取上边界和下边
   int nTopEdge = pSideData->m_nGlassStartLine;
   int nBottomEdge = pSideData->m_nGlassEndLine;
   g_pLog->DisplayMessage(_T("[APP]Measure Side Edge Start, StartEdge = %d, EndEdge = %d, Width = %d"), nTopEdge, nBottomEdge, imgWidth);
	
   stFrameIndex stFrame = m_pGrabber->GetGrabFrame();
   CRIP_THICKNESS_PARM& rip = m_pRecipe->m_SideParam[eDim].m_RipThk;
   if (rip.m_bUseInspect != TRUE) {
      return TRUE;
   }

   int inspectNum = 36;

   //输入参数
   int topOffset = rip.m_nTopOffset;      //T Offset
   int botOffset = rip.m_nBottomOffset;    //B Offset
   int leftEdge = rip.m_nRectLeft;         //Rect L
   int rightEdge = rip.m_nRectRight;      //Rect R
   int leftThres = rip.m_nLeftThres;       //Left Thres
    int rightThres = rip.m_nRightThres;     //Right Thres
   int gassThres = rip.m_nGlassThres;      //Gas Thres

   double dist_array[36];                     //输出结果
   double left_dist_Gass_array[36];           //输出结果
   double right_dist_Gass_array[36];          //输出结果
   double xMinEdge_array_px[36];              //输出结果
   double yMinEdge_array_px[36];              //输出结果
   double xMaxEdge_array_px[36];              //输出结果
   double yMaxEdge_array_px[36];              //输出结果
   double xMinGas_array_px[36];               //输出结果
   double yMinGas_array_px[36];               //输出结果
   double xMaxGas_array_px[36];               //输出结果
   double yMaxGas_array_px[36];               //输出结果

   int startY = nTopEdge + topOffset;
   int endY = nBottomEdge - botOffset;
   int step = (int)((endY - startY) / inspectNum);
   g_pLog->DisplayMessage(_T("[APP]Measure Side Edge, (startY, endY, step) = (%d, %d, %d)"), startY, endY, step);

   for (int i = 0; i < inspectNum; i++) {
      int x1 = leftEdge;
      int y1 = startY + i * step;
      int x2 = rightEdge;
      int y2 = startY + (i + 1) * step;

      double szDist, leftGassDist, rightGassDist;
      MeasureSideEdge_POS(eDim,
         x1, y1, x2, y2,
         leftThres, rightThres, gassThres,
         xMinEdge_array_px[i], yMinEdge_array_px[i], xMaxEdge_array_px[i], yMaxEdge_array_px[i],
            xMinGas_array_px[i], yMinGas_array_px[i], xMaxGas_array_px[i], yMaxGas_array_px[i],
         szDist, leftGassDist, rightGassDist);

      dist_array[i] = m_dPixelSizeX * szDist;
      left_dist_Gass_array[i] = m_dPixelSizeX * leftGassDist;
      right_dist_Gass_array[i] = m_dPixelSizeX * rightGassDist;

      g_pLog->DisplayMessage(_T("[APP]Measure Result %d: LeftEdge = (%.1f, %.1f), LeftGas = (%.1f, %.1f), rightGas = (%.1f, %.1f), RightEdge = (%.1f, %.1f), (Dist, LeftGass, RightGass) = (%.1f, %.1f, %.1f)"),
         i + 1, 
            xMinEdge_array_px[i], yMinEdge_array_px[i],
            xMinGas_array_px[i], yMinGas_array_px[i],
            xMaxGas_array_px[i], yMaxGas_array_px[i],
            xMaxEdge_array_px[i], yMaxEdge_array_px[i],
         dist_array[i], left_dist_Gass_array[i], right_dist_Gass_array[i]);

      // 添加缺陷
      int nStep = max(1, (endY - startY) / inspectNum); // 防 0
      auto SpecDiff = [](double v, double vMin, double vMax)->double {
         if (v <= 0) return 0.0;            // 无效值
         if (v < vMin) return v - vMin;     // 负：低于下限
         if (v > vMax) return v - vMax;     // 正：高于上限
         return 0.0;                        // 在规格内
      };

      auto MakeBaseInfo = [&](CPoint pt, CRect rt, DefectLocation loc)->CDefect_Info {
         CDefect_Info info;
         info.m_iFrameIdx = stFrame.nFrameIdx;
         info.m_nCamID = m_iCamera;
         info.m_nScanIdx = stFrame.nScanIdx;
         info.m_nGlassStartLine = pSideData->m_nGlassStartLine;
         info.m_nSideIdx = (int)eDim;
         info.m_ptDefectPos_pxl = pt;
         info.m_rtDefectPos_pxl = rt;
         info.m_DefectLoc = loc;
         return info;
      };

      bool ngGlass = (dist_array[i] > 0) && (dist_array[i] < rip.m_nGlassSizeMin_um || dist_array[i] > rip.m_nGlassSizeMax_um);
      bool ngLeft = (left_dist_Gass_array[i] > 0) && (left_dist_Gass_array[i] < rip.m_nLeftRipSizeMin_um || left_dist_Gass_array[i] > rip.m_nLeftRipSizeMax_um);
      bool ngRight = (right_dist_Gass_array[i] > 0) && (right_dist_Gass_array[i] < rip.m_nRightRipSizeMin_um || right_dist_Gass_array[i] > rip.m_nRightRipSizeMax_um);

      // Glass 厚度 NG
      if (ngGlass) {
         CRect rt(
            (int)min(min(xMinEdge_array_px[i], xMinGas_array_px[i]), min(xMaxEdge_array_px[i], xMaxGas_array_px[i])),
            (int)min(min(yMinEdge_array_px[i], yMinGas_array_px[i]), min(yMaxEdge_array_px[i], yMaxGas_array_px[i])),
            (int)max(max(xMinEdge_array_px[i], xMinGas_array_px[i]), max(xMaxEdge_array_px[i], xMaxGas_array_px[i])),
            (int)max(max(yMinEdge_array_px[i], yMinGas_array_px[i]), max(yMaxEdge_array_px[i], yMaxGas_array_px[i]))
         );
         CPoint pt((rt.left + rt.right) / 2, (rt.top + rt.bottom) / 2);
         CDefect_Info defect = MakeBaseInfo(pt, rt, DefectLoc_Rip_Thickness_Glass);
         double dDiff = SpecDiff(dist_array[i], rip.m_nGlassSizeMin_um, rip.m_nGlassSizeMax_um);
         m_pDefectControl->ExtractDefect_RipThickness(eDim, m_iCamera, stFrame.nScanIdx, defect, dist_array[i], dDiff);
      }

      // 左侧气隙 NG
      if (ngLeft) {
         CRect rt(
            (int)min(xMinEdge_array_px[i], xMinGas_array_px[i]),
            (int)min(yMinEdge_array_px[i], yMinGas_array_px[i]),
            (int)max(xMinEdge_array_px[i], xMinGas_array_px[i]),
            (int)max(yMinEdge_array_px[i], yMinGas_array_px[i])
         );
         CPoint pt((rt.left + rt.right) / 2, (rt.top + rt.bottom) / 2);
         CDefect_Info defect = MakeBaseInfo(pt, rt, DefectLoc_Rip_Thickness_Left);
         double dDiff = SpecDiff(left_dist_Gass_array[i], rip.m_nLeftRipSizeMin_um, rip.m_nLeftRipSizeMax_um);
         m_pDefectControl->ExtractDefect_RipThickness(eDim, m_iCamera, stFrame.nScanIdx, defect, left_dist_Gass_array[i], dDiff);
      }

      // 右侧气隙 NG
      if (ngRight) {
         CRect rt(
            (int)min(xMaxEdge_array_px[i], xMaxGas_array_px[i]),
            (int)min(yMaxEdge_array_px[i], yMaxGas_array_px[i]),
            (int)max(xMaxEdge_array_px[i], xMaxGas_array_px[i]),
            (int)max(yMaxEdge_array_px[i], yMaxGas_array_px[i])
         );
         CPoint pt((rt.left + rt.right) / 2, (rt.top + rt.bottom) / 2);
         CDefect_Info defect = MakeBaseInfo(pt, rt, DefectLoc_Rip_Thickness_Right);
         double dDiff = SpecDiff(right_dist_Gass_array[i], rip.m_nRightRipSizeMin_um, rip.m_nRightRipSizeMax_um);
         m_pDefectControl->ExtractDefect_RipThickness(eDim, m_iCamera, stFrame.nScanIdx, defect, right_dist_Gass_array[i], dDiff);
      }
   }

   return TRUE;
}

void CInspectCamera::MeasureSideEdge_POS(DimensionDir eDim, 
   int x1, int y1, int x2, int y2,
   int leftThres, int rightThres, int gassThres,
   double& minEdgeX, double& minEdgeY, double& maxEdgeX, double& maxEdgeY,
   double& minGasX, double& minGasY, double& maxGasX, double& maxGasY,
   double& szDist, double& leftGassDist, double& rightGassDist) {
   /* code */
   szDist = 0.0f;
   leftGassDist = 0.0f;
   rightGassDist = 0.0f;
   int width = x2 - x1 + 1;
   int height = y2 - y1 + 1;
   uchar* imgData = new uchar[width * height];
   try {
      CutImageROI(imgData, eDim, x1, y1, x2, y2);

      MeasurePoint dotResult1[100];
      MeasurePoint dotResult2[100];
      MeasurePoint dotResult3[100];
      MeasurePoint dotResult4[100];
      MeasurePoint dotResult5[100];
      MeasurePoint dotResult6[100];
      MeasurePoint dotResult7[100];
      int dotNum1 = 0;
      int dotNum2 = 0;
      int dotNum3 = 0;
      int dotNum4 = 0;
      int dotNum5 = 0;
      int dotNum6 = 0;
      int dotNum7 = 0;
      CVisionMeasureClass doExec;
      double sigma = 2.5f;   //输入参数, 增加参数
      doExec.doMeasurePosA(imgData, width, height, sigma,
         dotResult1, dotNum1,
         dotResult2, dotNum2,
         dotResult3, dotNum3,
         dotResult4, dotNum4,
         dotResult5, dotNum5,
         dotResult6, dotNum6,
         dotResult7, dotNum7);
      for (int i = 0; i < dotNum1; i++) {
         dotResult1[i].x += x1;
         dotResult1[i].y += y1;
      }
      for (int i = 0; i < dotNum2; i++) {
         dotResult2[i].x += x1;
         dotResult2[i].y += y1;
      }
      for (int i = 0; i < dotNum3; i++) {
         dotResult3[i].x += x1;
         dotResult3[i].y += y1;
      }
      for (int i = 0; i < dotNum4; i++) {
         dotResult4[i].x += x1;
         dotResult4[i].y += y1;
      }
      for (int i = 0; i < dotNum5; i++) {
         dotResult5[i].x += x1;
         dotResult5[i].y += y1;
      }
      for (int i = 0; i < dotNum6; i++) {
         dotResult6[i].x += x1;
         dotResult6[i].y += y1;
      }
      for (int i = 0; i < dotNum7; i++) {
         dotResult7[i].x += x1;
         dotResult7[i].y += y1;
      }

      int fzDist = 4.5;                 //输入参数, 增加参数

      double xMinResult[7] = { -1 };
      double yMinResult[7] = { -1 };
      double xMaxResult[7] = { -1 };
      double yMaxResult[7] = { -1 };
      double xMinGassResult[7] = { -1 };
      double yMinGassResult[7] = { -1 };
      double xMaxGassResult[7] = { -1 };
      double yMaxGassResult[7] = { -1 };

      MeasureResultProc(dotResult1, dotNum1, leftThres, rightThres, gassThres, fzDist, 
         xMinResult[0], yMinResult[0], xMaxResult[0], yMaxResult[0],
         xMinGassResult[0], yMinGassResult[0], xMaxGassResult[0], yMaxGassResult[0]);
      MeasureResultProc(dotResult2, dotNum2, leftThres, rightThres, gassThres, fzDist,
         xMinResult[1], yMinResult[1], xMaxResult[1], yMaxResult[1],
         xMinGassResult[1], yMinGassResult[1], xMaxGassResult[1], yMaxGassResult[1]);
      MeasureResultProc(dotResult3, dotNum3, leftThres, rightThres, gassThres, fzDist,
         xMinResult[2], yMinResult[2], xMaxResult[2], yMaxResult[2],
         xMinGassResult[2], yMinGassResult[2], xMaxGassResult[2], yMaxGassResult[2]);
      MeasureResultProc(dotResult4, dotNum4, leftThres, rightThres, gassThres, fzDist,
         xMinResult[3], yMinResult[3], xMaxResult[3], yMaxResult[3],
         xMinGassResult[3], yMinGassResult[3], xMaxGassResult[3], yMaxGassResult[3]);
      MeasureResultProc(dotResult5, dotNum5, leftThres, rightThres, gassThres, fzDist,
         xMinResult[4], yMinResult[4], xMaxResult[4], yMaxResult[4],
         xMinGassResult[4], yMinGassResult[4], xMaxGassResult[4], yMaxGassResult[4]);
      MeasureResultProc(dotResult6, dotNum6, leftThres, rightThres, gassThres, fzDist,
         xMinResult[5], yMinResult[5], xMaxResult[5], yMaxResult[5],
         xMinGassResult[5], yMinGassResult[5], xMaxGassResult[5], yMaxGassResult[5]);
      MeasureResultProc(dotResult7, dotNum7, leftThres, rightThres, gassThres, fzDist,
         xMinResult[6], yMinResult[6], xMaxResult[6], yMaxResult[6],
         xMinGassResult[6], yMinGassResult[6], xMaxGassResult[6], yMaxGassResult[6]);

      std::vector<double> vDist, vLeftGass, vRightGass;
      for (int i = 0; i < 7; i++) {
         if (xMinResult[i] > 0 && xMaxResult[i] > 0) {
            double dx = xMaxResult[i] - xMinResult[i];
            double dy = yMaxResult[i] - yMinResult[i];
            double dist = sqrt(dx * dx + dy * dy);
            vDist.push_back(dist);
         }
         if (xMinResult[i] > 0 && xMinGassResult[i] > 0) {
            double dx = xMinGassResult[i] - xMinResult[i];
            double dy = yMinGassResult[i] - yMinResult[i];
                double dist = sqrt(dx * dx + dy * dy);
                vLeftGass.push_back(dist);
         }
         if (xMaxResult[i] > 0 && xMaxGassResult[i] > 0) {
            double dx = xMaxResult[i] - xMaxGassResult[i];
            double dy = yMaxResult[i] - yMaxGassResult[i];
            double dist = sqrt(dx * dx + dy * dy);
            vRightGass.push_back(dist);
         }
      }

      double avgDist = 0.0f;
      int sz = (int)(vDist.size());
      if (sz > 3){
         for (int i = 0; i < sz - 1; i++) {
            for (int j = i + 1; j < sz; j++) {
               if (vDist[i] > vDist[j]) {
                  double tmp = vDist[i];
                  vDist[i] = vDist[j];
                  vDist[j] = tmp;
               }
            }
         }
         double avg = 0.0f;
         for (int i = 1; i < sz - 1; i++) {
            avg += vDist[i];
         }
         avgDist = avg / (sz - 2);
      }
      double avgLeftGass = 0.0f;
      sz = (int)(vLeftGass.size());
      if (sz > 3) {
         for (int i = 0; i < sz - 1; i++) {
            for (int j = i + 1; j < sz; j++) {
               if (vLeftGass[i] > vLeftGass[j]) {
                  double tmp = vLeftGass[i];
                  vLeftGass[i] = vLeftGass[j];
                  vLeftGass[j] = tmp;
               }
            }
         }
         double avg = 0.0f;
         for (int i = 1; i < sz - 1; i++) {
            avg += vLeftGass[i];
         }
         avgLeftGass = avg / (sz - 2);
      }

      double avgRightGass = 0.0f;
        sz = (int)(vRightGass.size());
      if (sz > 3) {
         for (int i = 0; i < sz - 1; i++) {
            for (int j = i + 1; j < sz; j++) {
               if (vRightGass[i] > vRightGass[j]) {
                  double tmp = vRightGass[i];
                  vRightGass[i] = vRightGass[j];
                  vRightGass[j] = tmp;
               }
            }
         }
         double avg = 0.0f;
         for (int i = 1; i < sz - 1; i++) {
            avg += vRightGass[i];
         }
         avgRightGass = avg / (sz - 2);
      }

      szDist = avgDist;
      leftGassDist = avgLeftGass;
      rightGassDist = avgRightGass;

      minEdgeX = xMinResult[3];
      minEdgeY = yMinResult[3];
      maxEdgeX = xMaxResult[3];
      maxEdgeY = yMaxResult[3];
      minGasX = minEdgeX + leftGassDist - 1;
      minGasY = minEdgeY;
      maxGasX = maxEdgeX - rightGassDist + 1;
      maxGasY = maxEdgeY;

      delete[] imgData;
      imgData = nullptr;
   }
   catch (...) {
      delete[] imgData;
      imgData = nullptr;
   }
}

bool CInspectCamera::MeasureResultProc(MeasurePoint* ptResult, int dotNum, int leftThres, int rightRes, int gasThres, double fzDist,
   double& minX, double& minY, double& maxX, double& maxY, double& minGasX, double& minGasY, double& maxGasX, double& maxGasY){
   /* code */
   minX = -1.0f;
   minY = -1.0f;
   maxX = -1.0f;
   maxY = -1.0f;
   minGasX = -1.0f;
   minGasY = -1.0f;
   if (dotNum < 2) return false;

   //1. 首先查找minX, minY
   bool bMinFin = false;
   minX = MAXINT;
   for (int i = 0; i < dotNum; i++) {
      if (fabs(ptResult[i].cy) > leftThres && ptResult[i].x < minX) {
         minX = ptResult[i].x;
         minY = ptResult[i].y;
         bMinFin = true;
      }
   }
   if (!bMinFin) {
      minX = -1.0f;
      minY = -1.0f;
   }

   //2. 查找左右点
   bool bMaxFind = false;
   maxX = -1.0f;
   for (int i = 0; i < dotNum; i++) {
      if (fabs(ptResult[i].cy) > rightRes && ptResult[i].x > maxX) {
         maxX = ptResult[i].x;
         maxY = ptResult[i].y;
         bMaxFind = true;
      }
   }
   if (!bMaxFind) {
      maxX = -1.0f;
      maxY = -1.0f;
   }

   //3. 查找最小气体点
   if (bMinFin) {
      bool bFind = false;
      minGasX = MAXINT;
      for (int i = 0; i < dotNum; i++) {
         double dx = ptResult[i].x - minX;
         double dy = ptResult[i].y - minY;
         double dist = sqrt(dx * dx + dy * dy);
         if (dist > fzDist) {
            if (fabs(ptResult[i].cy) > gasThres && ptResult[i].x < minGasX && ptResult[i].x > minX) {
               minGasX = ptResult[i].x;
               minGasY = ptResult[i].y;
               bFind = true;
            }
         }
      }
      if (!bFind) {
         minGasX = -1.0f;
         minGasY = -1.0f;
      }
   }

   //4. 查找最大气体点
   if (bMaxFind) {
      bool bFind = false;
      maxGasX = -1.0f;
      for (int i = 0; i < dotNum; i++) {
         double dx = ptResult[i].x - maxX;
         double dy = ptResult[i].y - maxY;
         double dist = sqrt(dx * dx + dy * dy);
         if (dist > fzDist) {
            if (fabs(ptResult[i].cy) > gasThres && ptResult[i].x > maxGasX && ptResult[i].x < maxX) {
               maxGasX = ptResult[i].x;
               maxGasY = ptResult[i].y;
               bFind = true;
            }
         }
      }
      if (!bFind) {
            maxGasX = -1.0f;
            maxGasY = -1.0f;
      }
   }

   return true;
}

int CInspectCamera::CutImageROI(uchar* img, DimensionDir eDim, int x1, int y1, int x2, int y2) {
   /* code */
   int iScan = m_pHardparm->GetScanToDimension(eDim);

   int width = x2 - x1 + 1;
   for (int i = y1; i <= y2; i++) {
      LPBYTE lp =   m_pGrabber->GetFrameHeaderLine(iScan, i);
      std::memcpy(img+ (i-y1) * width, lp+x1, width);
   }

   return 1;
}

BOOL CInspectCamera::CheckThreadEnd(int iThread, stFrameIndex stFrame)
@@ -3826,7 +4278,7 @@
         defectInfo.m_nSideIdx = (int)emDim;
         defectInfo.m_ptDefectPos_pxl = rtRotateArea.CenterPoint();
         defectInfo.m_rtDefectPos_pxl = rtRotateArea;
         defectInfo.m_DefectLoc = DefectLoc_Notch_Crack;
         defectInfo.m_DefectLoc = DefectLoc_Notch_NoGrind;
         m_pDefectControl->ExtractDefect(emDim, m_iCamera, stFrame.nScanIdx, defectInfo);

         cvReleaseImageHeader(&pOriginImage);
@@ -4127,13 +4579,13 @@
{
   if (m_pRecipe == NULL || m_pGlassData == NULL)
      return FALSE;

   int NotchFlag = 0;
   for (int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_NOTCH_MEASURE_COUNT; nMeasureIdx++)
   {
      CPoint ptRef_pxl = m_pGlassData->GetSideData(emDim)->m_ptNotch_Reference[nNotchIdx][nMeasureIdx];
      CPoint ptDim_pxl = m_pGlassData->GetSideData(emDim)->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx];

      if (ptRef_pxl.x < 0 || ptRef_pxl.y < 0) {
		
   /*   if (ptRef_pxl.x < 0 || ptRef_pxl.y < 0) {
         g_pLog->DisplayMessage(_T("[ERROR] Invalid Ref Point at Notch_Process_Calculate, NotchIdx: %d, MeasureIdx: %d, Point: (%d, %d)"), nNotchIdx, nMeasureIdx, ptRef_pxl.x, ptRef_pxl.y);
         continue;
      }
@@ -4141,7 +4593,7 @@
      if (ptDim_pxl.x < 0 || ptDim_pxl.y < 0) {
         g_pLog->DisplayMessage(_T("[ERROR] Invalid Dim Point at Notch_Process_Calculate, NotchIdx: %d, MeasureIdx: %d, Point: (%d, %d)"), nNotchIdx, nMeasureIdx, ptDim_pxl.x, ptDim_pxl.y);
         continue;
      }
      }*/

      // Dimension
      double dX_dim_um = (double)(ptRef_pxl.x - ptDim_pxl.x) * m_dPixelSizeX;
@@ -4150,22 +4602,25 @@
      m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Result_um[nNotchIdx][nMeasureIdx] = dDimension;

      CPoint ptChamfer_pxl = m_pGlassData->GetSideData(emDim)->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx];
      if (ptChamfer_pxl.x < 0 || ptChamfer_pxl.y < 0) {
   /*   if (ptChamfer_pxl.x < 0 || ptChamfer_pxl.y < 0) {
         g_pLog->DisplayMessage(_T("[ERROR] Invalid Chamfer Point at Notch_Process_Calculate, NotchIdx: %d, MeasureIdx: %d, Point: (%d, %d)"), nNotchIdx, nMeasureIdx, ptChamfer_pxl.x, ptChamfer_pxl.y);
         continue;
      }
      }*/

      double dX_Chamfer = (double)(ptChamfer_pxl.x - ptDim_pxl.x) * m_dPixelSizeX;
      double dY_Chamfer = (double)(ptChamfer_pxl.y - ptDim_pxl.y) * m_dPixelSizeY;
      double dChamfer = sqrtf((dX_Chamfer * dX_Chamfer) + (dY_Chamfer * dY_Chamfer));
      m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx] = dChamfer;

      if (dDimension > 2000.0 && dChamfer > 2000.0) {
      if (dDimension > 5000.0 && dChamfer > 5000.0) {
         g_pLog->DisplayMessage(_T("[ERROR] Abnormal Dimension & Chamfer too large at Notch_Process_Calculate, NotchIdx: %d, MeasureIdx: %d, Dimension: %.2f, Chamfer: %.2f"), nNotchIdx, nMeasureIdx, dDimension, dChamfer);
         continue;
         NotchFlag=1;
      }
   }

   if (NotchFlag == TRUE)
   {
      return FALSE;
   }else
   return TRUE;
}

@@ -6256,6 +6711,11 @@
      // 1. Find End Line.. (Corner를 제외한 Side라인을 찾기 위해 End Line부터 찾는다)
      FindEndLine(iThread, emDim, stFrame);

      bool bIsRipSide = (emDim == DIMENSION_A_RIP || emDim == DIMENSION_B_RIP || emDim == DIMENSION_C_RIP || emDim == DIMENSION_D_RIP);
      if (bIsRipSide) {
         return TRUE;
      }

      // 2. Find Side Line.. (해당 프레임에서 Corner/Notch 를 제외한 Side 라인 찾기)
#if USE_AI_DETECT
      FindSideLine(iThread, emDim, stFrame);