mechanism.c
Go to the documentation of this file.
1 #include "mechanism.h"
2 
3 #include <string.h>
4 
5 
17 {
20  m->nbodies=0;
21  m->allSpheres=TRUE;
22  m->maxCoord=0.0;
24 }
25 
27 {
28  return(VectorSize(&(m->links)));
29 }
30 
32 {
33  return(VectorSize(&(m->joints)));
34 }
35 
37 {
38  return(m->nbodies);
39 }
40 
42 {
43  return(m->allSpheres);
44 }
45 
47 {
48  return(m->maxCoord);
49 }
50 
51 unsigned int GetLinkID(char *name,Tmechanism *m)
52 {
53  unsigned int id,nl;
54  boolean found;
55  Tlink *l;
56 
57  nl=GetMechanismNLinks(m);
58  found=FALSE;
59  id=0;
60  while((!found)&&(id<nl))
61  {
62  l=GetMechanismLink(id,m);
63  if ((l!=NULL)&&(strcmp(name,GetLinkName(l))==0))
64  found=TRUE;
65  else
66  id++;
67  }
68  if (found)
69  return(id);
70  else
71  return(NO_UINT);
72 }
73 
75 {
76  signed int ndof,constraints;
77  unsigned int i,nj;
78 
79  ndof=6*(GetMechanismNLinks(m)-1); /*Ground link is fixed !!*/
80 
81  nj=GetMechanismNJoints(m);
82  constraints=0;
83  for(i=0;i<nj;i++)
84  constraints+=(6-GetJointDOF(GetMechanismJoint(i,m)));
85 
86  return(ndof-constraints);
87 }
88 
89 void GetMechanismDefiningPoint(unsigned int lID,unsigned int bID,unsigned int pID,
90  double *p,Tmechanism *m)
91 {
93 }
94 
95 unsigned int AddLink2Mechanism(Tlink *l,Tmechanism *m)
96 {
97  Tlink *li;
98  unsigned int k;
99 
100  NEW(li,1,Tlink);
101  CopyLink(li,l);
102  k=GetMechanismNLinks(m);
103  SetVectorElement(k,&li,&(m->links));
104 
106  m->nbodies+=LinkNBodies(l);
107  m->allSpheres=((m->allSpheres)&&(IsLinkAllSpheres(l)));
108  m->isTensegrity=((m->isTensegrity)||(GetLinkType(l)==LINK_NoRot)); /* ForceModel ? */
109 
110  return(k);
111 }
112 
114 {
115  Tjoint *ji;
116  unsigned int k;
117 
118  NEW(ji,1,Tjoint);
119  CopyJoint(ji,j);
120  k=GetMechanismNJoints(m);
121  SetVectorElement(k,&ji,&(m->joints));
122 
123  /* Free joints are unbounded: don't take them into account */
124  if (GetJointType(j)!=FREE_JOINT)
126 
127  return(k);
128 }
129 
130 unsigned int AddBody2Mechanism(unsigned int lID,Tpolyhedron *b,Tmechanism *m)
131 {
132  Tlink *lk;
133 
134  lk=GetMechanismLink(lID,m);
135  if (lk==NULL)
136  Error("Unkown link in AddBody2Mechanism");
137 
138 
140  AddBody2Link(b,lk);
141 
143  m->nbodies++;
144  m->allSpheres=((m->allSpheres)&&(IsLinkAllSpheres(lk)));
145 
146  return(m->nbodies);
147 }
148 
149 Tlink *GetMechanismLink(unsigned int i,Tmechanism *m)
150 {
151  Tlink **l;
152 
153  l=(Tlink **)GetVectorElement(i,&(m->links));
154  if (l==NULL)
155  return(NULL);
156  else
157  return(*l);
158 }
159 
160 unsigned int GetMechanismLinkID(char *ln,Tmechanism *m)
161 {
162  unsigned int i,nl;
163  Tlink **l;
164  boolean found;
165 
166  nl=VectorSize(&(m->links));
167  found=FALSE;
168  i=0;
169  while((!found)&&(i<nl))
170  {
171  l=(Tlink **)GetVectorElement(i,&(m->links));
172 
173  if ((l!=NULL)&&(strcmp(ln,GetLinkName(*l))==0))
174  found=TRUE;
175  else
176  i++;
177  }
178 
179  if (found)
180  return(i);
181  else
182  return(NO_UINT);
183 }
184 
186 {
187  Tjoint **j;
188 
189  j=(Tjoint **)GetVectorElement(i,&(m->joints));
190  if (j==NULL)
191  return(NULL);
192  else
193  return(*j);
194 }
195 
197 {
198  unsigned int nj,i;
199  boolean all;
200 
201  nj=GetMechanismNJoints(m);
202  all=TRUE;
203  i=0;
204  while((all)&&(i<nj))
205  {
207  i++;
208  }
209  return(all);
210 }
211 
212 void PlotMechanism(Tplot3d *pt,double axesLength,Tmechanism *m)
213 {
214  unsigned int i;
215  unsigned int n;
216  Tlink *l;
217 
218  n=GetMechanismNLinks(m);
219  if (n>0) Start3dBlock(pt);
220  for(i=0;i<n;i++)
221  {
222  l=GetMechanismLink(i,m);
223  if (l!=NULL)
224  PlotLink(pt,axesLength,l);
225  }
226 
227  if (n>0) Close3dBlock(pt);
228 }
229 
231  double *sol,Tmechanism *m)
232 {
233  unsigned int i;
234  unsigned int n;
235  Tlink *l;
236  Tjoint *j;
237 
238  n=GetMechanismNLinks(m);
239  for(i=0;i<n;i++)
240  {
241  l=GetMechanismLink(i,m);
242  if (l!=NULL)
243  RegenerateLinkSolution(p,cs,sol,IsGroundLink(i),l);
244  }
245 
246  n=GetMechanismNJoints(m);
247  for(i=0;i<n;i++)
248  {
249  j=GetMechanismJoint(i,m);
250  if (j!=NULL)
251  RegenerateJointSolution(p,cs,sol,j);
252  }
253 }
254 
256 {
257  unsigned int i;
258  unsigned int n;
259  Tlink *l;
260  Tjoint *j;
261  unsigned int r;
262 
263  r=(unsigned int)(GetParameter(CT_REPRESENTATION,p));
264 
265  /* for DOF representations -> nothing to regenerate */
266  if (r!=REP_JOINTS)
267  {
268  n=GetMechanismNLinks(m);
269  for(i=0;i<n;i++)
270  {
271  l=GetMechanismLink(i,m);
272  if (l!=NULL)
273  RegenerateLinkBox(p,cs,b,IsGroundLink(i),l);
274  }
275 
276  n=GetMechanismNJoints(m);
277  for(i=0;i<n;i++)
278  {
279  j=GetMechanismJoint(i,m);
280  if (j!=NULL)
281  RegenerateJointBox(p,cs,b,j);
282  }
283  }
284 }
285 
287  double *dof,Tmechanism *m)
288 {
289  Tjoint *j;
290  Tlink *l;
291  unsigned int i,nj,k;
292  unsigned int l1,l2;
293  THTransform t;
294 
295  k=0;
296  if (def!=NULL)
297  {
298  Tlink *l;
299  unsigned int nl;
300 
301  nl=GetMechanismNLinks(m);
302  for(i=0;i<nl;i++)
303  {
304  l=GetMechanismLink(i,m);
305  if ((l!=NULL)&&(NumLinkDOF(l)>0))
306  {
307  GenerateDOFFromLinkConf(&(def[i]),&(dof[k]),l);
308  k+=NumLinkDOF(l);
309  }
310  }
311  }
312 
313  nj=GetMechanismNJoints(m);
314  for(i=0;i<nj;i++)
315  {
316  j=GetMechanismJoint(i,m);
317  if (j!=NULL)
318  {
319  l1=JointFromID(j);
320  l2=JointToID(j);
321  l=JointFrom(j);
322  /* If necessary traverse the previous deformation link
323  (remove the deformation dof from the transforms to use
324  to get the DOF) */
325  if (IsVariableLengthLink(l))
326  {
327  GetLinkTransformFromConf(&(def[l1]),&t,l);
328  HTransformProduct(&(tl[l1]),&t,&t);
329  GetJointDOFValues(p,&t,&(tl[l2]),&(dof[k]),j);
330  HTransformDelete(&t);
331  }
332  else
333  GetJointDOFValues(p,&(tl[l1]),&(tl[l2]),&(dof[k]),j);
334  k+=GetJointDOF(j);
335  }
336  }
337 }
338 
340 {
341  unsigned int i,n;
342  Tlink *l;
343 
344  n=GetMechanismNLinks(m);
345  for(i=0;i<n;i++)
346  {
347  l=GetMechanismLink(i,m);
348  if (l!=NULL)
349  LinkPrintAtoms(f,&(tl[i]),l);
350  }
351  fprintf(f,"\n");
352 }
353 
355 {
356  unsigned int i,n,nr,na;
357  Tlink *l;
358 
359  n=GetMechanismNLinks(m);
360 
361  /* number of rigid = number of links with balls */
362  nr=0;
363  for(i=0;i<n;i++)
364  {
365  l=GetMechanismLink(i,m);
366  if (l!=NULL)
367  {
368  if (LinkNAtoms(l)>0)
369  nr++;
370  }
371  }
372  fprintf(f,"%u\n",nr);
373 
374  /* now store */
375  for(i=0;i<n;i++)
376  {
377  l=GetMechanismLink(i,m);
378  if (l!=NULL)
379  {
380  na=LinkNAtoms(l);
381  if (na>0)
382  {
383  fprintf(f,"%u %u\n",na,IsGroundLink(i));
384  LinkStoreAtoms(f,&(tl[i]),l);
385  }
386  }
387  }
388  fprintf(f,"\n");
389 }
390 
392  THTransform *tl,TLinkConf *def,
393  Tmechanism *m)
394 {
395  unsigned int i;
396  unsigned int n;
397  Tlink *l;
398 
399  n=GetMechanismNLinks(m);
400  if (n>0) Start3dBlock(pt);
401  for(i=1;i<n;i++) /*Ground link (ID==0) does not move*/
402  {
403  l=GetMechanismLink(i,m);
404  if (l!=NULL)
405  MoveLinkFromTransform(pt,&(tl[i]),&(def[i]),l);
406  }
407 
408  if (n>0) Close3dBlock(pt);
409 }
410 
411 void PrintMechanism(FILE *f,char *path,char *prefix,Tmechanism *m)
412 {
413  unsigned int i,n;
414  Tlink *l;
415  Tjoint *j;
416 
417  if (m->isTensegrity)
418  Error("Tensegrity mechanisms can not be printed (not implemented yet)");
419 
420  n=GetMechanismNLinks(m);
421  if (n>0)
422  fprintf(f,"[LINKS]\n\n");
423  for(i=0;i<n;i++)
424  {
425  l=GetMechanismLink(i,m);
426  if (l!=NULL)
427  PrintLink(f,path,prefix,l);
428  }
429 
430  n=GetMechanismNJoints(m);
431  if (n>0)
432  fprintf(f,"[JOINTS]\n\n");
433  i=0;
434  while (i<n)
435  {
436  j=GetMechanismJoint(i,m);
437  if (j!=NULL)
438  {
439  unsigned int t;
440  Tpolyhedron *b;
441 
442  t=GetJointType(j);
443  switch(t)
444  {
445  case REV_LOW_JOINT:
446  case REV_UP_JOINT:
447  Error("Tensegrity mechanisms can not be printed (not implemented yet)");
448  break;
449  case SPH_SPH_LOW_JOINT:
450  {
451  Tjoint *j2;
452  Tlink *l1,*l2,*l3;
453  unsigned int bs;
454  Tcolor c;
455  Tinterval *l;
456  double *p1,*p2;
457  boolean prs;
458 
459  j2=GetMechanismJoint(i+1,m);
460 
461  l1=JointFrom(j);
462  l2=JointTo(j);
463  l3=JointTo(j2);
464 
465  /* fixed of prismatic leg */
466  if (GetLinkType(l2)!=LINK_AxisX)
467  Error("Inconsistent composite joint");
468 
469  NEW(p1,3,double);
470  NEW(p2,3,double);
471 
472  l=GetLinkLength(l2);
473 
474  prs=(IntervalSize(l)>ZERO);
475  b=GetLinkBody(1,l2); /* The cylinder (skip sphere) */
476  GetPolyhedronColor(&c,b);
477  bs=GetPolyhedronStatus(b);
478  GetJointPoint(0,0,p1,j);
479  GetJointPoint(1,0,p2,j2);
480 
481  if (prs)
482  fprintf(f," sph_prs_sph %s :",GetLinkName(l2));
483  else
484  fprintf(f," sph_sph %s :",GetLinkName(l2));
485  fprintf(f," %s (%.16f,%.16f,%.16f)",GetLinkName(l1),p1[0],p1[1],p1[2]);
486  fprintf(f," %s (%.16f,%.16f,%.16f)",GetLinkName(l3),p2[0],p2[1],p2[2]);
487  if (prs)
488  { fprintf(f," length ");PrintInterval(f,l); }
489  else
490  fprintf(f," length %.16f",IntervalCenter(l));
491  fprintf(f," radius %.16f ",GetPolyhedronRadius(b));
492  fprintf(f," color (");PrintColor(f,&c);
493  if (bs!=NORMAL_SHAPE)
494  fprintf(f,") %s\n",(bs==HIDDEN_SHAPE?"hidden":"decoration"));
495  else
496  fprintf(f,")\n");
497 
498  DeleteColor(&c);
499  free(p2);
500  free(p1);
501 
502  i+=2; /* skip the sph_sph_upper joint */
503  }
504  break;
505  default:
506  PrintJoint(f,j);
507  i++;
508  }
509  }
510  }
511 }
512 
514 {
515 
516  unsigned int i;
517  unsigned int n;
518  Tlink *l;
519  Tjoint *j;
520 
521  n=GetMechanismNLinks(m);
522  for(i=0;i<n;i++)
523  {
524  l=GetMechanismLink(i,m);
525  if (l!=NULL)
526  {
527  DeleteLink(l);
528  free(l);
529  }
530  }
531 
532  n=GetMechanismNJoints(m);
533  for(i=0;i<n;i++)
534  {
535  j=GetMechanismJoint(i,m);
536  if (j!=NULL)
537  {
538  DeleteJoint(j);
539  free(j);
540  }
541  }
542 
543  DeleteVector(&(m->links));
544  DeleteVector(&(m->joints));
545 }
void RegenerateJointSolution(Tparameters *p, TCuikSystem *cs, double *sol, Tjoint *j)
Computes the values for the dummy variables used in the joint equations.
Definition: joint.c:2291
double GetPolyhedronRadius(Tpolyhedron *p)
Returns the radius used in the definition of the object.
Definition: polyhedron.c:1440
void DeleteVector(void *vector)
Destructor.
Definition: vector.c:389
void GetJointPoint(unsigned int link, unsigned int point, double *p, Tjoint *j)
Gets one of the points defining the rotation/sliding axis for the joint.
Definition: joint.c:1102
#define REP_JOINTS
One of the possible values of the REPRESENTATION parameter.
Definition: parameters.h:60
void PlotMechanism(Tplot3d *pt, double axesLength, Tmechanism *m)
Adds a mechanism to a 3d scene.
Definition: mechanism.c:212
void PrintColor(FILE *f, Tcolor *c)
Prints the color.
Definition: color.c:138
unsigned int VectorSize(Tvector *vector)
Gets the number of elements in a vector.
Definition: vector.c:173
double GetJointMaxCoordinate(Tjoint *j)
Gets the maximum coordinate.
Definition: joint.c:936
#define FALSE
FALSE.
Definition: boolean.h:30
void GetJointDOFValues(Tparameters *p, THTransform *t1, THTransform *t2, double *dof, Tjoint *j)
Recovers the joint DOFs from the absolute poses of the links.
Definition: joint.c:2638
unsigned int GetLinkID(char *name, Tmechanism *m)
Gets the identifier of a link given its name.
Definition: mechanism.c:51
#define INIT_NUM_LINKS
Initial room for links in a mechanism.
Definition: mechanism.h:28
Relation between two links.
Definition: joint.h:168
#define NEW(_var, _n, _type)
Allocates memory space.
Definition: defines.h:385
unsigned int GetJointDOF(Tjoint *j)
Computes the degrees of freedom allowed by a given joint.
Definition: joint.c:1293
void * GetVectorElement(unsigned int i, Tvector *vector)
Returns a pointer to a vector element.
Definition: vector.c:270
A homgeneous transform in R^3.
double GetMechanismMaxCoordinate(Tmechanism *m)
Returns the sum of the maximum coordinate value for all the links and joints in the mechanism...
Definition: mechanism.c:46
Tlink * JointFrom(Tjoint *j)
Gets a pointer to the first link involved in the joint.
Definition: joint.c:951
boolean IsMechanismAllSpheres(Tmechanism *m)
TRUE if the mechanism is composed by spheres only.
Definition: mechanism.c:41
double maxCoord
Definition: mechanism.h:58
#define NORMAL_SHAPE
One of the possible type of shapes.
Definition: polyhedron.h:28
#define FREE_JOINT
One of the possible type of joints.
Definition: joint.h:40
#define REV_LOW_JOINT
One of the possible type of joints.
Definition: joint.h:101
#define TRUE
TRUE.
Definition: boolean.h:21
void Close3dBlock(Tplot3d *p)
Ends a block of commands.
Definition: plot3d.c:146
void Error(const char *s)
General error function.
Definition: error.c:80
A color.
Definition: color.h:86
Tvector joints
Definition: mechanism.h:52
A mechanism description.
Definition: mechanism.h:51
boolean AllRevolute(Tmechanism *m)
TRUE if all joints are revolute joints.
Definition: mechanism.c:196
CBLAS_INLINE void HTransformProduct(THTransform *t1, THTransform *t2, THTransform *t3)
Product of two homogeneous transforms.
Definition: htransform.c:410
#define ZERO
Floating point operations giving a value below this constant (in absolute value) are considered 0...
Definition: defines.h:37
void GetMechanismDOFsFromTransforms(Tparameters *p, THTransform *tl, TLinkConf *def, double *dof, Tmechanism *m)
Extract the joint DOF values form the poses of all links.
Definition: mechanism.c:286
void InitMechanism(Tmechanism *m)
Constructor.
Definition: mechanism.c:16
unsigned int nbodies
Definition: mechanism.h:56
void CopyVoidPtr(void *a, void *b)
Copy constructor for void pointers.
Definition: vector.c:87
unsigned int AddJoint2Mechanism(Tjoint *j, Tmechanism *m)
Adds a joint to a mechanism.
Definition: mechanism.c:113
A polyhedron.
Definition: polyhedron.h:134
Tjoint * GetMechanismJoint(unsigned int i, Tmechanism *m)
Gets a joint given its identifier.
Definition: mechanism.c:185
Tlink * JointTo(Tjoint *j)
Gets a pointer to the second link involved in the joint.
Definition: joint.c:961
unsigned int GetMechanismNBodies(Tmechanism *m)
Gets the number of convex sub-parts (or bodies) of a mechanism.
Definition: mechanism.c:36
A 3D plot.
Definition: plot3d.h:54
#define INIT_NUM_JOINTS
Initial room for joints in a mechanism.
Definition: mechanism.h:36
unsigned int GetMechanismNLinks(Tmechanism *m)
Gets the number of links of a mechanism.
Definition: mechanism.c:26
void GetMechanismDefiningPoint(unsigned int lID, unsigned int bID, unsigned int pID, double *p, Tmechanism *m)
Gets a point from the mechanism.
Definition: mechanism.c:89
unsigned int GetMechanismNJoints(Tmechanism *m)
Gets the number of joints of a mechanism.
Definition: mechanism.c:31
void DeleteMechanism(Tmechanism *m)
Destructor.
Definition: mechanism.c:513
boolean isTensegrity
Definition: mechanism.h:60
void InitVector(unsigned int ele_size, void(*Copy)(void *, void *), void(*Delete)(void *), unsigned int max_ele, Tvector *vector)
Constructor.
Definition: vector.c:100
void SetVectorElement(unsigned int i, void *e, Tvector *vector)
Adds an element to the vector in a given position.
Definition: vector.c:238
Definition of the Tmechanism type and the associated functions.
unsigned int GetJointType(Tjoint *j)
Gets the joint type.
Definition: joint.c:931
A table of parameters.
unsigned int AddLink2Mechanism(Tlink *l, Tmechanism *m)
Adds a link to a mechanism.
Definition: mechanism.c:95
void GetPolyhedronColor(Tcolor *c, Tpolyhedron *p)
Gets the color of a polyhedron.
Definition: polyhedron.c:1373
void PrintMechanism(FILE *f, char *path, char *prefix, Tmechanism *m)
Stores the mechanisms information into a file.
Definition: mechanism.c:411
#define CT_REPRESENTATION
Representation.
Definition: parameters.h:215
#define REV_JOINT
One of the possible type of joints.
Definition: joint.h:59
A box.
Definition: box.h:83
unsigned int GetPolyhedronStatus(Tpolyhedron *p)
Gets the status of a polyhedron (NORMAL, HIDDEN, DECOR).
Definition: polyhedron.c:1378
void PrintJoint(FILE *f, Tjoint *j)
Stores the joint information into a file.
Definition: joint.c:3054
Tlink * GetMechanismLink(unsigned int i, Tmechanism *m)
Gets a link given its identifier.
Definition: mechanism.c:149
A cuiksystem, i.e., a set of variables and equations defining a position analysis problem...
Definition: cuiksystem.h:181
void PrintInterval(FILE *f, Tinterval *i)
Prints an interval.
Definition: interval.c:1006
void MoveMechanismFromTransforms(Tparameters *pr, Tplot3d *pt, THTransform *tl, TLinkConf *def, Tmechanism *m)
Displaces a mechanism in a 3d scene.
Definition: mechanism.c:391
#define NO_UINT
Used to denote an identifier that has not been initialized.
Definition: defines.h:435
unsigned int JointFromID(Tjoint *j)
Gets the identifier of the first link involved in the joint.
Definition: joint.c:946
double IntervalCenter(Tinterval *i)
Gets the interval center.
Definition: interval.c:129
unsigned int AddBody2Mechanism(unsigned int lID, Tpolyhedron *b, Tmechanism *m)
Adds a convex sub-part to a mechanism.
Definition: mechanism.c:130
#define REV_UP_JOINT
One of the possible type of joints.
Definition: joint.h:109
void RegenerateMechanismBox(Tparameters *p, TCuikSystem *cs, Tbox *b, Tmechanism *m)
Computes the values for the non-system variables.
Definition: mechanism.c:255
Tvector links
Definition: mechanism.h:53
void DeleteVoidPtr(void *a)
Destructor for void pointers.
Definition: vector.c:92
void HTransformDelete(THTransform *t)
Destructor.
Definition: htransform.c:887
void GetPolyhedronDefiningPoint(unsigned int i, double *point, Tpolyhedron *p)
Gets a point defining a a object.
Definition: polyhedron.c:1398
unsigned int GetMechanismLinkID(char *ln, Tmechanism *m)
Gets a link identifier given its name.
Definition: mechanism.c:160
double GetParameter(unsigned int n, Tparameters *p)
Gets the value for a particular parameter.
Definition: parameters.c:93
#define SPH_SPH_LOW_JOINT
One of the possible type of joints.
Definition: joint.h:84
void DeleteColor(Tcolor *c)
Destructor.
Definition: color.c:143
signed int GetMechanismMobility(Tmechanism *m)
Computes the mobility of a given mechanism.
Definition: mechanism.c:74
boolean allSpheres
Definition: mechanism.h:57
Defines a interval.
Definition: interval.h:33
void MechanismPrintAtoms(FILE *f, THTransform *tl, Tmechanism *m)
Prints the center of the atoms in a mechanism.
Definition: mechanism.c:339
void MechanismStoreRigidAtoms(FILE *f, THTransform *tl, Tmechanism *m)
Auxiliary function for WorldStoreRigidGroups.
Definition: mechanism.c:354
double IntervalSize(Tinterval *i)
Gets the uppser limit.
Definition: interval.c:96
void DeleteJoint(Tjoint *j)
Destructor.
Definition: joint.c:3190
void CopyJoint(Tjoint *j_dst, Tjoint *j_src)
Copy constructor.
Definition: joint.c:879
void Start3dBlock(Tplot3d *p)
Starts a block of commands.
Definition: plot3d.c:141
unsigned int JointToID(Tjoint *j)
Gets the identifier of the second link involved in the joint.
Definition: joint.c:956
Link configuration.
Definition: link.h:276
void RegenerateMechanismSolution(Tparameters *p, TCuikSystem *cs, double *sol, Tmechanism *m)
Computes the values for the non-system variables used to represent the rotation matrices for all link...
Definition: mechanism.c:230
#define HIDDEN_SHAPE
One of the possible type of shapes.
Definition: polyhedron.h:37
void RegenerateJointBox(Tparameters *p, TCuikSystem *cs, Tbox *b, Tjoint *j)
Computes the values for the dummy variables used in the joint equations.
Definition: joint.c:2327