SDC C-Project CF Review 프로그램
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#pragma once
 
#include "ReviewProcessor.h"
#include "CHEdgeTriangle/EdgeTriangle.h"
#include "LineChecker/LineChecker.h"
#include "CHThreadPools/TimerThreadPools.h" /* < KJG 20230630 - #4517 ADD Start >*/
 
#define ErrorCount 20
 
#define ImageCaptionStartX    10
#define ImageCaptionStartY    1900
 
enum CPJT_PROCESS_STATUS {CPJT_REVIEW_SUCCESS = 0, CPJT_USER_SUCCESS, CPJT_MEASURE_SUCCESS, CPJT_WSI_SUCCESS,CPJT_REFLOW_SUCCESS}; //kmj
#define GLASS_SIZE_WIDTH    2500000
#define GLASS_SIZE_HEIGHT    2200000
enum RPCornerCutDirection    { RPCLeftTop=0, RPCRightTop, RPCLeftBottom,   RPCRightBottom };
enum RPOriginDirection    { RPOLeftTop=0, RPORightTop, RPOLeftBottom,   RPORightBottom };
 
 
class CTimerThreadFileMonitor : public CTimerThreadPools /* < KJG 20230630 - #4517 ADD Start >*/
{
public:
    explicit CTimerThreadFileMonitor(DWORD dwPeriod = 10000, int nThreadCount = 1);
    ~CTimerThreadFileMonitor() = default;
 
    void SetParam(CDisplayMessage* pLog, CString strPath) { m_pLog = pLog; m_strFilePath = strPath; }
 
private:
    CDisplayMessage* m_pLog;
    CString m_strFilePath;
 
    void TimerThreadProcess(PVOID pParameter);
 
};
 
class CReviewProcessor_CPJT : public CReviewProcessor
{
public:
    CReviewProcessor_CPJT(int nThreadCount=1);
    virtual ~CReviewProcessor_CPJT(void);
 
    virtual void    AddWsiResultData(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    AddWsiReflowResultData(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    AddWsiUserResultData(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    AddWsiVLSIResultData(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    AddWsiMultiShotResultData(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    AddCameraImageData(int nModuleIndex, int nResultIndex, VectorImageData& vectorImageData);
    virtual int        AddReviewProcessData(SReviewResult* pReviewResult);
 
    BOOL bLeftGantryReviewDone;
    BOOL bRightGantryReviewDone;
 
    void    ResetGantryDone();
 
 
    virtual int        PostProcessReviewResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessUserResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessWsiResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessMeasureResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessReflowResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessWsiReflowResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessWsiUserResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessWsiMultiShotResult(int nThreadIdx, SReviewResult* pReviewResult);
    virtual int        PostProcessWsiVLSIResult(int nThreadIdx, SReviewResult* pReviewResult);
 
 
    BOOL            CheckProcessSuccess(CRsRcpReviewInfo* pRsRcpReviewInfo);
    void            ProcessSuccessReset();
 
    void            FileMonitorThreadStart() { m_threadFileMonitor.StartThread(); } /* < KJG 20230630 - #4517 ADD Start >*/
    void            FileMonitorThreadStop() { m_threadFileMonitor.StopThread(); } /* < KJG 20230630 - #4517 ADD Start >*/
 
protected:
    virtual void    WorkThreadProcess(PVOID pParameter);
    int                CheckMotionComplete();
 
private:
    int        ProcessReview(int nThreadIdx, SReviewResult* pReviewResult);
    int        ProcessMeasure(int nThreadIdx, SReviewResult* pReviewResult);
    int        ProcessWSI(int nThreadIdx, SReviewResult* pReviewResult);
    int        ProcessUser(int nThreadIdx, SReviewResult* pReviewResult);
    int        ProcessReflow(int nThreadIdx, SReviewResult* pReviewResult);
    int        ProcessWSIReflow(int nThreadIdx, SReviewResult* pReviewResult);
    int     ProcessWSIUser(int nThreadIdx, SReviewResult* pReviewResult);
    int     ProcessWSIMultiShot(int nThreadIdx, SReviewResult* pReviewResult);
    // ProcessReview
    BOOL    MakeReviewImageFileName(SReviewResult* pReviewResult);
    void    LoadAoiImage(const CString& strGlassID, int nOpticType, int nPosX, int nPosY, CCHImageData* pAoiDark, CCHImageData *pAoiBright);
    void    FindAoiDefectImagePath(const CString& strGlassID, int nOpticType, int nPosX, int nPosY,  CString& strDarkPath, CString& strBrightPath);
    void    FindDefectPos(int nThreadIdx, CCHImageData* pImageData, const SReviewDefectFindParam& findParam, SReviewDefectFindResult& findResult, SReviewResult* pReviewResult);
    BOOL    MakeUploadImage(CCHImageData *pUploadImage, CCHImageData *pReviewCam, CCHImageData *pAoiDark, CCHImageData *pAoiBright, const SReviewDefectFindResult& findResult, const SReviewResult* pReviewResult);
    void    MakeAoiImage(CCHImageData *pAoiDark, CCHImageData* pAoiBright,  CCHImageData* pAoiDark1, CCHImageData* pAoiBright1, CCHImageData* pAoiDark2, CCHImageData* pAoiBright2, int& nMaxWidth, int& nMaxHeight);
    void    DrawAoiImage(CDC *pDC, CCHImageData *pAoiDark1, CCHImageData* pAoiBright1, CCHImageData *pAoiDark2, CCHImageData* pAoiBright2, int nWidth, int nHeight);
    void    DrawDefectInfo(CDC *pDC, const SReviewDefectFindResult& findResult, const SReviewResult* pReviewResult);
 
    // ProcessMeasure
    BOOL    MakeMeasureImageFileName(SReviewResult* pReviewResult);
    BOOL    MakeUploadMeasureImage(CCHImageData *pUploadImage, CCHImageData *pReviewCam, const SReviewResult* pReviewResult, CResultTriangle * pResultTriangle, int nMeasureResult); //Modify by JuneKi 2016-02-29
 
    // ProcessUser
    BOOL    MakeUserImageFileName(SReviewResult* pReviewResult);    
 
    // ProcessReflow
    BOOL    MakeReflowImageFileName(SReviewResult* pReviewResult);
    
    // Checking Process Success    
    BOOL    bProcessSuccess[3]; //kmj
 
    // 190130 SJB, Plan Memory Update
    BOOL    UpdateMemoryReviewPlan(SReviewResult* pReviewResult);
    BOOL    UpdateMemoryUserPlan(SReviewResult* pReviewResult);
    BOOL    UpdateMemoryReflowPlan(SReviewResult* pReviewResult);
    BOOL    UpdateMemoryWsiPlan(SReviewResult* pReviewResult);
    BOOL    UpdateMemoryWsiReflowPlan(SReviewResult* pReviewResult);
    BOOL    UpdateMemoryWsiUserPlan(SReviewResult* pReviewResult);
    BOOL    UpdateMemoryWsiMutiShotPlan(SReviewResult* pReviewResult);
 
    // process image
    double    CalcFocusValue(const char* pImageBuffer, int nImageWidth, int nImageHeight, int nMothod=FocusValueMethod_Diff);
 
public:
    CString MakeWSIImageFileName( SReviewResult* pReviewResult );
    double GetCentertoOrginCoordinate(double dPosX,double dPosY,int nCornercut,int nOriginDirection);
    CString GetStepID(int nMachin);
    CString GetEQPID(int nMachin);
    CString GetStackType(int nStackType);
private:
    CRITICAL_SECTION    m_csUserCriticalSection;
 
    CMotorControlInfo* m_MotorControlInfo;
 
    CString m_strReviewFirst;
    CString m_strReviewSecned;
 
    CTimerThreadFileMonitor m_threadFileMonitor; /* < KJG 20230630 - #4517 ADD Start >*/
 
protected:
    CString                ErrorStringCode[ErrorCount];
};