Ongoing60 #4517 CF AOI Review 결과 파일 찾기 실패 개선 1. AOIServer RawBin 폴더 연결 Time...

kojingeun

2023-06-30 c70166f3e86ffd0528884911483c067a6b21ebdd

 ReviewSystem/ReviewSystem/ReviewProcessor_CPJT.cpp

@@ -5,16 +5,44 @@
#include "CameraControlReview.h"
#include "CHImageControls/CHImageProcess.h"
#include "CHMotorControls/MotorControl.h"
#include "CHSignalControls/SignalControl.h"

#include "CHEdgeTriangle/EdgeTriangle.h"
#include "CHEdgeTriangle/RecipeManager.h"
#include "CHReviewRecipe/RsRcpReviewInfo.h"
#include "DitGlassRawClient.h"
#include "LineChecker/LineChecker.h"

#include <fstream> /* < KJG 20230630 - #4517 ADD >*/
enum StackInfo { Stack_Unknown = 0, Stack_TD, Stack_SD, Stack_PD, Stack_SP, Stack_CD };
using namespace CHImageControls;

CReviewProcessor_CPJT::CReviewProcessor_CPJT(int nThreadCount) : CReviewProcessor(nThreadCount)
const CString AOIRAWBIN_PATH = _T("\\\\126.100.100.1\\d\\DIT_ResultData\\RawBin");

CString GetFormatMessageString(DWORD dwError) /* < KJG 20230630 - #4517 ADD >*/
{
   LPVOID lpMsgBuf;

   FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
      | FORMAT_MESSAGE_FROM_SYSTEM
      | FORMAT_MESSAGE_IGNORE_INSERTS
      , NULL
      , dwError
      , MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT)
      , (LPTSTR)&lpMsgBuf
      , 0
      , NULL
   );

   CString str;
   str.Format(_T("%s"), lpMsgBuf);

   LocalFree(lpMsgBuf);
   return str;
}

CReviewProcessor_CPJT::CReviewProcessor_CPJT(int nThreadCount) 
   : CReviewProcessor(nThreadCount)
{
   bProcessSuccess[CPJT_REVIEW_SUCCESS] = FALSE;
   bProcessSuccess[CPJT_MEASURE_SUCCESS] = FALSE;
@@ -43,6 +71,12 @@
   ErrorStringCode[17].Insert(17,_T("CircleCoefficientFail"));
   ErrorStringCode[18].Insert(18,_T("ProcessSuccess"));
   ErrorStringCode[19].Insert(19,_T("ProcessNone"));
	
   /* < KJG 20230630 - #4517 ADD Start >*/
   CString strDummyFilePath;
   strDummyFilePath.Format(_T("%s\\file_dummy"), AOIRAWBIN_PATH);
   m_threadFileMonitor.StartThread();
   /* < KJG 20230630 - #4517 ADD End >*/
}

CReviewProcessor_CPJT::~CReviewProcessor_CPJT(void)
@@ -359,7 +393,6 @@
   }

   LeaveCriticalSection(&m_csUserCriticalSection);
.
   m_pRP2P->IRP2P_UpdateReviewResult(nModuleIndex, pGlassResult);
   return;

@@ -1224,15 +1257,35 @@

        if (pReviewResult->nModuleIdx == 0 && m_pRP2P->IRP2P_GetFirstReviewLeft())
        {
           m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
           const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
           int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
           int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

           //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
           m_pRP2P->IRP2P_SetReview00ImageContrast(round(dFocusValue));
           m_pRP2P->IRP2P_SetFirstReviewLeft(FALSE);
           m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewLeft FDC FocusValue = %.2f "), dFocusValue);

           if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
           {
              m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
           }
        }
        else if(pReviewResult->nModuleIdx == 1 && m_pRP2P->IRP2P_GetFirstReviewRight())
        {
           m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
           const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
           int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
           int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

           //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
           m_pRP2P->IRP2P_SetReview01ImageContrast(round(dFocusValue));
           m_pRP2P->IRP2P_SetFirstReviewRight(FALSE);
           m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewRight FDC FocusValue = %.2f "), dFocusValue);

           if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
           {
              m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
           }
        }
     }
   }
@@ -1256,15 +1309,36 @@

      if (pReviewResult->nModuleIdx == 0 && m_pRP2P->IRP2P_GetFirstReviewLeft())
      {
         m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
         const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
         int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
         int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

         //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
         m_pRP2P->IRP2P_SetReview00ImageContrast(round(dFocusValue));
         m_pRP2P->IRP2P_SetFirstReviewLeft(FALSE);
         m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewLeft FDC FocusValue = %.2f "), dFocusValue);
			
         if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
         {
            m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
         }
			
      }
      else if (pReviewResult->nModuleIdx == 1 && m_pRP2P->IRP2P_GetFirstReviewRight())
      {
         m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
         const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
         int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
         int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

         //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
         m_pRP2P->IRP2P_SetReview01ImageContrast(round(dFocusValue));
         m_pRP2P->IRP2P_SetFirstReviewRight(FALSE);
         m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewRight FDC FocusValue = %.2f "), dFocusValue);

         if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
         {
            m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
         }

      }
   }
@@ -1371,15 +1445,35 @@

            if (pReviewResult->nModuleIdx == 0 && m_pRP2P->IRP2P_GetFirstReviewLeft())
            {
               m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
               const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
               int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
               int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

               //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
               m_pRP2P->IRP2P_SetReview00ImageContrast(round(dFocusValue));
               m_pRP2P->IRP2P_SetFirstReviewLeft(FALSE);
               m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewLeft FDC FocusValue = %.2f "), dFocusValue);

               if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
               {
                  m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
               }
            }
            else if (pReviewResult->nModuleIdx == 1 && m_pRP2P->IRP2P_GetFirstReviewRight())
            {
               m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
               const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
               int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
               int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

               //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
               m_pRP2P->IRP2P_SetReview01ImageContrast(round(dFocusValue));
               m_pRP2P->IRP2P_SetFirstReviewRight(FALSE);
               m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewRight FDC FocusValue = %.2f "), dFocusValue);

               if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
               {
                  m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
               }

            }

@@ -1424,15 +1518,35 @@

      if (pReviewResult->nModuleIdx == 0 && m_pRP2P->IRP2P_GetFirstReviewLeft())
      {
         m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
         const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
         int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
         int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

         //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview00ImageContrast = dFocusValue;
         m_pRP2P->IRP2P_SetReview00ImageContrast(round(dFocusValue));
         m_pRP2P->IRP2P_SetFirstReviewLeft(FALSE);
         m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewLeft FDC FocusValue = %.2f "), dFocusValue);

         if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
         {
            m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
         }
      }
      else if (pReviewResult->nModuleIdx == 1 && m_pRP2P->IRP2P_GetFirstReviewRight())
      {
         m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
         const CSignalControlInfo* pSignalInfo = m_pRP2P->IRP2P_GetReviewSignalinfo();
         int nDefocusValueMin = pSignalInfo->GetDefocusValueMin();
         int nDefocusValueMax = pSignalInfo->GetDefocusValueMax();

         //m_pRP2P->IRP2P_GetCurrentGlassResult()->nReview01ImageContrast = dFocusValue;
         m_pRP2P->IRP2P_SetReview01ImageContrast(round(dFocusValue));
         m_pRP2P->IRP2P_SetFirstReviewRight(FALSE);
         m_pRP2P->IRP2P_DisplayMessage(_T("FirstReviewRight FDC FocusValue = %.2f "), dFocusValue);

         if (dFocusValue < nDefocusValueMin || dFocusValue > nDefocusValueMax)
         {
            m_pRP2P->IRP2P_GetSequenceProcessor()->SendSignalToSignalControl(0, 3, 1000);
         }

      }
   }
@@ -3732,49 +3846,121 @@
   BYTE *pImageBufferByte = (BYTE*)(pImageBuffer);
   if (pImageBuffer==NULL) return 0.;

   //#3524_210902_LYW_MOD START
   int nWidth = nImageWidth;
   //int nWidthStep = nImageWidth;
   int nHeight = nImageHeight;
   int nCalWidth = nWidth/2;
   int nCalHeight = nHeight/2;
   //    int nCalWidth = nWidth/2;
   //    int nCalHeight = nHeight/2;
   // 
   //    int nStartX = nWidth/2 - nCalWidth/2;
   //    int nStartY = nHeight/2 - nCalHeight/2;

   int nStartX = nWidth/2 - nCalWidth/2;
   int nStartY = nHeight/2 - nCalHeight/2;
   int nCalWidth = nWidth;
   int nCalHeight = nHeight;

   //
   double Focusvalue = 0;
   double SumValue = 0;
   double TempValue = 0;
   double m_nResultFocusValue = 0;
   int nStartX = 0;
   int nStartY = 0;

   for (int y = 0; y < nHeight - 1; y++)
   int nStep = 3;

   double dXValue = 0., dYValue = 0., dCurr = 0., dSum = 0., dFocus = 0.;
   for (int nH = nStartY; nH < nStartY + nCalHeight - nStep; nH++)
   {
      for (int x = 0; x < nWidth - 1; x++)
      for (int nW = nStartX; nW < nStartX + nCalWidth - nStep; nW++)
      {
         TempValue = (double)(pImageBufferByte[y*nWidth + x] - pImageBufferByte[y*nWidth + x + 1]);
         SumValue = TempValue * TempValue;
         TempValue = (double)(pImageBufferByte[y*nWidth + x] - pImageBufferByte[(y + 1)*nWidth + x]);
         SumValue += TempValue * TempValue;

         Focusvalue += sqrt(SumValue);
         //Focusvalue += SumValue;
      }
   }

   m_nResultFocusValue = int(Focusvalue / (double)(nWidth*nHeight));

   double dXValue=0., dYValue=0., dCurr=0., dSum=0., dFocus=0.;
   for(int nH=nStartY ; nH<nStartY+nCalHeight-1 ; nH++)
   {
      for(int nW=nStartX ; nW<nStartX+nCalWidth-1 ; nW++)
      {
         dXValue = float((pImageBufferByte[nH*nW + nW+1] - pImageBufferByte[nH*nW + nW])*(pImageBufferByte[nH*nW + nW+1] - pImageBufferByte[nH*nW + nW]));
         dYValue = float((pImageBufferByte[(nH+1)*nW + nW] - pImageBufferByte[nH*nW + nW])*(pImageBufferByte[(nH+1)*nW + nW] - pImageBufferByte[nH*nW + nW]));
         dXValue = float((pImageBufferByte[nH*nWidth + nW + nStep] - pImageBufferByte[nH*nWidth + nW])*(pImageBufferByte[nH*nWidth + nW + nStep] - pImageBufferByte[nH*nWidth + nW]));
         dYValue = float((pImageBufferByte[(nH + nStep)*nWidth + nW] - pImageBufferByte[nH*nWidth + nW])*(pImageBufferByte[(nH + nStep)*nWidth + nW] - pImageBufferByte[nH*nWidth + nW]));
         dCurr = sqrt(dXValue + dYValue);
         //break;

         dSum += dCurr;
      }
   }
   dFocus = dSum/double(nCalWidth*nCalHeight);
   dFocus = dSum / double(nCalWidth*nCalHeight);

   if (dFocus >= 10.0) dFocus = 10.0;

   return dFocus;
   //#3524_210902_LYW_MOD END
   //Origin
//    int nWidth = nImageWidth;
//    int nHeight = nImageHeight;
//    int nCalWidth = nWidth/2;
//    int nCalHeight = nHeight/2;
// 
//    int nStartX = nWidth/2 - nCalWidth/2;
//    int nStartY = nHeight/2 - nCalHeight/2;
// 
//    //
//    double Focusvalue = 0;
//    double SumValue = 0;
//    double TempValue = 0;
//    double m_nResultFocusValue = 0;
// 
//    for (int y = 0; y < nHeight - 1; y++)
//    {
//       for (int x = 0; x < nWidth - 1; x++)
//       {
//          TempValue = (double)(pImageBufferByte[y*nWidth + x] - pImageBufferByte[y*nWidth + x + 1]);
//          SumValue = TempValue * TempValue;
//          TempValue = (double)(pImageBufferByte[y*nWidth + x] - pImageBufferByte[(y + 1)*nWidth + x]);
//          SumValue += TempValue * TempValue;
// 
//          Focusvalue += sqrt(SumValue);
//          //Focusvalue += SumValue;
//       }
//    }
// 
//    m_nResultFocusValue = int(Focusvalue / (double)(nWidth*nHeight));
// 
//    double dXValue=0., dYValue=0., dCurr=0., dSum=0., dFocus=0.;
//    for(int nH=nStartY ; nH<nStartY+nCalHeight-1 ; nH++)
//    {
//       for(int nW=nStartX ; nW<nStartX+nCalWidth-1 ; nW++)
//       {
//          dXValue = float((pImageBufferByte[nH*nW + nW+1] - pImageBufferByte[nH*nW + nW])*(pImageBufferByte[nH*nW + nW+1] - pImageBufferByte[nH*nW + nW]));
//          dYValue = float((pImageBufferByte[(nH+1)*nW + nW] - pImageBufferByte[nH*nW + nW])*(pImageBufferByte[(nH+1)*nW + nW] - pImageBufferByte[nH*nW + nW]));
//          dCurr = sqrt(dXValue + dYValue);
//          dSum += dCurr;
//       }
//    }
//    dFocus = dSum/double(nCalWidth*nCalHeight);
// 
//    return dFocus;
}

CTimerThreadFileMonitor::CTimerThreadFileMonitor(DWORD dwPeriod /*=10000*/, int nThreadCount /*=1*/)
   : CTimerThreadPools(dwPeriod, nThreadCount), m_pLog(nullptr)
{

}

void CTimerThreadFileMonitor::TimerThreadProcess(PVOID pParameter)
{
   if (m_strFilePath.IsEmpty())
      return;

   std::ofstream file(m_strFilePath);

   if (file.is_open())
   {

   }
   else
   {
      DWORD dwError = GetLastError();

      if(m_pLog)
         m_pLog->DisplayMessage(_T("[FileMonitor Thread] Abort! Error Code[%d][%s] File Path[%s]"), dwError, GetFormatMessageString(dwError), m_strFilePath);

      AfxBeginThread([](LPVOID pParam)->UINT {
         CTimerThreadFileMonitor *pMain = static_cast<CTimerThreadFileMonitor*>(pParam);
         pMain->StopThread();

         return 0;
      }, this);
   }

   return;
}