Debian Codegraph @

src/python/PyImathTest/pyImathTest.in

raw
1 #!@PYTHON@
2
3 #
4 # SPDX-License-Identifier: BSD-3-Clause
5 # Copyright Contributors to the OpenEXR Project.
6 #
7
8 from imath import *
9 from math import sqrt, pi, sin, cos
10 import math
11 import string, traceback, sys
12 import random
13
14 testList = []
15
16 # -----------------------------------------------------------------
17 # Test helper functions
18 # -----------------------------------------------------------------
19
20 ArrayBaseType = {}
21 ArrayBaseType[V2sArray] = V2s
22 ArrayBaseType[V2iArray] = V2i
23 ArrayBaseType[V2fArray] = V2f
24 ArrayBaseType[V2dArray] = V2d
25 ArrayBaseType[V3sArray] = V3s
26 ArrayBaseType[V3iArray] = V3i
27 ArrayBaseType[V3fArray] = V3f
28 ArrayBaseType[V3dArray] = V3d
29
30 VecBaseType = {}
31 VecBaseType[V2s] = int
32 VecBaseType[V2i] = int
33 VecBaseType[V2f] = float
34 VecBaseType[V2d] = float
35 VecBaseType[V3s] = int
36 VecBaseType[V3i] = int
37 VecBaseType[V3f] = float
38 VecBaseType[V3d] = float
39
40 eps = 10*FLT_EPS
41
42 def dimensions(baseType):
43 if hasattr(baseType, 'dimensions'):
44 return baseType.dimensions()
45 else:
46 return 1
47
48 def numNonZeroMaskEntries(mask):
49 count = 0
50 for i in range(0, len(mask)):
51 if mask[i]:
52 count += 1
53 return count
54
55 def equalWithAbsErrorScalar(x1, x2, e):
56 return abs(x1 - x2) < e
57
58 def make_range(start, end):
59 num = end-start
60 increment = 1
61 if num < 0:
62 num = -num;
63 increment = -1
64
65 retval = IntArray(num)
66 val = start
67 for i in range(0, num):
68 retval[i] = val
69 val += increment
70
71 return retval
72
73 # We want to be able to use the test helper
74 # functions generically with different array types
75 # so we use hasattr to check if the arguments support
76 # [] operator. This is sufficient to distinguish
77 # between vector and scalar types for our purposes here
78
79 def equalWithAbsError(x1, x2, e):
80 if hasattr(x1, '__len__') and hasattr(x1, '__getitem__') and hasattr(x2, '__len__') and hasattr(x2, '__getitem__'):
81 assert(len(x1) == len(x2))
82 for i in range(0, len(x1)):
83 if not equalWithAbsErrorScalar(x1[i], x2[i], e):
84 return False
85 return True
86 else:
87 return equalWithAbsErrorScalar(x1, x2, e)
88
89 def equalWithRelErrorScalar(x1, x2, e):
90 return abs(x1 - x2) <= e * abs(x1)
91
92 def equalWithRelError(x1, x2, e):
93 if hasattr(x1, '__len__') and hasattr(x1, '__getitem__') and hasattr(x2, '__len__') and hasattr(x2, '__getitem__'):
94 assert(len(x1) == len(x2))
95 for i in range(0, len(x1)):
96 if not equalWithRelErrorScalar(x1[i], x2[i], e):
97 return False
98 return True
99 else:
100 return equalWithRelErrorScalar(x1, x2, e)
101
102 def testVectorVectorArithmeticOps(f1, f2):
103 f = f1 + f2
104 assert(len(f) == len(f1))
105 for i in range(0, len(f)):
106 assert(f[i] == f1[i] + f2[i])
107
108 f = f1 - f2
109 assert(len(f) == len(f1))
110 for i in range(0, len(f)):
111 assert(f[i] == f1[i] - f2[i])
112
113 f = f1 * f2
114 assert(len(f) == len(f1))
115 for i in range(0, len(f)):
116 assert(f[i] == f1[i] * f2[i])
117
118 f = f1 / f2
119 assert(len(f) == len(f1))
120
121 if isinstance(f,IntArray) or isinstance(f,ShortArray):
122 op = lambda a,b : a // b
123 else:
124 op = lambda a,b : a / b
125 for i in range(0, len(f)):
126 assert(equalWithAbsError(f[i], op(f1[i],f2[i]), eps))
127
128 f = -f1
129 assert(len(f) == len(f1))
130 for i in range(0, len(f)):
131 assert(f[i] == -f1[i])
132
133 def testVectorScalarArithmeticOps(f1, v):
134 f = f1 + v
135 assert(len(f) == len(f1))
136 for i in range(0, len(f)):
137 assert(f[i] == f1[i] + v)
138
139 f = v + f1
140 assert(len(f) == len(f1))
141 for i in range(0, len(f)):
142 assert(f[i] == v + f1[i])
143
144 f = f1 - v
145 assert(len(f) == len(f1))
146 for i in range(0, len(f)):
147 assert(f[i] == f1[i] - v)
148
149 f = v - f1
150 assert(len(f) == len(f1))
151 for i in range(0, len(f)):
152 if f[i] != v - f1[i]:
153 assert(f[i] == v - f1[i])
154
155 f = f1 * v
156 assert(len(f) == len(f1))
157 for i in range(0, len(f)):
158 assert(f[i] == f1[i] * v)
159
160 f = v * f1
161 assert(len(f) == len(f1))
162 for i in range(0, len(f)):
163 assert(f[i] == v * f1[i])
164
165 f = f1 / v
166 assert(len(f) == len(f1))
167 if isinstance(f,IntArray) or isinstance(f,ShortArray):
168 op = lambda a,b : a // b
169 else:
170 op = lambda a,b : a / b
171 for i in range(0, len(f)):
172 assert(equalWithAbsError(f[i], op(f1[i],v), eps))
173
174
175 def testVectorVectorInPlaceArithmeticOps(f1, f2):
176 f = f1[:]
177 f += f2
178
179 assert(len(f) == len(f1))
180 for i in range(0, len(f)):
181 assert(f[i] == f1[i] + f2[i])
182
183 f = f1[:]
184 f -= f2
185 assert(len(f) == len(f1))
186 for i in range(0, len(f)):
187 assert(f[i] == f1[i] - f2[i])
188
189 f = f1[:]
190 f *= f2
191 assert(len(f) == len(f1))
192 for i in range(0, len(f)):
193 assert(f[i] == f1[i] * f2[i])
194
195 f = f1[:]
196 f /= f2
197 assert(len(f) == len(f1))
198 if isinstance(f,IntArray) or isinstance(f,ShortArray):
199 op = lambda a,b : a // b
200 else:
201 op = lambda a,b : a / b
202 for i in range(0, len(f)):
203 assert(equalWithAbsError(f[i], op(f1[i],f2[i]), eps))
204
205 f = f1[:]
206 f = -f;
207 assert(len(f) == len(f1))
208 for i in range(0, len(f)):
209 assert(f[i] == -f1[i])
210
211 def testVectorScalarInPlaceArithmeticOps(f1, v):
212 f = f1[:]
213 f += v
214 assert(len(f) == len(f1))
215 for i in range(0, len(f)):
216 assert(f[i] == f1[i] + v)
217
218 f = f1[:]
219 f -= v
220 assert(len(f) == len(f1))
221 for i in range(0, len(f)):
222 assert(f[i] == f1[i] - v)
223
224 f = f1[:]
225 f *= v
226 assert(len(f) == len(f1))
227 for i in range(0, len(f)):
228 assert(f[i] == f1[i] * v)
229
230 f = f1[:]
231 f /= v
232 assert(len(f) == len(f1))
233 if isinstance(f,IntArray) or isinstance(f,ShortArray):
234 op = lambda a,b : a // b
235 else:
236 op = lambda a,b : a / b
237 for i in range(0, len(f)):
238 assert(equalWithAbsError(f[i], op(f1[i],v), eps))
239
240 def testPowFunctions(f1, f2):
241 # vector-vector pow
242 assert(len(f1) == len(f2))
243 f = pow(f1, f2)
244 assert(len(f) == len(f1))
245 for i in range(0, len(f)):
246 assert(equalWithRelError(f[i], pow(f1[i], f2[i]), eps))
247
248 f = f1 ** f2
249 assert(len(f) == len(f1))
250 for i in range(0, len(f)):
251 assert(equalWithRelError(f[i], f1[i] ** f2[i], eps))
252
253 # vector-scalar pow
254 v = f2[0]
255 f = pow(f1, v)
256 assert(len(f) == len(f1))
257 for i in range(0, len(f)):
258 assert(equalWithRelError(f[i], pow(f1[i], v), eps))
259
260 # in-place vector-vector pow
261 f = f1[:]
262 f **= f2
263 assert(len(f) == len(f1))
264 for i in range(0, len(f)):
265 assert(equalWithRelError(f[i], pow(f1[i], f2[i]), eps))
266
267 # in-place vector-scalar pow
268 f = f1[:]
269 v = f2[0]
270 f **= v
271 assert(len(f) == len(f1))
272 for i in range(0, len(f)):
273 assert(equalWithRelError(f[i], f1[i] ** v, eps))
274
275 def testModOps(f1, f2):
276 f = f1 % f2
277 assert(len(f) == len(f1))
278 for i in range(0, len(f)):
279 assert(f[i] == f1[i] % f2[i])
280
281 v = f2[0]
282 f = f1 % v
283 assert(len(f) == len(f1))
284 for i in range(0, len(f)):
285 assert(f[i] == f1[i] %v)
286
287 f = f1[:]
288 f %= f2
289 assert(len(f) == len(f1))
290 for i in range(0, len(f)):
291 assert(f[i] == f1[i] % f2[i])
292
293
294 def testVectorVectorComparisonOps(f1, f2):
295 f = f1 == f2
296 assert(len(f) == len(f1))
297 for i in range(0, len(f)):
298 if (f1[i] == f2[i]):
299 assert(f[i] == 1)
300 else:
301 assert(f[i] == 0)
302
303 f = f1 != f2
304 assert(len(f) == len(f1))
305 for i in range(0, len(f)):
306 if (f1[i] != f2[i]):
307 assert(f[i] == 1)
308 else:
309 assert(f[i] == 0)
310
311 def testVectorVectorInequalityOps(f1, f2):
312 f = f1 < f2
313 assert(len(f) == len(f1))
314 for i in range(0, len(f)):
315 if (f1[i] < f2[i]):
316 assert(f[i] == 1)
317 else:
318 assert(f[i] == 0)
319
320 f = f1 > f2
321 assert(len(f) == len(f1))
322 for i in range(0, len(f)):
323 if (f1[i] > f2[i]):
324 assert(f[i] == 1)
325 else:
326 assert(f[i] == 0)
327
328 f = f1 <= f2
329 for i in range(0, len(f)):
330 if (f1[i] <= f2[i]):
331 assert(f[i] == 1)
332 else:
333 assert(f[i] == 0)
334
335 f = f1 >= f2
336 for i in range(0, len(f)):
337 if (f1[i] >= f2[i]):
338 assert(f[i] == 1)
339 else:
340 assert(f[i] == 0)
341
342 def testVectorScalarComparisonOps(f1, v):
343 f = f1 == v
344 assert(len(f) == len(f1))
345 for i in range(0, len(f)):
346 if (f1[i] == v):
347 assert(f[i] == 1)
348 else:
349 assert(f[i] == 0)
350
351 f = v == f1
352 assert(len(f) == len(f1))
353 for i in range(0, len(f)):
354 if (v == f1[i]):
355 assert(f[i] == 1)
356 else:
357 assert(f[i] == 0)
358
359 f = f1 != v
360 assert(len(f) == len(f1))
361 for i in range(0, len(f)):
362 if (f1[i] != v):
363 assert(f[i] == 1)
364 else:
365 assert(f[i] == 0)
366
367 f = v != f1
368 assert(len(f) == len(f1))
369 for i in range(0, len(f)):
370 if (v != f1[i]):
371 assert(f[i] == 1)
372 else:
373 assert(f[i] == 0)
374
375 def testVectorScalarInequalityOps(f1, v):
376 f = f1 < v
377 assert(len(f) == len(f1))
378 for i in range(0, len(f)):
379 if (f1[i] < v):
380 assert(f[i] == 1)
381 else:
382 assert(f[i] == 0)
383
384 f = v < f1
385 assert(len(f) == len(f1))
386 for i in range(0, len(f)):
387 if (v < f1[i]):
388 assert(f[i] == 1)
389 else:
390 assert(f[i] == 0)
391
392 f = f1 > v
393 assert(len(f) == len(f1))
394 for i in range(0, len(f)):
395 if (f1[i] > v):
396 assert(f[i] == 1)
397 else:
398 assert(f[i] == 0)
399
400 f = v > f1
401 assert(len(f) == len(f1))
402 for i in range(0, len(f)):
403 if (v > f1[i]):
404 assert(f[i] == 1)
405 else:
406 assert(f[i] == 0)
407
408 f = f1 <= v
409 for i in range(0, len(f)):
410 if (f1[i] <= v):
411 assert(f[i] == 1)
412 else:
413 assert(f[i] == 0)
414
415 f = v <= f1
416 for i in range(0, len(f)):
417 if (v <= f1[i]):
418 assert(f[i] == 1)
419 else:
420 assert(f[i] == 0)
421
422 f = f1 >= v
423 for i in range(0, len(f)):
424 if (f1[i] >= v):
425 assert(f[i] == 1)
426 else:
427 assert(f[i] == 0)
428
429 f = v >= f1
430 for i in range(0, len(f)):
431 if (v >= f1[i]):
432 assert(f[i] == 1)
433 else:
434 assert(f[i] == 0)
435
436
437 # f1 and f2 are assumed to be unmasked arrays of the same length
438 def testVectorVectorMaskedInPlaceArithmeticOps(f1, f2, m):
439 assert(len(f1) == len(f2))
440
441 f = f1[:]
442 f[m] += f2
443 for i in range(0, len(m)):
444 if m[i]: assert(f[i] == f1[i] + f2[i])
445
446 f = f1[:]
447 f[m] -= f2
448 for i in range(0, len(m)):
449 if m[i]: assert(f[i] == f1[i] - f2[i])
450
451 f = f1[:]
452 f[m] *= f2
453 for i in range(0, len(m)):
454 if m[i]: assert(f[i] == f1[i] * f2[i])
455
456 f = f1[:]
457 f[m] /= f2
458 if isinstance(f,IntArray) or isinstance(f,ShortArray):
459 op = lambda a,b : a // b
460 else:
461 op = lambda a,b : a / b
462 for i in range(0, len(m)):
463 if m[i]: assert(equalWithAbsError(f[i], op(f1[i],f2[i]), eps))
464
465 f = f1[:]
466 f[m] = -f
467 for i in range(0, len(m)):
468 if m[i]: assert(f[i] == -f1[i])
469
470 # f1 is assumed to be an unmasked array and f2 is a masked
471 # or unmasked array such that len(f2) == len(f1[m])
472 def testVectorVectorMaskedInPlaceArithmeticOps2(f1, f2, m):
473 assert(len(f1[m]) == len(f2))
474 f = f1[:]
475 f1m = f1[m]
476 f[m] += f2
477 fm = f[m]
478
479 for i in range(0, len(fm)):
480 assert(fm[i] == f1m[i] + f2[i])
481
482 for i in range(0, len(m)):
483 if m[i] == 0:
484 assert(f[i] == f1[i])
485
486 f = f1[:]
487 f[m] -= f2
488 fm = f[m]
489
490 for i in range(0, len(fm)):
491 assert(fm[i] == f1m[i] - f2[i])
492
493 for i in range(0, len(m)):
494 if m[i] == 0:
495 assert(f[i] == f1[i])
496
497 f = f1[:]
498 f[m] *= f2
499 fm = f[m]
500
501 for i in range(0, len(fm)):
502 assert(fm[i] == f1m[i] * f2[i])
503
504 for i in range(0, len(m)):
505 if m[i] == 0:
506 assert(f[i] == f1[i])
507
508 f = f1[:]
509 f[m] /= f2
510 fm = f[m]
511
512 if isinstance(f,IntArray) or isinstance(f,ShortArray):
513 op = lambda a,b : a // b
514 else:
515 op = lambda a,b : a / b
516 for i in range(0, len(fm)):
517 assert(equalWithAbsError(fm[i], op(f1m[i],f2[i]), eps))
518
519 for i in range(0, len(m)):
520 if m[i] == 0:
521 assert(f[i] == f1[i])
522
523 def testVectorVectorMaskedArithmeticOps(f1, f2, f3, m):
524 f = f3[:]
525 f[m] = f1[m] + f2[m]
526 for i in range(0, len(m)):
527 if m[i]: assert(f[i] == f1[i] + f2[i])
528 else: assert(f[i] == f3[i])
529
530 f = f3[:]
531 f[m] = f1[m] - f2[m]
532 for i in range(0, len(m)):
533 if m[i]: assert(f[i] == f1[i] - f2[i])
534 else: assert(f[i] == f3[i])
535
536 f = f3[:]
537 f[m] = f1[m] * f2[m]
538 for i in range(0, len(m)):
539 if m[i]: assert(f[i] == f1[i] * f2[i])
540 else: assert(f[i] == f3[i])
541
542 f = f3[:]
543 f[m] = f1[m] / f2[m]
544 if isinstance(f,IntArray) or isinstance(f,ShortArray):
545 op = lambda a,b : a // b
546 else:
547 op = lambda a,b : a / b
548 for i in range(0, len(m)):
549 if m[i]: assert(equalWithRelError(f[i], op(f1[i],f2[i]), eps))
550 else: assert(f[i] == f3[i])
551
552
553 def testUnaryVecMethods(f):
554 g = f.length2()
555 assert(len(g) == len(f))
556 for i in range(0, len(f)):
557 assert(g[i] == f[i].length2())
558
559 # Normalization and length only makes sense for these types
560 if type(f) in [V2fArray, V2dArray, V3fArray, V3dArray]:
561 g = f.length()
562 assert(len(g) == len(f))
563 for i in range(0, len(f)):
564 assert(equalWithRelError(g[i], f[i].length(), eps))
565
566 g = f[:]
567 g.normalize()
568 assert(len(g) == len(f))
569 for i in range(0, len(f)):
570 assert(g[i] == f[i].normalized())
571
572 g = f.normalized()
573 assert(len(g) == len(f))
574 for i in range(0, len(f)):
575 assert(g[i] == f[i].normalized())
576
577
578 def testBinaryVecMethods(f1, f2):
579 f = f1.dot(f2)
580 assert(len(f) == len(f1))
581 for i in range(0, len(f)):
582 assert(f[i] == f1[i].dot(f2[i]))
583
584 assert(f1.dot(f2) == f2.dot(f1))
585
586 f = f1.cross(f2)
587 assert(len(f) == len(f1))
588 for i in range(0, len(f)):
589 assert(equalWithAbsError(f[i], f1[i].cross(f2[i]), eps))
590
591 assert(f1.cross(f2) == -f2.cross(f1))
592
593 v = f2[0]
594 f = f1.dot(v)
595 assert(len(f) == len(f1))
596 for i in range(0, len(f)):
597 assert(f[i] == f1[i].dot(v))
598
599 assert(f1.dot(v) == v.dot(f1))
600
601 f = f1.cross(v)
602 assert(len(f) == len(f1))
603 for i in range(0, len(f)):
604 assert(equalWithAbsError(f[i], f1[i].cross(v), eps))
605
606 assert(f1.cross(v) == -v.cross(f1))
607
608
609 def assertVectorVectorArithmeticOpFailures(f1, f2):
610 try:
611 f = f1 + f2
612 except:
613 pass
614 else:
615 assert(False)
616
617 try:
618 f = f1 - f2
619 except:
620 pass
621 else:
622 assert(False)
623
624 try:
625 f = f1 * f2
626 except:
627 pass
628 else:
629 assert(False)
630
631 try:
632 f = f1 / f2
633 except:
634 pass
635 else:
636 assert(False)
637
638 def assertVectorVectorInPlaceArithmeticOpFailures(f1, f2):
639 try:
640 f1 += f2
641 except:
642 pass
643 else:
644 assert(False)
645
646 try:
647 f1 -= f2
648 except:
649 pass
650 else:
651 assert(False)
652
653 try:
654 f1 *= f2
655 except:
656 pass
657 else:
658 assert(False)
659
660 try:
661 f1 /= f2
662 except:
663 pass
664 else:
665 assert(False)
666
667 def assertVectorVectorComparisonOpFailures(f1, f2):
668 try:
669 f1 == f2
670 except:
671 pass
672 else:
673 assert(False)
674
675 try:
676 f1 != f2
677 except:
678 pass
679 else:
680 assert(False)
681
682 try:
683 f1 < f2
684 except:
685 pass
686 else:
687 assert(False)
688
689 try:
690 f1 > f2
691 except:
692 pass
693 else:
694 assert(False)
695
696 try:
697 f1 <= f2
698 except:
699 pass
700 else:
701 assert(False)
702
703 try:
704 f1 >= f2
705 except:
706 pass
707 else:
708 assert(False)
709
710 def assertPowFunctionFailures(f1, f2):
711 try:
712 f1 ** f2
713 except:
714 pass
715 else:
716 assert(False)
717
718 try:
719 f1 **= f2
720 except:
721 pass
722 else:
723 assert(False)
724
725 def assertModOpFailures(f1, f2):
726 try:
727 f1 % f2
728 except:
729 pass
730 else:
731 assert(False)
732
733 try:
734 f1 %= f2
735 except:
736 pass
737 else:
738 assert(False)
739
740 def testArrayArrayEquality(a1,a2):
741 assert len(a1) == len(a2)
742 for i in range(0, len(a1)):
743 assert a1[i] == a2[i]
744
745 # -----------------------------------------------------------------
746 # Begin main test definitions
747 # -----------------------------------------------------------------
748
749 def testSlicesOnArrayImpl(Array, BaseTypeConstructor):
750
751 # Test the slicing operators on array types.
752 # We use a python list as a reference here.
753
754 size = 4
755
756 a = Array(size)
757 l = []
758
759 for i in range(0,size):
760 n = BaseTypeConstructor(i)
761 a[i] = n
762 l.append(n)
763
764 # Test extraction using slices
765
766 a1 = a[::2]
767 l1 = l[::2]
768 testArrayArrayEquality(a1, l1)
769
770 a2 = a[::-1]
771 l2 = l[::-1]
772 testArrayArrayEquality(a2, l2)
773
774 a3 = a[1:size]
775 l3 = l[1:size]
776 testArrayArrayEquality(a3, l3)
777
778 a4 = a[:size]
779 l4 = l[:size]
780 testArrayArrayEquality(a4, l4)
781
782 a5 = a[:-1]
783 l5 = l[:-1]
784 testArrayArrayEquality(a5, l5)
785
786 a6 = a[1:]
787 l6 = l[1:]
788 testArrayArrayEquality(a6, l6)
789
790 testArrayArrayEquality(a,a[:])
791
792 # Test assignment using slices
793
794 a8 = a
795 l8 = l
796 a8[::2] = a8[::-2]
797 l8[::2] = a8[::-2]
798
799 testArrayArrayEquality(a8,l8)
800
801 try:
802 a9 = a
803 a9[::1] = a9[::2]
804 except:
805 pass
806 else:
807 assert(False)
808
809 # Test that a sliced array does not share
810 # the same internal data
811 a10 = a[:]
812 a10[0] = BaseTypeConstructor(size)
813
814 assert a10[0] != a[0]
815
816 def testSlicesOnArray():
817
818 # All fixed arrays except StringArray shares
819 # the same implementation. We just choose
820 # a few samples for testing.
821 testSlicesOnArrayImpl(IntArray, int)
822 testSlicesOnArrayImpl(V3fArray, V3f)
823 testSlicesOnArrayImpl(FloatArray, float)
824 testSlicesOnArrayImpl(StringArray, str)
825
826 print ("ok")
827
828 testList.append (('testSlicesOnArray',testSlicesOnArray))
829
830 def testNonMaskedFloatTypeArray(FloatTypeArray):
831 f1 = FloatTypeArray(5)
832 assert (len(f1) == 5)
833
834 # Check for correct initialization
835 for i in range(0, len(f1)):
836 assert(f1[i] == 0)
837
838 f1 = FloatTypeArray(1.25, 10)
839 assert(len(f1) == 10)
840 for i in range(0, len(f1)):
841 assert(f1[i] == 1.25)
842
843 # Ensure that an exception is thrown when
844 # we exceed the bounds of the array
845 try:
846 print (f1[10])
847 except:
848 pass
849 else:
850 assert(False)
851
852 # Check element assignment
853 f1[0] = 1.5
854 f1[1] = 2.0
855
856 assert(f1[0] == 1.5)
857 assert(f1[1] == 2.0)
858
859 # Test copy construction
860 f2 = FloatTypeArray(f1)
861 assert(len(f2) == len(f1))
862 for i in range(0, len(f1)):
863 assert f1[i] == f2[i]
864
865 # The same internal data is referenced by both arrays
866 f2[3] = 4.5
867 assert(f2[3] == 4.5)
868 assert(f1[3] == 4.5)
869 f1[4] = 5.5
870 assert(f1[4] == 5.5)
871 assert(f2[4] == 5.5)
872
873 # Test negative indices
874 assert(f2[-1] == f2[len(f2)-1])
875 assert(f2[-2] == f2[len(f2)-2])
876
877 # Test slice operations
878
879 # Copy contents of f1
880 f3 = f1[:]
881 assert(len(f3) == len(f1))
882
883 for i in range(0, len(f1)):
884 assert(f3[i] == f1[i])
885
886 f3[0] = 0.25
887 assert(f3[0] != f1[0])
888
889 f3 = f1[2:4]
890 assert(len(f3) == 2)
891 assert(f3[0] == f1[2] and f3[1] == f1[3])
892
893 # Test array-array operations
894 f1 = FloatTypeArray(5)
895 f2 = FloatTypeArray(5)
896
897 # These values were chosen to allow division operations
898 # to return exact values that can be compared with '=='
899
900 f1[0] = 1.25
901 f1[1] = 2.0
902 f1[2] = 3.0
903 f1[3] = 1.0
904 f1[4] = 3.75
905
906 f2[0] = 5.0
907 f2[1] = 2.0
908 f2[2] = 1.5
909 f2[3] = 2.0
910 f2[4] = 10.0
911
912 testVectorVectorArithmeticOps(f1, f2)
913 testVectorVectorInPlaceArithmeticOps(f1, f2)
914
915 # Test operations for arrays with scalars
916 testVectorScalarArithmeticOps(f1, 1.75)
917 testVectorScalarInPlaceArithmeticOps(f1, 0.25)
918 testVectorScalarComparisonOps(f1, 3.5)
919 testVectorScalarInequalityOps(f1, 3.5)
920
921 # Make sure that operations fail when performed on arrays
922 # of differing lengths
923 f3 = FloatTypeArray(6)
924
925 assertVectorVectorArithmeticOpFailures(f1, f3)
926 assertVectorVectorInPlaceArithmeticOpFailures(f1, f3)
927 assertVectorVectorComparisonOpFailures(f1, f3)
928 assertPowFunctionFailures(f1, f3)
929
930 testPowFunctions(f1, f2)
931
932 print ("ok")
933
934 testList.append(('testNonMaskedFloatArray', lambda : testNonMaskedFloatTypeArray(FloatArray)))
935 testList.append(('testNonMaskedDoubleArray', lambda : testNonMaskedFloatTypeArray(DoubleArray)))
936
937 def testNonMaskedIntTypeArray(IntTypeArray):
938 f1 = IntTypeArray(5)
939 assert (len(f1) == 5)
940
941 # Check for correct initialization
942 for i in range(0, len(f1)):
943 assert(f1[i] == 0)
944
945 f1 = IntTypeArray(3, 10)
946 assert(len(f1) == 10)
947 for i in range(0, len(f1)):
948 assert(f1[i] == 3)
949
950 # Ensure that an exception is thrown when
951 # we exceed the bounds of the array
952 try:
953 print (f1[10])
954 except:
955 pass
956 else:
957 assert(false)
958
959 # Check element assignment
960 f1[0] = 1
961 f1[1] = 2
962
963 assert(f1[0] == 1)
964 assert(f1[1] == 2)
965
966 # Test copy construction
967 f2 = IntTypeArray(f1)
968 assert(len(f2) == len(f1))
969 for i in range(0, len(f1)):
970 assert f1[i] == f2[i]
971
972 # The same internal data is referenced by both arrays
973 f2[3] = 4
974 assert(f2[3] == 4)
975 assert(f1[3] == 4)
976 f1[4] = 5
977 assert(f1[4] == 5)
978 assert(f2[4] == 5)
979
980 # Test negative indices
981 assert(f2[-1] == f2[len(f2)-1])
982 assert(f2[-2] == f2[len(f2)-2])
983
984 # Test slice operations
985
986 # Copy contents of f1
987 f3 = f1[:]
988 assert(len(f3) == len(f1))
989
990 for i in range(0, len(f1)):
991 assert(f3[i] == f1[i])
992
993 f3[0] = 4
994 assert(f3[0] != f1[0])
995
996 f3 = f1[2:4]
997 assert(len(f3) == 2)
998 assert(f3[0] == f1[2] and f3[1] == f1[3])
999
1000 # Test array-array operations
1001 f1 = IntTypeArray(5)
1002 f2 = IntTypeArray(5)
1003
1004 # These values were chosen to allow division operations
1005 # to return exact values that can be compared with '=='
1006
1007 f1[0] = 1
1008 f1[1] = 2
1009 f1[2] = 3
1010 f1[3] = 1
1011 f1[4] = 7
1012
1013 f2[0] = 5
1014 f2[1] = 2
1015 f2[2] = 1
1016 f2[3] = 2
1017 f2[4] = 10
1018
1019 testVectorVectorArithmeticOps(f1, f2)
1020 testVectorVectorInPlaceArithmeticOps(f1, f2)
1021 testVectorVectorComparisonOps(f1, f2)
1022 testVectorVectorInequalityOps(f1, f2)
1023
1024 # Test operations for arrays with scalars
1025 testVectorScalarArithmeticOps(f1, 2)
1026 testVectorScalarInPlaceArithmeticOps(f1, 4)
1027 testVectorScalarComparisonOps(f1, 7)
1028 testVectorScalarInequalityOps(f1, 7)
1029
1030 testModOps(f1, f2)
1031
1032 # Make sure that operations fail when performed on arrays
1033 # of differing lengths
1034 f3 = IntTypeArray(6)
1035
1036 assertVectorVectorArithmeticOpFailures(f1, f3)
1037 assertVectorVectorInPlaceArithmeticOpFailures(f1, f3)
1038 assertVectorVectorComparisonOpFailures(f1, f3)
1039 assertModOpFailures(f1, f3)
1040
1041 print ("ok")
1042
1043 testList.append(('testNonMaskedIntArray', lambda : testNonMaskedIntTypeArray(IntArray)))
1044 testList.append(('testNonMaskedShortArray', lambda : testNonMaskedIntTypeArray(ShortArray)))
1045 #testList.append(('testNonMaskedUnsignedCharArray', lambda : testNonMaskedIntTypeArray(UnsignedCharArray))) # arithmetic tests will fail this
1046
1047 def testMaskedFloatTypeArray(FloatTypeArray):
1048 f = FloatTypeArray(10)
1049
1050 f[0] = 1.25
1051 f[1] = 2.5
1052 f[2] = 1.0
1053 f[3] = 1.75
1054 f[4] = 5.25
1055 f[5] = 7.0
1056 f[6] = 4.25
1057 f[7] = 1.0
1058 f[8] = 0.5
1059 f[9] = 3.5
1060
1061 # Ensure we can't create a masked array if the indices don't match
1062 m1 = IntArray(9)
1063 try:
1064 mf = f[m1]
1065 except:
1066 pass
1067 else:
1068 assert(false)
1069
1070 m1 = IntArray(len(f))
1071 m1[0] = 1
1072 m1[1] = 0
1073 m1[2] = 0
1074 m1[3] = 1
1075 m1[4] = 1
1076 m1[5] = 0
1077 m1[6] = 0
1078 m1[7] = 1
1079 m1[8] = 0
1080 m1[9] = 1
1081
1082 # Ensure the masked array reports the correct reduced length
1083 mf = f[m1]
1084 assert(len(mf) == numNonZeroMaskEntries(m1))
1085
1086 # Ensure the masked array holds the correct values
1087 assert(mf[0] == 1.25)
1088 assert(mf[1] == 1.75)
1089 assert(mf[2] == 5.25)
1090 assert(mf[3] == 1.0)
1091 assert(mf[4] == 3.5)
1092
1093 # Masked arrays reference the same internal data
1094 f[9] = 1.75
1095 assert(mf[4] == 1.75)
1096 mf[3] = 10.5
1097 assert(f[7] == 10.5)
1098
1099 # Test copy construction of masked references
1100 g = FloatTypeArray(mf)
1101
1102 # Check slices of masks
1103 s = mf[1:3]
1104 assert(len(s) == 2)
1105 assert(s[0] == mf[1])
1106 assert(s[1] == mf[2])
1107
1108 assert(mf[-1] == mf[len(mf)-1])
1109 assert(mf[-2] == mf[len(mf)-2])
1110
1111 # Check that slices copy (not reference) array data
1112 s = mf[:]
1113 assert(len(s) == len(mf))
1114 for i in range(0, len(mf)):
1115 assert(s[i] == mf[i])
1116
1117 s[0] = 0
1118 assert(s[0] != mf[0])
1119
1120 # Test operations with masked arrays
1121 # Masked arrays should behave exactly as ordinary arrays
1122
1123 m2 = IntArray(len(f))
1124 m2[0] = 1
1125 m2[1] = 0
1126 m2[2] = 1
1127 m2[3] = 0
1128 m2[4] = 1
1129 m2[5] = 1
1130 m2[6] = 0
1131 m2[7] = 0
1132 m2[8] = 1
1133 m2[9] = 1
1134
1135 # m1 and m2 differ in the number of non-zero entries.
1136 # Ensure that arithmetic operations with masked arrays
1137 # cannot proceed if they have differing lengths
1138
1139 mf1 = f[m1]
1140 mf2 = f[m2]
1141
1142 assertVectorVectorInPlaceArithmeticOpFailures(mf1, mf2)
1143
1144 # Test that the operations still fail when the number
1145 # of non-zero mask entries is the same
1146
1147 m2[9] = 0
1148
1149 assert(numNonZeroMaskEntries(m1) == numNonZeroMaskEntries(m2))
1150
1151 mf2 = f[m2]
1152
1153 # Aritmetic operations and comparison ops are supported
1154 testVectorVectorArithmeticOps(mf1, mf2)
1155 testVectorVectorComparisonOps(mf1, mf2)
1156 testVectorVectorInequalityOps(mf1, mf2)
1157
1158 # Test operations between masked arrays and non-masked arrays
1159 assert(len(mf1) == 5);
1160 g = FloatTypeArray(5)
1161 g[0] = 0.25
1162 g[1] = 1.75
1163 g[2] = 3.0
1164 g[3] = 4.25
1165 g[4] = 5.75
1166
1167 testVectorVectorArithmeticOps(g, mf1)
1168 testVectorVectorComparisonOps(g, mf1)
1169 testVectorVectorInequalityOps(g, mf1)
1170
1171 assert(len(f) == 10)
1172 g = FloatTypeArray(10)
1173 g[0] = 0.75
1174 g[1] = 1.25
1175 g[2] = 6.0
1176 g[3] = 4.25
1177 g[4] = 1.5
1178 g[5] = 8.0
1179 g[6] = 3.5
1180 g[7] = 2.0
1181 g[8] = 1.75
1182 g[9] = 6.5
1183
1184 testVectorVectorMaskedInPlaceArithmeticOps(f, g, m1)
1185 testVectorVectorMaskedInPlaceArithmeticOps2(f, g[m1], m1)
1186 testVectorVectorMaskedInPlaceArithmeticOps2(f, g[m2][:], m1)
1187 testVectorVectorMaskedArithmeticOps(f, g, f / 2.0, m1)
1188
1189 print ("ok")
1190
1191 testList.append(('testMaskedFloatArray', lambda : testMaskedFloatTypeArray(FloatArray)))
1192 testList.append(('testMaskedDoubleArray', lambda : testMaskedFloatTypeArray(DoubleArray)))
1193
1194
1195 def testMaskedIntTypeArray(IntTypeArray):
1196 f = IntTypeArray(10)
1197
1198 f[0] = 1
1199 f[1] = 2
1200 f[2] = 9
1201 f[3] = 1
1202 f[4] = 5
1203 f[5] = 7
1204 f[6] = 4
1205 f[7] = 1
1206 f[8] = 6
1207 f[9] = 3
1208
1209 # Ensure we can't create a masked array if the indices don't match
1210 m1 = IntArray(9)
1211 try:
1212 mf = f[m1]
1213 except:
1214 pass
1215 else:
1216 assert(false)
1217
1218 m1 = IntArray(len(f))
1219 m1[0] = 1
1220 m1[1] = 0
1221 m1[2] = 0
1222 m1[3] = 1
1223 m1[4] = 1
1224 m1[5] = 0
1225 m1[6] = 0
1226 m1[7] = 1
1227 m1[8] = 0
1228 m1[9] = 1
1229
1230 # Ensure the masked array reports the correct reduced length
1231 mf = f[m1]
1232 assert(len(mf) == numNonZeroMaskEntries(m1))
1233
1234 # Ensure the masked array holds the correct values
1235 assert(mf[0] == 1)
1236 assert(mf[1] == 1)
1237 assert(mf[2] == 5)
1238 assert(mf[3] == 1)
1239 assert(mf[4] == 3)
1240
1241 # Masked arrays reference the same internal data
1242 f[9] = 4
1243 assert(mf[4] == 4)
1244 mf[3] = 5
1245 assert(f[7] == 5)
1246
1247 # Test copy construction of masked references
1248 g = IntTypeArray(mf)
1249
1250 # Check slices of masks
1251 s = mf[1:3]
1252 assert(len(s) == 2)
1253 assert(s[0] == mf[1])
1254 assert(s[1] == mf[2])
1255
1256 assert(mf[-1] == mf[len(mf)-1])
1257 assert(mf[-2] == mf[len(mf)-2])
1258
1259 # Check that slices copy (not reference) array data
1260 s = mf[:]
1261 assert(len(s) == len(mf))
1262 for i in range(0, len(mf)):
1263 assert(s[i] == mf[i])
1264
1265 s[0] = 0
1266 assert(s[0] != mf[0])
1267
1268 # Test operations with masked arrays
1269 # Masked arrays should behave exactly as ordinary arrays
1270
1271 m2 = IntArray(len(f))
1272 m2[0] = 1
1273 m2[1] = 0
1274 m2[2] = 1
1275 m2[3] = 0
1276 m2[4] = 1
1277 m2[5] = 1
1278 m2[6] = 0
1279 m2[7] = 0
1280 m2[8] = 1
1281 m2[9] = 1
1282
1283 # m1 and m2 differ in the number of non-zero entries.
1284 # Ensure that arithmetic operations with masked arrays
1285 # cannot proceed if they have differing lengths
1286
1287 mf1 = f[m1]
1288 mf2 = f[m2]
1289
1290 assertVectorVectorInPlaceArithmeticOpFailures(mf1, mf2)
1291
1292 # Test that the operations still fail when the number
1293 # of non-zero mask entries is the same
1294
1295 m2[9] = 0
1296
1297 assert(numNonZeroMaskEntries(m1) == numNonZeroMaskEntries(m2))
1298
1299 mf2 = f[m2]
1300
1301 #assertVectorVectorInPlaceArithmeticOpFailures(mf1, mf2)
1302
1303 # Aritmetic operations and comparison ops are supported
1304 testVectorVectorArithmeticOps(mf1, mf2)
1305 testVectorVectorComparisonOps(mf1, mf2)
1306 testVectorVectorInequalityOps(mf1, mf2)
1307
1308 # Test operations between masked arrays and non-masked arrays
1309 assert(len(mf1) == 5);
1310 g = IntTypeArray(5)
1311 g[0] = 2
1312 g[1] = 1
1313 g[2] = 5
1314 g[3] = 4
1315 g[4] = 8
1316
1317 testVectorVectorArithmeticOps(g, mf1)
1318 testVectorVectorComparisonOps(g, mf1)
1319 testVectorVectorInequalityOps(g, mf1)
1320
1321 assert(len(f) == 10)
1322 g = IntTypeArray(10)
1323 g[0] = 5
1324 g[1] = 11
1325 g[2] = 3
1326 g[3] = 4
1327 g[4] = 1
1328 g[5] = 8
1329 g[6] = 6
1330 g[7] = 2
1331 g[8] = 1
1332 g[9] = 7
1333
1334 testVectorVectorMaskedInPlaceArithmeticOps(f, g, m1)
1335 testVectorVectorMaskedInPlaceArithmeticOps2(f, g[m1], m1)
1336 testVectorVectorMaskedInPlaceArithmeticOps2(f, g[m2][:], m1)
1337 testVectorVectorMaskedArithmeticOps(f, g, f / 2, m1)
1338
1339 print ("ok")
1340
1341 testList.append(('testMaskedIntArray', lambda : testMaskedIntTypeArray(IntArray)))
1342 testList.append(('testMaskedShortArray', lambda : testMaskedIntTypeArray(ShortArray)))
1343
1344 def testNonMaskedVecTypeArray(VecTypeArray):
1345 base_type = ArrayBaseType[VecTypeArray]
1346 vec_base_type = VecBaseType[base_type]
1347
1348 f1 = VecTypeArray(5)
1349 assert (len(f1) == 5)
1350
1351 # Check for correct initialization
1352 for i in range(0, len(f1)):
1353 assert(f1[i] == base_type(0))
1354
1355 v = None
1356 if dimensions(base_type) == 2:
1357 v = base_type(1.25, 3.75)
1358 elif base_type.dimensions() == 3:
1359 v = base_type(1.25, 3.75, 2.0)
1360 else:
1361 assert(False)
1362
1363 f1 = VecTypeArray(v, 10)
1364 assert(len(f1) == 10)
1365 for i in range(0, len(f1)):
1366 assert(f1[i] == v)
1367
1368 # Ensure that an exception is thrown when
1369 # we exceed the bounds of the array
1370 try:
1371 print (f1[10])
1372 except:
1373 pass
1374 else:
1375 assert(False)
1376
1377 # Check element assignment
1378
1379 v1 = None
1380 v2 = None
1381
1382 if dimensions(base_type) == 2:
1383 v1 = base_type(1.5, 0.75)
1384 v2 = base_type(4.25, 7.5)
1385 elif dimensions(base_type) == 3:
1386 v1 = base_type(1.5, 0.75, 5.0)
1387 v2 = base_type(4.25, 7.5, 2.25)
1388 else:
1389 assert(False)
1390
1391 f1[0] = v1
1392 f1[1] = v2
1393
1394 assert(f1[0] == v1)
1395 assert(f1[1] == v2)
1396
1397 # Test copy construction
1398 f2 = VecTypeArray(f1)
1399 assert(len(f2) == len(f1))
1400 for i in range(0, len(f1)):
1401 assert f1[i] == f2[i]
1402
1403 # The same internal data is referenced by both arrays
1404 v = None
1405 if dimensions(base_type) == 2:
1406 v = base_type(4.5, 1.75)
1407 elif base_type.dimensions() == 3:
1408 v = base_type(4.5, 1.75, 6.0)
1409 else:
1410 assert(False)
1411
1412 f2[3] = v
1413 assert(f2[3] == v)
1414 assert(f1[3] == v)
1415
1416 f1[4] = 2*v
1417 assert(f1[4] == 2*v)
1418 assert(f2[4] == 2*v)
1419
1420 # Test negative indices
1421 assert(f2[-1] == f2[len(f2)-1])
1422 assert(f2[-2] == f2[len(f2)-2])
1423
1424 # Test slice operations
1425
1426 # Copy contents of f1
1427 f3 = f1[:]
1428 assert(len(f3) == len(f1))
1429
1430 for i in range(0, len(f1)):
1431 assert(f3[i] == f1[i])
1432
1433 v = None
1434 if dimensions(base_type) == 2:
1435 v = base_type(0.25, 5.25)
1436 elif base_type.dimensions() == 3:
1437 v = base_type(0.25, 5.25, 1.0)
1438
1439 assert(v is not None)
1440
1441 f3[0] = v
1442 assert(f3[0] != f1[0])
1443
1444 f3 = f1[2:4]
1445 assert(len(f3) == 2)
1446 assert(f3[0] == f1[2] and f3[1] == f1[3])
1447
1448 # Test array-array operations
1449 f1 = VecTypeArray(5)
1450 f2 = VecTypeArray(5)
1451
1452 # These values were chosen to allow division operations
1453 # to return exact values that can be compared with '=='
1454
1455 if dimensions(base_type) == 2:
1456 f1[0] = base_type(1.25, 2.5)
1457 f1[1] = base_type(2.0, 7.25)
1458 f1[2] = base_type(3.0, 9.0)
1459 f1[3] = base_type(1.0, 8.5)
1460 f1[4] = base_type(3.75, 3.25)
1461
1462 f2[0] = base_type(5.0, 4.25)
1463 f2[1] = base_type(2.0, 3.5)
1464 f2[2] = base_type(1.5, 6.0)
1465 f2[3] = base_type(2.0, 7.25)
1466 f2[4] = base_type(10.0, 11.0)
1467
1468 elif dimensions(base_type) == 3:
1469 f1[0] = base_type(1.25, 2.5, 11.75)
1470 f1[1] = base_type(2.0, 7.25, 4.0)
1471 f1[2] = base_type(3.0, 9.0, 12.25)
1472 f1[3] = base_type(1.0, 8.5, 6.5)
1473 f1[4] = base_type(3.75, 0.25, 5.25)
1474
1475 f2[0] = base_type(5.0, 4.25, 5.75)
1476 f2[1] = base_type(2.0, 3.5, 8.0)
1477 f2[2] = base_type(1.5, 6.0, 12.5)
1478 f2[3] = base_type(2.0, 7.25, 15.0)
1479 f2[4] = base_type(10.0, 11.0, 1.25)
1480
1481 testVectorVectorArithmeticOps(f1, f2)
1482 testVectorVectorInPlaceArithmeticOps(f1, f2)
1483 testUnaryVecMethods(f1)
1484 testBinaryVecMethods(f1, f2)
1485
1486 if dimensions(base_type) == 2:
1487 v = base_type(1.25, 5.25)
1488 elif dimensions(base_type) == 3:
1489 v = base_type(1.25, 5.25, 1.0)
1490 else:
1491 assert(False)
1492
1493 assert(v is not None)
1494
1495 # Test operations for arrays with scalars
1496 testVectorScalarArithmeticOps(f1, v)
1497 testVectorScalarInPlaceArithmeticOps(f1, v)
1498 testVectorScalarComparisonOps(f1, v)
1499
1500 # Test multiplication and division by vector base types
1501 v = vec_base_type(4.25)
1502
1503 f = f1 * v
1504 assert(len(f) == len(f1))
1505 for i in range(0, len(f)):
1506 assert(f[i] == f1[i] * v)
1507
1508 f = v * f1
1509 assert(len(f) == len(f1))
1510 for i in range(0, len(f)):
1511 assert(f[i] == v * f1[i])
1512
1513 f = f1 / v
1514 assert(len(f) == len(f1))
1515 for i in range(0, len(f)):
1516 assert(equalWithAbsError(f[i], f1[i] / v, eps))
1517
1518
1519 # Make sure that operations fail when performed on arrays
1520 # of differing lengths
1521 f3 = VecTypeArray(6)
1522
1523 assertVectorVectorArithmeticOpFailures(f1, f3)
1524 assertVectorVectorInPlaceArithmeticOpFailures(f1, f3)
1525
1526 print ("ok")
1527
1528 testList.append(('testNonMaskedV2sArray', lambda : testNonMaskedVecTypeArray(V2sArray)))
1529 testList.append(('testNonMaskedV2iArray', lambda : testNonMaskedVecTypeArray(V2iArray)))
1530 testList.append(('testNonMaskedV2fArray', lambda : testNonMaskedVecTypeArray(V2fArray)))
1531 testList.append(('testNonMaskedV2dArray', lambda : testNonMaskedVecTypeArray(V2dArray)))
1532 testList.append(('testNonMaskedV3sArray', lambda : testNonMaskedVecTypeArray(V3sArray)))
1533 testList.append(('testNonMaskedV3iArray', lambda : testNonMaskedVecTypeArray(V3iArray)))
1534 testList.append(('testNonMaskedV3fArray', lambda : testNonMaskedVecTypeArray(V3fArray)))
1535 testList.append(('testNonMaskedV3dArray', lambda : testNonMaskedVecTypeArray(V3dArray)))
1536
1537
1538 def testMaskedVecTypeArray(VecTypeArray):
1539 base_type = ArrayBaseType[VecTypeArray]
1540 vec_base_type = VecBaseType[base_type]
1541
1542 f = VecTypeArray(10)
1543
1544 if dimensions(base_type) == 2:
1545 f[0] = base_type(1.25, 5.25)
1546 f[1] = base_type(2.5, 6.0)
1547 f[2] = base_type(1.0, 3.75)
1548 f[3] = base_type(1.75, 11.25)
1549 f[4] = base_type(5.25, 12.0)
1550 f[5] = base_type(7.0, 4.5)
1551 f[6] = base_type(4.25, 6.5)
1552 f[7] = base_type(1.0, 2.25)
1553 f[8] = base_type(1.5, 1.75)
1554 f[9] = base_type(3.5, 4.0)
1555 elif dimensions(base_type) == 3:
1556 f[0] = base_type(1.25, 5.25, 8.5)
1557 f[1] = base_type(2.5, 6.0, 7.25)
1558 f[2] = base_type(1.0, 3.75, 15.5)
1559 f[3] = base_type(1.75, 11.25, 10.0)
1560 f[4] = base_type(5.25, 12.0, 16.5)
1561 f[5] = base_type(7.0, 4.5, 1.25)
1562 f[6] = base_type(4.25, 6.5, 9.25)
1563 f[7] = base_type(1.0, 2.25, 5.0)
1564 f[8] = base_type(1.5, 1.75, 7.5)
1565 f[9] = base_type(3.5, 4.0, 5.75)
1566
1567 # Ensure we can't create a masked array if the indices don't match
1568 m1 = IntArray(9)
1569 try:
1570 mf = f[m1]
1571 except:
1572 pass
1573 else:
1574 assert(false)
1575
1576 m1 = IntArray(len(f))
1577 m1[0] = 1
1578 m1[1] = 0
1579 m1[2] = 0
1580 m1[3] = 1
1581 m1[4] = 1
1582 m1[5] = 0
1583 m1[6] = 0
1584 m1[7] = 1
1585 m1[8] = 0
1586 m1[9] = 1
1587
1588 # Ensure the masked array reports the correct reduced length
1589 mf = f[m1]
1590 assert(len(mf) == numNonZeroMaskEntries(m1))
1591
1592 # Ensure the masked array holds the correct values
1593 assert(mf[0] == f[0])
1594 assert(mf[1] == f[3])
1595 assert(mf[2] == f[4])
1596 assert(mf[3] == f[7])
1597 assert(mf[4] == f[9])
1598
1599 # Masked arrays reference the same internal data
1600 v = None
1601 if dimensions(base_type) == 2:
1602 v = base_type(1.75, 2.5)
1603 elif dimensions(base_type) == 3:
1604 v = base_type(1.75, 2.5, 9.25)
1605 else:
1606 assert(False)
1607
1608 f[9] = v
1609 assert(mf[4] == v)
1610
1611 mf[3] = 2*v
1612 assert(f[7] == 2*v)
1613
1614 # Test copy construction of masked references
1615 g = VecTypeArray(mf)
1616
1617 # Check slices of masks
1618 s = mf[1:3]
1619 assert(len(s) == 2)
1620 assert(s[0] == mf[1])
1621 assert(s[1] == mf[2])
1622
1623 assert(mf[-1] == mf[len(mf)-1])
1624 assert(mf[-2] == mf[len(mf)-2])
1625
1626 # Check that slices copy (not reference) array data
1627 s = mf[:]
1628 assert(len(s) == len(mf))
1629 for i in range(0, len(mf)):
1630 assert(s[i] == mf[i])
1631
1632 s[0] = base_type(0)
1633 assert(s[0] != mf[0])
1634
1635 # Test operations with masked arrays
1636 # Masked arrays should behave exactly as ordinary arrays
1637
1638 m2 = IntArray(len(f))
1639 m2[0] = 1
1640 m2[1] = 0
1641 m2[2] = 1
1642 m2[3] = 0
1643 m2[4] = 1
1644 m2[5] = 1
1645 m2[6] = 0
1646 m2[7] = 0
1647 m2[8] = 1
1648 m2[9] = 1
1649
1650 # m1 and m2 differ in the number of non-zero entries.
1651 # Ensure that arithmetic operations with masked arrays
1652 # cannot proceed if they have differing lengths
1653
1654 mf1 = f[m1]
1655 mf2 = f[m2]
1656
1657 assertVectorVectorInPlaceArithmeticOpFailures(mf1, mf2)
1658
1659 # Test that the operations still fail when the number
1660 # of non-zero mask entries is the same
1661
1662 m2[9] = 0
1663
1664 assert(numNonZeroMaskEntries(m1) == numNonZeroMaskEntries(m2))
1665
1666 mf2 = f[m2]
1667
1668 # Aritmetic operations and comparison ops are supported
1669 testVectorVectorArithmeticOps(mf1, mf2)
1670 testVectorVectorComparisonOps(mf1, mf2)
1671
1672 # Test operations between masked arrays and non-masked arrays
1673 assert(len(mf1) == 5);
1674 g = VecTypeArray(5)
1675
1676 if dimensions(base_type) == 2:
1677 g[0] = base_type(5.25, 2.75)
1678 g[1] = base_type(1.75, 11.5)
1679 g[2] = base_type(3.0, 8.25)
1680 g[3] = base_type(4.25, 6.75)
1681 g[4] = base_type(5.75, 12.0)
1682 elif dimensions(base_type) == 3:
1683 g[0] = base_type(5.25, 2.75, 1.0)
1684 g[1] = base_type(1.75, 11.5, 15.25)
1685 g[2] = base_type(3.0, 8.25, 9.0)
1686 g[3] = base_type(4.25, 6.75, 1.25)
1687 g[4] = base_type(5.75, 12.0, 7.5)
1688 else:
1689 assert(False)
1690
1691 testVectorVectorArithmeticOps(g, mf1)
1692 testVectorVectorComparisonOps(g, mf1)
1693
1694 testUnaryVecMethods(g)
1695 testBinaryVecMethods(g, mf1)
1696 testBinaryVecMethods(mf1, mf2)
1697
1698 assert(len(f) == 10)
1699 g = VecTypeArray(10)
1700
1701 if dimensions(base_type) == 2:
1702 g[0] = base_type(5.25, 2.75)
1703 g[1] = base_type(1.75, 11.5)
1704 g[2] = base_type(3.0, 8.25)
1705 g[3] = base_type(4.25, 6.75)
1706 g[4] = base_type(5.75, 12.0)
1707 g[5] = base_type(8.0, 5.25)
1708 g[6] = base_type(3.5, 4.0)
1709 g[7] = base_type(2.0, 12.5)
1710 g[8] = base_type(1.75, 6.75)
1711 g[9] = base_type(6.5, 8.0)
1712 elif dimensions(base_type) == 3:
1713 g[0] = base_type(5.25, 2.75, 1.0)
1714 g[1] = base_type(1.75, 11.5, 15.25)
1715 g[2] = base_type(3.0, 8.25, 9.0)
1716 g[3] = base_type(4.25, 6.75, 1.25)
1717 g[4] = base_type(5.75, 12.0, 7.5)
1718 g[5] = base_type(8.0, 5.25, 12.25)
1719 g[6] = base_type(3.5, 4.0, 6.0)
1720 g[7] = base_type(2.0, 12.5, 16.5)
1721 g[8] = base_type(1.75, 6.75, 4.25)
1722 g[9] = base_type(6.5, 8.0, 7.75)
1723 else:
1724 assert(False)
1725
1726 testVectorVectorMaskedInPlaceArithmeticOps(f, g, m1)
1727 testVectorVectorMaskedInPlaceArithmeticOps2(f, g[m1], m1)
1728 testVectorVectorMaskedInPlaceArithmeticOps2(f, g[m2][:], m1)
1729
1730 v = None
1731 if dimensions(base_type) == 2:
1732 v = base_type(1.25, 3.75)
1733 elif base_type.dimensions() == 3:
1734 v = base_type(1.25, 3.75, 2.0)
1735 else:
1736 assert(False)
1737
1738 assert(v is not None)
1739
1740 # Test operations for arrays with scalars
1741 testVectorScalarArithmeticOps(g, v)
1742 testVectorScalarInPlaceArithmeticOps(g, v)
1743 testVectorScalarComparisonOps(g, v)
1744
1745 testVectorVectorMaskedArithmeticOps(f, f, f, m1)
1746
1747 # Test multiplication and division by vector base types
1748 v = vec_base_type(4.25)
1749
1750 f = g * v
1751 assert(len(f) == len(g))
1752 for i in range(0, len(f)):
1753 assert(f[i] == g[i] * v)
1754
1755 f = v * g
1756 assert(len(f) == len(g))
1757 for i in range(0, len(f)):
1758 assert(f[i] == v * g[i])
1759
1760 f = g / v
1761 assert(len(f) == len(g))
1762 for i in range(0, len(f)):
1763 assert(equalWithAbsError(f[i], g[i] / v, eps))
1764
1765 testVectorVectorMaskedArithmeticOps
1766
1767 print ("ok")
1768
1769 testList.append(('testMaskedV2sArray', lambda : testMaskedVecTypeArray(V2sArray)))
1770 testList.append(('testMaskedV2iArray', lambda : testMaskedVecTypeArray(V2iArray)))
1771 testList.append(('testMaskedV2fArray', lambda : testMaskedVecTypeArray(V2fArray)))
1772 testList.append(('testMaskedV2dArray', lambda : testMaskedVecTypeArray(V2dArray)))
1773 testList.append(('testMaskedV3fArray', lambda : testMaskedVecTypeArray(V3fArray)))
1774 testList.append(('testMaskedV3dArray', lambda : testMaskedVecTypeArray(V3dArray)))
1775
1776
1777 # -------------------------------------------------------------------------
1778 # Tests for functions
1779
1780 def testFun ():
1781
1782 assert sign(5) == 1
1783 assert sign(5.0) == 1
1784 assert sign(-5) == -1
1785 assert sign(-5.0) == -1
1786
1787 assert log(math.e) == 1
1788 assert log(1) == 0
1789
1790 assert log10(10) == 1
1791 assert log10(1) == 0
1792
1793 assert lerp(1, 2, 0.5) == 1.5
1794 assert lerp(1.0, 2.0, 0.5) == 1.5
1795 assert lerp(2, 1, 0.5) == 1.5
1796 assert lerp(2.0, 1.0, 0.5) == 1.5
1797
1798 assert lerpfactor(1.5, 1, 2) == 0.5
1799 assert lerpfactor(1.5, 1.0, 2.0) == 0.5
1800
1801 assert clamp(0, 1, 2) == 1
1802 assert clamp(3, 1, 2) == 2
1803 assert clamp(0.0, 1.0, 2.0) == 1
1804 assert clamp(3.0, 1.0, 2.0) == 2
1805
1806 assert cmp(1, 2) == -1
1807 assert cmp(2, 2) == 0
1808 assert cmp(3, 2) == 1
1809 assert cmp(1.0, 2.0) == -1
1810 assert cmp(2.0, 2.0) == 0
1811 assert cmp(3.0, 2.0) == 1
1812
1813 assert cmpt(1.0, 1.5, 0.1) == -1
1814 assert cmpt(1.5, 1.5, 0.1) == 0
1815 assert cmpt(2.0, 1.5, 0.1) == 1
1816 assert cmpt(1.0, 1.5, 0.6) == 0
1817 assert cmpt(1.5, 1.5, 0.6) == 0
1818 assert cmpt(2.0, 1.5, 0.6) == 0
1819
1820 assert iszero(0, 0) == 1
1821 assert iszero(0, 0.1) == 1
1822 assert iszero(0.01, 0.1) == 1
1823 assert iszero(0.01, 0.001) == 0
1824
1825 assert equal(5, 5, 0) == 1
1826 assert equal(5, 6, 0) == 0
1827 assert equal(5, 5.01, 0.1) == 1
1828 assert equal(5, 5.01, 0.001) == 0
1829
1830 assert trunc(1.1) == 1
1831 assert trunc(-1.1) == -1
1832 assert trunc(1) == 1
1833
1834 assert divs( 4, 2) == 2
1835 assert divs(-4, 2) == -2
1836 assert divs( 4, -2) == -2
1837 assert divs(-4, -2) == 2
1838 assert mods( 3, 2) == 1
1839 assert mods(-3, 2) == -1
1840 assert mods( 3, -2) == 1
1841 assert mods(-3, -2) == -1
1842
1843 assert divp( 4, 2) == 2
1844 assert divp(-4, 2) == -2
1845 assert divp( 4, -2) == -2
1846 assert divp(-4, -2) == 2
1847 assert modp( 3, 2) == 1
1848 assert modp(-3, 2) == 1
1849 assert modp( 3, -2) == 1
1850 assert modp(-3, -2) == 1
1851
1852 print ("ok")
1853
1854 return
1855
1856 testList.append (('testFun',testFun))
1857
1858
1859 # -------------------------------------------------------------------------
1860 # Tests for V2x
1861
1862 def testV2x (Vec):
1863
1864 # Constructors (and element access).
1865
1866 v = Vec()
1867 assert v[0] == 0 and v[1] == 0
1868
1869 v = Vec(1)
1870 assert v[0] == 1 and v[1] == 1
1871
1872 v = Vec(0, 1)
1873 assert v[0] == 0 and v[1] == 1
1874
1875 v = Vec((0, 1))
1876 assert v[0] == 0 and v[1] == 1
1877
1878 v = Vec([0, 1])
1879 assert v[0] == 0 and v[1] == 1
1880
1881 v = Vec()
1882 v.setValue(0, 1)
1883 assert v[0] == 0 and v[1] == 1
1884
1885 # Repr.
1886
1887 v = Vec(1/9., 2/9.)
1888 assert v == eval(repr(v))
1889
1890 # Sequence length.
1891
1892 v = Vec()
1893 assert len(v) == 2
1894
1895 # Element setting.
1896
1897 v = Vec()
1898 v[0] = 10
1899 v[1] = 11
1900 assert v[0] == 10 and v[1] == 11
1901
1902 try:
1903 v[-3] = 0 # This should raise an exception.
1904 except:
1905 pass
1906 else:
1907 assert 0 # We shouldn't get here.
1908
1909 try:
1910 v[3] = 0 # This should raise an exception.
1911 except:
1912 pass
1913 else:
1914 assert 0 # We shouldn't get here.
1915
1916 try:
1917 v[1] = "a" # This should raise an exception.
1918 except:
1919 pass
1920 else:
1921 assert 0 # We shouldn't get here.
1922
1923 # Assignment.
1924
1925 v1 = Vec(1)
1926
1927 v2 = v1
1928 assert v2[0] == 1 and v2[1] == 1
1929 v1[0] = 2
1930 assert v2[0] == 2 and v2[1] == 1
1931
1932 # Comparison operators.
1933
1934 v1 = Vec(20, 20)
1935 v2 = Vec(20, 20)
1936 v3 = Vec(20, 21)
1937
1938 assert v1 == v2
1939 assert v1 != v3
1940 assert not (v1 < v2)
1941 assert v1 < v3
1942 assert v1 <= v2
1943 assert v1 <= v3
1944 assert not (v3 <= v1)
1945 assert not (v2 > v1)
1946 assert v3 > v1
1947 assert v2 >= v1
1948 assert v3 >= v1
1949 assert not (v1 >= v3)
1950
1951 # Epsilon equality.
1952
1953 e = 0.005
1954 v1 = Vec(1)
1955 v2 = Vec(1 + e)
1956
1957 assert v1.equalWithAbsError(v2, e)
1958 assert v2.equalWithAbsError(v1, e)
1959
1960 e = 0.003
1961 v1 = Vec(10)
1962 v2 = Vec(10 + 10 * e)
1963
1964 assert v1.equalWithRelError(v2, e)
1965 assert v2.equalWithRelError(v1, e)
1966
1967 # Dot products.
1968
1969 v1 = Vec(0, 1)
1970 v2 = Vec(1, 0)
1971 v3 = Vec(1, 1)
1972
1973 assert v1.dot(v2) == 0
1974 assert v1.dot(v3) == 1
1975 assert v1 ^ v2 == v1.dot(v2)
1976 assert v1 ^ v3 == v1.dot(v3)
1977
1978 # Cross products.
1979
1980 v1 = Vec(1, 0)
1981 v2 = Vec(0, 1)
1982
1983 assert v1.cross(v2) == 1
1984 assert v2.cross(v1) == -1
1985 assert v1 % v2 == v1.cross(v2)
1986 assert v2 % v1 == v2.cross(v1)
1987
1988 # Addition.
1989
1990 v1 = Vec(10, 20)
1991 v2 = Vec(30, 40)
1992
1993 assert v1 + v2 == Vec(40, 60)
1994 assert v2 + v1 == v1 + v2
1995 assert v1 + 1 == Vec(11, 21)
1996 assert 1 + v1 == v1 + 1
1997
1998 # (with the switch to python2, we now allow ops between vectors and tuples)
1999 assert v1 + (1, 2) == Vec(11, 22)
2000 assert (1, 2) + v1 == v1 + (1, 2)
2001
2002 # Subtraction and negation.
2003
2004 v1 = Vec(10, 20)
2005 v2 = Vec(30, 40)
2006
2007 assert v2 - v1 == Vec(20, 20)
2008 assert v1 - 1 == Vec(9, 19)
2009 assert 1 - v1 == - (v1 - 1)
2010
2011 # (with the switch to python2, we now allow ops between vectors and tuples)
2012 assert v1 - (1, 2) == Vec(9, 18)
2013 assert (1, 2) - v1 == - (v1 - (1, 2))
2014
2015 assert v1.negate() == Vec(-10, -20)
2016
2017 # Multiplication.
2018
2019 v1 = Vec(1, 2)
2020 v2 = Vec(3, 4)
2021
2022 assert v1 * v2 == Vec(3, 8)
2023 assert v2 * v1 == v1 * v2
2024 assert 2 * v1 == Vec(2, 4)
2025 assert v1 * 2 == 2 * v1
2026
2027 assert v1 * V2i(3, 4) == Vec(3, 8)
2028 assert v1 * V2f(3, 4) == Vec(3, 8)
2029 assert v1 * V2d(3, 4) == Vec(3, 8)
2030
2031 v1 *= 2
2032 assert v1 == Vec(2, 4)
2033 v1 = Vec(1, 2)
2034
2035 # (with the switch to python2, we now allow ops between vectors and tuples)
2036 assert v1 * (1, 2) == Vec(1, 4)
2037 assert (1, 2) * v1 == v1 * (1, 2)
2038
2039 # Division.
2040
2041 v1 = Vec(10, 20)
2042 v2 = Vec(2, 4)
2043
2044 assert v1 / v2 == Vec(10/2, 20/4)
2045 assert v1 / 2 == Vec(10/2, 20/2)
2046 assert Vec(40) / v1 == Vec(40/10, 40/20)
2047
2048 # (with the switch to python2, we now allow ops between vectors and tuples)
2049 assert v1 / (1, 2) == Vec(10/1, 20/2)
2050 assert Vec(30, 40) / v1 == Vec(30/10, 40/20)
2051
2052 assert v1 / V2i (2, 4) == Vec(10/2, 20/4)
2053 assert v1 / V2f (2, 4) == Vec(10/2, 20/4)
2054 assert v1 / V2d (2, 4) == Vec(10/2, 20/4)
2055 assert v1 / (2, 4) == Vec(10/2, 20/4)
2056 assert v1 / [2, 4] == Vec(10/2, 20/4)
2057
2058 v1 = Vec(10, 20)
2059 v1 /= 2
2060 assert v1 == Vec(10/2, 20/2)
2061
2062 v1 = Vec(10, 20)
2063 v1 /= V2i (2, 4)
2064 assert v1 == Vec(10/2, 20/4)
2065
2066 v1 = Vec(10, 20)
2067 v1 /= V2f (2, 4)
2068 assert v1 == Vec(10/2, 20/4)
2069
2070 v1 = Vec(10, 20)
2071 v1 /= V2d (2, 4)
2072 assert v1 == Vec(10/2, 20/4)
2073
2074 v1 = Vec(10, 20)
2075 v1 /= (2, 4)
2076 assert v1 == Vec(10/2, 20/4)
2077
2078 v1 = Vec(10, 20)
2079 v1 /= [2, 4]
2080 assert v1 == Vec(10/2, 20/4)
2081
2082 # Length.
2083
2084 if (Vec != V2i):
2085 v = Vec(1, 2)
2086 assert equal(v.length(), sqrt(1*1 + 2*2), v.baseTypeEpsilon())
2087
2088 v = Vec(1, 2)
2089 assert v.length2() == 1*1 + 2*2
2090
2091 # Normalizing.
2092
2093 if (Vec != V2i):
2094 v = Vec(1, 2)
2095 v.normalize()
2096 assert equal(v.length(), 1, v.baseTypeEpsilon())
2097
2098 v = Vec(1, 2)
2099 v.normalizeExc()
2100 assert equal(v.length(), 1, v.baseTypeEpsilon())
2101 v = Vec(0)
2102 try:
2103 v.normalizeExc() # This should raise an exception.
2104 except:
2105 pass
2106 else:
2107 assert 0 # We shouldn't get here.
2108
2109 v = Vec(1, 2)
2110 v.normalizeNonNull()
2111 assert equal(v.length(), 1, v.baseTypeEpsilon())
2112
2113 v = Vec(1, 2)
2114 assert equal(v.normalized().length(), 1, v.baseTypeEpsilon())
2115
2116 v = Vec(1, 2)
2117 assert equal(v.normalizedExc().length(), 1, v.baseTypeEpsilon())
2118 v = Vec(0)
2119 try:
2120 v.normalizedExc() # This should raise an exception.
2121 except:
2122 pass
2123 else:
2124 assert 0 # We shouldn't get here.
2125
2126 v = Vec(1, 2)
2127 assert equal(v.normalizedNonNull().length(), 1, v.baseTypeEpsilon())
2128
2129
2130 # Projection.
2131
2132 if (Vec != V2i):
2133 s = Vec(2, 0)
2134 t = Vec(1, 1)
2135 assert t.project(s) == Vec(1, 0)
2136
2137 # Orthogonal.
2138
2139 if (Vec != V2i):
2140 s = Vec(2, 0)
2141 t = Vec(1, 1)
2142 o = s.orthogonal(t)
2143 assert iszero(o ^ s, s.baseTypeEpsilon())
2144
2145 # Reflect.
2146
2147 if (Vec != V2i):
2148 s = Vec(1, 1)
2149 t = Vec(2, 0)
2150 r = s.reflect(t)
2151 assert equal(abs(s ^ t), abs(r ^ t), s.baseTypeEpsilon())
2152
2153 # Closest vertex.
2154
2155 v0 = Vec(0, 0)
2156 v1 = Vec(5, 0)
2157 v2 = Vec(0, 5)
2158
2159 p = Vec(1, 1)
2160 assert p.closestVertex(v0, v1, v2) == v0
2161
2162 p = Vec(4, 1)
2163 assert p.closestVertex(v0, v1, v2) == v1
2164
2165 p = Vec(1, 4)
2166 assert p.closestVertex(v0, v1, v2) == v2
2167
2168
2169 print ("ok")
2170
2171 return
2172
2173 def testV2 ():
2174
2175 print ("V2i")
2176 testV2x (V2i)
2177 print ("V2f")
2178 testV2x (V2f)
2179 print ("V2d")
2180 testV2x (V2d)
2181
2182 testList.append (('testV2',testV2))
2183
2184
2185 # -------------------------------------------------------------------------
2186 # Tests for V2xArray
2187
2188 def testV2xArray (Array, Vec, Arrayx):
2189
2190 # Constructors (and element access).
2191
2192 a = Array (3)
2193
2194 a[0] = Vec(0)
2195 a[1] = Vec(1)
2196 a[2] = Vec(2)
2197
2198 assert a[0] == Vec(0)
2199 assert a[1] == Vec(1)
2200 assert a[2] == Vec(2)
2201
2202 a[0].setValue(10,10)
2203 a[1].setValue(11,11)
2204 a[2].setValue(12,12)
2205
2206 assert a[0] == Vec(10)
2207 assert a[1] == Vec(11)
2208 assert a[2] == Vec(12)
2209
2210 # Element setting.
2211
2212 a = Array(2)
2213
2214 try:
2215 a[-3] = Vec(0) # This should raise an exception.
2216 except:
2217 pass
2218 else:
2219 assert 0 # We shouldn't get here.
2220
2221 try:
2222 a[3] = Vec(0) # This should raise an exception.
2223 except:
2224 pass
2225 else:
2226 assert 0 # We shouldn't get here.
2227
2228 try:
2229 a[1] = "a" # This should raise an exception.
2230 except:
2231 pass
2232 else:
2233 assert 0 # We shouldn't get here.
2234
2235 # Assignment.
2236
2237 a = Array(2)
2238 a[0] = Vec(0)
2239 a[1] = Vec(1)
2240
2241 b = Array(2)
2242 b[0] = Vec(0)
2243 b[1] = Vec(1)
2244
2245 c = Array(2)
2246 c[0] = Vec(10)
2247 c[1] = Vec(11)
2248
2249 # TODO: make equality work correctly.
2250 #assert a == b
2251 assert a != c
2252
2253 # Dot products.
2254
2255 a = Array(2)
2256 a[0] = Vec(1, 2)
2257 a[1] = Vec(3, 4)
2258
2259 b = Array(2)
2260 b[0] = Vec(5, 6)
2261 b[1] = Vec(7, 8)
2262
2263 r = a.dot(b)
2264 assert r[0] == 1*5 + 2*6
2265 assert r[1] == 3*7 + 4*8
2266
2267 c = Vec(5, 6)
2268 r = a.dot(c)
2269 assert r[0] == 1*5 + 2*6
2270 assert r[1] == 3*5 + 4*6
2271
2272 d = Array(3)
2273 try:
2274 a.dot(d) # This should raise an exception.
2275 except:
2276 pass
2277 else:
2278 assert 0 # We shouldn't get here.
2279
2280
2281 # Cross products.
2282
2283 a = Array(2)
2284 a[0] = Vec(1, 2)
2285 a[1] = Vec(3, 4)
2286
2287 b = Array(2)
2288 b[0] = Vec(5, 6)
2289 b[1] = Vec(7, 8)
2290
2291 r = a.cross(b)
2292 assert r[0] == 1*6 - 2*5
2293 assert r[1] == 3*8 - 4*7
2294
2295 c = Vec(5, 6)
2296 r = a.cross(c)
2297 assert r[0] == 1*6 - 2*5
2298 assert r[1] == 3*6 - 4*5
2299
2300 d = Array(3)
2301 try:
2302 a.cross(d) # This should raise an exception.
2303 except:
2304 pass
2305 else:
2306 assert 0 # We shouldn't get here.
2307
2308 # Addition.
2309
2310 a = Array(2)
2311 a[0] = Vec(1, 2)
2312 a[1] = Vec(3, 4)
2313
2314 b = Array(2)
2315 b[0] = Vec(5, 6)
2316 b[1] = Vec(7, 8)
2317
2318 r = a + b
2319 assert r[0] == Vec(1+5, 2+6)
2320 assert r[1] == Vec(3+7, 4+8)
2321
2322 r = a + Vec(10)
2323 assert r[0] == Vec(1+10, 2+10)
2324 assert r[1] == Vec(3+10, 4+10)
2325
2326 v = Vec(11)
2327 r = v + a
2328 assert r[0] == Vec(11+1, 11+2)
2329 assert r[1] == Vec(11+3, 11+4)
2330
2331 a += b
2332 assert a[0] == Vec(1+5, 2+6)
2333 assert a[1] == Vec(3+7, 4+8)
2334
2335 a[0] = Vec(1, 2)
2336 a[1] = Vec(3, 4)
2337
2338 a += Vec(10)
2339 assert a[0] == Vec(1+10, 2+10)
2340 assert a[1] == Vec(3+10, 4+10)
2341
2342 c = Array(3)
2343
2344 try:
2345 a + c # This should raise an exception.
2346 except:
2347 pass
2348 else:
2349 assert 0 # We shouldn't get here.
2350
2351 try:
2352 a += c # This should raise an exception.
2353 except:
2354 pass
2355 else:
2356 assert 0 # We shouldn't get here.
2357
2358 # Subtraction.
2359
2360 a = Array(2)
2361 a[0] = Vec(1, 2)
2362 a[1] = Vec(3, 4)
2363
2364 b = Array(2)
2365 b[0] = Vec(5, 6)
2366 b[1] = Vec(7, 8)
2367
2368 r = a - b
2369 assert r[0] == Vec(1-5, 2-6)
2370 assert r[1] == Vec(3-7, 4-8)
2371
2372 r = a - Vec(10)
2373 assert r[0] == Vec(1-10, 2-10)
2374 assert r[1] == Vec(3-10, 4-10)
2375
2376 r = Vec(10) - a
2377 assert r[0] == Vec(10-1, 10-2)
2378 assert r[1] == Vec(10-3, 10-4)
2379
2380 v = Vec(11)
2381 r = v - a
2382 assert r[0] == Vec(11-1, 11-2)
2383 assert r[1] == Vec(11-3, 11-4)
2384
2385 a -= b
2386 assert a[0] == Vec(1-5, 2-6)
2387 assert a[1] == Vec(3-7, 4-8)
2388
2389 a[0] = Vec(1, 2)
2390 a[1] = Vec(3, 4)
2391
2392 a -= Vec(10)
2393 assert a[0] == Vec(1-10, 2-10)
2394 assert a[1] == Vec(3-10, 4-10)
2395
2396 c = Array(3)
2397
2398 try:
2399 a - c # This should raise an exception.
2400 except:
2401 pass
2402 else:
2403 assert 0 # We shouldn't get here.
2404
2405 try:
2406 a -= c # This should raise an exception.
2407 except:
2408 pass
2409 else:
2410 assert 0 # We shouldn't get here.
2411
2412 # Negation.
2413
2414 a = Array(2)
2415 a[0] = Vec(1, 2)
2416 a[1] = Vec(3, 4)
2417
2418 r = -a
2419 assert r[0] == Vec(-1, -2)
2420 assert r[1] == Vec(-3, -4)
2421
2422 # Multiplication.
2423
2424 a = Array(2)
2425 a[0] = Vec(1, 2)
2426 a[1] = Vec(3, 4)
2427
2428 r = a * 10
2429 assert r[0] == Vec(1, 2) * 10
2430 assert r[1] == Vec(3, 4) * 10
2431
2432 b = Arrayx(2)
2433 b[0] = 10
2434 b[1] = 11
2435
2436 r = a * b
2437 assert r[0] == Vec(1, 2) * 10
2438 assert r[1] == Vec(3, 4) * 11
2439
2440 a *= 10
2441 assert a[0] == Vec(1, 2) * 10
2442 assert a[1] == Vec(3, 4) * 10
2443
2444 a[0] = Vec(1, 2)
2445 a[1] = Vec(3, 4)
2446
2447 a *= b
2448 assert a[0] == Vec(1, 2) * 10
2449 assert a[1] == Vec(3, 4) * 11
2450
2451 a[0] = Vec(1, 2)
2452 a[1] = Vec(3, 4)
2453
2454 b = Array(2)
2455 b[0] = Vec(5, 6)
2456 b[1] = Vec(7, 8)
2457
2458 r = a * b
2459 assert r[0] == Vec(1*5, 2*6)
2460 assert r[1] == Vec(3*7, 4*8)
2461
2462 v = Vec(9, 10)
2463
2464 r = a * v
2465 assert r[0] == Vec(1*9, 2*10)
2466 assert r[1] == Vec(3*9, 4*10)
2467
2468 r = v * a
2469 assert r[0] == Vec(1*9, 2*10)
2470 assert r[1] == Vec(3*9, 4*10)
2471
2472 a *= b
2473 assert a[0] == Vec(1*5, 2*6)
2474 assert a[1] == Vec(3*7, 4*8)
2475
2476 a[0] = Vec(1, 2)
2477 a[1] = Vec(3, 4)
2478
2479 a *= v
2480 assert a[0] == Vec(1*9, 2*10)
2481 assert a[1] == Vec(3*9, 4*10)
2482
2483 d = Array(3)
2484 try:
2485 a * d # This should raise an exception.
2486 except:
2487 pass
2488 else:
2489 assert 0 # We shouldn't get here.
2490
2491 try:
2492 a *= d # This should raise an exception.
2493 except:
2494 pass
2495 else:
2496 assert 0 # We shouldn't get here.
2497
2498 # Division.
2499
2500 a = Array(2)
2501 a[0] = Vec(1.0, 2.0)
2502 a[1] = Vec(3.0, 4.0)
2503
2504 r = a / 10
2505 assert r[0] == Vec(1.0, 2.0) / 10
2506 assert r[1] == Vec(3.0, 4.0) / 10
2507
2508 b = Arrayx(2)
2509 b[0] = 10
2510 b[1] = 11
2511
2512 r = a / b
2513 assert r[0] == Vec(1.0, 2.0) / 10
2514 assert r[1] == Vec(3.0, 4.0) / 11
2515
2516 a /= 10
2517 assert a[0] == Vec(1.0, 2.0) / 10
2518 assert a[1] == Vec(3.0, 4.0) / 10
2519
2520 a[0] = Vec(1.0, 2.0)
2521 a[1] = Vec(3.0, 4.0)
2522
2523 a /= b
2524 assert a[0] == Vec(1.0, 2.0) / 10
2525 assert a[1] == Vec(3.0, 4.0) / 11
2526
2527 a[0] = Vec(1.0, 2.0)
2528 a[1] = Vec(3.0, 4.0)
2529
2530 b = Array(2)
2531 b[0] = Vec(5, 6)
2532 b[1] = Vec(7, 8)
2533
2534 r = a / b
2535 assert r[0] == Vec(1.0/5, 2.0/6)
2536 assert r[1] == Vec(3.0/7, 4.0/8)
2537
2538 v = Vec(9, 10)
2539
2540 r = a / v
2541 assert r[0] == Vec(1.0/9, 2.0/10)
2542 assert r[1] == Vec(3.0/9, 4.0/10)
2543
2544 # TODO: Figure out why "v / a" is illegal, even though the
2545 # add_arithmetic_math_functions() routine in PyImathFixedArray.h
2546 # should make it possible.
2547 #r = v / a
2548 #assert r[0] == Vec(1.0/9, 2.0/10)
2549 #assert r[1] == Vec(3.0/9, 4.0/10)
2550
2551 a /= b
2552 assert a[0] == Vec(1.0/5, 2.0/6)
2553 assert a[1] == Vec(3.0/7, 4.0/8)
2554
2555 a[0] = Vec(1.0, 2.0)
2556 a[1] = Vec(3.0, 4.0)
2557
2558 a /= v
2559 assert a[0] == Vec(1.0/9, 2.0/10)
2560 assert a[1] == Vec(3.0/9, 4.0/10)
2561
2562 d = Array(3)
2563 try:
2564 a / d # This should raise an exception.
2565 except:
2566 pass
2567 else:
2568 assert 0 # We shouldn't get here.
2569
2570 try:
2571 a /= d # This should raise an exception.
2572 except:
2573 pass
2574 else:
2575 assert 0 # We shouldn't get here.
2576
2577 # Length.
2578
2579 if (Vec != V2i):
2580 v0 = Vec(1, 2)
2581 v1 = Vec(3, 4)
2582
2583 a = Array(2)
2584 a[0] = v0
2585 a[1] = v1
2586
2587 l = a.length()
2588 assert (l[0] == v0.length())
2589 assert (l[1] == v1.length())
2590
2591 l = a.length2()
2592 assert (l[0] == v0.length2())
2593 assert (l[1] == v1.length2())
2594
2595 # Normalizing.
2596
2597 if (Vec != V2i):
2598
2599 a[0] = Vec(1, 2)
2600 a[1] = Vec(3, 4)
2601
2602 r = a.normalized();
2603 assert r[0] == Vec(1, 2).normalized()
2604 assert r[1] == Vec(3, 4).normalized()
2605
2606 a.normalize();
2607 assert a[0] == Vec(1, 2).normalized()
2608 assert a[1] == Vec(3, 4).normalized()
2609
2610 print ("ok")
2611
2612 return
2613
2614 def testV2Array ():
2615
2616 print ("V2iArray")
2617 testV2xArray (V2iArray, V2i, IntArray)
2618 print ("V2fArray")
2619 testV2xArray (V2fArray, V2f, FloatArray)
2620 print ("V2dArray")
2621 testV2xArray (V2dArray, V2d, DoubleArray)
2622
2623 testList.append (('testV2Array',testV2Array))
2624
2625
2626 # -------------------------------------------------------------------------
2627 # Tests for V3x
2628
2629 def testV3x (Vec):
2630
2631 # Constructors (and element access).
2632
2633 v = Vec()
2634 assert v[0] == 0 and v[1] == 0 and v[2] == 0
2635
2636 v = Vec(1)
2637 assert v[0] == 1 and v[1] == 1 and v[2] == 1
2638
2639 v = Vec(0, 1, 2)
2640 assert v[0] == 0 and v[1] == 1 and v[2] == 2
2641
2642 v = Vec((0, 1, 2))
2643 assert v[0] == 0 and v[1] == 1 and v[2] == 2
2644
2645 v = Vec([0, 1, 2])
2646 assert v[0] == 0 and v[1] == 1 and v[2] == 2
2647
2648 v = Vec()
2649 v.setValue(0, 1, 2)
2650 assert v[0] == 0 and v[1] == 1 and v[2] == 2
2651
2652 # Repr.
2653
2654 v = Vec(1/9., 2/9., 3/9.)
2655 assert v == eval(repr(v))
2656
2657 # Sequence length.
2658
2659 v = Vec()
2660 assert len(v) == 3
2661
2662 # Element setting.
2663
2664 v = Vec()
2665 v[0] = 10
2666 v[1] = 11
2667 v[2] = 12
2668 assert v[0] == 10 and v[1] == 11 and v[2] == 12
2669
2670 try:
2671 v[-4] = 0 # This should raise an exception.
2672 except:
2673 pass
2674 else:
2675 assert 0 # We shouldn't get here.
2676
2677 try:
2678 v[3] = 0 # This should raise an exception.
2679 except:
2680 pass
2681 else:
2682 assert 0 # We shouldn't get here.
2683
2684 try:
2685 v[1] = "a" # This should raise an exception.
2686 except:
2687 pass
2688 else:
2689 assert 0 # We shouldn't get here.
2690
2691 # Assignment.
2692
2693 v1 = Vec(1)
2694
2695 v2 = v1
2696 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1
2697 v1[0] = 2
2698 assert v2[0] == 2 and v2[1] == 1 and v2[2] == 1
2699
2700 # Comparison operators.
2701
2702 v1 = Vec(20, 20, 0)
2703 v2 = Vec(20, 20, 0)
2704 v3 = Vec(20, 21, 0)
2705
2706 assert v1 == v2
2707 assert v1 != v3
2708 assert not (v1 < v2)
2709 assert v1 < v3
2710 assert v1 <= v2
2711 assert v1 <= v3
2712 assert not (v3 <= v1)
2713 assert not (v2 > v1)
2714 assert v3 > v1
2715 assert v2 >= v1
2716 assert v3 >= v1
2717 assert not (v1 >= v3)
2718
2719 # Epsilon equality.
2720
2721 e = 0.005
2722 v1 = Vec(1)
2723 v2 = Vec(1 + e)
2724
2725 assert v1.equalWithAbsError(v2, e)
2726 assert v2.equalWithAbsError(v1, e)
2727
2728 e = 0.003
2729 v1 = Vec(10)
2730 v2 = Vec(10 + 10 * e)
2731
2732 assert v1.equalWithRelError(v2, e)
2733 assert v2.equalWithRelError(v1, e)
2734
2735 # Dot products.
2736
2737 v1 = Vec(0, 1, 0)
2738 v2 = Vec(1, 0, 0)
2739 v3 = Vec(1, 1, 0)
2740
2741 assert v1.dot(v2) == 0
2742 assert v1.dot(v3) == 1
2743 assert v1 ^ v2 == v1.dot(v2)
2744 assert v1 ^ v3 == v1.dot(v3)
2745
2746 # Cross products.
2747
2748 v1 = Vec(1, 0, 0)
2749 v2 = Vec(0, 1, 0)
2750
2751 assert v1.cross(v2) == Vec(0, 0, 1)
2752 assert v2.cross(v1) == Vec(0, 0, -1)
2753 assert v1 % v2 == v1.cross(v2)
2754 assert v2 % v1 == v2.cross(v1)
2755
2756 # Addition.
2757
2758 v1 = Vec(10, 20, 30)
2759 v2 = Vec(30, 40, 50)
2760
2761 assert v1 + v2 == Vec(40, 60, 80)
2762 assert v2 + v1 == v1 + v2
2763 assert v1 + 1 == Vec(11, 21, 31)
2764 assert 1 + v1 == v1 + 1
2765
2766 # (with the switch to python2, we now allow ops between vectors and tuples)
2767 assert v1 + (1, 2, 3) == Vec(11, 22, 33)
2768 assert (1, 2, 3) + v1 == v1 + (1, 2, 3)
2769
2770 # Subtraction and negation.
2771
2772 v1 = Vec(10, 20, 30)
2773 v2 = Vec(30, 40, 50)
2774
2775 assert v2 - v1 == Vec(20, 20, 20)
2776 assert v1 - 1 == Vec(9, 19, 29)
2777 assert 1 - v1 == - (v1 - 1)
2778
2779 # (with the switch to python2, we now allow ops between vectors and tuples)
2780 assert v1 - (1, 2, 3) == Vec(9, 18, 27)
2781 assert (1, 2, 3) - v1 == - (v1 - (1, 2, 3))
2782
2783 assert v1.negate() == Vec(-10, -20, -30)
2784
2785 # Multiplication.
2786
2787 v1 = Vec(1, 2, 3)
2788 v2 = Vec(3, 4, 5)
2789
2790 assert v1 * v2 == Vec(3, 8, 15)
2791 assert v2 * v1 == v1 * v2
2792 assert 2 * v1 == Vec(2, 4, 6)
2793 assert v1 * 2 == 2 * v1
2794
2795 assert v1 * V3i(3, 4, 5) == Vec(3, 8, 15)
2796 assert v1 * V3f(3, 4, 5) == Vec(3, 8, 15)
2797 assert v1 * V3d(3, 4, 5) == Vec(3, 8, 15)
2798
2799 v1 *= 2
2800 assert v1 == Vec(2, 4, 6)
2801 v1 = Vec(1, 2, 3)
2802
2803 # (with the switch to python2, we now allow ops between vectors and tuples)
2804 assert v1 * (1, 2, 3) == Vec(1, 4, 9)
2805 assert (1, 2, 3) * v1 == v1 * (1, 2, 3)
2806
2807 # Division.
2808
2809 v1 = Vec(10, 20, 40)
2810 v2 = Vec(2, 4, 8)
2811
2812 assert v1 / v2 == Vec(10/2, 20/4, 40/8)
2813 assert v1 / 2 == Vec(10/2, 20/2, 40/2)
2814 assert Vec(40) / v1 == Vec(40/10, 40/20, 40/40)
2815
2816 # (with the switch to python2, we now allow ops between vectors and tuples)
2817 assert v1 / (1, 2, 4) == Vec(10, 10, 10)
2818 assert Vec(50, 40, 80) / v1 == Vec(5, 2, 2)
2819
2820 assert v1 / V3i (2, 4, 8) == Vec(10/2, 20/4, 40/8)
2821 assert v1 / V3f (2, 4, 8) == Vec(10/2, 20/4, 40/8)
2822 assert v1 / V3d (2, 4, 8) == Vec(10/2, 20/4, 40/8)
2823 assert v1 / (2, 4, 8) == Vec(10/2, 20/4, 40/8)
2824 assert v1 / [2, 4, 8] == Vec(10/2, 20/4, 40/8)
2825
2826 v1 = Vec(10, 20, 40)
2827 v1 /= 2
2828 assert v1 == Vec(10/2, 20/2, 40/2)
2829
2830 v1 = Vec(10, 20, 40)
2831 v1 /= V3i (2, 4, 8)
2832 assert v1 == Vec(10/2, 20/4, 40/8)
2833
2834 v1 = Vec(10, 20, 40)
2835 v1 /= V3f (2, 4, 8)
2836 assert v1 == Vec(10/2, 20/4, 40/8)
2837
2838 v1 = Vec(10, 20, 40)
2839 v1 /= V3d (2, 4, 8)
2840 assert v1 == Vec(10/2, 20/4, 40/8)
2841
2842 v1 = Vec(10, 20, 40)
2843 v1 /= (2, 4, 8)
2844 assert v1 == Vec(10/2, 20/4, 40/8)
2845
2846 v1 = Vec(10, 20, 40)
2847 v1 /= [2, 4, 8]
2848 assert v1 == Vec(10/2, 20/4, 40/8)
2849
2850 # Length.
2851
2852 if (Vec != V3i):
2853 v = Vec(1, 2, 3)
2854 assert equal(v.length(), sqrt(1*1 + 2*2 + 3*3), v.baseTypeEpsilon())
2855
2856 v = Vec(1, 2, 3)
2857 assert v.length2() == 1*1 + 2*2 + 3*3
2858
2859 # Normalizing.
2860
2861 if (Vec != V3i):
2862 v = Vec(1, 2, 3)
2863 v.normalize()
2864 assert equal(v.length(), 1, v.baseTypeEpsilon())
2865
2866 v = Vec(1, 2, 3)
2867 v.normalizeExc()
2868 assert equal(v.length(), 1, v.baseTypeEpsilon())
2869 v = Vec(0)
2870 try:
2871 v.normalizeExc() # This should raise an exception.
2872 except:
2873 pass
2874 else:
2875 assert 0 # We shouldn't get here.
2876
2877 v = Vec(1, 2, 3)
2878 v.normalizeNonNull()
2879 assert equal(v.length(), 1, v.baseTypeEpsilon())
2880
2881 v = Vec(1, 2, 3)
2882 assert equal(v.normalized().length(), 1, v.baseTypeEpsilon())
2883
2884 v = Vec(1, 2, 3)
2885 assert equal(v.normalizedExc().length(), 1, v.baseTypeEpsilon())
2886 v = Vec(0)
2887 try:
2888 v.normalizedExc() # This should raise an exception.
2889 except:
2890 pass
2891 else:
2892 assert 0 # We shouldn't get here.
2893
2894 v = Vec(1, 2, 3)
2895 assert equal(v.normalizedNonNull().length(), 1, v.baseTypeEpsilon())
2896
2897 # Projection.
2898
2899 if (Vec != V3i):
2900 s = Vec(2, 0, 0)
2901 t = Vec(1, 1, 0)
2902 assert t.project(s) == Vec(1, 0, 0)
2903
2904 # Orthogonal.
2905
2906 if (Vec != V3i):
2907 s = Vec(2, 0, 0)
2908 t = Vec(1, 1, 0)
2909 o = s.orthogonal(t)
2910 assert iszero(o ^ s, s.baseTypeEpsilon())
2911
2912 # Reflect.
2913
2914 if (Vec != V3i):
2915 s = Vec(1, 1, 0)
2916 t = Vec(2, 0, 0)
2917 r = s.reflect(t)
2918 assert equal(abs(s ^ t), abs(r ^ t), s.baseTypeEpsilon())
2919
2920 # Closest vertex.
2921
2922 v0 = Vec(0, 0, 0)
2923 v1 = Vec(5, 0, 0)
2924 v2 = Vec(0, 5, 0)
2925
2926 p = Vec(1, 1, 0)
2927 assert p.closestVertex(v0, v1, v2) == v0
2928
2929 p = Vec(4, 1, 0)
2930 assert p.closestVertex(v0, v1, v2) == v1
2931
2932 p = Vec(1, 4, 0)
2933 assert p.closestVertex(v0, v1, v2) == v2
2934
2935
2936 print ("ok")
2937
2938 return
2939
2940 def testV3 ():
2941
2942 print ("V3i")
2943 testV3x (V3i)
2944 print ("V3f")
2945 testV3x (V3f)
2946 print ("V3d")
2947 testV3x (V3d)
2948
2949 testList.append (('testV3',testV3))
2950
2951
2952 # -------------------------------------------------------------------------
2953 # Tests for V3xArray
2954
2955 def testV3xArray (Array, Vec, Arrayx):
2956
2957 # Constructors (and element access).
2958
2959 a = Array (3)
2960
2961 a[0] = Vec(0)
2962 a[1] = Vec(1)
2963 a[2] = Vec(2)
2964
2965 assert a[0] == Vec(0)
2966 assert a[1] == Vec(1)
2967 assert a[2] == Vec(2)
2968
2969 a[0].setValue(10,10,10)
2970 a[1].setValue(11,11,11)
2971 a[2].setValue(12,12,12)
2972
2973 assert a[0] == Vec(10)
2974 assert a[1] == Vec(11)
2975 assert a[2] == Vec(12)
2976
2977 # explicit constructors across types
2978 af = V3fArray(a)
2979 assert a[0] == Vec(af[0])
2980 assert a[1] == Vec(af[1])
2981 assert a[2] == Vec(af[2])
2982 ad = V3dArray(a)
2983 assert a[0] == Vec(ad[0])
2984 assert a[1] == Vec(ad[1])
2985 assert a[2] == Vec(ad[2])
2986 ai = V3iArray(a)
2987 assert a[0] == Vec(ai[0])
2988 assert a[1] == Vec(ai[1])
2989 assert a[2] == Vec(ai[2])
2990
2991
2992 # Element setting.
2993
2994 a = Array(2)
2995
2996 try:
2997 a[-3] = Vec(0) # This should raise an exception.
2998 except:
2999 pass
3000 else:
3001 assert 0 # We shouldn't get here.
3002
3003 try:
3004 a[3] = Vec(0) # This should raise an exception.
3005 except:
3006 pass
3007 else:
3008 assert 0 # We shouldn't get here.
3009
3010 try:
3011 a[1] = "a" # This should raise an exception.
3012 except:
3013 pass
3014 else:
3015 assert 0 # We shouldn't get here.
3016
3017 # Assignment.
3018
3019 a = Array(2)
3020 a[0] = Vec(0)
3021 a[1] = Vec(1)
3022
3023 b = Array(2)
3024 b[0] = Vec(0)
3025 b[1] = Vec(1)
3026
3027 c = Array(2)
3028 c[0] = Vec(10)
3029 c[1] = Vec(11)
3030
3031 # TODO: make equality work correctly.
3032 #assert a == b
3033 assert a != c
3034
3035 # Dot products.
3036
3037 a = Array(2)
3038 a[0] = Vec(1, 2, 3)
3039 a[1] = Vec(4, 5, 6)
3040
3041 b = Array(2)
3042 b[0] = Vec(7, 8, 9)
3043 b[1] = Vec(10, 11, 12)
3044
3045 r = a.dot(b)
3046 assert r[0] == 1*7 + 2*8 + 3*9
3047 assert r[1] == 4*10 + 5*11 + 6*12
3048
3049 c = Vec(13, 14, 15)
3050 r = a.dot(c)
3051 assert r[0] == 1*13 + 2*14 + 3*15
3052 assert r[1] == 4*13 + 5*14 + 6*15
3053
3054 d = Array(3)
3055 try:
3056 a.dot(d) # This should raise an exception.
3057 except:
3058 pass
3059 else:
3060 assert 0 # We shouldn't get here.
3061
3062
3063 # Cross products.
3064
3065 a = Array(2)
3066 a[0] = Vec(1, 2, 3)
3067 a[1] = Vec(4, 5, 6)
3068
3069 b = Array(2)
3070 b[0] = Vec(7, 8, 9)
3071 b[1] = Vec(10, 11, 12)
3072
3073 r = a.cross(b)
3074 assert r[0] == Vec(1, 2, 3) % Vec(7, 8, 9)
3075 assert r[1] == Vec(4, 5, 6) % Vec(10, 11, 12)
3076
3077 c = Vec(13, 14, 15)
3078 r = a.cross(c)
3079 assert r[0] == Vec(1, 2, 3) % Vec(13, 14, 15)
3080 assert r[1] == Vec(4, 5, 6) % Vec(13, 14, 15)
3081
3082 d = Array(3)
3083 try:
3084 a.cross(d) # This should raise an exception.
3085 except:
3086 pass
3087 else:
3088 assert 0 # We shouldn't get here.
3089
3090 # Addition.
3091
3092 a = Array(2)
3093 a[0] = Vec(1, 2, 3)
3094 a[1] = Vec(4, 5, 6)
3095
3096 b = Array(2)
3097 b[0] = Vec(7, 8, 9)
3098 b[1] = Vec(10, 11, 12)
3099
3100 r = a + b
3101 assert r[0] == Vec(1+7, 2+8, 3+9)
3102 assert r[1] == Vec(4+10, 5+11, 6+12)
3103
3104 r = a + Vec(10)
3105 assert r[0] == Vec(1+10, 2+10, 3+10)
3106 assert r[1] == Vec(4+10, 5+10, 6+10)
3107
3108 v = Vec(11)
3109 r = v + a
3110 assert r[0] == Vec(11+1, 11+2, 11+3)
3111 assert r[1] == Vec(11+4, 11+5, 11+6)
3112
3113 a += b
3114 assert a[0] == Vec(1+7, 2+8, 3+9)
3115 assert a[1] == Vec(4+10, 5+11, 6+12)
3116
3117 a[0] = Vec(1, 2, 3)
3118 a[1] = Vec(4, 5, 6)
3119
3120 a += Vec(10)
3121 assert a[0] == Vec(1+10, 2+10, 3+10)
3122 assert a[1] == Vec(4+10, 5+10, 6+10)
3123
3124 c = Array(3)
3125
3126 try:
3127 a + c # This should raise an exception.
3128 except:
3129 pass
3130 else:
3131 assert 0 # We shouldn't get here.
3132
3133 try:
3134 a += c # This should raise an exception.
3135 except:
3136 pass
3137 else:
3138 assert 0 # We shouldn't get here.
3139
3140 # Subtraction.
3141
3142 a = Array(2)
3143 a[0] = Vec(1, 2, 3)
3144 a[1] = Vec(4, 5, 6)
3145
3146 b = Array(2)
3147 b[0] = Vec(7, 8, 9)
3148 b[1] = Vec(10, 11, 12)
3149
3150 r = a - b
3151 assert r[0] == Vec(1-7, 2-8, 3-9)
3152 assert r[1] == Vec(4-10, 5-11, 6-12)
3153
3154 r = a - Vec(10)
3155 assert r[0] == Vec(1-10, 2-10, 3-10)
3156 assert r[1] == Vec(4-10, 5-10, 6-10)
3157
3158 v = Vec(11)
3159 r = v - a
3160 assert r[0] == Vec(11-1, 11-2, 11-3)
3161 assert r[1] == Vec(11-4, 11-5, 11-6)
3162
3163 a -= b
3164 assert a[0] == Vec(1-7, 2-8, 3-9)
3165 assert a[1] == Vec(4-10, 5-11, 6-12)
3166
3167 a[0] = Vec(1, 2, 3)
3168 a[1] = Vec(4, 5, 6)
3169
3170 a -= Vec(10)
3171 assert a[0] == Vec(1-10, 2-10, 3-10)
3172 assert a[1] == Vec(4-10, 5-10, 6-10)
3173
3174 c = Array(3)
3175
3176 try:
3177 a - c # This should raise an exception.
3178 except:
3179 pass
3180 else:
3181 assert 0 # We shouldn't get here.
3182
3183 try:
3184 a -= c # This should raise an exception.
3185 except:
3186 pass
3187 else:
3188 assert 0 # We shouldn't get here.
3189
3190 # Negation.
3191
3192 a = Array(2)
3193 a[0] = Vec(1, 2, 3)
3194 a[1] = Vec(4, 5, 6)
3195
3196 r = -a
3197 assert r[0] == Vec(-1, -2, -3)
3198 assert r[1] == Vec(-4, -5, -6)
3199
3200 # Multiplication.
3201
3202 a = Array(2)
3203 a[0] = Vec(1, 2, 3)
3204 a[1] = Vec(4, 5, 6)
3205
3206 r = a * 10
3207 assert r[0] == Vec(1, 2, 3) * 10
3208 assert r[1] == Vec(4, 5, 6) * 10
3209
3210 b = Arrayx(2)
3211 b[0] = 10
3212 b[1] = 11
3213
3214 r = a * b
3215 assert r[0] == Vec(1, 2, 3) * 10
3216 assert r[1] == Vec(4, 5, 6) * 11
3217
3218 a *= 10
3219 assert a[0] == Vec(1, 2, 3) * 10
3220 assert a[1] == Vec(4, 5, 6) * 10
3221
3222 a[0] = Vec(1, 2, 3)
3223 a[1] = Vec(4, 5, 6)
3224
3225 a *= b
3226 assert a[0] == Vec(1, 2, 3) * 10
3227 assert a[1] == Vec(4, 5, 6) * 11
3228
3229 a[0] = Vec(1, 2, 3)
3230 a[1] = Vec(4, 5, 6)
3231
3232 b = Array(2)
3233 b[0] = Vec(7, 8, 9)
3234 b[1] = Vec(10, 11, 12)
3235
3236 r = a * b
3237 assert r[0] == Vec(1*7, 2*8, 3*9)
3238 assert r[1] == Vec(4*10, 5*11, 6*12)
3239
3240 v = Vec(13, 14, 15)
3241
3242 r = a * v
3243 assert r[0] == Vec(1*13, 2*14, 3*15)
3244 assert r[1] == Vec(4*13, 5*14, 6*15)
3245
3246 r = v * a
3247 assert r[0] == Vec(1*13, 2*14, 3*15)
3248 assert r[1] == Vec(4*13, 5*14, 6*15)
3249
3250 a *= b
3251 assert a[0] == Vec(1*7, 2*8, 3*9)
3252 assert a[1] == Vec(4*10, 5*11, 6*12)
3253
3254 a[0] = Vec(1, 2, 3)
3255 a[1] = Vec(4, 5, 6)
3256
3257 a *= v
3258 assert a[0] == Vec(1*13, 2*14, 3*15)
3259 assert a[1] == Vec(4*13, 5*14, 6*15)
3260
3261 d = Array(3)
3262 try:
3263 a * d # This should raise an exception.
3264 except:
3265 pass
3266 else:
3267 assert 0 # We shouldn't get here.
3268
3269 try:
3270 a *= d # This should raise an exception.
3271 except:
3272 pass
3273 else:
3274 assert 0 # We shouldn't get here.
3275
3276 # Division.
3277
3278 a = Array(2)
3279 a[0] = Vec(1.0, 2.0, 3.0)
3280 a[1] = Vec(4.0, 5.0, 6.0)
3281
3282 r = a / 10
3283 assert r[0] == Vec(1.0, 2.0, 3.0) / 10
3284 assert r[1] == Vec(4.0, 5.0, 6.0) / 10
3285
3286 b = Arrayx(2)
3287 b[0] = 10
3288 b[1] = 11
3289
3290 r = a / b
3291 assert r[0] == Vec(1.0, 2.0, 3.0) / 10
3292 assert r[1] == Vec(4.0, 5.0, 6.0) / 11
3293
3294 a /= 10
3295 assert a[0] == Vec(1.0, 2.0, 3.0) / 10
3296 assert a[1] == Vec(4.0, 5.0, 6.0) / 10
3297
3298 a[0] = Vec(1.0, 2.0, 3.0)
3299 a[1] = Vec(4.0, 5.0, 6.0)
3300
3301 a /= b
3302 assert a[0] == Vec(1.0, 2.0, 3.0) / 10
3303 assert a[1] == Vec(4.0, 5.0, 6.0) / 11
3304
3305 a[0] = Vec(1.0, 2.0, 3.0)
3306 a[1] = Vec(4.0, 5.0, 6.0)
3307
3308 b = Array(2)
3309 b[0] = Vec(7.0, 8.0, 9.0)
3310 b[1] = Vec(10.0, 11.0, 12.0)
3311
3312 r = a / b
3313 assert r[0] == Vec(1.0/7, 2.0/8, 3.0/9)
3314 assert r[1] == Vec(4.0/10, 5.0/11, 6.0/12)
3315
3316 v = Vec(13.0, 14.0, 15.0)
3317
3318 r = a / v
3319 assert r[0] == Vec(1.0/13, 2.0/14, 3.0/15)
3320 assert r[1] == Vec(4.0/13, 5.0/14, 6.0/15)
3321
3322 # TODO: Figure out why "v / a" is illegal, even though the
3323 # add_arithmetic_math_functions() routine in PyImathFixedArray.h
3324 # should make it possible.
3325 #r = v / a
3326 #assert r[0] == Vec(1.0/13, 2.0/14, 3.0/15)
3327 #assert r[1] == Vec(4.0/13, 5.0/14, 6.0/15)
3328
3329 a /= b
3330 assert a[0] == Vec(1.0/7, 2.0/8, 3.0/9)
3331 assert a[1] == Vec(4.0/10, 5.0/11, 6.0/12)
3332
3333 a[0] = Vec(1.0, 2.0, 3.0)
3334 a[1] = Vec(4.0, 5.0, 6.0)
3335
3336 a /= v
3337 assert a[0] == Vec(1.0/13, 2.0/14, 3.0/15)
3338 assert a[1] == Vec(4.0/13, 5.0/14, 6.0/15)
3339
3340 d = Array(3)
3341 try:
3342 a / d # This should raise an exception.
3343 except:
3344 pass
3345 else:
3346 assert 0 # We shouldn't get here.
3347
3348 try:
3349 a /= d # This should raise an exception.
3350 except:
3351 pass
3352 else:
3353 assert 0 # We shouldn't get here.
3354
3355 # Length.
3356
3357 v0 = Vec(1, 2, 3)
3358 v1 = Vec(4, 5, 6)
3359
3360 a = Array(2)
3361 a[0] = v0
3362 a[1] = v1
3363
3364 if (Vec != V3i):
3365 l = a.length()
3366 assert (l[0] == v0.length())
3367 assert (l[1] == v1.length())
3368
3369 l = a.length2()
3370 assert (l[0] == v0.length2())
3371 assert (l[1] == v1.length2())
3372
3373 # Normalizing.
3374
3375 if (Vec != V3i):
3376
3377 a[0] = Vec(1, 2, 3)
3378 a[1] = Vec(4, 5, 6)
3379
3380 r = a.normalized();
3381 assert r[0] == Vec(1, 2, 3).normalized()
3382 assert r[1] == Vec(4, 5, 6).normalized()
3383
3384 a.normalize();
3385 assert a[0] == Vec(1, 2, 3).normalized()
3386 assert a[1] == Vec(4, 5, 6).normalized()
3387
3388 print ("ok")
3389
3390 return
3391
3392 def testV3Array ():
3393
3394 print ("V3iArray")
3395 testV3xArray (V3iArray, V3i, IntArray)
3396 print ("V3fArray")
3397 testV3xArray (V3fArray, V3f, FloatArray)
3398 print ("V3dArray")
3399 testV3xArray (V3dArray, V3d, DoubleArray)
3400
3401 testList.append (('testV3Array',testV3Array))
3402
3403
3404 # -------------------------------------------------------------------------
3405 # Tests for Vec --> Vec conversions
3406
3407 def testV2xConversions (Vec):
3408
3409 # Assignment
3410
3411 v1 = Vec(0, 1)
3412
3413 v2 = V2i (v1)
3414 assert v2[0] == 0 and v2[1] == 1
3415
3416 v2 = V2f (v1)
3417 assert v2[0] == 0 and v2[1] == 1
3418
3419 v2 = V2d (v1)
3420 assert v2[0] == 0 and v2[1] == 1
3421
3422 # The += operator
3423
3424 v2 = Vec (1, 2)
3425 v2 += V2i (v1)
3426 assert v2[0] == 1 and v2[1] == 3
3427
3428 v2 = Vec (1, 2)
3429 v2 += V2f (v1)
3430 assert v2[0] == 1 and v2[1] == 3
3431
3432 v2 = Vec (1, 2)
3433 v2 += V2d (v1)
3434 assert v2[0] == 1 and v2[1] == 3
3435
3436 # The -= operator
3437
3438 v2 = Vec (1, 2)
3439 v2 -= V2i (v1)
3440 assert v2[0] == 1 and v2[1] == 1
3441
3442 v2 = Vec (1, 2)
3443 v2 -= V2f (v1)
3444 assert v2[0] == 1 and v2[1] == 1
3445
3446 v2 = Vec (1, 2)
3447 v2 -= V2d (v1)
3448 assert v2[0] == 1 and v2[1] == 1
3449
3450 # The *= operator
3451
3452 v2 = Vec (1, 2)
3453 v2 *= V2i (v1)
3454 assert v2[0] == 0 and v2[1] == 2
3455
3456 v2 = Vec (1, 2)
3457 v2 *= V2f (v1)
3458 assert v2[0] == 0 and v2[1] == 2
3459
3460 v2 = Vec (1, 2)
3461 v2 *= V2d (v1)
3462 assert v2[0] == 0 and v2[1] == 2
3463
3464 print ("ok")
3465 return
3466
3467
3468 def testV3xConversions (Vec):
3469
3470 # Assignment
3471
3472 v1 = Vec(0, 1, 2)
3473
3474 v2 = V3i (v1)
3475 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2
3476
3477 v2 = V3f (v1)
3478 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2
3479
3480 v2 = V3d (v1)
3481 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2
3482
3483 # The += operator
3484
3485 v2 = Vec (1, 2, 3)
3486 v2 += V3i (v1)
3487 assert v2[0] == 1 and v2[1] == 3 and v2[2] == 5
3488
3489 v2 = Vec (1, 2, 3)
3490 v2 += V3f (v1)
3491 assert v2[0] == 1 and v2[1] == 3 and v2[2] == 5
3492
3493 v2 = Vec (1, 2, 3)
3494 v2 += V3d (v1)
3495 assert v2[0] == 1 and v2[1] == 3 and v2[2] == 5
3496
3497 # The -= operator
3498
3499 v2 = Vec (1, 2, 3)
3500 v2 -= V3i (v1)
3501 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1
3502
3503 v2 = Vec (1, 2, 3)
3504 v2 -= V3f (v1)
3505 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1
3506
3507 v2 = Vec (1, 2, 3)
3508 v2 -= V3d (v1)
3509 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1
3510
3511 # The *= operator
3512
3513 v2 = Vec (1, 2, 3)
3514 v2 *= V3i (v1)
3515 assert v2[0] == 0 and v2[1] == 2 and v2[2] == 6
3516
3517 v2 = Vec (1, 2, 3)
3518 v2 *= V3f (v1)
3519 assert v2[0] == 0 and v2[1] == 2 and v2[2] == 6
3520
3521 v2 = Vec (1, 2, 3)
3522 v2 *= V3d (v1)
3523 assert v2[0] == 0 and v2[1] == 2 and v2[2] == 6
3524
3525 print ("ok")
3526 return
3527
3528 # -------------------------------------------------------------------------
3529 # Tests for V4x
3530
3531 def testV4x (Vec):
3532
3533 # Constructors (and element access).
3534
3535 v = Vec()
3536 assert v[0] == 0 and v[1] == 0 and v[2] == 0 and v[3] == 0
3537
3538 v = Vec(1)
3539 assert v[0] == 1 and v[1] == 1 and v[2] == 1 and v[3] == 1
3540
3541 v = Vec(0, 1, 2, 3)
3542 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
3543
3544 v = Vec((0, 1, 2, 3))
3545 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
3546
3547 v = Vec([0, 1, 2, 3])
3548 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
3549
3550 v = Vec()
3551 v.setValue(0, 1, 2, 3)
3552 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
3553
3554 # Repr.
3555
3556 v = Vec(1/9., 2/9., 3/9., 4./9.)
3557 assert v == eval(repr(v))
3558
3559 # Sequence length.
3560
3561 v = Vec()
3562 assert len(v) == 4
3563
3564 # Element setting.
3565
3566 v = Vec()
3567 v[0] = 10
3568 v[1] = 11
3569 v[2] = 12
3570 v[3] = 13
3571 assert v[0] == 10 and v[1] == 11 and v[2] == 12 and v[3] == 13
3572
3573 try:
3574 # TODO why does this have to be -5 and not -4?
3575 v[-5] = 0 # This should raise an exception.
3576 except:
3577 pass
3578 else:
3579 assert 0 # We shouldn't get here.
3580
3581 try:
3582 v[4] = 0 # This should raise an exception.
3583 except:
3584 pass
3585 else:
3586 assert 0 # We shouldn't get here.
3587
3588 try:
3589 v[1] = "a" # This should raise an exception.
3590 except:
3591 pass
3592 else:
3593 assert 0 # We shouldn't get here.
3594
3595 # Assignment.
3596
3597 v1 = Vec(1)
3598
3599 v2 = v1
3600 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
3601 v1[0] = 2
3602 assert v2[0] == 2 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
3603
3604 # Comparison operators.
3605
3606 v1 = Vec(20, 20, 20, 20)
3607 v2 = Vec(20, 20, 20, 20)
3608 v3 = Vec(20, 20, 20, 21)
3609
3610 assert v1 == v2
3611 assert v1 != v3
3612 assert not (v1 < v2)
3613 assert v1 < v3
3614 assert v1 <= v2
3615 assert v1 <= v3
3616 assert not (v3 <= v1)
3617 assert not (v2 > v1)
3618 assert v3 > v1
3619 assert v2 >= v1
3620 assert v3 >= v1
3621 assert not (v1 >= v3)
3622
3623 # Epsilon equality.
3624
3625 e = 0.005
3626 v1 = Vec(1)
3627 v2 = Vec(1 + e)
3628
3629 assert v1.equalWithAbsError(v2, e)
3630 assert v2.equalWithAbsError(v1, e)
3631
3632 e = 0.003
3633 v1 = Vec(10)
3634 v2 = Vec(10 + 10 * e)
3635
3636 assert v1.equalWithRelError(v2, e)
3637 assert v2.equalWithRelError(v1, e)
3638
3639 # Dot products.
3640
3641 v1 = Vec(0, 1, 0, 1)
3642 v2 = Vec(1, 0, 0, 0)
3643 v3 = Vec(1, 1, 1, 1)
3644
3645 assert v1.dot(v2) == 0
3646 assert v1.dot(v3) == 2
3647 assert v1 ^ v2 == v1.dot(v2)
3648 assert v1 ^ v3 == v1.dot(v3)
3649
3650 # Addition.
3651
3652 v1 = Vec(10, 20, 30, 40)
3653 v2 = Vec(30, 40, 50, 60)
3654
3655 assert v1 + v2 == Vec(40, 60, 80, 100)
3656 assert v2 + v1 == v1 + v2
3657 assert v1 + 1 == Vec(11, 21, 31, 41)
3658 assert 1 + v1 == v1 + 1
3659
3660 # (with the switch to python2, we now allow ops between vectors and tuples)
3661 assert v1 + (1, 2, 3, 4) == Vec(11, 22, 33, 44)
3662 assert (1, 2, 3, 4) + v1 == v1 + (1, 2, 3, 4)
3663
3664 # Subtraction and negation.
3665
3666 v1 = Vec(10, 20, 30, 40)
3667 v2 = Vec(30, 40, 50, 60)
3668
3669 assert v2 - v1 == Vec(20, 20, 20, 20)
3670 assert v1 - 1 == Vec(9, 19, 29, 39)
3671 assert 1 - v1 == - (v1 - 1)
3672
3673 # (with the switch to python2, we now allow ops between vectors and tuples)
3674 assert v1 - (1, 2, 3, 4) == Vec(9, 18, 27, 36)
3675 assert (1, 2, 3, 4) - v1 == - (v1 - (1, 2, 3, 4))
3676
3677 assert v1.negate() == Vec(-10, -20, -30, -40)
3678
3679 # Multiplication.
3680
3681 v1 = Vec(1, 2, 3, 4)
3682 v2 = Vec(3, 4, 5, 6)
3683
3684 assert v1 * v2 == Vec(3, 8, 15, 24)
3685 assert v2 * v1 == v1 * v2
3686 assert 2 * v1 == Vec(2, 4, 6, 8)
3687 assert v1 * 2 == 2 * v1
3688
3689 assert v1 * V4i(3, 4, 5, 6) == Vec(3, 8, 15, 24)
3690 assert v1 * V4f(3, 4, 5, 6) == Vec(3, 8, 15, 24)
3691 assert v1 * V4d(3, 4, 5, 6) == Vec(3, 8, 15, 24)
3692
3693 v1 *= 2
3694 assert v1 == Vec(2, 4, 6, 8)
3695 v1 = Vec(1, 2, 3, 4)
3696
3697 # (with the switch to python2, we now allow ops between vectors and tuples)
3698 assert v1 * (1, 2, 3, 4) == Vec(1, 4, 9, 16)
3699 assert (1, 2, 3, 4) * v1 == v1 * (1, 2, 3, 4)
3700
3701 # Division.
3702
3703 v1 = Vec(10, 20, 40, 80)
3704 v2 = Vec(2, 4, 8, 10)
3705
3706 assert v1 / v2 == Vec(10/2, 20/4, 40/8, 80/10)
3707 assert v1 / 2 == Vec(10/2, 20/2, 40/2, 80/2)
3708 assert Vec(80) / v1 == Vec(80/10, 80/20, 80/40, 80/80)
3709
3710 # (with the switch to python2, we now allow ops between vectors and tuples)
3711 assert v1 / (1, 2, 4, 8) == Vec(10, 10, 10, 10)
3712 assert Vec(50, 40, 80, 160) / v1 == Vec(5, 2, 2, 2)
3713
3714 assert v1 / V4i (2, 4, 8, 10) == Vec(10/2, 20/4, 40/8, 80/10)
3715 assert v1 / V4f (2, 4, 8, 10) == Vec(10/2, 20/4, 40/8, 80/10)
3716 assert v1 / V4d (2, 4, 8, 10) == Vec(10/2, 20/4, 40/8, 80/10)
3717 assert v1 / (2, 4, 8, 10) == Vec(10/2, 20/4, 40/8, 80/10)
3718 assert v1 / [2, 4, 8, 10] == Vec(10/2, 20/4, 40/8, 80/10)
3719
3720 v1 = Vec(10, 20, 40, 80)
3721 v1 /= 2
3722 assert v1 == Vec(10/2, 20/2, 40/2, 80/2)
3723
3724 v1 = Vec(10, 20, 40, 80)
3725 v1 /= V4i (2, 4, 8, 10)
3726 assert v1 == Vec(10/2, 20/4, 40/8, 80/10)
3727
3728 v1 = Vec(10, 20, 40, 80)
3729 v1 /= V4f (2, 4, 8, 10)
3730 assert v1 == Vec(10/2, 20/4, 40/8, 80/10)
3731
3732 v1 = Vec(10, 20, 40, 80)
3733 v1 /= V4d (2, 4, 8, 10)
3734 assert v1 == Vec(10/2, 20/4, 40/8, 80/10)
3735
3736 v1 = Vec(10, 20, 40, 80)
3737 v1 /= (2, 4, 8, 10)
3738 assert v1 == Vec(10/2, 20/4, 40/8, 80/10)
3739
3740 v1 = Vec(10, 20, 40, 80)
3741 v1 /= [2, 4, 8, 10]
3742 assert v1 == Vec(10/2, 20/4, 40/8, 80/10)
3743
3744 # Length.
3745
3746 if (Vec != V4i):
3747 v = Vec(1, 2, 3, 4)
3748 assert equal(v.length(), sqrt(1*1 + 2*2 + 3*3 + 4*4), 10.0*v.baseTypeEpsilon())
3749
3750 v = Vec(1, 2, 3, 4)
3751 assert v.length2() == 1*1 + 2*2 + 3*3 + 4*4
3752
3753 # Normalizing.
3754
3755 if (Vec != V4i):
3756 v = Vec(1, 2, 3, 4)
3757 v.normalize()
3758 assert equal(v.length(), 1, v.baseTypeEpsilon())
3759
3760 v = Vec(1, 2, 3, 4)
3761 v.normalizeExc()
3762 assert equal(v.length(), 1, v.baseTypeEpsilon())
3763 v = Vec(0)
3764 try:
3765 v.normalizeExc() # This should raise an exception.
3766 except:
3767 pass
3768 else:
3769 assert 0 # We shouldn't get here.
3770
3771 v = Vec(1, 2, 3, 4)
3772 v.normalizeNonNull()
3773 assert equal(v.length(), 1, v.baseTypeEpsilon())
3774
3775 v = Vec(1, 2, 3, 4)
3776 assert equal(v.normalized().length(), 1, v.baseTypeEpsilon())
3777
3778 v = Vec(1, 2, 3, 4)
3779 assert equal(v.normalizedExc().length(), 1, v.baseTypeEpsilon())
3780 v = Vec(0)
3781 try:
3782 v.normalizedExc() # This should raise an exception.
3783 except:
3784 pass
3785 else:
3786 assert 0 # We shouldn't get here.
3787
3788 v = Vec(1, 2, 3, 4)
3789 assert equal(v.normalizedNonNull().length(), 1, v.baseTypeEpsilon())
3790
3791 # Projection.
3792
3793 if (Vec != V4i):
3794 s = Vec(0, 0, 0, 2)
3795 t = Vec(1, 1, 1, 1)
3796 assert t.project(s) == Vec(0, 0, 0, 1)
3797
3798 # Orthogonal.
3799
3800 if (Vec != V4i):
3801 s = Vec(0, 0, 0, 2)
3802 t = Vec(1, 1, 1, 1)
3803 o = s.orthogonal(t)
3804 assert iszero(o ^ s, s.baseTypeEpsilon())
3805
3806 # Reflect.
3807
3808 if (Vec != V4i):
3809 s = Vec(1, 1, 1, 1)
3810 t = Vec(0, 0, 0, 2)
3811 r = s.reflect(t)
3812 assert equal(abs(s ^ t), abs(r ^ t), s.baseTypeEpsilon())
3813
3814 print ("ok")
3815
3816 return
3817
3818 def testV4 ():
3819
3820 print ("V4i")
3821 testV4x (V4i)
3822 print ("V4f")
3823 testV4x (V4f)
3824 print ("V4d")
3825 testV4x (V4d)
3826
3827 testList.append (('testV4',testV4))
3828
3829
3830 # -------------------------------------------------------------------------
3831 # Tests for V4xArray
3832
3833 def testV4xArray (Array, Vec, Arrayx):
3834
3835 # Constructors (and element access).
3836
3837 a = Array (4)
3838
3839 a[0] = Vec(0)
3840 a[1] = Vec(1)
3841 a[2] = Vec(2)
3842 a[3] = Vec(3)
3843
3844 assert a[0] == Vec(0)
3845 assert a[1] == Vec(1)
3846 assert a[2] == Vec(2)
3847 assert a[3] == Vec(3)
3848
3849 a[0].setValue(10,10,10,10)
3850 a[1].setValue(11,11,11,11)
3851 a[2].setValue(12,12,12,12)
3852 a[3].setValue(13,13,13,13)
3853
3854 assert a[0] == Vec(10)
3855 assert a[1] == Vec(11)
3856 assert a[2] == Vec(12)
3857 assert a[3] == Vec(13)
3858
3859 # Element setting.
3860
3861 a = Array(2)
3862
3863 try:
3864 a[-3] = Vec(0) # This should raise an exception.
3865 except:
3866 pass
3867 else:
3868 assert 0 # We shouldn't get here.
3869
3870 try:
3871 a[4] = Vec(0) # This should raise an exception.
3872 except:
3873 pass
3874 else:
3875 assert 0 # We shouldn't get here.
3876
3877 try:
3878 a[1] = "a" # This should raise an exception.
3879 except:
3880 pass
3881 else:
3882 assert 0 # We shouldn't get here.
3883
3884 # Assignment.
3885
3886 a = Array(2)
3887 a[0] = Vec(0)
3888 a[1] = Vec(1)
3889
3890 b = Array(2)
3891 b[0] = Vec(0)
3892 b[1] = Vec(1)
3893
3894 c = Array(2)
3895 c[0] = Vec(10)
3896 c[1] = Vec(11)
3897
3898 # TODO: make equality work correctly.
3899 #assert a == b
3900 assert a != c
3901
3902 # Dot products.
3903
3904 a = Array(2)
3905 a[0] = Vec(1, 2, 3, 4)
3906 a[1] = Vec(4, 5, 6, 7)
3907
3908 b = Array(2)
3909 b[0] = Vec(7, 8, 9, 10)
3910 b[1] = Vec(10, 11, 12, 13)
3911
3912 r = a.dot(b)
3913 assert r[0] == 1*7 + 2*8 + 3*9 + 4*10
3914 assert r[1] == 4*10 + 5*11 + 6*12 + 7*13
3915
3916 c = Vec(13, 14, 15, 16)
3917 r = a.dot(c)
3918 assert r[0] == 1*13 + 2*14 + 3*15 + 4*16
3919 assert r[1] == 4*13 + 5*14 + 6*15 + 7*16
3920
3921 d = Array(3)
3922 try:
3923 a.dot(d) # This should raise an exception.
3924 except:
3925 pass
3926 else:
3927 assert 0 # We shouldn't get here.
3928
3929 # Addition.
3930
3931 a = Array(2)
3932 a[0] = Vec(1, 2, 3, 4)
3933 a[1] = Vec(4, 5, 6, 7)
3934
3935 b = Array(2)
3936 b[0] = Vec(7, 8, 9, 10)
3937 b[1] = Vec(10, 11, 12, 13)
3938
3939 r = a + b
3940 assert r[0] == Vec(1+7, 2+8, 3+9, 4+10)
3941 assert r[1] == Vec(4+10, 5+11, 6+12, 7+13)
3942
3943 r = a + Vec(10)
3944 assert r[0] == Vec(1+10, 2+10, 3+10, 4+10)
3945 assert r[1] == Vec(4+10, 5+10, 6+10, 7+10)
3946
3947 v = Vec(11)
3948 r = v + a
3949 assert r[0] == Vec(11+1, 11+2, 11+3, 11+4)
3950 assert r[1] == Vec(11+4, 11+5, 11+6, 11+7)
3951
3952 a += b
3953 assert a[0] == Vec(1+7, 2+8, 3+9, 4+10)
3954 assert a[1] == Vec(4+10, 5+11, 6+12, 7+13)
3955
3956 a[0] = Vec(1, 2, 3, 4)
3957 a[1] = Vec(4, 5, 6, 7)
3958
3959 a += Vec(10)
3960 assert a[0] == Vec(1+10, 2+10, 3+10, 4+10)
3961 assert a[1] == Vec(4+10, 5+10, 6+10, 7+10)
3962
3963 c = Array(3)
3964
3965 try:
3966 a + c # This should raise an exception.
3967 except:
3968 pass
3969 else:
3970 assert 0 # We shouldn't get here.
3971
3972 try:
3973 a += c # This should raise an exception.
3974 except:
3975 pass
3976 else:
3977 assert 0 # We shouldn't get here.
3978
3979 # Subtraction.
3980
3981 a = Array(2)
3982 a[0] = Vec(1, 2, 3, 4)
3983 a[1] = Vec(4, 5, 6, 7)
3984
3985 b = Array(2)
3986 b[0] = Vec(7, 8, 9, 10)
3987 b[1] = Vec(10, 11, 12, 13)
3988
3989 r = a - b
3990 assert r[0] == Vec(1-7, 2-8, 3-9, 4-10)
3991 assert r[1] == Vec(4-10, 5-11, 6-12, 7-13)
3992
3993 r = a - Vec(10)
3994 assert r[0] == Vec(1-10, 2-10, 3-10, 4-10)
3995 assert r[1] == Vec(4-10, 5-10, 6-10, 7-10)
3996
3997 v = Vec(11)
3998 r = v - a
3999 assert r[0] == Vec(11-1, 11-2, 11-3, 11-4)
4000 assert r[1] == Vec(11-4, 11-5, 11-6, 11-7)
4001
4002 a -= b
4003 assert a[0] == Vec(1-7, 2-8, 3-9, 4-10)
4004 assert a[1] == Vec(4-10, 5-11, 6-12, 7-13)
4005
4006 a[0] = Vec(1, 2, 3, 4)
4007 a[1] = Vec(4, 5, 6, 7)
4008
4009 a -= Vec(10)
4010 assert a[0] == Vec(1-10, 2-10, 3-10, 4-10)
4011 assert a[1] == Vec(4-10, 5-10, 6-10, 7-10)
4012
4013 c = Array(3)
4014
4015 try:
4016 a - c # This should raise an exception.
4017 except:
4018 pass
4019 else:
4020 assert 0 # We shouldn't get here.
4021
4022 try:
4023 a -= c # This should raise an exception.
4024 except:
4025 pass
4026 else:
4027 assert 0 # We shouldn't get here.
4028
4029 # Negation.
4030
4031 a = Array(2)
4032 a[0] = Vec(1, 2, 3, 4)
4033 a[1] = Vec(4, 5, 6, 7)
4034
4035 r = -a
4036 assert r[0] == Vec(-1, -2, -3, -4)
4037 assert r[1] == Vec(-4, -5, -6, -7)
4038
4039 # Multiplication.
4040
4041 a = Array(2)
4042 a[0] = Vec(1, 2, 3, 4)
4043 a[1] = Vec(4, 5, 6, 7)
4044
4045 r = a * 10
4046 assert r[0] == Vec(1, 2, 3, 4) * 10
4047 assert r[1] == Vec(4, 5, 6, 7) * 10
4048
4049 b = Arrayx(2)
4050 b[0] = 10
4051 b[1] = 11
4052
4053 r = a * b
4054 assert r[0] == Vec(1, 2, 3, 4) * 10
4055 assert r[1] == Vec(4, 5, 6, 7) * 11
4056
4057 a *= 10
4058 assert a[0] == Vec(1, 2, 3, 4) * 10
4059 assert a[1] == Vec(4, 5, 6, 7) * 10
4060
4061 a[0] = Vec(1, 2, 3, 4)
4062 a[1] = Vec(4, 5, 6, 7)
4063
4064 a *= b
4065 assert a[0] == Vec(1, 2, 3, 4) * 10
4066 assert a[1] == Vec(4, 5, 6, 7) * 11
4067
4068 a[0] = Vec(1, 2, 3, 4)
4069 a[1] = Vec(4, 5, 6, 7)
4070
4071 b = Array(2)
4072 b[0] = Vec(7, 8, 9, 10)
4073 b[1] = Vec(10, 11, 12, 13)
4074
4075 r = a * b
4076 assert r[0] == Vec(1*7, 2*8, 3*9, 4*10)
4077 assert r[1] == Vec(4*10, 5*11, 6*12, 7*13)
4078
4079 v = Vec(13, 14, 15, 16)
4080
4081 r = a * v
4082 assert r[0] == Vec(1*13, 2*14, 3*15, 4*16)
4083 assert r[1] == Vec(4*13, 5*14, 6*15, 7*16)
4084
4085 r = v * a
4086 assert r[0] == Vec(1*13, 2*14, 3*15, 4*16)
4087 assert r[1] == Vec(4*13, 5*14, 6*15, 7*16)
4088
4089 a *= b
4090 assert a[0] == Vec(1*7, 2*8, 3*9, 4*10)
4091 assert a[1] == Vec(4*10, 5*11, 6*12, 7*13)
4092
4093 a[0] = Vec(1, 2, 3, 4)
4094 a[1] = Vec(4, 5, 6, 7)
4095
4096 a *= v
4097 assert a[0] == Vec(1*13, 2*14, 3*15, 4*16)
4098 assert a[1] == Vec(4*13, 5*14, 6*15, 7*16)
4099
4100 d = Array(3)
4101 try:
4102 a * d # This should raise an exception.
4103 except:
4104 pass
4105 else:
4106 assert 0 # We shouldn't get here.
4107
4108 try:
4109 a *= d # This should raise an exception.
4110 except:
4111 pass
4112 else:
4113 assert 0 # We shouldn't get here.
4114
4115 # Division.
4116
4117 a = Array(2)
4118 a[0] = Vec(1.0, 2.0, 3.0, 4.0)
4119 a[1] = Vec(4.0, 5.0, 6.0, 7.0)
4120
4121 r = a / 10
4122 assert r[0] == Vec(1.0, 2.0, 3.0, 4.0) / 10
4123 assert r[1] == Vec(4.0, 5.0, 6.0, 7.0) / 10
4124
4125 b = Arrayx(2)
4126 b[0] = 10
4127 b[1] = 11
4128
4129 r = a / b
4130 assert r[0] == Vec(1.0, 2.0, 3.0, 4.0) / 10
4131 assert r[1] == Vec(4.0, 5.0, 6.0, 7.0) / 11
4132
4133 a /= 10
4134 assert a[0] == Vec(1.0, 2.0, 3.0, 4.0) / 10
4135 assert a[1] == Vec(4.0, 5.0, 6.0, 7.0) / 10
4136
4137 a[0] = Vec(1.0, 2.0, 3.0, 4.0)
4138 a[1] = Vec(4.0, 5.0, 6.0, 7.0)
4139
4140 a /= b
4141 assert a[0] == Vec(1.0, 2.0, 3.0, 4.0) / 10
4142 assert a[1] == Vec(4.0, 5.0, 6.0, 7.0) / 11
4143
4144 a[0] = Vec(1.0, 2.0, 3.0, 4.0)
4145 a[1] = Vec(4.0, 5.0, 6.0, 7.0)
4146
4147 b = Array(2)
4148 b[0] = Vec(7.0, 8.0, 9.0, 10.0)
4149 b[1] = Vec(10.0, 11.0, 12.0, 13.0)
4150
4151 r = a / b
4152 assert r[0] == Vec(1.0/7, 2.0/8, 3.0/9, 4.0/10)
4153 assert r[1] == Vec(4.0/10, 5.0/11, 6.0/12, 7.0/13)
4154
4155 v = Vec(13.0, 14.0, 15.0, 16)
4156
4157 r = a / v
4158 assert r[0] == Vec(1.0/13, 2.0/14, 3.0/15, 4.0/16)
4159 assert r[1] == Vec(4.0/13, 5.0/14, 6.0/15, 7.0/16)
4160
4161 # TODO: Figure out why "v / a" is illegal, even though the
4162 # add_arithmetic_math_functions() routine in PyImathFixedArray.h
4163 # should make it possible.
4164 #r = v / a
4165 #assert r[0] == Vec(1.0/13, 2.0/14, 3.0/15)
4166 #assert r[1] == Vec(4.0/13, 5.0/14, 6.0/15)
4167
4168 a /= b
4169 assert a[0] == Vec(1.0/7, 2.0/8, 3.0/9, 4.0/10)
4170 assert a[1] == Vec(4.0/10, 5.0/11, 6.0/12, 7.0/13)
4171
4172 a[0] = Vec(1.0, 2.0, 3.0, 4.0)
4173 a[1] = Vec(4.0, 5.0, 6.0, 7.0)
4174
4175 a /= v
4176 assert a[0] == Vec(1.0/13, 2.0/14, 3.0/15, 4.0/16)
4177 assert a[1] == Vec(4.0/13, 5.0/14, 6.0/15, 7.0/16)
4178
4179 d = Array(3)
4180 try:
4181 a / d # This should raise an exception.
4182 except:
4183 pass
4184 else:
4185 assert 0 # We shouldn't get here.
4186
4187 try:
4188 a /= d # This should raise an exception.
4189 except:
4190 pass
4191 else:
4192 assert 0 # We shouldn't get here.
4193
4194 # Length.
4195
4196 v0 = Vec(1, 2, 3, 4)
4197 v1 = Vec(4, 5, 6, 7)
4198
4199 a = Array(2)
4200 a[0] = v0
4201 a[1] = v1
4202
4203 if (Vec != V4i):
4204 l = a.length()
4205 assert (l[0] == v0.length())
4206 assert (l[1] == v1.length())
4207
4208 l = a.length2()
4209 assert (l[0] == v0.length2())
4210 assert (l[1] == v1.length2())
4211
4212 # Normalizing.
4213
4214 if (Vec != V4i):
4215
4216 a[0] = Vec(1, 2, 3, 4)
4217 a[1] = Vec(4, 5, 6, 7)
4218
4219 r = a.normalized();
4220 assert r[0] == Vec(1, 2, 3, 4).normalized()
4221 assert r[1] == Vec(4, 5, 6, 7).normalized()
4222
4223 a.normalize();
4224 assert a[0] == Vec(1, 2, 3, 4).normalized()
4225 assert a[1] == Vec(4, 5, 6, 7).normalized()
4226
4227 print ("ok")
4228
4229 return
4230
4231 def testV4Array ():
4232
4233 print ("V4iArray")
4234 testV4xArray (V4iArray, V4i, IntArray)
4235 print ("V4fArray")
4236 testV4xArray (V4fArray, V4f, FloatArray)
4237 print ("V4dArray")
4238 testV4xArray (V4dArray, V4d, DoubleArray)
4239
4240 testList.append (('testV4Array',testV4Array))
4241
4242 def testV4xConversions (Vec):
4243
4244 # Assignment
4245
4246 v1 = Vec(0, 1, 2, 3)
4247
4248 v2 = V4i (v1)
4249 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2 and v2[3] == 3
4250
4251 v2 = V4f (v1)
4252 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2 and v2[3] == 3
4253
4254 v2 = V4d (v1)
4255 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2 and v2[3] == 3
4256
4257 # The += operator
4258
4259 v2 = Vec (1, 2, 3, 4)
4260 v2 += V4i (v1)
4261 assert v2[0] == 1 and v2[1] == 3 and v2[2] == 5 and v2[3] == 7
4262
4263 v2 = Vec (1, 2, 3, 4)
4264 v2 += V4f (v1)
4265 assert v2[0] == 1 and v2[1] == 3 and v2[2] == 5 and v2[3] == 7
4266
4267 v2 = Vec (1, 2, 3, 4)
4268 v2 += V4d (v1)
4269 assert v2[0] == 1 and v2[1] == 3 and v2[2] == 5 and v2[3] == 7
4270
4271 # The -= operator
4272
4273 v2 = Vec (1, 2, 3, 4)
4274 v2 -= V4i (v1)
4275 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
4276
4277 v2 = Vec (1, 2, 3, 4)
4278 v2 -= V4f (v1)
4279 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
4280
4281 v2 = Vec (1, 2, 3, 4)
4282 v2 -= V4d (v1)
4283 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
4284
4285 # The *= operator
4286
4287 v2 = Vec (1, 2, 3, 4)
4288 v2 *= V4i (v1)
4289 assert v2[0] == 0 and v2[1] == 2 and v2[2] == 6 and v2[3] == 12
4290
4291 v2 = Vec (1, 2, 3, 4)
4292 v2 *= V4f (v1)
4293 assert v2[0] == 0 and v2[1] == 2 and v2[2] == 6 and v2[3] == 12
4294
4295 v2 = Vec (1, 2, 3, 4)
4296 v2 *= V4d (v1)
4297 assert v2[0] == 0 and v2[1] == 2 and v2[2] == 6 and v2[3] == 12
4298
4299 print ("ok")
4300 return
4301
4302
4303 def testV2xV3xConversion (VecA, VecB):
4304
4305 try:
4306 v = VecA();
4307 v1 = VecB (v); # This should raise an exception.
4308 except:
4309 pass
4310 else:
4311 assert 0 # We shouldn't get here.
4312
4313
4314 def testVecConversions ():
4315
4316 print ("V2i")
4317 testV2xConversions (V2i)
4318 print ("V2f")
4319 testV2xConversions (V2f)
4320 print ("V2d")
4321 testV2xConversions (V2d)
4322
4323 print ("V3i")
4324 testV3xConversions (V3i)
4325 print ("V3f")
4326 testV3xConversions (V3f)
4327 print ("V3d")
4328 testV3xConversions (V3d)
4329
4330 print ("V4i")
4331 testV4xConversions (V4i)
4332 print ("V4f")
4333 testV4xConversions (V4f)
4334 print ("V4d")
4335 testV4xConversions (V4d)
4336
4337
4338 print ("invalid conversions")
4339 # Deliberatly not exhaustive, just representative.
4340 testV2xV3xConversion (V2i, V3f)
4341 testV2xV3xConversion (V3f, V2d)
4342
4343 print ("ok")
4344 return
4345
4346
4347 testList.append (('testVecConversions',testVecConversions))
4348
4349
4350
4351 # -------------------------------------------------------------------------
4352 # Tests for Shear6x
4353
4354 def testShear6x (Shear):
4355
4356 # Constructors (and element access).
4357
4358 h = Shear()
4359 assert h[0] == 0 and h[1] == 0 and h[2] == 0 and \
4360 h[3] == 0 and h[4] == 0 and h[5] == 0
4361
4362 h = Shear(1)
4363 assert h[0] == 1 and h[1] == 1 and h[2] == 1 and \
4364 h[3] == 1 and h[4] == 1 and h[5] == 1
4365
4366 h = Shear(0, 1, 2)
4367 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4368 h[3] == 0 and h[4] == 0 and h[5] == 0
4369
4370 h = Shear((0, 1, 2))
4371 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4372 h[3] == 0 and h[4] == 0 and h[5] == 0
4373
4374 h = Shear(0, 1, 2, 3, 4, 5)
4375 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4376 h[3] == 3 and h[4] == 4 and h[5] == 5
4377
4378 h = Shear((0, 1, 2, 3, 4, 5))
4379 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4380 h[3] == 3 and h[4] == 4 and h[5] == 5
4381
4382 h = Shear()
4383 h.setValue(0, 1, 2, 3, 4, 5)
4384 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4385 h[3] == 3 and h[4] == 4 and h[5] == 5
4386
4387 # Repr.
4388
4389 h = Shear(1/9., 2/9., 3/9., 4/9., 5/9., 6/9.)
4390 assert h == eval(repr(h))
4391
4392 # Sequence length.
4393
4394 h = Shear()
4395 assert len(h) == 6
4396
4397 # Element setting.
4398
4399 h = Shear()
4400 h[0] = 10
4401 h[1] = 11
4402 h[2] = 12
4403 h[3] = 13
4404 h[4] = 14
4405 h[5] = 15
4406 assert h[0] == 10 and h[1] == 11 and h[2] == 12 and \
4407 h[3] == 13 and h[4] == 14 and h[5] == 15
4408
4409 try:
4410 h[-7] = 0 # This should raise an exception.
4411 except:
4412 pass
4413 else:
4414 assert 0 # We shouldn't get here.
4415
4416 try:
4417 h[6] = 0 # This should raise an exception.
4418 except:
4419 pass
4420 else:
4421 assert 0 # We shouldn't get here.
4422
4423 try:
4424 h[1] = "a" # This should raise an exception.
4425 except:
4426 pass
4427 else:
4428 assert 0 # We shouldn't get here.
4429
4430 # Assignment.
4431
4432 h1 = Shear(1)
4433
4434 h2 = h1
4435 assert h2[0] == 1 and h2[1] == 1 and h2[2] == 1 and \
4436 h2[3] == 1 and h2[4] == 1 and h2[5] == 1
4437 h1[0] = 2
4438 assert h2[0] == 2 and h2[1] == 1 and h2[2] == 1 and \
4439 h2[3] == 1 and h2[4] == 1 and h2[5] == 1
4440
4441 # Comparison operators.
4442
4443 h1 = Shear(20, 20, 20, 20, 20, 0)
4444 h2 = Shear(20, 20, 20, 20, 20, 0)
4445 h3 = Shear(20, 20, 20, 20, 21, 0)
4446
4447 assert h1 == h2
4448 assert h1 != h3
4449 assert not (h1 < h2)
4450 assert h1 < h3
4451 assert h1 <= h2
4452 assert h1 <= h3
4453 assert not (h3 <= h1)
4454 assert not (h2 > h1)
4455 assert h3 > h1
4456 assert h2 >= h1
4457 assert h3 >= h1
4458 assert not (h1 >= h3)
4459
4460 # Epsilon equality.
4461
4462 e = 0.005
4463 h1 = Shear(1)
4464 h2 = Shear(1 + e)
4465
4466 assert h1.equalWithAbsError(h2, e)
4467 assert h2.equalWithAbsError(h1, e)
4468
4469 e = 0.003
4470 h1 = Shear(10)
4471 h2 = Shear(10 + 10 * e)
4472
4473 assert h1.equalWithRelError(h2, e)
4474 assert h2.equalWithRelError(h1, e)
4475
4476 # Addition.
4477
4478 h1 = Shear(10, 20, 30, -10, -20, -30)
4479 h2 = Shear(30, 40, 50, -30, -40, -50)
4480
4481 assert h1 + h2 == Shear(40, 60, 80, -40, -60, -80)
4482 assert h2 + h1 == h1 + h2
4483 assert h1 + 1 == Shear(11, 21, 31, -9, -19, -29)
4484 assert 1 + h1 == h1 + 1
4485
4486 # (with the switch to python2, we now allow ops between vectors and tuples)
4487 assert h1 + (1, 2, 3, 4, 5, 6) == Shear(11, 22, 33, -6, -15, -24)
4488 assert (1, 2, 3, 4, 5, 6) + h1 == h1 + (1, 2, 3, 4, 5, 6)
4489
4490 # Subtraction and negation.
4491
4492 h1 = Shear(10, 20, 30, -10, -20, -30)
4493 h2 = Shear(30, 40, 50, -30, -40, -50)
4494
4495 assert h2 - h1 == Shear(20, 20, 20, -20, -20, -20)
4496 assert h1 - 1 == Shear(9, 19, 29, -11, -21, -31)
4497 assert 1 - h1 == - (h1 - 1)
4498
4499 # (with the switch to python2, we now allow ops between vectors and tuples)
4500 assert h1 - (1, 2, 3, 4, 5, 6) == Shear(9, 18, 27, -14, -25, -36)
4501 assert (1, 2, 3, 4, 5, 6) - h1 == - (h1 - (1, 2, 3, 4, 5, 6))
4502
4503 assert h1.negate() == Shear(-10, -20, -30, 10, 20, 30)
4504
4505 # Multiplication.
4506
4507 h1 = Shear(1, 2, 3, -1, -2, -3)
4508 h2 = Shear(3, 4, 5, -3, -4, -5)
4509
4510 assert h1 * h2 == Shear(3, 8, 15, 3, 8, 15)
4511 assert h2 * h1 == h1 * h2
4512 assert 2 * h1 == Shear(2, 4, 6, -2, -4, -6)
4513 assert h1 * 2 == 2 * h1
4514
4515 # (with the switch to python2, we now allow ops between vectors and tuples)
4516 assert h1 * (1, 2, 3, 4, 5, 6) == Shear(1, 4, 9, -4, -10, -18)
4517 assert (1, 2, 3, 4, 5, 6) * h1 == h1 * (1, 2, 3, 4, 5, 6)
4518
4519 # Division.
4520
4521 h1 = Shear(10, 20, 40, -10, -20, -40)
4522 h2 = Shear(2, 4, 8, -2, -4, -8)
4523
4524 assert h1 / h2 == Shear(10/2, 20/4, 40/8, -10/-2, -20/-4, -40/-8)
4525 assert h1 / 2 == Shear(10/2, 20/2, 40/2, -10/2, -20/2, -40/2)
4526 assert Shear(40) / h1 == Shear(40/10, 40/20, 40/40, 40/-10, 40/-20, 40/-40)
4527
4528 # (with the switch to python2, we now allow ops between vectors and tuples)
4529 assert h1 / (1, 2, 4, -1, -2, -4) == Shear(10, 10, 10, 10, 10, 10)
4530 assert Shear(50, 40, 80, -50, -40, -80) / h1 == Shear(5, 2, 2, 5, 2, 2)
4531
4532 print ("ok")
4533
4534 return
4535
4536 def testShear6 ():
4537
4538 print ("Shear6f")
4539 testShear6x (Shear6f)
4540 print ("Shear6d")
4541 testShear6x (Shear6d)
4542
4543 testList.append (('testShear6',testShear6))
4544
4545
4546 # -------------------------------------------------------------------------
4547 # Tests for Shear --> Shear conversions
4548
4549 def testShearV3xConversions (Vec):
4550
4551 v = Vec (0, 1, 2)
4552
4553 h = Shear6f (v)
4554 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4555 h[3] == 0 and h[4] == 0 and h[5] == 0
4556
4557 h = Shear6d (v)
4558 assert h[0] == 0 and h[1] == 1 and h[2] == 2 and \
4559 h[3] == 0 and h[4] == 0 and h[5] == 0
4560
4561 print ("ok")
4562 return
4563
4564
4565 def testShear6xConversions (Shear):
4566
4567 h1 = Shear(0, 1, 2, 3, 4, 5)
4568
4569 h2 = Shear6f (h1)
4570 assert h2[0] == 0 and h2[1] == 1 and h2[2] == 2 and \
4571 h2[3] == 3 and h2[4] == 4 and h2[5] == 5
4572
4573 h2 = Shear6d (h1)
4574 assert h2[0] == 0 and h2[1] == 1 and h2[2] == 2 and \
4575 h2[3] == 3 and h2[4] == 4 and h2[5] == 5
4576
4577 print ("ok")
4578 return
4579
4580
4581 def testShearConversions ():
4582
4583 print ("V3f")
4584 testShearV3xConversions (V3f)
4585 print ("V3d")
4586 testShearV3xConversions (V3d)
4587
4588 print ("Shear6f")
4589 testShear6xConversions (Shear6f)
4590 print ("Shear6d")
4591 testShear6xConversions (Shear6d)
4592
4593 print ("ok")
4594 return
4595
4596
4597 testList.append (('testShearConversions',testShearConversions))
4598
4599
4600 # -------------------------------------------------------------------------
4601 # Tests for M22x
4602
4603 def testM22x (Mat, Vec):
4604
4605 # Constructors (and element access).
4606
4607 m = Mat()
4608 assert m[0][0] == 1 and m[0][1] == 0 and \
4609 m[1][0] == 0 and m[1][1] == 1
4610
4611 m = Mat(1)
4612 assert m[0][0] == 1 and m[0][1] == 1 and \
4613 m[1][0] == 1 and m[1][1] == 1
4614
4615 m = Mat((0, 1), (2, 3))
4616 assert m[0][0] == 0 and m[0][1] == 1 and \
4617 m[1][0] == 2 and m[1][1] == 3
4618
4619
4620 m = Mat(0, 1, 2, 3)
4621 assert m[0][0] == 0 and m[0][1] == 1 and \
4622 m[1][0] == 2 and m[1][1] == 3
4623
4624 # Repr.
4625
4626 m = Mat(0/9., 1/9., 2/9., 3/9.)
4627 assert m == eval(repr(m))
4628
4629 # Sequence length.
4630
4631 m = Mat()
4632 assert len(m) == 2
4633
4634 # Element setting.
4635
4636 m = Mat()
4637 m[0][0] = 10
4638 m[1][1] = 11
4639 assert m[0][0] == 10 and m[1][1] == 11
4640
4641 try:
4642 m[-4][0] = 0 # This should raise an exception.
4643 except:
4644 pass
4645 else:
4646 assert 0 # We shouldn't get here.
4647
4648 try:
4649 v[3][0] = 0 # This should raise an exception.
4650 except:
4651 pass
4652 else:
4653 assert 0 # We shouldn't get here.
4654
4655 try:
4656 m[0][-4] = 0 # This should raise an exception.
4657 except:
4658 pass
4659 else:
4660 assert 0 # We shouldn't get here.
4661
4662 try:
4663 v[0][3] = 0 # This should raise an exception.
4664 except:
4665 pass
4666 else:
4667 assert 0 # We shouldn't get here.
4668
4669 try:
4670 v[1] = (1,2,3) # This should raise an exception.
4671 except:
4672 pass
4673 else:
4674 assert 0 # We shouldn't get here.
4675
4676 # Assignment.
4677
4678 m1 = Mat(1)
4679
4680 m2 = m1
4681 assert m2[0][0] == 1 and m2[0][1] == 1 and \
4682 m2[1][0] == 1 and m2[1][1] == 1
4683
4684 m1[0][0] = 2
4685 assert m2[0][0] == 2 and m2[0][1] == 1 and \
4686 m2[1][0] == 1 and m2[1][1] == 1
4687
4688 # Identity.
4689
4690 m = Mat(2)
4691
4692 m.makeIdentity()
4693 assert m[0][0] == 1 and m[0][1] == 0 and \
4694 m[1][0] == 0 and m[1][1] == 1
4695
4696 # Comparison operators.
4697
4698 m1 = Mat()
4699 m1[1][1] = 2
4700 m2 = Mat()
4701 m2[1][1] = 2
4702 m3 = Mat()
4703 m3[1][1] = 3
4704
4705 assert m1 == m2
4706 assert m1 != m3
4707 assert not (m1 < m2)
4708 assert m1 < m3
4709 assert m1 <= m2
4710 assert m1 <= m3
4711 assert not (m3 <= m1)
4712 assert not (m2 > m1)
4713 assert m3 > m1
4714 assert m2 >= m1
4715 assert m3 >= m1
4716 assert not (m1 >= m3)
4717
4718 # Epsilon equality.
4719
4720 e = 0.005
4721 m1 = Mat(1)
4722 m2 = Mat(1 + e)
4723
4724 assert m1.equalWithAbsError(m2, e)
4725 assert m2.equalWithAbsError(m1, e)
4726
4727 e = 0.003
4728 m1 = Mat(10)
4729 m2 = Mat(10 + 10 * e)
4730
4731 assert m1.equalWithRelError(m2, e)
4732 assert m2.equalWithRelError(m1, e)
4733
4734 # Addition.
4735
4736 m1 = Mat(1)
4737 m2 = Mat(2)
4738
4739 assert m1 + m2 == Mat(3)
4740 assert m2 + m1 == m1 + m2
4741 assert m1 + 1 == Mat(2)
4742 assert 1 + m1 == m1 + 1
4743
4744 # Subtraction and negation.
4745
4746 m1 = Mat(2)
4747 m2 = Mat(3)
4748
4749 assert m2 - m1 == Mat(1)
4750 assert m1 - 1 == Mat(1)
4751 assert 1 - m1 == - (m1 - 1)
4752 assert m1.negate() == Mat(-2)
4753
4754 # Multiplication.
4755
4756 m1 = Mat(1)
4757 # (Scales by (3, 4).)
4758 m2 = Mat()
4759 m2[0][0] = 3
4760 m2[1][1] = 4
4761 v = Vec(1, 2)
4762
4763 assert m1 * 2 == Mat(2)
4764 assert m1 * 2 == 2 * m1
4765 assert m1 * m2 == Mat((3,4),(3,4))
4766 assert v * m2 == Vec(3, 8)
4767 try:
4768 m1 * v # This should raise an exception.
4769 except:
4770 pass
4771 else:
4772 assert 0 # We shouldn't get here.
4773
4774 m2f = M22f()
4775 m2f[0][0] = 1
4776 m2f[1][1] = 2
4777 v = Vec(1, 2)
4778 v *= m2f
4779 assert v == Vec(1, 4)
4780
4781 m2d = M22d()
4782 m2d[0][0] = 1
4783 m2d[1][1] = 2
4784 v = Vec(1, 2)
4785 v *= m2d
4786 assert v == Vec(1, 4)
4787
4788 # (Rotates by 45 degrees.)
4789 m3 = Mat()
4790 m3[0][0] = 0
4791 m3[0][1] = 1
4792 m3[1][0] = -1
4793 m3[1][1] = 0
4794 m4 = m3 * Mat()
4795 v1 = Vec(1, 0)
4796 v2 = Vec()
4797
4798 m4.multDirMatrix(v1,v2)
4799 assert v2.equalWithAbsError((0, 1), v2.baseTypeEpsilon())
4800 v2 = m4.multDirMatrix(v1)
4801 assert v2.equalWithAbsError((0, 1), v2.baseTypeEpsilon())
4802 v1a = V2fArray(1)
4803 v1a[:] = V2f(v1)
4804 v2a = m4.multDirMatrix(v1a)
4805 assert v2a[0].equalWithAbsError((0, 1), v2a[0].baseTypeEpsilon())
4806 v1a = V2dArray(1)
4807 v1a[:] = V2d(v1)
4808 v2a = m4.multDirMatrix(v1a)
4809 assert v2a[0].equalWithAbsError((0, 1), v2a[0].baseTypeEpsilon())
4810
4811 # Division.
4812
4813 m = Mat(4)
4814
4815 assert m / 2 == Mat(2)
4816 try:
4817 4 / m # This should raise an exception.
4818 except:
4819 pass
4820 else:
4821 assert 0 # We shouldn't get here.
4822
4823 # Transpose.
4824
4825 m = Mat(1, 2, 3, 4)
4826
4827 assert m.transpose() == Mat(1, 3, 2, 4)
4828 m.transposed()
4829 assert m == Mat(1, 3, 2, 4)
4830
4831 # Invert.
4832
4833 m1 = Mat()
4834 m1[0][0] = 1
4835 m1[1][1] = 2
4836
4837 m1I = m1.inverse()
4838 assert m1 * m1I == Mat()
4839
4840 m2 = Mat(m1)
4841 m2.invert()
4842 assert m1 * m2 == Mat()
4843
4844 # Rotation (in radians).
4845
4846 v1 = Vec(1, 0)
4847
4848 m = Mat()
4849 m.setRotation(-pi / 2)
4850
4851 v2 = v1 * m
4852 assert v2.equalWithAbsError((0, -1), v2.baseTypeEpsilon())
4853
4854 m.rotate(-pi / 2)
4855
4856 v2 = v1 * m
4857 assert v2.equalWithAbsError((-1, 0), v2.baseTypeEpsilon())
4858
4859 # Scaling.
4860
4861 v1 = Vec(1, 2)
4862
4863 m = Mat()
4864 m.setScale(2)
4865
4866 v2 = v1 * m
4867 assert v2.equalWithAbsError((2, 4), v2.baseTypeEpsilon())
4868
4869 m.scale(3)
4870
4871 v2 = v1 * m
4872 assert v2.equalWithAbsError((6, 12), v2.baseTypeEpsilon())
4873
4874 m = Mat()
4875 m.setScale((1, 2))
4876
4877 v2 = v1 * m
4878 assert v2.equalWithAbsError((1, 4), v2.baseTypeEpsilon())
4879
4880 m.scale((2, 3))
4881
4882 v2 = v1 * m
4883 assert v2.equalWithAbsError((2, 12), v2.baseTypeEpsilon())
4884
4885 # It is not essential for correctness that the following exceptions
4886 # occur. Instead, these tests merely document the way the Python
4887 # wrappings currently work.
4888 try:
4889 m.setScale(1, 2) # This should raise an exception.
4890 except:
4891 pass
4892 else:
4893 assert 0 # We shouldn't get here.
4894
4895 m = Mat()
4896 a = pi/4
4897 # (Rotation by -a around Z axis.)
4898 m[0][0] = cos(a)
4899 m[0][1] = -sin(a)
4900 m[1][0] = sin(a)
4901 m[1][1] = cos(a)
4902 v = Vec()
4903
4904 m.extractEuler(v)
4905 assert v.equalWithAbsError((-a, 0), v.baseTypeEpsilon())
4906
4907 # Determinants (by building a random singular value decomposition)
4908
4909 u = Mat()
4910 v = Mat()
4911 s = Mat()
4912
4913 u.setRotation( random.random() )
4914 v.setRotation( random.random() )
4915 s[0][0] = random.random()
4916 s[1][1] = random.random()
4917
4918 c = u * s * v.transpose()
4919 assert abs(c.determinant() - s[0][0]*s[1][1]) <= u.baseTypeEpsilon()
4920
4921
4922 print ("ok")
4923 return
4924
4925 def testM22 ():
4926
4927 print ("M22f")
4928 testM22x (M22f, V2f)
4929 print ("M22d")
4930 testM22x (M22d, V2d)
4931
4932 testList.append (('testM22',testM22))
4933
4934
4935 # -------------------------------------------------------------------------
4936 # Tests for M33x
4937
4938 def testM33x (Mat, Vec, Vec3):
4939
4940 # Constructors (and element access).
4941
4942 m = Mat()
4943 assert m[0][0] == 1 and m[0][1] == 0 and m[0][2] == 0 and \
4944 m[1][0] == 0 and m[1][1] == 1 and m[1][2] == 0 and \
4945 m[2][0] == 0 and m[2][1] == 0 and m[2][2] == 1
4946
4947 m = Mat(1)
4948 assert m[0][0] == 1 and m[0][1] == 1 and m[0][2] == 1 and \
4949 m[1][0] == 1 and m[1][1] == 1 and m[1][2] == 1 and \
4950 m[2][0] == 1 and m[2][1] == 1 and m[2][2] == 1
4951
4952 m = Mat((0, 1, 2), (3, 4, 5), (6, 7, 8))
4953 assert m[0][0] == 0 and m[0][1] == 1 and m[0][2] == 2 and \
4954 m[1][0] == 3 and m[1][1] == 4 and m[1][2] == 5 and \
4955 m[2][0] == 6 and m[2][1] == 7 and m[2][2] == 8
4956
4957
4958 m = Mat(0, 1, 2, 3, 4, 5, 6, 7, 8)
4959 assert m[0][0] == 0 and m[0][1] == 1 and m[0][2] == 2 and \
4960 m[1][0] == 3 and m[1][1] == 4 and m[1][2] == 5 and \
4961 m[2][0] == 6 and m[2][1] == 7 and m[2][2] == 8
4962
4963 # Repr.
4964
4965 m = Mat(0/9., 1/9., 2/9., 3/9., 4/9., 5/9., 6/9., 7/9., 8/9.)
4966 assert m == eval(repr(m))
4967
4968 # Sequence length.
4969
4970 m = Mat()
4971 assert len(m) == 3
4972
4973 # Element setting.
4974
4975 m = Mat()
4976 m[0][0] = 10
4977 m[1][2] = 11
4978 assert m[0][0] == 10 and m[1][2] == 11
4979
4980 try:
4981 m[-4][0] = 0 # This should raise an exception.
4982 except:
4983 pass
4984 else:
4985 assert 0 # We shouldn't get here.
4986
4987 try:
4988 v[3][0] = 0 # This should raise an exception.
4989 except:
4990 pass
4991 else:
4992 assert 0 # We shouldn't get here.
4993
4994 try:
4995 m[0][-4] = 0 # This should raise an exception.
4996 except:
4997 pass
4998 else:
4999 assert 0 # We shouldn't get here.
5000
5001 try:
5002 v[0][3] = 0 # This should raise an exception.
5003 except:
5004 pass
5005 else:
5006 assert 0 # We shouldn't get here.
5007
5008 try:
5009 v[1] = (1,2,3) # This should raise an exception.
5010 except:
5011 pass
5012 else:
5013 assert 0 # We shouldn't get here.
5014
5015 # Assignment.
5016
5017 m1 = Mat(1)
5018
5019 m2 = m1
5020 assert m2[0][0] == 1 and m2[0][1] == 1 and m2[0][2] == 1 and \
5021 m2[1][0] == 1 and m2[1][1] == 1 and m2[1][2] == 1 and \
5022 m2[2][0] == 1 and m2[2][1] == 1 and m2[2][2] == 1
5023 m1[0][0] = 2
5024 assert m2[0][0] == 2 and m2[0][1] == 1 and m2[0][2] == 1 and \
5025 m2[1][0] == 1 and m2[1][1] == 1 and m2[1][2] == 1 and \
5026 m2[2][0] == 1 and m2[2][1] == 1 and m2[2][2] == 1
5027
5028 # Identity.
5029
5030 m = Mat(2)
5031
5032 m.makeIdentity()
5033 assert m[0][0] == 1 and m[0][1] == 0 and m[0][2] == 0 and \
5034 m[1][0] == 0 and m[1][1] == 1 and m[1][2] == 0 and \
5035 m[2][0] == 0 and m[2][1] == 0 and m[2][2] == 1
5036
5037 # Comparison operators.
5038
5039 m1 = Mat()
5040 m1[1][1] = 2
5041 m2 = Mat()
5042 m2[1][1] = 2
5043 m3 = Mat()
5044 m3[1][1] = 3
5045
5046 assert m1 == m2
5047 assert m1 != m3
5048 assert not (m1 < m2)
5049 assert m1 < m3
5050 assert m1 <= m2
5051 assert m1 <= m3
5052 assert not (m3 <= m1)
5053 assert not (m2 > m1)
5054 assert m3 > m1
5055 assert m2 >= m1
5056 assert m3 >= m1
5057 assert not (m1 >= m3)
5058
5059 # Epsilon equality.
5060
5061 e = 0.005
5062 m1 = Mat(1)
5063 m2 = Mat(1 + e)
5064
5065 assert m1.equalWithAbsError(m2, e)
5066 assert m2.equalWithAbsError(m1, e)
5067
5068 e = 0.003
5069 m1 = Mat(10)
5070 m2 = Mat(10 + 10 * e)
5071
5072 assert m1.equalWithRelError(m2, e)
5073 assert m2.equalWithRelError(m1, e)
5074
5075 # Addition.
5076
5077 m1 = Mat(1)
5078 m2 = Mat(2)
5079
5080 assert m1 + m2 == Mat(3)
5081 assert m2 + m1 == m1 + m2
5082 assert m1 + 1 == Mat(2)
5083 assert 1 + m1 == m1 + 1
5084
5085 # Subtraction and negation.
5086
5087 m1 = Mat(2)
5088 m2 = Mat(3)
5089
5090 assert m2 - m1 == Mat(1)
5091 assert m1 - 1 == Mat(1)
5092 assert 1 - m1 == - (m1 - 1)
5093 assert m1.negate() == Mat(-2)
5094
5095 # Multiplication.
5096
5097 m1 = Mat(1)
5098 # (Translates by (1,2).)
5099 m2 = Mat()
5100 m2[2][0] = 1
5101 m2[2][1] = 2
5102 # (Scales by (3, 4).)
5103 m3 = Mat()
5104 m3[0][0] = 3
5105 m3[1][1] = 4
5106 v = Vec(1, 2)
5107
5108 assert m1 * 2 == Mat(2)
5109 assert m1 * 2 == 2 * m1
5110 assert m2 * m3 == Mat((3,0,0),(0,4,0),(3,8,1))
5111 assert m3 * m2 == Mat((3,0,0),(0,4,0),(1,2,1))
5112 assert v * m2 == Vec(2, 4)
5113 try:
5114 m1 * v # This should raise an exception.
5115 except:
5116 pass
5117 else:
5118 assert 0 # We shouldn't get here.
5119
5120 m2f = M33f()
5121 m2f[2][0] = 1
5122 m2f[2][1] = 2
5123 v = Vec(1, 2)
5124 v *= m2f
5125 assert v == Vec(2, 4)
5126
5127 m2d = M33d()
5128 m2d[2][0] = 1
5129 m2d[2][1] = 2
5130 v = Vec(1, 2)
5131 v *= m2d
5132 assert v == Vec(2, 4)
5133
5134 # (Rotates by 45 degrees, then translates by (1,2).)
5135 m3 = Mat()
5136 m3[0][0] = 0
5137 m3[0][1] = 1
5138 m3[1][0] = -1
5139 m3[1][1] = 0
5140 m4 = m3 * m2
5141 v1 = Vec(1, 0)
5142 v2 = Vec()
5143
5144 m4.multVecMatrix(v1,v2)
5145 assert v2.equalWithAbsError((1, 3), v2.baseTypeEpsilon())
5146 v2 = m4.multVecMatrix(v1)
5147 assert v2.equalWithAbsError((1, 3), v2.baseTypeEpsilon())
5148 v1a = V2fArray(1)
5149 v1a[:] = V2f(v1)
5150 v2a = m4.multVecMatrix(v1a)
5151 assert v2a[0].equalWithAbsError((1, 3), v2a[0].baseTypeEpsilon())
5152 v1a = V2dArray(1)
5153 v1a[:] = V2d(v1)
5154 v2a = m4.multVecMatrix(v1a)
5155 assert v2a[0].equalWithAbsError((1, 3), v2a[0].baseTypeEpsilon())
5156
5157
5158 m4.multDirMatrix(v1,v2)
5159 assert v2.equalWithAbsError((0, 1), v2.baseTypeEpsilon())
5160 v2 = m4.multDirMatrix(v1)
5161 assert v2.equalWithAbsError((0, 1), v2.baseTypeEpsilon())
5162 v1a = V2fArray(1)
5163 v1a[:] = V2f(v1)
5164 v2a = m4.multDirMatrix(v1a)
5165 assert v2a[0].equalWithAbsError((0, 1), v2a[0].baseTypeEpsilon())
5166 v1a = V2dArray(1)
5167 v1a[:] = V2d(v1)
5168 v2a = m4.multDirMatrix(v1a)
5169 assert v2a[0].equalWithAbsError((0, 1), v2a[0].baseTypeEpsilon())
5170
5171 # Division.
5172
5173 m = Mat(4)
5174
5175 assert m / 2 == Mat(2)
5176 try:
5177 4 / m # This should raise an exception.
5178 except:
5179 pass
5180 else:
5181 assert 0 # We shouldn't get here.
5182
5183 # Transpose.
5184
5185 m = Mat(1, 2, 3, 4, 5, 6, 7, 8, 9)
5186
5187 assert m.transpose() == Mat(1, 4, 7, 2, 5, 8, 3, 6, 9)
5188 m.transposed()
5189 assert m == Mat(1, 4, 7, 2, 5, 8, 3, 6, 9)
5190
5191 # Invert.
5192
5193 # (Translates by (1,2).)
5194 m1 = Mat()
5195 m1[2][0] = 1
5196 m1[2][1] = 2
5197
5198 m1I = m1.inverse()
5199 assert m1 * m1I == Mat()
5200 m1I = m1.gjInverse()
5201 assert m1 * m1I == Mat()
5202
5203 m2 = Mat(m1)
5204 m2.invert()
5205 assert m1 * m2 == Mat()
5206 m2 = Mat(m1)
5207 m2.gjInvert()
5208 assert m1 * m2 == Mat()
5209
5210 # Rotation (in radians).
5211
5212 v1 = Vec(1, 0)
5213
5214 m = Mat()
5215 m.setRotation(-pi / 2)
5216
5217 v2 = v1 * m
5218 assert v2.equalWithAbsError((0, -1), v2.baseTypeEpsilon())
5219
5220 m.rotate(-pi / 2)
5221
5222 v2 = v1 * m
5223 assert v2.equalWithAbsError((-1, 0), v2.baseTypeEpsilon())
5224
5225 # Scaling.
5226
5227 v1 = Vec(1, 2)
5228
5229 m = Mat()
5230 m.setScale(2)
5231
5232 v2 = v1 * m
5233 assert v2.equalWithAbsError((2, 4), v2.baseTypeEpsilon())
5234
5235 m.scale(3)
5236
5237 v2 = v1 * m
5238 assert v2.equalWithAbsError((6, 12), v2.baseTypeEpsilon())
5239
5240 m = Mat()
5241 m.setScale((1, 2))
5242
5243 v2 = v1 * m
5244 assert v2.equalWithAbsError((1, 4), v2.baseTypeEpsilon())
5245
5246 m.scale((2, 3))
5247
5248 v2 = v1 * m
5249 assert v2.equalWithAbsError((2, 12), v2.baseTypeEpsilon())
5250
5251 # It is not essential for correctness that the following exceptions
5252 # occur. Instead, these tests merely document the way the Python
5253 # wrappings currently work.
5254 try:
5255 m.setScale(1, 2) # This should raise an exception.
5256 except:
5257 pass
5258 else:
5259 assert 0 # We shouldn't get here.
5260
5261 # Shearing.
5262
5263 v1 = Vec(1, 2)
5264
5265 m = Mat()
5266 m.setShear(2)
5267
5268 v2 = v1 * m
5269 assert v2.equalWithAbsError((5, 2), v2.baseTypeEpsilon())
5270
5271 m.shear(3)
5272
5273 v2 = v1 * m
5274 assert v2.equalWithAbsError((11, 2), v2.baseTypeEpsilon())
5275
5276 m = Mat()
5277 m.setShear((2, 1))
5278
5279 v2 = v1 * m
5280 assert v2.equalWithAbsError((5, 3), v2.baseTypeEpsilon())
5281
5282 m.shear((3, 2))
5283
5284 v2 = v1 * m
5285 assert v2.equalWithAbsError((15, 11), v2.baseTypeEpsilon())
5286
5287 m = Mat()
5288 m.setShear((1, 2))
5289
5290 v2 = v1 * m
5291 assert v2.equalWithAbsError((3, 4), v2.baseTypeEpsilon())
5292
5293 m.shear((2, 3))
5294
5295 v2 = v1 * m
5296 assert v2.equalWithAbsError((10, 15), v2.baseTypeEpsilon())
5297
5298 # It is not essential for correctness that the following exceptions
5299 # occur. Instead, these tests merely document the way the Python
5300 # wrappings currently work.
5301 try:
5302 m.setShear(1, 2) # This should raise an exception.
5303 except:
5304 pass
5305 else:
5306 assert 0 # We shouldn't get here.
5307
5308 # Translation.
5309
5310 v1 = Vec(1, 0)
5311
5312 m = Mat()
5313 m.setTranslation((3, 2))
5314
5315 v2 = v1 * m
5316 assert v2.equalWithAbsError((4, 2), v2.baseTypeEpsilon())
5317
5318 m.translate((1, 2))
5319
5320 v2 = v1 * m
5321 assert v2.equalWithAbsError((5, 4), v2.baseTypeEpsilon())
5322
5323 v3 = m.translation()
5324 assert v3.equalWithAbsError((4, 4), v2.baseTypeEpsilon())
5325
5326 # Extract scaling.
5327
5328 m = Mat()
5329 s = Vec(4, 5)
5330 m.translate((1, 2))
5331 m.shear(7)
5332 m.scale(s)
5333
5334 sM = Vec()
5335 m.extractScaling(sM)
5336 assert sM.equalWithAbsError(s, s.baseTypeEpsilon())
5337
5338 # Sans scaling / Remove scaling.
5339
5340 m1 = Mat()
5341 m1.translate((1, 2))
5342 m1.shear(7)
5343 m1.scale((4, 5))
5344
5345 m2 = m1.sansScaling()
5346 assert m2[0][0] == 1 and m2[1][1] == 1 and \
5347 abs (m2[1][0] - 7) <= 4 * m2.baseTypeEpsilon () and \
5348 abs (m2[0][1]) <= 4 * m2.baseTypeEpsilon () and \
5349 m2[2][0] == 1 and m2[2][1] == 2
5350
5351 m1 = Mat()
5352 m1.translate((1, 2))
5353 m1.shear(7)
5354 m1.scale((0, 0))
5355
5356 try:
5357 m2 = m1.sansScaling() # This should raise an exception.
5358 except:
5359 pass
5360 else:
5361 assert 0 # We shouldn't get here.
5362
5363 m1 = Mat()
5364 m1.translate((1, 2))
5365 m1.shear(7)
5366 m2 = Mat(m1)
5367 m1.scale((4, 5))
5368
5369 r = m1.removeScaling()
5370 assert r == 1 and m1.equalWithAbsError(m2, 4 * m1.baseTypeEpsilon())
5371
5372 m = Mat()
5373 m.translate((1, 2))
5374 m.shear(7)
5375 m.scale((0, 0))
5376
5377 try:
5378 r = m.removeScaling() # This should raise an exception.
5379 except:
5380 pass
5381 else:
5382 assert 0 # We shouldn't get here.
5383
5384 m = Mat()
5385 m.translate((1, 2))
5386 m.shear(7)
5387 m.scale((0, 0))
5388
5389 r = m.removeScaling(0)
5390 assert r == 0
5391
5392 # Sans scaling and shear / Remove scaling and shear.
5393
5394 m1 = Mat()
5395 m1.translate((1, 2))
5396 m1.shear(7)
5397 m1.scale((4, 5))
5398
5399 m2 = m1.sansScalingAndShear()
5400 assert m2[0][0] == 1 and m2[1][1] == 1 and \
5401 m2[1][0] == 0 and m2[0][1] == 0 and \
5402 m2[2][0] == 1 and m2[2][1] == 2
5403
5404 m1 = Mat()
5405 m1.translate((1, 2))
5406 m1.shear(7)
5407 m1.scale((0, 0))
5408
5409 try:
5410 m2 = m1.sansScalingAndShear() # This should raise an exception.
5411 except:
5412 pass
5413 else:
5414 assert 0 # We shouldn't get here.
5415
5416 m1 = Mat()
5417 m1.translate((1, 2))
5418 m2 = Mat(m1)
5419 m1.shear(7)
5420 m1.scale((4, 5))
5421
5422 r = m1.removeScalingAndShear()
5423 assert r == 1 and m1.equalWithAbsError(m2, m1.baseTypeEpsilon())
5424
5425 m = Mat()
5426 m.translate((1, 2))
5427 m.scale((0, 0))
5428
5429 try:
5430 r = m.removeScalingAndShear() # This should raise an exception.
5431 except:
5432 pass
5433 else:
5434 assert 0 # We shouldn't get here.
5435
5436 m = Mat()
5437 m.translate((1, 2))
5438 m.shear(7)
5439 m.scale((0, 0))
5440
5441 r = m.removeScalingAndShear(0)
5442 assert r == 0
5443
5444 # Extract and remove scaling and shear.
5445
5446 m = Mat()
5447 s = Vec(4, 5)
5448 h = Vec(7, 0)
5449 m.translate((1, 2))
5450 m2 = Mat(m)
5451 m.shear(h)
5452 m.scale(s)
5453
5454 sM = Vec()
5455 hM = Vec()
5456 m.extractScalingAndShear(sM, hM)
5457 assert sM.equalWithAbsError(s, s.baseTypeEpsilon())
5458 assert hM.equalWithAbsError(h, 4 * h.baseTypeEpsilon())
5459
5460 sM = Vec()
5461 hM = Vec()
5462 m.extractAndRemoveScalingAndShear(sM, hM)
5463 assert sM.equalWithAbsError(s, s.baseTypeEpsilon())
5464 assert hM.equalWithAbsError(h, 4 * h.baseTypeEpsilon())
5465 assert m2.equalWithAbsError(m, m.baseTypeEpsilon())
5466
5467 # Extract Euler.
5468
5469 m = Mat()
5470 a = pi/4
5471 # (Rotation by -a around Z axis.)
5472 m[0][0] = cos(a)
5473 m[0][1] = -sin(a)
5474 m[1][0] = sin(a)
5475 m[1][1] = cos(a)
5476 v = Vec()
5477
5478 m.extractEuler(v)
5479 assert v.equalWithAbsError((-a, 0), v.baseTypeEpsilon())
5480
5481 # Extract scale, shear, rotation, translation.
5482
5483 s = Vec(1, 2)
5484 h = Vec(0.5, 0)
5485 a = pi/4
5486 t = Vec(4, 5)
5487
5488 mS = Mat()
5489 mS.scale(s)
5490 mH = Mat()
5491 # (Shear by XY, XZ, YZ shear factors.)
5492 mH.shear(h)
5493 mR = Mat()
5494 # (Rotation by -a around Z axis.)
5495 mR[0][0] = cos(a)
5496 mR[0][1] = -sin(a)
5497 mR[1][0] = sin(a)
5498 mR[1][1] = cos(a)
5499 mT = Mat()
5500 mT.translate(t)
5501 m = mS * mH * mR * mT
5502
5503 sInq = Vec()
5504 hInq = Vec()
5505 rInq = Vec()
5506 tInq = Vec()
5507
5508 b = m.extractSHRT(sInq, hInq, rInq, tInq)
5509
5510 assert sInq.equalWithAbsError(s, 2 * sInq.baseTypeEpsilon())
5511 assert hInq.equalWithAbsError(h, hInq.baseTypeEpsilon())
5512 assert rInq.equalWithAbsError((-a, 0), 2 * rInq.baseTypeEpsilon())
5513 assert tInq.equalWithAbsError(t, tInq.baseTypeEpsilon())
5514
5515 # Matrix minors
5516
5517 a = Mat(1,2,3,4,5,6,7,8,9)
5518 assert a.minorOf(0,0) == a.fastMinor(1,2,1,2)
5519 assert a.minorOf(0,1) == a.fastMinor(1,2,0,2)
5520 assert a.minorOf(0,2) == a.fastMinor(1,2,0,1)
5521 assert a.minorOf(1,0) == a.fastMinor(0,2,1,2)
5522 assert a.minorOf(1,1) == a.fastMinor(0,2,0,2)
5523 assert a.minorOf(1,2) == a.fastMinor(0,2,0,1)
5524 assert a.minorOf(2,0) == a.fastMinor(0,1,1,2)
5525 assert a.minorOf(2,1) == a.fastMinor(0,1,0,2)
5526 assert a.minorOf(2,2) == a.fastMinor(0,1,0,1)
5527
5528 # Determinants (by building a random singular value decomposition)
5529
5530 u = Mat()
5531 v = Mat()
5532 s = Mat()
5533
5534 u.setRotation( random.random() )
5535 v.setRotation( random.random() )
5536 s[0][0] = random.random()
5537 s[1][1] = random.random()
5538 s[2][2] = random.random()
5539
5540 c = u * s * v.transpose()
5541 assert abs(c.determinant() - s[0][0]*s[1][1]*s[2][2]) <= u.baseTypeEpsilon()
5542
5543 # Outer product of two 3D vectors
5544
5545 a = Vec3(1,2,3)
5546 b = Vec3(4,5,6)
5547 p = Mat()
5548
5549 p.outerProduct(a,b)
5550 for i in range(3):
5551 for j in range(3):
5552 assert p[i][j] == a[i]*b[j]
5553
5554 print ("ok")
5555 return
5556
5557 def testM33 ():
5558
5559 print ("M33f")
5560 testM33x (M33f, V2f, V3f)
5561 print ("M33d")
5562 testM33x (M33d, V2d, V3d)
5563
5564 testList.append (('testM33',testM33))
5565
5566
5567 # -------------------------------------------------------------------------
5568 # Tests for M44x
5569
5570 def testM44x (Mat, Vec):
5571
5572 # Constructors (and element access).
5573
5574 m = Mat()
5575 assert \
5576 m[0][0] == 1 and m[0][1] == 0 and m[0][2] == 0 and m[0][3] == 0 and \
5577 m[1][0] == 0 and m[1][1] == 1 and m[1][2] == 0 and m[1][3] == 0 and \
5578 m[2][0] == 0 and m[2][1] == 0 and m[2][2] == 1 and m[2][3] == 0 and \
5579 m[3][0] == 0 and m[3][1] == 0 and m[3][2] == 0 and m[3][3] == 1
5580
5581 m = Mat(1)
5582 assert \
5583 m[0][0] == 1 and m[0][1] == 1 and m[0][2] == 1 and m[0][3] == 1 and \
5584 m[1][0] == 1 and m[1][1] == 1 and m[1][2] == 1 and m[1][3] == 1 and \
5585 m[2][0] == 1 and m[2][1] == 1 and m[2][2] == 1 and m[2][3] == 1 and \
5586 m[3][0] == 1 and m[3][1] == 1 and m[3][2] == 1 and m[3][3] == 1
5587
5588 m = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
5589 assert \
5590 m[0][0] == 0 and m[0][1] == 1 and m[0][2] == 2 and m[0][3] == 3 and \
5591 m[1][0] == 4 and m[1][1] == 5 and m[1][2] == 6 and m[1][3] == 7 and \
5592 m[2][0] == 8 and m[2][1] == 9 and m[2][2] ==10 and m[2][3] ==11 and \
5593 m[3][0] ==12 and m[3][1] ==13 and m[3][2] ==14 and m[3][3] ==15
5594
5595 # Repr.
5596
5597 m = Mat((0/9.,1/9.,2/9.,3/9.),
5598 (4/9.,5/9.,6/9.,7/9.),
5599 (8/9.,9/9.,10/9.,11/9.),
5600 (12/9.,13/9.,14/9.,15/9.))
5601 assert m == eval(repr(m))
5602
5603 # Sequence length.
5604
5605 m = Mat()
5606 assert len(m) == 4
5607
5608 # Element setting.
5609
5610 m = Mat()
5611 m[0][0] = 10
5612 m[1][2] = 11
5613 assert m[0][0] == 10 and m[1][2] == 11
5614
5615 try:
5616 m[-5][0] = 0 # This should raise an exception.
5617 except:
5618 pass
5619 else:
5620 assert 0 # We shouldn't get here.
5621
5622 try:
5623 m[4][0] = 0 # This should raise an exception.
5624 except:
5625 pass
5626 else:
5627 assert 0 # We shouldn't get here.
5628
5629 try:
5630 m[0][-5] = 0 # This should raise an exception.
5631 except:
5632 pass
5633 else:
5634 assert 0 # We shouldn't get here.
5635
5636 try:
5637 m[0][4] = 0 # This should raise an exception.
5638 except:
5639 pass
5640 else:
5641 assert 0 # We shouldn't get here.
5642
5643 try:
5644 m[1] = (1,2,3,4) # This should raise an exception.
5645 except:
5646 pass
5647 else:
5648 assert 0 # We shouldn't get here.
5649
5650 # Assignment.
5651
5652 m1 = Mat(1)
5653
5654 m2 = m1
5655 assert \
5656 m2[0][0] ==1 and m2[0][1] ==1 and m2[0][2] ==1 and m2[0][3] ==1 and \
5657 m2[1][0] ==1 and m2[1][1] ==1 and m2[1][2] ==1 and m2[1][3] ==1 and \
5658 m2[2][0] ==1 and m2[2][1] ==1 and m2[2][2] ==1 and m2[2][3] ==1 and \
5659 m2[3][0] ==1 and m2[3][1] ==1 and m2[3][2] ==1 and m2[3][3] ==1
5660
5661 m1[0][0] = 2
5662 assert \
5663 m2[0][0] ==2 and m2[0][1] ==1 and m2[0][2] ==1 and m2[0][3] ==1 and \
5664 m2[1][0] ==1 and m2[1][1] ==1 and m2[1][2] ==1 and m2[1][3] ==1 and \
5665 m2[2][0] ==1 and m2[2][1] ==1 and m2[2][2] ==1 and m2[2][3] ==1 and \
5666 m2[3][0] ==1 and m2[3][1] ==1 and m2[3][2] ==1 and m2[3][3] ==1
5667
5668 # Identity.
5669
5670 m = Mat(2)
5671
5672 m.makeIdentity()
5673 assert \
5674 m[0][0] == 1 and m[0][1] == 0 and m[0][2] == 0 and m[0][3] == 0 and \
5675 m[1][0] == 0 and m[1][1] == 1 and m[1][2] == 0 and m[1][3] == 0 and \
5676 m[2][0] == 0 and m[2][1] == 0 and m[2][2] == 1 and m[2][3] == 0 and \
5677 m[3][0] == 0 and m[3][1] == 0 and m[3][2] == 0 and m[3][3] == 1
5678
5679 # Comparison operators.
5680
5681 m1 = Mat()
5682 m1[1][1] = 2
5683 m2 = Mat()
5684 m2[1][1] = 2
5685 m3 = Mat()
5686 m3[1][1] = 3
5687
5688 assert m1 == m2
5689 assert m1 != m3
5690 assert not (m1 < m2)
5691 assert m1 < m3
5692 assert m1 <= m2
5693 assert m1 <= m3
5694 assert not (m3 <= m1)
5695 assert not (m2 > m1)
5696 assert m3 > m1
5697 assert m2 >= m1
5698 assert m3 >= m1
5699 assert not (m1 >= m3)
5700
5701 # Epsilon equality.
5702
5703 e = 0.005
5704 m1 = Mat(1)
5705 m2 = Mat(1 + e)
5706
5707 assert m1.equalWithAbsError(m2, e)
5708 assert m2.equalWithAbsError(m1, e)
5709
5710 e = 0.003
5711 m1 = Mat(10)
5712 m2 = Mat(10 + 10 * e)
5713
5714 assert m1.equalWithRelError(m2, e)
5715 assert m2.equalWithRelError(m1, e)
5716
5717 # Addition.
5718
5719 m1 = Mat(1)
5720 m2 = Mat(2)
5721
5722 assert m1 + m2 == Mat(3)
5723 assert m2 + m1 == m1 + m2
5724 assert m1 + 1 == Mat(2)
5725 assert 1 + m1 == m1 + 1
5726
5727 # Subtraction and negation.
5728
5729 m1 = Mat(2)
5730 m2 = Mat(3)
5731
5732 assert m2 - m1 == Mat(1)
5733 assert m1 - 1 == Mat(1)
5734 assert 1 - m1 == - (m1 - 1)
5735 assert m1.negate() == Mat(-2)
5736
5737 # Multiplication.
5738
5739 m1 = Mat(1)
5740 # (Translates by (1, 2, 0).)
5741 m2 = Mat()
5742 m2[3][0] = 1
5743 m2[3][1] = 2
5744 # (Scales by (3, 4, 1).)
5745 m3 = Mat()
5746 m3[0][0] = 3
5747 m3[1][1] = 4
5748 v = Vec(1, 2, 0)
5749
5750 assert m1 * 2 == Mat(2)
5751 assert m1 * 2 == 2 * m1
5752 assert m2 * m3 == Mat((3,0,0,0),(0,4,0,0),(0,0,1,0),(3,8,0,1))
5753 assert m3 * m2 == Mat((3,0,0,0),(0,4,0,0),(0,0,1,0),(1,2,0,1))
5754 assert v * m2 == Vec(2, 4, 0)
5755 try:
5756 m1 * v # This should raise an exception.
5757 except:
5758 pass
5759 else:
5760 assert 0 # We shouldn't get here.
5761
5762 m2f = M44f()
5763 m2f[3][0] = 1
5764 m2f[3][1] = 2
5765 v = Vec(1, 2, 0)
5766 v *= m2f
5767 assert v == Vec(2, 4, 0)
5768
5769 m2d = M44d()
5770 m2d[3][0] = 1
5771 m2d[3][1] = 2
5772 v = Vec(1, 2, 0)
5773 v *= m2d
5774 assert v == Vec(2, 4, 0)
5775
5776 # (Rotates by 45 degrees around Z, then translates by (1, 2, 0).)
5777 m3 = Mat()
5778 m3[0][0] = 0
5779 m3[0][1] = 1
5780 m3[1][0] = -1
5781 m3[1][1] = 0
5782 m4 = m3 * m2
5783 v1 = Vec(1, 0, 0)
5784 v2 = Vec()
5785
5786 m4.multVecMatrix(v1,v2)
5787 assert v2.equalWithAbsError((1, 3, 0), v2.baseTypeEpsilon())
5788 v2 = m4.multVecMatrix(v1)
5789 assert v2.equalWithAbsError((1, 3, 0), v2.baseTypeEpsilon())
5790 v1a = V3fArray(1)
5791 v1a[:] = V3f(v1)
5792 v2a = m4.multVecMatrix(v1a)
5793 assert v2a[0].equalWithAbsError((1, 3, 0), v2a[0].baseTypeEpsilon())
5794 v1a = V3dArray(1)
5795 v1a[:] = V3d(v1)
5796 v2a = m4.multVecMatrix(v1a)
5797 assert v2a[0].equalWithAbsError((1, 3, 0), v2a[0].baseTypeEpsilon())
5798
5799 m4.multDirMatrix(v1,v2)
5800 assert v2.equalWithAbsError((0, 1, 0), v2.baseTypeEpsilon())
5801 v2 = m4.multDirMatrix(v1)
5802 assert v2.equalWithAbsError((0, 1, 0), v2.baseTypeEpsilon())
5803 v1a = V3fArray(1)
5804 v1a[:] = V3f(v1)
5805 v2a = m4.multDirMatrix(v1a)
5806 assert v2a[0].equalWithAbsError((0, 1, 0), v2a[0].baseTypeEpsilon())
5807 v1a = V3dArray(1)
5808 v1a[:] = V3d(v1)
5809 v2a = m4.multDirMatrix(v1a)
5810 assert v2a[0].equalWithAbsError((0, 1, 0), v2a[0].baseTypeEpsilon())
5811
5812 # Division.
5813
5814 m = Mat(4)
5815
5816 assert m / 2 == Mat(2)
5817 try:
5818 4 / m # This should raise an exception.
5819 except:
5820 pass
5821 else:
5822 assert 0 # We shouldn't get here.
5823
5824 # Transpose.
5825
5826 m = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
5827
5828 assert m.transpose() == Mat((0,4,8,12), (1,5,9,13), (2,6,10,14), (3,7,11,15))
5829 m.transposed()
5830 assert m == Mat((0,4,8,12), (1,5,9,13), (2,6,10,14), (3,7,11,15))
5831
5832 # Invert.
5833
5834 # (Translates by (1,2).)
5835 m1 = Mat()
5836 m1[3][0] = 1
5837 m1[3][1] = 2
5838
5839 m1I = m1.inverse()
5840 assert m1 * m1I == Mat()
5841 m1I = m1.gjInverse()
5842 assert m1 * m1I == Mat()
5843
5844 m2 = Mat(m1)
5845 m2.invert()
5846 assert m1 * m2 == Mat()
5847 m2 = Mat(m1)
5848 m2.gjInvert()
5849 assert m1 * m2 == Mat()
5850
5851 # Scaling.
5852
5853 v1 = Vec(1, 2, 0)
5854
5855 m = Mat()
5856 m.setScale(2)
5857
5858 v2 = v1 * m
5859 assert v2.equalWithAbsError((2, 4, 0), v2.baseTypeEpsilon())
5860
5861 m.scale(3)
5862
5863 v2 = v1 * m
5864 assert v2.equalWithAbsError((6, 12, 0), v2.baseTypeEpsilon())
5865
5866 m = Mat()
5867 m.setScale((1, 2, 1))
5868
5869 v2 = v1 * m
5870 assert v2.equalWithAbsError((1, 4, 0), v2.baseTypeEpsilon())
5871
5872 m.scale((2, 3, 1))
5873
5874 v2 = v1 * m
5875 assert v2.equalWithAbsError((2, 12, 0), v2.baseTypeEpsilon())
5876
5877 # It is not essential for correctness that the following exceptions
5878 # occur. Instead, these tests merely document the way the Python
5879 # wrappings currently work.
5880 try:
5881 m.setScale(1, 2) # This should raise an exception.
5882 except:
5883 pass
5884 else:
5885 assert 0 # We shouldn't get here.
5886
5887 # Shearing.
5888
5889 v1 = Vec((1, 2, 3))
5890
5891 m = Mat()
5892 m.setShear((2, 3, 4))
5893
5894 v2 = v1 * m
5895 assert v2.equalWithAbsError((14, 14, 3), v2.baseTypeEpsilon())
5896
5897 m.shear((1, 2, 3))
5898
5899 v2 = v1 * m
5900 assert v2.equalWithAbsError((40, 23, 3), v2.baseTypeEpsilon())
5901
5902 m = Mat()
5903 m.setShear((4, 3, 2, -4, -3, -2))
5904
5905 v2 = v1 * m
5906 assert v2.equalWithAbsError((18, 4, -4), v2.baseTypeEpsilon())
5907
5908 m.shear((3, 2, 1, -3, -2, -1))
5909
5910 v2 = v1 * m
5911 assert v2.equalWithAbsError((18, -52, -44), v2.baseTypeEpsilon())
5912
5913 # It is not essential for correctness that the following exceptions
5914 # occur. Instead, these tests merely document the way the Python
5915 # wrappings currently work.
5916 try:
5917 m.setShear(1, 2, 3) # This should raise an exception.
5918 except:
5919 pass
5920 else:
5921 assert 0 # We shouldn't get here.
5922
5923 # It is not essential for correctness that the following exceptions
5924 # occur. Instead, these tests merely document the way the Python
5925 # wrappings currently work.
5926 try:
5927 m.shear(1, 2, 3, 4, 5, 6) # This should raise an exception.
5928 except:
5929 pass
5930 else:
5931 assert 0 # We shouldn't get here.
5932
5933 # Translation.
5934
5935 v1 = Vec(1, 0, 0)
5936
5937 m = Mat()
5938 m.setTranslation((3, 2, 0))
5939
5940 v2 = v1 * m
5941 assert v2.equalWithAbsError((4, 2, 0), v2.baseTypeEpsilon())
5942
5943 m.translate((1, 2, 0))
5944
5945 v2 = v1 * m
5946 assert v2.equalWithAbsError((5, 4, 0), v2.baseTypeEpsilon())
5947
5948 v3 = m.translation()
5949 assert v3.equalWithAbsError((4, 4, 0), v3.baseTypeEpsilon())
5950
5951 # Extract scaling.
5952
5953 m = Mat()
5954 s = Vec(4, 5, 6)
5955 m.translate((1, 2, 3))
5956 m.shear((7, 8, 9))
5957 m.scale(s)
5958
5959 sM = Vec()
5960 m.extractScaling(sM)
5961 assert sM.equalWithAbsError(s, s.baseTypeEpsilon())
5962
5963 # Sans scaling / Remove scaling.
5964
5965 m1 = Mat()
5966 m1.translate((1, 2, 3))
5967 m1.shear((7, 8, 9))
5968 m1.scale((4, 5, 6))
5969
5970 m2 = m1.sansScaling()
5971 assert m2[0][0] == 1 and m2[1][1] == 1 and m2[2][2] == 1 and \
5972 m2[1][0] == 7 and m2[2][0] == 8 and m2[2][1] == 9 and \
5973 m2[0][1] == 0 and m2[0][2] == 0 and m2[1][2] == 0 and \
5974 m2[3][0] == 1 and m2[3][1] == 2 and m2[3][2] == 3
5975
5976 m1 = Mat()
5977 m1.translate((1, 2, 3))
5978 m1.shear((7, 8, 9))
5979 m1.scale((0, 0, 0))
5980
5981 try:
5982 m2 = m1.sansScaling() # This should raise an exception.
5983 except:
5984 pass
5985 else:
5986 assert 0 # We shouldn't get here.
5987
5988 m1 = Mat()
5989 m1.translate((1, 2, 3))
5990 m1.shear((7, 8, 9))
5991 m2 = Mat(m1)
5992 m1.scale((4, 5, 6))
5993
5994 r = m1.removeScaling()
5995 assert r == 1 and m1.equalWithAbsError(m2, m1.baseTypeEpsilon())
5996
5997 m = Mat()
5998 m.translate((1, 2, 3))
5999 m.shear((7, 8, 9))
6000 m.scale((0, 0, 0))
6001
6002 try:
6003 r = m.removeScaling() # This should raise an exception.
6004 except:
6005 pass
6006 else:
6007 assert 0 # We shouldn't get here.
6008
6009 m = Mat()
6010 m.translate((1, 2, 3))
6011 m.shear((7, 8, 9))
6012 m.scale((0, 0, 0))
6013
6014 r = m.removeScaling(0)
6015 assert r == 0
6016
6017 # Sans scaling and shear / Remove scaling and shear.
6018
6019 m1 = Mat()
6020 m1.translate((1, 2, 3))
6021 m1.shear((7, 8, 9))
6022 m1.scale((4, 5, 6))
6023
6024 m2 = m1.sansScalingAndShear()
6025 assert m2[0][0] == 1 and m2[1][1] == 1 and m2[2][2] == 1 and \
6026 m2[1][0] == 0 and m2[2][0] == 0 and m2[2][1] == 0 and \
6027 m2[0][1] == 0 and m2[0][2] == 0 and m2[1][2] == 0 and \
6028 m2[3][0] == 1 and m2[3][1] == 2 and m2[3][2] == 3
6029
6030 m1 = Mat()
6031 m1.translate((1, 2, 3))
6032 m1.shear((7, 8, 9))
6033 m1.scale((0, 0, 0))
6034
6035 try:
6036 m2 = m1.sansScalingAndShear() # This should raise an exception.
6037 except:
6038 pass
6039 else:
6040 assert 0 # We shouldn't get here.
6041
6042 m1 = Mat()
6043 m1.translate((1, 2, 3))
6044 m2 = Mat(m1)
6045 m1.shear((7, 8, 9))
6046 m1.scale((4, 5, 6))
6047
6048 r = m1.removeScalingAndShear()
6049 assert r == 1 and m1.equalWithAbsError(m2, m1.baseTypeEpsilon())
6050
6051 m = Mat()
6052 m.translate((1, 2, 3))
6053 m.scale((0, 0, 0))
6054
6055 try:
6056 r = m.removeScalingAndShear() # This should raise an exception.
6057 except:
6058 pass
6059 else:
6060 assert 0 # We shouldn't get here.
6061
6062 m = Mat()
6063 m.translate((1, 2, 3))
6064 m.shear((7, 8, 9))
6065 m.scale((0, 0, 0))
6066
6067 r = m.removeScalingAndShear(0)
6068 assert r == 0
6069
6070 # Extract and remove scaling and shear.
6071
6072 m = Mat()
6073 s = Vec(4, 5, 6)
6074 h = Vec(7, 8, 9)
6075 m.translate((1, 2, 3))
6076 m2 = Mat(m)
6077 m.shear(h)
6078 m.scale(s)
6079
6080 sM = Vec()
6081 hM = Vec()
6082 m.extractScalingAndShear(sM, hM)
6083 assert sM.equalWithAbsError(s, s.baseTypeEpsilon())
6084 assert hM.equalWithAbsError(h, h.baseTypeEpsilon())
6085
6086 sM = Vec()
6087 hM = Vec()
6088 m.extractAndRemoveScalingAndShear(sM, hM)
6089 assert sM.equalWithAbsError(s, s.baseTypeEpsilon())
6090 assert hM.equalWithAbsError(h, h.baseTypeEpsilon())
6091 assert m2.equalWithAbsError(m, m.baseTypeEpsilon())
6092
6093 # Extract Euler.
6094
6095 m = Mat()
6096 a = pi/4
6097 # (Rotation by -a around Z axis.)
6098 m[0][0] = cos(a)
6099 m[0][1] = -sin(a)
6100 m[1][0] = sin(a)
6101 m[1][1] = cos(a)
6102 v = Vec()
6103
6104 m.extractEulerZYX(v)
6105 assert v.equalWithAbsError((-a, 0, 0), v.baseTypeEpsilon())
6106
6107 m.extractEulerXYZ(v)
6108 assert v.equalWithAbsError((0, 0, -a), v.baseTypeEpsilon())
6109
6110
6111 # Extract scale, shear, rotation, translation.
6112
6113 s = Vec(1, 2, 3)
6114 h = Vec(0.5, 1, 0.75)
6115 a = pi/4
6116 t = Vec(4, 5, 6)
6117
6118 mS = Mat()
6119 mS.scale(s)
6120 mH = Mat()
6121 # (Shear by XY, XZ, YZ shear factors.)
6122 mH.shear(h)
6123 mR = Mat()
6124 # (Rotation by -a around Z axis.)
6125 mR[0][0] = cos(a)
6126 mR[0][1] = -sin(a)
6127 mR[1][0] = sin(a)
6128 mR[1][1] = cos(a)
6129 mT = Mat()
6130 mT.translate(t)
6131 m = mS * mH * mR * mT
6132
6133 sInq = Vec()
6134 hInq = Vec()
6135 rInq = Vec()
6136 tInq = Vec()
6137
6138 b = m.extractSHRT(sInq, hInq, rInq, tInq)
6139
6140 assert sInq.equalWithAbsError(s, 2 * sInq.baseTypeEpsilon())
6141 assert hInq.equalWithAbsError(h, hInq.baseTypeEpsilon())
6142 assert rInq.equalWithAbsError((0, 0, -a), 2 * rInq.baseTypeEpsilon())
6143 assert tInq.equalWithAbsError(t, tInq.baseTypeEpsilon())
6144
6145 # From-to rotation matrix.
6146
6147 fromDir = Vec(1, 1, 0)
6148 fromDir.normalize()
6149 toDir = Vec(0, 1, 1)
6150 toDir.normalize()
6151 m = Mat()
6152 m.rotationMatrix(fromDir, toDir)
6153
6154 v = fromDir * m
6155 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6156
6157 fromDirTup = (fromDir[0], fromDir[1], fromDir[2])
6158 toDirTup = (toDir[0], toDir[1], toDir[2])
6159
6160 m = Mat()
6161 m.rotationMatrix(fromDirTup, toDirTup)
6162
6163 v = fromDir * m
6164 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6165
6166 m = Mat()
6167 m.rotationMatrix(fromDir, toDirTup)
6168
6169 v = fromDir * m
6170 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6171
6172 m = Mat()
6173 m.rotationMatrix(fromDirTup, toDir)
6174
6175 v = fromDir * m
6176 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6177
6178 fromDir = V3f(1, 1, 0)
6179 fromDir.normalize()
6180 toDir = V3f(0, 1, 1)
6181 toDir.normalize()
6182 m = Mat()
6183 m.rotationMatrix(fromDir, toDir)
6184
6185 v = fromDir * m
6186 assert v.equalWithAbsError(toDir, 2 * V3f.baseTypeEpsilon())
6187
6188 fromDir = V3d(1, 1, 0)
6189 fromDir.normalize()
6190 toDir = V3d(0, 1, 1)
6191 toDir.normalize()
6192 m = Mat()
6193 m.rotationMatrix(fromDir, toDir)
6194
6195 v = fromDir * m
6196 assert v.equalWithAbsError(toDir, 2 * V3f.baseTypeEpsilon())
6197
6198 # From-to rotation matrix with up dir.
6199
6200 upDir = Vec(1, 0, 1)
6201 upDir.normalize()
6202 fromDir = Vec(1, 1, 0)
6203 fromDir.normalize()
6204 toDir = Vec(0, 1, 1)
6205 toDir.normalize()
6206 m = Mat()
6207 m.rotationMatrixWithUpDir(fromDir, toDir, upDir)
6208
6209 v = fromDir * m
6210 assert v.equalWithAbsError(toDir, v.baseTypeEpsilon())
6211
6212 fromDirTup = (fromDir[0], fromDir[1], fromDir[2])
6213 toDirTup = (toDir[0], toDir[1], toDir[2])
6214 upDirTup = (upDir[0], upDir[1], upDir[2])
6215
6216 m = Mat()
6217 m.rotationMatrixWithUpDir(fromDirTup, toDirTup, upDirTup)
6218
6219 v = fromDir * m
6220 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6221
6222 m = Mat()
6223 m.rotationMatrixWithUpDir(fromDir, toDirTup, upDirTup)
6224
6225 v = fromDir * m
6226 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6227
6228 m = Mat()
6229 m.rotationMatrixWithUpDir(fromDirTup, toDir, upDirTup)
6230
6231 v = fromDir * m
6232 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6233
6234 m = Mat()
6235 m.rotationMatrixWithUpDir(fromDirTup, toDirTup, upDir)
6236
6237 v = fromDir * m
6238 assert v.equalWithAbsError(toDir, 2 * v.baseTypeEpsilon())
6239
6240 upDir = V3f(1, 0, 1)
6241 upDir.normalize()
6242 fromDir = V3f(1, 1, 0)
6243 fromDir.normalize()
6244 toDir = V3f(0, 1, 1)
6245 toDir.normalize()
6246 m = Mat()
6247 m.rotationMatrixWithUpDir(fromDir, toDir, upDir)
6248
6249 v = fromDir * m
6250 assert v.equalWithAbsError(toDir, V3f.baseTypeEpsilon())
6251
6252 upDir = V3d(1, 0, 1)
6253 upDir.normalize()
6254 fromDir = V3d(1, 1, 0)
6255 fromDir.normalize()
6256 toDir = V3d(0, 1, 1)
6257 toDir.normalize()
6258 m = Mat()
6259 m.rotationMatrixWithUpDir(fromDir, toDir, upDir)
6260
6261 v = fromDir * m
6262 assert v.equalWithAbsError(toDir, V3f.baseTypeEpsilon())
6263
6264 # Determinants (by building a random singular value decomposition)
6265
6266 u = Mat()
6267 v = Mat()
6268 s = Mat()
6269
6270 u.rotationMatrix( V3f(random.random(),random.random(),random.random()).normalize(),
6271 V3f(random.random(),random.random(),random.random()).normalize() )
6272 v.rotationMatrix( V3f(random.random(),random.random(),random.random()).normalize(),
6273 V3f(random.random(),random.random(),random.random()).normalize() )
6274 s[0][0] = random.random()
6275 s[1][1] = random.random()
6276 s[2][2] = random.random()
6277 s[3][3] = random.random()
6278
6279 c = u * s * v.transpose()
6280 assert abs(c.determinant() - s[0][0]*s[1][1]*s[2][2]*s[3][3]) <= u.baseTypeEpsilon()
6281
6282 # Matrix minors
6283
6284 a = Mat(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16)
6285 assert a.minorOf(0,0) == a.fastMinor(1,2,3,1,2,3)
6286 assert a.minorOf(0,1) == a.fastMinor(1,2,3,0,2,3)
6287 assert a.minorOf(0,2) == a.fastMinor(1,2,3,0,1,3)
6288 assert a.minorOf(0,3) == a.fastMinor(1,2,3,0,1,2)
6289 assert a.minorOf(1,0) == a.fastMinor(0,2,3,1,2,3)
6290 assert a.minorOf(1,1) == a.fastMinor(0,2,3,0,2,3)
6291 assert a.minorOf(1,2) == a.fastMinor(0,2,3,0,1,3)
6292 assert a.minorOf(1,3) == a.fastMinor(0,2,3,0,1,2)
6293 assert a.minorOf(2,0) == a.fastMinor(0,1,3,1,2,3)
6294 assert a.minorOf(2,1) == a.fastMinor(0,1,3,0,2,3)
6295 assert a.minorOf(2,2) == a.fastMinor(0,1,3,0,1,3)
6296 assert a.minorOf(2,3) == a.fastMinor(0,1,3,0,1,2)
6297 assert a.minorOf(3,0) == a.fastMinor(0,1,2,1,2,3)
6298 assert a.minorOf(3,1) == a.fastMinor(0,1,2,0,2,3)
6299 assert a.minorOf(3,2) == a.fastMinor(0,1,2,0,1,3)
6300 assert a.minorOf(3,3) == a.fastMinor(0,1,2,0,1,2)
6301
6302 print ("ok")
6303 return
6304
6305 def testM44 ():
6306
6307 print ("M44f")
6308 testM44x (M44f, V3f)
6309 print ("M44d")
6310 testM44x (M44d, V3d)
6311
6312 testList.append (('testM44',testM44))
6313
6314
6315 # -------------------------------------------------------------------------
6316 # Tests for Mat --> Mat conversions
6317
6318 def testM22xConversions (Mat):
6319
6320 # Assignment
6321
6322 m1 = Mat(0,1, 2,3)
6323
6324 m2 = M22f (m1)
6325 assert m2[0][0] == 0 and m2[0][1] == 1
6326
6327 m2 = M22d (m1)
6328 assert m2[0][0] == 0 and m2[0][1] == 1
6329
6330 m2 = M22f(42)
6331 assert m2[0][0] == 42 and m2[0][1] == 42
6332
6333 m2 = M22d(42)
6334 assert m2[0][0] == 42 and m2[0][1] == 42
6335
6336 # The += operator
6337
6338 m2 = Mat(0,1, 2,3)
6339 m2 += M22f (m1)
6340 assert m2[0][0] == 0 and m2[0][1] == 2
6341
6342 m2 = Mat(0,1, 2,3)
6343 m2 += M22d (m1)
6344 assert m2[0][0] == 0 and m2[0][1] == 2
6345
6346 m2 += 1
6347 assert m2[0][0] == 1 and m2[0][1] == 3
6348
6349 # The -= operator
6350
6351 m2 = Mat(0,1, 2,3)
6352 m2 -= M22f (m1)
6353 assert m2[0][0] == 0 and m2[0][1] == 0
6354
6355 m2 = Mat(0,1, 2,3)
6356 m2 -= M22d (m1)
6357 assert m2[0][0] == 0 and m2[0][1] == 0
6358
6359 m2 -= 1
6360 assert m2[0][0] == -1 and m2[0][1] == -1
6361
6362 # The *= operator
6363
6364 m2 = Mat(0,1, 2,3)
6365 m2 *= M22f (m1)
6366 assert m2[0][0] == 0*0 + 1*2
6367 assert m2[0][1] == 0*1 + 1*3
6368
6369 m2 = Mat(0,1, 2,3)
6370 m2 *= M22d (m1)
6371 assert m2[0][0] == 0*0 + 1*2
6372 assert m2[0][1] == 0*1 + 1*3
6373
6374 m2 *= 10
6375 assert m2[0][0] == 20 and m2[0][1] == 30
6376
6377 # The /= operator
6378
6379 m2.makeIdentity()
6380 m2 /= 10
6381 assert equalWithRelErrorScalar(m2[0][0], 1/10.0, 0.0001)
6382
6383 print ("ok")
6384 return
6385
6386
6387 def testM33xConversions (Mat):
6388
6389 # Assignment
6390
6391 m1 = Mat(0,1,2, 3,4,5, 6,7,8)
6392
6393 m2 = M33f (m1)
6394 assert m2[0][0] == 0 and m2[0][1] == 1
6395
6396 m2 = M33d (m1)
6397 assert m2[0][0] == 0 and m2[0][1] == 1
6398
6399 m2 = M33f(42)
6400 assert m2[0][0] == 42 and m2[0][1] == 42
6401
6402 m2 = M33d(42)
6403 assert m2[0][0] == 42 and m2[0][1] == 42
6404
6405 # The += operator
6406
6407 m2 = Mat(0,1,2, 3,4,5, 6,7,8)
6408 m2 += M33f (m1)
6409 assert m2[0][0] == 0 and m2[0][1] == 2
6410
6411 m2 = Mat(0,1,2, 3,4,5, 6,7,8)
6412 m2 += M33d (m1)
6413 assert m2[0][0] == 0 and m2[0][1] == 2
6414
6415 m2 += 1
6416 assert m2[0][0] == 1 and m2[0][1] == 3
6417
6418 # The -= operator
6419
6420 m2 = Mat(0,1,2, 3,4,5, 6,7,8)
6421 m2 -= M33f (m1)
6422 assert m2[0][0] == 0 and m2[0][1] == 0
6423
6424 m2 = Mat(0,1,2, 3,4,5, 6,7,8)
6425 m2 -= M33d (m1)
6426 assert m2[0][0] == 0 and m2[0][1] == 0
6427
6428 m2 -= 1
6429 assert m2[0][0] == -1 and m2[0][1] == -1
6430
6431 # The *= operator
6432
6433 m2 = Mat(0,1,2, 3,4,5, 6,7,8)
6434 m2 *= M33f (m1)
6435 assert m2[0][0] == 0*0 + 1*3 + 2*6
6436 assert m2[0][1] == 0*1 + 1*4 + 2*7
6437
6438 m2 = Mat(0,1,2, 3,4,5, 6,7,8)
6439 m2 *= M33d (m1)
6440 assert m2[0][0] == 0*0 + 1*3 + 2*6
6441 assert m2[0][1] == 0*1 + 1*4 + 2*7
6442
6443 m2 *= 10
6444 assert m2[0][0] == (0*0 + 1*3 + 2*6)*10 and m2[0][1] == (0*1 + 1*4 + 2*7)*10
6445
6446 # The /= operator
6447
6448 m2.makeIdentity()
6449 m2 /= 10
6450 assert equalWithRelErrorScalar(m2[0][0], 1/10.0, 0.0001)
6451
6452 print ("ok")
6453 return
6454
6455
6456 def testM44xConversions (Mat):
6457
6458 # Assignment
6459
6460 m1 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6461
6462 m2 = M44f (m1)
6463 assert m2[0][0] == 0 and m2[0][1] == 1 and m2[0][2] == 2
6464
6465 m2 = M44d (m1)
6466 assert m2[0][0] == 0 and m2[0][1] == 1 and m2[0][2] == 2
6467
6468 m2 = M44f(42)
6469 assert m2[0][0] == 42 and m2[0][1] == 42
6470
6471 m2 = M44d(42)
6472 assert m2[0][0] == 42 and m2[0][1] == 42
6473
6474 # The += operator
6475
6476 m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6477 m2 += M44f (m1)
6478 assert m2[0][0] == 0 and m2[0][1] == 2
6479
6480 m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6481 m2 += M44d (m1)
6482 assert m2[0][0] == 0 and m2[0][1] == 2
6483
6484 m2 += 1
6485 assert m2[0][0] == 1 and m2[0][1] == 3
6486
6487 # The -= operator
6488
6489 m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6490 m2 -= M44f (m1)
6491 assert m2[0][0] == 0 and m2[0][1] == 0
6492
6493 m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6494 m2 -= M44d (m1)
6495 assert m2[0][0] == 0 and m2[0][1] == 0
6496
6497 m2 -= 1
6498 assert m2[0][0] == -1 and m2[0][1] == -1
6499
6500 # The *= operator
6501
6502 m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6503 m2 *= M44f (m1)
6504 assert m2[0][0] == 0*0 + 1*4 + 2*8 + 3*12
6505 assert m2[0][1] == 0*1 + 1*5 + 2*9 + 3*13
6506
6507 m2 = Mat((0,1,2,3), (4,5,6,7), (8,9,10,11), (12,13,14,15))
6508 m2 *= M44d (m1)
6509 assert m2[0][0] == 0*0 + 1*4 + 2*8 + 3*12
6510 assert m2[0][1] == 0*1 + 1*5 + 2*9 + 3*13
6511
6512 m2 *= 10
6513 assert m2[0][0] == (0*0 + 1*4 + 2*8 + 3*12)*10 and m2[0][1] == (0*1 + 1*5 + 2*9 + 3*13)*10
6514
6515 # The /= operator
6516
6517 m2.makeIdentity()
6518 m2 /= 10
6519 assert equalWithRelErrorScalar(m2[0][0], 1/10.0, 0.0001)
6520
6521 print ("ok")
6522 return
6523
6524
6525 def testInvalidConversion (MatA, MatB):
6526 try:
6527 m = MatA();
6528 m1 = MatB (m); # This should raise an exception.
6529 except:
6530 pass
6531 else:
6532 assert 0 # We shouldn't get here.
6533
6534
6535 def testM33xM44xConversion (MatA, MatB):
6536 testInvalidConversion (MatA, MatB)
6537
6538
6539 def testM22xM33xConversion (MatA, MatB):
6540 testInvalidConversion (MatA, MatB)
6541
6542
6543 def testM22xM44xConversion (MatA, MatB):
6544 testInvalidConversion (MatA, MatB)
6545
6546
6547 def testMatConversions ():
6548
6549 print ("M22f")
6550 testM22xConversions (M22f)
6551 print ("M22d")
6552 testM22xConversions (M22d)
6553
6554 print ("M33f")
6555 testM33xConversions (M33f)
6556 print ("M33d")
6557 testM33xConversions (M33d)
6558
6559 print ("M44f")
6560 testM44xConversions (M44f)
6561 print ("M44d")
6562 testM44xConversions (M44d)
6563
6564 print ("invalid conversions")
6565 # Deliberatly not exhaustive, just representative.
6566
6567 testM22xM33xConversion (M22f, M33d)
6568 testM22xM33xConversion (M33f, M22d)
6569
6570 testM22xM44xConversion (M22f, M44d)
6571 testM22xM44xConversion (M44f, M22d)
6572
6573 testM33xM44xConversion (M33f, M44d)
6574 testM33xM44xConversion (M44f, M33d)
6575
6576 print ("ok")
6577 return
6578
6579
6580 testList.append (('testMatConversions',testMatConversions))
6581
6582
6583 # -------------------------------------------------------------------------
6584 # Tests for Box2x
6585
6586 def testBox2x (Box, Vec):
6587
6588 # constructors
6589
6590 b = Box()
6591 assert b.isEmpty() and (not b.hasVolume())
6592
6593 b = Box (Vec (1, 2))
6594 assert (not b.isEmpty()) and (not b.hasVolume())
6595 assert b.min() == Vec (1, 2) and b.max() == Vec (1, 2)
6596
6597 b = Box (Vec (4, 5), Vec (7, 8))
6598 assert (not b.isEmpty()) and b.hasVolume()
6599 assert b.min() == Vec (4, 5) and b.max() == Vec (7, 8)
6600
6601 b1 = Box (b)
6602 assert b1.min() == Vec (4, 5) and b1.max() == Vec (7, 8)
6603
6604 b = Box (((1, 2), (4, 5)))
6605 assert b.min() == Vec (1, 2) and b.max() == Vec (4, 5)
6606
6607 # setMin(), setMax()
6608
6609 b = Box()
6610 b.setMin (Vec (1, 2))
6611 b.setMax (Vec (3, 6))
6612 assert b.min() == Vec (1, 2) and b.max() == Vec (3, 6)
6613 assert b.size() == Vec (2, 4)
6614 assert b.center() == Vec (2, 4)
6615
6616 # makeEmpty()
6617
6618 b.makeEmpty()
6619 assert b.isEmpty()
6620
6621 # extendBy()
6622
6623 b.extendBy (Vec (1, 2))
6624 assert b.min() == Vec (1, 2) and b.max() == Vec (1, 2)
6625
6626 b.extendBy (Vec (0, 2))
6627 assert b.min() == Vec (0, 2) and b.max() == Vec (1, 2)
6628
6629 b.extendBy (Box (Vec (0, 0), Vec (4, 4)))
6630 assert b.min() == Vec (0, 0) and b.max() == Vec (4, 4)
6631
6632 # intersects()
6633
6634 b = Box (Vec (0, 0), Vec (4, 4))
6635 assert b.intersects (Vec (1, 2))
6636 assert not b.intersects (Vec (6, 7))
6637 assert b.intersects (Box (Vec (-2, -2), Vec (1, 1)))
6638 assert not b.intersects (Box (Vec (-2, -2), Vec (-1, -1)))
6639
6640 # majorAxis()
6641
6642 assert 0 == Box(Vec (0, 0), Vec (2, 1)).majorAxis()
6643 assert 1 == Box(Vec (0, 0), Vec (1, 2)).majorAxis()
6644
6645 # repr
6646
6647 b = Box (Vec (1/9., 2/9.), Vec (4/9., 5/9.))
6648 assert b == eval (repr (b))
6649
6650 print ("ok")
6651 return
6652
6653
6654 def testBox2():
6655
6656 print ("Box2i")
6657 testBox2x (Box2i, V2i)
6658 print ("Box2i64")
6659 testBox2x (Box2i64, V2i64)
6660 print ("Box2f")
6661 testBox2x (Box2f, V2f)
6662 print ("Box2d")
6663 testBox2x (Box2d, V2d)
6664
6665
6666 testList.append (('testBox2',testBox2))
6667
6668
6669 # -------------------------------------------------------------------------
6670 # Tests for Box3x
6671
6672 def testBox3x (Box, Vec):
6673
6674 # constructors
6675
6676 b = Box()
6677 assert b.isEmpty() and (not b.hasVolume())
6678
6679 b = Box (Vec (1, 2, 3))
6680 assert (not b.isEmpty()) and (not b.hasVolume())
6681 assert b.min() == Vec (1, 2, 3) and b.max() == Vec (1, 2, 3)
6682
6683 b = Box (Vec (4, 5, 6), Vec (7, 8, 9))
6684 assert (not b.isEmpty()) and b.hasVolume()
6685 assert b.min() == Vec (4, 5, 6) and b.max() == Vec (7, 8, 9)
6686
6687 b1 = Box (b)
6688 assert b1.min() == Vec (4, 5, 6) and b1.max() == Vec (7, 8, 9)
6689
6690 b = Box (((1, 2, 3), (4, 5, 6)))
6691 assert b.min() == Vec (1, 2, 3) and b.max() == Vec (4, 5, 6)
6692
6693 # setMin(), setMax()
6694
6695 b = Box()
6696 b.setMin (Vec (1, 2, 3))
6697 b.setMax (Vec (3, 6, 11))
6698 assert b.min() == Vec (1, 2, 3) and b.max() == Vec (3, 6, 11)
6699 assert b.size() == Vec (2, 4, 8)
6700 assert b.center() == Vec (2, 4, 7)
6701
6702 # makeEmpty()
6703
6704 b.makeEmpty()
6705 assert b.isEmpty()
6706
6707 # extendBy()
6708
6709 b.extendBy (Vec (1, 2, 3))
6710 assert b.min() == Vec (1, 2, 3) and b.max() == Vec (1, 2, 3)
6711
6712 b.extendBy (Vec (0, 2, 4))
6713 assert b.min() == Vec (0, 2, 3) and b.max() == Vec (1, 2, 4)
6714
6715 b.extendBy (Box (Vec (0, 0, 0), Vec (4, 4, 4)))
6716 assert b.min() == Vec (0, 0, 0) and b.max() == Vec (4, 4, 4)
6717
6718 # intersects()
6719
6720 b = Box (Vec (0, 0, 0), Vec (4, 4, 4))
6721 assert b.intersects (Vec (1, 2, 3))
6722 assert not b.intersects (Vec (6, 7, 8))
6723 assert b.intersects (Box (Vec (-2, -2, -2), Vec (1, 1, 1)))
6724 assert not b.intersects (Box (Vec (-2, -2, -2), Vec (-1, -1, -1)))
6725
6726 # majorAxis()
6727
6728 assert 0 == Box(Vec (0, 0, 0), Vec (2, 1, 1)).majorAxis()
6729 assert 1 == Box(Vec (0, 0, 0), Vec (1, 2, 1)).majorAxis()
6730 assert 2 == Box(Vec (0, 0, 0), Vec (1, 1, 2)).majorAxis()
6731
6732 # repr
6733
6734 b = Box (Vec (1/9., 2/9., 3/9.), Vec (4/9., 5/9., 6/9.))
6735 assert b == eval (repr (b))
6736
6737 # tranform
6738
6739 b = Box (Vec (1, 1, 1), Vec (2, 2, 2))
6740
6741 mf = M44f ()
6742 mf.setTranslation (Vec (10, 11, 12))
6743
6744 b2 = b * mf
6745 assert b2.min() == Vec (11, 12, 13)
6746 assert b2.max() == Vec (12, 13, 14)
6747
6748 b *= mf
6749 assert b.min() == Vec (11, 12, 13)
6750 assert b.max() == Vec (12, 13, 14)
6751
6752 b = Box (Vec (1, 1, 1), Vec (2, 2, 2))
6753
6754 md = M44d ()
6755 md.setTranslation (Vec (10, 11, 12))
6756
6757 b2 = b * md
6758 assert b2.min() == Vec (11, 12, 13)
6759 assert b2.max() == Vec (12, 13, 14)
6760
6761 b *= md
6762 assert b.min() == Vec (11, 12, 13)
6763 assert b.max() == Vec (12, 13, 14)
6764
6765 print ("ok")
6766 return
6767
6768
6769 def testBox3():
6770
6771 print ("Box3i")
6772 testBox3x (Box3i, V3i)
6773 print ("Box3i64")
6774 testBox3x (Box3i64, V3i64)
6775 print ("Box3f")
6776 testBox3x (Box3f, V3f)
6777 print ("Box3d")
6778 testBox3x (Box3d, V3d)
6779
6780
6781 testList.append (('testBox3',testBox3))
6782
6783
6784 # -------------------------------------------------------------------------
6785 # Tests for Box --> Box conversions
6786
6787 def testBox2Conversions (Box, Vec):
6788
6789 b1 = Box (Vec (1, 2), Vec (4, 5))
6790
6791 b2 = Box2i (b1)
6792 assert b2.min() == V2i (1, 2) and b2.max() == V2i (4, 5)
6793
6794 b2 = Box2f (b1)
6795 assert b2.min() == V2f (1, 2) and b2.max() == V2f (4, 5)
6796
6797 b2 = Box2d (b1)
6798 assert b2.min() == V2d (1, 2) and b2.max() == V2d (4, 5)
6799
6800 print ("ok")
6801 return
6802
6803
6804 def testBox3Conversions (Box, Vec):
6805
6806 b1 = Box (Vec (1, 2, 3), Vec (4, 5, 6))
6807
6808 b2 = Box3i (b1)
6809 assert b2.min() == V3i (1, 2, 3) and b2.max() == V3i (4, 5, 6)
6810
6811 b2 = Box3f (b1)
6812 assert b2.min() == V3f (1, 2, 3) and b2.max() == V3f (4, 5, 6)
6813
6814 b2 = Box3d (b1)
6815 assert b2.min() == V3d (1, 2, 3) and b2.max() == V3d (4, 5, 6)
6816
6817 print ("ok")
6818 return
6819
6820
6821 def testBox2Box3Conversion (Box1, Box2):
6822
6823 try:
6824 b = Box1();
6825 b1 = Box2 (b); # This should raise an exception.
6826 except:
6827 pass
6828 else:
6829 assert 0 # We shouldn't get here.
6830
6831
6832 def testBoxConversions ():
6833
6834 print ("Box2i")
6835 testBox2Conversions (Box2i, V2i)
6836 print ("Box2i64")
6837 testBox2Conversions (Box2i64, V2i64)
6838 print ("Box2f")
6839 testBox2Conversions (Box2f, V2f)
6840 print ("Box2d")
6841 testBox2Conversions (Box2d, V2d)
6842
6843 print ("Box3i")
6844 testBox3Conversions (Box3i, V3i)
6845 print ("Box3i64")
6846 testBox3Conversions (Box3i64, V3i64)
6847 print ("Box3f")
6848 testBox3Conversions (Box3f, V3f)
6849 print ("Box3d")
6850 testBox3Conversions (Box3d, V3d)
6851
6852 print ("invalid conversions")
6853 testBox2Box3Conversion (Box2i, Box3i)
6854 testBox2Box3Conversion (Box2i, Box3f)
6855 testBox2Box3Conversion (Box3d, Box2i)
6856 testBox2Box3Conversion (Box3f, Box2f)
6857
6858 print ("ok")
6859 return
6860
6861
6862 testList.append (('testBoxConversions',testBoxConversions))
6863
6864
6865 # -------------------------------------------------------------------------
6866 # Tests for Quatx
6867
6868 def testQuatx (Quat, Vec, M33, M44):
6869
6870 # constructors, r(), v()
6871 e = 4 * Vec.baseTypeEpsilon()
6872
6873 q = Quat()
6874 assert q.r() == 1 and q.v() == Vec (0, 0, 0)
6875
6876 q = Quat (2, 3, 4, 5)
6877 assert q.r() == 2 and q.v() == Vec (3, 4, 5)
6878
6879 q = Quat (6, Vec (7, 8, 9))
6880 assert q.r() == 6 and q.v() == Vec (7, 8, 9)
6881
6882 q1 = Quat (q)
6883 assert q1.r() == 6 and q1.v() == Vec (7, 8, 9)
6884
6885 # setR(), setV()
6886
6887 q.setR (1)
6888 q.setV (Vec (2, 3, 4))
6889 assert q.r() == 1 and q.v() == Vec (2, 3, 4)
6890
6891 # invert(), inverse()
6892
6893 q = Quat (1, 0, 0, 1)
6894 assert q.inverse() == Quat (0.5, 0, 0, -0.5)
6895 q.invert()
6896 assert q == Quat (0.5, 0, 0, -0.5)
6897
6898 # normalize(), normalized()
6899
6900 q = Quat (2, Vec (0, 0, 0))
6901 assert q.normalized() == Quat (1, 0, 0, 0)
6902 q.normalize()
6903 assert q == Quat (1, 0, 0, 0)
6904
6905 q = Quat (0, Vec (0, 2, 0))
6906 assert q.normalized() == Quat (0, 0, 1, 0)
6907 q.normalize()
6908 assert q == Quat (0, 0, 1, 0)
6909
6910 # length()
6911
6912 q = Quat (3, 0, 4, 0)
6913 assert q.length() == 5
6914
6915 # setAxisAngle(), angle(), axis()
6916
6917 q.setAxisAngle (Vec (0, 0, 1), pi/2)
6918 v = q.axis()
6919 a = q.angle()
6920 assert v.equalWithAbsError (Vec (0, 0, 1), e)
6921 assert equal(a, pi/2, e)
6922
6923 # setRotation()
6924
6925 q.setRotation (Vec (1, 0, 0), Vec (0, 1, 0))
6926 v = q.axis()
6927 a = q.angle()
6928 assert v.equalWithAbsError (Vec (0, 0, 1), e)
6929 assert equal(a, pi/2, e)
6930
6931 # slerp()
6932
6933 q = Quat()
6934 q.setAxisAngle (Vec (0, 0, 1), pi/2)
6935 p = Quat()
6936 p.setAxisAngle (Vec (1, 0, 0), pi/2)
6937
6938 r = q.slerp (p, 0)
6939
6940 assert equal (r.r(), sqrt(2) / 2, e)
6941
6942 assert r.v().equalWithAbsError (Vec (0, 0, sqrt(2) / 2), e)
6943 r = q.slerp (p, 1)
6944
6945 assert equal (r.r(), sqrt(2) / 2, e)
6946
6947 assert r.v().equalWithAbsError (Vec (sqrt(2) / 2, 0, 0), e)
6948
6949 # toMatrix33(), toMatrix44()
6950
6951 q.setRotation (Vec (1, 0, 0), Vec (0, 1, 0))
6952
6953 m = q.toMatrix33()
6954
6955 assert m.equalWithAbsError (M33 (0, 1, 0,
6956 -1, 0, 0,
6957 0, 0, 1),
6958 m.baseTypeEpsilon())
6959 m = q.toMatrix44()
6960
6961 assert m.equalWithAbsError (M44 (( 0, 1, 0, 0),
6962 (-1, 0, 0, 0),
6963 ( 0, 0, 1, 0),
6964 ( 0, 0, 0, 1)),
6965 m.baseTypeEpsilon())
6966
6967 # +, - (unary and binary), ~ *, /, ^
6968
6969 assert Quat (1, 2, 3, 4) + Quat (5, 6, 7, 8) == Quat (6, 8, 10, 12)
6970
6971 assert Quat (-1, -2, -3, -4) - Quat (5, 6, 7, 8) == Quat (-6, -8, -10, -12)
6972 assert -Quat (1, 2, 3, 4) == Quat (-1, -2, -3, -4)
6973
6974 assert ~Quat (1, 2, 3, 4) == Quat (1, -2, -3, -4)
6975
6976 assert 2 * Quat (1, 2, 3, 4) == Quat (2, 4, 6, 8)
6977 assert Quat (1, 2, 3, 4) * 2 == Quat (2, 4, 6, 8)
6978 assert Quat (1, 0, 0, 1) * Quat (1, 1, 0, 0) == Quat (1, 1, 1, 1)
6979 assert Quat (1, 1, 0, 0) * Quat (1, 0, 0, 1) == Quat (1, 1, -1, 1)
6980
6981 assert Quat (1, 0, 0, 1) / Quat (0.5, -0.5, 0, 0) == Quat (1, 1, 1, 1)
6982 assert Quat (2, 4, 6, 8) / 2 == Quat (1, 2, 3, 4)
6983
6984 assert Quat (1, 2, 3, 4) ^ Quat (2, 2, 2, 2) == 20
6985
6986 # repr
6987
6988 q = Quat (1/9., 2/9., 3/9., 4/9.)
6989 assert q == eval (repr (q))
6990
6991 # extract()
6992
6993 m1 = M44 ()
6994 vFrom = Vec (1, 0, 0)
6995 vTo = Vec (0, 1, 1)
6996 m1.rotationMatrix(vFrom, vTo)
6997 q = Quat ()
6998 q.extract(m1)
6999 m2 = q.toMatrix44()
7000 assert m2.equalWithAbsError(m1, 2*m1.baseTypeEpsilon())
7001
7002 print ("ok")
7003 return
7004
7005
7006 def testQuatConversions ():
7007
7008 q = Quatf (1, V3f (2, 3, 4))
7009 q1 = Quatd (q)
7010 assert q1.r() == 1 and q1.v() == V3d (2, 3, 4)
7011
7012 q = Quatd (1, V3d (2, 3, 4))
7013 q1 = Quatf (q)
7014 assert q1.r() == 1 and q1.v() == V3f (2, 3, 4)
7015
7016 print ("ok")
7017 return
7018
7019
7020 def testQuat():
7021
7022 print ("Quatf")
7023 testQuatx (Quatf, V3f, M33f, M44f)
7024 print ("Quatd")
7025 testQuatx (Quatd, V3d, M33d, M44d)
7026 print ("conversions")
7027 testQuatConversions()
7028
7029
7030 testList.append (('testQuat',testQuat))
7031
7032
7033 # -------------------------------------------------------------------------
7034 # Tests for Eulerx
7035
7036 def testEulerx (Euler, Vec, M33, M44):
7037
7038 # constructors, toXYZVector(), order()
7039
7040 e = Euler()
7041 assert e.toXYZVector() == Vec (0, 0, 0) and e.order() == EULER_XYZ
7042
7043 e = Euler (Vec (1, 2, 3))
7044 assert e.toXYZVector() == Vec (1, 2, 3) and e.order() == EULER_XYZ
7045
7046 e = Euler (Vec (1, 2, 3), EULER_ZYX)
7047 assert e.toXYZVector() == Vec (3, 2, 1) and e.order() == EULER_ZYX
7048
7049 e1 = Euler (e)
7050 assert e1.toXYZVector() == Vec (3, 2, 1) and e1.order() == EULER_ZYX
7051
7052 e = Euler (4, 5, 6)
7053 assert e.toXYZVector() == Vec (4, 5, 6) and e.order() == EULER_XYZ
7054
7055 e = Euler (4, 5, 6, EULER_ZXY)
7056 assert e.toXYZVector() == Vec (5, 6, 4) and e.order() == EULER_ZXY
7057
7058 e = Euler (M33())
7059 assert e.toXYZVector() == Vec (0, 0, 0) and e.order() == EULER_XYZ
7060
7061 e = Euler (M33(), EULER_ZYX)
7062 assert e.toXYZVector() == Vec (0, 0, 0) and e.order() == EULER_ZYX
7063
7064 e = Euler (M44())
7065 assert e.toXYZVector() == Vec (0, 0, 0) and e.order() == EULER_XYZ
7066
7067 e = Euler (M44(), EULER_ZYX)
7068 assert e.toXYZVector() == Vec (0, 0, 0) and e.order() == EULER_ZYX
7069
7070 # comparison
7071
7072 e = Euler (1, 2, 3, EULER_XYZ)
7073
7074 e1 = e
7075 assert e1 == e
7076
7077 e1 = Euler (1, 2, 3, EULER_XZY)
7078 assert e1 != e
7079
7080 e1 = Euler (1, 1, 3, EULER_XYZ)
7081 assert e1 != e
7082
7083 # setXYZVector(), setOrder()
7084
7085 e.setXYZVector (Vec (7, 8, 9))
7086
7087 e.setOrder (EULER_ZYX)
7088 assert e.order() == EULER_ZYX and e.toXYZVector() == Vec (9, 8, 7)
7089
7090 e.setOrder (EULER_XYZ)
7091 assert e.order() == EULER_XYZ and e.toXYZVector() == Vec (7, 8, 9)
7092
7093 # set(), frameStatic(), initialRepeated(), parityEven(), initialAxis()
7094
7095 e.set (EULER_X_AXIS, 0, 0, 1)
7096 assert e.order() == EULER_XZX
7097 assert e.frameStatic() == 1
7098 assert e.initialRepeated() == 1
7099 assert e.parityEven() == 0
7100 assert e.initialAxis() == EULER_X_AXIS
7101
7102 e.set (EULER_Y_AXIS, 1, 0, 1)
7103 assert e.order() == EULER_YZYr
7104 assert e.frameStatic() == 0
7105 assert e.initialRepeated() == 1
7106 assert e.parityEven() == 0
7107 assert e.initialAxis() == EULER_Y_AXIS
7108
7109 e.set (EULER_Z_AXIS, 1, 1, 1)
7110 assert e.order() == EULER_XZXr
7111 assert e.frameStatic() == 0
7112 assert e.initialRepeated() == 1
7113 assert e.parityEven() == 1
7114 assert e.initialAxis() == EULER_Z_AXIS
7115
7116 # extract()
7117
7118 e = Euler (EULER_XYZ);
7119
7120 m = M33 (( 0, 2, 0), # 90-degree rotation around Z,
7121 (-2, 0, 0), # scale by factor 2
7122 ( 0, 0, 2))
7123
7124 e.extract (m);
7125 v = e.toXYZVector();
7126
7127 assert v.equalWithAbsError (Vec (0, 0, pi/2), v.baseTypeEpsilon())
7128
7129 m = M44 (( 0, 2, 0, 0), # 90-degree rotation around Z
7130 (-2, 0, 0, 0), # scale by factor 2
7131 ( 0, 0, 2, 0),
7132 ( 0, 0, 0, 1))
7133
7134 e.extract (m);
7135 v = e.toXYZVector();
7136
7137 assert v.equalWithAbsError (Vec (0, 0, pi/2), v.baseTypeEpsilon())
7138
7139 # toMatrix33(), toMatrix44()
7140
7141 m = e.toMatrix33();
7142
7143 assert m.equalWithAbsError (M33 (0, 1, 0,
7144 -1, 0, 0,
7145 0, 0, 1),
7146 m.baseTypeEpsilon())
7147 m = e.toMatrix44();
7148
7149 assert m.equalWithAbsError (M44 (( 0, 1, 0, 0),
7150 (-1, 0, 0, 0),
7151 ( 0, 0, 1, 0),
7152 ( 0, 0, 0, 1)),
7153 m.baseTypeEpsilon())
7154 # toQuat()
7155
7156 q = e.toQuat();
7157
7158 assert equal (q.r(), sqrt(2) / 2, Vec().baseTypeEpsilon())
7159
7160 assert q.v().equalWithAbsError (Vec (0, 0, sqrt(2) / 2),
7161 Vec().baseTypeEpsilon())
7162
7163 # angleOrder()
7164
7165 e = Euler (EULER_XYZ)
7166 assert e.angleOrder() == (0, 1, 2)
7167
7168 e = Euler (EULER_XZY)
7169 assert e.angleOrder() == (0, 2, 1)
7170
7171 e = Euler (EULER_ZYX)
7172 assert e.angleOrder() == (2, 1, 0)
7173
7174 # makeNear()
7175
7176 e = Euler (0, 0, 0.1 + 2 * pi)
7177 e1 = Euler (0, 0, 0.1)
7178
7179 e.makeNear (e1)
7180 v = e.toXYZVector()
7181 assert v.equalWithAbsError (Vec (0, 0, 0.1), v.baseTypeEpsilon())
7182
7183 # repr
7184
7185 e = Euler (1/9., 2/9., 3/9., EULER_XYZ)
7186 assert e == eval (repr (e))
7187
7188 e = Euler (1/9., 2/9., 3/9., EULER_YXZ)
7189 assert e == eval (repr (e))
7190
7191 e = Euler (1/9., 2/9., 3/9., EULER_XZXr)
7192 assert e == eval (repr (e))
7193
7194 print ("ok")
7195 return
7196
7197
7198 def testEulerConversions ():
7199
7200 e = Eulerf (V3f (1, 2, 3), EULER_XYZ)
7201 e1 = Eulerd (e)
7202 assert e1.toXYZVector() == V3d (1, 2, 3) and e1.order() == EULER_XYZ
7203
7204 e = Eulerd (V3d (1, 2, 3), EULER_XYZ)
7205 e1 = Eulerf (e)
7206 assert e1.toXYZVector() == V3f (1, 2, 3) and e1.order() == EULER_XYZ
7207
7208 print ("ok")
7209 return
7210
7211
7212 def testEuler():
7213
7214 print ("Eulerf")
7215 testEulerx (Eulerf, V3f, M33f, M44f)
7216 print ("Eulerd")
7217 testEulerx (Eulerd, V3d, M33d, M44d)
7218 print ("conversions")
7219 testEulerConversions()
7220
7221
7222 testList.append (('testEuler',testEuler))
7223
7224
7225 # -------------------------------------------------------------------------
7226 # Tests for Line3x
7227
7228 def testLine3x (Line, Vec, Mat):
7229
7230 # constructors, pos(), dir()
7231
7232 l = Line()
7233 assert l.pos() == Vec (0, 0, 0) and l.dir() == Vec (1, 0, 0)
7234
7235 l = Line (Vec (1, 2, 3), Vec (1, 6, 3))
7236 assert l.pos() == Vec (1, 2, 3) and l.dir() == Vec (0, 1, 0)
7237
7238 l1 = Line (l)
7239 assert l1.pos() == Vec (1, 2, 3) and l1.dir() == Vec (0, 1, 0)
7240
7241 # comparison
7242
7243 l = Line (Vec (1, 1, 1), Vec (2, 2, 2))
7244 l1 = Line (l)
7245 assert l == l1
7246
7247 l = Line (Vec (1, 1, 1), Vec (2, 2, 3))
7248 assert l != l1
7249
7250 l = Line (Vec (1, 1, 2), Vec (2, 2, 2))
7251 assert l != l1
7252
7253 # setPos(), setDir(), set()
7254
7255 l.setPos (Vec (4, 5, 6))
7256 l.setDir (Vec (0, 0, 4))
7257 assert l.pos() == Vec (4, 5, 6) and l.dir() == Vec (0, 0, 1)
7258
7259 l.set (Vec (1, 2, 3), Vec (1, 6, 3))
7260 assert l.pos() == Vec (1, 2, 3) and l.dir() == Vec (0, 1, 0)
7261
7262 # pointAt()
7263
7264 l = Line (Vec (1, 2, 3), Vec (2, 2, 3))
7265 assert l.pointAt (2) == Vec (3, 2, 3)
7266
7267 # distanceTo()
7268
7269 l = Line (Vec (0, 0, 0), Vec (1, 0, 0))
7270 assert l.distanceTo (Vec (2, 3, 0)) == 3
7271 assert l.distanceTo (Line (Vec (0, 2, -1), Vec (0, 2, 1))) == 2
7272
7273 # closestPointTo(), closestPoints()
7274
7275 l = Line (Vec (1, 0, 0), Vec (2, 0, 0))
7276 assert l.closestPointTo (Vec (0, 1, 0)) == Vec (0, 0, 0)
7277
7278 l1 = Line (Vec (0, 1, 1), Vec (0, 1, 2))
7279 assert l.closestPointTo (l1) == Vec (0, 0, 0)
7280
7281 p = l.closestPoints (l1)
7282 assert p[0] == Vec (0, 0, 0) and p[1] == Vec (0, 1, 0)
7283
7284 # closestTriangleVertex()
7285
7286 l = Line (Vec (0, 0, 0), Vec (1, 0, 0))
7287 v = l.closestTriangleVertex (Vec (1, 1, 1), Vec (2, 0, 2), Vec (1, 2, 3))
7288 assert v == Vec (1, 1, 1)
7289
7290 # intersectWithTriangle()
7291
7292 l = Line (Vec (0, 0, 0), Vec (1, 0, 0))
7293
7294 i = l.intersectWithTriangle (Vec (1, 1, 0), Vec (1, 2, 0), Vec (2, 2, 0))
7295
7296 assert i == None
7297
7298 i = l.intersectWithTriangle (Vec (4,-1,-1), Vec (4,-1, 2), Vec (4, 2,-1))
7299
7300 assert i[0] == Vec (4, 0, 0)
7301 assert i[1].equalWithAbsError (Vec (1) / 3, i[1].baseTypeEpsilon())
7302 assert i[2] == 0
7303
7304 # rotatePoint()
7305
7306 l = Line (Vec (0, 0, 0), Vec (1, 0, 0))
7307 p = l.rotatePoint (Vec (2, 2, 0), pi/2)
7308
7309 assert p.equalWithAbsError (Vec (2, 0, -2), p.baseTypeEpsilon())
7310
7311 # line*matrix multiplication
7312
7313 l = Line (Vec (0, 0, 0), Vec (1, 0, 0))
7314
7315 m = Mat (( 0, 1, 0, 0),
7316 (-1, 0, 0, 0),
7317 ( 0, 0, 1, 0),
7318 ( 0, 0, 0, 1))
7319
7320 l = l * m
7321 assert l.pos() == Vec (0, 0, 0) and l.dir() == Vec (0, 1, 0)
7322
7323 try:
7324 l = m * l # should raise TypeError
7325 except TypeError:
7326 pass
7327 else:
7328 assert 0
7329
7330 # repr
7331
7332 e = Line (V3f (1/9., 2/9., 3/9.), V3f (1/9., 3/9., 3/9.))
7333 assert e == eval (repr (e))
7334
7335 print ("ok")
7336 return
7337
7338
7339 def testLine3Conversions ():
7340
7341 l = Line3f (V3f (1, 2, 3), V3f (1, 3, 3))
7342 l1 = Line3d (l)
7343 assert l1.pos() == V3d (1, 2, 3) and l1.dir() == V3d (0, 1, 0)
7344
7345 l = Line3d (V3d (1, 2, 3), V3d (1, 3, 3))
7346 l1 = Line3f (l)
7347 assert l1.pos() == V3f (1, 2, 3) and l1.dir() == V3f (0, 1, 0)
7348
7349 print ("ok")
7350 return
7351
7352
7353 def testLine3():
7354
7355 print ("Line3f")
7356 testLine3x (Line3f, V3f, M44f)
7357 print ("Line3d")
7358 testLine3x (Line3d, V3d, M44d)
7359 print ("conversions")
7360 testLine3Conversions()
7361
7362
7363 testList.append (('testLine3',testLine3))
7364
7365
7366 # -------------------------------------------------------------------------
7367 # Tests for Plane3x
7368
7369 def testPlane3x (Plane, Vec, Mat, Line):
7370
7371 # constructors, normal(), distance()
7372
7373 p = Plane()
7374 assert p.normal() == Vec (1, 0, 0) and p.distance() == 0
7375
7376 p = Plane (Vec (0, 4, 0), 3) # normal, distance
7377 assert p.normal() == Vec (0, 1, 0) and p.distance() == 3
7378
7379 p = Plane (Vec (0, 4, 0), Vec (0, 1, 0)) # point, normal
7380 assert p.normal() == Vec (0, 1, 0) and p.distance() == 4
7381
7382 p = Plane (Vec (0, 0, 1), Vec (2, 0, 1), Vec (0, 2, 1)) # three points
7383 assert p.normal() == Vec (0, 0, 1) and p.distance() == 1
7384
7385 p1 = Plane (p)
7386 assert p1.normal() == Vec (0, 0, 1) and p1.distance() == 1
7387
7388 # comparison
7389
7390 p = Plane (Vec (1, 1, 1), 2)
7391 p1 = Plane (p)
7392 assert p == p1
7393
7394 p = Plane (Vec (1, 1, 2), 2)
7395 assert p != p1
7396
7397 p = Plane (Vec (1, 1, 1), 1)
7398 assert p != p1
7399
7400 # setNormal(), setDistance()
7401
7402 p = Plane(Vec (1, 1, 1), 3)
7403 p.setNormal (Vec (0, 0, 4))
7404 p.setDistance (5)
7405 assert p.normal() == Vec (0, 0, 1) and p.distance() == 5
7406
7407 # set()
7408
7409 p.set (Vec (0, 1, 0), 2) # normal, distance
7410 assert p.normal() == Vec (0, 1, 0) and p.distance() == 2
7411
7412 p.set (Vec (0, 2, 0), Vec (0, 0, 1)) # point, normal
7413 assert p.normal() == Vec (0, 0, 1) and p.distance() == 0
7414
7415 p.set (Vec (1, 0, 2), Vec (1, 2, 0), Vec (1, 0, 0)) # three points
7416 assert p.normal() == Vec (-1, 0, 0) and p.distance() == -1
7417
7418 # intersect(), intersectT(), distanceTo(), reflectPoint(), reflectVector()
7419
7420 p = Plane (Vec (2, 0, 2), Vec (2, 2, 0), Vec (2, 0, 0)) # three points
7421
7422 l = Line (Vec (0, 0, 0), Vec (1, 0, 0))
7423 assert p.intersect(l) == Vec (2, 0, 0)
7424 assert p.intersectT(l) == 2
7425
7426 assert p.distanceTo (Vec (1, 2, 3)) == 1
7427 assert p.distanceTo (Vec (3, 2, 3)) == -1
7428
7429 assert p.reflectPoint (Vec (1, 2, 3)) == Vec (3, 2, 3)
7430 assert p.reflectVector (Vec (1, 2, 3)) == Vec (1, -2, -3)
7431
7432 # plane*matrix multiplication
7433
7434 p = Plane (Vec (1, 0, 0), 4)
7435
7436 m = Mat (( 0, 1, 0, 0),
7437 (-1, 0, 0, 0),
7438 ( 0, 0, 1, 0),
7439 ( 0, 0, 0, 1))
7440
7441 p = p * m
7442 assert p.normal().equalWithAbsError (Vec (0, 1, 0), Vec().baseTypeEpsilon())
7443 assert equal (p.distance(), 4, Vec().baseTypeEpsilon())
7444
7445 try:
7446 p = m * p # should raise TypeError
7447 except TypeError:
7448 pass
7449 else:
7450 assert 0
7451
7452 # unary minus operator
7453
7454 assert -Plane (Vec (0, 1, 0), 4) == Plane (Vec (0, -1, 0), -4)
7455
7456 # repr
7457
7458 e = Plane (Vec (0/9., 1/9., 0/9.), 3/9.)
7459 assert e == eval (repr (e))
7460
7461 print ("ok")
7462 return
7463
7464
7465 def testPlane3Conversions ():
7466
7467 p = Plane3f (V3f (1, 0, 0), 3)
7468 p1 = Plane3d (p)
7469 assert p1.normal() == V3d (1, 0, 0) and p1.distance() == 3
7470
7471 p = Plane3d (V3d (1, 0, 0), 3)
7472 p1 = Plane3f (p)
7473 assert p1.normal() == V3f (1, 0, 0) and p1.distance() == 3
7474
7475 print ("ok")
7476 return
7477
7478
7479 def testPlane3():
7480
7481 print ("Plane3f")
7482 testPlane3x (Plane3f, V3f, M44f, Line3f)
7483 print ("Plane3d with Line3f")
7484 testPlane3x (Plane3d, V3d, M44d, Line3f)
7485 print ("Plane3d with Line3d")
7486 testPlane3x (Plane3d, V3d, M44d, Line3d)
7487 print ("conversions")
7488 testPlane3Conversions()
7489
7490
7491 testList.append (('testPlane3',testPlane3))
7492
7493
7494 # -------------------------------------------------------------------------
7495 # Tests for Color3x
7496
7497 def testColor3x (Color, maxComp):
7498
7499 # Constructors (and element access).
7500
7501 v = Color()
7502 assert v[0] == 0 and v[1] == 0 and v[2] == 0
7503
7504 v = Color(1)
7505 assert v[0] == 1 and v[1] == 1 and v[2] == 1
7506
7507 v = Color(0, 1, 2)
7508 assert v[0] == 0 and v[1] == 1 and v[2] == 2
7509
7510 v = Color((0, 1, 2))
7511 assert v[0] == 0 and v[1] == 1 and v[2] == 2
7512
7513 v = Color([0, 1, 2])
7514 assert v[0] == 0 and v[1] == 1 and v[2] == 2
7515
7516 v = Color()
7517 v.setValue(0, 1, 2)
7518 assert v[0] == 0 and v[1] == 1 and v[2] == 2
7519
7520 # Repr.
7521
7522 v = Color(1/9., 2/9., 3/9.)
7523 assert v == eval(repr(v))
7524
7525 # Sequence length.
7526
7527 v = Color()
7528 assert len(v) == 3
7529
7530 # Element setting.
7531
7532 v = Color()
7533 v[0] = 10
7534 v[1] = 11
7535 v[2] = 12
7536 assert v[0] == 10 and v[1] == 11 and v[2] == 12
7537
7538 try:
7539 v[-4] = 0 # This should raise an exception.
7540 except:
7541 pass
7542 else:
7543 assert 0 # We shouldn't get here.
7544
7545 try:
7546 v[3] = 0 # This should raise an exception.
7547 except:
7548 pass
7549 else:
7550 assert 0 # We shouldn't get here.
7551
7552 try:
7553 v[1] = "a" # This should raise an exception.
7554 except:
7555 pass
7556 else:
7557 assert 0 # We shouldn't get here.
7558
7559 # Assignment.
7560
7561 v1 = Color(1)
7562
7563 v2 = v1
7564 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1
7565 v1[0] = 2
7566 assert v2[0] == 2 and v2[1] == 1 and v2[2] == 1
7567
7568 # Comparison operators.
7569
7570 v1 = Color(20, 20, 0)
7571 v2 = Color(20, 20, 0)
7572 v3 = Color(20, 21, 0)
7573
7574 assert v1 == v2
7575 assert v1 != v3
7576 assert not (v1 < v2)
7577 assert v1 < v3
7578 assert v1 <= v2
7579 assert v1 <= v3
7580 assert not (v3 <= v1)
7581 assert not (v2 > v1)
7582 assert v3 > v1
7583 assert v2 >= v1
7584 assert v3 >= v1
7585 assert not (v1 >= v3)
7586
7587 # Addition.
7588
7589 v1 = Color(10, 20, 30)
7590 v2 = Color(30, 40, 50)
7591
7592 assert v1 + v2 == Color(40, 60, 80)
7593 assert v2 + v1 == v1 + v2
7594 assert v1 + 1 == Color(11, 21, 31)
7595 assert 1 + v1 == v1 + 1
7596
7597 # (with the switch to python2, we now allow ops between colors and tuples)
7598 assert v1 + (1, 2, 3) == Color(11, 22, 33)
7599 assert (1, 2, 3) + v1 == v1 + (1, 2, 3)
7600
7601 # Subtraction and negation.
7602
7603 v1 = Color(10, 20, 30)
7604 v2 = Color(30, 40, 50)
7605
7606 assert v2 - v1 == Color(20, 20, 20)
7607 assert v1 - 1 == Color(9, 19, 29)
7608 assert 1 - v1 == - (v1 - 1)
7609
7610 # (with the switch to python2, we now allow ops between colors and tuples)
7611 assert v1 - (1, 2, 3) == Color(9, 18, 27)
7612 assert (1, 2, 3) - v1 == - (v1 - (1, 2, 3))
7613
7614 assert v1.negate() == Color(-10, -20, -30)
7615
7616 # Multiplication.
7617
7618 v1 = Color(1, 2, 3)
7619 v2 = Color(3, 4, 5)
7620
7621 assert v1 * v2 == Color(3, 8, 15)
7622 assert v2 * v1 == v1 * v2
7623 assert 2 * v1 == Color(2, 4, 6)
7624 assert v1 * 2 == 2 * v1
7625
7626 # (with the switch to python2, we now allow ops between colors and tuples)
7627 assert v1 * (1, 2, 3) == Color(1, 4, 9)
7628 assert (1, 2, 3) * v1 == v1 * (1, 2, 3)
7629
7630 # Division.
7631
7632 v1 = Color(10, 20, 40)
7633 v2 = Color(2, 4, 8)
7634
7635 assert v1 / v2 == Color(10/2, 20/4, 40/8)
7636 assert v1 / 2 == Color(10/2, 20/2, 40/2)
7637 assert Color(40) / v1 == Color(40/10, 40/20, 40/40)
7638
7639 # (with the switch to python2, we now allow ops between colors and tuples)
7640 assert v1 / (1, 4, 20) == Color(10/1, 20/4, 40/20)
7641 assert Color(20, 60, 160) / v1 == Color(20/10, 60/20, 160/40)
7642
7643 # Color space conversion.
7644
7645 c1 = Color(maxComp, 0, 0)
7646
7647 c2 = c1.rgb2hsv()
7648 assert c2[0] == 0 and c2[1] == maxComp and c2[2] == maxComp
7649
7650 c3 = c2.hsv2rgb()
7651 assert c3[0] == maxComp and c3[1] == 0 and c3[2] == 0
7652
7653 print ("ok")
7654
7655 return
7656
7657 def testColor3 ():
7658
7659 print ("Color3f")
7660 testColor3x (Color3f, 1.0)
7661 print ("Color3c")
7662 testColor3x (Color3c, 255)
7663
7664 testList.append (('testColor3',testColor3))
7665
7666
7667 # -------------------------------------------------------------------------
7668 # Tests for Color4x
7669
7670 def testColor4x (Color, maxComp):
7671
7672 # Constructors (and element access).
7673
7674 v = Color()
7675 assert v[0] == 0 and v[1] == 0 and v[2] == 0 and v[3] == 0
7676
7677 v = Color(1)
7678 assert v[0] == 1 and v[1] == 1 and v[2] == 1 and v[3] == 1
7679
7680 v = Color(0, 1, 2, 3)
7681 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
7682
7683 v = Color((0, 1, 2, 3))
7684 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
7685
7686 v = Color([0, 1, 2, 3])
7687 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
7688
7689 v = Color()
7690 v.setValue(0, 1, 2, 3)
7691 assert v[0] == 0 and v[1] == 1 and v[2] == 2 and v[3] == 3
7692
7693 # Repr.
7694
7695 v = Color(1/9., 2/9., 3/9., 4/9.)
7696 assert v == eval(repr(v))
7697
7698 # Sequence length.
7699
7700 v = Color()
7701 assert len(v) == 4
7702
7703 # Element setting.
7704
7705 v = Color()
7706 v[0] = 10
7707 v[1] = 11
7708 v[2] = 12
7709 v[3] = 13
7710 assert v[0] == 10 and v[1] == 11 and v[2] == 12 and v[3] == 13
7711
7712 try:
7713 v[-5] = 0 # This should raise an exception.
7714 except:
7715 pass
7716 else:
7717 assert 0 # We shouldn't get here.
7718
7719 try:
7720 v[4] = 0 # This should raise an exception.
7721 except:
7722 pass
7723 else:
7724 assert 0 # We shouldn't get here.
7725
7726 try:
7727 v[1] = "a" # This should raise an exception.
7728 except:
7729 pass
7730 else:
7731 assert 0 # We shouldn't get here.
7732
7733 # Assignment.
7734
7735 v1 = Color(1)
7736
7737 v2 = v1
7738 assert v2[0] == 1 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
7739 v1[0] = 2
7740 assert v2[0] == 2 and v2[1] == 1 and v2[2] == 1 and v2[3] == 1
7741
7742 # Comparison operators.
7743
7744 v1 = Color(20, 20, 0, 0)
7745 v2 = Color(20, 20, 0, 0)
7746 v3 = Color(20, 21, 0, 0)
7747
7748 assert v1 == v2
7749 assert v1 != v3
7750 assert not (v1 < v2)
7751 assert v1 < v3
7752 assert v1 <= v2
7753 assert v1 <= v3
7754 assert not (v3 <= v1)
7755 assert not (v2 > v1)
7756 assert v3 > v1
7757 assert v2 >= v1
7758 assert v3 >= v1
7759 assert not (v1 >= v3)
7760
7761 # Addition.
7762
7763 v1 = Color(10, 20, 30, 0)
7764 v2 = Color(30, 40, 50, 0)
7765
7766 assert v1 + v2 == Color(40, 60, 80, 0)
7767 assert v2 + v1 == v1 + v2
7768 assert v1 + 1 == Color(11, 21, 31, 1)
7769 assert 1 + v1 == v1 + 1
7770
7771 # (with the switch to python2, we now allow ops between colors and tuples)
7772 assert v1 + (1, 2, 3, 4) == Color(11, 22, 33, 4)
7773 assert (1, 2, 3, 4) + v1 == v1 + (1, 2, 3, 4)
7774
7775 # Subtraction and negation.
7776
7777 v1 = Color(10, 20, 30, 0)
7778 v2 = Color(30, 40, 50, 0)
7779
7780 assert v2 - v1 == Color(20, 20, 20, 0)
7781 assert v1 - 1 == Color(9, 19, 29, -1)
7782 assert 1 - v1 == - (v1 - 1)
7783
7784 # (with the switch to python2, we now allow ops between colors and tuples)
7785 assert v1 - (1, 2, 3, 4) == Color(9, 18, 27, -4)
7786 assert (1, 2, 3, 4) - v1 == - (v1 - (1, 2, 3, 4))
7787
7788 assert v1.negate() == Color(-10, -20, -30, 0)
7789
7790 # Multiplication.
7791
7792 v1 = Color(1, 2, 3, 0)
7793 v2 = Color(3, 4, 5, 0)
7794
7795 assert v1 * v2 == Color(3, 8, 15, 0)
7796 assert v2 * v1 == v1 * v2
7797 assert 2 * v1 == Color(2, 4, 6, 0)
7798 assert v1 * 2 == 2 * v1
7799
7800 # (with the switch to python2, we now allow ops between colors and tuples)
7801 assert v1 * (1, 2, 3, 4) == Color(1, 4, 9, 0)
7802 assert (1, 2, 3, 4) * v1 == v1 * (1, 2, 3, 4)
7803
7804 # Division.
7805
7806 v1 = Color(10, 20, 40, 40)
7807 v2 = Color(2, 4, 8, 8)
7808
7809 assert v1 / v2 == Color(10/2, 20/4, 40/8, 40/8)
7810 assert v1 / 2 == Color(10/2, 20/2, 40/2, 40/2)
7811 assert Color(40) / v1 == Color(40/10, 40/20, 40/40, 40/40)
7812
7813 # (with the switch to python2, we now allow ops between colors and tuples)
7814 assert v1 / (1, 4, 8, 20) == Color(10/1, 20/4, 40/8, 40/20)
7815 assert Color(20, 60, 160, 40) / v1 == Color(20/10, 60/20, 160/40, 40/40)
7816
7817 # Color space conversion.
7818
7819 c1 = Color(maxComp, 0, 0, 0)
7820
7821 c2 = c1.rgb2hsv()
7822 assert c2[0] == 0 and c2[1] == maxComp and c2[2] == maxComp and c2[3] == 0
7823
7824 c3 = c2.hsv2rgb()
7825 assert c3[0] == maxComp and c3[1] == 0 and c3[2] == 0 and c3[3] == 0
7826
7827 print ("ok")
7828
7829 return
7830
7831 def testColor4 ():
7832
7833 print ("Color4f")
7834 testColor4x (Color4f, 1.0)
7835 print ("Color4c")
7836 testColor4x (Color4c, 255)
7837
7838 testList.append (('testColor4',testColor4))
7839
7840
7841 # -------------------------------------------------------------------------
7842 # Tests for Color --> Color conversions
7843
7844 def testColor3xConversions (Color):
7845
7846 v1 = Color(0, 1, 2)
7847
7848 v2 = Color3c (v1)
7849 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2
7850
7851 v2 = Color3f (v1)
7852 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2
7853
7854 print ("ok")
7855 return
7856
7857
7858 def testColor4xConversions (Color):
7859
7860 v1 = Color(0, 1, 2, 3)
7861
7862 v2 = Color4c (v1)
7863 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2 and v2[3] == 3
7864
7865 v2 = Color4f (v1)
7866 assert v2[0] == 0 and v2[1] == 1 and v2[2] == 2 and v2[3] == 3
7867
7868 print ("ok")
7869 return
7870
7871
7872 def testColor3xColor4xConversion (ColorA, ColorB):
7873
7874 try:
7875 v = ColorA ();
7876 v1 = ColorB (v); # This should raise an exception.
7877 except:
7878 pass
7879 else:
7880 assert 0 # We shouldn't get here.
7881
7882
7883 def testColorConversions ():
7884
7885 print ("Color3c")
7886 testColor3xConversions (Color3c)
7887 print ("Color3f")
7888 testColor3xConversions (Color3f)
7889 print ("V3i")
7890 testColor3xConversions (V3i)
7891 print ("V3f")
7892 testColor3xConversions (V3f)
7893 print ("V3d")
7894 testColor3xConversions (V3d)
7895
7896 print ("Color4c")
7897 testColor4xConversions (Color4c)
7898 print ("Color4f")
7899 testColor4xConversions (Color4f)
7900
7901 print ("invalid conversions")
7902 # Deliberatly not exhaustive, just representative.
7903 testColor3xColor4xConversion (Color3c, Color4f)
7904 testColor3xColor4xConversion (Color4c, Color3f)
7905
7906 print ("ok")
7907 return
7908
7909
7910 testList.append (('testColorConversions',testColorConversions))
7911
7912
7913 # -------------------------------------------------------------------------
7914 # Tests for Frustumx
7915
7916 def testFrustumx (Frustum, Vec3, Mat):
7917
7918 # Constructors (and accessors).
7919
7920 f = Frustum()
7921
7922 nearPlane = 1
7923 farPlane = 1000
7924 left = -2
7925 right = 2
7926 top = 2
7927 bottom = -2
7928 ortho = 1
7929
7930 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
7931 assert f.nearPlane() == nearPlane and f.farPlane() == farPlane and \
7932 f.left() == left and f.right() == right and \
7933 f.bottom() == bottom and f.top() == top and \
7934 f.orthographic() == ortho
7935
7936 # Repr.
7937
7938 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
7939 assert f.nearPlane() == nearPlane and f.farPlane() == farPlane and \
7940 f.left() == left and f.right() == right and \
7941 f.bottom() == bottom and f.top() == top and \
7942 f.orthographic() == ortho
7943 assert f.near() == nearPlane and f.far() == farPlane
7944
7945 # Assignment.
7946
7947 f1 = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
7948
7949 f2 = f1
7950 assert f2.nearPlane() == f1.nearPlane() and f2.farPlane() == f1.farPlane() and \
7951 f2.left() == f1.left() and f2.right() == f2.right() and \
7952 f2.bottom() == f1.bottom() and f2.top() == f1.top() and \
7953 f2.orthographic() == f1.orthographic()
7954 assert f2.near() == f1.nearPlane() and f2.far() == f1.farPlane()
7955
7956 # Planes.
7957
7958 nearPlane = 1
7959 farPlane = 2
7960 left = -1
7961 right = 1
7962 top = 1
7963 bottom = -1
7964 ortho = 0
7965 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
7966
7967 p1 = f.planes();
7968
7969 topN = Vec3( 0, 1, 1).normalized()
7970 rightN = Vec3( 1, 0, 1).normalized()
7971 bottomN = Vec3( 0,-1, 1).normalized()
7972 leftN = Vec3(-1, 0, 1).normalized()
7973 nearPlaneN = Vec3( 0, 0, 1)
7974 farPlaneN = Vec3( 0, 0,-1)
7975 assert p1[0].normal() == topN and p1[0].distance() == 0
7976 assert p1[1].normal() == rightN and p1[1].distance() == 0
7977 assert p1[2].normal() == bottomN and p1[2].distance() == 0
7978 assert p1[3].normal() == leftN and p1[3].distance() == 0
7979 assert p1[4].normal() == nearPlaneN and p1[4].distance() == -nearPlane
7980 assert p1[5].normal() == farPlaneN and p1[5].distance() == farPlane
7981
7982 m = Mat()
7983 m.rotationMatrix(Vec3(0, 0,-1), (-1, 0, 0))
7984 p2 = f.planes(m)
7985
7986 topN = Vec3( 1, 1, 0).normalized()
7987 rightN = Vec3( 1, 0,-1).normalized()
7988 bottomN = Vec3( 1,-1, 0).normalized()
7989 leftN = Vec3( 1, 0, 1).normalized()
7990 nearPlaneN = Vec3( 1, 0, 0)
7991 farPlaneN = Vec3(-1, 0, 0)
7992 assert p2[0].normal().equalWithAbsError(topN, topN.baseTypeEpsilon())
7993 assert p2[0].distance() == 0
7994 assert p2[1].normal().equalWithAbsError(rightN, rightN.baseTypeEpsilon())
7995 assert p2[1].distance() == 0
7996 assert p2[2].normal().equalWithAbsError(bottomN, bottomN.baseTypeEpsilon())
7997 assert p2[2].distance() == 0
7998 assert p2[3].normal().equalWithAbsError(leftN, leftN.baseTypeEpsilon())
7999 assert p2[3].distance() == 0
8000 assert p2[4].normal().equalWithAbsError(nearPlaneN, nearPlaneN.baseTypeEpsilon())
8001 assert equal(p2[4].distance(), -nearPlane, 2 * nearPlaneN.baseTypeEpsilon())
8002 assert p2[5].normal().equalWithAbsError(farPlaneN, farPlaneN.baseTypeEpsilon())
8003 assert equal(p2[5].distance(), farPlane, 2 * farPlaneN.baseTypeEpsilon())
8004
8005 m_near = f.nearPlane() - 0.1
8006 m_far = f.farPlane() + 100
8007 f.modifyNearAndFar(m_near, m_far)
8008 assert equal(f.nearPlane(), m_near, 2 * farPlaneN.baseTypeEpsilon())
8009 assert equal(f.farPlane(), m_far, 2 * farPlaneN.baseTypeEpsilon())
8010
8011 # Fovy, aspect, projection matrix.
8012
8013 nearPlane = 1
8014 farPlane = 2
8015 left = -1
8016 right = 1
8017 top = 1
8018 bottom = -1
8019 ortho = 0
8020 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
8021
8022 assert equal(f.fovx(), pi / 2.0, Vec3().baseTypeEpsilon())
8023 assert equal(f.aspect(), 1, Vec3().baseTypeEpsilon())
8024
8025 m = f.projectionMatrix()
8026 C = -(farPlane + nearPlane) / (farPlane - nearPlane)
8027 D = (-2 * farPlane * nearPlane) / (farPlane - nearPlane)
8028 E = 2 * nearPlane / (right - left)
8029 F = 2 * nearPlane / (top - bottom)
8030 assert m[0][0] == E
8031 assert m[1][1] == F
8032 assert m[2][2] == C
8033 assert m[3][2] == D
8034 # constructor w/ fov and aspect
8035 g = Frustum(nearPlane, farPlane, f.fovx(), f.fovy(), f.aspect())
8036 assert (g == f)
8037
8038 # Window.
8039
8040 nearPlane = 2
8041 farPlane = 4
8042 left = -2
8043 right = 2
8044 top = 2
8045 bottom = -2
8046 ortho = 0
8047 f1 = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
8048
8049 left2 = -0.5
8050 right2 = 0.5
8051 top2 = 0.25
8052 bottom2 = -0.25
8053 f2 = f1.window(left2, right2, top2, bottom2)
8054 assert f2.left() == -1 and f2.right() == 1
8055 assert f2.top() == 0.5 and f2.bottom() == -0.5
8056
8057 # Project screen to ray, point to screen.
8058
8059 nearPlane = 1
8060 farPlane = 2
8061 left = -1
8062 right = 1
8063 top = 1
8064 bottom = -1
8065 ortho = 0
8066 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
8067
8068 s = 0.5
8069 t = 0.5
8070 l = f.projectScreenToRay((s, t))
8071
8072 p3d = Vec3(left + (right - left) * (1 + s) / 2.0,
8073 bottom + (top - bottom) * (1 + t) / 2.0, -nearPlane)
8074 assert iszero(l.distanceTo(p3d), 2 * p3d.baseTypeEpsilon())
8075
8076 p2d = f.projectPointToScreen(p3d)
8077 assert p2d.equalWithAbsError((s, t), p2d.baseTypeEpsilon())
8078
8079 p3df = V3f (p3d)
8080 p2d = f.projectPointToScreen(p3df)
8081 assert p2d.equalWithAbsError((s, t), p2d.baseTypeEpsilon())
8082
8083 p3dd = V3d (p3d)
8084 p2d = f.projectPointToScreen(p3dd)
8085 assert p2d.equalWithAbsError((s, t), p2d.baseTypeEpsilon())
8086 ortho = 1
8087 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
8088 s = 0.5
8089 t = 0.5
8090 l = f.projectScreenToRay((s, t))
8091 assert equalWithRelError (l.pos(), V3f(0.5, 0.5, 0), 0.001)
8092 assert equalWithRelError (l.dir(), V3f(0.0, 0.0, -1), 0.001)
8093
8094 p2d = f.projectPointToScreen(p3d)
8095 assert equalWithRelError (p2d, V2f(0.5, 0.5), 0.001)
8096
8097 # Conversion between depth and Z.
8098
8099 f = Frustum()
8100 zMin = 1
8101 zMax = 100
8102
8103 assert round(f.ZToDepth(zMin, zMin, zMax)) == round(-f.nearPlane())
8104 assert round(f.ZToDepth(zMax, zMin, zMax)) == round(-f.farPlane())
8105 assert (f.near() == f.nearPlane())
8106 assert (f.far() == f.farPlane())
8107
8108 assert round(f.normalizedZToDepth(-1)) == round(-f.nearPlane())
8109 assert round(f.normalizedZToDepth(1)) == round(-f.farPlane())
8110
8111 assert f.DepthToZ(-f.nearPlane(), zMin, zMax) == zMin
8112 assert f.DepthToZ(-f.farPlane(), zMin, zMax) == zMax
8113 f.setOrthographic(True)
8114 assert equalWithRelErrorScalar (f.normalizedZToDepth(-1), 999.8, 0.01)
8115 assert equalWithRelErrorScalar (f.DepthToZ(-f.nearPlane(), zMin, zMax), 1.0, 0.001)
8116 assert equalWithRelErrorScalar (f.DepthToZ(-f.farPlane(), zMin, zMax), 100.0, 0.001)
8117
8118 # Screen and world radius conversion.
8119
8120 nearPlane = 1
8121 farPlane = 10
8122 left = -1
8123 right = 1
8124 top = 1
8125 bottom = -1
8126 ortho = 0
8127 f = Frustum(nearPlane, farPlane, left, right, top, bottom, ortho)
8128
8129 d = 4
8130 s = 0.75
8131 r1 = f.screenRadius((0, 0, -d), d * s)
8132 assert equal(r1, s, Vec3().baseTypeEpsilon())
8133
8134 r2 = f.worldRadius((0, 0, -d), r1)
8135 assert equal(r2, d * s, Vec3().baseTypeEpsilon())
8136
8137 print ("ok")
8138
8139 return
8140
8141 def testFrustum ():
8142
8143 print ("Frustumf")
8144 testFrustumx (Frustumf, V3f, M44f)
8145
8146 testList.append (('testFrustum',testFrustum))
8147
8148
8149 # -------------------------------------------------------------------------
8150 # Tests for random number generators
8151
8152 def testRandomCompare (r1a, r1b, r1c, r2):
8153 n = 10
8154 nMatch1a1b = 0
8155 nMatch1a1c = 0
8156 nMatch1a2 = 0
8157 for i in range(n):
8158 a = r1a()
8159 b = r1b()
8160 c = r1c()
8161 d = r2()
8162 if (a == b): nMatch1a1b = nMatch1a1b + 1
8163 if (a == c): nMatch1a1c = nMatch1a1c + 1
8164 if (a == d): nMatch1a2 = nMatch1a2 + 1
8165 assert nMatch1a1b == n
8166 assert nMatch1a1c == n
8167 assert nMatch1a2 < n
8168
8169 def testRandomCompareSphere (r1a, r1b, r1c, r2, type):
8170 n = 10
8171 nMatch1a1b = 0
8172 nMatch1a1c = 0
8173 nMatch1a2 = 0
8174 for i in range(n):
8175 a = r1a(type)
8176 b = r1b(type)
8177 c = r1c(type)
8178 d = r2(type)
8179 if (a == b): nMatch1a1b = nMatch1a1b + 1
8180 if (a == c): nMatch1a1c = nMatch1a1c + 1
8181 if (a == d): nMatch1a2 = nMatch1a2 + 1
8182 assert nMatch1a1b == n
8183 assert nMatch1a1c == n
8184 assert nMatch1a2 < n
8185
8186 def testRandomx (Rand):
8187
8188 # Same/different seeds produces same/different sequences.
8189
8190 r1a = Rand(1)
8191 r1b = Rand(1)
8192 r1c = Rand(r1a)
8193 r2 = Rand(2)
8194
8195 testRandomCompare(r1a.nextb, r1b.nextb, r1c.nextb, r2.nextb)
8196 testRandomCompare(r1a.nexti, r1b.nexti, r1c.nexti, r2.nexti)
8197 testRandomCompare(r1a.nextf, r1b.nextf, r1c.nextf, r2.nextf)
8198 testRandomCompareSphere(r1a.nextSolidSphere, r1b.nextSolidSphere, \
8199 r1c.nextSolidSphere, r2.nextSolidSphere, V2f())
8200 testRandomCompareSphere(r1a.nextSolidSphere, r1b.nextSolidSphere, \
8201 r1c.nextSolidSphere, r2.nextSolidSphere, V2d())
8202 testRandomCompareSphere(r1a.nextSolidSphere, r1b.nextSolidSphere, \
8203 r1c.nextSolidSphere, r2.nextSolidSphere, V3f())
8204 testRandomCompareSphere(r1a.nextSolidSphere, r1b.nextSolidSphere, \
8205 r1c.nextSolidSphere, r2.nextSolidSphere, V3f())
8206 testRandomCompareSphere(r1a.nextHollowSphere, r1b.nextHollowSphere, \
8207 r1c.nextHollowSphere, r2.nextHollowSphere, V2f())
8208 testRandomCompareSphere(r1a.nextHollowSphere, r1b.nextHollowSphere, \
8209 r1c.nextHollowSphere, r2.nextHollowSphere, V2d())
8210 testRandomCompareSphere(r1a.nextHollowSphere, r1b.nextHollowSphere, \
8211 r1c.nextHollowSphere, r2.nextHollowSphere, V3f())
8212 testRandomCompareSphere(r1a.nextHollowSphere, r1b.nextHollowSphere, \
8213 r1c.nextHollowSphere, r2.nextHollowSphere, V3f())
8214 testRandomCompare(r1a.nextGauss, r1b.nextGauss, r1c.nextGauss, \
8215 r2.nextGauss)
8216 testRandomCompareSphere(r1a.nextGaussSphere, r1b.nextGaussSphere, \
8217 r1c.nextGaussSphere, r2.nextGaussSphere, V2f())
8218 testRandomCompareSphere(r1a.nextGaussSphere, r1b.nextGaussSphere, \
8219 r1c.nextGaussSphere, r2.nextGaussSphere, V2d())
8220 testRandomCompareSphere(r1a.nextGaussSphere, r1b.nextGaussSphere, \
8221 r1c.nextGaussSphere, r2.nextGaussSphere, V3f())
8222 testRandomCompareSphere(r1a.nextGaussSphere, r1b.nextGaussSphere, \
8223 r1c.nextGaussSphere, r2.nextGaussSphere, V3f())
8224
8225 # Init (if it works for one type, it should work for all).
8226
8227 r = Rand(10)
8228 seq = []
8229 n = 10
8230 for i in range(n):
8231 seq.append(r.nextb())
8232 r.init(10)
8233 for i in range(n):
8234 assert r.nextb() == seq[i]
8235
8236 print ("ok")
8237
8238 return
8239
8240 def testRandom ():
8241
8242 print ("Rand32")
8243 testRandomx (Rand32)
8244 print ("Rand48")
8245 testRandomx (Rand48)
8246
8247 testList.append (('testRandom',testRandom))
8248
8249 # -------------------------------------------------------------------------
8250 # Tests C4xArrays
8251 def testC4xArray(Array, Color, Arrayx):
8252 a = Array (3)
8253
8254 a[0] = Color(0)
8255 a[1] = Color(1)
8256 a[2] = Color(2)
8257
8258 assert a[0] == Color(0)
8259 assert a[1] == Color(1)
8260 assert a[2] == Color(2)
8261
8262 # Element setting.
8263
8264 a = Array(2)
8265
8266 try:
8267 a[-3] = Color(0) # This should raise an exception.
8268 except:
8269 pass
8270 else:
8271 assert 0 # We shouldn't get here.
8272
8273 try:
8274 a[3] = Color(0) # This should raise an exception.
8275 except:
8276 pass
8277 else:
8278 assert 0 # We shouldn't get here.
8279
8280 try:
8281 a[1] = "a" # This should raise an exception.
8282 except:
8283 pass
8284 else:
8285 assert 0 # We shouldn't get here.
8286
8287 # Assignment.
8288
8289 a = Array(2)
8290 a[0] = Color(0)
8291 a[1] = Color(1)
8292
8293 # Array Component access
8294
8295 ar = Arrayx(2)
8296 ag = Arrayx(2)
8297 ab = Arrayx(2)
8298 aa = Arrayx(2)
8299 ar[:] = a.r
8300 ag[:] = a.g
8301 ab[:] = a.b
8302 aa[:] = a.a
8303
8304 assert ar == a.r
8305 assert ag == a.g
8306 assert ab == a.b
8307 assert aa == a.a
8308
8309 a.r[0] = 1
8310 assert ar != a.r
8311
8312
8313 def testC4Array ():
8314 print ("C4fArray")
8315 testC4xArray (C4fArray, Color4f, FloatArray)
8316 print ("C4cArray")
8317 testC4xArray (C4cArray, Color4c, UnsignedCharArray)
8318
8319 testList.append (('testC4Array',testC4Array))
8320
8321 # -------------------------------------------------------------------------
8322 # Tests C3xArrays
8323 def testC3xArray(Array, Color, Arrayx):
8324 a = Array (3)
8325
8326 a[0] = Color(0)
8327 a[1] = Color(1)
8328 a[2] = Color(2)
8329
8330 assert a[0] == Color(0)
8331 assert a[1] == Color(1)
8332 assert a[2] == Color(2)
8333
8334 # Element setting.
8335
8336 a = Array(2)
8337
8338 try:
8339 a[-3] = Color(0) # This should raise an exception.
8340 except:
8341 pass
8342 else:
8343 assert 0 # We shouldn't get here.
8344
8345 try:
8346 a[3] = Color(0) # This should raise an exception.
8347 except:
8348 pass
8349 else:
8350 assert 0 # We shouldn't get here.
8351
8352 try:
8353 a[1] = "a" # This should raise an exception.
8354 except:
8355 pass
8356 else:
8357 assert 0 # We shouldn't get here.
8358
8359 # Assignment.
8360
8361 a = Array(2)
8362 a[0] = Color(0)
8363 a[1] = Color(1)
8364
8365 # Array Component access
8366
8367 ar = Arrayx(2)
8368 ag = Arrayx(2)
8369 ab = Arrayx(2)
8370 ar[:] = a.r
8371 ag[:] = a.g
8372 ab[:] = a.b
8373
8374 assert ar == a.r
8375 assert ag == a.g
8376 assert ab == a.b
8377
8378 a.r[0] = 1
8379 assert ar != a.r
8380
8381
8382 def testC3xExplicitConversion(Array):
8383
8384 # explicit constructors from Vec3 types
8385 af = V3fArray(3)
8386 af[0] = V3f(0)
8387 af[1] = V3f(1)
8388 af[2] = V3f(2)
8389 a = Array(af);
8390 assert af[0] == V3f(a[0])
8391 assert af[1] == V3f(a[1])
8392 assert af[2] == V3f(a[2])
8393
8394 ad = V3dArray(3)
8395 ad[0] = V3d(0)
8396 ad[1] = V3d(1)
8397 ad[2] = V3d(2)
8398 a = Array(ad);
8399 assert ad[0] == V3d(a[0])
8400 assert ad[1] == V3d(a[1])
8401 assert ad[2] == V3d(a[2])
8402
8403 def testC3Array ():
8404 print ("C3fArray")
8405 testC3xArray (C3fArray, Color3f, FloatArray)
8406 testC3xExplicitConversion(C3fArray)
8407 print ("C3cArray")
8408 testC3xArray (C3cArray, Color3c, UnsignedCharArray)
8409
8410 testList.append (('testC3Array',testC3Array))
8411
8412 # -------------------------------------------------------------------------
8413 # Verify that floating-point exceptions, both in Imath and in Python,
8414 # raise Python exceptions rather than causing crashes.
8415
8416 def testFpExceptions():
8417
8418 try:
8419 f = sqrt (-1)
8420 print (f)
8421 except ValueError:
8422 pass
8423 except OverflowError:
8424 pass
8425 else:
8426 assert 0
8427
8428 try:
8429 f = sqrt (-1)
8430 print (f)
8431 except ValueError:
8432 pass
8433 except OverflowError:
8434 pass
8435 else:
8436 assert 0
8437
8438 try:
8439 f = 1 / 0
8440 print (f)
8441 except ZeroDivisionError:
8442 pass
8443 else:
8444 assert 0
8445
8446 print ("ok")
8447 return
8448
8449 testList.append (('testFpExceptions',testFpExceptions))
8450
8451 def testProcrustes():
8452 m = M44d()
8453 m.translate (V3d(10, 5, 0))
8454
8455 r = Eulerd (pi, pi/4.0, 0)
8456 m = m * r.toMatrix44()
8457
8458 n = 8
8459 f = []
8460 t = []
8461 w = []
8462 for i in range (n):
8463 theta = 2.0 * pi * float(i)/float(n)
8464 fromVec = V3d(cos(theta), sin(theta), 0)
8465 w.append (1)
8466 f.append (fromVec)
8467 t.append (fromVec * m)
8468
8469 result = procrustesRotationAndTranslation (f, t, None, False)
8470 for i in range(n):
8471 res = f[i] * result
8472 assert ((res - t[i]).length2() < 1e-5)
8473
8474 # Test it with arrays:
8475 r = Rand48(145)
8476 f1 = V3dArray (n)
8477 t1 = V3dArray (n)
8478 for i in range(n):
8479 fromVec = V3d (r.nextf(), r.nextf(), r.nextf())
8480 f1[i] = fromVec
8481 t1[i] = fromVec * m
8482 result = procrustesRotationAndTranslation (f1, t1, None, False)
8483 for i in range(n):
8484 res = f1[i] * result
8485 assert ((res - t1[i]).length2() < 1e-5)
8486
8487 # Verify weights:
8488 f.append (V3d(0,0,0))
8489 t.append (V3d(10000,10000,100))
8490 w.append (0.0)
8491 result = procrustesRotationAndTranslation (f, t, w, False)
8492 for i in range(n):
8493 res = f[i] * result
8494 assert ((res - t[i]).length2() < 1e-5)
8495
8496 testList.append (('testProcrustes',testProcrustes))
8497
8498 def testSVD():
8499 # We'll just test the Python wrapper here; for comprehensive SVD tests,
8500 # please see ImathToolboxTest.
8501 # 4x4
8502 m = M44d()
8503 [U, S, V] = m.singularValueDecomposition(False)
8504
8505 eps = 1e-4
8506 def sameMatrix44 (m1, m2):
8507 for i in range(4):
8508 for j in range(4):
8509 if (abs(m1[i][j] - m2[i][j]) > eps):
8510 return False
8511 return True
8512
8513 def sameVector4 (v1, v2):
8514 for i in range(4):
8515 if (abs(v1[i] - v2[i]) > eps):
8516 return False
8517 return True
8518
8519 assert (sameMatrix44(U, M44d()));
8520 assert (sameMatrix44(V, M44d()));
8521 assert (sameVector4(S, V4d(1,1,1,1)))
8522
8523 def checkSVD44(m):
8524 [U, S, V] = m.singularValueDecomposition(True)
8525 assert (sameMatrix44(U*U.transposed(), M44d()))
8526 assert (sameMatrix44(V*V.transposed(), M44d()))
8527 for i in range(3):
8528 assert S[i] >= 0
8529
8530 assert (U.determinant() > 0)
8531 assert (V.determinant() > 0)
8532
8533 sDiag = M44d()
8534 for i in range(4):
8535 sDiag[i][i] = S[i]
8536 assert (sameMatrix44(U*sDiag*V.transposed(), m))
8537
8538 [U2, S2, V2] = m.singularValueDecomposition(False)
8539 for i in range(4):
8540 assert (S2[i] >= 0)
8541 for i in range(3):
8542 assert (abs(S[i] - S2[i]) < eps)
8543 assert (abs(abs(S[3]) - S2[3]) < eps)
8544
8545 scaleMatrix = M44d()
8546 scaleMatrix.setScale (V3d(1, 2, 3))
8547 m = m * scaleMatrix
8548 checkSVD44(m)
8549
8550 e = Eulerd (20, 30, 40)
8551 m = m * e.toMatrix44()
8552 checkSVD44(m)
8553
8554 scaleMatrix.setScale (V3d(-3, 2, 3))
8555 m = m * e.toMatrix44()
8556 checkSVD44(m)
8557
8558 # 3x3
8559 m = M33d()
8560 [U, S, V] = m.singularValueDecomposition(False)
8561
8562 eps = 1e-4
8563 def sameMatrix33 (m1, m2):
8564 for i in range(3):
8565 for j in range(3):
8566 if (abs(m1[i][j] - m2[i][j]) > eps):
8567 return False
8568 return True
8569
8570 def sameVector3 (v1, v2):
8571 for i in range(3):
8572 if (abs(v1[i] - v2[i]) > eps):
8573 return False
8574 return True
8575
8576 assert (sameMatrix33(U, M33d()));
8577 assert (sameMatrix33(V, M33d()));
8578 assert (sameVector3(S, V3d(1,1,1)))
8579
8580 def checkSVD33(m):
8581 [U, S, V] = m.singularValueDecomposition(True)
8582 assert (sameMatrix33(U*U.transposed(), M33d()))
8583 assert (sameMatrix33(V*V.transposed(), M33d()))
8584 for i in range(3):
8585 assert S[i] >= 0
8586
8587 assert (U.determinant() > 0)
8588 assert (V.determinant() > 0)
8589
8590 sDiag = M33d()
8591 for i in range(3):
8592 sDiag[i][i] = S[i]
8593 assert (sameMatrix33(U*sDiag*V.transposed(), m))
8594
8595 [U2, S2, V2] = m.singularValueDecomposition(False)
8596 for i in range(2):
8597 assert (S2[i] >= 0)
8598 for i in range(2):
8599 assert (abs(S[i] - S2[i]) < eps)
8600 assert (abs(abs(S[2]) - S2[2]) < eps)
8601
8602 scaleMatrix = M33d (1, 0, 0, 0, 2, 0, 0, 0, 3)
8603 m = m * scaleMatrix
8604 checkSVD33(m)
8605
8606 e = Eulerd (20, 30, 40)
8607 m = m * e.toMatrix33()
8608 checkSVD33(m)
8609
8610 scaleMatrix = M33d (-3, 0, 0, 0, 2, 0, 0, 0, 3)
8611 m = m * e.toMatrix33()
8612 checkSVD33(m)
8613
8614 testList.append (('testSVD',testSVD))
8615
8616 def testSymmetricEigensolve():
8617 # We'll just test the Python wrapper here; for comprehensive eigensolver tests,
8618 # please see ImathToolboxTest.
8619 # 4x4
8620
8621 eps = 1e-4
8622 def sameMatrix44 (m1, m2):
8623 for i in range(4):
8624 for j in range(4):
8625 if (abs(m1[i][j] - m2[i][j]) > eps):
8626 return False
8627 return True
8628
8629 def sameVector4 (v1, v2):
8630 for i in range(4):
8631 if (abs(v1[i] - v2[i]) > eps):
8632 return False
8633 return True
8634
8635 m = M44d()
8636 [Q, S] = m.symmetricEigensolve()
8637 assert (sameMatrix44 (Q, M44d()))
8638 assert (sameVector4 (S, V4d(1,1,1,1)))
8639
8640 m = M44d(2, 4, 3, 6,
8641 4, 1, 9, 7,
8642 3, 9, 10, 13,
8643 6, 7, 13, 27);
8644 [Q, S] = m.symmetricEigensolve()
8645 assert (sameMatrix44(Q*Q.transposed(), M44d()))
8646
8647 sDiag = M44d()
8648 for i in range(4):
8649 sDiag[i][i] = S[i]
8650 assert (sameMatrix44 (Q * sDiag * Q.transposed(), m))
8651
8652 # Verify that it checks for symmetry:
8653 m[2][3] = 1000
8654 try:
8655 m.symmetricEigensolve()
8656 except ValueError:
8657 pass
8658 else:
8659 assert 0
8660
8661 def sameMatrix33 (m1, m2):
8662 for i in range(3):
8663 for j in range(3):
8664 if (abs(m1[i][j] - m2[i][j]) > eps):
8665 return False
8666 return True
8667
8668 def sameVector3 (v1, v2):
8669 for i in range(3):
8670 if (abs(v1[i] - v2[i]) > eps):
8671 return False
8672 return True
8673
8674 m = M33d()
8675 [Q, S] = m.symmetricEigensolve()
8676 assert (sameMatrix33 (Q, M33d()))
8677 assert (sameVector3 (S, V3d(1,1,1)))
8678
8679 m = M33d(2, 4, 3,
8680 4, 1, 9,
8681 3, 9, 10)
8682 [Q, S] = m.symmetricEigensolve()
8683 assert (sameMatrix33(Q*Q.transposed(), M33d()))
8684
8685 sDiag = M33d()
8686 for i in range(3):
8687 sDiag[i][i] = S[i]
8688 assert (sameMatrix33 (Q * sDiag * Q.transposed(), m))
8689
8690 # Verify that it checks for symmetry:
8691 m[1][2] = 1000
8692 try:
8693 m.symmetricEigensolve()
8694 except ValueError:
8695 pass
8696 else:
8697 assert 0
8698
8699
8700
8701 testList.append (('testSymmetricEigensolve',testSymmetricEigensolve))
8702
8703 # -------------------------------------------------------------------------
8704 # Tests MxArrays
8705 def testMxArray(Array, Matrix):
8706 a = Array (3)
8707
8708 a[0] = Matrix(0)
8709 a[1] = Matrix(1)
8710 a[2] = Matrix(2)
8711
8712 assert a[0] == Matrix(0)
8713 assert a[1] == Matrix(1)
8714 assert a[2] == Matrix(2)
8715
8716 # Element setting.
8717
8718 a = Array(2)
8719
8720 try:
8721 a[-3] = Matrix(0) # This should raise an exception.
8722 except:
8723 pass
8724 else:
8725 assert 0 # We shouldn't get here.
8726
8727 try:
8728 a[3] = Matrix(0) # This should raise an exception.
8729 except:
8730 pass
8731 else:
8732 assert 0 # We shouldn't get here.
8733
8734 try:
8735 a[1] = "a" # This should raise an exception.
8736 except:
8737 pass
8738 else:
8739 assert 0 # We shouldn't get here.
8740
8741 # Assignment.
8742
8743 a = Array(2)
8744 a[0] = Matrix(0)
8745 a[1] = Matrix(1)
8746
8747 # Comparison.
8748
8749 m = Matrix(2)
8750 a1 = Array(m, 3)
8751 a2 = Array(m, 3)
8752
8753 testVectorVectorComparisonOps(a1, a2)
8754 testVectorScalarComparisonOps(a1, m)
8755
8756 def testM4Array(Array, Matrix, Vec, VecArray):
8757
8758 a = Array(3)
8759 m0 = Matrix()
8760 m0.setTranslation (Vec(1,2,3))
8761 m1 = Matrix()
8762 m1.setScale (Vec(.3,.2,.1))
8763 m2 = Matrix()
8764 m2.rotate (Vec(.3,.1,.2))
8765
8766 a[0] = m0
8767 a[1] = m1
8768 a[2] = m2
8769
8770 n = a.inverse()
8771 assert n[0] == m0.inverse()
8772 assert n[1] == m1.inverse()
8773 assert n[2] == m2.inverse()
8774
8775 a.invert()
8776 testVectorVectorComparisonOps(a, n)
8777
8778 n0 = a[0]
8779 n1 = a[2]
8780 n2 = a[2]
8781 a.transpose()
8782 assert n[0].transposed() == a[0]
8783 assert n[1].transposed() == a[1]
8784 assert n[2].transposed() == a[2]
8785
8786 v = VecArray(3)
8787 v[0] = Vec(11,17,3).normalized()
8788 v[1] = Vec(7,19,31).normalized()
8789 v[2] = Vec(23,5,13).normalized()
8790
8791 V = a.multDirMatrix(v)
8792 assert a[0].multDirMatrix(v[0]) == V[0]
8793 assert a[1].multDirMatrix(v[1]) == V[1]
8794 assert a[2].multDirMatrix(v[2]) == V[2]
8795
8796 V = a.multVecMatrix(v)
8797 assert a[0].multVecMatrix(v[0]) == V[0]
8798 assert a[1].multVecMatrix(v[1]) == V[1]
8799 assert a[2].multVecMatrix(v[2]) == V[2]
8800
8801 def testMatrixArray ():
8802 print ("M44fArray")
8803 testMxArray (M44fArray, M44f)
8804 testM4Array (M44fArray, M44f, V3f, V3fArray)
8805 print ("M44dArray")
8806 testMxArray (M44dArray, M44d)
8807 testM4Array (M44dArray, M44d, V3d, V3dArray)
8808 print ("M33fArray")
8809 testMxArray (M33fArray, M33f)
8810 print ("M33dArray")
8811 testMxArray (M33dArray, M33d)
8812 print ("M22fArray")
8813 testMxArray (M22fArray, M22f)
8814 print ("M22dArray")
8815 testMxArray (M22dArray, M22d)
8816
8817 testList.append(("testMatrixArray",testMatrixArray))
8818
8819 # -------------------------------------------------------------------------
8820 # Tests BoxxArrays
8821 def testBoxxArray(Array, Box, Vec):
8822
8823 b0 = Box(Vec(1), Vec(2))
8824 b1 = Box(Vec(2), Vec(3))
8825 b2 = Box(Vec(3), Vec(4))
8826
8827 a = Array (3)
8828
8829 a[0] = b0
8830 a[1] = b1
8831 a[2] = b2
8832
8833 assert a[0] == b0
8834 assert a[1] == b1
8835 assert a[2] == b2
8836
8837 # Element setting.
8838
8839 a = Array(2)
8840
8841 try:
8842 a[-3] = b0 # This should raise an exception.
8843 except:
8844 pass
8845 else:
8846 assert 0 # We shouldn't get here.
8847
8848 try:
8849 a[3] = b0 # This should raise an exception.
8850 except:
8851 pass
8852 else:
8853 assert 0 # We shouldn't get here.
8854
8855 try:
8856 a[1] = "a" # This should raise an exception.
8857 except:
8858 pass
8859 else:
8860 assert 0 # We shouldn't get here.
8861
8862 # Assignment.
8863
8864 a = Array(2)
8865 a[0] = b0
8866 a[1] = b1
8867
8868 # Comparison.
8869
8870 a1 = Array(b2, 3)
8871 a2 = Array(b2, 3)
8872
8873 testVectorVectorComparisonOps(a1, a2)
8874 testVectorScalarComparisonOps(a1, b2)
8875
8876 def testBoxArray ():
8877 print ("Box2iArray")
8878 testBoxxArray (Box2iArray, Box2i, V2i)
8879 print ("Box2sArray")
8880 testBoxxArray (Box2sArray, Box2s, V2s)
8881 print ("Box2fArray")
8882 testBoxxArray (Box2fArray, Box2f, V2f)
8883 print ("Box2dArray")
8884 testBoxxArray (Box2dArray, Box2d, V2d)
8885 print ("Box3iArray")
8886 testBoxxArray (Box3iArray, Box3i, V3i)
8887 print ("Box3sArray")
8888 testBoxxArray (Box3sArray, Box3s, V3s)
8889 print ("Box3fArray")
8890 testBoxxArray (Box3fArray, Box3f, V3f)
8891 print ("Box3dArray")
8892 testBoxxArray (Box3dArray, Box3d, V3d)
8893
8894 testList.append(("testBoxArray",testBoxArray))
8895
8896 def testStringArray():
8897
8898 num = 10
8899
8900 s = StringArray(num)
8901 s2 = StringArray(num)
8902
8903 assert((s != '').reduce() == 0)
8904 assert((s == '').reduce() == num)
8905
8906 assert(('' != s).reduce() == 0)
8907 assert(('' == s).reduce() == num)
8908
8909 assert((s != s2).reduce() == 0)
8910 assert((s == s2).reduce() == num)
8911
8912 id = IntArray(num)
8913 id[:] = make_range(0,num)
8914
8915 s = StringArray('foo', num)
8916 s2 = StringArray('a', num)
8917 s2[:] = 'foo'
8918
8919 assert((s != 'foo').reduce() == 0)
8920 assert((s == 'foo').reduce() == num)
8921
8922 assert(('foo' != s).reduce() == 0)
8923 assert(('foo' == s).reduce() == num)
8924 assert((s != s2).reduce() == 0)
8925 assert((s == s2).reduce() == num)
8926
8927 s[id < num//2] = 'bar'
8928
8929 assert((s != 'foo').reduce() == num//2)
8930 assert((s == 'foo').reduce() == num//2)
8931
8932 assert(('foo' != s).reduce() == num//2)
8933 assert(('foo' == s).reduce() == num//2)
8934
8935 assert((s != 'bar').reduce() == num//2)
8936 assert((s == 'bar').reduce() == num//2)
8937
8938 assert(('bar' != s).reduce() == num//2)
8939 assert(('bar' == s).reduce() == num//2)
8940
8941 assert((s != s2).reduce() == num//2)
8942 assert((s == s2).reduce() == num//2)
8943
8944 for i in range(0,num):
8945 s2[i] = str(i)
8946
8947 for i in range(0,num):
8948 assert(int(s2[i]) == i)
8949
8950 print ("should see {0} 'bar' and {1} 'foo'".format (num//2,num//2))
8951 for m in s:
8952 print (m)
8953 print ("should see '0' through '{}'".format(num-1))
8954 for m in s2:
8955 print (m)
8956
8957 print ("ok")
8958
8959 testList.append(("testStringArray",testStringArray))
8960
8961
8962 def testWstringArray():
8963
8964 num = 10
8965
8966 s = WstringArray(num)
8967 s2 = WstringArray(num)
8968
8969 assert((s != '').reduce() == 0)
8970 assert((s == '').reduce() == num)
8971
8972 assert(('' != s).reduce() == 0)
8973 assert(('' == s).reduce() == num)
8974
8975 assert((s != s2).reduce() == 0)
8976 assert((s == s2).reduce() == num)
8977
8978 id = IntArray(num)
8979 id[:] = make_range(0,num)
8980
8981 s = WstringArray(u'foo', num)
8982 s2 = WstringArray(u'a', num)
8983 s2[:] = u'foo'
8984
8985 assert((s != u'foo').reduce() == 0)
8986 assert((s == u'foo').reduce() == num)
8987
8988 assert((u'foo' != s).reduce() == 0)
8989 assert((u'foo' == s).reduce() == num)
8990 assert((s != s2).reduce() == 0)
8991 assert((s == s2).reduce() == num)
8992
8993 s[id < num//2] = u'bar'
8994
8995 assert((s != u'foo').reduce() == num//2)
8996 assert((s == u'foo').reduce() == num//2)
8997
8998 assert((u'foo' != s).reduce() == num//2)
8999 assert((u'foo' == s).reduce() == num//2)
9000
9001 assert((s != u'bar').reduce() == num//2)
9002 assert((s == u'bar').reduce() == num//2)
9003
9004 assert((u'bar' != s).reduce() == num//2)
9005 assert((u'bar' == s).reduce() == num//2)
9006
9007 assert((s != s2).reduce() == num//2)
9008 assert((s == s2).reduce() == num//2)
9009
9010 for i in range(0,num):
9011 s2[i] = str(i)
9012
9013 for i in range(0,num):
9014 assert(int(s2[i]) == i)
9015
9016 print ("should see {0} 'bar' and {1} 'foo'".format(num//2,num//2))
9017 for m in s:
9018 print (m)
9019 print ("should see '0' through '{}'".format(num-1))
9020 for m in s2:
9021 print (m)
9022
9023 print ("ok")
9024
9025 testList.append(("testWstringArray",testWstringArray))
9026
9027
9028 def testVArrays():
9029 '''
9030 Test variable-length arrays. Currently we only support an
9031 VIntArray with very limited Python functionality. This test
9032 should be expanded when support for variable-length arrays
9033 becomes more complete.
9034 '''
9035
9036 num = 1000
9037 a1 = VIntArray(num)
9038 a2 = VIntArray(1, num)
9039 a3 = VIntArray(a2)
9040 assert(len(a1) == num)
9041 assert(len(a2) == num)
9042 assert(len(a3) == num)
9043
9044 # test constructor failure cases
9045 failed = False
9046 try:
9047 VIntArray(-1)
9048 except:
9049 failed = True
9050 assert(failed)
9051
9052 failed = False
9053 try:
9054 VIntArray(10,-1)
9055 except:
9056 failed = True
9057 assert(failed)
9058
9059 assert(a2[0][0] == 1)
9060 assert(a2[1][0] == 1)
9061 assert(a2[2][0] == 1)
9062 assert(a2[3][0] == 1)
9063
9064 # index out of bounds
9065 failed = False
9066 try:
9067 a2[num]
9068 except:
9069 failed = True
9070 assert(failed)
9071
9072
9073 values = IntArray(1)
9074 values[0] = 5
9075
9076 # test getitem and setitem
9077 assert(len(a1[0]) == 0)
9078 assert(len(a2[0]) == 1)
9079 assert(len(a3[0]) == 1)
9080 a2[0] = values
9081 assert(a2[0][0] == 5)
9082
9083 # test getitem, negative indices
9084 assert(len(a1[-1]) == 0)
9085 assert(len(a2[-1]) == 1)
9086 assert(len(a3[-1]) == 1)
9087 a2[-1] = values
9088 assert(a2[-1][0] == 5)
9089
9090 mask = IntArray(num)
9091 mask[2] = 1
9092 mask[3] = 1
9093
9094 # test getitem and setitem with mask
9095 assert(len(a2[mask]) == 2) # two elements from the original array
9096 a2[mask] = values
9097 assert(a2[0][0] == 5)
9098 assert(a2[1][0] == 1)
9099 assert(a2[2][0] == 5)
9100 assert(a2[3][0] == 5)
9101
9102 a2[3][0] = 6
9103 assert(a2[3][0] == 6)
9104 a2m = a2[mask] # masked to [2,3]
9105 a2ms = a2m[1:2:1] # sliced to [2]
9106 a2msa = a2ms[0] # indexed to the elemnt 3 array
9107 assert(a2msa[0] == 6) # test slice on mask
9108
9109 # test slice assignment in masked array
9110 tmpValues = IntArray(9,1)
9111 a2m[1:2:1] = tmpValues
9112 assert(a2[3][0] == 9)
9113
9114 tmpValues = IntArray(9,2)
9115 tmpValuesMask = IntArray(2)
9116 tmpValuesMask[1] = 1
9117 tmpValues[1] = 15
9118 a2m[1:2:1] = tmpValues[tmpValuesMask]
9119 assert(a2[3][0] == 15)
9120
9121 # mismatched length on RHG
9122 failed = False
9123 try:
9124 a2m[1:2:1] = tmpValues
9125 except:
9126 failed = True
9127 assert(failed)
9128
9129 tmpValues[1] = 17
9130 a2[3:4:1] = tmpValues[tmpValuesMask]
9131 assert(a2[3][0] == 17)
9132
9133 # mismatched length on RHG
9134 failed = False
9135 try:
9136 a2[3:4:1] = tmpValues
9137 except:
9138 failed = True
9139 assert(failed)
9140
9141 a2[mask] = tmpValues[tmpValuesMask]
9142
9143 # test getitem and setitem with slice
9144 values[:] = 7
9145 assert(len(a2[1:4:2]) == 2) # two elements from the original array
9146 a2[1:4:2] = values
9147 assert(a2[0][0] == 5)
9148 assert(a2[1][0] == 7)
9149 assert(a2[2][0] == 17)
9150 assert(a2[3][0] == 7)
9151
9152 # test size property setitem and getitem
9153 a1.size[0] = 10
9154 assert(len(a1[0]) == 10)
9155 assert(a1.size[0] == 10)
9156
9157 # test internal reference handling
9158 a10 = a1[0]
9159 a10[9] = 15
9160 del a10
9161 a10 = a1[0]
9162 assert(a10[9] == 15)
9163
9164 # Some tests for Variable V2is
9165
9166 print ("Testing VV2i...")
9167 failed = False
9168 try:
9169 VV2iArray(-1)
9170 except:
9171 failed = True
9172 assert(failed)
9173
9174 failed = False
9175 try:
9176 VV2iArray(10,-1)
9177 except:
9178 failed = True
9179 assert(failed)
9180
9181 defaults2i = V2iArray(1)
9182 defaults2i[0] = V2i(17,31)
9183
9184 a = VV2iArray (defaults2i[0], 5)
9185 count = 0
9186 for elem in a:
9187 assert (elem == V2i(17,31))
9188 count += 1
9189 assert (count == 5)
9190
9191 failed = False
9192 try:
9193 print ("If you see a value here it's bogus: {}".format(a[-6]))
9194 except:
9195 failed = True
9196 assert (failed)
9197 print ("")
9198
9199 # Some tests for Variable floats
9200
9201 print ("Testing VFloat...")
9202 failed = False
9203 try:
9204 VFloatArray(-1)
9205 except:
9206 failed = True
9207 assert(failed)
9208
9209 failed = False
9210 try:
9211 VFloatArray(10.,-1)
9212 except:
9213 failed = True
9214 assert(failed)
9215
9216 value0 = 42.23
9217 value1 = 2.
9218 defaultsFloats = VFloatArray(1,2)
9219 defaultsFloats[0] = FloatArray(value0, 1)
9220 defaultsFloats[1] = FloatArray(value1, 1)
9221
9222 a = VFloatArray (defaultsFloats[1][0], 7)
9223 count = 0
9224 for elem in a:
9225 assert (len(elem) == 1)
9226 assert (elem[0] == value1)
9227 assert (elem[-1] == value1)
9228 count += 1
9229 assert (count == 7 and len(a) == count)
9230
9231 failed = False
9232 try:
9233 print ("If you see a value here it's bogus: {}".format(a[8]))
9234 except:
9235 failed = True
9236 assert (failed)
9237 print ("")
9238
9239 # See the 'PyImath/varraySemantics.txt' document for more information.
9240
9241 testList.append(("testVArrays", testVArrays))
9242
9243
9244 def testReadOnlyBasic(AType, val):
9245 '''
9246 Tests the basic operation, features, and expectations of a read-only
9247 fixed array. Makes sure the writeable state is accurate and errors
9248 are thrown if we try to modify a read-only array. Also makes sures
9249 that values returned from arrays are as expected, depending on the
9250 writable state of the array (i.e. copies of array values or direct
9251 references to those array values).
9252 '''
9253
9254 a = AType(13)
9255 assert (len(a) == 13)
9256 assert (a.writable() == True)
9257
9258 for i in range(5):
9259 a[i] = val
9260 for i in range(5):
9261 assert (equalWithAbsError(a[i], val, eps) == True)
9262 for i in range(5,13):
9263 assert (equalWithAbsError(a[i], val, eps) == False)
9264
9265 # Test '__getitem__' subtleties for array items.
9266 if hasattr(a[0], 'setValue'):
9267 l = len(a[0])
9268 # Vector-type arrays.
9269 if l == 2:
9270 for i in range(13):
9271 a[i].setValue(101, 102)
9272 for i in range(13):
9273 assert (equalWithAbsError(a[i].x, 101, eps) == True)
9274 assert (equalWithAbsError(a[i].y, 102, eps) == True)
9275 for i in range(5):
9276 v = a[i]
9277 v.setValue(val.x, val.y)
9278 elif l == 3:
9279 for i in range(13):
9280 a[i].setValue(101, 102, 103)
9281 for i in range(13):
9282 assert (equalWithAbsError(a[i].x, 101, eps) == True)
9283 assert (equalWithAbsError(a[i].y, 102, eps) == True)
9284 assert (equalWithAbsError(a[i].z, 103, eps) == True)
9285 for i in range(5):
9286 v = a[i]
9287 v.setValue(val.x, val.y, val.z)
9288
9289 for i in range(5):
9290 assert (equalWithAbsError(a[i], val, eps) == True)
9291 for i in range(5,13):
9292 assert (equalWithAbsError(a[i], val, eps) == False)
9293
9294 b = a
9295 c = AType (a)
9296 assert (len(b) == 13)
9297 assert (len(c) == 13)
9298 assert (b.writable() == True)
9299 assert (c.writable() == True)
9300
9301 for i in range(5):
9302 assert (equalWithAbsError(b[i], val, eps) == True)
9303 assert (equalWithAbsError(c[i], val, eps) == True)
9304 for i in range(5,13):
9305 assert (equalWithAbsError(b[i], val, eps) == False)
9306 assert (equalWithAbsError(c[i], val, eps) == False)
9307
9308 # Make the array 'read only'.
9309
9310 a.makeReadOnly()
9311 assert (len(a) == 13)
9312 assert (a.writable() == False)
9313
9314 b = a
9315 c = AType (a)
9316 assert (len(b) == 13)
9317 assert (len(c) == 13)
9318 assert (b.writable() == False)
9319 assert (c.writable() == False)
9320
9321 for i in range(5):
9322 assert (equalWithAbsError(a[i], val, eps) == True)
9323 assert (equalWithAbsError(b[i], val, eps) == True)
9324 assert (equalWithAbsError(c[i], val, eps) == True)
9325 for i in range(5,13):
9326 assert (equalWithAbsError(a[i], val, eps) == False)
9327 assert (equalWithAbsError(b[i], val, eps) == False)
9328 assert (equalWithAbsError(c[i], val, eps) == False)
9329
9330 # These should all fail because the array is read-only.
9331 try:
9332 a[3] = val
9333 except:
9334 pass
9335 else:
9336 assert(False)
9337 try:
9338 a[5] = val
9339 except:
9340 pass
9341 else:
9342 assert(False)
9343 try:
9344 a[8:10] = val
9345 except:
9346 pass
9347 else:
9348 assert(False)
9349
9350 # Continue to test '__getitem__' subtleties for array items.
9351 if hasattr(a[0], 'setValue'):
9352 l = len(a[0])
9353 # Vector-type arrays.
9354 if l == 2:
9355 for i in range(13):
9356 a[i].setValue(201, 202)
9357 # For read-only arrays, the setValue should be operating
9358 # on copies of the vaslues. Because of that, the values
9359 # should not have actually changed.
9360 for i in range(13):
9361 assert (equalWithAbsError(a[i].x, 201, eps) == False)
9362 assert (equalWithAbsError(a[i].y, 202, eps) == False)
9363 elif l == 3:
9364 for i in range(13):
9365 a[i].setValue(201, 202, 203)
9366 # For read-only arrays, the setValue should be operating
9367 # on copies of the vaslues. Because of that, the values
9368 # should not have actually changed.
9369 for i in range(13):
9370 assert (equalWithAbsError(a[i].x, 201, eps) == False)
9371 assert (equalWithAbsError(a[i].y, 202, eps) == False)
9372 assert (equalWithAbsError(a[i].z, 203, eps) == False)
9373
9374 for i in range(5):
9375 assert (equalWithAbsError(a[i], val, eps) == True)
9376 for i in range(5,13):
9377 assert (equalWithAbsError(a[i], val, eps) == False)
9378
9379 print ("ok")
9380
9381 testList.append(("testReadOnlyBasicInt",
9382 lambda : testReadOnlyBasic(IntArray, 7)))
9383 testList.append(("testReadOnlyBasicFloat",
9384 lambda : testReadOnlyBasic(FloatArray, 1.234)))
9385 testList.append(("testReadOnlyBasicV3f",
9386 lambda : testReadOnlyBasic(V3fArray, V3f(1.2, 3.4, 5.6))))
9387 testList.append(("testReadOnlyBasicV2i",
9388 lambda : testReadOnlyBasic(V2iArray, V2i(8, 9))))
9389
9390
9391 def testVectorVectorInPlaceArithmeticOpsReadOnly(f1, f2,
9392 shouldFail = True):
9393 assert(len(f1) == len(f2))
9394
9395 try: f1 += f2
9396 except: pass
9397 else: assert(not shouldFail)
9398
9399 try: f1 -= f2
9400 except: pass
9401 else: assert(not shouldFail)
9402
9403 try: f1 *= f2
9404 except: pass
9405 else: assert(not shouldFail)
9406
9407 try: f1 /= f2
9408 except: pass
9409 else: assert(not shouldFail)
9410
9411 def testVectorScalarInPlaceArithmeticOpsReadOnly(f1, v):
9412 try: f1 += v
9413 except: pass
9414 else: assert(False)
9415
9416 try: f1 -= v
9417 except: pass
9418 else: assert(False)
9419
9420 try: f1 *= v
9421 except: pass
9422 else: assert(False)
9423
9424 try: f1 /= v
9425 except: pass
9426 else: assert(False)
9427
9428 def testVectorVectorMaskedInPlaceArithmeticOpsReadOnly(f1, f2, m,
9429 shouldFail = True):
9430 assert(len(f1) == len(f2))
9431 assert(len(f1) == len(m ));
9432
9433 try: f1[m] += f2
9434 except: pass
9435 else: assert(not shouldFail)
9436
9437 try: f1[m] -= f2
9438 except: pass
9439 else: assert(not shouldFail)
9440
9441 try: f1[m] *= f2
9442 except: pass
9443 else: assert(not shouldFail)
9444
9445 try: f1[m] /= f2
9446 except: pass
9447 else: assert(not shouldFail)
9448
9449 def testVectorVectorMaskedInPlaceArithmeticOps2ReadOnly(f1, f2, m,
9450 shouldFail = True):
9451 assert(len(f1) == len(m))
9452 assert(len(f1[m]) == len(f2))
9453
9454 try: f1[m] += f2
9455 except: pass
9456 else: assert(not shouldFail)
9457
9458 try: f1[m] -= f2
9459 except: pass
9460 else: assert(not shouldFail)
9461
9462 try: f1[m] *= f2
9463 except: pass
9464 else: assert(not shouldFail)
9465
9466 try: f1[m] /= f2
9467 except: pass
9468 else: assert(not shouldFail)
9469
9470 def testUnaryVecMethodsReadOnly(f):
9471 g = f.length()
9472 assert(len(g) == len(f))
9473 for i in range(0, len(f)):
9474 assert(equalWithRelError(g[i], f[i].length(), eps))
9475
9476 g = f.length2()
9477 assert(len(g) == len(f))
9478 for i in range(0, len(f)):
9479 assert(g[i] == f[i].length2())
9480
9481 # Normalization only makes sense for these types
9482 try: f.normalize()
9483 except: pass
9484 else: assert(False)
9485
9486 g = f.normalized()
9487 assert(len(g) == len(f))
9488 for i in range(0, len(f)):
9489 assert(g[i] == f[i].normalized())
9490
9491 def testReadOnlyAutoVect(ArrayType, val1, val2):
9492 '''
9493 Tests the auto-vectorized functions operating on read-only arrays.
9494 Generally it is ok if a read-only array is used in a vectorized function
9495 if its values are just read (used), but errors should be thrown if the
9496 auto-vectorized function tries to modify a read-only array.
9497 '''
9498
9499 aLen = 1234
9500 f1 = ArrayType(val1, aLen)
9501 f1w = ArrayType(val1, aLen)
9502 f2 = ArrayType(val2, aLen)
9503
9504 m = IntArray(aLen)
9505 m[ : 100] = 1
9506 m[ 100: 200] = 0
9507 m[ 200: 300] = 1
9508 m[ 300: 400] = 0
9509 m[ 400: 500] = 1
9510 m[ 500: 600] = 0
9511 m[ 600: 700] = 1
9512 m[ 700: 800] = 0
9513 m[ 800: 900] = 1
9514 m[ 900:1000] = 0
9515 m[1000:1100] = 1
9516 m[1100:1200] = 0
9517 m[1200: ] = 1
9518
9519 m.makeReadOnly()
9520
9521 maskedLen = len(f1[m])
9522 f3 = ArrayType(val2, len(f1[m]))
9523
9524 assert (f1.writable() == True)
9525 assert (f2.writable() == True)
9526 assert (f3.writable() == True)
9527
9528 testVectorVectorArithmeticOps(f1, f2)
9529
9530 testVectorScalarArithmeticOps(f1, val2)
9531
9532 testVectorVectorInPlaceArithmeticOps(f1, f2)
9533
9534 testVectorScalarInPlaceArithmeticOps(f1, val2)
9535
9536 testVectorVectorComparisonOps(f1, f2)
9537
9538 testVectorScalarComparisonOps(f1, val2)
9539
9540 testVectorVectorMaskedInPlaceArithmeticOps(f1, f2, m)
9541
9542 testVectorVectorMaskedInPlaceArithmeticOps2(f1, f3, m)
9543
9544 if ArrayType in [V2fArray, V2dArray, V3fArray, V3dArray]:
9545 testUnaryVecMethods(f1)
9546
9547 testBinaryVecMethods(f1, f2)
9548
9549 # Now do the test again with both arrays read-only.
9550 # Most tests will still pass, but some will fail.
9551
9552 f1.makeReadOnly()
9553 f2.makeReadOnly()
9554 f3.makeReadOnly()
9555 assert (f1.writable() == False)
9556 assert (f2.writable() == False)
9557 assert (f3.writable() == False)
9558
9559 f1w = ArrayType(val1, aLen)
9560 assert (f1w.writable() == True)
9561
9562 testVectorVectorArithmeticOps(f1, f2)
9563
9564 testVectorScalarArithmeticOps(f1, val2)
9565
9566 testVectorVectorInPlaceArithmeticOpsReadOnly(f1 , f2)
9567 testVectorVectorInPlaceArithmeticOpsReadOnly(f1w, f2, False)
9568
9569 testVectorScalarInPlaceArithmeticOpsReadOnly(f1, val2)
9570
9571 testVectorVectorComparisonOps(f1, f2)
9572
9573 testVectorScalarComparisonOps(f1, val2)
9574
9575 testVectorVectorMaskedInPlaceArithmeticOpsReadOnly(f1 , f2, m)
9576 testVectorVectorMaskedInPlaceArithmeticOpsReadOnly(f1w, f2, m, False)
9577
9578 testVectorVectorMaskedInPlaceArithmeticOps2ReadOnly(f1 , f3, m)
9579 testVectorVectorMaskedInPlaceArithmeticOps2ReadOnly(f1w, f3, m, False)
9580
9581 if ArrayType in [V2fArray, V2dArray, V3fArray, V3dArray]:
9582 testUnaryVecMethodsReadOnly(f1)
9583
9584 testBinaryVecMethods(f1, f2)
9585
9586 print ("ok")
9587
9588 testList.append(("testReadOnlyAutoVectFloat",
9589 lambda : testReadOnlyAutoVect(FloatArray, 1.25, 5.0)))
9590 testList.append(("testReadOnlyAutoVectDouble",
9591 lambda : testReadOnlyAutoVect(DoubleArray, 3.456, 4.567)))
9592 testList.append(("testReadOnlyAutoVectV3f",
9593 lambda : testReadOnlyAutoVect(V3fArray, V3f(1.234, 2.345, 3.456),
9594 V3f(4.234, 6.345, 5.456))))
9595 testList.append(("testReadOnlyAutoVectV2d",
9596 lambda : testReadOnlyAutoVect(V2dArray, V2d(3.456, 0.456),
9597 V2d(4.567, 0.581))))
9598
9599
9600 def testReadOnlySpecialAccess():
9601 '''
9602 Tests that some of the special array-access operators (for example,
9603 a 'V3fArray' x, y, or z operators) maintain the proper writable
9604 state and behave as expected.
9605 '''
9606
9607 aLen = 123
9608
9609 b2 = Box2dArray(aLen)
9610 b3 = Box3fArray(aLen)
9611
9612 assert (b2.writable() == True)
9613 assert (b3.writable() == True)
9614
9615 assert (b2.min.writable() == True)
9616 assert (b2.max.writable() == True)
9617 assert (b3.min.writable() == True)
9618 assert (b3.max.writable() == True)
9619
9620 b2.min[10] = V2d( 1, 2)
9621 b2.max[10] = V2d( 2, 3)
9622 b3.min[10] = V3f(-1,-1,-1)
9623 b3.max[10] = V3f( 1, 1, 1)
9624
9625 b2.makeReadOnly()
9626 b3.makeReadOnly()
9627
9628 assert (b2.writable() == False)
9629 assert (b3.writable() == False)
9630
9631 assert (b2.min.writable() == False)
9632 assert (b2.max.writable() == False)
9633 assert (b3.min.writable() == False)
9634 assert (b3.max.writable() == False)
9635
9636 assert (equalWithAbsError(b2.min[10], V2d(1,2), eps) == True)
9637 assert (equalWithAbsError(b2.max[10], V2d(2,3), eps) == True)
9638 assert (equalWithAbsError(b3.min[10], V3f(-1,-1,-1), eps) == True)
9639 assert (equalWithAbsError(b3.max[10], V3f( 1, 1, 1), eps) == True)
9640
9641 try: b2.min[20] = V2d( 1, 2)
9642 except: pass
9643 else: assert(False)
9644 try: b2.max[20] = V2d( 2, 3)
9645 except: pass
9646 else: assert(False)
9647 try: b3.min[20] = V3f(-1,-1,-1)
9648 except: pass
9649 else: assert(False)
9650 try: b3.max[20] = V3f( 1, 1, 1)
9651 except: pass
9652 else: assert(False)
9653
9654 ##
9655
9656 c3 = C3fArray(aLen)
9657 c4 = C4fArray(aLen)
9658
9659 assert (c3.writable() == True)
9660 assert (c4.writable() == True)
9661
9662 assert (c3.r.writable() == True)
9663 assert (c3.g.writable() == True)
9664 assert (c3.b.writable() == True)
9665
9666 assert (c4.r.writable() == True)
9667 assert (c4.g.writable() == True)
9668 assert (c4.b.writable() == True)
9669 assert (c4.a.writable() == True)
9670
9671 c3.r[10] = 0.1
9672 c3.g[10] = 0.2
9673 c3.b[10] = 0.3
9674
9675 c4.r[10] = 0.1
9676 c4.g[10] = 0.2
9677 c4.b[10] = 0.3
9678 c4.a[10] = 0.4
9679
9680 c3.makeReadOnly()
9681 c4.makeReadOnly()
9682
9683 assert (c3.writable() == False)
9684 assert (c4.writable() == False)
9685
9686 assert (c3.r.writable() == False)
9687 assert (c3.g.writable() == False)
9688 assert (c3.b.writable() == False)
9689
9690 assert (c4.r.writable() == False)
9691 assert (c4.g.writable() == False)
9692 assert (c4.b.writable() == False)
9693 assert (c4.a.writable() == False)
9694
9695 assert (equalWithAbsError(c3.r[10], 0.1, eps) == True)
9696 assert (equalWithAbsError(c3.g[10], 0.2, eps) == True)
9697 assert (equalWithAbsError(c3.b[10], 0.3, eps) == True)
9698
9699 assert (equalWithAbsError(c4.r[10], 0.1, eps) == True)
9700 assert (equalWithAbsError(c4.g[10], 0.2, eps) == True)
9701 assert (equalWithAbsError(c4.b[10], 0.3, eps) == True)
9702 assert (equalWithAbsError(c4.a[10], 0.4, eps) == True)
9703
9704 try: c3.r[10] = 0.2
9705 except: pass
9706 else: assert(False)
9707 try: c3.g[10] = 0.3
9708 except: pass
9709 else: assert(False)
9710 try: c3.b[10] = 0.4
9711 except: pass
9712 else: assert(False)
9713
9714 try: c4.r[10] = 0.2
9715 except: pass
9716 else: assert(False)
9717 try: c4.g[10] = 0.3
9718 except: pass
9719 else: assert(False)
9720 try: c4.b[10] = 0.4
9721 except: pass
9722 else: assert(False)
9723 try: c4.a[10] = 0.5
9724 except: pass
9725 else: assert(False)
9726
9727 ##
9728
9729 qd = QuatdArray(aLen)
9730 qf = QuatfArray(aLen)
9731
9732 assert (qd.writable() == True)
9733 assert (qf.writable() == True)
9734
9735 assert (qd.r.writable() == True)
9736 assert (qd.x.writable() == True)
9737 assert (qd.y.writable() == True)
9738 assert (qd.z.writable() == True)
9739 assert (qf.r.writable() == True)
9740 assert (qf.x.writable() == True)
9741 assert (qf.y.writable() == True)
9742 assert (qf.z.writable() == True)
9743
9744 qd.setRotation( V3dArray(V3d(1,2,3), aLen),
9745 V3dArray(V3d(2,3,4), aLen) )
9746 qf.orientToVectors( V3fArray(V3f(2,3,4), aLen),
9747 V3fArray(V3f(3,4,5), aLen), False )
9748 qd.setAxisAngle( V3dArray(V3d(4,5,6), aLen), DoubleArray(23.45, aLen) )
9749 qf.setEulerXYZ( V3fArray(V3f(30,-10,20), aLen) )
9750
9751 qd.makeReadOnly()
9752 qf.makeReadOnly()
9753
9754 assert (qd.writable() == False)
9755 assert (qf.writable() == False)
9756
9757 assert (qd.r.writable() == False)
9758 assert (qd.x.writable() == False)
9759 assert (qd.y.writable() == False)
9760 assert (qd.z.writable() == False)
9761 assert (qf.r.writable() == False)
9762 assert (qf.x.writable() == False)
9763 assert (qf.y.writable() == False)
9764 assert (qf.z.writable() == False)
9765
9766 try:
9767 qd.setRotation( V3dArray(V3d(-1,-2,-3), aLen),
9768 V3dArray(V3d(-2,-3,-4), aLen) )
9769 except:
9770 pass
9771 else:
9772 assert(False)
9773 try:
9774 qf.orientToVectors( V3fArray(V3f(-2,-3,-4), aLen),
9775 V3fArray(V3f(-3,-4,-5), aLen), True )
9776 except:
9777 pass
9778 else:
9779 assert(False)
9780 try:
9781 qd.setAxisAngle( V3dArray(V3d(-4,-5,-6), aLen), DoubleArray(-23.45, aLen) )
9782 except:
9783 pass
9784 else:
9785 assert(False)
9786 try:
9787 qf.setEulerXYZ( V3fArray(V3f(-30,10,-20), aLen) )
9788 except:
9789 pass
9790 else:
9791 assert(False)
9792
9793 ##
9794
9795 v2 = V2fArray(aLen)
9796 v3 = V3dArray(aLen)
9797 v4 = V4fArray(aLen)
9798
9799 assert (v2.writable() == True)
9800 assert (v3.writable() == True)
9801 assert (v4.writable() == True)
9802
9803 assert (v2.x.writable() == True)
9804 assert (v2.y.writable() == True)
9805 assert (v3.x.writable() == True)
9806 assert (v3.y.writable() == True)
9807 assert (v3.z.writable() == True)
9808 assert (v4.x.writable() == True)
9809 assert (v4.y.writable() == True)
9810 assert (v4.z.writable() == True)
9811 assert (v4.w.writable() == True)
9812
9813 v2.x[10] = 0.1
9814 v2.y[10] = 0.2
9815 v3.x[10] = 0.1
9816 v3.y[10] = 0.2
9817 v3.z[10] = 0.3
9818 v4.x[10] = 0.1
9819 v4.y[10] = 0.2
9820 v4.z[10] = 0.3
9821 v4.w[10] = 0.4
9822
9823 v2.makeReadOnly()
9824 v3.makeReadOnly()
9825 v4.makeReadOnly()
9826
9827 assert (v2.writable() == False)
9828 assert (v3.writable() == False)
9829 assert (v4.writable() == False)
9830
9831 assert (v2.x.writable() == False)
9832 assert (v2.y.writable() == False)
9833 assert (v3.x.writable() == False)
9834 assert (v3.y.writable() == False)
9835 assert (v3.z.writable() == False)
9836 assert (v4.x.writable() == False)
9837 assert (v4.y.writable() == False)
9838 assert (v4.z.writable() == False)
9839 assert (v4.w.writable() == False)
9840
9841 assert (equalWithAbsError(v2.x[10], 0.1, eps) == True)
9842 assert (equalWithAbsError(v2.y[10], 0.2, eps) == True)
9843 assert (equalWithAbsError(v3.x[10], 0.1, eps) == True)
9844 assert (equalWithAbsError(v3.y[10], 0.2, eps) == True)
9845 assert (equalWithAbsError(v3.z[10], 0.3, eps) == True)
9846 assert (equalWithAbsError(v4.x[10], 0.1, eps) == True)
9847 assert (equalWithAbsError(v4.y[10], 0.2, eps) == True)
9848 assert (equalWithAbsError(v4.z[10], 0.3, eps) == True)
9849 assert (equalWithAbsError(v4.w[10], 0.4, eps) == True)
9850
9851 try: v2.x[20] = 0.2
9852 except: pass
9853 else: assert(False)
9854 try: v2.y[20] = 0.3
9855 except: pass
9856 else: assert(False)
9857 try: v3.x[20] = 0.2
9858 except: pass
9859 else: assert(False)
9860 try: v3.y[20] = 0.3
9861 except: pass
9862 else: assert(False)
9863 try: v3.z[20] = 0.4
9864 except: pass
9865 else: assert(False)
9866 try: v4.x[20] = 0.2
9867 except: pass
9868 else: assert(False)
9869 try: v4.y[20] = 0.3
9870 except: pass
9871 else: assert(False)
9872 try: v4.z[20] = 0.4
9873 except: pass
9874 else: assert(False)
9875 try: v4.w[20] = 0.5
9876 except: pass
9877 else: assert(False)
9878
9879 print ("ok")
9880
9881 testList.append(("testReadOnlySpecialAccess", testReadOnlySpecialAccess))
9882
9883
9884 def testReadOnlyIndexedArrays(ArrayType, val):
9885 '''
9886 Tests that indexed read-only arrays behave as expected.
9887 '''
9888
9889 aLen = 123
9890
9891 a = ArrayType(aLen)
9892 assert (a.writable() == True)
9893
9894 m = IntArray(aLen)
9895 m[:] = 0
9896 m[10:80] = 1
9897 assert (m.writable() == True)
9898 m.makeReadOnly()
9899 assert (m.writable() == False)
9900
9901 a1 = a[30:100] # getitem (new array; writable)
9902 assert (len(a1) == 70)
9903 assert (a1.writable() == True)
9904 a1[:] = val
9905
9906 a2 = a[m] # getitem (copied; writable state preserved)
9907 assert (len(a2) == 70)
9908 assert (a2.writable() == True)
9909 a2[:] = val
9910
9911 assert (equalWithAbsError(a[ 5], val, eps) == False)
9912 assert (equalWithAbsError(a[20], val, eps) == True )
9913 assert (equalWithAbsError(a[90], val, eps) == False)
9914
9915 a2[:] = ArrayType(2 * val, 70)
9916 assert (equalWithAbsError(a[ 5], 2*val, eps) == False)
9917 assert (equalWithAbsError(a[20], 2*val, eps) == True )
9918 assert (equalWithAbsError(a[90], 2*val, eps) == False)
9919
9920 a.makeReadOnly()
9921 assert (a.writable() == False)
9922
9923 a1 = a[30:100] # getitem (new array; writable by default)
9924 assert (len(a1) == 70)
9925 assert (a1.writable() == True)
9926 a1[:] = val
9927
9928 a2 = a[m] # getitem (copied; writable state preserved)
9929 assert (len(a2) == 70)
9930 assert (a2.writable() == False)
9931 try: a2[:] = val
9932 except: pass
9933 else: assert(False)
9934
9935 a1[:] = ArrayType(val, 70)
9936 try: a2[:] = ArrayType(val, 70)
9937 except: pass
9938 else: assert(False)
9939
9940 #
9941
9942 a = ArrayType(aLen)
9943 assert (a.writable() == True)
9944
9945 a[m] = val # setitem_scalar
9946 a[100:110] = 2*val # setitem_scalar
9947 assert (equalWithAbsError(a[ 5], val, eps) == False)
9948 assert (equalWithAbsError(a[ 30], val, eps) == True )
9949 assert (equalWithAbsError(a[105], 2*val, eps) == True )
9950 assert (equalWithAbsError(a[115], 2*val, eps) == False)
9951
9952 a[m] = ArrayType(3*val, 70) # setitem_vector
9953 a[100:110] = ArrayType(4*val, 10) # setitem_vector
9954 assert (equalWithAbsError(a[ 5], 3*val, eps) == False)
9955 assert (equalWithAbsError(a[ 30], 3*val, eps) == True )
9956 assert (equalWithAbsError(a[105], 4*val, eps) == True )
9957 assert (equalWithAbsError(a[115], 4*val, eps) == False)
9958
9959 a.makeReadOnly()
9960 assert (a.writable() == False)
9961
9962 try: a[m] = 5*val; # setitem_scalar
9963 except: pass
9964 else: assert(False)
9965 try: a[100:110] = 6*val; # setitem_scalar
9966 except: pass
9967 else: assert(False)
9968
9969 try: a[m] = ArrayType(7*val, 70) # setitem_vector
9970 except: pass
9971 else: assert(False)
9972 try: a[100:110] = ArrayType(8*val, 10) # setitem_vector
9973 except: pass
9974 else: assert(False)
9975
9976 print ("ok")
9977
9978 testList.append(("testReadOnlyIndexedArraysFloat",
9979 lambda : testReadOnlyIndexedArrays(FloatArray, 1.25)))
9980 testList.append(("testReadOnlyIndexedArraysV3f",
9981 lambda : testReadOnlyIndexedArrays(V3fArray, V3f(1.25, 2, 3))))
9982
9983
9984 def testReadOnlyVIntArrays():
9985 '''
9986 Tests the basic operations of read-only Variable-Int arrays and makes
9987 sure they behave as expected and throw access errors when they should.
9988 '''
9989
9990 aLen = 123
9991
9992 a = VIntArray(aLen)
9993 assert (len(a) == aLen)
9994 assert (a.writable() == True)
9995
9996 a.size[:] = 10 # 10 cvs each.
9997
9998 for i in range(aLen):
9999 assert (len(a[i]) == 10)
10000 for j in range(10):
10001 a[i][j] = j + i
10002
10003 for i in range(aLen):
10004 for j in range(len(a[i])):
10005 assert (a[i][j] == (i+j))
10006
10007 a.makeReadOnly()
10008 assert (a.writable() == False)
10009
10010 av = a[70] # getitem
10011 assert(len(av) == 10)
10012 assert(av.writable() == False)
10013
10014 try: a[80][5] = 7
10015 except: pass
10016 else: assert(False)
10017
10018 assert (a.size[12] == 10)
10019 try: a.size[13] = 12
10020 except: pass
10021 else: assert(False)
10022
10023 av = a[10:14]
10024 assert (len(av) == 4)
10025 assert (av.writable() == True) # A new array is returned for slices
10026 for i in range(len(av)):
10027 assert (len(av[i]) == 10)
10028 av[i][3] = 3
10029 av[i][8] = 8
10030
10031 m = IntArray(aLen)
10032 m[:] = 0
10033 m[50:70] = 1
10034 m.makeReadOnly()
10035
10036 av = a[m]
10037 assert (len(av) == 20)
10038 assert (av.writable() == False) # An copied indexed array is returned for masks.
10039
10040 print ("ok")
10041
10042 testList.append(("testReadOnlyVIntArrays", testReadOnlyVIntArrays))
10043
10044
10045 def testReadOnlyStringArrays():
10046 '''
10047 Tests the basic operations of read-only string arrays and makes sure
10048 they behave as expected and throw access errors when they should.
10049 '''
10050
10051 aLen = 20
10052
10053 a = StringArray(aLen)
10054 assert (len(a) == aLen)
10055 assert (a.writable() == True)
10056
10057 a[:] = "Hello"
10058 a[10] = "Hello Joe"
10059
10060 for i in range(20):
10061 if i == 10:
10062 assert (a[i] == "Hello Joe")
10063 else:
10064 assert (a[i] == "Hello")
10065
10066 a.makeReadOnly()
10067 assert (len(a) == aLen)
10068 assert (a.writable() == False)
10069
10070 for i in range(20):
10071 if i == 10:
10072 assert (a[i] == "Hello Joe")
10073 else:
10074 assert (a[i] == "Hello")
10075
10076 try: a[3:12] = "Goodbye"
10077 except: pass
10078 else: assert(False)
10079 try: a[10] = "Goodbye Joe"
10080 except: pass
10081 else: assert(False)
10082
10083 print ("ok")
10084
10085 testList.append(("testReadOnlyStringArrays", testReadOnlyStringArrays))
10086
10087
10088 def testQuatArrays():
10089
10090 x = math.sqrt(2.) / 2.
10091 q1 = QuatfArray(5)
10092
10093 q1[0].setAxisAngle (V3f ( 1., 0., 0.), math.pi)
10094 q1[1].setAxisAngle (V3f ( 1., 1., 0.), math.pi)
10095 q1[2].setAxisAngle (V3f ( 0., 1., 0.), math.pi)
10096 q1[3].setAxisAngle (V3f (-1., 1., 0.), math.pi)
10097 q1[4].setAxisAngle (V3f (-1., 0., 0.), math.pi)
10098
10099 qA = Quatf()
10100 qA.setAxisAngle (V3f (0., 0., 1.), math.pi / 2.)
10101
10102 assert (abs (q1.x[1] - x) <= 1.e-6)
10103 assert (abs (q1.y[1] - x) <= 1.e-6)
10104 assert (abs (q1.x[3] + x) <= 1.e-6)
10105 assert (abs (q1.y[3] - x) <= 1.e-6)
10106
10107 q2 = -q1
10108 for i in range(5):
10109 assert (q2[i] == -q1[i])
10110
10111 s = q1 ^ q2
10112 for i in range(5):
10113 assert (s[i] == q1[i] ^ q2[i])
10114
10115 q3 = q1 * qA
10116 for i in range(5):
10117 assert (q3[i] == q1[i] * qA)
10118 q3 *= 10.
10119
10120 tmp = QuatfArray (5)
10121 tmp[:] = q3
10122 q3.normalize()
10123 for i in range(5):
10124 assert (q3[i] != tmp[i])
10125 assert (q3[i] == tmp[i].normalized())
10126
10127 q4 = q1.slerp (q3, 0.5)
10128 for i in range(5):
10129 assert (q4[i] == q1[i].slerpShortestArc (q3[i], 0.5))
10130
10131 tmp[:] = q4
10132 q4 *= q3.inverse()
10133 for i in range(5):
10134 assert (q4[i] == tmp[i] * q3[i].inverse())
10135
10136 q5 = QuatfArray (5)
10137 tmp[:] = q4
10138 q5[:] = q4.normalized()
10139 for i in range(5):
10140 assert (q4[i] == tmp[i])
10141 assert (q5[i] == q4[i].normalize())
10142
10143 print ("ok")
10144
10145 testList.append(("testQuatArrays", testQuatArrays))
10146
10147
10148 def testBufferProtocol():
10149 '''
10150 The buffer protocol can be used to exchange array data between python modules.
10151 For example, numpy and Pixar Vt arrays both support the buffer protocol.
10152 There's a limited amount of testing that can be done with native python, so
10153 the majority of this functionality is tested in the PyImathNumpyTest project.
10154 '''
10155 def verifyScalar (a):
10156
10157 m = memoryview (a)
10158 assert ( m.ndim == 1)
10159 assert (len(m.strides) == m.ndim)
10160 assert ( len(m.shape) == m.ndim)
10161 assert ( m.shape[0] == len(a))
10162 assert ( m.strides[0] == struct.calcsize (m.format))
10163
10164
10165 def verifyVector (a):
10166
10167 m = memoryview (a)
10168 assert ( m.ndim == 2)
10169 assert (len(m.strides) == m.ndim)
10170 assert ( len(m.shape) == m.ndim)
10171 assert ( m.shape[0] == len(a))
10172 assert ( m.shape[1] == len(a[0]))
10173 assert ( m.strides[0] == struct.calcsize (m.format) * len(a[0]))
10174 assert ( m.strides[1] == struct.calcsize (m.format))
10175
10176 # .............................................................................
10177
10178 import struct
10179
10180 a = UnsignedCharArray (10)
10181 verifyScalar (a)
10182
10183 a = IntArray (10)
10184 verifyScalar (a)
10185
10186 a = FloatArray (10)
10187 verifyScalar (a)
10188
10189 a = DoubleArray (10)
10190 verifyScalar (a)
10191
10192 a = V2iArray (10)
10193 verifyVector (a)
10194
10195 a = V2fArray (10)
10196 verifyVector (a)
10197
10198 a = V2dArray (10)
10199 verifyVector (a)
10200
10201 a = V3iArray (10)
10202 verifyVector (a)
10203
10204 a = V3fArray (10)
10205 verifyVector (a)
10206
10207 a = V3dArray (10)
10208 verifyVector (a)
10209
10210 print ("ok")
10211
10212 testList.append(("Buffer protocol test", testBufferProtocol))
10213
10214 def testFloatArray2D():
10215
10216 a = FloatArray2D(2,3)
10217 a[(0,0)] = 1.0
10218 a[(0,1)] = 2.0
10219 a[(0,2)] = 3.0
10220 a[(1,0)] = 4.0
10221 a[(1,1)] = 5.0
10222 a[(1,2)] = 6.0
10223
10224 a += 1.0
10225 a -= 0.5
10226 a *= 4.0
10227 a /= 2.0
10228 b = 3 * a - a + (a * a / 2) / a
10229
10230 assert equalWithAbsError (b.item(0,0), 7.5, 0.001)
10231 assert equalWithAbsError (b.item(0,1), 12.5, 0.001)
10232 assert equalWithAbsError (b.item(0,2), 17.5, 0.001)
10233 assert equalWithAbsError (b.item(1,0), 22.5, 0.001)
10234 assert equalWithAbsError (b.item(1,1), 27.5, 0.001)
10235 assert equalWithAbsError (b.item(1,2), 32.5, 0.001)
10236
10237 choice = IntArray2D(2,3)
10238 choice[(0,0)] = 1
10239 choice[(0,1)] = 0
10240 choice[(0,2)] = 0
10241 choice[(1,0)] = 0
10242 choice[(1,1)] = 1
10243 choice[(1,2)] = 0
10244
10245 d = b.ifelse(choice,a)
10246
10247 assert d.item(0,0) == b.item(0,0)
10248 assert d.item(0,1) == a.item(0,1)
10249 assert d.item(0,2) == a.item(0,2)
10250 assert d.item(1,0) == a.item(1,0)
10251 assert d.item(1,1) == b.item(1,1)
10252 assert d.item(1,2) == a.item(1,2)
10253
10254 print ("ok")
10255
10256 testList.append(("FloatArray2D test", testFloatArray2D))
10257
10258 def testColor4Array2D():
10259
10260 a = Color4fArray2D(2,3)
10261 a[(0,0)] = Color4f(1,0,0,0)
10262 a[(0,1)] = Color4f(0,1,0,0)
10263 a[(0,2)] = Color4f(0,0,1,0)
10264 a[(1,0)] = Color4f(1,0,0,1)
10265 a[(1,1)] = Color4f(0,1,0,1)
10266 a[(1,2)] = Color4f(0,0,1,1)
10267
10268 a += Color4f(1.0, 1.0, 1.0, 1.0)
10269 a -= Color4f(0.5, 0.5, 0.5, 0.5)
10270 a *= 4.0
10271 a /= 2.0
10272 b = 3 * a - a + (a * a / 2) / a
10273
10274 assert equalWithAbsError (b.item(0,0), Color4f(7.5, 2.5, 2.5, 2.5), 0.001)
10275 assert equalWithAbsError (b.item(0,1), Color4f(2.5, 7.5, 2.5, 2.5), 0.001)
10276 assert equalWithAbsError (b.item(0,2), Color4f(2.5, 2.5, 7.5, 2.5), 0.001)
10277 assert equalWithAbsError (b.item(1,0), Color4f(7.5, 2.5, 2.5, 7.5), 0.001)
10278 assert equalWithAbsError (b.item(1,1), Color4f(2.5, 7.5, 2.5, 7.5), 0.001)
10279 assert equalWithAbsError (b.item(1,2), Color4f(2.5, 2.5, 7.5, 7.5), 0.001)
10280
10281 choice = IntArray2D(2,3)
10282 choice[(0,0)] = 1
10283 choice[(0,1)] = 0
10284 choice[(0,2)] = 0
10285 choice[(1,0)] = 0
10286 choice[(1,1)] = 1
10287 choice[(1,2)] = 0
10288
10289 d = b.ifelse(choice,a)
10290
10291 assert d.item(0,0) == b.item(0,0)
10292 assert d.item(0,1) == a.item(0,1)
10293 assert d.item(0,2) == a.item(0,2)
10294 assert d.item(1,0) == a.item(1,0)
10295 assert d.item(1,1) == b.item(1,1)
10296 assert d.item(1,2) == a.item(1,2)
10297
10298 print ("ok")
10299
10300 testList.append(("Color4fArray2D test", testColor4Array2D))
10301
10302 # -------------------------------------------------------------------------
10303 # Main loop
10304
10305 random.seed (1567)
10306
10307 import imath
10308 print (imath.__file__)
10309
10310 for test in testList:
10311 funcName = test[0]
10312 print ("")
10313 print ("Running {}".format (funcName))
10314 test[1]()
10315
10316 print ("")
10317
10318 # Local Variables:
10319 # mode:python
10320 # End: