amulet-core 2.0.7a0__cp312-cp312-macosx_10_15_universal2.whl

amulet/core/selection/box_group.pyi

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import collections.abc
+import types
+import typing
+
+import amulet.core.selection.box
+import amulet.core.selection.shape_group
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionBoxGroup"]
+
+class SelectionBoxGroup:
+    """
+    A container for zero or more :class:`SelectionBox` instances.
+
+    This allows for non-rectangular and non-contiguous selections.
+    """
+
+    __hash__: typing.ClassVar[None] = None  # type: ignore
+    def __bool__(self) -> bool:
+        """
+        Are there any selections in the group.
+        """
+
+    @typing.overload
+    def __eq__(self, other: SelectionBoxGroup) -> bool:
+        """
+        Does the contents of this :class:`SelectionBoxGroup` match the other :class:`SelectionBoxGroup`.
+
+        Note if the boxes do not exactly match this will return False even if the volume represented is the same.
+
+        :param other: The other :class:`SelectionBoxGroup` to compare with.
+        :return: True if the boxes contained match.
+        """
+
+    @typing.overload
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
+    @typing.overload
+    def __init__(self) -> None:
+        """
+        Create an empty SelectionBoxGroup.
+
+        >>> SelectionBoxGroup()
+        """
+
+    @typing.overload
+    def __init__(
+        self, shape_group: amulet.core.selection.shape_group.SelectionShapeGroup
+    ) -> None: ...
+    @typing.overload
+    def __init__(
+        self, boxes: collections.abc.Iterable[amulet.core.selection.box.SelectionBox]
+    ) -> None:
+        """
+        Create a SelectionBoxGroup from the boxes in the iterable.
+
+        >>> SelectionBoxGroup([
+        >>>     SelectionBox(0, 0, 0, 1, 1, 1),
+        >>>     SelectionBox(1, 1, 1, 1, 1, 1)
+        >>> ])
+        """
+
+    def __iter__(
+        self,
+    ) -> collections.abc.Iterator[amulet.core.selection.box.SelectionBox]:
+        """
+        An iterable of all the :class:`SelectionBox` classes in the group.
+        """
+
+    def __len__(self) -> int:
+        """
+        The number of :class:`SelectionBox` classes in the group.
+        """
+
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def contains_block(
+        self, x: typing.SupportsInt, y: typing.SupportsInt, z: typing.SupportsInt
+    ) -> bool:
+        """
+        Is the block contained within the selection.
+
+        >>> selection1: AbstractBaseSelection
+        >>> (1, 2, 3) in selection1
+        True
+
+        :param x: The x coordinate of the block. Defined by the most negative corner.
+        :param y: The y coordinate of the block. Defined by the most negative corner.
+        :param z: The z coordinate of the block. Defined by the most negative corner.
+        :return: True if the block is in the selection.
+        """
+
+    def contains_point(
+        self, x: typing.SupportsFloat, y: typing.SupportsFloat, z: typing.SupportsFloat
+    ) -> bool:
+        """
+        Is the point contained within the selection.
+
+        >>> selection1: AbstractBaseSelection
+        >>> (1.5, 2.5, 3.5) in selection1
+        True
+
+        :param x: The x coordinate of the point.
+        :param y: The y coordinate of the point.
+        :param z: The z coordinate of the point.
+        :return: True if the point is in the selection.
+        """
+
+    @typing.overload
+    def intersects(self, other: amulet.core.selection.box.SelectionBox) -> bool:
+        """
+        Does this selection intersect ``other``.
+
+        :param other: The other selection.
+        :return: True if the selections intersect, False otherwise.
+        """
+
+    @typing.overload
+    def intersects(self, other: SelectionBoxGroup) -> bool: ...
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionBoxGroup:
+        """
+        Transform the boxes in this group by the given transformation matrix.
+        """
+
+    def translate(
+        self, dx: typing.SupportsInt, dy: typing.SupportsInt, dz: typing.SupportsInt
+    ) -> SelectionBoxGroup:
+        """
+        Create a new :class:`SelectionBoxGroup` based on this one with the coordinates moved by the given offset.
+
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: The z offset.
+        :return: The new selection with the given offset.
+        """
+
+    @property
+    def bounding_box(self) -> amulet.core.selection.box.SelectionBox:
+        """
+        A SelectionBox containing this entire selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def bounds(self) -> tuple[tuple[int, int, int], tuple[int, int, int]]:
+        """
+        The minimum and maximum x, y and z coordinates in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def boxes(self) -> collections.abc.Iterator[amulet.core.selection.box.SelectionBox]:
+        """
+        An iterator of the :class:`SelectionBox` instances stored for this group.
+        """
+
+    @property
+    def max(self) -> tuple[int, int, int]:
+        """
+        The maximum x, y and z coordinates in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max_x(self) -> int:
+        """
+        The maximum x coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max_y(self) -> int:
+        """
+        The maximum y coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def max_z(self) -> int:
+        """
+        The maximum z coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min(self) -> tuple[int, int, int]:
+        """
+        The minimum x, y and z coordinates in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min_x(self) -> int:
+        """
+        The minimum x coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min_y(self) -> int:
+        """
+        The minimum y coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """
+
+    @property
+    def min_z(self) -> int:
+        """
+        The minimum z coordinate in the selection.
+
+        :raises RuntimeError: If there are no boxes in the selection.
+        """

amulet/core/selection/cuboid.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <amulet/core/dll.hpp>
+
+#include "shape.hpp"
+
+namespace Amulet {
+
+class AMULET_CORE_EXPORT SelectionCuboid : public SelectionShape {
+public:
+    SelectionCuboid();
+    SelectionCuboid(const Matrix4x4&);
+
+    SelectionCuboid(
+        double min_x,
+        double min_y,
+        double min_z,
+        double size_x,
+        double size_y,
+        double size_z
+    );
+
+    SelectionCuboid(const SelectionCuboid& other);
+
+    std::string serialise() const override;
+
+    std::unique_ptr<SelectionShape> copy() const override;
+    explicit operator std::set<SelectionBox>() const override;
+
+    // Transform
+    SelectionCuboid translate_cuboid(double dx, double dy, double dz) const;
+    SelectionCuboid transform_cuboid(const Matrix4x4&) const;
+    std::unique_ptr<SelectionShape> transform(const Matrix4x4&) const override;
+
+    bool almost_equal(const SelectionCuboid&) const;
+    bool almost_equal(const SelectionShape&) const override;
+    bool operator==(const SelectionCuboid&) const;
+    bool operator==(const SelectionShape&) const override;
+};
+
+} // namespace Amulet

amulet/core/selection/cuboid.pyi

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import typing
+
+import amulet.core.selection.shape
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionCuboid"]
+
+class SelectionCuboid(amulet.core.selection.shape.SelectionShape):
+    """
+    The SelectionCuboid class represents a single spherical selection.
+    """
+
+    @typing.overload
+    def __init__(
+        self,
+        min_x: typing.SupportsFloat,
+        min_y: typing.SupportsFloat,
+        min_z: typing.SupportsFloat,
+        size_x: typing.SupportsFloat,
+        size_y: typing.SupportsFloat,
+        size_z: typing.SupportsFloat,
+    ) -> None: ...
+    @typing.overload
+    def __init__(self, matrix: amulet.utils.matrix.Matrix4x4) -> None: ...
+    def __repr__(self) -> str: ...
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionCuboid:
+        """
+        Create a new :class:`SelectionCuboid` based on this one transformed by the given matrix.
+
+        :param matrix: The matrix to transform by.
+        :return: The new selection with the added transform.
+        """
+
+    def translate(
+        self,
+        dx: typing.SupportsFloat,
+        dy: typing.SupportsFloat,
+        dz: typing.SupportsFloat,
+    ) -> SelectionCuboid:
+        """
+        Create a new :class:`SelectionCuboid` based on this one with the coordinates moved by the given offset.
+
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: The z offset.
+        :return: The new selection with the given offset.
+        """

amulet/core/selection/ellipsoid.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include <cstdint>
+
+#include <amulet/core/dll.hpp>
+
+#include "shape.hpp"
+
+namespace Amulet {
+
+class SelectionBox;
+
+// The SelectionEllipsoid class represents a single spherical selection.
+class AMULET_CORE_EXPORT SelectionEllipsoid : public SelectionShape {
+public:
+    SelectionEllipsoid();
+    SelectionEllipsoid(const Matrix4x4&);
+
+    SelectionEllipsoid(
+        double x,
+        double y,
+        double z,
+        double radius);
+        
+    SelectionEllipsoid(const SelectionEllipsoid& other);
+
+    std::string serialise() const override;
+        
+    std::unique_ptr<SelectionShape> copy() const override;
+    explicit operator std::set<SelectionBox>() const override;
+
+    // Transform
+    SelectionEllipsoid translate_ellipsoid(double dx, double dy, double dz) const;
+    SelectionEllipsoid transform_ellipsoid(const Matrix4x4&) const;
+    std::unique_ptr<SelectionShape> transform(const Matrix4x4&) const override;
+
+    bool almost_equal(const SelectionEllipsoid&) const;
+    bool almost_equal(const SelectionShape&) const override;
+    bool operator==(const SelectionEllipsoid&) const;
+    bool operator==(const SelectionShape&) const override;
+};
+
+} // namespace Amulet

amulet/core/selection/ellipsoid.pyi

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import typing
+
+import amulet.core.selection.shape
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionEllipsoid"]
+
+class SelectionEllipsoid(amulet.core.selection.shape.SelectionShape):
+    """
+    The SelectionEllipsoid class represents a single ellipsoid selection.
+    """
+
+    @typing.overload
+    def __init__(
+        self,
+        x: typing.SupportsFloat,
+        y: typing.SupportsFloat,
+        z: typing.SupportsFloat,
+        radius: typing.SupportsFloat,
+    ) -> None: ...
+    @typing.overload
+    def __init__(self, matrix: amulet.utils.matrix.Matrix4x4) -> None: ...
+    def __repr__(self) -> str: ...
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionEllipsoid:
+        """
+        Create a new :class:`SelectionEllipsoid` based on this one transformed by the given matrix.
+
+        :param matrix: The matrix to transform by.
+        :return: The new selection with the added transform.
+        """
+
+    def translate(
+        self,
+        dx: typing.SupportsFloat,
+        dy: typing.SupportsFloat,
+        dz: typing.SupportsFloat,
+    ) -> SelectionEllipsoid:
+        """
+        Create a new :class:`SelectionEllipsoid` based on this one with the coordinates moved by the given offset.
+
+        :param dx: The x offset.
+        :param dy: The y offset.
+        :param dz: The z offset.
+        :return: The new selection with the given offset.
+        """

amulet/core/selection/shape.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <string_view>
+#include <utility>
+
+#include <amulet/utils/matrix.hpp>
+
+#include <amulet/core/dll.hpp>
+
+namespace Amulet {
+
+class SelectionBox;
+class SelectionBoxGroup;
+
+class AMULET_CORE_EXPORT SelectionShape {
+private:
+    Matrix4x4 _matrix;
+
+public:
+    SelectionShape() = default;
+    SelectionShape(const Matrix4x4& matrix)
+        : _matrix(matrix)
+    {
+    }
+    virtual ~SelectionShape() = default;
+
+    const Matrix4x4& get_matrix() const;
+    void set_matrix(const Matrix4x4&);
+
+    // Convert the class to human readable plain text.
+    virtual std::string serialise() const = 0;
+
+    // Deserialise the serialised data back to an object.
+    static std::unique_ptr<SelectionShape> deserialise(std::string_view, size_t&);
+    static std::unique_ptr<SelectionShape> deserialise(std::string_view);
+
+    using Deserialiser = std::function<
+        std::unique_ptr<SelectionShape>(std::string_view, size_t&)>;
+
+    static bool register_deserialiser(Deserialiser);
+
+    // Create a copy of the class.
+    virtual std::unique_ptr<SelectionShape> copy() const = 0;
+
+    explicit operator std::unique_ptr<SelectionShape>() const
+    {
+        return copy();
+    }
+
+    // Convert the shape into unit voxels.
+    virtual explicit operator std::set<SelectionBox>() const = 0;
+    explicit operator SelectionBoxGroup() const;
+    SelectionBoxGroup voxelise() const;
+
+    // translate and transform
+    virtual std::unique_ptr<SelectionShape> transform(const Matrix4x4&) const = 0;
+    std::unique_ptr<SelectionShape> translate(double dx, double dy, double dz) const
+    {
+        return transform(Matrix4x4::translation_matrix(dx, dy, dz));
+    }
+
+    // Equality
+    virtual bool almost_equal(const SelectionShape&) const = 0;
+    virtual bool operator==(const SelectionShape&) const = 0;
+};
+
+} // namespace Amulet

amulet/core/selection/shape.pyi

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import types
+import typing
+
+import amulet.core.selection.box_group
+import amulet.utils.matrix
+
+__all__: list[str] = ["SelectionShape"]
+
+class SelectionShape:
+    """
+    A base class for selection classes.
+    """
+
+    __hash__: typing.ClassVar[None] = None  # type: ignore
+    matrix: amulet.utils.matrix.Matrix4x4
+    @staticmethod
+    def deserialise(s: str) -> SelectionShape:
+        """
+        Deserialise the serialised data back to an object.
+        """
+
+    @typing.overload
+    def __eq__(self, other: SelectionShape) -> bool: ...
+    @typing.overload
+    def __eq__(self, other: typing.Any) -> bool | types.NotImplementedType: ...
+    def almost_equal(self, other: SelectionShape) -> bool:
+        """
+        Check if this shape is equal or almost equal to another shape.
+        """
+
+    def serialise(self) -> str:
+        """
+        Convert the class to human readable plain text.
+        """
+
+    def transform(self, matrix: amulet.utils.matrix.Matrix4x4) -> SelectionShape:
+        """
+        Translate the shape by the given matrix
+        """
+
+    def translate(
+        self,
+        dx: typing.SupportsFloat,
+        dy: typing.SupportsFloat,
+        dz: typing.SupportsFloat,
+    ) -> SelectionShape:
+        """
+        Translate the shape by the given amount
+        """
+
+    def voxelise(self) -> amulet.core.selection.box_group.SelectionBoxGroup:
+        """
+        Convert the selection to a SelectionBoxGroup.
+        """

amulet/core/selection/shape_group.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <amulet/core/dll.hpp>
+
+#include "shape.hpp"
+
+namespace Amulet {
+
+class SelectionBox;
+class SelectionBoxGroup;
+
+class AMULET_CORE_EXPORT SelectionShapeGroup {
+private:
+    std::vector<std::shared_ptr<SelectionShape>> _shapes;
+
+public:
+    SelectionShapeGroup();
+    SelectionShapeGroup(std::vector<std::shared_ptr<SelectionShape>> shapes);
+
+    SelectionShapeGroup(const SelectionShapeGroup&);
+    SelectionShapeGroup& operator=(const SelectionShapeGroup&);
+
+    SelectionShapeGroup(SelectionShapeGroup&&);
+    SelectionShapeGroup& operator=(SelectionShapeGroup&&);
+
+    SelectionShapeGroup deep_copy() const;
+
+    std::string serialise() const;
+    static SelectionShapeGroup deserialise(std::string_view);
+
+    const std::vector<std::shared_ptr<SelectionShape>>& get_shapes() const
+    {
+        return _shapes;
+    }
+    std::vector<std::shared_ptr<SelectionShape>>& get_shapes()
+    {
+        return _shapes;
+    }
+    void set_shapes(std::vector<std::shared_ptr<SelectionShape>> shapes)
+    {
+        _shapes = std::move(shapes);
+    }
+    std::vector<std::shared_ptr<SelectionShape>>::const_iterator begin() const
+    {
+        return _shapes.begin();
+    }
+    std::vector<std::shared_ptr<SelectionShape>>::const_iterator end() const
+    {
+        return _shapes.end();
+    }
+    operator bool() const
+    {
+        return !_shapes.empty();
+    }
+    size_t count() const
+    {
+        return _shapes.size();
+    }
+
+    explicit operator SelectionBoxGroup() const;
+    explicit operator std::set<SelectionBox>() const;
+    SelectionBoxGroup voxelise() const;
+
+    bool almost_equal(const SelectionShapeGroup&) const;
+    bool operator==(const SelectionShapeGroup&) const;
+};
+
+}