SDC C-Project CF Review 프로그램
LYW
2022-05-31 f1a543772246f59b8b52a8857270b38ee38f3588
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
#pragma once
 
#include <vector>
#include "GreedyTSP.h"
 
struct SSchedulerResult
{
    SSchedulerResult() 
    {
        Reset();
    }
 
    void Reset()
    {
        nAxisType        = 0; //x
        nPointIndex        = -1;
        nTotalIndex        = -1;
        dPositionX        = 0.0;
        dPositionY        = 0.0;
        dMoveDistance    = 0.0;
        dMoveSpeed        = 0.0;
        dMoveAccel        = 0.0;
        dMoveDecel        = 0.0;
        dMoveTime        = 0.0;
 
        dAutoFocusTime    = 0.0;
        dImageGrabTime    = 0.0;
        dMotionDelayTime = 0.0;
    }
 
    double GetDurationTime() const
    {
        return (dMoveTime+dAutoFocusTime+dImageGrabTime+dMotionDelayTime);
    }
 
    int        nAxisType;
    int        nPointIndex;
    int        nTotalIndex;
 
    int        pDataType[PATH_DATA_TYPE_COUNT];
    
    double    dPositionX;
    double    dPositionY;
 
    double    dMoveDistance;    // mm
    double    dMoveSpeed;        // mm/sec
    double    dMoveAccel;
    double    dMoveDecel;
    double    dMoveTime;
 
    double    dAutoFocusTime;
    double    dImageGrabTime;
    double    dMotionDelayTime;
};
 
class AFX_EXT_CLASS CPathSchedulerResult
{
public:
    CPathSchedulerResult(int nModuleIdx=0, int nScanIdx=0);
    CPathSchedulerResult(const CPathSchedulerResult& rhs);
    CPathSchedulerResult& operator=(const CPathSchedulerResult& rhs);
    virtual ~CPathSchedulerResult(void);
    void Reset();
 
    // adder
    void AddHeadScheduleResult(CPathSchedulerResult& reviewResult);
    void AddTailScheduleResult(CPathSchedulerResult& reviewResult);
    
    // resize
    void ResizeScheduleResult(int nCount);
 
    // setter
    void SetScheduleResultCount(int nCount);
    void SetScheduleResult(int nIndex, const SSchedulerResult& scheduleResult);
    
    // getter
    int GetModuleIndex() const;
    int GetScanIndex() const;
    int    GetPathSchedulerResultCount() const;
    SSchedulerResult* GetPathSchedulerResult();
    const SSchedulerResult* GetPathSchedulerResult() const;
    SSchedulerResult* GetPathSchedulerResult(int nIndex);
    const SSchedulerResult* GetPathSchedulerResult(int nIndex) const;
 
    double GetTotalSchedulerTime() const;
    double GetTotalSchedulerTime(int nIndex) const;
    double GetScheduleTime(int nIndex) const;
    double GetScheduleTime(int nStartIdx, int nEndIdx) const;
    double GetTotalSchedulerDistance() const;
    double GetTotalSchedulerDistance(int nIndex) const;
 
    void    SetCollisionResultIndex(int nIndex);
    void    SetCollisionResultTime(double dTime);
    void    SetCollisionPositionX(int nPos);
    void    SetCollisionPositionY(int nPos);
    int        GetCollisionResultIndex() const;
    double    GetCollisionResultTime() const;
    int        GetCollisionPositionX() const;
    int        GetCollisionPositionY() const;
 
    static BOOL LoadResult(const CString& strFilename, CPathSchedulerResult& reviewResult);
    static BOOL SaveResult(const CString& strFilename, CPathSchedulerResult& reviewResult);
 
protected:
    int                    nModuleIndex;
    int                    nScanIndex;
    SSchedulerResult*    pScheduleResult;    
    int                    nScheduleResultCount;
    int                    nCollisionResultIndex;
    double                dCollisionResultTime;
    int                    nCollisionPositionX;
    int                    nCollisionPositionY;
};
 
typedef std::vector<CPathSchedulerResult>                    VectorPathSchedulerResult;
typedef std::vector<CPathSchedulerResult>::iterator            VectorPathScheduleResultIt;
typedef std::vector<CPathSchedulerResult>::const_iterator    constVectorPathScheduleResultIt;
 
typedef std::vector<CRect>                    VectorRect;
typedef std::vector<CRect>::iterator        VectorRectIt;
typedef std::vector<CRect>::const_iterator    constVectorRectIt;