Added python bindings for Box2 and Box3 classes (#495)

* Added python bindings for Box2 and Box3 classes

Signed-off-by: azmine-1 <[email protected]>

* fixed box setMin/setMax bindings to use direct member access

* Resolve issues with Box classes

Signed-off-by: Cary Phillips <[email protected]>

---------

Signed-off-by: azmine-1 <[email protected]>
Signed-off-by: Cary Phillips <[email protected]>
Co-authored-by: azmine-1 <[email protected]>

Author: cary-ilm

src/pybind11/PyBindImath/PyBindImathBox.cpp

@@ -4,61 +4,113 @@
 //
 
 #include "PyBindImath.h"
+#include "PyBindImathVec.h"
 #include <ImathBox.h>
+#include <ImathBoxAlgo.h>
+#include <ImathMatrix.h>
+
+namespace py = pybind11;
 
 namespace {
 
-template <class T, class V>
-void register_box(pybind11::class_<T>& c)
+template <class Box, class Vec>
+py::class_<Box>
+register_box(const char* name, py::class_<Box>& c)
 {
-    c.def(pybind11::init<>())
-    .def(pybind11::init<const V &>())
-    .def(pybind11::init<const V &, const V &>())
-    .def(pybind11::self == pybind11::self)
-    .def(pybind11::self != pybind11::self)
-    .def("makeEmpty", &T::makeEmpty, "makeEmpty() make the box empty")
-    .def("makeInfinite", &T::makeInfinite, "makeInfinite() make the box cover all space")
-    .def_readwrite("min", &T::min)
-    .def_readwrite("max", &T::max)
-    .def("extendBy", pybind11::overload_cast<const T &>(&T::extendBy), "extendBy(point) extend the box by a box")
-    .def("extendBy", pybind11::overload_cast<const V &>(&T::extendBy), "extendBy(point) extend the box by a point")
-    .def("size", &T::size, "size() size of the box")
-    .def("center", &T::center, "center() center of the box")
-    .def("intersects",pybind11::overload_cast<const V &>(&T::extendBy), "intersects(point) returns true if the box intersects the given point")
-    .def("intersects",pybind11::overload_cast<const T &>(&T::extendBy), "intersects(box) returns true if the box intersects the given box")
-    .def("majorAxis",&T::majorAxis, "majorAxis() major axis of the box")
-    .def("isEmpty",&T::isEmpty, "isEmpty() returns true if the box is empty")
-    .def("isInfinite",&T::isInfinite, "isInfinite() returns true if the box covers all space")
-    .def("hasVolume",&T::hasVolume, "hasVolume() returns true if the box has volume")
-        ;
+    c
+        .def(py::init<>())
+        .def(py::init<const Vec &>())
+        .def(py::init<const Vec &, const Vec &>())
+        .def(py::init<const Box &>())  // Copy constructor
+        .def(py::init([](py::tuple t)
+            {
+                if (t.size() != 2)
+                    throw std::runtime_error("Box constructor requires two arguments");
+                return Box(vecFromObject<Vec>(t[0]), vecFromObject<Vec>(t[1]));
+            }))
+        .def("__repr__", [name](const Box& b) {
+            py::object min_obj = py::cast(b.min);
+            py::object max_obj = py::cast(b.max);
+            return py::str("{}({}, {})").format(name, py::repr(min_obj), py::repr(max_obj));
+        })
+        .def(py::self == py::self)
+        .def(py::self != py::self)
+        .def("makeEmpty", &Box::makeEmpty, "makeEmpty() make the box empty")
+        .def("makeInfinite", &Box::makeInfinite, "makeInfinite() make the box cover all space")
+        .def("min", [](const Box& self) { return self.min; }, "min() returns the minimum point of the box")
+        .def("max", [](const Box& self) { return self.max; }, "max() returns the maximum point of the box")
+        .def("setMin", [](Box& self, const Vec& v) { self.min = v; }, "setMin(point) sets the minimum point of the box")
+        .def("setMax", [](Box& self, const Vec& v) { self.max = v; }, "setMax(point) sets the maximum point of the box")
+        .def("size", &Box::size, "size() size of the box")
+        .def("center", &Box::center, "center() center of the box")
+        .def("extendBy", py::overload_cast<const Box &>(&Box::extendBy), "extendBy(box) extend the box by a box")
+        .def("extendBy", py::overload_cast<const Vec &>(&Box::extendBy), "extendBy(point) extend the box by a point")
+        .def("intersects", py::overload_cast<const Vec &>(&Box::intersects, py::const_), "intersects(point) returns true if the box intersects the given point")
+        .def("intersects", py::overload_cast<const Box &>(&Box::intersects, py::const_), "intersects(box) returns true if the box intersects the given box")
+        .def("majorAxis", &Box::majorAxis, "majorAxis() major axis of the box")
+        .def("isEmpty", &Box::isEmpty, "isEmpty() returns true if the box is empty")
+        .def("isInfinite", &Box::isInfinite, "isInfinite() returns true if the box covers all space")
+        .def("hasVolume", &Box::hasVolume, "hasVolume() returns true if the box has volume");
+
+    return c;
+}
+
 
+template <class Box, class Matrix>
+py::class_<Box>
+register_box_mul(py::class_<Box>& c)
+{ 
+    auto ri = py::return_value_policy::reference_internal;
+
+    c.def("__mul__", [](const Box& self, const Matrix& M) { return IMATH_NAMESPACE::transform(self, M); });
+    c.def("__imul__", [](Box& self, const Matrix& M) -> const Box& { self = IMATH_NAMESPACE::transform(self, M); return self; }, ri);
+    return c;
 }
 
-template <class T, class V>
-void register_box2(pybind11::module& m, const char * name)
+template <class Box, class Vec>
+py::class_<Box>
+register_box2(py::module& m, const char * name)
 {
-    pybind11::class_<T> c(m, name);
-    register_box<T, V>(c);
+    py::class_<Box> c(m, name);
+    return register_box<Box, Vec>(name, c);
 }
 
-template <class T, class V>
-void register_box3(pybind11::module& m, const char * name)
+template <class Box, class Vec>
+py::class_<Box>
+register_box3(py::module& m, const char * name)
 {
-    pybind11::class_<T> c(m, name);
-    register_box<T, V>(c);
+    py::class_<Box> c(m, name);
+    return register_box<Box, Vec>(name, c);
 }
 
 } // namespace
 
 namespace PyBindImath {
 
-void register_imath_box(pybind11::module& m)
+void register_imath_box(py::module& m)
 {
-    register_box2<IMATH_NAMESPACE::Box2d, IMATH_NAMESPACE::V2d>(m, "Box2d");
+    // Register 2D boxes
+    register_box2<IMATH_NAMESPACE::Box2i, IMATH_NAMESPACE::V2i>(m, "Box2i");
+    register_box2<IMATH_NAMESPACE::Box2i64, IMATH_NAMESPACE::V2i64>(m, "Box2i64");
     register_box2<IMATH_NAMESPACE::Box2f, IMATH_NAMESPACE::V2f>(m, "Box2f");
+    register_box2<IMATH_NAMESPACE::Box2d, IMATH_NAMESPACE::V2d>(m, "Box2d");
+
+    // Register 3D boxes
+    auto box3i = register_box3<IMATH_NAMESPACE::Box3i, IMATH_NAMESPACE::V3i>(m, "Box3i");
+    register_box_mul<IMATH_NAMESPACE::Box3i,IMATH_NAMESPACE::M44f>(box3i);
+    register_box_mul<IMATH_NAMESPACE::Box3i,IMATH_NAMESPACE::M44d>(box3i);
+  
+    auto box3i64 = register_box3<IMATH_NAMESPACE::Box3i64, IMATH_NAMESPACE::V3i64>(m, "Box3i64");
+    register_box_mul<IMATH_NAMESPACE::Box3i64,IMATH_NAMESPACE::M44f>(box3i64);
+    register_box_mul<IMATH_NAMESPACE::Box3i64,IMATH_NAMESPACE::M44d>(box3i64);
 
-    register_box3<IMATH_NAMESPACE::Box3d, IMATH_NAMESPACE::V3d>(m, "Box3d");
-    register_box3<IMATH_NAMESPACE::Box3f, IMATH_NAMESPACE::V3f>(m, "Box3f");
+    auto box3f = register_box3<IMATH_NAMESPACE::Box3f, IMATH_NAMESPACE::V3f>(m, "Box3f");
+    register_box_mul<IMATH_NAMESPACE::Box3f,IMATH_NAMESPACE::M44f>(box3f);
+    register_box_mul<IMATH_NAMESPACE::Box3f,IMATH_NAMESPACE::M44d>(box3f);
+    
+    auto box3d = register_box3<IMATH_NAMESPACE::Box3d, IMATH_NAMESPACE::V3d>(m, "Box3d");
+    register_box_mul<IMATH_NAMESPACE::Box3d,IMATH_NAMESPACE::M44f>(box3d);
+    register_box_mul<IMATH_NAMESPACE::Box3d,IMATH_NAMESPACE::M44d>(box3d);
 }
 
 } // namespace PyBindImath

src/pybind11/PyBindImathTest/pyBindImathTest.py

@@ -6758,6 +6758,7 @@ def testBox2x (Box, Vec):
     # repr
 
     b = Box (Vec (1/9., 2/9.), Vec (4/9., 5/9.))
+    print(f"repr: {repr(b)}")
     assert b == eval (repr (b))
 
     print ("ok")
@@ -6776,7 +6777,7 @@ def testBox2():
     testBox2x (Box2d, V2d)
 
 
-#testList.append (('testBox2',testBox2))
+testList.append (('testBox2',testBox2))
 
 
 # -------------------------------------------------------------------------
@@ -6852,7 +6853,7 @@ def testBox3x (Box, Vec):
     b = Box (Vec (1, 1, 1), Vec (2, 2, 2))
 
     mf = M44f ()
-    mf.setTranslation (Vec (10, 11, 12))
+    mf.setTranslation (V3f (10, 11, 12))
 
     b2 = b * mf
     assert b2.min() == Vec (11, 12, 13)
@@ -6865,7 +6866,7 @@ def testBox3x (Box, Vec):
     b = Box (Vec (1, 1, 1), Vec (2, 2, 2))
 
     md = M44d ()
-    md.setTranslation (Vec (10, 11, 12))
+    md.setTranslation (V3d (10, 11, 12))
 
     b2 = b * md
     assert b2.min() == Vec (11, 12, 13)
@@ -6891,7 +6892,7 @@ def testBox3():
     testBox3x (Box3d, V3d)
 
 
-#testList.append (('testBox3',testBox3))
+testList.append (('testBox3',testBox3))
 
 
 # -------------------------------------------------------------------------
@@ -9051,7 +9052,6 @@ def checkSVD33(m):
     scaleMatrix = M33d (-3, 0, 0, 0, 2, 0, 0, 0, 3)
     m = m * e.toMatrix33()
     checkSVD33(m)
-
 #testList.append (('testSVD',testSVD))
 
 def testSymmetricEigensolve():
@@ -10801,3 +10801,4 @@ def testColor4Array2D():
 # Local Variables:
 # mode:python
 # End:
+