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
#pragma once
 
#include "InspectDefect.h"
#include "Global_Define.h"
 
#define        RUSULT_POINT_COUNT        5
 
class CCameraSettings;
class CResultData
{
public:
    CResultData(void);    
    virtual ~CResultData(void);
    CResultData& operator=(CResultData& rh);
 
public:
    void                Reset();
    void                TrimString();
    void                CalJudgement();        
    void                SetInspectOpt(CInspectOption *pInsOpt,CProfileOption *pProfileOpt){m_pInspectOpt=pInsOpt,m_pProfileOpt=pProfileOpt;}
 
public:
    BOOL                m_bGlassResult;    
    CString                m_strRecipeName,m_strScanStartTime,m_strScanEndTime,m_strPCID;
 
// Cut Area
    BOOL                m_bCutAreaRes[2][MAX_DIMENSION_COUNT];
    double                m_dCutAreaPoint[2][MAX_DIMENSION_COUNT][RUSULT_POINT_COUNT];
    double                m_dCutAreaAvg[2][MAX_DIMENSION_COUNT];
    BOOL                m_bCutAreaDiagonalLine[2][MAX_DIMENSION_COUNT];//20140622
    double                m_dCutAreaDiagonalLine[2][MAX_DIMENSION_COUNT];//20140622
    double                GetCutAreaAvg(std::vector<STU_THICKPOS*> *pCamThick,CAMERA_DIR camDir);
    double                GetCutAreaStdDev(std::vector<STU_THICKPOS*> *pCamThick,CAMERA_DIR camDir,double dAvg);
    BOOL                GetRangeCheck(int nBase,int nMinus,int nPlus,int nValue);
    void                GetJudgePointValue(std::vector<STU_THICKPOS> *pVecThick,CAMERA_DIR camDir,DimensionDir enDir,int nGlassSize);
    BOOL                GetJudgePointMaxMin(std::vector<STU_THICKPOS> *pVecThick,int &nMinPos,int &nMaxPos);
    double                GetJudgePointRangeValue(std::vector<STU_THICKPOS> *pVecThick,int nGlassSize,int iPos);        
    void                Save_FullImgProc_ROI(LPBYTE pImg,CSize szImg,CRect ROI,LPBYTE lpIn);
    BOOL                FlipImage(LPBYTE pImg,CSize szImg);
 
// Dimension
    BOOL                m_bDimensionRes[MAX_DIMENSION_COUNT];
    double                m_dDimensionAvg[MAX_DIMENSION_COUNT];
    double                m_dDimensionPoint[MAX_DIMENSION_COUNT][RUSULT_POINT_COUNT];
    double                m_dGlassSize[2];
    double                GetDimensionAvg(std::vector<STU_DIMENSIONPOS*> *pResult);
    double                GetDimensionStd(std::vector<STU_DIMENSIONPOS*> *pResult,double dAvg);
    void                GetDimensionPointValue(std::vector<STU_DIMENSIONPOS> *pData,DimensionDir enDir);
    double                GetDimensionPointRangeValue(std::vector<STU_DIMENSIONPOS> *pData,double dPos);
 
// Spline
    BOOL                m_bSplineRes[2][2];
    double                m_dSplineAvg[2][2];
    double                m_dSplinePoint[2][2][RUSULT_POINT_COUNT];
    double                m_dSplineMaxDefect[MAX_DIMENSION_COUNT];
 
// Notch
    BOOL                m_bUseNCutSize[MAX_DIMENSION_COUNT];
    BOOL                m_bUseNCutChip[MAX_DIMENSION_COUNT];
    BOOL                m_bNCutSize[2];
    BOOL                m_bNCutThick[2];
    double                m_dNCutThick[2];
    double                m_dNCutAvg[2];
    double                m_dNCutX[MAX_DIMENSION_COUNT];
    double                m_dNCutY[MAX_DIMENSION_COUNT];
    double                m_dNCutDiff[MAX_DIMENSION_COUNT];
    CPoint                m_pointCAD[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    CPoint                m_pointIMG[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    double                m_dNCutRange[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    BOOL                m_bNCutRange[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
 
    CPoint                m_pointCAD_Dy[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    CPoint                m_pointIMG_Dy[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    double                m_dNCutRange_Dy[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    BOOL                m_bNCutRange_Dy[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
 
    CPoint                m_pointCAD_Cham[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    CPoint                m_pointIMG_Cham[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    double                m_dNCutRange_Cham[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
    BOOL                m_bNCutRange_Cham[2][MAX_DIMENSION_COUNT][NOTCH_RANGE_VAL_MAX_COUNT];//20140528
 
    int                    m_nNotchInsCount[MAX_DIMENSION_COUNT];//20140528
    BOOL                m_bUseNotchPointIns_Dimen[MAX_DIMENSION_COUNT];//20140721
    BOOL                m_bUseNotchPointIns_Cham[MAX_DIMENSION_COUNT];//20140721
 
// Corner Cut
    BOOL                m_bCornerResWidth[2][2];    
    BOOL                m_bCornerResHeight[2][2];    
    double                m_dCornerWidth[2][2];
    double                m_dCornerHeight[2][2];
    int                    m_nCornerImageCamIdx[2][2];
 
// Defect
    int                    m_nCrackCount,m_nBrokenCount,m_nChipCount,m_nChamferCount,m_nBurrCount,m_nUnknownCount;
    double                m_dDefectPosMax[MAX_DIMENSION_COUNT];    
    int                    m_nErrorCountCF;
    int                    m_nErrorCountTFT;
    int                    m_nMaxDefectCam;
    MapDefect            *m_pDefectIns;
    int                    m_nDefectCnt;
    void                SetDefectIns(MapDefect *pMapDefect,int nDefectCnt){m_pDefectIns=pMapDefect,m_nDefectCnt=nDefectCnt;}
 
//Left Line
    int                    m_nLeftLineMargin[MAX_DIMENSION_COUNT];
 
    CInspectOption        *m_pInspectOpt;
    CProfileOption        *m_pProfileOpt;
};