주석 추가

LYW

2021-06-09 f143e5ece742a275d1e360c55e829d21e706b26d

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
#pragma once
 
#include <vector>
#include "SPosition2D.h"
 
struct SCalculateResult
{
    SCalculateResult() 
    {    
        Reset();
    }
 
    void Reset()
    {
        dStraightLineA        = 0.;
        dStraightLineB        = 0.;
        dOrthogonalLineA    = 0.;
        dOrthogonalLineB    = 0.;
        dStraghtValue        = 0.;
        dOrthogonalValue    = 0.;
        dOrthogonalTheta    = 0.;
    }
 
    double dStraightLineA;
    double dStraightLineB;
    double dOrthogonalLineA;
    double dOrthogonalLineB;
 
    double dStraghtValue;
    double dOrthogonalValue;
    double dOrthogonalTheta;
};
typedef std::vector<SCalculateResult>                    VectorCalculateResult;
typedef std::vector<SCalculateResult>::iterator            VectorCalculateResultIt;
typedef std::vector<SCalculateResult>::const_iterator    constVectorCalculateResultIt;
 
typedef std::vector<double>                                VectorDouble;
typedef std::vector<double>::iterator                    VectorDoubleIt;
typedef std::vector<double>::const_iterator                constVectorDoubleIt;
 
class AFX_EXT_CLASS CMotorCalculator
{
public:
    CMotorCalculator(int nIndex=-1);
    virtual ~CMotorCalculator(void);
    void Reset();
 
    void SetDesignPosition(const VectorDouble& vectorPosX, const VectorDouble& vectorPosY);
    void SetDesignPosition(const VectorPosition2D& vectorDesignPos)        { m_vectorDesignPos = vectorDesignPos; }
    void SetMotorPosition(const VectorDouble& vectorPosX, const VectorDouble& vectorPosY);
    void SetMotorPosition(const VectorPosition2D& vectorMotorPos)        { m_vectorMotorPos = vectorMotorPos; }
 
    const VectorPosition2D* GetDesignPosition()                            { return &m_vectorDesignPos; }
    const VectorPosition2D* GetMotorPosition()                            { return &m_vectorMotorPos; }
    const SCalculateResult*    GetCalculateResult()                        { return &m_sCalculateResult; }
 
    int CalculateResult();
 
protected:
    int                        m_nIndex;
    VectorPosition2D        m_vectorDesignPos;
    VectorPosition2D        m_vectorMotorPos;
    SCalculateResult        m_sCalculateResult;
 
};