SDC C-Project CF Review 프로그램
blame | 히스토리 | 패치 | 커밋 | 커밋비교 | 공백 무시
kojingeun
2023-06-30 0d1dc43291d094add1afbd40d39ae48760041176 
 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,13 @@


   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.SetParam(CDisplayMessage::GetSingletonPtr(), strDummyFilePath);


   m_threadFileMonitor.StartThread();


   /* < KJG 20230630 - #4517 ADD End >*/


}




CReviewProcessor_CPJT::~CReviewProcessor_CPJT(void)


@@ -359,7 +394,6 @@


   }




   LeaveCriticalSection(&m_csUserCriticalSection);


.


   m_pRP2P->IRP2P_UpdateReviewResult(nModuleIndex, pGlassResult);


   return;




@@ -1224,15 +1258,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 +1310,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 +1446,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 +1519,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 +3847,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;


}