polycubetools 1.1.0__tar.gz → 1.1.2__tar.gz

{polycubetools-1.1.0/src/polycubetools.egg-info → polycubetools-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polycubetools
-Version: 1.1.0
+Version: 1.1.2
 Summary: Basic framework for working with polycubes in a 3-dimensional grid.
 Author: Team Polycube
 Classifier: Development Status :: 3 - Alpha

{polycubetools-1.1.0 → polycubetools-1.1.2}/src/polycubetools/__init__.py

@@ -10,9 +10,10 @@ Basic framework for working with polycubes in a 3-dimensional grid.
 __author__ = "Team Polycube"
 __title__ = "polycubetools"
 __license__ = "MIT"
-__version__ = "1.1.0"
+__version__ = "1.1.2"
 
 from . import utils as utils
+from .errors import *
 from .grid import *
 from .hull import *
 from .models import *

polycubetools-1.1.2/src/polycubetools/errors.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+__all__ = (
+    "InvalidVolumeException",
+    "PolycubeException",
+)
+
+
+class PolycubeException(Exception):
+    """Base exception for all errors raised by this library."""
+
+    pass
+
+
+class InvalidVolumeException(PolycubeException):
+    """Exception raised when failing to compute a volume."""
+
+    pass

{polycubetools-1.1.0 → polycubetools-1.1.2}/src/polycubetools/hull.py

@@ -35,6 +35,11 @@ class AbstractHull(ABC):
         """Checks if the given coordinate is inside the hull."""
         pass
 
+    @abstractmethod
+    def inside_hull(self, pos: Coordinate) -> bool:
+        """Checks if the given coordinate is inside the hull or in its inner part."""
+        pass
+
     @abstractmethod
     def in_inner_part(self, pos: Coordinate) -> bool:
         """Checks if the given coordinate is inside the inner part of the hull."""
@@ -67,6 +72,9 @@ class CoordinateHull(AbstractHull):
     def in_hull(self, pos: Coordinate) -> bool:
         return pos in self.coords
 
+    def inside_hull(self, pos: Coordinate) -> bool:
+        return pos in self.coords or self.in_inner_part(pos)
+
     def in_inner_part(self, pos: Coordinate) -> bool:
         raise NotImplementedError(
             "Inner part is not defined for coordinate hulls (you can implement it in a subclass if needed)"
@@ -113,9 +121,56 @@ class CuboidHull(AbstractHull):
     def in_hull(self, pos: Coordinate) -> bool:
         minc, maxc = self.min_coord, self.max_coord
         px, py, pz = pos.x, pos.y, pos.z
-        return px == minc.x or px == maxc.x or py == minc.y or py == maxc.y or pz == minc.z or pz == maxc.z
+        return (
+            px == minc.x or px == maxc.x or py == minc.y or py == maxc.y or pz == minc.z or pz == maxc.z
+        ) and self.inside_hull(pos)
+
+    def inside_hull(self, pos: Coordinate) -> bool:
+        minc, maxc = self.min_coord, self.max_coord
+        px, py, pz = pos.x, pos.y, pos.z
+        return minc.x <= px <= maxc.x and minc.y <= py <= maxc.y and minc.z <= pz <= maxc.z
 
     def in_inner_part(self, pos: Coordinate) -> bool:
         minc, maxc = self.min_coord, self.max_coord
         px, py, pz = pos.x, pos.y, pos.z
         return minc.x < px < maxc.x and minc.y < py < maxc.y and minc.z < pz < maxc.z
+
+
+class CoordinateSetHull(AbstractHull):
+    def __init__(
+        self,
+        coords: frozenset[Coordinate],
+        inner_coords: frozenset[Coordinate],
+        frontier: set[Coordinate] | None = None,
+    ) -> None:
+        super().__init__()
+        self.coords = coords
+        self.inner_coords = inner_coords
+        if frontier is None:
+            self.frontier = set(coords)
+        else:
+            self.frontier = frontier
+
+    @classmethod
+    def from_snapshot(cls, snapshot: SNAPSHOT) -> Self:
+        coords = frozenset(Coordinate.from_tuple(t) for t in snapshot["coords"])
+        frontier = {Coordinate.from_tuple(t) for t in snapshot["frontier"]}
+        inner_coords = frozenset(Coordinate.from_tuple(t) for t in snapshot["inner_coords"])
+
+        return cls(coords, inner_coords, frontier)
+
+    def to_snapshot(self) -> SNAPSHOT:
+        return {
+            "coords": tuple(c.to_tuple() for c in self.coords),
+            "frontier": tuple(c.to_tuple() for c in self.frontier),
+            "inner_coords": tuple(c.to_tuple() for c in self.inner_coords),
+        }
+
+    def in_hull(self, pos: Coordinate) -> bool:
+        return pos in self.coords
+
+    def inside_hull(self, pos: Coordinate) -> bool:
+        return pos in self.coords or self.in_inner_part(pos)
+
+    def in_inner_part(self, pos: Coordinate) -> bool:
+        return pos in self.inner_coords

{polycubetools-1.1.0 → polycubetools-1.1.2}/src/polycubetools/utils.py

@@ -5,6 +5,7 @@ import json
 import logging
 from typing import Any, TYPE_CHECKING
 
+from .errors import InvalidVolumeException
 from .models import TWENTY_SIX_NEIGHBORHOOD_DIRECTIONS, Polycube, RotatedPolycube, Coordinate
 
 if TYPE_CHECKING:
@@ -12,12 +13,10 @@ if TYPE_CHECKING:
 
 _logger = logging.getLogger(__name__)
 
-NO_VOLUME = -1
-MULTIPLE_VOLUME_COMPONENTS = -2
-ERROR_IN_ALGORITHM = -3
-
 __all__ = (
+    "collect_volume",
     "compute_volume",
+    "find_connected_component",
     "get_extreme_points",
     "is_valid_fence",
     "load_polycubes",
@@ -49,7 +48,7 @@ def _is_border_coordinate(coord: Coordinate, max_extrem_point: Coordinate, min_e
     )
 
 
-def _find_connected_component(visible_coords: set[Coordinate]) -> set[Coordinate]:
+def find_connected_component(visible_coords: set[Coordinate]) -> set[Coordinate]:
     """Finds all coordinates connected to the first coordinate in the set using 26-neighborhood."""
     start = visible_coords.pop()
     stack = [start]
@@ -86,7 +85,7 @@ def get_extreme_points(coords: set[Coordinate]) -> tuple[Coordinate, Coordinate]
     return Coordinate(x_max, y_max, z_max), Coordinate(x_min, y_min, z_min)
 
 
-def compute_volume(coords: set[Coordinate]) -> int:
+def collect_volume(coords: set[Coordinate]) -> set[Coordinate]:
     """Compute the volume from the hull formed by the coordinates"""
     max_extreme_point, min_extreme_point = get_extreme_points(coords)
     max_extreme_point = Coordinate(max_extreme_point.x + 1, max_extreme_point.y + 1, max_extreme_point.z + 1)
@@ -101,24 +100,41 @@ def compute_volume(coords: set[Coordinate]) -> int:
     }
 
     # the here popped coordinate is always outside the hull; this is because we added this outside new layer!
-    _find_connected_component(visible_coords)
+    first_component = find_connected_component(visible_coords)
 
-    # we return false because there is no second component, meaning the shape has no volume
     if not visible_coords:
         _logger.warning("No volume found! Only one component detected.")
-        return NO_VOLUME
+        return set()
+
+    second_component = find_connected_component(visible_coords)
+
+    if min_extreme_point in second_component and max_extreme_point in second_component:
+        volume_cubes = first_component
+    elif min_extreme_point in first_component and max_extreme_point in first_component:
+        volume_cubes = second_component
+    else:
+        _logger.warning("Error. Couldn't find one outside component")
+        raise InvalidVolumeException("Couldn't find one outside component")
 
-    volume_cubes = _find_connected_component(visible_coords)
     if visible_coords:
         _logger.warning(
-            f"Found {len(volume_cubes)} as volume, but still {len(visible_coords)} unvisited cubes left. Exists another enclosed area!"
+            f"Found {len(volume_cubes)} as volume, but still {len(visible_coords)} unvisited cubes left. Another enclosed area exists!"
         )
-        return MULTIPLE_VOLUME_COMPONENTS
+        raise InvalidVolumeException("Volume has multiple components")
 
     if any(_is_border_coordinate(c, max_extreme_point, min_extreme_point) for c in volume_cubes):
         _logger.warning("Volume has been found on the border! Bug in the validation.")
-        return ERROR_IN_ALGORITHM
+        raise InvalidVolumeException("Volume has been found on the border")
 
+    return volume_cubes
+
+
+def compute_volume(coords: set[Coordinate]) -> int:
+    """
+    Ruft die Funktion collect_volume auf, um alle Punkte der Volumen-Komponente zu erhalten.
+    Die Anzahl dieser Punkte ist das Volumen.
+    """
+    volume_cubes = collect_volume(coords)
     return len(volume_cubes)
 
 

{polycubetools-1.1.0 → polycubetools-1.1.2/src/polycubetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polycubetools
-Version: 1.1.0
+Version: 1.1.2
 Summary: Basic framework for working with polycubes in a 3-dimensional grid.
 Author: Team Polycube
 Classifier: Development Status :: 3 - Alpha

{polycubetools-1.1.0 → polycubetools-1.1.2}/src/polycubetools.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 requirements.txt
 setup.py
 src/polycubetools/__init__.py
+src/polycubetools/errors.py
 src/polycubetools/grid.py
 src/polycubetools/hull.py
 src/polycubetools/models.py
@@ -19,6 +20,7 @@ src/polycubetools/data/heptacubes.json
 src/polycubetools/data/hexacubes.json
 src/polycubetools/data/pentacubes.json
 tests/test_grid.py
+tests/test_hull.py
 tests/test_models.py
 tests/test_parallel_solver.py
 tests/test_solver.py

polycubetools-1.1.2/tests/test_hull.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import pytest
+
+from polycubetools import Coordinate
+from polycubetools.hull import CuboidHull, CoordinateHull
+
+
+class TestCuboidHullInHull:
+    """Tests for CuboidHull.in_hull method."""
+
+    def test_in_hull_inside_point(self):
+        """A point strictly inside the cuboid should be in the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        assert hull.inside_hull(Coordinate(2, 2, 2))
+
+    def test_in_hull_on_boundary(self):
+        """A point on the boundary should be in the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        # On face
+        assert hull.inside_hull(Coordinate(0, 2, 2))
+        assert hull.inside_hull(Coordinate(4, 2, 2))
+        # On edge
+        assert hull.inside_hull(Coordinate(0, 0, 2))
+        # On corner
+        assert hull.inside_hull(Coordinate(0, 0, 0))
+        assert hull.inside_hull(Coordinate(4, 4, 4))
+
+    def test_in_hull_outside_point(self):
+        """A point outside the cuboid should not be in the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        # Outside in x
+        assert not hull.inside_hull(Coordinate(-1, 2, 2))
+        assert not hull.inside_hull(Coordinate(5, 2, 2))
+        # Outside in y
+        assert not hull.inside_hull(Coordinate(2, -1, 2))
+        assert not hull.inside_hull(Coordinate(2, 5, 2))
+        # Outside in z
+        assert not hull.inside_hull(Coordinate(2, 2, -1))
+        assert not hull.inside_hull(Coordinate(2, 2, 5))
+
+    def test_in_hull_with_negative_coordinates(self):
+        """Test hull with negative coordinate bounds."""
+        hull = CuboidHull(Coordinate(-3, -3, -3), Coordinate(3, 3, 3))
+        assert hull.inside_hull(Coordinate(0, 0, 0))
+        assert hull.inside_hull(Coordinate(-3, -3, -3))
+        assert hull.inside_hull(Coordinate(3, 3, 3))
+        assert not hull.inside_hull(Coordinate(-4, 0, 0))
+
+    def test_in_hull_single_point(self):
+        """Test a hull that is a single point."""
+        hull = CuboidHull(Coordinate(1, 1, 1), Coordinate(1, 1, 1))
+        assert hull.inside_hull(Coordinate(1, 1, 1))
+        assert not hull.inside_hull(Coordinate(0, 1, 1))
+        assert not hull.inside_hull(Coordinate(2, 1, 1))
+
+
+class TestCuboidHullOnHull:
+    """Tests for CuboidHull.on_hull method."""
+
+    def test_on_hull_corner(self):
+        """Corner points should be on the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        assert hull.in_hull(Coordinate(0, 0, 0))
+        assert hull.in_hull(Coordinate(4, 4, 4))
+        assert hull.in_hull(Coordinate(0, 4, 4))
+        assert hull.in_hull(Coordinate(4, 0, 0))
+
+    def test_on_hull_edge(self):
+        """Edge points should be on the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        assert hull.in_hull(Coordinate(0, 0, 2))
+        assert hull.in_hull(Coordinate(4, 4, 2))
+        assert hull.in_hull(Coordinate(2, 0, 0))
+
+    def test_on_hull_face(self):
+        """Points on faces should be on the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        # x-face
+        assert hull.in_hull(Coordinate(0, 2, 2))
+        assert hull.in_hull(Coordinate(4, 2, 2))
+        # y-face
+        assert hull.in_hull(Coordinate(2, 0, 2))
+        assert hull.in_hull(Coordinate(2, 4, 2))
+        # z-face
+        assert hull.in_hull(Coordinate(2, 2, 0))
+        assert hull.in_hull(Coordinate(2, 2, 4))
+
+    def test_on_hull_interior_point(self):
+        """Interior points should NOT be on the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        assert not hull.in_hull(Coordinate(2, 2, 2))
+        assert not hull.in_hull(Coordinate(1, 1, 1))
+        assert not hull.in_hull(Coordinate(3, 3, 3))
+
+    def test_on_hull_outside_point(self):
+        """Points outside the hull should NOT be on the hull."""
+        hull = CuboidHull(Coordinate(0, 0, 0), Coordinate(4, 4, 4))
+        assert not hull.in_hull(Coordinate(-1, 2, 2))
+        assert not hull.in_hull(Coordinate(5, 2, 2))
+        # Even if one coordinate matches a boundary
+        assert not hull.in_hull(Coordinate(0, 5, 2))
+
+    def test_on_hull_with_negative_coordinates(self):
+        """Test on_hull with negative coordinate bounds."""
+        hull = CuboidHull(Coordinate(-2, -2, -2), Coordinate(2, 2, 2))
+        # Corners
+        assert hull.in_hull(Coordinate(-2, -2, -2))
+        assert hull.in_hull(Coordinate(2, 2, 2))
+        # Face
+        assert hull.in_hull(Coordinate(-2, 0, 0))
+        # Interior
+        assert not hull.in_hull(Coordinate(0, 0, 0))
+
+    def test_on_hull_single_point(self):
+        """A single-point hull should be on the hull."""
+        hull = CuboidHull(Coordinate(1, 1, 1), Coordinate(1, 1, 1))
+        assert hull.in_hull(Coordinate(1, 1, 1))
+        assert not hull.in_hull(Coordinate(0, 1, 1))
+
+
+class TestCoordinateHullInHull:
+    """Tests for CoordinateHull.in_hull method."""
+
+    def test_in_hull_present_coordinate(self):
+        """Coordinates in the set should be in the hull."""
+        coords = frozenset({
+            Coordinate(0, 0, 0),
+            Coordinate(1, 0, 0),
+            Coordinate(0, 1, 0),
+        })
+        hull = CoordinateHull(coords)
+        assert hull.in_hull(Coordinate(0, 0, 0))
+        assert hull.in_hull(Coordinate(1, 0, 0))
+        assert hull.in_hull(Coordinate(0, 1, 0))
+
+    def test_in_hull_absent_coordinate(self):
+        """Coordinates not in the set should not be in the hull."""
+        coords = frozenset({
+            Coordinate(0, 0, 0),
+            Coordinate(1, 0, 0),
+        })
+        hull = CoordinateHull(coords)
+        assert not hull.in_hull(Coordinate(2, 0, 0))
+        assert not hull.in_hull(Coordinate(0, 1, 0))
+        assert not hull.in_hull(Coordinate(-1, 0, 0))
+
+    def test_in_hull_empty_hull(self):
+        """Empty hull should contain no coordinates."""
+        hull = CoordinateHull(frozenset())
+        assert not hull.in_hull(Coordinate(0, 0, 0))

{polycubetools-1.1.0 → polycubetools-1.1.2}/tests/test_models.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import pytest
-from polycubetools import Coordinate, RotatedPolycube, utils
+from polycubetools import Coordinate, RotatedPolycube, utils, InvalidVolumeException
 
 
 def test_validation_of_compactness():
@@ -19,13 +19,13 @@ def test_validation_of_compactness():
     # remove side cube
     cube.remove(Coordinate(2, 1, 1))
     volume = utils.compute_volume(cube)
-    assert volume == utils.NO_VOLUME
+    assert volume == 0
     cube.add(Coordinate(2, 1, 1))
 
     # remove corner cube
     cube.remove(Coordinate(0, 0, 0))
     volume = utils.compute_volume(cube)
-    assert volume == utils.NO_VOLUME
+    assert volume == 0
     cube.add(Coordinate(0, 0, 0))
 
     cube.add(Coordinate(3, 1, 1))
@@ -35,7 +35,7 @@ def test_validation_of_compactness():
     # now it has no volume
     cube.add(Coordinate(1, 1, 1))
     volume = utils.compute_volume(cube)
-    assert volume == utils.NO_VOLUME
+    assert volume == 0
     cube.remove(Coordinate(1, 1, 1))
 
     cuboid = {
@@ -49,9 +49,8 @@ def test_validation_of_compactness():
     assert volume == 2
 
     two_hulls = cube.union(cuboid)
-    volume = utils.compute_volume(two_hulls)
-    # we could also compute the sum of the enclosed area by multiple components
-    assert volume == utils.MULTIPLE_VOLUME_COMPONENTS
+    with pytest.raises(InvalidVolumeException, match="Volume has multiple components"):
+        volume = utils.compute_volume(two_hulls)
 
     two_hulls_with_one_empty_hull = two_hulls
     two_hulls_with_one_empty_hull.add(Coordinate(1, 1, 1))