math3d-py 1.3.4__tar.gz → 1.4.1__tar.gz

{math3d_py-1.3.4 → math3d_py-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: math3d_py
-Version: 1.3.4
+Version: 1.4.1
 Summary: Python bindings for 3dmath
 Author-Email: Murali Dhanakoti <dhanakoti.murali@gmail.com>
 Requires-Python: <3.14,>=3.13

{math3d_py-1.3.4 → math3d_py-1.4.1}/include/3dmath/SupportingTypes.h

@@ -153,6 +153,62 @@ namespace math3d {
         Vector3<T> max() const {
             return {x.max, y.max, z.max};
         }
+
+        /// @brief Gets the corner vertices of this bounding box
+        ///
+        /// The corners are returned lower back to front with the bottom corners appearing before the top ones
+        [[nodiscard]]
+        std::array<Vector3<T>, 8> corners() const {
+            using Vec3 = Vector3<T>;
+
+            auto lower_left_back = min();
+            auto lower_right_back = lower_left_back + Vec3{x.length(), 0, 0};
+            auto upper_right_back= lower_right_back + Vec3{0, y.length(), 0};
+            auto upper_left_back = upper_right_back - Vec3{x.length(), 0, 0};
+
+            auto upper_right_front = max();
+            auto upper_left_front = upper_right_front - Vec3{x.length(), 0, 0};
+            auto lower_left_front  = upper_left_front - Vec3{0, y.length(), 0};
+            auto lower_right_front = lower_left_front + Vec3{x.length(), 0, 0};
+
+            return {lower_left_back, lower_right_back, upper_right_back, upper_left_back,
+                    lower_left_front, lower_right_front, upper_right_front, upper_left_front};
+        }
+
+        /// @brief Gets vertex indices of the quadrilateral faces of this bounding box
+        ///
+        /// Edges are returned in the following face order: front, right, back, left, bottom, and top
+        [[nodiscard]]
+        static constexpr std::array<std::array<uint8_t , 4>, 6> edges() {
+
+            using Face = std::array<uint8_t, 4>;
+
+            return {
+                    Face{4, 5, 6, 7},
+                    Face{5, 1, 2, 6},
+                    Face{0, 1, 2, 3},
+                    Face{0, 4, 7, 3},
+                    Face{0, 1, 5, 4},
+                    Face{6, 2, 3, 7}
+                };
+        }
+
+        [[nodiscard]]
+        Extent<T> extent(Direction dir) const {
+            if (dir == Direction::x) {
+                return x;
+            }
+            if (dir == Direction::y) {
+                return y;
+            }
+            if (dir == Direction::z) {
+                return z;
+            }
+            throw std::runtime_error(
+                std::format("Direction {} is not supported in the extent accessor",
+                            std::underlying_type_t<Direction>(dir))
+            );
+        }
     };
 
     template<typename T>

{math3d_py-1.3.4 → math3d_py-1.4.1}/py/math3d/math3d.pyi

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import pybind11_stubgen.typing_ext
 import typing
 __all__: list[str] = ['AABB', 'Extent', 'Identity2', 'Identity3', 'Identity4', 'LinearSystem2', 'LinearSystem3', 'LinearSystem4', 'Matrix2', 'Matrix3', 'Matrix4', 'Vector2', 'Vector3', 'Vector4', 'col_major', 'order', 'row_major']
 class AABB:
@@ -8,12 +9,29 @@ class AABB:
     @typing.overload
     def __init__(self, arg0: Extent, arg1: Extent, arg2: Extent) -> None:
         ...
+    @typing.overload
+    def __init__(self, arg0: Vector3, arg1: Vector3) -> None:
+        ...
     def __repr__(self) -> str:
         ...
     def __str__(self) -> str:
         ...
+    def corners(self) -> typing.Annotated[list[Vector3], pybind11_stubgen.typing_ext.FixedSize(8)]:
+        ...
+    def edges(self) -> typing.Annotated[list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(4)]], pybind11_stubgen.typing_ext.FixedSize(6)]:
+        ...
+    def max(self) -> Vector3:
+        ...
     def merge(self, arg0: AABB) -> None:
         ...
+    def min(self) -> Vector3:
+        ...
+    def x_extent(self) -> Extent:
+        ...
+    def y_extent(self) -> Extent:
+        ...
+    def z_extent(self) -> Extent:
+        ...
 class Extent:
     max: float
     min: float
@@ -168,6 +186,8 @@ class Vector2:
         ...
     def __repr__(self) -> str:
         ...
+    def __rmul__(self, arg0: float) -> Vector2:
+        ...
     def __str__(self) -> str:
         ...
     def __sub__(self, arg0: Vector2) -> Vector2:
@@ -207,6 +227,8 @@ class Vector3:
         ...
     def __repr__(self) -> str:
         ...
+    def __rmul__(self, arg0: float) -> Vector3:
+        ...
     def __str__(self) -> str:
         ...
     def __sub__(self, arg0: Vector3) -> Vector3:
@@ -246,6 +268,8 @@ class Vector4:
         ...
     def __repr__(self) -> str:
         ...
+    def __rmul__(self, arg0: float) -> Vector4:
+        ...
     def __str__(self) -> str:
         ...
     def __sub__(self, arg0: Vector4) -> Vector4:

{math3d_py-1.3.4 → math3d_py-1.4.1}/py/math3d/types.hpp

@@ -65,9 +65,33 @@ void bind_Bounds(py::module_ const& module, std::string_view className) {
     .def(py::init([](m3d::Extent<T> const& x, m3d::Extent<T> const& y, m3d::Extent<T> const& z) {
         return Bounds {x, y, z};
     }))
+    .def(py::init([](m3d::Vector3<T> const& min, m3d::Vector3<T> const& max) {
+        return Bounds(m3d::Extent<T>{min.x, max.x}, m3d::Extent<T>{min.y, max.y}, m3d::Extent<T>{min.z, max.z});
+    }))
+    .def("min", [](Bounds const& self) {
+        return self.min();
+    })
+    .def("max", [](Bounds const& self) {
+        return self.max();
+    })
+    .def("corners", [](Bounds const& self) {
+        return self.corners();
+    })
+    .def("edges", [](Bounds const& self) {
+        return self.edges();
+    })
     .def("merge", [](Bounds& self, Bounds const& another) {
         self.merge(another);
     })
+    .def("x_extent", [](Bounds const& self) {
+        return self.extent(Bounds::Direction::x);
+    })
+    .def("y_extent", [](Bounds const& self) {
+        return self.extent(Bounds::Direction::y);
+    })
+    .def("z_extent", [](Bounds const& self) {
+        return self.extent(Bounds::Direction::z);
+    })
     .def("__str__", [](Bounds const& bounds) {
         return bounds.asString();
     })

{math3d_py-1.3.4/tmp → math3d_py-1.4.1/py}/math3d/vector.hpp

@@ -29,6 +29,7 @@ void bind_Vector(py::module_ const& module, char const* className) {
         .def(py::self + py::self)
         .def(py::self - py::self)
         .def(py::self * T{})
+        .def(T{} * py::self)
         .def(py::self / T{})
         .def("dot", &vector::dot)
         .def("normalize", [](vector& v) { v.normalize(); return v; })

{math3d_py-1.3.4 → math3d_py-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "math3d_py"
-version = "1.3.4"
+version = "1.4.1"
 description = "Python bindings for 3dmath"
 authors = [{ name = "Murali Dhanakoti", email = "dhanakoti.murali@gmail.com" }]
 requires-python = ">=3.13,<3.14"

{math3d_py-1.3.4 → math3d_py-1.4.1}/tests/Types.cpp

@@ -144,5 +144,13 @@ TEST(Bounds, Merging) {
     boundsA.merge(boundsB);
     ASSERT_NEAR((boundsA.min() - Vector3{-100, -10, -10}).lengthSquared(), 0, 1e-6);
     ASSERT_NEAR((boundsA.max() - Vector3{10, 200, 10}).lengthSquared(), 0, 1e-6);
+}
 
+TEST(Bounds, Corners) {
+    Bounds3D const bounds {{-10, -10, -10}, { 10,  10,  10}};
+    auto const corners = bounds.corners();
+    ASSERT_EQ((bounds.min() - corners.at(0)).lengthSquared(), 0);
+    ASSERT_EQ(((bounds.min() + Vector3{bounds.x.length(), bounds.y.length(), 0}) - corners.at(2)).lengthSquared(), 0);
+    ASSERT_EQ((bounds.max() - corners.at(6)).lengthSquared(), 0);
+    ASSERT_EQ(((bounds.max() - Vector3{bounds.x.length(), bounds.y.length(), 0}) - corners.at(4)).lengthSquared(), 0);
 }