diskpack 0.1.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diskpack
-Version: 0.1.0
+Version: 0.3.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.3.0}/pyproject.toml

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

diskpack-0.3.0/src/diskpack/packer.py

@@ -0,0 +1,338 @@
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Optional, Iterator, Tuple, Dict
+
+# Type aliases
+Polygon = np.ndarray
+Point = np.ndarray
+GridKey = Tuple[int, int]
+Circle = Tuple[float, float, float]
+
+
+@dataclass
+class PackingConfig:
+    """Configuration parameters for the circle packing algorithm."""
+    padding: float = 1.5
+    min_radius: float = 1.0
+    grid_resolution_divisor: float = 25
+    max_failed_attempts: int = 200
+    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
+class PackingProgress:
+    """Tracks the current state of the packing algorithm."""
+    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%})"
+
+
+class PolygonGeometry:
+    """Handles geometric calculations for polygon boundaries."""
+
+    def __init__(self, polygons: List[Polygon], epsilon: float = 1e-10):
+        self.polygons = [np.array(p, dtype=float) for p in polygons]
+        self.epsilon = epsilon
+        self._compute_bounds()
+        self._precompute_edges()
+
+    def _compute_bounds(self) -> None:
+        all_vertices = np.vstack(self.polygons)
+        self.min_coords = np.min(all_vertices, axis=0)
+        self.max_coords = np.max(all_vertices, axis=0)
+
+    def _precompute_edges(self) -> None:
+        """Precompute edge data for vectorized distance calculations."""
+        all_p1 = []
+        all_p2 = []
+        for poly in self.polygons:
+            n = len(poly)
+            for i in range(n):
+                all_p1.append(poly[i])
+                all_p2.append(poly[(i + 1) % n])
+
+        self.edge_starts = np.array(all_p1)
+        self.edge_ends = np.array(all_p2)
+        self.edge_vecs = self.edge_ends - self.edge_starts
+        self.edge_lengths_sq = np.sum(self.edge_vecs ** 2, axis=1)
+
+    def contains_points(self, points: np.ndarray) -> np.ndarray:
+        """Even-Odd Rule for interior detection, supports holes."""
+        x, y = points[:, 0], points[:, 1]
+        inside = np.zeros(len(points), dtype=bool)
+
+        for poly in self.polygons:
+            n = len(poly)
+            for i in range(n):
+                p1, p2 = poly[i], poly[(i + 1) % n]
+                crosses_edge = (p1[1] > y) != (p2[1] > y)
+                dy = p2[1] - p1[1] + self.epsilon
+                x_intercept = (p2[0] - p1[0]) * (y - p1[1]) / dy + p1[0]
+                inside ^= crosses_edge & (x < x_intercept)
+
+        return inside
+
+    def distance_to_boundary(self, point: Point) -> float:
+        """Vectorized distance to nearest polygon edge."""
+        to_point = point - self.edge_starts
+
+        dots = np.sum(to_point * self.edge_vecs, axis=1)
+
+        with np.errstate(divide='ignore', invalid='ignore'):
+            t = np.clip(dots / self.edge_lengths_sq, 0, 1)
+            t = np.where(self.edge_lengths_sq == 0, 0, t)
+
+        projections = self.edge_starts + t[:, np.newaxis] * self.edge_vecs
+        distances = np.linalg.norm(point - projections, axis=1)
+
+        return float(np.min(distances))
+
+    def distances_to_boundary_batch(self, points: np.ndarray) -> np.ndarray:
+        """
+        Vectorized distance calculation for multiple points at once.
+        
+        Args:
+            points: Array of shape (n_points, 2)
+            
+        Returns:
+            Array of shape (n_points,) with distance to nearest edge for each point
+        """
+        n_points = len(points)
+        n_edges = len(self.edge_starts)
+
+        # Reshape for broadcasting: (n_points, 1, 2) - (n_edges, 2) -> (n_points, n_edges, 2)
+        to_point = points[:, np.newaxis, :] - self.edge_starts[np.newaxis, :, :]
+
+        # Dot products: (n_points, n_edges)
+        dots = np.sum(to_point * self.edge_vecs[np.newaxis, :, :], axis=2)
+
+        # Project onto edges
+        with np.errstate(divide='ignore', invalid='ignore'):
+            t = np.clip(dots / self.edge_lengths_sq[np.newaxis, :], 0, 1)
+            t = np.where(self.edge_lengths_sq[np.newaxis, :] == 0, 0, t)
+
+        # Closest points on edges: (n_points, n_edges, 2)
+        projections = (
+            self.edge_starts[np.newaxis, :, :] + 
+            t[:, :, np.newaxis] * self.edge_vecs[np.newaxis, :, :]
+        )
+
+        # Distances: (n_points, n_edges)
+        distances = np.linalg.norm(points[:, np.newaxis, :] - projections, axis=2)
+
+        # Min distance per point
+        return np.min(distances, axis=1)
+
+
+@dataclass
+class SpatialIndex:
+    """Grid-based spatial index for efficient collision detection."""
+    cell_size: float
+    origin: np.ndarray
+    mega_threshold: float
+    grid: Dict[GridKey, List[int]] = field(default_factory=dict)
+    mega_circles: List[int] = field(default_factory=list)
+    
+    # Store centers/radii arrays for vectorized lookup
+    _centers: np.ndarray = field(default_factory=lambda: np.empty((0, 2)))
+    _radii: np.ndarray = field(default_factory=lambda: np.empty(0))
+
+    def add_circle(self, index: int, center: Point, radius: float) -> None:
+        # Update arrays
+        self._centers = np.vstack([self._centers, center]) if len(self._centers) > 0 else center.reshape(1, 2)
+        self._radii = np.append(self._radii, radius)
+        
+        if radius > self.cell_size * self.mega_threshold:
+            self.mega_circles.append(index)
+        else:
+            key = self._get_cell_key(center)
+            self.grid.setdefault(key, []).append(index)
+
+    def get_nearby_indices(self, point: Point) -> Iterator[int]:
+        yield from self.mega_circles
+        center_key = self._get_cell_key(point)
+        for dx in range(-1, 2):
+            for dy in range(-1, 2):
+                neighbor_key = (center_key[0] + dx, center_key[1] + dy)
+                if neighbor_key in self.grid:
+                    yield from self.grid[neighbor_key]
+
+    def get_nearby_indices_batch(self, points: np.ndarray) -> List[np.ndarray]:
+        """
+        Get nearby circle indices for multiple points.
+        Returns list of index arrays, one per point.
+        """
+        results = []
+        mega_set = set(self.mega_circles)
+        
+        for point in points:
+            indices = list(self.mega_circles)
+            center_key = self._get_cell_key(point)
+            for dx in range(-1, 2):
+                for dy in range(-1, 2):
+                    neighbor_key = (center_key[0] + dx, center_key[1] + dy)
+                    if neighbor_key in self.grid:
+                        for idx in self.grid[neighbor_key]:
+                            if idx not in mega_set:
+                                indices.append(idx)
+            results.append(np.array(indices, dtype=int))
+        
+        return results
+
+    def distance_to_circles(self, point: Point) -> float:
+        """Get minimum distance from point to any existing circle's edge."""
+        if len(self._centers) == 0:
+            return float('inf')
+        
+        indices = list(self.get_nearby_indices(point))
+        if not indices:
+            return float('inf')
+        
+        centers = self._centers[indices]
+        radii = self._radii[indices]
+        
+        distances = np.linalg.norm(centers - point, axis=1) - radii
+        return float(np.min(distances))
+
+    def _get_cell_key(self, point: Point) -> GridKey:
+        cell_coords = ((point - self.origin) // self.cell_size).astype(int)
+        return (int(cell_coords[0]), int(cell_coords[1]))
+
+
+class CirclePacker:
+    """Packs circles within polygon boundaries using random sampling."""
+
+    def __init__(self, polygons: List[Polygon], config: Optional[PackingConfig] = None):
+        self.config = config or PackingConfig()
+        self.geometry = PolygonGeometry(polygons, self.config.ray_cast_epsilon)
+        self.centers: List[Point] = []
+        self.radii: List[float] = []
+        self.progress = PackingProgress(max_failed_attempts=self.config.max_failed_attempts)
+
+        extent = max(self.geometry.max_coords - self.geometry.min_coords)
+        cell_size = extent / self.config.grid_resolution_divisor
+        self.spatial_index = SpatialIndex(
+            cell_size=cell_size,
+            origin=self.geometry.min_coords,
+            mega_threshold=self.config.mega_circle_threshold
+        )
+
+    def _sample_candidate_points(self, count: int) -> np.ndarray:
+        points = np.random.uniform(
+            self.geometry.min_coords,
+            self.geometry.max_coords,
+            size=(count, 2)
+        )
+        return points[self.geometry.contains_points(points)]
+
+    def _compute_max_radius(self, point: Point) -> float:
+        """Compute max radius for a single point."""
+        max_radius = self.geometry.distance_to_boundary(point)
+        circle_dist = self.spatial_index.distance_to_circles(point)
+        max_radius = min(max_radius, circle_dist)
+        return max_radius - self.config.padding
+
+    def _compute_max_radii_batch(self, points: np.ndarray) -> np.ndarray:
+        """
+        Vectorized max radius computation for multiple points.
+        """
+        if len(points) == 0:
+            return np.array([])
+
+        # Boundary distances (fully vectorized)
+        max_radii = self.geometry.distances_to_boundary_batch(points)
+
+        # Circle collision distances (per-point, but with vectorized distance calc)
+        if len(self.centers) > 0:
+            centers_arr = np.array(self.centers)
+            radii_arr = np.array(self.radii)
+            
+            for i, point in enumerate(points):
+                # Get nearby indices
+                indices = list(self.spatial_index.get_nearby_indices(point))
+                if indices:
+                    nearby_centers = centers_arr[indices]
+                    nearby_radii = radii_arr[indices]
+                    distances = np.linalg.norm(nearby_centers - point, axis=1) - nearby_radii
+                    max_radii[i] = min(max_radii[i], np.min(distances))
+
+        return max_radii - self.config.padding
+
+    def _find_best_placement(self, candidates: np.ndarray) -> Optional[Tuple[Point, float]]:
+        if len(candidates) == 0:
+            return None
+
+        # Batch compute all radii
+        radii = self._compute_max_radii_batch(candidates)
+        fixed = self.config.fixed_radius
+
+        if fixed is not None:
+            # For fixed radius, filter to valid positions and pick randomly
+            valid_mask = radii >= fixed
+            if not np.any(valid_mask):
+                return None
+            valid_indices = np.where(valid_mask)[0]
+            best_idx = valid_indices[0]  # Take first valid (or could randomize)
+            return candidates[best_idx], fixed
+        else:
+            # Variable radius: pick the largest
+            best_idx = np.argmax(radii)
+            best_radius = radii[best_idx]
+            
+            if best_radius >= self.config.min_radius:
+                return candidates[best_idx], best_radius
+            return None
+
+    def _place_circle(self, center: Point, radius: float) -> None:
+        idx = len(self.centers)
+        self.centers.append(center)
+        self.radii.append(radius)
+        self.spatial_index.add_circle(idx, center, radius)
+
+    def generate(self) -> Iterator[Circle]:
+        """
+        Generate circles until no more can be placed.
+
+        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)
+
+            if result is not None:
+                center, radius = result
+                self._place_circle(center, radius)
+                self.progress.circles_placed += 1
+                self.progress.failed_attempts = 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 self.config.verbose and self.progress.failed_attempts % 50 == 0:
+                    print(self.progress)
+
+        if self.config.verbose:
+            print(f"Done! {self.progress}")
+
+    def pack(self) -> List[Circle]:
+        """Pack circles and return them as a list."""
+        return list(self.generate())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diskpack
-Version: 0.1.0
+Version: 0.3.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.3.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()

diskpack-0.1.0/src/diskpack/packer.py

@@ -1,208 +0,0 @@
-import numpy as np
-from dataclasses import dataclass, field
-from typing import List, Optional, Iterator, Tuple, Dict
-
-# Type aliases
-Polygon = np.ndarray
-Point = np.ndarray
-GridKey = Tuple[int, int]
-Circle = Tuple[float, float, float]
-
-
-@dataclass
-class PackingConfig:
-    """Configuration parameters for the circle packing algorithm."""
-    padding: float = 1.5
-    min_radius: float = 1.0
-    grid_resolution_divisor: float = 25
-    max_failed_attempts: int = 200
-    mega_circle_threshold: float = 0.5
-    ray_cast_epsilon: float = 1e-10
-    sample_batch_size: int = 50
-
-
-@dataclass
-class PackingProgress:
-    """Tracks the current state of the packing algorithm."""
-    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%})"
-
-
-class PolygonGeometry:
-    """Handles geometric calculations for polygon boundaries."""
-
-    def __init__(self, polygons: List[Polygon], epsilon: float = 1e-10):
-        self.polygons = [np.array(p, dtype=float) for p in polygons]
-        self.epsilon = epsilon
-        self._compute_bounds()
-
-    def _compute_bounds(self) -> None:
-        all_vertices = np.vstack(self.polygons)
-        self.min_coords = np.min(all_vertices, axis=0)
-        self.max_coords = np.max(all_vertices, axis=0)
-
-    def contains_points(self, points: np.ndarray) -> np.ndarray:
-        """Even-Odd Rule for interior detection, supports holes."""
-        x, y = points[:, 0], points[:, 1]
-        inside = np.zeros(len(points), dtype=bool)
-
-        for poly in self.polygons:
-            n = len(poly)
-            for i in range(n):
-                p1, p2 = poly[i], poly[(i + 1) % n]
-                crosses_edge = (p1[1] > y) != (p2[1] > y)
-                dy = p2[1] - p1[1] + self.epsilon
-                x_intercept = (p2[0] - p1[0]) * (y - p1[1]) / dy + p1[0]
-                inside ^= crosses_edge & (x < x_intercept)
-
-        return inside
-
-    def distance_to_boundary(self, point: Point) -> float:
-        min_distance = float('inf')
-        for poly in self.polygons:
-            for i in range(len(poly)):
-                p1, p2 = poly[i], poly[(i + 1) % len(poly)]
-                min_distance = min(min_distance, self._point_to_segment_distance(point, p1, p2))
-        return min_distance
-
-    @staticmethod
-    def _point_to_segment_distance(point: Point, seg_start: Point, seg_end: Point) -> float:
-        segment_vec = seg_end - seg_start
-        segment_length_sq = np.sum(segment_vec ** 2)
-        if segment_length_sq == 0:
-            return np.linalg.norm(point - seg_start)
-        t = np.clip(np.dot(point - seg_start, segment_vec) / segment_length_sq, 0, 1)
-        projection = seg_start + t * segment_vec
-        return np.linalg.norm(point - projection)
-
-
-@dataclass
-class SpatialIndex:
-    """Grid-based spatial index for efficient collision detection."""
-    cell_size: float
-    origin: np.ndarray
-    mega_threshold: float
-    grid: Dict[GridKey, List[int]] = field(default_factory=dict)
-    mega_circles: List[int] = field(default_factory=list)
-
-    def add_circle(self, index: int, center: Point, radius: float) -> None:
-        if radius > self.cell_size * self.mega_threshold:
-            self.mega_circles.append(index)
-        else:
-            key = self._get_cell_key(center)
-            self.grid.setdefault(key, []).append(index)
-
-    def get_nearby_indices(self, point: Point) -> Iterator[int]:
-        yield from self.mega_circles
-        center_key = self._get_cell_key(point)
-        for dx in range(-1, 2):
-            for dy in range(-1, 2):
-                neighbor_key = (center_key[0] + dx, center_key[1] + dy)
-                if neighbor_key in self.grid:
-                    yield from self.grid[neighbor_key]
-
-    def _get_cell_key(self, point: Point) -> GridKey:
-        cell_coords = ((point - self.origin) // self.cell_size).astype(int)
-        return (int(cell_coords[0]), int(cell_coords[1]))
-
-
-class CirclePacker:
-    """Packs circles within polygon boundaries using random sampling."""
-
-    def __init__(self, polygons: List[Polygon], config: Optional[PackingConfig] = None):
-        self.config = config or PackingConfig()
-        self.geometry = PolygonGeometry(polygons, self.config.ray_cast_epsilon)
-        self.centers: List[Point] = []
-        self.radii: List[float] = []
-        self.progress = PackingProgress(max_failed_attempts=self.config.max_failed_attempts)
-
-        extent = max(self.geometry.max_coords - self.geometry.min_coords)
-        cell_size = extent / self.config.grid_resolution_divisor
-        self.spatial_index = SpatialIndex(
-            cell_size=cell_size,
-            origin=self.geometry.min_coords,
-            mega_threshold=self.config.mega_circle_threshold
-        )
-
-    def _sample_candidate_points(self, count: int) -> np.ndarray:
-        points = np.random.uniform(
-            self.geometry.min_coords,
-            self.geometry.max_coords,
-            size=(count, 2)
-        )
-        return points[self.geometry.contains_points(points)]
-
-    def _compute_max_radius(self, point: Point) -> float:
-        max_radius = self.geometry.distance_to_boundary(point)
-        for idx in self.spatial_index.get_nearby_indices(point):
-            distance_to_circle = np.linalg.norm(self.centers[idx] - point) - self.radii[idx]
-            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]]:
-        best_point, best_radius = None, 0
-        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 radius > best_radius:
-                best_point, best_radius = point, radius
-
-        if best_point is not None and best_radius >= self.config.min_radius:
-            return best_point, best_radius
-        return None
-
-    def _place_circle(self, center: Point, radius: float) -> None:
-        idx = len(self.centers)
-        self.centers.append(center)
-        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]:
-        """
-        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)
-            
-            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:
-                    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:
-                    print(self.progress)
-
-        if verbose:
-            print(f"Done! {self.progress}")
-
-    def pack(self, fixed_radius: Optional[float] = None, verbose: bool = False) -> List[Circle]:
-        """Pack circles and return them as a list."""
-        return list(self.generate(fixed_radius, verbose=verbose))