ed02bcce53e98fb1d752ef67195b7a1df3279013
[blender.git] / intern / iksolver / intern / IK_QChain.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 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  *
37  * @author Laurence
38  */
39
40 #ifndef NAN_INCLUDED_IK_QChain_h
41 #define NAN_INCLUDED_IK_QChain_h
42
43
44 #include "IK_QSegment.h"
45 #include <vector>
46 #include "MT_Scalar.h"
47 #include "TNT/cmat.h"
48
49 /**
50  * This class is a collection of ordered segments that are used
51  * in an Inverse Kinematic solving routine. An IK solver operating
52  * on the chain, will in general manipulate all the segments of the
53  * chain in order to solve the IK problem.
54  * 
55  * To build a chain use the default constructor. Once built it's
56  * then possible to add IK_Segments to the chain by inserting
57  * them into the vector of IK_Segments. Note that segments will be
58  * copied into the chain so chains cannot share instances of 
59  * IK_Segments. 
60  * 
61  * You have full control of which segments form the chain via the 
62  * the std::vector routines. 
63  */
64
65 class IK_QChain{
66
67 public :
68
69         /**
70          * Construct a IK_QChain with no segments.
71          */
72
73         IK_QChain(
74         );
75
76         // IK_QChains also have the default copy constructors
77         // available. 
78
79         /** 
80      * Const access to the array of segments
81          * comprising the IK_QChain. Used for rendering
82          * etc
83      * @return a const reference to a vector of segments
84          */
85
86         const 
87                 std::vector<IK_QSegment> &
88         Segments(
89         ) const ;
90
91
92         /**
93          * Full access to segments used to initialize
94          * the IK_QChain and manipulate the segments.
95          * Use the push_back() method of std::vector to add
96      * segments in order to the chain
97      * @return a reference to a vector of segments
98          */
99
100                 std::vector<IK_QSegment> &
101         Segments(
102         );
103
104
105         /** 
106          * Force the IK_QChain to recompute all the local 
107          * segment transformations and composite them
108          * to calculate the global transformation for 
109          * each segment. Must be called before 
110          * ComputeJacobian()
111      */
112
113                 void
114         UpdateGlobalTransformations(
115         );
116
117         /** 
118          * Return the global position of the end
119          * of the last segment.
120          */
121
122                 MT_Vector3 
123         EndEffector(
124         ) const;
125
126
127         /** 
128          * Return the global pose of the end
129          * of the last segment.
130          */
131
132                 MT_Vector3
133         EndPose(
134         ) const;
135
136
137         /** 
138          * Calculate the jacobian matrix for
139          * the current end effector position.
140          * A jacobian is the set of column vectors
141          * of partial derivatives for each active angle.
142          * This method also computes the transposed jacobian.
143          * @pre You must have updated the global transformations
144          * of the chain's segments before a call to this method. Do this
145          * with UpdateGlobalTransformation()
146          */
147
148                 void
149         ComputeJacobian(
150         );
151         
152
153         /** 
154          * @return A const reference to the last computed jacobian matrix
155          */
156
157         const 
158                 TNT::Matrix<MT_Scalar> &
159         Jacobian(
160         ) const ;
161
162         /** 
163          * @return A const reference to the last computed transposed jacobian matrix
164          */
165
166         const 
167                 TNT::Matrix<MT_Scalar> &
168         TransposedJacobian(
169         ) const ;
170
171         /** 
172          * Count the degrees of freedom in the IK_QChain
173          * @warning store this value rather than using this function
174          * as the termination value of a for loop etc.
175          */
176
177                 int
178         DoF(
179         ) const;
180
181         /** 
182          * Compute the maximum extension of the chain from the
183          * root segment. This is the length of the root segments
184          * + the max extensions of all the other segments
185          */
186         
187         const 
188                 MT_Scalar
189         MaxExtension(
190         ) const;
191
192
193 private :
194
195         /// The vector of segments comprising the chain
196         std::vector<IK_QSegment> m_segments;
197
198         /// The jacobain of the IK_QChain
199         TNT::Matrix<MT_Scalar> m_jacobian;
200
201         /// It's transpose
202         TNT::Matrix<MT_Scalar> m_t_jacobian;
203
204         MT_Vector3 m_end_effector;              
205         MT_Vector3 m_end_pose;
206
207
208 };
209
210
211 #endif