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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/**
* $Id$
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
/**
* $Id$
* Copyright (C) 2001 NaN Technologies B.V.
*
* @author Laurence
* @mainpage IK - Blender inverse kinematics module.
*
* @section about About the IK module
*
* This module allows you to create segments and form them into
* chains. You can then define a goal point that the end of the
* chain should attempt to reach - an inverse kinematic problem.
* This module will then modify the segments in the chain in
* order to get the end of the chain as near as possible to the
* goal. This solver uses an inverse jacobian method to find
* a solution.
*
* @section issues Known issues with this IK solver.
*
* - The current solver works with only one type of segment. These
* segments always have 3 degress of freedom (DOF). i.e. the solver
* uses all these degrees to solve the IK problem. It would be
* nice to allow the user to specify different segment types such
* as 1 DOF joints in a given plane. 2 DOF joints about given axis.
* - There is currently no support for joint constraints in the
* solver. This is within the realms of possibility - please ask
* if this functionality is required.
* - The solver is slow, inverse jacobian methods in general give
* 'smooth' solutions and the method is also very flexible, it
* does not rely on specific angle parameterization and can be
* extended to deal with different joint types and joint
* constraints. However it is not suitable for real time use.
* Other algorithms exist which are more suitable for real-time
* applications, please ask if this functionality is required.
*
* @section dependencies Dependencies
*
* This module only depends on Moto.
*/
#ifndef NAN_INCLUDED_IK_solver_h
#define NAN_INCLUDED_IK_solver_h
#ifdef __cplusplus
extern "C" {
#endif
/**
* External segment structure
*/
/**
* This structure defines a single segment of an IK chain.
* - Individual segments are always defined in local coordinates.
* - The segment is assumed to be oriented in the local
* y-direction.
* - seg_start is the start of the segment relative to the end
* of the parent segment.
* - basis is a column major matrix defining the rest position
* of the bone.
* - length is the simply the length of the bone.
* - basis_change is a 3x3 matrix representing the change
* from the rest position of the segment to the solved position.
* In fact it is the transpose of this matrix because blender
* does something weird with quaternion conversion. This is
* strictly an ouput variable for returning the results of an
* an ik solve back to you.
* The local transformation specified as a column major matrix
* of a segment is then defined as.
* translate(seg_start)*basis*transpose(basis_change)*translate(0,length,0)
*/
typedef struct IK_Segment_Extern {
float seg_start[3];
float basis[9];
float length;
float basis_change[9];
} IK_Segment_Extern;
typedef IK_Segment_Extern* IK_Segment_ExternPtr;
/**
* External chain structure.
* This structure is filled when you call IK_LoadChain.
* The first segment in the chain is the root segment.
* The end of the last segment is the end-effector of the chain
* this is the point that tries to move to the goal in the ik
* solver.
* - num_segments is the number of segments in the array pointed
* to by the member segments.
* - chain_dof is the number of degrees of freedom of the chain
* that is the number of independent ways the chain can be changed
* to reach the goal.
* - segments points to an array of IK_Segment_Extern structs
* containing the segments of this chain.
* - intern is pointer used by the module to store information
* about the chain. Please do not touch the member in any way.
*/
typedef struct IK_Chain_Extern {
int num_segments;
int chain_dof;
IK_Segment_ExternPtr segments;
void * intern;
} IK_Chain_Extern;
typedef IK_Chain_Extern* IK_Chain_ExternPtr;
/**
* Create a clean chain structure.
* @return A IK_Chain_Extern structure allocated on the heap.
* Do not attempt to delete or free this memory yourself please
* use the FreeChain(...) function for this.
*/
extern IK_Chain_ExternPtr IK_CreateChain(void);
/**
* Copy segment information into the chain structure.
* @param chain A chain to load the segments into.
* @param segments a ptr to an array of IK_Input_Segment_Extern structures
* @param num_segs the number of segments to load into the chain
* @return 1 if the chain was correctly loaded into the structure.
* @return 0 if an error occured loading the chain. This will normally
* occur when there is not enough memory to allocate internal chain data.
* In this case you should not use the chain structure and should call
* IK_FreeChain to free the memory associated with the chain.
*/
extern int IK_LoadChain(IK_Chain_ExternPtr chain,IK_Segment_ExternPtr segments, int num_segs);
/**
* Compute the solution of an inverse kinematic problem.
* @param chain a ptr to an IK_Segment_Extern loaded with the segments
* to solve for.
* @param goal the goal of the IK problem
* @param tolerance .The distance to the solution within which the chain is deemed
* to be solved.
* @param max_iterations. The maximum number of iterations to use in solving the
* problem.
* @param max_angle_change. The maximum allowed angular change. 0.1 is a good value here.
* @param output. Results of the solution are written to the segments pointed to by output.
* Only the basis and basis_change fields are written. You must make sure that you have
* allocated enough room for the output segments.
* @return 0 if the solved chain did not reach the goal. This occurs when the
* goal was unreachable by the chain end effector.
* @return 1 if the chain reached the goal.
*/
extern int IK_SolveChain(
IK_Chain_ExternPtr chain,
float goal[3],
float tolerance,
int max_iterations,
float max_angle_change,
IK_Segment_ExternPtr output
);
/**
* Free a chain and all it's internal memory.
*/
extern void IK_FreeChain(IK_Chain_ExternPtr);
#ifdef __cplusplus
}
#endif
#endif // NAN_INCLUDED_IK_solver_h
|
