# C_PJT_CF_REVIEW 최초 커밋

LAPTOP-N7PT1MHU\dit-709

2021-05-10 a94966aed7229fbacf418acf73dfb0885050f47d

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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
#pragma once
 
 
class AFX_EXT_CLASS CPadPoint
{
public:
    int x, y;
 
    void SetPoint(int px, int py)    { x= px; y= py;    }
    void VectorTo(CPadPoint &point)    {    x= point.x- x;    y= point.y- y;    }
 
    BOOL FindCrossX(CPadPoint &point, int cy, int &tx);// ÀÓÀÇÀÇ cy¿¡ ÇØ´çÇϴ x °ª ±¸Çϱâ
    BOOL FindCrossY(CPadPoint &point, int cx, int &ty);// ÀÓÀÇÀÇ cx¿¡ ÇØ´çÇϴ y °ª ±¸Çϱâ
 
    BOOL ChangeCrossHori(CPadPoint &point, int cy);// ÀÓÀÇÀÇ cy¿¡ ÇØ´çÇϴ x, y ·Î point °ª ¹Ù²Ù±â
    BOOL ChangeCrossVert(CPadPoint &point, int cx);// ÀÓÀÇÀÇ cx¿¡ ÇØ´çÇϴ x, y ·Î point °ª ¹Ù²Ù±â
};
 
class AFX_EXT_CLASS CTrapezium
{
public:
    CPadPoint    m_TrapPoint[4];
 
public:
    CTrapezium*    GetSelfTrapezium()    {return this;}
    int        GetTop()    {return m_TrapPoint->y;}
    int        GetBottom()    {return m_TrapPoint[3].y;}
    void    OffsetPlus(int x, int y)
    {
        for(int i= 0; i< 4; i++)
        {
            m_TrapPoint[i].x+= x;
            m_TrapPoint[i].y+= y;
        }
    }
    void    ChangeAxis()
    {
        int temp;
        for(int i= 0; i< 4; i++)
        {
            temp= m_TrapPoint[i].x;
            m_TrapPoint[i].x= m_TrapPoint[i].y;
            m_TrapPoint[i].y= temp;
        }
    }
    void OpenTrap(CPadPoint &TopLeft, CPadPoint &TopRight)
    {
        m_TrapPoint[0]= TopLeft;
        m_TrapPoint[1]= TopRight;
    }
    void CloseTrap(CPadPoint &BotLeft, CPadPoint &BotRight)
    {
        m_TrapPoint[2]= BotLeft;
        m_TrapPoint[3]= BotRight;
    }
};
 
class AFX_EXT_CLASS CTrapeziumStorage
{
protected:
    int m_nTrapSpace;
    int m_nTrap;
    CTrapezium    m_Trapeziums[10];
    
public:
    CTrapeziumStorage(){m_nTrapSpace= 10; ResetTrapeziumCount();}
 
public:
    void ResetTrapeziumCount(){m_nTrap= 0;}
    CTrapezium*    GetTrapezium(int i){    return m_Trapeziums+ i;}
    int    GetTrapeziumCount(){return m_nTrap;}
 
    BOOL OpenTrap(CPadPoint &TopLeft, CPadPoint &TopRight)
    {
        if(m_nTrap >= m_nTrapSpace)
            return FALSE;
        //m_Trapeziums[m_nTrap].m_TrapPoint[0]= TopLeft;
        //m_Trapeziums[m_nTrap].m_TrapPoint[1]= TopRight;
        m_Trapeziums[m_nTrap].OpenTrap(TopLeft, TopRight);
        return TRUE;
    }
    BOOL CloseTrap(CPadPoint &BotLeft, CPadPoint &BotRight)
    {
        if(m_nTrap >= m_nTrapSpace)
            return FALSE;
        //m_Trapeziums[m_nTrap].m_TrapPoint[2]= BotLeft;
        //m_Trapeziums[m_nTrap].m_TrapPoint[3]= BotRight;
        m_Trapeziums[m_nTrap].CloseTrap(BotLeft, BotRight);
        m_nTrap++;
        return TRUE;
    }
};
 
class AFX_EXT_CLASS CPadPoligon
{
    int            m_nPadPoint;    // À¯È¿ Æ÷ÀÎÆ® ¼ö
    BOOL        m_bHorizontal;    // °Ë»ç ¹æÇâ
public:
    int            m_iTopLeft, m_iTopRight;    // m_iTopLeft = 0 À̾î¾ß ÇÑ´Ù.
    int            m_iBottomRight, m_iBottomLeft;        // 
 
//    int            m_iLeftBottom, m_iLeftTop;    // vertical À̸é TopÀÌ Left·Î ¹Ù²î´Â °ÍÀÌÁö·Õ..
//    int            m_iRightTop, m_iRightBottom;
 
    CPadPoint    m_PadPoints[10];
    CRect        m_OutRect;
    float        m_PitchMin;
    float        m_PitchMax;
 
public:
    int        GetPointCount(){return m_nPadPoint;}
    CPadPoint* GetPadPoint(int i){ return m_PadPoints+ i;}
    CPadPoint* GetPadPoint_Round(int i){ return m_PadPoints+ GetRoundIndex(i);}
 
    int        GetRoundIndex(int id){return id%m_nPadPoint;}
    int        GetNextIndex(int id){ return (id+ 1)%m_nPadPoint;}
    int        GetPreIndex(int id){ return (id+ m_nPadPoint- 1)%m_nPadPoint;}
    void    CalOutRect();
 
public:
    CPadPoligon()    {        ResetPoligon();    }
    CPadPoligon* GetSelfPoligon(){return this;}
    /////------- test debug
    void Test();
    void OffsetPlusIndex(int start);
    void OffsetPlus(int dx, int dy);
    void ReverseIndex(int start);
    /////======= test debug
    BOOL IsClockwise();
 
    void ResetPoligon(){m_nPadPoint= 0;}
    void AddPoint(int x, int y)
    {
        m_PadPoints[m_nPadPoint].x= x;
        m_PadPoints[m_nPadPoint].y= y;
        m_nPadPoint++;
    }
    void AddPoint(CPadPoint& point)
    {
        m_PadPoints[m_nPadPoint]= point;
        m_nPadPoint++;
    }
 
    void Cut_Margin(int left, int right, CPadPoligon &PadPoligon)
    {    Cut_LeftRight(left, right, PadPoligon);}
    void Cut_LeftRight(int left, int right, CPadPoligon &PadPoligon);
    void Cut_TopBottom(int top, int bottom, CPadPoligon &PadPoligon);
    void Cut_3Pitch(float fPitch);
    void Find_Corner();
 
    BOOL Cut_TrapeziumHori(CTrapeziumStorage    *pTrapeziums);
    BOOL Cut_TrapeziumVert(CTrapeziumStorage    *pTrapeziums);
};
 
class AFX_EXT_CLASS CPoligonStorage
{
    int            m_nPadPoligon;
    CPadPoligon    m_PadPoligons[10];
public:
    CPadPoligon* GetPadPoligon(int i){ return m_PadPoligons+ i;}
};