diskpack 0.1.0__tar.gz → 0.2.0__tar.gz

{diskpack-0.1.0/src/diskpack.egg-info → diskpack-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diskpack
-Version: 0.1.0
+Version: 0.2.0
 Summary: A high-performance vectorized circle packer with spatial hashing.
 Author-email: James Kelly <mrkellyjam@gmail.com>
 Requires-Python: >=3.8

{diskpack-0.1.0 → diskpack-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diskpack"
-version = "0.1.0"
+version = "0.2.0"
 authors = [{ name="James Kelly", email="mrkellyjam@gmail.com" }]
 description = "A high-performance vectorized circle packer with spatial hashing."
 readme = "README.md"

{diskpack-0.1.0 → diskpack-0.2.0}/src/diskpack/packer.py

@@ -19,6 +19,8 @@ class PackingConfig:
     mega_circle_threshold: float = 0.5
     ray_cast_epsilon: float = 1e-10
     sample_batch_size: int = 50
+    fixed_radius: Optional[float] = None
+    verbose: bool = False
 
 
 @dataclass
@@ -27,12 +29,12 @@ class PackingProgress:
     circles_placed: int = 0
     failed_attempts: int = 0
     max_failed_attempts: int = 200
-    
+
     @property
     def progress_ratio(self) -> float:
         """How close we are to stopping (0.0 = just started, 1.0 = about to stop)."""
         return self.failed_attempts / self.max_failed_attempts
-    
+
     def __str__(self) -> str:
         return f"Placed: {self.circles_placed} | Failed attempts: {self.failed_attempts}/{self.max_failed_attempts} ({self.progress_ratio:.0%})"
 
@@ -148,12 +150,14 @@ class CirclePacker:
             max_radius = min(max_radius, distance_to_circle)
         return max_radius - self.config.padding
 
-    def _find_best_placement(self, candidates: np.ndarray, fixed_radius: Optional[float]) -> Optional[Tuple[Point, float]]:
+    def _find_best_placement(self, candidates: np.ndarray) -> Optional[Tuple[Point, float]]:
         best_point, best_radius = None, 0
+        fixed = self.config.fixed_radius
+        
         for point in candidates:
             radius = self._compute_max_radius(point)
-            if fixed_radius is not None:
-                radius = fixed_radius if radius >= fixed_radius else -1
+            if fixed is not None:
+                radius = fixed if radius >= fixed else -1
             if radius > best_radius:
                 best_point, best_radius = point, radius
 
@@ -167,42 +171,38 @@ class CirclePacker:
         self.radii.append(radius)
         self.spatial_index.add_circle(idx, center, radius)
 
-    def generate(self, fixed_radius: Optional[float] = None, verbose: bool = False) -> Iterator[Circle]:
+    def generate(self) -> Iterator[Circle]:
         """
         Generate circles until no more can be placed.
-        
-        Args:
-            fixed_radius: If provided, all circles will have this exact radius.
-            verbose: If True, print progress updates periodically.
-        
+
         Yields:
             Tuples of (x, y, radius) for each placed circle.
         """
         self.progress = PackingProgress(max_failed_attempts=self.config.max_failed_attempts)
-        
+
         while self.progress.failed_attempts < self.config.max_failed_attempts:
             candidates = self._sample_candidate_points(self.config.sample_batch_size)
-            result = self._find_best_placement(candidates, fixed_radius)
-            
+            result = self._find_best_placement(candidates)
+
             if result is not None:
                 center, radius = result
                 self._place_circle(center, radius)
                 self.progress.circles_placed += 1
                 self.progress.failed_attempts = 0
-                
-                if verbose and self.progress.circles_placed % 25 == 0:
+
+                if self.config.verbose and self.progress.circles_placed % 25 == 0:
                     print(self.progress)
-                
+
                 yield (float(center[0]), float(center[1]), float(radius))
             else:
                 self.progress.failed_attempts += 1
-                
-                if verbose and self.progress.failed_attempts % 50 == 0:
+
+                if self.config.verbose and self.progress.failed_attempts % 50 == 0:
                     print(self.progress)
 
-        if verbose:
+        if self.config.verbose:
             print(f"Done! {self.progress}")
 
-    def pack(self, fixed_radius: Optional[float] = None, verbose: bool = False) -> List[Circle]:
+    def pack(self) -> List[Circle]:
         """Pack circles and return them as a list."""
-        return list(self.generate(fixed_radius, verbose=verbose))
+        return list(self.generate())

{diskpack-0.1.0 → diskpack-0.2.0/src/diskpack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diskpack
-Version: 0.1.0
+Version: 0.2.0
 Summary: A high-performance vectorized circle packer with spatial hashing.
 Author-email: James Kelly <mrkellyjam@gmail.com>
 Requires-Python: >=3.8

{diskpack-0.1.0 → diskpack-0.2.0}/tests/tests.py

@@ -3,14 +3,13 @@ import numpy as np
 from diskpack.packer import CirclePacker, PackingConfig, PolygonGeometry
 
 
-
 class TestCirclePacker(unittest.TestCase):
     def setUp(self):
         """Set up a simple 10x10 square for testing."""
         self.square_verts = np.array([[0, 0], [10, 0], [10, 10], [0, 10]])
         self.square = [self.square_verts]
         # Use small padding/min_radius to allow for dense filling
-        self.config = PackingConfig(padding=0.1, min_radius=0.5, patience_before_stop=100)
+        self.config = PackingConfig(padding=0.1, min_radius=0.5, max_failed_attempts=100)
 
     def _calculate_poly_area(self, segments: list) -> float:
         """Calculates area of polygons (including holes) using the Shoelace Formula."""
@@ -18,20 +17,15 @@ class TestCirclePacker(unittest.TestCase):
         for poly in segments:
             x = poly[:, 0]
             y = poly[:, 1]
-            # Area = 0.5 * |sum(x_i * y_{i+1} - x_{i+1} * y_i)|
             area = 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
-            # If it's a hole (clockwise), it naturally subtracts if we don't use abs here,
-            # but since our parser handles holes via Even-Odd, we treat all as positive 
-            # and subtract holes manually if needed. For this test, we assume shells.
             total_area += area
         return total_area
 
     def test_filling_density(self):
         """Verify that the packer fills a minimum percentage of the polygon area."""
         packer = CirclePacker(self.square, self.config)
-        circles = list(packer.generate())
+        circles = packer.pack()
         
-        # Calculate areas
         poly_area = self._calculate_poly_area(self.square)
         circle_area = sum(np.pi * (r**2) for _, _, r in circles)
         
@@ -41,8 +35,6 @@ class TestCirclePacker(unittest.TestCase):
         print(f"Total Area: {poly_area:.2f} | Circle Area: {circle_area:.2f}")
         print(f"Packing Density: {fill_percentage:.2f}%")
         
-        # Assert a minimum density threshold. 
-        # For a random packer, 30-50% is a reasonable 'success' floor depending on radius.
         self.assertGreater(fill_percentage, 25.0, f"Packing density too low: {fill_percentage:.2f}%")
 
     def test_geometry_containment(self):
@@ -61,15 +53,16 @@ class TestCirclePacker(unittest.TestCase):
     def test_no_overlap_integrity(self):
         """Mathematically verify no circles overlap including padding."""
         packer = CirclePacker(self.square, self.config)
-        circles = list(packer.generate())
+        circles = packer.pack()
         
         for i, (x1, y1, r1) in enumerate(circles):
             for j, (x2, y2, r2) in enumerate(circles):
-                if i == j: continue
+                if i == j:
+                    continue
                 dist = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
-                # Distance must be >= sum of radii + padding
                 min_sep = r1 + r2 + self.config.padding
                 self.assertGreaterEqual(dist, min_sep - 1e-9)
 
+
 if __name__ == '__main__':
     unittest.main()