Debian Codegraph @

src/python/PyImath/PyImathBox.cpp

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 // clang-format off
7
8 #include <boost/python/make_constructor.hpp>
9 #include <vector>
10 #include <ImathBoxAlgo.h>
11 #include "PyImathBox.h"
12 #include "PyImathVec.h"
13 #include "PyImathMathExc.h"
14 #include "PyImathDecorators.h"
15 #include "PyImathExport.h"
16 #include "PyImathTask.h"
17 #include "PyImathBoxArrayImpl.h"
18
19 namespace PyImath {
20 using namespace boost::python;
21 using namespace IMATH_NAMESPACE;
22 using namespace PyImath;
23
24 template <class T> struct BoxName { static const char *value; };
25 template <> const char *BoxName<IMATH_NAMESPACE::V2s>::value = "Box2s";
26 template <> const char *BoxName<IMATH_NAMESPACE::V2i>::value = "Box2i";
27 template <> const char *BoxName<IMATH_NAMESPACE::V2i64>::value = "Box2i64";
28 template <> const char *BoxName<IMATH_NAMESPACE::V2f>::value = "Box2f";
29 template <> const char *BoxName<IMATH_NAMESPACE::V2d>::value = "Box2d";
30 template <> const char *BoxName<IMATH_NAMESPACE::V3s>::value = "Box3s";
31 template <> const char *BoxName<IMATH_NAMESPACE::V3i>::value = "Box3i";
32 template <> const char *BoxName<IMATH_NAMESPACE::V3i64>::value = "Box3i64";
33 template <> const char *BoxName<IMATH_NAMESPACE::V3f>::value = "Box3f";
34 template <> const char *BoxName<IMATH_NAMESPACE::V3d>::value = "Box3d";
35
36 template <> PYIMATH_EXPORT const char *PyImath::Box2sArray::name() { return "Box2sArray"; }
37 template <> PYIMATH_EXPORT const char *PyImath::Box2iArray::name() { return "Box2iArray"; }
38 template <> PYIMATH_EXPORT const char *PyImath::Box2i64Array::name() { return "Box2i64Array"; }
39 template <> PYIMATH_EXPORT const char *PyImath::Box2fArray::name() { return "Box2fArray"; }
40 template <> PYIMATH_EXPORT const char *PyImath::Box2dArray::name() { return "Box2dArray"; }
41 template <> PYIMATH_EXPORT const char *PyImath::Box3sArray::name() { return "Box3sArray"; }
42 template <> PYIMATH_EXPORT const char *PyImath::Box3iArray::name() { return "Box3iArray"; }
43 template <> PYIMATH_EXPORT const char *PyImath::Box3i64Array::name() { return "Box3i64Array"; }
44 template <> PYIMATH_EXPORT const char *PyImath::Box3fArray::name() { return "Box3fArray"; }
45 template <> PYIMATH_EXPORT const char *PyImath::Box3dArray::name() { return "Box3dArray"; }
46
47 template <class T>
48 static Box<T> * box2TupleConstructor1(const tuple &t)
49 {
50 if(t.attr("__len__")() == 2)
51 {
52 // The constructor was called like this:
53 // Box2f ((V2f(1,2), V2f(3,4))) or
54 // Box2f (((1,2), (3,4)))
55
56 PyObject *t0Obj = extract <object> (t[0])().ptr();
57 PyObject *t1Obj = extract <object> (t[1])().ptr();
58 T t0, t1;
59 if (V2<typename T::BaseType>::convert (t0Obj, &t0) &&
60 V2<typename T::BaseType>::convert (t1Obj, &t1))
61 {
62 return new Box<T> (t0, t1);
63 }
64
65 // The constructor was called like this:
66 // Box2f ((1,2))
67
68 else
69 {
70 T point;
71 point.x = extract<double>(t[0]);
72 point.y = extract<double>(t[1]);
73 return new Box<T>(point);
74 }
75 }
76 else
77 throw std::invalid_argument ( "Invalid input to Box tuple constructor");
78 }
79
80 template <class T>
81 static Box<T> * box2TupleConstructor2(const tuple &t0, const tuple &t1)
82 {
83 if(t0.attr("__len__")() == 2 && t1.attr("__len__")() == 2)
84 {
85 T point0, point1;
86 point0.x = extract<double>(t0[0]); point0.y = extract<double>(t0[1]);
87 point1.x = extract<double>(t1[0]); point1.y = extract<double>(t1[1]);
88
89 return new Box<T>(point0, point1);
90 }
91 else
92 throw std::invalid_argument ("Invalid input to Box tuple constructor");
93 }
94
95 template <class T, class S>
96 static Box<T> *boxConstructor(const Box<S> &box)
97 {
98 Box<T> *newBox = new Box<T>;
99 newBox->min = box.min;
100 newBox->max = box.max;
101
102 return newBox;
103 }
104
105 template <class T>
106 static Box<T> * box3TupleConstructor1(const tuple &t)
107 {
108 if(t.attr("__len__")() == 3)
109 {
110 // The constructor was called like this:
111 // Box3f ((1,2,3))
112
113 T point;
114 point.x = extract<double>(t[0]);
115 point.y = extract<double>(t[1]);
116 point.z = extract<double>(t[2]);
117 return new Box<T>(point);
118 }
119
120 else if (t.attr("__len__")() == 2)
121 {
122 // The constructor was called like this:
123 // Box3f ((V3f(1,2,3), V3f(4,5,6))) or
124 // Box3f (((1,2,3), (4,5,6)))
125
126 PyObject *t0Obj = extract <object> (t[0])().ptr();
127 PyObject *t1Obj = extract <object> (t[1])().ptr();
128 T t0, t1;
129 if (V3<typename T::BaseType>::convert (t0Obj, &t0) &&
130 V3<typename T::BaseType>::convert (t1Obj, &t1))
131 {
132 return new Box<T> (t0, t1);
133 }
134 else
135 throw std::invalid_argument ("Invalid input to Box tuple constructor");
136 }
137
138 else
139 throw std::invalid_argument ("Invalid input to Box tuple constructor");
140 }
141
142 template <class T>
143 static Box<T> * box3TupleConstructor2(const tuple &t0, const tuple &t1)
144 {
145 if(t0.attr("__len__")() == 3 && t1.attr("__len__")() == 3)
146 {
147 T point0, point1;
148 point0.x = extract<double>(t0[0]);
149 point0.y = extract<double>(t0[1]);
150 point0.z = extract<double>(t0[2]);
151
152 point1.x = extract<double>(t1[0]);
153 point1.y = extract<double>(t1[1]);
154 point1.z = extract<double>(t1[2]);
155
156 return new Box<T>(point0, point1);
157 }
158 else
159 throw std::invalid_argument ("Invalid input to Box tuple constructor");
160 }
161
162 template <class T>
163 static std::string Box_repr(const Box<T> &box)
164 {
165 std::stringstream stream;
166 typename boost::python::return_by_value::apply <T>::type converter;
167
168 handle<> minObj (converter (box.min));
169 handle<> minH (PYUTIL_OBJECT_REPR (minObj.get()));
170 std::string minReprStr = extract<std::string> (minH.get());
171
172 handle<> maxObj (converter (box.max));
173 handle<> maxH (PYUTIL_OBJECT_REPR (maxObj.get()));
174 std::string maxReprStr = extract<std::string> (maxH.get());
175
176 stream << BoxName<T>::value << "(" << minReprStr << ", " << maxReprStr << ")";
177
178 return stream.str();
179 }
180
181 template <class T>
182 static void boxSetMin(IMATH_NAMESPACE::Box<T> &box, const T &m)
183 {
184 box.min = m;
185 }
186
187 template <class T>
188 static void boxSetMax(IMATH_NAMESPACE::Box<T> &box, const T &m)
189 {
190 box.max = m;
191 }
192
193 template <class T>
194 static T
195 boxMin(IMATH_NAMESPACE::Box<T> &box)
196 {
197 return box.min;
198 }
199
200 template <class T>
201 static T
202 boxMax(IMATH_NAMESPACE::Box<T> &box)
203 {
204 return box.max;
205 }
206
207 template <class T>
208 struct IntersectsTask : public Task
209 {
210 const IMATH_NAMESPACE::Box<T>& box;
211 const PyImath::FixedArray<T>& points;
212 PyImath::FixedArray<int>& results;
213
214 IntersectsTask(IMATH_NAMESPACE::Box<T>& b, const PyImath::FixedArray<T> &p, PyImath::FixedArray<int> &r)
215 : box(b), points(p), results(r) {}
216
217 void execute(size_t start, size_t end)
218 {
219 for(size_t p = start; p < end; ++p)
220 results[p] = box.intersects(points[p]);
221 }
222 };
223
224 template <class T>
225 struct ExtendByTask : public Task
226 {
227 std::vector<IMATH_NAMESPACE::Box<T> >& boxes;
228 const PyImath::FixedArray<T>& points;
229
230 ExtendByTask(std::vector<IMATH_NAMESPACE::Box<T> >& b, const PyImath::FixedArray<T> &p)
231 : boxes(b), points(p) {}
232
233 void execute(size_t start, size_t end, int tid)
234 {
235 for(size_t p = start; p < end; ++p)
236 boxes[tid].extendBy(points[p]);
237 }
238 void execute(size_t start, size_t end)
239 {
240 throw std::invalid_argument ("Box::ExtendBy execute requires a thread id");
241 }
242 };
243
244 template <class T>
245 static void
246 box_extendBy(IMATH_NAMESPACE::Box<T> &box, const PyImath::FixedArray<T> &points)
247 {
248 size_t numBoxes = workers();
249 std::vector<IMATH_NAMESPACE::Box<T> > boxes(numBoxes);
250 ExtendByTask<T> task(boxes,points);
251 dispatchTask(task,points.len());
252 for (size_t i=0; i<numBoxes; ++i) {
253 box.extendBy(boxes[i]);
254 }
255 }
256
257 template <class T>
258 PyImath::FixedArray<int>
259 box_intersects(IMATH_NAMESPACE::Box<T>& box, const PyImath::FixedArray<T>& points)
260 {
261 size_t numPoints = points.len();
262 PyImath::FixedArray<int> mask(numPoints);
263
264 IntersectsTask<T> task(box,points,mask);
265 dispatchTask(task,numPoints);
266 return mask;
267 }
268
269 template <class T>
270 class_<IMATH_NAMESPACE::Box<T> >
271 register_Box2()
272 {
273 void (IMATH_NAMESPACE::Box<T>::*extendBy1)(const T&) = &IMATH_NAMESPACE::Box<T>::extendBy;
274 void (IMATH_NAMESPACE::Box<T>::*extendBy2)(const IMATH_NAMESPACE::Box<T>&) = &IMATH_NAMESPACE::Box<T>::extendBy;
275 bool (IMATH_NAMESPACE::Box<T>::*intersects1)(const T&) const = &IMATH_NAMESPACE::Box<T>::intersects;
276 bool (IMATH_NAMESPACE::Box<T>::*intersects2)(const IMATH_NAMESPACE::Box<T>&) const = &IMATH_NAMESPACE::Box<T>::intersects;
277 const char *name = BoxName<T>::value;
278 class_<Box<T> > box_class(name);
279 box_class
280 .def(init<>("Box() create empty box") )
281 .def(init<T>("Box(point)create box containing the given point") )
282 .def(init<T,T>("Box(point,point) create box continaing min and max") )
283 .def("__init__", make_constructor(box2TupleConstructor1<T>), "Box(point) where point is a python tuple")
284 .def("__init__", make_constructor(box2TupleConstructor2<T>), "Box(point,point) where point is a python tuple")
285 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V2f>))
286 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V2d>))
287 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V2i>))
288 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V2i64>))
289 .def_readwrite("min",&Box<T>::min)
290 .def_readwrite("max",&Box<T>::max)
291 .def("min", &boxMin<T>)
292 .def("max", &boxMax<T>)
293 .def(self == self) // NOSONAR - suppress SonarCloud bug report.
294 .def(self != self) // NOSONAR - suppress SonarCloud bug report.
295 .def("__repr__", &Box_repr<T>)
296 .def("makeEmpty",&Box<T>::makeEmpty,"makeEmpty() make the box empty")
297 .def("makeInfinite",&Box<T>::makeInfinite,"makeInfinite() make the box cover all space")
298 .def("extendBy",extendBy1,"extendBy(point) extend the box by a point")
299 .def("extendBy",box_extendBy<T>,"extendBy(array) extend the box the values in the array")
300 .def("extendBy",extendBy2,"extendBy(box) extend the box by a box")
301 .def("size",&Box<T>::size,"size() size of the box")
302 .def("center",&Box<T>::center,"center() center of the box")
303 .def("intersects",intersects1,"intersects(point) returns true if the box intersects the given point")
304 .def("intersects",intersects2,"intersects(box) returns true if the box intersects the given box")
305 .def("majorAxis",&Box<T>::majorAxis,"majorAxis() major axis of the box")
306 .def("isEmpty",&Box<T>::isEmpty,"isEmpty() returns true if the box is empty")
307 .def("isInfinite",&Box<T>::isInfinite,"isInfinite() returns true if the box covers all space")
308 .def("hasVolume",&Box<T>::hasVolume,"hasVolume() returns true if the box has volume")
309 .def("setMin",&boxSetMin<T>,"setMin() sets the min value of the box")
310 .def("setMax",&boxSetMax<T>,"setMax() sets the max value of the box")
311 ;
312 return box_class;
313 }
314
315 template <class T, class U>
316 static IMATH_NAMESPACE::Box<T>
317 mulM44 (const IMATH_NAMESPACE::Box<T> &b, const Matrix44<U> &m)
318 {
319 MATH_EXC_ON;
320 return IMATH_NAMESPACE::transform (b, m);
321 }
322
323 template <class T, class U>
324 static const IMATH_NAMESPACE::Box<T> &
325 imulM44 (IMATH_NAMESPACE::Box<T> &b, const Matrix44<U> &m)
326 {
327 MATH_EXC_ON;
328 b = IMATH_NAMESPACE::transform (b, m);
329 return b;
330 }
331
332 template <class T>
333 class_<IMATH_NAMESPACE::Box<T> >
334 register_Box3()
335 {
336 void (IMATH_NAMESPACE::Box<T>::*extendBy1)(const T&) = &IMATH_NAMESPACE::Box<T>::extendBy;
337 void (IMATH_NAMESPACE::Box<T>::*extendBy2)(const IMATH_NAMESPACE::Box<T>&) = &IMATH_NAMESPACE::Box<T>::extendBy;
338 bool (IMATH_NAMESPACE::Box<T>::*intersects1)(const T&) const = &IMATH_NAMESPACE::Box<T>::intersects;
339 bool (IMATH_NAMESPACE::Box<T>::*intersects2)(const IMATH_NAMESPACE::Box<T>&) const = &IMATH_NAMESPACE::Box<T>::intersects;
340 const char *name = BoxName<T>::value;
341 class_<Box<T> > box_class(name);
342 box_class
343 .def(init<>("Box() create empty box") )
344 .def(init<T>("Box(point)create box containing the given point") )
345 .def(init<T,T>("Box(point,point) create box continaing min and max") )
346 .def("__init__", make_constructor(box3TupleConstructor1<T>), "Box(point) where point is a python tuple")
347 .def("__init__", make_constructor(box3TupleConstructor2<T>), "Box(point,point) where point is a python tuple")
348 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V3f>))
349 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V3d>))
350 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V3i>))
351 .def("__init__", make_constructor(boxConstructor<T, IMATH_NAMESPACE::V3i64>))
352 .def_readwrite("min",&Box<T>::min)
353 .def_readwrite("max",&Box<T>::max)
354 .def(self == self) // NOSONAR - suppress SonarCloud bug report.
355 .def(self != self) // NOSONAR - suppress SonarCloud bug report.
356 .def("__mul__", &mulM44<T, float>)
357 .def("__mul__", &mulM44<T, double>)
358 .def("__imul__", &imulM44<T, float>,return_internal_reference<>())
359 .def("__imul__", &imulM44<T, double>,return_internal_reference<>())
360 .def("min", &boxMin<T>)
361 .def("max", &boxMax<T>)
362 .def("__repr__", &Box_repr<T>)
363 .def("makeEmpty",&Box<T>::makeEmpty,"makeEmpty() make the box empty")
364 .def("makeInfinite",&Box<T>::makeInfinite,"makeInfinite() make the box cover all space")
365 .def("extendBy",extendBy1,"extendBy(point) extend the box by a point")
366 .def("extendBy",box_extendBy<T>,"extendBy(array) extend the box the values in the array")
367 .def("extendBy",extendBy2,"extendBy(box) extend the box by a box")
368 .def("size",&Box<T>::size,"size() size of the box")
369 .def("center",&Box<T>::center,"center() center of the box")
370 .def("intersects",intersects1,"intersects(point) returns true if the box intersects the given point")
371 .def("intersects",intersects2,"intersects(box) returns true if the box intersects the given box")
372 .def("intersects",box_intersects<T>, "intersects(array) returns an int array where 0 indicates the point is not in the box and 1 indicates that it is")
373 .def("majorAxis",&Box<T>::majorAxis,"majorAxis() major axis of the box")
374 .def("isEmpty",&Box<T>::isEmpty,"isEmpty() returns true if the box is empty")
375 .def("isInfinite",&Box<T>::isInfinite,"isInfinite() returns true if the box covers all space")
376 .def("hasVolume",&Box<T>::hasVolume,"hasVolume() returns true if the box has volume")
377 .def("setMin",&boxSetMin<T>,"setMin() sets the min value of the box")
378 .def("setMax",&boxSetMax<T>,"setMax() sets the max value of the box")
379 ;
380
381 decoratecopy(box_class);
382
383 return box_class;
384 }
385
386
387 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V2s> > register_Box2<IMATH_NAMESPACE::V2s>();
388 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V2i> > register_Box2<IMATH_NAMESPACE::V2i>();
389 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V2i64> > register_Box2<IMATH_NAMESPACE::V2i64>();
390 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V2f> > register_Box2<IMATH_NAMESPACE::V2f>();
391 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V2d> > register_Box2<IMATH_NAMESPACE::V2d>();
392 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V3s> > register_Box3<IMATH_NAMESPACE::V3s>();
393 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V3i> > register_Box3<IMATH_NAMESPACE::V3i>();
394 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V3i64> > register_Box3<IMATH_NAMESPACE::V3i64>();
395 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V3f> > register_Box3<IMATH_NAMESPACE::V3f>();
396 template PYIMATH_EXPORT class_<IMATH_NAMESPACE::Box<IMATH_NAMESPACE::V3d> > register_Box3<IMATH_NAMESPACE::V3d>();
397
398 }