doxygen: intern/itasc tagged
[blender.git] / intern / itasc / kdl / joint.hpp
1 // Copyright  (C)  2007  Ruben Smits <ruben dot smits at mech dot kuleuven dot be>
2
3 // Version: 1.0
4 // Author: Ruben Smits <ruben dot smits at mech dot kuleuven dot be>
5 // Maintainer: Ruben Smits <ruben dot smits at mech dot kuleuven dot be>
6 // URL: http://www.orocos.org/kdl
7
8 // This library is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
12
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 // Lesser General Public License for more details.
17
18 // You should have received a copy of the GNU Lesser General Public
19 // License along with this library; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21
22 #ifndef KDL_JOINT_HPP
23 #define KDL_JOINT_HPP
24
25 #include "frames.hpp"
26 #include <string>
27
28 namespace KDL {
29
30     /**
31           * \brief This class encapsulates a simple joint, that is with one
32           * parameterized degree of freedom and with scalar dynamic properties.
33      *
34      * A simple joint is described by the following properties :
35      *      - scale: ratio between motion input and motion output
36      *      - offset: between the "physical" and the "logical" zero position.
37      *      - type: revolute or translational, along one of the basic frame axes
38           *      - inertia, stiffness and damping: scalars representing the physical
39           *      effects along/about the joint axis only.
40      *
41      * @ingroup KinematicFamily
42      */
43     class Joint {
44     public:
45         typedef enum { RotX,RotY,RotZ,TransX,TransY,TransZ,Sphere,Swing,None} JointType;
46         /**
47          * Constructor of a joint.
48          *
49          * @param type type of the joint, default: Joint::None
50          * @param scale scale between joint input and actual geometric
51          * movement, default: 1
52          * @param offset offset between joint input and actual
53          * geometric input, default: 0
54          * @param inertia 1D inertia along the joint axis, default: 0
55          * @param damping 1D damping along the joint axis, default: 0
56          * @param stiffness 1D stiffness along the joint axis,
57          * default: 0
58          */
59         Joint(const JointType& type=None,const double& scale=1,const double& offset=0,
60               const double& inertia=0,const double& damping=0,const double& stiffness=0);
61         Joint(const Joint& in);
62
63         Joint& operator=(const Joint& arg);
64
65         /**
66          * Request the 6D-pose between the beginning and the end of
67          * the joint at joint position q
68          *
69          * @param q the 1D joint position
70          *
71          * @return the resulting 6D-pose
72          */
73         Frame pose(const double& q)const;
74         /**
75          * Request the resulting 6D-velocity with a joint velocity qdot
76          *
77          * @param qdot the 1D joint velocity
78          *
79          * @return the resulting 6D-velocity
80          */
81         Twist twist(const double& qdot, int dof=0)const;
82
83         /**
84          * Request the type of the joint.
85          *
86          * @return const reference to the type
87          */
88         const JointType& getType() const
89         {
90             return type;
91         };
92
93         /**
94          * Request the stringified type of the joint.
95          *
96          * @return const string
97          */
98         const std::string getTypeName() const
99         {
100             switch (type) {
101             case RotX:
102                 return "RotX";
103             case RotY:
104                 return "RotY";
105             case RotZ:
106                 return "RotZ";
107             case TransX:
108                 return "TransX";
109             case TransY:
110                 return "TransY";
111             case TransZ:
112                 return "TransZ";
113                         case Sphere:
114                                 return "Sphere";
115                         case Swing:
116                                 return "Swing";
117             case None:
118                 return "None";
119             default:
120                 return "None";
121             }
122         };
123                 unsigned int getNDof() const;
124
125         virtual ~Joint();
126
127     private:
128         Joint::JointType type;
129         double scale;
130         double offset;
131         double inertia;
132         double damping;
133         double stiffness;
134     };
135
136 } // end of namespace KDL
137
138 #endif