Debian Codegraph @

src/python/PyImath/PyImathColor4Array2DImpl.h

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 // clang-format off
7
8 #ifndef _PyImathColor4Array2DImpl_h_
9 #define _PyImathColor4Array2DImpl_h_
10
11 //
12 // This .C file was turned into a header file so that instantiations
13 // of the various V3* types can be spread across multiple files in
14 // order to work around MSVC limitations.
15 //
16
17 #include <Python.h>
18 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
19 #include <boost/python.hpp>
20 #include <boost/python/make_constructor.hpp>
21 #include <boost/format.hpp>
22 #include "PyImath.h"
23 #include "PyImathMathExc.h"
24 #include "PyImathDecorators.h"
25
26 namespace PyImath {
27 using namespace boost::python;
28 using namespace IMATH_NAMESPACE;
29
30 template <class T> struct Color4Array2DName { static const char *value(); };
31
32
33 // XXX fixme - template this
34 // really this should get generated automatically...
35
36 template <class T,int index>
37 static FixedArray2D<T>
38 Color4Array2D_get(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va)
39 {
40 return FixedArray2D<T>(&va(0,0)[index], va.len().x,va.len().y, 4*va.stride().x, va.stride().y, va.handle());
41 }
42
43
44 // template <class T>
45 // static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
46 // Color4Array_cross0(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
47 // {
48 // PY_IMATH_LEAVE_PYTHON;
49 // IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
50 // FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
51 // for (size_t i = 0; i < len; ++i)
52 // f(i,j) = va(i,j).cross(vb(i,j));
53 // return f;
54 // }
55 //
56 // template <class T>
57 // static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
58 // Color4Array_cross1(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
59 // {
60 // PY_IMATH_LEAVE_PYTHON;
61 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
62 // FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
63 // for (size_t i = 0; i < len; ++i)
64 // f(i,j) = va(i,j).cross(vb);
65 // return f;
66 // }
67 //
68 // template <class T>
69 // static FixedArray2D<T>
70 // Color4Array_dot0(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
71 // {
72 // PY_IMATH_LEAVE_PYTHON;
73 // IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
74 // FixedArray2D<T> f(len);
75 // for (size_t i = 0; i < len; ++i)
76 // f(i,j) = va(i,j).dot(vb(i,j));
77 // return f;
78 // }
79 //
80 // template <class T>
81 // static FixedArray2D<T>
82 // Color4Array_dot1(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
83 // {
84 // PY_IMATH_LEAVE_PYTHON;
85 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
86 // FixedArray2D<T> f(len);
87 // for (size_t i = 0; i < len; ++i)
88 // f(i,j) = va(i,j).dot(vb);
89 // return f;
90 // }
91
92 // template <class T>
93 // static FixedArray2D<T>
94 // Color4Array_length(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va)
95 // {
96 // PY_IMATH_LEAVE_PYTHON;
97 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
98 // FixedArray2D<T> f(len);
99 // for (size_t i = 0; i < len; ++i)
100 // f(i,j) = va(i,j).length();
101 // return f;
102 // }
103 //
104 // template <class T>
105 // static FixedArray2D<T>
106 // Color4Array_length2(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va)
107 // {
108 // PY_IMATH_LEAVE_PYTHON;
109 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
110 // FixedArray2D<T> f(len);
111 // for (size_t i = 0; i < len; ++i)
112 // f(i,j) = va(i,j).length2();
113 // return f;
114 // }
115 //
116 // template <class T>
117 // static FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
118 // Color4Array_normalize(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va)
119 // {
120 // PY_IMATH_LEAVE_PYTHON;
121 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
122 // for (size_t i = 0; i < len; ++i)
123 // va(i,j).normalize();
124 // return va;
125 // }
126 //
127 // template <class T> static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
128 // Color4Array_normalized(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va)
129 // {
130 // PY_IMATH_LEAVE_PYTHON;
131 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
132 // FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
133 // for (size_t i = 0; i < len; ++i)
134 // f(i,j) = va(i,j).normalized();
135 // return f;
136 // }
137 //
138 template <class T>
139 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
140 Color4Array_mulT(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, T t)
141 {
142 PY_IMATH_LEAVE_PYTHON;
143 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
144 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
145 for (size_t j = 0; j < len.y; ++j)
146 for (size_t i = 0; i < len.x; ++i)
147 f(i,j) = va(i,j) * t;
148 return f;
149 }
150 //
151 // template <class T, class U>
152 // static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
153 // Color4Array_mulM44(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Matrix44<U> &m)
154 // {
155 // PY_IMATH_LEAVE_PYTHON;
156 // IMATH_NAMESPACE::Vec2<size_t> len = va.len();
157 // FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
158 // for (size_t i = 0; i < len; ++i)
159 // f(i,j) = va(i,j) * m;
160 // return f;
161 // }
162 //
163 template <class T>
164 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
165 Color4Array_mulArrayT(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<T> &vb)
166 {
167 PY_IMATH_LEAVE_PYTHON;
168 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
169 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
170 for (size_t j = 0; j < len.y; ++j)
171 for (size_t i = 0; i < len.x; ++i)
172 f(i,j) = va(i,j) * vb(i,j);
173 return f;
174 }
175
176 template <class T>
177 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
178 Color4Array_imulT(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, T t)
179 {
180 PY_IMATH_LEAVE_PYTHON;
181 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
182 for (size_t j = 0; j < len.y; ++j)
183 for (size_t i = 0; i < len.x; ++i)
184 va(i,j) *= t;
185 return va;
186 }
187
188 template <class T>
189 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
190 Color4Array_imulArrayT(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<T> &vb)
191 {
192 PY_IMATH_LEAVE_PYTHON;
193 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
194 for (size_t j = 0; j < len.y; ++j)
195 for (size_t i = 0; i < len.x; ++i)
196 va(i,j) *= vb(i,j);
197 return va;
198 }
199
200 template <class T>
201 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
202 Color4Array_divT(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, T t)
203 {
204 PY_IMATH_LEAVE_PYTHON;
205 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
206 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
207 for (size_t j = 0; j < len.y; ++j)
208 for (size_t i = 0; i < len.x; ++i)
209 f(i,j) = va(i,j) / t;
210 return f;
211 }
212
213 template <class T>
214 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
215 Color4Array_divArrayT(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<T> &vb)
216 {
217 PY_IMATH_LEAVE_PYTHON;
218 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
219 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
220 for (size_t j = 0; j < len.y; ++j)
221 for (size_t i = 0; i < len.x; ++i)
222 f(i,j) = va(i,j) / vb(i,j);
223 return f;
224 }
225
226 template <class T>
227 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
228 Color4Array_idivT(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, T t)
229 {
230 PY_IMATH_LEAVE_PYTHON;
231 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
232 for (size_t j = 0; j < len.y; ++j)
233 for (size_t i = 0; i < len.x; ++i)
234 va(i,j) /= t;
235 return va;
236 }
237
238 template <class T>
239 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
240 Color4Array_idivArrayT(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<T> &vb)
241 {
242 PY_IMATH_LEAVE_PYTHON;
243 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
244 for (size_t j = 0; j < len.y; ++j)
245 for (size_t i = 0; i < len.x; ++i)
246 va(i,j) /= vb(i,j);
247 return va;
248 }
249
250 template <class T>
251 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
252 Color4Array_add(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
253 {
254 PY_IMATH_LEAVE_PYTHON;
255 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
256 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
257 for (size_t j = 0; j < len.y; ++j)
258 for (size_t i = 0; i < len.x; ++i)
259 f(i,j) = va(i,j) + vb(i,j);
260 return f;
261 }
262
263 template <class T>
264 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
265 Color4Array_addColor(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
266 {
267 PY_IMATH_LEAVE_PYTHON;
268 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
269 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
270 for (size_t j = 0; j < len.y; ++j)
271 for (size_t i = 0; i < len.x; ++i)
272 f(i,j) = va(i,j) + vb;
273 return f;
274 }
275
276 template <class T>
277 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
278 Color4Array_sub(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
279 {
280 PY_IMATH_LEAVE_PYTHON;
281 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
282 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
283 for (size_t j = 0; j < len.y; ++j)
284 for (size_t i = 0; i < len.x; ++i)
285 f(i,j) = va(i,j) - vb(i,j);
286 return f;
287 }
288
289 template <class T>
290 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
291 Color4Array_subColor(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
292 {
293 PY_IMATH_LEAVE_PYTHON;
294 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
295 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
296 for (size_t j = 0; j < len.y; ++j)
297 for (size_t i = 0; i < len.x; ++i)
298 f(i,j) = va(i,j) - vb;
299 return f;
300 }
301
302 template <class T>
303 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
304 Color4Array_rsubColor(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
305 {
306 PY_IMATH_LEAVE_PYTHON;
307 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
308 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
309 for (size_t j = 0; j < len.y; ++j)
310 for (size_t i = 0; i < len.x; ++i)
311 f(i,j) = vb - va(i,j);
312 return f;
313 }
314
315 template <class T>
316 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
317 Color4Array_mul(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
318 {
319 PY_IMATH_LEAVE_PYTHON;
320 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
321 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
322 for (size_t j = 0; j < len.y; ++j)
323 for (size_t i = 0; i < len.x; ++i)
324 f(i,j) = va(i,j) * vb(i,j);
325 return f;
326 }
327
328 template <class T>
329 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
330 Color4Array_mulColor(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
331 {
332 PY_IMATH_LEAVE_PYTHON;
333 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
334 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
335 for (size_t j = 0; j < len.y; ++j)
336 for (size_t i = 0; i < len.x; ++i)
337 f(i,j) = va(i,j) * vb;
338 return f;
339 }
340
341 template <class T>
342 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
343 Color4Array_div(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
344 {
345 PY_IMATH_LEAVE_PYTHON;
346 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
347 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
348 for (size_t j = 0; j < len.y; ++j)
349 for (size_t i = 0; i < len.x; ++i)
350 f(i,j) = va(i,j) / vb(i,j);
351 return f;
352 }
353
354 template <class T>
355 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
356 Color4Array_divColor(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
357 {
358 PY_IMATH_LEAVE_PYTHON;
359 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
360 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
361 for (size_t j = 0; j < len.y; ++j)
362 for (size_t i = 0; i < len.x; ++i)
363 f(i,j) = va(i,j) / vb;
364 return f;
365 }
366
367 template <class T>
368 static FixedArray2D<IMATH_NAMESPACE::Color4<T> >
369 Color4Array_neg(const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va)
370 {
371 PY_IMATH_LEAVE_PYTHON;
372 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
373 FixedArray2D<IMATH_NAMESPACE::Color4<T> > f(len);
374 for (size_t j = 0; j < len.y; ++j)
375 for (size_t i = 0; i < len.x; ++i)
376 f(i,j) = -va(i,j);
377 return f;
378 }
379
380 template <class T>
381 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
382 Color4Array_iadd(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
383 {
384 PY_IMATH_LEAVE_PYTHON;
385 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
386 for (size_t j = 0; j < len.y; ++j)
387 for (size_t i = 0; i < len.x; ++i)
388 va(i,j) += vb(i,j);
389 return va;
390 }
391
392 template <class T>
393 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
394 Color4Array_iaddColor(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
395 {
396 PY_IMATH_LEAVE_PYTHON;
397 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
398 for (size_t j = 0; j < len.y; ++j)
399 for (size_t i = 0; i < len.x; ++i)
400 va(i,j) += vb;
401 return va;
402 }
403
404 template <class T>
405 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
406 Color4Array_isub(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
407 {
408 PY_IMATH_LEAVE_PYTHON;
409 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
410 for (size_t j = 0; j < len.y; ++j)
411 for (size_t i = 0; i < len.x; ++i)
412 va(i,j) -= vb(i,j);
413 return va;
414 }
415
416 template <class T>
417 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
418 Color4Array_isubColor(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
419 {
420 PY_IMATH_LEAVE_PYTHON;
421 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
422 for (size_t j = 0; j < len.y; ++j)
423 for (size_t i = 0; i < len.x; ++i)
424 va(i,j) -= vb;
425 return va;
426 }
427
428 template <class T>
429 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
430 Color4Array_imul(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
431 {
432 PY_IMATH_LEAVE_PYTHON;
433 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
434 for (size_t j = 0; j < len.y; ++j)
435 for (size_t i = 0; i < len.x; ++i)
436 va(i,j) *= vb(i,j);
437 return va;
438 }
439
440 template <class T>
441 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
442 Color4Array_imulColor(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
443 {
444 PY_IMATH_LEAVE_PYTHON;
445 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
446 for (size_t j = 0; j < len.y; ++j)
447 for (size_t i = 0; i < len.x; ++i)
448 va(i,j) *= vb;
449 return va;
450 }
451
452 template <class T>
453 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
454 Color4Array_idiv(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &vb)
455 {
456 PY_IMATH_LEAVE_PYTHON;
457 IMATH_NAMESPACE::Vec2<size_t> len = va.match_dimension(vb);
458 for (size_t j = 0; j < len.y; ++j)
459 for (size_t i = 0; i < len.x; ++i)
460 va(i,j) /= vb(i,j);
461 return va;
462 }
463
464 template <class T>
465 static const FixedArray2D<IMATH_NAMESPACE::Color4<T> > &
466 Color4Array_idivColor(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const IMATH_NAMESPACE::Color4<T> &vb)
467 {
468 PY_IMATH_LEAVE_PYTHON;
469 IMATH_NAMESPACE::Vec2<size_t> len = va.len();
470 for (size_t j = 0; j < len.y; ++j)
471 for (size_t i = 0; i < len.x; ++i)
472 va(i,j) /= vb;
473 return va;
474 }
475
476 template <class T>
477 static void
478 setItemTuple(FixedArray2D<IMATH_NAMESPACE::Color4<T> > &va, const tuple &index, const tuple &t)
479 {
480 if(t.attr("__len__")() == 4 && index.attr("__len__")() == 2)
481 {
482 Color4<T> v;
483 v.r = extract<T>(t[0]);
484 v.g = extract<T>(t[1]);
485 v.b = extract<T>(t[2]);
486 v.a = extract<T>(t[3]);
487 va(va.canonical_index(extract<Py_ssize_t>(index[0]),va.len()[0]),
488 va.canonical_index(extract<Py_ssize_t>(index[1]),va.len()[1])) = v;
489 }
490 else
491 throw std::invalid_argument ("tuple of length 4 expected");
492 }
493
494 template <class T>
495 class_<FixedArray2D<IMATH_NAMESPACE::Color4<T> > >
496 register_Color4Array2D()
497 {
498 class_<FixedArray2D<IMATH_NAMESPACE::Color4<T> > > color4Array2D_class =
499 FixedArray2D<IMATH_NAMESPACE::Color4<T> >::register_(Color4Array2DName<T>::value(),"Fixed length 2d array of IMATH_NAMESPACE::Color4");
500 color4Array2D_class
501 .add_property("r",&Color4Array2D_get<T,0>)
502 .add_property("g",&Color4Array2D_get<T,1>)
503 .add_property("b",&Color4Array2D_get<T,2>)
504 .add_property("a",&Color4Array2D_get<T,3>)
505 // .def("dot",&Color4Array_dot0<T>)
506 // .def("dot",&Color4Array_dot1<T>)
507 // .def("cross", &Color4Array_cross0<T>)
508 // .def("cross", &Color4Array_cross1<T>)
509 // .def("length", &Color4Array_length<T>)
510 // .def("length2", &Color4Array_length2<T>)
511 // .def("normalize", &Color4Array_normalize<T>,return_internal_reference<>())
512 // .def("normalized", &Color4Array_normalized<T>)
513 .def("__setitem__", &setItemTuple<T>)
514 .def("__mul__", &Color4Array_mulT<T>)
515 // .def("__mul__", &Color4Array_mulM44<T, float>)
516 // .def("__mul__", &Color4Array_mulM44<T, double>)
517 .def("__rmul__", &Color4Array_mulT<T>)
518 .def("__mul__", &Color4Array_mulArrayT<T>)
519 .def("__rmul__", &Color4Array_mulArrayT<T>)
520 .def("__imul__", &Color4Array_imulT<T>,return_internal_reference<>())
521 .def("__imul__", &Color4Array_imulArrayT<T>,return_internal_reference<>())
522 .def("__div__", &Color4Array_divT<T>)
523 .def("__div__", &Color4Array_divArrayT<T>)
524 .def("__truediv__", &Color4Array_divT<T>)
525 .def("__truediv__", &Color4Array_divArrayT<T>)
526 .def("__idiv__", &Color4Array_idivT<T>,return_internal_reference<>())
527 .def("__idiv__", &Color4Array_idivArrayT<T>,return_internal_reference<>())
528 .def("__itruediv__", &Color4Array_idivT<T>,return_internal_reference<>())
529 .def("__itruediv__", &Color4Array_idivArrayT<T>,return_internal_reference<>())
530 .def("__add__",&Color4Array_add<T>)
531 .def("__add__",&Color4Array_addColor<T>)
532 .def("__radd__",&Color4Array_addColor<T>)
533 .def("__sub__",&Color4Array_sub<T>)
534 .def("__sub__",&Color4Array_subColor<T>)
535 .def("__rsub__",&Color4Array_rsubColor<T>)
536 .def("__mul__",&Color4Array_mul<T>)
537 .def("__mul__",&Color4Array_mulColor<T>)
538 .def("__rmul__",&Color4Array_mulColor<T>)
539 .def("__div__",&Color4Array_div<T>)
540 .def("__div__",&Color4Array_divColor<T>)
541 .def("__truediv__",&Color4Array_div<T>)
542 .def("__truediv__",&Color4Array_divColor<T>)
543 .def("__neg__",&Color4Array_neg<T>)
544 .def("__iadd__",&Color4Array_iadd<T>, return_internal_reference<>())
545 .def("__iadd__",&Color4Array_iaddColor<T>, return_internal_reference<>())
546 .def("__isub__",&Color4Array_isub<T>, return_internal_reference<>())
547 .def("__isub__",&Color4Array_isubColor<T>, return_internal_reference<>())
548 .def("__imul__",&Color4Array_imul<T>, return_internal_reference<>())
549 .def("__imul__",&Color4Array_imulColor<T>, return_internal_reference<>())
550 .def("__idiv__",&Color4Array_idiv<T>, return_internal_reference<>())
551 .def("__idiv__",&Color4Array_idivColor<T>, return_internal_reference<>())
552 .def("__itruediv__",&Color4Array_idiv<T>, return_internal_reference<>())
553 .def("__itruediv__",&Color4Array_idivColor<T>, return_internal_reference<>())
554 ;
555
556 add_comparison_functions(color4Array2D_class);
557 decoratecopy(color4Array2D_class);
558
559 return color4Array2D_class;
560 }
561
562
563 } // namespace PyImath
564
565 #endif // _PyImathColor4ArrayImpl_h_