Initial revision
[blender.git] / intern / iksolver / intern / IK_Chain.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program 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
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 #ifndef NAN_INCLUDED_IK_Chain_h
33
34 #define NAN_INCLUDED_IK_Chain_h
35
36 /**
37  * @author Laurence Bourn
38  * @date 28/6/2001
39  */
40
41 #include "IK_Segment.h"
42 #include <vector>
43 #include "MT_Scalar.h"
44 #include "TNT/cmat.h"
45
46 /**
47  * This class is a collection of ordered segments that are used
48  * in an Inverse Kinematic solving routine. An IK solver operating
49  * on the chain, will in general manipulate all the segments of the
50  * chain in order to solve the IK problem.
51  * 
52  * To build a chain use the default constructor. Once built it's
53  * then possible to add IK_Segments to the chain by inserting
54  * them into the vector of IK_Segments. Note that segments will be
55  * copied into the chain so chain's cannot share instances of 
56  * IK_Segments. 
57  * 
58  * You have full control of which segments form the chain via the 
59  * the std::vector routines. 
60  */
61 class IK_Chain{
62
63 public :
64
65         /**
66          * Construct a IK_Chain with no segments.
67          */
68
69         IK_Chain(
70         );
71
72         // IK_Chains also have the default copy constructors
73         // available. 
74
75         /** 
76      * Const access to the array of segments
77          * comprising the IK_Chain. Used for rendering
78          * etc
79      * @return a vector of segments
80          */
81
82         const 
83                 std::vector<IK_Segment> &
84         Segments(
85         ) const ;
86
87
88         /**
89          * Full access to segments used to initialize
90          * the IK_Chain and manipulate the segments.
91          * Use the push_back() method of std::vector to add
92      * segments in order to the chain
93          */
94
95                 std::vector<IK_Segment> &
96         Segments(
97         );
98
99
100         /** 
101          * Force the IK_Chain to recompute all the local 
102          * segment transformations and composite them
103          * to calculate the global transformation for 
104          * each segment. Must be called before 
105          * ComputeJacobian()
106      */
107
108                 void
109         UpdateGlobalTransformations(
110         );
111
112         /** 
113          * Return the global position of the end
114          * of the last segment.
115          */
116
117                 MT_Vector3 
118         EndEffector(
119         ) const;
120
121
122         /** 
123          * Return the global pose of the end
124          * of the last segment.
125          */
126
127                 MT_Vector3
128         EndPose(
129         ) const;
130
131
132         /** 
133          * Calculate the jacobian matrix for
134          * the current end effector position.
135          * A jacobian is the set of column vectors
136          * of partial derivatives for each active angle.
137          * This method also computes the transposed jacobian.
138          * @pre You must have updated the global transformations
139          * of the chain's segments before a call to this method. Do this
140          * with UpdateGlobalTransformation()
141          */
142
143                 void
144         ComputeJacobian(
145         );
146         
147
148         /** 
149          * @return A reference to the last computed jacobian matrix
150          */
151
152         const 
153                 TNT::Matrix<MT_Scalar> &
154         Jacobian(
155         ) const ;
156
157         /** 
158          * @return A reference to the last computed transposed jacobian matrix
159          */
160
161         const 
162                 TNT::Matrix<MT_Scalar> &
163         TransposedJacobian(
164         ) const ;
165
166         /** 
167          * Count the degrees of freedom in the IK_Chain
168          * @warning store this value rather than using this function
169          * as the termination value of a for loop etc.
170          */
171
172                 int
173         DoF(
174         ) const;
175
176
177 private :
178
179         /// The vector of segments comprising the chain
180         std::vector<IK_Segment> m_segments;
181
182         /// The jacobain of the IK_Chain
183         TNT::Matrix<MT_Scalar> m_jacobian;
184
185         /// It's transpose
186         TNT::Matrix<MT_Scalar> m_t_jacobian;
187
188         MT_Vector3 m_end_effector;              
189         MT_Vector3 m_end_pose;
190
191 };
192
193
194 #endif