shtransform.c
Go to the documentation of this file.
1 #include "shtransform.h"
2 
3 #include <math.h>
4 
24 
26 {
27  unsigned int i,j;
28 
29  NEW((*t),(DIM_SP+1),Tequation**);
30  for(i=0;i<(DIM_SP+1);i++)
31  {
32  NEW((*t)[i],(DIM_SP+1),Tequation*);
33  for(j=0;j<(DIM_SP+1);j++)
34  {
35  NEW((*t)[i][j],1,Tequation);
36  InitEquation((*t)[i][j]);
37  SetEquationCmp(EQU,(*t)[i][j]);
38  SetEquationType(SYSTEM_EQ,(*t)[i][j]);
39  }
40  }
41 }
42 
44 {
45  unsigned int i;
46 
47  SHTransformInit(t);
48 
49  for(i=0;i<=AXIS_H;i++)
50  SetEquationValue(-1.0,(*t)[i][i]);
51 }
52 
54  TEqVector *d,TSHTransform *t)
55 {
56  unsigned int i,j;
57  TEqVector z;
58 
59  NEW((*t),(DIM_SP+1),Tequation**);
60  for(i=0;i<(DIM_SP+1);i++)
61  {
62  NEW((*t)[i],(DIM_SP+1),Tequation*);
63  for(j=0;j<(DIM_SP+1);j++)
64  {
65  NEW((*t)[i][j],1,Tequation);
66  /* Only initialize the last row (the rest will be
67  directly set) */
68  if (i==DIM_SP)
69  InitEquation((*t)[i][j]);
70  }
71  }
72 
73  SetEquationValue(-1.0,(*t)[AXIS_H][AXIS_H]);
74 
75  for(i=0;i<DIM_SP;i++)
76  CopyEquation((*t)[i][AXIS_X],GetEqVectorElement(i,x));
77 
78  for(i=0;i<DIM_SP;i++)
79  CopyEquation((*t)[i][AXIS_Y],GetEqVectorElement(i,y));
80 
81  CrossProductEqVectors(x,y,&z);
82  for(i=0;i<DIM_SP;i++)
83  CopyEquation((*t)[i][AXIS_Z],GetEqVectorElement(i,&z));
84  DeleteEqVector(&z);
85 
86  for(i=0;i<DIM_SP;i++)
87  CopyEquation((*t)[i][AXIS_H],GetEqVectorElement(i,d));
88 }
89 
91 {
92 
93  unsigned int i,j;
94 
95  NEW((*t_dst),(DIM_SP+1),Tequation**);
96  for(i=0;i<(DIM_SP+1);i++)
97  {
98  NEW((*t_dst)[i],(DIM_SP+1),Tequation*);
99  for(j=0;j<(DIM_SP+1);j++)
100  {
101  NEW((*t_dst)[i][j],1,Tequation);
102  CopyEquation((*t_dst)[i][j],(*t_org)[i][j]);
103  }
104  }
105 }
106 
107 void SHTransformTx(double tx,TSHTransform *t)
108 {
110  SetEquationValue(-tx,(*t)[AXIS_X][AXIS_H]);
111 }
112 
113 void SHTransformVarTx(unsigned int x,TSHTransform *t)
114 {
115  Tmonomial f;
116 
118 
119  InitMonomial(&f);
120  AddVariable2Monomial(NFUN,x,1,&f);
121  AddMonomial(&f,(*t)[AXIS_X][AXIS_H]);
122  DeleteMonomial(&f);
123 }
124 
125 void SHTransformTy(double ty,TSHTransform *t)
126 {
128  SetEquationValue(-ty,(*t)[AXIS_Y][AXIS_H]);
129 }
130 
131 void SHTransformVarTy(unsigned int y,TSHTransform *t)
132 {
133  Tmonomial f;
134 
136 
137  InitMonomial(&f);
138  AddVariable2Monomial(NFUN,y,1,&f);
139  AddMonomial(&f,(*t)[AXIS_Y][AXIS_H]);
140  DeleteMonomial(&f);
141 }
142 
143 void SHTransformTz(double tz,TSHTransform *t)
144 {
146  SetEquationValue(-tz,(*t)[AXIS_Z][AXIS_H]);
147 }
148 
149 void SHTransformVarTz(unsigned int z,TSHTransform *t)
150 {
151  Tmonomial f;
152 
154 
155  InitMonomial(&f);
156  AddVariable2Monomial(NFUN,z,1,&f);
157  AddMonomial(&f,(*t)[AXIS_Z][AXIS_H]);
158  DeleteMonomial(&f);
159 }
160 
161 void SHTransformTxyz(double tx,double ty,double tz,TSHTransform *t)
162 {
164  SetEquationValue(-tx,(*t)[AXIS_X][AXIS_H]);
165  SetEquationValue(-ty,(*t)[AXIS_Y][AXIS_H]);
166  SetEquationValue(-tz,(*t)[AXIS_Z][AXIS_H]);
167 }
168 
169 void SHTransformVarTxyz(unsigned int x,unsigned int y,unsigned int z,TSHTransform *t)
170 {
171  Tmonomial f;
172 
174 
175  InitMonomial(&f);
176 
177  AddVariable2Monomial(NFUN,x,1,&f);
178  AddMonomial(&f,(*t)[AXIS_X][AXIS_H]);
179  ResetMonomial(&f);
180 
181  AddVariable2Monomial(NFUN,y,1,&f);
182  AddMonomial(&f,(*t)[AXIS_Y][AXIS_H]);
183  ResetMonomial(&f);
184 
185  AddVariable2Monomial(NFUN,z,1,&f);
186  AddMonomial(&f,(*t)[AXIS_Z][AXIS_H]);
187  DeleteMonomial(&f);
188 }
189 
190 
191 void SHTransformVarDisplacementAlongVector(double *v,unsigned int vID,TSHTransform *t)
192 {
193  Tmonomial f;
194 
196 
197  InitMonomial(&f);
198 
199  AddVariable2Monomial(NFUN,vID,1,&f);
200  AddCt2Monomial(v[0],&f);
201  AddMonomial(&f,(*t)[AXIS_X][AXIS_H]);
202  ResetMonomial(&f);
203 
204  AddVariable2Monomial(NFUN,vID,1,&f);
205  AddCt2Monomial(v[1],&f);
206  AddMonomial(&f,(*t)[AXIS_Y][AXIS_H]);
207  ResetMonomial(&f);
208 
209  AddVariable2Monomial(NFUN,vID,1,&f);
210  AddCt2Monomial(v[2],&f);
211  AddMonomial(&f,(*t)[AXIS_Z][AXIS_H]);
212  DeleteMonomial(&f);
213 }
214 
215 void SHTransformRx(double rx,TSHTransform *t)
216 {
217  double s,c;
218 
219  s=sin(rx);
220  c=cos(rx);
221 
223 
224  SetEquationValue(-c,(*t)[AXIS_Y][AXIS_Y]);
225  SetEquationValue(-c,(*t)[AXIS_Z][AXIS_Z]);
226 
227  SetEquationValue(-s,(*t)[AXIS_Z][AXIS_Y]);
228  SetEquationValue( s,(*t)[AXIS_Y][AXIS_Z]);
229 }
230 
231 void SHTransformVarRx(unsigned int x,TSHTransform *t)
232 {
233  Tmonomial s,c;
234 
235  InitMonomial(&s);
236  InitMonomial(&c);
237  AddVariable2Monomial(SINV,x,1,&s);
238  AddVariable2Monomial(COSV,x,1,&c);
239 
240  SHTransformInit(t);
241 
242  AddMonomial(&c,(*t)[AXIS_Y][AXIS_Y]);
243  AddMonomial(&c,(*t)[AXIS_Z][AXIS_Z]);
244 
245  AddMonomial(&s,(*t)[AXIS_Z][AXIS_Y]);
246  AddCt2Monomial(-1.0,&s);
247  AddMonomial(&s,(*t)[AXIS_Y][AXIS_Z]);
248 
249  SetEquationValue(-1.0,(*t)[AXIS_X][AXIS_X]);
250  SetEquationValue(-1.0,(*t)[AXIS_H][AXIS_H]);
251 
252  DeleteMonomial(&s);
253  DeleteMonomial(&c);
254 }
255 
256 void SHTransformRy(double ry,TSHTransform *t)
257 {
258  double s,c;
259 
260  s=sin(ry);
261  c=cos(ry);
262 
264 
265  SetEquationValue(-c,(*t)[AXIS_X][AXIS_X]);
266  SetEquationValue(-c,(*t)[AXIS_Z][AXIS_Z]);
267 
268  SetEquationValue(-s,(*t)[AXIS_X][AXIS_Z]);
269  SetEquationValue( s,(*t)[AXIS_Z][AXIS_X]);
270 }
271 
272 void SHTransformVarRy(unsigned int y,TSHTransform *t)
273 {
274  Tmonomial s,c;
275 
276  InitMonomial(&s);
277  InitMonomial(&c);
278  AddVariable2Monomial(SINV,y,1,&s);
279  AddVariable2Monomial(COSV,y,1,&c);
280 
281  SHTransformInit(t);
282 
283  AddMonomial(&c,(*t)[AXIS_X][AXIS_X]);
284  AddMonomial(&c,(*t)[AXIS_Z][AXIS_Z]);
285 
286  AddMonomial(&s,(*t)[AXIS_X][AXIS_Z]);
287  AddCt2Monomial(-1.0,&s);
288  AddMonomial(&s,(*t)[AXIS_Z][AXIS_X]);
289 
290  SetEquationValue(-1.0,(*t)[AXIS_Y][AXIS_Y]);
291  SetEquationValue(-1.0,(*t)[AXIS_H][AXIS_H]);
292 
293  DeleteMonomial(&s);
294  DeleteMonomial(&c);
295 }
296 
297 void SHTransformRz(double rz,TSHTransform *t)
298 {
299  double s,c;
300 
301  s=sin(rz);
302  c=cos(rz);
303 
305 
306  SetEquationValue(-c,(*t)[AXIS_X][AXIS_X]);
307  SetEquationValue(-c,(*t)[AXIS_Y][AXIS_Y]);
308 
309  SetEquationValue(-s,(*t)[AXIS_Y][AXIS_X]);
310  SetEquationValue( s,(*t)[AXIS_X][AXIS_Y]);
311 }
312 
313 void SHTransformVarRz(unsigned int z,TSHTransform *t)
314 {
315  Tmonomial s,c;
316 
317  InitMonomial(&s);
318  InitMonomial(&c);
319  AddVariable2Monomial(SINV,z,1,&s);
320  AddVariable2Monomial(COSV,z,1,&c);
321 
322  SHTransformInit(t);
323 
324  AddMonomial(&c,(*t)[AXIS_X][AXIS_X]);
325  AddMonomial(&c,(*t)[AXIS_Y][AXIS_Y]);
326 
327  AddMonomial(&s,(*t)[AXIS_Y][AXIS_X]);
328  AddCt2Monomial(-1.0,&s);
329  AddMonomial(&s,(*t)[AXIS_X][AXIS_Y]);
330 
331  SetEquationValue(-1.0,(*t)[AXIS_Z][AXIS_Z]);
332  SetEquationValue(-1.0,(*t)[AXIS_H][AXIS_H]);
333 
334  DeleteMonomial(&s);
335  DeleteMonomial(&c);
336 }
337 
338 void SHTransformCreate(unsigned int dof_r3,double v,TSHTransform *t)
339 {
340  switch (dof_r3)
341  {
342  case TX:
343  SHTransformTx(v,t);
344  break;
345  case TY:
346  SHTransformTy(v,t);
347  break;
348  case TZ:
349  SHTransformTz(v,t);
350  break;
351  case RX:
352  SHTransformRx(v,t);
353  break;
354  case RY:
355  SHTransformRy(v,t);
356  break;
357  case RZ:
358  SHTransformRz(v,t);
359  break;
360  }
361 }
362 
363 void SHTransformVarCreate(unsigned int dof_r3,unsigned int v,TSHTransform *t)
364 {
365  switch (dof_r3)
366  {
367  case TX:
368  SHTransformVarTx(v,t);
369  break;
370  case TY:
371  SHTransformVarTy(v,t);
372  break;
373  case TZ:
374  SHTransformVarTz(v,t);
375  break;
376  case RX:
377  SHTransformVarRx(v,t);
378  break;
379  case RY:
380  SHTransformVarRy(v,t);
381  break;
382  case RZ:
383  SHTransformVarRz(v,t);
384  break;
385  }
386 }
387 
388 Tequation *SHTransformGetElement(unsigned int i,unsigned int j,TSHTransform *t)
389 {
390  /* We do not return the elements in the last row (they are always constant) */
391  if ((i<AXIS_H)&&(j<=AXIS_H))
392  return((*t)[i][j]);
393  else
394  Error("Element out of range in SHTransformGetElement");
395  return(NULL);
396 }
397 
399 {
400  TSHTransform t4;
401  unsigned int i,j,k;
402  Tequation eq;
403 
404  SHTransformInit(&t4);
405  for(i=0;i<(DIM_SP+1);i++)
406  {
407  for(j=0;j<(DIM_SP+1);j++)
408  {
409  for(k=0;k<(DIM_SP+1);k++)
410  {
411  ProductEquations((*t1)[i][k],(*t2)[k][j],&eq);
412  AccumulateEquations(&eq,1.0,t4[i][j]);
413  DeleteEquation(&eq);
414  }
415  }
416  }
417 
418  if ((t3==t1)||(t3==t2))
419  SHTransformDelete(t3);
420  SHTransformCopy(t3,&t4);
421  SHTransformDelete(&t4);
422 }
423 
425 {
426  TSHTransform t4;
427  unsigned int i,j,k;
428  double ct;
429 
430  SHTransformInit(&t4);
431  for(i=0;i<(DIM_SP+1);i++)
432  {
433  for(j=0;j<(DIM_SP+1);j++)
434  {
435  for(k=0;k<(DIM_SP+1);k++)
436  {
437  ct=HTransformGetElement(i,k,t1);
438  AccumulateEquations((*t2)[k][j],ct,t4[i][j]);
439  }
440  }
441  }
442  if (t3==t2)
443  SHTransformDelete(t3);
444  SHTransformCopy(t3,&t4);
445  SHTransformDelete(&t4);
446 }
447 
449 {
450  TSHTransform t4;
451  unsigned int i,j,k;
452  double ct;
453 
454  SHTransformInit(&t4);
455  for(i=0;i<(DIM_SP+1);i++)
456  {
457  for(j=0;j<(DIM_SP+1);j++)
458  {
459  for(k=0;k<(DIM_SP+1);k++)
460  {
461  ct=HTransformGetElement(k,j,t2);
462  AccumulateEquations((*t1)[i][k],ct,t4[i][j]);
463  }
464  }
465  }
466  if (t3==t1)
467  SHTransformDelete(t3);
468  SHTransformCopy(t3,&t4);
469  SHTransformDelete(&t4);
470 }
471 
473 {
474  TSHTransform t4;
475  unsigned int i,j;
476 
477  SHTransformInit(&t4);
478  for(i=0;i<(DIM_SP+1);i++)
479  {
480  for(j=0;j<(DIM_SP+1);j++)
481  {
482  AccumulateEquations((*t1)[i][j],1.0,t4[i][j]);
483  AccumulateEquations((*t2)[i][j],1.0,t4[i][j]);
484  }
485  }
486  if ((t3==t1)||(t3==t2))
487  SHTransformDelete(t3);
488  SHTransformCopy(t3,&t4);
489  SHTransformDelete(&t4);
490 }
491 
493 {
494  unsigned int i,j;
495  TSHTransform tt,tr;
496 
497  SHTransformIdentity(&tt);
498  for(i=0;i<DIM_SP;i++)
499  AccumulateEquations((*t)[i][AXIS_H],-1.0,tt[i][AXIS_H]);
500 
501  SHTransformInit(&tr);
502  for(i=0;i<DIM_SP;i++)
503  {
504  for(j=0;j<DIM_SP;j++)
505  {
506  DeleteEquation(tr[i][j]);
507  CopyEquation(tr[i][j],(*t)[j][i]);
508  }
509  }
510  SetEquationValue(1.0,tr[AXIS_H][AXIS_H]);
511 
512  if (t==ti)
513  SHTransformDelete(ti);
514 
515  SHTransformProduct(&tr,&tt,ti);
516 
517  SHTransformDelete(&tr);
518  SHTransformDelete(&tt);
519 }
520 
522 {
523  TSHTransform ta;
524  unsigned int i,j;
525 
526  NEW(ta,(DIM_SP+1),Tequation**);
527  for(i=0;i<(DIM_SP+1);i++)
528  {
529  NEW(ta[i],(DIM_SP+1),Tequation*);
530  for(j=0;j<(DIM_SP+1);j++)
531  {
532  NEW(ta[i][j],1,Tequation);
533  CopyEquation(ta[i][j],(*t)[j][i]);
534  }
535  }
536 
537  if (tt==t)
538  SHTransformDelete(tt);
539  SHTransformCopy(tt,&ta);
540  SHTransformDelete(&ta);
541 }
542 
543 void SHTransformApply(double *p_in,Tequation *p_out,TSHTransform *t)
544 {
545  unsigned int i,j;
546 
547  for(i=0;i<DIM_SP;i++)
548  {
549  CopyEquation(&(p_out[i]),(*t)[i][AXIS_H]); /*The homogeneous term*/
550 
551  for(j=0;j<DIM_SP;j++)
552  AccumulateEquations((*t)[i][j],p_in[j],&(p_out[i]));
553  }
554 }
555 
556 void SHTransformApplyRot(double *p_in,Tequation *p_out,TSHTransform *t)
557 {
558  unsigned int i,j;
559 
560  for(i=0;i<DIM_SP;i++)
561  {
562  InitEquation(&(p_out[i])); /* Do not use homogeneous term */
563 
564  for(j=0;j<DIM_SP;j++)
565  AccumulateEquations((*t)[i][j],p_in[j],&(p_out[i]));
566  }
567 }
568 
569 void SHTransformEvaluate(double *varValues,THTransform *tc,TSHTransform *t)
570 {
571  unsigned int i,j;
572  double ct;
573 
574  HTransformIdentity(tc); /* Just initialize */
575  for(i=0;i<DIM_SP;i++)
576  {
577  for(j=0;j<(DIM_SP+1);j++)
578  {
579  ct=EvaluateWholeEquation(varValues,(*t)[i][j]);
580  HTransformSetElement(i,j,ct,tc);
581  }
582  }
583 }
584 
585 
586 void SHTransformPrint(FILE *f,char **varNames,TSHTransform *t)
587 {
588  unsigned int i,j;
589 
590  for(i=0;i<DIM_SP;i++)
591  {
592  for(j=0;j<(DIM_SP+1);j++)
593  {
594  fprintf(f," ST[%u,%u]=",i,j);
595  PrintMonomials(f,varNames,(*t)[i][j]);
596  }
597  }
598 }
599 
601 {
602  unsigned int i,j;
603 
604  for(i=0;i<(DIM_SP+1);i++)
605  {
606  for(j=0;j<(DIM_SP+1);j++)
607  {
608  DeleteEquation((*t)[i][j]);
609  free((*t)[i][j]);
610  }
611  free((*t)[i]);
612  }
613  free(*t);
614 }
#define AXIS_X
One of the dimension of R^3.
Definition: htransform.h:83
double EvaluateWholeEquation(double *varValues, Tequation *eq)
Evaluates an equation in a given point.
Definition: equation.c:1726
#define SYSTEM_EQ
One of the possible type of equations.
Definition: equation.h:146
void SHTransformCreate(unsigned int dof_r3, double v, TSHTransform *t)
Constructor.
Definition: shtransform.c:338
void SetEquationType(unsigned int type, Tequation *eq)
Changes the type of the equation (SYSTEM_EQ, CARTESIAN_EQ, DUMMY_EQ, DERIVED_EQ). ...
Definition: equation.c:1076
#define NEW(_var, _n, _type)
Allocates memory space.
Definition: defines.h:385
void DeleteEquation(Tequation *eq)
Destructor.
Definition: equation.c:1859
void SHTransformVarCreate(unsigned int dof_r3, unsigned int v, TSHTransform *t)
Constructor.
Definition: shtransform.c:363
void SHTransformTz(double tz, TSHTransform *t)
Constructor.
Definition: shtransform.c:143
A homgeneous transform in R^3.
#define AXIS_Y
One of the dimension of R^3.
Definition: htransform.h:91
#define RZ
One of the types of homogeneous transforms in R^3.
Definition: htransform.h:75
void SHTransformRy(double ry, TSHTransform *t)
Constructor.
Definition: shtransform.c:256
void SHTransformVarTy(unsigned int y, TSHTransform *t)
Constructor.
Definition: shtransform.c:131
void CopyEquation(Tequation *eq_dst, Tequation *eq_orig)
Copy constructor.
Definition: equation.c:216
#define EQU
In a Tequation, the equation relational operator is equal.
Definition: equation.h:202
void SHTransformPreCtProduct(THTransform *t1, TSHTransform *t2, TSHTransform *t3)
Product of a constant and a symbolic homogeneous transforms.
Definition: shtransform.c:424
void SHTransformTranspose(TSHTransform *t, TSHTransform *tt)
Transpose of a homogeneous transform.
Definition: shtransform.c:521
void SHTransformApply(double *p_in, Tequation *p_out, TSHTransform *t)
Multiply a symbolic homogeneous transform and a vector.
Definition: shtransform.c:543
void SHTransformVarTx(unsigned int x, TSHTransform *t)
Constructor.
Definition: shtransform.c:113
void SHTransformRz(double rz, TSHTransform *t)
Constructor.
Definition: shtransform.c:297
#define RY
One of the types of homogeneous transforms in R^3.
Definition: htransform.h:67
Tequation TEqVector[3]
An array with three equations.
Definition: eqvector.h:25
void InitEquation(Tequation *eq)
Constructor.
Definition: equation.c:86
void Error(const char *s)
General error function.
Definition: error.c:80
#define NFUN
No trigonometric function for the variable.
Definition: variable_set.h:36
#define TZ
One of the types of homogeneous transforms in R^3.
Definition: htransform.h:51
#define COSV
Cosine of the variable.
Definition: variable_set.h:50
#define AXIS_H
The homogeneous dimension in R^3.
Definition: htransform.h:108
void SHTransformInit(TSHTransform *t)
Initializes an empty symbolic transform.
Definition: shtransform.c:25
void SetEquationValue(double v, Tequation *eq)
Changes the right-hand value of the equation.
Definition: equation.c:1089
void AddMonomial(Tmonomial *f, Tequation *eq)
Adds a new monomial to the equation.
Definition: equation.c:1419
#define SINV
Sine of the variable.
Definition: variable_set.h:43
Tequation * GetEqVectorElement(unsigned int i, TEqVector *ev)
Gets an alement from a equation vector.
Definition: eqvector.c:41
double HTransformGetElement(unsigned int i, unsigned int j, THTransform *t)
Gets an element in a homogeneous transform.
Definition: htransform.c:329
void SHTransformVarTz(unsigned int z, TSHTransform *t)
Constructor.
Definition: shtransform.c:149
void SetEquationCmp(unsigned int cmp, Tequation *eq)
Changes the relational operator (LEQ, GEQ, EQU) of the equation.
Definition: equation.c:1081
void ResetMonomial(Tmonomial *f)
Reset the monomial information.
Definition: monomial.c:24
#define AXIS_Z
One of the dimension of R^3.
Definition: htransform.h:99
void SHTransformCopy(TSHTransform *t_dst, TSHTransform *t_org)
Copy constructor.
Definition: shtransform.c:90
#define TX
One of the types of homogeneous transforms in R^3.
Definition: htransform.h:35
An equation.
Definition: equation.h:237
void SHTransformPostCtProduct(TSHTransform *t1, THTransform *t2, TSHTransform *t3)
Product of a symbolic and a constant homogeneous transforms.
Definition: shtransform.c:448
void SHTransformFromEqVectors(TEqVector *x, TEqVector *y, TEqVector *d, TSHTransform *t)
Initializes a symbolic homogeneous transform from vectors.
Definition: shtransform.c:53
void SHTransformApplyRot(double *p_in, Tequation *p_out, TSHTransform *t)
Multiply the rotation part of the homogeneous transform and a vector.
Definition: shtransform.c:556
Tequation * SHTransformGetElement(unsigned int i, unsigned int j, TSHTransform *t)
Gets an element in a homogeneous transform.
Definition: shtransform.c:388
void SHTransformVarDisplacementAlongVector(double *v, unsigned int vID, TSHTransform *t)
Constructor.
Definition: shtransform.c:191
A scaled product of powers of variables.
Definition: monomial.h:32
void SHTransformTx(double tx, TSHTransform *t)
Constructor.
Definition: shtransform.c:107
void SHTransformAdd(TSHTransform *t1, TSHTransform *t2, TSHTransform *t3)
Addition of two homogeneous transforms.
Definition: shtransform.c:472
void SHTransformIdentity(TSHTransform *t)
Constructor.
Definition: shtransform.c:43
void SHTransformVarRy(unsigned int y, TSHTransform *t)
Constructor.
Definition: shtransform.c:272
void SHTransformVarTxyz(unsigned int x, unsigned int y, unsigned int z, TSHTransform *t)
Constructor.
Definition: shtransform.c:169
void SHTransformRx(double rx, TSHTransform *t)
Constructor.
Definition: shtransform.c:215
#define RX
One of the types of homogeneous transforms in R^3.
Definition: htransform.h:59
void SHTransformTxyz(double tx, double ty, double tz, TSHTransform *t)
Constructor.
Definition: shtransform.c:161
void AddVariable2Monomial(unsigned int fn, unsigned int varid, unsigned int p, Tmonomial *f)
Adds a power variable to the monomial.
Definition: monomial.c:171
Definition of the TSHTransform type and the associated functions.
void PrintMonomials(FILE *f, char **varNames, Tequation *eq)
Prints an equation as a set if monomials.
Definition: equation.c:1803
void SHTransformProduct(TSHTransform *t1, TSHTransform *t2, TSHTransform *t3)
Product of two symbolic homogeneous transforms.
Definition: shtransform.c:398
void HTransformSetElement(unsigned int i, unsigned int j, double v, THTransform *t)
Sets an element in a homogeneous transform.
Definition: htransform.c:312
void AddCt2Monomial(double k, Tmonomial *f)
Scales a monomial.
Definition: monomial.c:158
#define DIM_SP
Dimensions of R^3.
Definition: htransform.h:27
void SHTransformInverse(TSHTransform *t, TSHTransform *ti)
Inverse of a homogeneous transform.
Definition: shtransform.c:492
void SHTransformPrint(FILE *f, char **varNames, TSHTransform *t)
Prints the a homogeneous transform to a file.
Definition: shtransform.c:586
void ProductEquations(Tequation *eq1, Tequation *eq2, Tequation *eqOut)
Product of two equations.
Definition: equation.c:398
void SHTransformDelete(TSHTransform *t)
Destructor.
Definition: shtransform.c:600
void SHTransformTy(double ty, TSHTransform *t)
Constructor.
Definition: shtransform.c:125
void SHTransformVarRx(unsigned int x, TSHTransform *t)
Constructor.
Definition: shtransform.c:231
void HTransformIdentity(THTransform *t)
Constructor.
Definition: htransform.c:69
void InitMonomial(Tmonomial *f)
Constructor.
Definition: monomial.c:17
void AccumulateEquations(Tequation *eqn, double ct, Tequation *eq)
Adds a scaled equation to another equation.
Definition: equation.c:366
A homgeneous transform in R^3.
void SHTransformEvaluate(double *varValues, THTransform *tc, TSHTransform *t)
Evaluates a symbolic homogeneous transform.
Definition: shtransform.c:569
void DeleteMonomial(Tmonomial *f)
Destructor.
Definition: monomial.c:289
void DeleteEqVector(TEqVector *ev)
Deletes an equation vector.
Definition: eqvector.c:219
void CrossProductEqVectors(TEqVector *ev1, TEqVector *ev2, TEqVector *evOut)
Cross product of two equation vectors.
Definition: eqvector.c:126
#define TY
One of the types of homogeneous transforms in R^3.
Definition: htransform.h:43
void SHTransformVarRz(unsigned int z, TSHTransform *t)
Constructor.
Definition: shtransform.c:313