Debian Codegraph @

src/python/PyImath/PyImathEuler.cpp

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 // clang-format off
7
8 #include <Python.h>
9 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
10 #include <boost/python.hpp>
11 #include <boost/python/make_constructor.hpp>
12 #include <boost/format.hpp>
13 #include <ImathVec.h>
14 #include "PyImath.h"
15 #include "PyImathMathExc.h"
16 #include "PyImathEuler.h"
17 #include "PyImathDecorators.h"
18 #include "PyImathExport.h"
19 #include "PyImathOperators.h"
20
21 // XXX incomplete array wrapping, docstrings missing
22
23 namespace PyImath {
24 template<> const char *PyImath::EulerfArray::name() { return "EulerfArray"; }
25 template<> const char *PyImath::EulerdArray::name() { return "EulerdArray"; }
26 }
27
28 namespace PyImath {
29 using namespace boost::python;
30 using namespace IMATH_NAMESPACE;
31
32 template <class T> struct EulerName { static const char *value; };
33 template<> const char *EulerName<float>::value = "Eulerf";
34 template<> const char *EulerName<double>::value = "Eulerd";
35
36 template <class T>
37 static std::string nameOfOrder(typename IMATH_NAMESPACE::Euler<T>::Order order)
38 {
39 switch(order)
40 {
41 case IMATH_NAMESPACE::Euler<T>::XYZ:
42 return "EULER_XYZ";
43 case IMATH_NAMESPACE::Euler<T>::XZY:
44 return "EULER_XZY";
45 case IMATH_NAMESPACE::Euler<T>::YZX:
46 return "EULER_YZX";
47 case IMATH_NAMESPACE::Euler<T>::YXZ:
48 return "EULER_YXZ";
49 case IMATH_NAMESPACE::Euler<T>::ZXY:
50 return "EULER_ZXY";
51 case IMATH_NAMESPACE::Euler<T>::ZYX:
52 return "EULER_ZYX";
53 case IMATH_NAMESPACE::Euler<T>::XZX:
54 return "EULER_XZX";
55 case IMATH_NAMESPACE::Euler<T>::XYX:
56 return "EULER_XYX";
57 case IMATH_NAMESPACE::Euler<T>::YXY:
58 return "EULER_YXY";
59 case IMATH_NAMESPACE::Euler<T>::YZY:
60 return "EULER_YZY";
61 case IMATH_NAMESPACE::Euler<T>::ZYZ:
62 return "EULER_ZYZ";
63 case IMATH_NAMESPACE::Euler<T>::ZXZ:
64 return "EULER_ZXZ";
65 case IMATH_NAMESPACE::Euler<T>::XYZr:
66 return "EULER_XYZr";
67 case IMATH_NAMESPACE::Euler<T>::XZYr:
68 return "EULER_XZYr";
69 case IMATH_NAMESPACE::Euler<T>::YZXr:
70 return "EULER_YZXr";
71 case IMATH_NAMESPACE::Euler<T>::YXZr:
72 return "EULER_YXZr";
73 case IMATH_NAMESPACE::Euler<T>::ZXYr:
74 return "EULER_ZXYr";
75 case IMATH_NAMESPACE::Euler<T>::ZYXr:
76 return "EULER_ZYXr";
77 case IMATH_NAMESPACE::Euler<T>::XZXr:
78 return "EULER_XZXr";
79 case IMATH_NAMESPACE::Euler<T>::XYXr:
80 return "EULER_XYXr";
81 case IMATH_NAMESPACE::Euler<T>::YXYr:
82 return "EULER_YXYr";
83 case IMATH_NAMESPACE::Euler<T>::YZYr:
84 return "EULER_YZYr";
85 case IMATH_NAMESPACE::Euler<T>::ZYZr:
86 return "EULER_ZYZr";
87 case IMATH_NAMESPACE::Euler<T>::ZXZr:
88 return "EULER_ZXZr";
89 default:
90 break;
91 }
92
93 return "";
94 }
95
96 template <class T>
97 static std::string Euler_str(const Euler<T> &e)
98 {
99 std::stringstream stream;
100 stream << EulerName<T>::value << "(" << e.x << ", " << e.y << ", " << e.z << ", "
101 << nameOfOrder<T> (e.order()) << ")";
102 return stream.str();
103 }
104
105 // Non-specialized repr is same as str
106 template <class T>
107 static std::string Euler_repr(const Euler<T> &e)
108 {
109 return Euler_str(e);
110 }
111
112 // Specialization for float to full precision
113 template <>
114 std::string Euler_repr(const Euler<float> &e)
115 {
116 return (boost::format("%s(%.9g, %.9g, %.9g, %s)")
117 % EulerName<float>::value
118 % e.x % e.y % e.z
119 % nameOfOrder<float>(e.order()).c_str()).str();
120 }
121
122 // Specialization for double to full precision
123 template <>
124 std::string Euler_repr(const Euler<double> &e)
125 {
126 return (boost::format("%s(%.17g, %.17g, %.17g, %s)")
127 % EulerName<double>::value
128 % e.x % e.y % e.z
129 % nameOfOrder<double>(e.order()).c_str()).str();
130 }
131
132
133 template <class T>
134 static bool
135 equal(const Euler<T> &e0, const Euler<T> &e1)
136 {
137 if(e0.x == e1.x && e0.y == e1.y && e0.z == e1.z && (e0.order())==(e1.order()))
138 return true;
139 else
140 return false;
141 }
142
143 template <class T>
144 static bool
145 notequal(const Euler<T> &e0, const Euler<T> &e1)
146 {
147 if(e0.x != e1.x || e0.y != e1.y || e0.z != e1.z || (e0.order()) != (e1.order()))
148 {
149 return true;
150 }
151 else
152 return false;
153 }
154
155 template <class T>
156 static IMATH_NAMESPACE::Vec3 <int> getAngleOrder(Euler <T> &euler)
157 {
158 int i, j, k;
159 euler.angleOrder(i, j, k);
160 return IMATH_NAMESPACE::Vec3 <int> (i, j, k);
161 }
162
163 template <class T>
164 static void
165 setXYZTuple(Euler<T> &euler, const tuple &t)
166 {
167 MATH_EXC_ON;
168 Vec3<T> v;
169 if(t.attr("__len__")() == 3)
170 {
171 v.x = extract<T>(t[0]);
172 v.y = extract<T>(t[1]);
173 v.z = extract<T>(t[2]);
174
175 euler.setXYZVector(v);
176 }
177 else
178 throw std::invalid_argument ("Color3 expects tuple of length 3");
179 }
180
181 // needed to convert Eulerf::Order to Euler<T>::Order
182 template <class T>
183 static typename Euler<T>::Order interpretOrder(typename IMATH_NAMESPACE::Eulerf::Order order)
184 {
185 typename Euler<T>::Order o = Euler<T>::XYZ;
186 switch(order)
187 {
188 case IMATH_NAMESPACE::Eulerf::XYZ:
189 {
190 o = Euler<T>::XYZ;
191 }break;
192 case IMATH_NAMESPACE::Eulerf::XZY:
193 {
194 o = Euler<T>::XZY;
195 }break;
196 case IMATH_NAMESPACE::Eulerf::YZX:
197 {
198 o = Euler<T>::YZX;
199 }break;
200 case IMATH_NAMESPACE::Eulerf::YXZ:
201 {
202 o = Euler<T>::YXZ;
203 }break;
204 case IMATH_NAMESPACE::Eulerf::ZXY:
205 {
206 o = Euler<T>::ZXY;
207 }break;
208 case IMATH_NAMESPACE::Eulerf::ZYX:
209 {
210 o = Euler<T>::ZYX;
211 }break;
212 case IMATH_NAMESPACE::Eulerf::XZX:
213 {
214 o = Euler<T>::XZX;
215 }break;
216 case IMATH_NAMESPACE::Eulerf::XYX:
217 {
218 o = Euler<T>::XYX;
219 }break;
220 case IMATH_NAMESPACE::Eulerf::YXY:
221 {
222 o = Euler<T>::YXY;
223 }break;
224 case IMATH_NAMESPACE::Eulerf::YZY:
225 {
226 o = Euler<T>::YZY;
227 }break;
228 case IMATH_NAMESPACE::Eulerf::ZYZ:
229 {
230 o = Euler<T>::ZYZ;
231 }break;
232 case IMATH_NAMESPACE::Eulerf::ZXZ:
233 {
234 o = Euler<T>::ZXZ;
235 }break;
236 case IMATH_NAMESPACE::Eulerf::XYZr:
237 {
238 o = Euler<T>::XYZr;
239 }break;
240 case IMATH_NAMESPACE::Eulerf::XZYr:
241 {
242 o = Euler<T>::XZYr;
243 }break;
244 case IMATH_NAMESPACE::Eulerf::YZXr:
245 {
246 o = Euler<T>::YZXr;
247 }break;
248 case IMATH_NAMESPACE::Eulerf::YXZr:
249 {
250 o = Euler<T>::YXZr;
251 }break;
252 case IMATH_NAMESPACE::Eulerf::ZXYr:
253 {
254 o = Euler<T>::ZXYr;
255 }break;
256 case IMATH_NAMESPACE::Eulerf::ZYXr:
257 {
258 o = Euler<T>::ZYXr;
259 }break;
260 case IMATH_NAMESPACE::Eulerf::XZXr:
261 {
262 o = Euler<T>::XZXr;
263 }break;
264 case IMATH_NAMESPACE::Eulerf::XYXr:
265 {
266 o = Euler<T>::XYXr;
267 }break;
268 case IMATH_NAMESPACE::Eulerf::YXYr:
269 {
270 o = Euler<T>::YXYr;
271 }break;
272 case IMATH_NAMESPACE::Eulerf::YZYr:
273 {
274 o = Euler<T>::YZYr;
275 }break;
276 case IMATH_NAMESPACE::Eulerf::ZYZr:
277 {
278 o = Euler<T>::ZYZr;
279 }break;
280 case IMATH_NAMESPACE::Eulerf::ZXZr:
281 {
282 o = Euler<T>::ZXZr;
283 }break;
284 default:
285 break;
286 }
287
288 return o;
289 }
290
291 // needed to convert Eulerf::Axis to Euler<T>::Axis
292 template <class T>
293 static typename Euler<T>::Axis interpretAxis(typename IMATH_NAMESPACE::Eulerf::Axis axis)
294 {
295 if (axis == IMATH_NAMESPACE::Eulerf::X)
296 return Euler<T>::X;
297 else if (axis == IMATH_NAMESPACE::Eulerf::Y)
298 return Euler<T>::Y;
299 else
300 return Euler<T>::Z;
301 }
302
303 template <class T>
304 static Euler<T> *
305 eulerConstructor1(const Vec3<T> &v, typename IMATH_NAMESPACE::Eulerf::Order order)
306 {
307 typename Euler<T>::Order o = interpretOrder<T>(order);
308 return new Euler<T>(v, o);
309 }
310
311 template <class T>
312 static Euler<T> *
313 eulerConstructor1a(const Vec3<T> &v)
314 {
315 return eulerConstructor1 (v, IMATH_NAMESPACE::Eulerf::Default);
316 }
317
318 template <class T>
319 static Euler<T> *
320 eulerConstructor1b(const Vec3<T> &v, int iorder)
321 {
322 typename Euler<T>::Order o = typename Euler<T>::Order (iorder);
323 return new Euler<T>(v, o);
324 }
325
326 template <class T>
327 static Euler<T> *
328 eulerConstructor2(T i, T j, T k, typename IMATH_NAMESPACE::Eulerf::Order order)
329 {
330 typename Euler<T>::Order o = interpretOrder<T>(order);
331 return new Euler<T>(i, j, k, o);
332 }
333
334 template <class T>
335 static Euler<T> *
336 eulerConstructor2a(T i, T j, T k)
337 {
338 return eulerConstructor2 (i, j, k, IMATH_NAMESPACE::Eulerf::Default);
339 }
340
341 template <class T>
342 static Euler<T> *
343 eulerConstructor2b(T i, T j, T k, int iorder)
344 {
345 typename Euler<T>::Order o = typename Euler<T>::Order (iorder);
346 return new Euler<T>(i, j, k, o);
347 }
348
349 template <class T>
350 static Euler<T> *
351 eulerConstructor3(const Matrix33<T> &mat, typename IMATH_NAMESPACE::Eulerf::Order order)
352 {
353 typename Euler<T>::Order o = interpretOrder<T>(order);
354 return new Euler<T>(mat, o);
355 }
356
357 template <class T>
358 static Euler<T> *
359 eulerConstructor3a(const Matrix33<T> &mat)
360 {
361 return eulerConstructor3 (mat, IMATH_NAMESPACE::Eulerf::Default);
362 }
363
364 template <class T>
365 static Euler<T> *
366 eulerConstructor3b(const Matrix33<T> &mat, int iorder)
367 {
368 typename Euler<T>::Order o = typename Euler<T>::Order (iorder);
369 return new Euler<T>(mat, o);
370 }
371
372 template <class T>
373 static Euler<T> *
374 eulerConstructor4(const Matrix44<T> &mat, typename IMATH_NAMESPACE::Eulerf::Order order)
375 {
376 typename Euler<T>::Order o = interpretOrder<T>(order);
377 return new Euler<T>(mat, o);
378 }
379
380 template <class T>
381 static Euler<T> *
382 eulerConstructor4a(const Matrix44<T> &mat)
383 {
384 return eulerConstructor4 (mat, IMATH_NAMESPACE::Eulerf::Default);
385 }
386
387 template <class T>
388 static Euler<T> *
389 eulerConstructor4b(const Matrix44<T> &mat, int iorder)
390 {
391 typename Euler<T>::Order o = typename Euler<T>::Order (iorder);
392 return new Euler<T>(mat, o);
393 }
394
395 template <class T>
396 static Euler<T> *
397 eulerConstructor5(typename IMATH_NAMESPACE::Eulerf::Order order)
398 {
399 typename Euler<T>::Order o = interpretOrder<T>(order);
400 return new Euler<T>(o);
401 }
402
403 template <class T>
404 static Euler<T> *
405 eulerConstructor5a()
406 {
407 typename Euler<T>::Order o = interpretOrder<T>(IMATH_NAMESPACE::Eulerf::Default);
408 return new Euler<T>(o);
409 }
410
411 template <class T>
412 static Euler<T> *
413 eulerConstructor5b(int iorder)
414 {
415 typename Euler<T>::Order o = typename Euler<T>::Order (iorder);
416 return new Euler<T>(o);
417 }
418
419 template <class T>
420 static Euler<T> *
421 eulerConstructor6(T x, T y, T z)
422 {
423 return new Euler<T>(Vec3<T>(x,y,z));
424 }
425
426 template <class T>
427 static Euler<T> *
428 eulerConstructor7(const Quat<T> &quat, typename IMATH_NAMESPACE::Eulerf::Order order)
429 {
430 Euler<T> *e = eulerConstructor5<T>(order);
431 e->extract(quat);
432 return e;
433 }
434
435 template <class T>
436 static Euler<T> *
437 eulerConstructor7a(const Quat<T> &quat)
438 {
439 return eulerConstructor7(quat, IMATH_NAMESPACE::Eulerf::Default);
440 }
441
442 template <class T>
443 static Euler<T> *
444 eulerConstructor7b(const Quat<T> &quat, int iorder)
445 {
446 Euler<T> *e = eulerConstructor5b<T>(iorder);
447 e->extract(quat);
448 return e;
449 }
450
451 template <class T, class S>
452 static Euler<T> *
453 eulerConversionConstructor(const Euler<S> &euler)
454 {
455 MATH_EXC_ON;
456 Euler<T> *e = new Euler<T>;
457 *e = euler;
458 return e;
459 }
460
461 template <class T>
462 static void
463 eulerMakeNear(Euler<T> &euler, Euler<T> &target)
464 {
465 MATH_EXC_ON;
466 euler.makeNear (target);
467 }
468
469 template <class T>
470 static void
471 eulerSetOrder(Euler<T> &euler, typename IMATH_NAMESPACE::Eulerf::Order order)
472 {
473 typename Euler<T>::Order o = interpretOrder<T>(order);
474 euler.setOrder (o);
475 }
476
477 template <class T>
478 static void
479 eulerSet(Euler<T> &euler, IMATH_NAMESPACE::Eulerf::Axis axis, int relative, int parityEven, int firstRepeats)
480 {
481 MATH_EXC_ON;
482 typename Euler<T>::Axis a = interpretAxis<T>(axis);
483 euler.set (a, relative, parityEven, firstRepeats);
484 }
485
486 template <class T>
487 static void
488 extract1(Euler<T> &euler, const Matrix33<T> &m)
489 {
490 MATH_EXC_ON;
491 euler.extract(m);
492 }
493
494 template <class T>
495 static void
496 extract2(Euler<T> &euler, const Matrix44<T> &m)
497 {
498 MATH_EXC_ON;
499 euler.extract(m);
500 }
501
502 template <class T>
503 static void
504 extract3(Euler<T> &euler, const Quat<T> &q)
505 {
506 MATH_EXC_ON;
507 euler.extract(q);
508 }
509
510 template <class T>
511 static Matrix33<T>
512 toMatrix33(Euler<T> &euler)
513 {
514 MATH_EXC_ON;
515 return euler.toMatrix33();
516 }
517
518 template <class T>
519 static Matrix44<T>
520 toMatrix44(Euler<T> &euler)
521 {
522 MATH_EXC_ON;
523 return euler.toMatrix44();
524 }
525
526 template <class T>
527 static Quat<T>
528 toQuat(Euler<T> &euler)
529 {
530 MATH_EXC_ON;
531 return euler.toQuat();
532 }
533
534 template <class T>
535 static Vec3<T>
536 toXYZVector(Euler<T> &euler)
537 {
538 MATH_EXC_ON;
539 return euler.toXYZVector();
540 }
541
542 template <class T>
543 class_<Euler<T>,bases<IMATH_NAMESPACE::Vec3<T> > >
544 register_Euler()
545 {
546 class_<Euler<T>,bases<Vec3<T> > > euler_class(EulerName<T>::value,EulerName<T>::value,init<Euler<T> >("copy construction"));
547 euler_class
548 .def(init<>("imath Euler default construction"))
549 .def("__init__", make_constructor(eulerConstructor1<T>))
550 .def("__init__", make_constructor(eulerConstructor1a<T>))
551 .def("__init__", make_constructor(eulerConstructor1b<T>))
552 .def("__init__", make_constructor(eulerConstructor2<T>))
553 .def("__init__", make_constructor(eulerConstructor2a<T>))
554 .def("__init__", make_constructor(eulerConstructor2b<T>))
555 .def("__init__", make_constructor(eulerConstructor3<T>),
556 "Euler-from-matrix construction assumes, but does\n"
557 "not verify, that the matrix includes no shear or\n"
558 "non-uniform scaling. If necessary, you can fix\n"
559 "the matrix by calling the removeScalingAndShear()\n"
560 "function.\n")
561 .def("__init__", make_constructor(eulerConstructor3a<T>))
562 .def("__init__", make_constructor(eulerConstructor3b<T>))
563 .def("__init__", make_constructor(eulerConstructor4<T>))
564 .def("__init__", make_constructor(eulerConstructor4a<T>))
565 .def("__init__", make_constructor(eulerConstructor4b<T>))
566 .def("__init__", make_constructor(eulerConstructor5<T>))
567 .def("__init__", make_constructor(eulerConstructor5a<T>))
568 .def("__init__", make_constructor(eulerConstructor5b<T>))
569 .def("__init__", make_constructor(eulerConstructor6<T>))
570 .def("__init__", make_constructor(eulerConstructor7<T>))
571 .def("__init__", make_constructor(eulerConstructor7a<T>))
572 .def("__init__", make_constructor(eulerConstructor7b<T>))
573 .def("__init__", make_constructor(eulerConversionConstructor<T, float>))
574 .def("__init__", make_constructor(eulerConversionConstructor<T, double>))
575
576 .def("angleOrder", &getAngleOrder<T>, "angleOrder() set the angle order")
577
578 .def("frameStatic", &Euler<T>::frameStatic,
579 "e.frameStatic() -- returns true if the angles of e\n"
580 "are measured relative to a set of fixed axes,\n"
581 "or false if the angles of e are measured relative to\n"
582 "each other\n")
583
584 .def("initialAxis", &Euler<T>::initialAxis,
585 "e.initialAxis() -- returns the initial rotation\n"
586 "axis of e (EULER_X_AXIS, EULER_Y_AXIS, EULER_Z_AXIS)")
587
588 .def("initialRepeated", &Euler<T>::initialRepeated,
589 "e.initialRepeated() -- returns 1 if the initial\n"
590 "rotation axis of e is repeated (for example,\n"
591 "e.order() == EULER_XYX); returns 0 if the initial\n"
592 "rotation axis is not repeated.\n")
593
594 .def("makeNear", &eulerMakeNear<T>,
595 "e.makeNear(t) -- adjusts Euler e so that it\n"
596 "represents the same rotation as before, but the\n"
597 "individual angles of e differ from the angles of\n"
598 "t by as little as possible.\n"
599 "This method might not make sense if e.order()\n"
600 "and t.order() are different\n")
601
602 .def("order", &Euler<T>::order,
603 "e.order() -- returns the rotation order in e\n"
604 "(EULER_XYZ, EULER_XZY, ...)")
605
606 .def("parityEven", &Euler<T>::parityEven,
607 "e.parityEven() -- returns the parity of the\n"
608 "axis permutation of e\n")
609
610 .def("set", &eulerSet<T>,
611 "e.set(i,r,p,f) -- sets the rotation order in e\n"
612 "according to the following flags:\n"
613 "\n"
614 " i initial axis (EULER_X_AXIS,\n"
615 " EULER_Y_AXIS or EULER_Z_AXIS)\n"
616 "\n"
617 " r rotation angles are measured relative\n"
618 " to each other (r == 1), or relative to a\n"
619 " set of fixed axes (r == 0)\n"
620 "\n"
621 " p parity of axis permutation is even (r == 1)\n"
622 " or odd (r == 0)\n"
623 "\n"
624 " f first rotation axis is repeated (f == 1)\n"
625 " or not repeated (f == 0)\n")
626
627 .def("setOrder", &eulerSetOrder<T>,
628 "e.setOrder(o) -- sets the rotation order in e\n"
629 "to o (EULER_XYZ, EULER_XZY, ...)")
630
631 .def("setXYZVector", &Euler<T>::setXYZVector,
632 "e.setXYZVector(v) -- sets the three rotation\n"
633 "angles in e to v[0], v[1], v[2]")
634 .def("setXYZVector", &setXYZTuple<T>)
635
636 .def("extract", &extract1<T>,
637 "e.extract(m) -- extracts the rotation component\n"
638 "from 3x3 matrix m and stores the result in e.\n"
639 "Assumes that m does not contain shear or non-\n"
640 "uniform scaling. If necessary, you can fix m\n"
641 "by calling m.removeScalingAndShear().")
642
643 .def("extract", &extract2<T>,
644 "e.extract(m) -- extracts the rotation component\n"
645 "from 4x4 matrix m and stores the result in e.\n"
646 "Assumes that m does not contain shear or non-\n"
647 "uniform scaling. If necessary, you can fix m\n"
648 "by calling m.removeScalingAndShear().")
649
650 .def("extract", &extract3<T>,
651 "e.extract(q) -- extracts the rotation component\n"
652 "from quaternion q and stores the result in e")
653
654 .def("toMatrix33", &toMatrix33<T>, "e.toMatrix33() -- converts e into a 3x3 matrix\n")
655
656 .def("toMatrix44", &toMatrix44<T>, "e.toMatrix44() -- converts e into a 4x4 matrix\n")
657
658 .def("toQuat", &toQuat<T>, "e.toQuat() -- converts e into a quaternion\n")
659
660 .def("toXYZVector", &toXYZVector<T>,
661 "e.toXYZVector() -- converts e into an XYZ\n"
662 "rotation vector")
663 .def("__str__", &Euler_str<T>)
664 .def("__repr__", &Euler_repr<T>)
665
666 .def("__eq__", &equal<T>)
667 .def("__ne__", &notequal<T>)
668 ;
669
670 // fill in the Euler scope
671 {
672 scope euler_scope(euler_class);
673 enum_<typename Euler<T>::Order> euler_order("Order");
674 euler_order
675 .value("XYZ",Euler<T>::XYZ)
676 .value("XZY",Euler<T>::XZY)
677 .value("YZX",Euler<T>::YZX)
678 .value("YXZ",Euler<T>::YXZ)
679 .value("ZXY",Euler<T>::ZXY)
680 .value("ZYX",Euler<T>::ZYX)
681 .value("XZX",Euler<T>::XZX)
682 .value("XYX",Euler<T>::XYX)
683 .value("YXY",Euler<T>::YXY)
684 .value("YZY",Euler<T>::YZY)
685 .value("ZYZ",Euler<T>::ZYZ)
686 .value("ZXZ",Euler<T>::ZXZ)
687 .value("XYZr",Euler<T>::XYZr)
688 .value("XZYr",Euler<T>::XZYr)
689 .value("YZXr",Euler<T>::YZXr)
690 .value("YXZr",Euler<T>::YXZr)
691 .value("ZXYr",Euler<T>::ZXYr)
692 .value("ZYXr",Euler<T>::ZYXr)
693 .value("XZXr",Euler<T>::XZXr)
694 .value("XYXr",Euler<T>::XYXr)
695 .value("YXYr",Euler<T>::YXYr)
696 .value("YZYr",Euler<T>::YZYr)
697 .value("ZYZr",Euler<T>::ZYZr)
698 .value("ZXZr",Euler<T>::ZXZr)
699
700 // don't export these, they're not really part of the public interface
701 //.value("Legal",Euler<T>::Legal)
702 //.value("Min",Euler<T>::Min)
703 //.value("Max",Euler<T>::Max)
704
705 // handle Default seperately since boost sets up a 1-1 mapping for enum values
706 //.value("Default",Euler<T>::Default)
707 .export_values()
708 ;
709 // just set it to the XYZ value manually
710 euler_scope.attr("Default") = euler_scope.attr("XYZ");
711
712 enum_<typename Euler<T>::Axis>("Axis")
713 .value("X",Euler<T>::X)
714 .value("Y",Euler<T>::Y)
715 .value("Z",Euler<T>::Z)
716 .export_values()
717 ;
718
719 enum_<typename Euler<T>::InputLayout>("InputLayout")
720 .value("XYZLayout",Euler<T>::XYZLayout)
721 .value("IJKLayout",Euler<T>::IJKLayout)
722 .export_values()
723 ;
724 }
725
726 decoratecopy(euler_class);
727
728 return euler_class;
729 }
730
731 // XXX fixme - template this
732 // really this should get generated automatically...
733
734 /*
735 template <class T,int index>
736 static FixedArray<T>
737 EulerArray_get(FixedArray<IMATH_NAMESPACE::Euler<T> > &qa)
738 {
739 return FixedArray<T>( &(qa[0].r)+index, qa.len(), 4*qa.stride());
740 }
741 */
742
743 template <class T>
744 static FixedArray<IMATH_NAMESPACE::Euler<T> > *
745 EulerArray_eulerConstructor7a(const FixedArray<IMATH_NAMESPACE::Quat<T> > &q)
746 {
747 MATH_EXC_ON;
748 size_t len = q.len();
749 FixedArray<IMATH_NAMESPACE::Euler<T> >* result = new FixedArray<IMATH_NAMESPACE::Euler<T> >(len);
750 for (size_t i = 0; i < len; ++i) {
751 (*result)[i].extract(q[i]);
752 }
753 return result;
754 }
755
756 template <class T>
757 static FixedArray<IMATH_NAMESPACE::Euler<T> > *
758 EulerArray_eulerConstructor8a(const FixedArray<IMATH_NAMESPACE::Vec3<T> >& v)
759 {
760 MATH_EXC_ON;
761 size_t len = v.len();
762 FixedArray<IMATH_NAMESPACE::Euler<T> >* result = new FixedArray<IMATH_NAMESPACE::Euler<T> >(len);
763
764 for (size_t i = 0; i < len; ++i)
765 (*result)[i] = Euler<T>(v[i]);
766
767 return result;
768 }
769
770 template <class T>
771 static FixedArray<IMATH_NAMESPACE::Euler<T> > *
772 EulerArray_eulerConstructor9a(const FixedArray<IMATH_NAMESPACE::Vec3<T> >& v, typename IMATH_NAMESPACE::Eulerf::Order order)
773 {
774 MATH_EXC_ON;
775 size_t len = v.len();
776 FixedArray<IMATH_NAMESPACE::Euler<T> >* result = new FixedArray<IMATH_NAMESPACE::Euler<T> >(len);
777
778 typename Euler<T>::Order o = interpretOrder<T>(order);
779 for (size_t i = 0; i < len; ++i)
780 (*result)[i] = Euler<T>(v[i], o);
781
782 return result;
783 }
784
785 template <class T>
786 static FixedArray<IMATH_NAMESPACE::Vec3<T> >
787 EulerArray_toXYZVector(const FixedArray<IMATH_NAMESPACE::Euler<T> >& e)
788 {
789 MATH_EXC_ON;
790 size_t len = e.len();
791 FixedArray<IMATH_NAMESPACE::Vec3<T> > result(len, UNINITIALIZED);
792 for (size_t i = 0; i < len; ++i)
793 result[i] = e[i].toXYZVector();
794 return result;
795 }
796
797 template <class T>
798 static FixedArray<IMATH_NAMESPACE::Quat<T> >
799 EulerArray_toQuat(const FixedArray<IMATH_NAMESPACE::Euler<T> >& e)
800 {
801 MATH_EXC_ON;
802 size_t len = e.len();
803 FixedArray<IMATH_NAMESPACE::Quat<T> > result(len, UNINITIALIZED);
804 for (size_t i = 0; i < len; ++i)
805 result[i] = e[i].toQuat();
806 return result;
807 }
808
809
810 template <class T>
811 class_<FixedArray<IMATH_NAMESPACE::Euler<T> > >
812 register_EulerArray()
813 {
814 class_<FixedArray<IMATH_NAMESPACE::Euler<T> > > eulerArray_class = FixedArray<IMATH_NAMESPACE::Euler<T> >::register_("Fixed length array of IMATH_NAMESPACE::Euler");
815 eulerArray_class
816 //.add_property("x",&EulerArray_get<T,1>)
817 //.add_property("y",&EulerArray_get<T,2>)
818 //.add_property("z",&EulerArray_get<T,3>)
819 .def("__init__", make_constructor(EulerArray_eulerConstructor7a<T>))
820 .def("__init__", make_constructor(EulerArray_eulerConstructor8a<T>))
821 .def("__init__", make_constructor(EulerArray_eulerConstructor9a<T>))
822 .def("toXYZVector", EulerArray_toXYZVector<T>)
823 .def("toQuat", EulerArray_toQuat<T>)
824 ;
825
826 add_comparison_functions(eulerArray_class);
827 PyImath::add_explicit_construction_from_type<IMATH_NAMESPACE::Matrix33<T> >(eulerArray_class);
828 PyImath::add_explicit_construction_from_type<IMATH_NAMESPACE::Matrix44<T> >(eulerArray_class);
829 return eulerArray_class;
830 }
831
832 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Euler<float>,bases<IMATH_NAMESPACE::Vec3<float> > > register_Euler<float>();
833 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Euler<double>,bases<IMATH_NAMESPACE::Vec3<double> > > register_Euler<double>();
834
835 template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Euler<float> > > register_EulerArray<float>();
836 template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Euler<double> > > register_EulerArray<double>();
837
838 template<> PYIMATH_EXPORT IMATH_NAMESPACE::Euler<float> FixedArrayDefaultValue<IMATH_NAMESPACE::Euler<float> >::value() { return IMATH_NAMESPACE::Euler<float>(); }
839 template<> PYIMATH_EXPORT IMATH_NAMESPACE::Euler<double> FixedArrayDefaultValue<IMATH_NAMESPACE::Euler<double> >::value() { return IMATH_NAMESPACE::Euler<double>(); }
840
841 } // namespace PyImath