SDC C-Project CF Review 프로그램
LYW
2021-07-01 668b40db8e394058c7e0abad2fbe539a631043c2
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
#pragma once
#include <vector>
 
enum EdgeDirectionType    { EdgeDirection_Horiz=0, EdgeDirection_Vert, EdgeDirection_Count };
enum EdgeSearchType        { EdgeSearch_MinMax=0, EdgeSearch_Out2In, EdgeSearch_In2Out, EdgeSearch_Count };
enum EdgeSignalType        { EdgeSignal_Negative=0, EdgeSignal_Positive, EdgeSignal_None, EdgeSignal_Count };
enum EdgeResultType        { EdgeResult_Mid=0, EdgeResult_Left, EdgeResult_Right, EdgeResult_Count };
enum SubPixelType        { SubPixel_Linear=0, SubPixel_Quadratic, SubPixel_Gaussian, SubPixel_Quadratic_Regress, SubPixel_Gaussian_Regress, SubPixel_Count };
enum PreProcessType        { PreProc_None=0, PreProc_Sobel, PreProc_Count };
enum MeasureType        { Measure_Line=0, Measure_Circle, Measure_Ellipse };
 
class AFX_EXT_CLASS CRecipeMarker
{
public:
    CRecipeMarker(void);
    ~CRecipeMarker(void);
    void Reset()
    {
        m_nTypeBand            = 3;
        m_nTypeSubPixel        = SubPixel_Quadratic;
        m_nTypePreProcess    = PreProc_None;
        m_nMeasureType        = Measure_Line;
 
        m_nEdgeLeft            = EdgeSignal_Positive;
        m_nEdgeRight        = EdgeSignal_Negative;
        m_nEdgeKernelSize    = 4;
        m_dEdgeKernelSigma    = 1.0;
        m_dEdgeAngle        = 0.0;
        m_dEdgeThreshold    = 5.0;
        m_dEdgePosiThres    = 5.0;
        m_dEdgeNegaThres    = -5.0;
        m_nEdgeDirection    = EdgeDirection_Vert;
        m_nEdgeSearchType    = EdgeSearch_MinMax;
        m_nIteration        = 10;    
 
        m_dLength            = 20.0;    
        m_dLengthVariation    = 5.0;
 
        m_nCircleThreshold    = 100;
        m_nCircleBlobMargin = 3;
 
        m_nROILeft            = -1;
        m_nROITop            = -1;
        m_nROIWidth            = -1;
        m_nROIHeight        = -1;
    }
 
    int        m_nTypeBand;
    int        m_nTypeSubPixel;
    int        m_nTypePreProcess;
    int        m_nMeasureType;
 
    int        m_nEdgeLeft;
    int        m_nEdgeRight;
    int        m_nEdgeKernelSize;
    double    m_dEdgeKernelSigma;
    double    m_dEdgeAngle;
    double    m_dEdgeThreshold;
    double    m_dEdgePosiThres;
    double    m_dEdgeNegaThres;
    int        m_nEdgeDirection;
    int        m_nEdgeSearchType;
 
    int        m_nIteration;
    
    double    m_dLength;    
    double    m_dLengthVariation;
 
    int        m_nCircleThreshold;
    int        m_nCircleBlobMargin;
 
    int        m_nROILeft;
    int        m_nROITop;
    int        m_nROIWidth;
    int        m_nROIHeight;
};
typedef std::vector<CRecipeMarker>                VectorRecipeMarker;
typedef std::vector<CRecipeMarker>::iterator    VectorRecipeMarkerIt;
 
class AFX_EXT_CLASS CResultMarker
{
public:
    CResultMarker(void);
    ~CResultMarker(void);
    void Reset()
    {
        m_nResultCode        = 0;
        m_nMeasureType        = 0;
        m_nEdgeDirection    = 0;
        m_dEdgeValue        = 0.0;
 
        m_dCenterX            = 0.0;
        m_dCenterY            = 0.0;
 
        m_dLength            = 0.0;
        m_dFirstX            = 0.0;
        m_dFirstY            = 0.0;
 
        m_dSecondX            = 0.0;
        m_dSecondY            = 0.0;
    }
 
    int            m_nResultCode;
    int            m_nMeasureType;
    int            m_nEdgeDirection;
    double        m_dEdgeValue;
 
    double        m_dCenterX;
    double        m_dCenterY;
    double        m_dLength;
 
    double        m_dFirstX;
    double        m_dFirstY;
 
    double        m_dSecondX;
    double        m_dSecondY;
 
};
typedef std::vector<CResultMarker>                VectorResultMarker;
typedef std::vector<CResultMarker>::iterator    VectorResultMarkerIt;