mini车间与模组车间区分功能

LWQ

2025-07-14 52d230fd0eb38adc5c6f4c6d6ed3786a3c19354d

 EdgeInspector_App/Process/InspectCamera.cpp

@@ -4108,7 +4108,6 @@
   {
      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];
      CPoint ptChamfer_pxl = m_pGlassData->GetSideData(emDim)->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx];

      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);
@@ -4119,23 +4118,22 @@
         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;
      }
		
      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;
      }

      // Dimension
      double dX_dim_um = (double)(ptRef_pxl.x - ptDim_pxl.x) * m_dPixelSizeX;
      double dY_dim_um = (double)(ptRef_pxl.y - ptDim_pxl.y) * m_dPixelSizeY;
      double dDimension = sqrtf((dX_dim_um * dX_dim_um) + (dY_dim_um * dY_dim_um));

      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) {
         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) {
@@ -4149,38 +4147,46 @@

void CInspectCamera::Notch_Process_Judge(DimensionDir emDim, stFrameIndex stFrame, int nNotchIdx, IplImage* scr,IplImage* img_Edge,IplImage* img_Bin, CRect rtROI)
{
   if(m_pRecipe == NULL || m_pGlassData == NULL)
   if (m_pRecipe == NULL || m_pGlassData == NULL) {
      g_pLog->DisplayMessage(_T("[ERROR] Recipe or Glass Data is NULL in Notch_Process_Judge"));
      return;
   }

   CSide_Data* pSideData = m_pGlassData->GetSideData(emDim);
   if (pSideData == NULL) {
      g_pLog->DisplayMessage(_T("[ERROR] Side Data is NULL in Notch_Process_Judge, Dimension: %d"), (int)emDim);
      return;
   }

   for(int nMeasureIdx=0; nMeasureIdx < MAX_SIDE_NOTCH_MEASURE_COUNT; nMeasureIdx++)
   {
      // Dimension
      if(m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_bNotch_Dimension_Use[nMeasureIdx] == TRUE)
      {
         double dDimension_um = m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Result_um[nNotchIdx][nMeasureIdx];
         double dDimension_um = pSideData->m_dNotch_Dimension_Edge_Result_um[nNotchIdx][nMeasureIdx];
         double dDimension_std_um = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_dNotch_Dimension_STD_mm[nMeasureIdx] * 1000.0;
         double dDimension_min_um = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_dNotch_Dimension_Diff_MIN_mm[nMeasureIdx] * 1000.0;
         double dDimension_max_um = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_dNotch_Dimension_Diff_MAX_mm[nMeasureIdx] * 1000.0;
         double dDimension_Diff_um = dDimension_std_um - dDimension_um;

         m_pGlassData->GetSideData(emDim)->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] = 1;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Result_Diff_um[nNotchIdx][nMeasureIdx] = dDimension_Diff_um;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx] = dDimension_std_um;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Judge_Min_um[nNotchIdx][nMeasureIdx] = dDimension_min_um;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Judge_Max_um[nNotchIdx][nMeasureIdx] = dDimension_max_um;
         pSideData->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] = 1;
         pSideData->m_dNotch_Dimension_Edge_Result_Diff_um[nNotchIdx][nMeasureIdx] = dDimension_Diff_um;
         pSideData->m_dNotch_Dimension_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx] = dDimension_std_um;
         pSideData->m_dNotch_Dimension_Edge_Judge_Min_um[nNotchIdx][nMeasureIdx] = dDimension_min_um;
         pSideData->m_dNotch_Dimension_Edge_Judge_Max_um[nNotchIdx][nMeasureIdx] = dDimension_max_um;

         if(dDimension_um > dDimension_std_um + dDimension_max_um)
            m_pGlassData->GetSideData(emDim)->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] = 2;
            pSideData->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] = 2;
         else if(dDimension_um < dDimension_std_um - dDimension_min_um)
            m_pGlassData->GetSideData(emDim)->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] = 3;
            pSideData->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] = 3;

         if(m_pGlassData->GetSideData(emDim)->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] != 1)
         if(pSideData->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx] != 1)
         {
            // Make 搬窃..
            CRect rtDefectArea = CRect(m_pGlassData->GetSideData(emDim)->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].x, 
                                    m_pGlassData->GetSideData(emDim)->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].y, 
                                       m_pGlassData->GetSideData(emDim)->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].x, 
                                          m_pGlassData->GetSideData(emDim)->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].y);
            CRect rtDefectArea = CRect(pSideData->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].x,
                                 pSideData->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].y,
                                 pSideData->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].x,
                                 pSideData->m_ptNotch_Dimension_Edge[nNotchIdx][nMeasureIdx].y);

            rtDefectArea.InflateRect(10, 10);

@@ -4188,7 +4194,7 @@
            defectInfo.m_iFrameIdx         = stFrame.nFrameIdx;
            defectInfo.m_nCamID            = m_iCamera;
            defectInfo.m_nScanIdx         = stFrame.nScanIdx;
            defectInfo.m_nGlassStartLine   = m_pGlassData->GetSideData(emDim)->m_nGlassStartLine;
            defectInfo.m_nGlassStartLine   = pSideData->m_nGlassStartLine;
            defectInfo.m_nSideIdx         = (int) emDim;
            defectInfo.m_ptDefectPos_pxl   = rtDefectArea.CenterPoint();
            defectInfo.m_rtDefectPos_pxl   = rtDefectArea;
@@ -4201,35 +4207,38 @@
      // Chamfer
      if(m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_bNotch_Chamfer_Use[nMeasureIdx] == TRUE)
      {
         double dChamfer_um = m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx];
         double dChamfer_um = pSideData->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx];
         double dChamfer_std_um = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_dNotch_Chamfer_STD_mm[nMeasureIdx] * 1000.0;
         double dChamfer_min_um = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_dNotch_Chamfer_Diff_MIN_mm[nMeasureIdx] * 1000.0;
         double dChamfer_max_um = m_pRecipe->m_SideParam[(int) emDim].m_NotchPrm[nNotchIdx].m_dNotch_Chamfer_Diff_MAX_mm[nMeasureIdx] * 1000.0;
         double dChamfer_Diff_um = dChamfer_std_um - dChamfer_um;

         m_pGlassData->GetSideData(emDim)->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] = 1;
         pSideData->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] = 1;

#if MINI_LED
         //选取测量研磨尺寸最大值
         if (m_nChamferOffset_um < dChamfer_um)
         {
         if (m_nChamferOffset_um < dChamfer_um) {
            m_nChamferOffset_um = dChamfer_um;
         }
         m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Result_Diff_um[nNotchIdx][nMeasureIdx] = dChamfer_std_um - dChamfer_um;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx] = dChamfer_std_um;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Judge_Min_um[nNotchIdx][nMeasureIdx] = dChamfer_min_um;
         m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Judge_Max_um[nNotchIdx][nMeasureIdx] = dChamfer_max_um;
#endif

         pSideData->m_dNotch_Chamfer_Edge_Result_Diff_um[nNotchIdx][nMeasureIdx] = dChamfer_std_um - dChamfer_um;
         pSideData->m_dNotch_Chamfer_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx] = dChamfer_std_um;
         pSideData->m_dNotch_Chamfer_Edge_Judge_Min_um[nNotchIdx][nMeasureIdx] = dChamfer_min_um;
         pSideData->m_dNotch_Chamfer_Edge_Judge_Max_um[nNotchIdx][nMeasureIdx] = dChamfer_max_um;

         if(dChamfer_um > dChamfer_std_um + dChamfer_max_um)
            m_pGlassData->GetSideData(emDim)->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] = 2;
            pSideData->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] = 2;
         else if(dChamfer_um < dChamfer_std_um - dChamfer_min_um)
            m_pGlassData->GetSideData(emDim)->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] = 3;
            pSideData->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] = 3;

         if(m_pGlassData->GetSideData(emDim)->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] != 1)
         if(pSideData->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx] != 1)
         {
            // Make 搬窃..
            CRect rtDefectArea = CRect(m_pGlassData->GetSideData(emDim)->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].x, 
               m_pGlassData->GetSideData(emDim)->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].y, 
               m_pGlassData->GetSideData(emDim)->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].x, 
               m_pGlassData->GetSideData(emDim)->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].y);
            CRect rtDefectArea = CRect(pSideData->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].x,
                                 pSideData->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].y,
                                 pSideData->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].x,
                                 pSideData->m_ptNotch_Chamfer_Edge[nNotchIdx][nMeasureIdx].y);

            rtDefectArea.InflateRect(10, 10);

@@ -4237,7 +4246,7 @@
            defectInfo.m_iFrameIdx         = stFrame.nFrameIdx;
            defectInfo.m_nCamID            = m_iCamera;
            defectInfo.m_nScanIdx         = stFrame.nScanIdx;
            defectInfo.m_nGlassStartLine   = m_pGlassData->GetSideData(emDim)->m_nGlassStartLine;
            defectInfo.m_nGlassStartLine   = pSideData->m_nGlassStartLine;
            defectInfo.m_nSideIdx         = (int) emDim;
            defectInfo.m_ptDefectPos_pxl   = rtDefectArea.CenterPoint();
            defectInfo.m_rtDefectPos_pxl   = rtDefectArea;
@@ -4249,15 +4258,14 @@

      // Make Comment
      char strJudge[4][16] = {"None", "OK", "OV", "UN"};

      sprintf(m_pGlassData->GetSideData(emDim)->m_strNotchMeasure_Comment[nNotchIdx][nMeasureIdx], "NOTCH[%d]-POINT[%d]-DIM[%.1f/STD:%.1f][%s], CHAMFER[%.1f/STD:%.1f][%s]"
      sprintf(pSideData->m_strNotchMeasure_Comment[nNotchIdx][nMeasureIdx], "NOTCH[%d]-POINT[%d]-DIM[%.1f/STD:%.1f][%s], CHAMFER[%.1f/STD:%.1f][%s]"
         , nNotchIdx+1, nMeasureIdx+1
         , m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Result_um[nNotchIdx][nMeasureIdx]
         , m_pGlassData->GetSideData(emDim)->m_dNotch_Dimension_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx]
         , strJudge[m_pGlassData->GetSideData(emDim)->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx]]
         , m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx]
         , m_pGlassData->GetSideData(emDim)->m_dNotch_Chamfer_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx]
         , strJudge[m_pGlassData->GetSideData(emDim)->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx]]);
         , pSideData->m_dNotch_Dimension_Edge_Result_um[nNotchIdx][nMeasureIdx]
         , pSideData->m_dNotch_Dimension_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx]
         , strJudge[pSideData->m_nNotch_Dimension_Edge_Judge[nNotchIdx][nMeasureIdx]]
         , pSideData->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx]
         , pSideData->m_dNotch_Chamfer_Edge_Judge_Std_um[nNotchIdx][nMeasureIdx]
         , strJudge[pSideData->m_nNotch_Chamfer_Edge_Judge[nNotchIdx][nMeasureIdx]]);
   }
}

@@ -4320,10 +4328,13 @@
      vecDefectCandidateList.push_back(defectInfo);
   }
   m_pDefectControl->ExtractDefect_Notch(emDim, m_iCamera, stFrame.nScanIdx, nNotchIdx, &vecDefectCandidateList);
#else	
#else

#if MINI_LED
   nOffset = m_nChamferOffset_um / m_pGlassData->GetSideData(emDim)->m_dPixelSizeX;
   nOffset += pNotchParam->m_nNotch_Inspect_Defect_Offset;
   m_nChamferOffset_um = 0;
#endif // MINI_LED

   CRect rcIns = rtROI;
   rcIns.OffsetRect(-rcIns.left,-rcIns.top);
@@ -4332,9 +4343,8 @@
   IplImage* pProcessCanny = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);
   IplImage* pProcessBin = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);
   IplImage* pMaskImage = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);
   IplImage* pMaskImage1 = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);
   IplImage* pdstImage = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);//绘画轮廓
   IplImage* ptempImage1 = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);//凸包
   IplImage* pDilatedMaskImage = cvCreateImage(cvSize(rcIns.Width(), rcIns.Height()), 8, 1);

   for(int i=0; i<rcIns.Height(); i++)
   {
      memcpy(pProcImage->imageData+(i*pProcImage->widthStep), scr->imageData+(rtROI.left + (i*scr->widthStep)), rcIns.Width());
@@ -4354,8 +4364,8 @@
   strTemp.Format(_T("Notch\\Notch_%d_Defect_EdgeOrBin"), nNotchIdx);
   SaveDebugImage(emDim, stFrame, pMaskImage, strTemp);
   
   BOOL      bFind;
   int         nFindX;
   BOOL bFind;
   int    nFindX;
   for(int y=0;y<pMaskImage->height;y++)
   {
      bFind = FALSE;
@@ -4374,11 +4384,6 @@
      {
         memset(&pMaskImage->imageData[y*pMaskImage->widthStep], 255, nFindX);
         memset(&pMaskImage->imageData[y*pMaskImage->widthStep+nFindX], 0, pMaskImage->width - nFindX);

         //for (int x = 0; x < nFindX; x++)
         //   pMaskImage->imageData[y * pMaskImage->widthStep + x] = 255;
         //for (int x = nFindX; x < pMaskImage->width; x++)
         //   pMaskImage->imageData[y * pMaskImage->widthStep + x] = 0;
      }
   }

@@ -4403,15 +4408,17 @@

   strTemp.Format(_T("Notch\\Notch_%d_Defect_ProcBinImage"), nNotchIdx);
   SaveDebugImage(emDim, stFrame, pProcBinImage, strTemp);
   #if   MINI_LED == TRUE	
   cvDilate(pMaskImage, pMaskImage1, 0, pNotchParam->m_nNotch_Inspect_Defect_dilate);
   strTemp.Format(_T("Notch\\Notch_%d_Defect_pMaskImage2"), nNotchIdx);
   SaveDebugImage(emDim, stFrame, pMaskImage1, strTemp);

      cvAnd(pMaskImage1, pProcBinImage, pMaskImage1);
      strTemp.Format(_T("Notch\\Notch_%d_Defect_pMaskImage3"), nNotchIdx);
      SaveDebugImage(emDim, stFrame, pMaskImage1, strTemp);
    #endif	
#if   MINI_LED == 0	
   cvDilate(pMaskImage, pDilatedMaskImage, 0, pNotchParam->m_nNotch_Inspect_Defect_dilate);
   strTemp.Format(_T("Notch\\Notch_%d_Defect_pMaskImage2"), nNotchIdx);
   SaveDebugImage(emDim, stFrame, pDilatedMaskImage, strTemp);

   cvAnd(pDilatedMaskImage, pProcBinImage, pDilatedMaskImage);
   strTemp.Format(_T("Notch\\Notch_%d_Defect_pMaskImage3"), nNotchIdx);
   SaveDebugImage(emDim, stFrame, pDilatedMaskImage, strTemp);
#endif	

   // 3. Blob
   int iScan = stFrame.nScanIdx;
   int iFrame = stFrame.nFrameIdx;
@@ -4427,11 +4434,11 @@
   DefectLocation defectLoc = DefectLoc_Notch_Crack;

   std::vector<CDefect_Info> vecDefectCandidateList;
   if (MINI_LED == TRUE)
      DefectProcess(emDim, iScan, iFrame, pProcImage, pMaskImage1, rtProcessArea, nMinSize, nMinSize_X, nMinSize_Y, nDilation, bStartNearFilterUse, nStartNearFilterRange, defectLoc, &vecDefectCandidateList);
   else
#if   MINI_LED == 0	
      DefectProcess(emDim, iScan, iFrame, pProcImage, pDilatedMaskImage, rtProcessArea, nMinSize, nMinSize_X, nMinSize_Y, nDilation, bStartNearFilterUse, nStartNearFilterRange, defectLoc, &vecDefectCandidateList);
#else
      DefectProcess(emDim, iScan, iFrame, pProcImage, pProcBinImage, rtProcessArea, nMinSize, nMinSize_X, nMinSize_Y, nDilation, bStartNearFilterUse, nStartNearFilterRange, defectLoc, &vecDefectCandidateList);

#endif	
   
   m_pDefectControl->ExtractDefect_Notch(emDim, m_iCamera, stFrame.nScanIdx, nNotchIdx, &vecDefectCandidateList);