diskpack 0.4.0__tar.gz → 0.6.0__tar.gz

{diskpack-0.4.0/src/diskpack.egg-info → diskpack-0.6.0}/PKG-INFO

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

{diskpack-0.4.0 → diskpack-0.6.0}/pyproject.toml

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

{diskpack-0.4.0 → diskpack-0.6.0}/src/diskpack/packer.py

@@ -8,6 +8,9 @@ Point = np.ndarray
 GridKey = Tuple[int, int]
 Circle = Tuple[float, float, float]
 
+# Threshold for switching between vectorized and spatial index approaches
+VECTORIZED_THRESHOLD = 300
+
 
 @dataclass
 class PackingConfig:
@@ -20,6 +23,7 @@ class PackingConfig:
     ray_cast_epsilon: float = 1e-10
     sample_batch_size: int = 50
     fixed_radius: Optional[float] = None
+    use_hex_grid: bool = True
     verbose: bool = False
 
 
@@ -191,6 +195,27 @@ class CirclePacker:
             origin=self.geometry.min_coords,
             mega_threshold=self.config.mega_circle_threshold
         )
+        
+        # Cache for numpy arrays (avoid repeated conversion)
+        self._centers_arr: Optional[np.ndarray] = None
+        self._radii_arr: Optional[np.ndarray] = None
+        self._cache_valid = False
+
+    def _invalidate_cache(self) -> None:
+        """Mark the numpy array cache as needing refresh."""
+        self._cache_valid = False
+
+    def _get_arrays(self) -> Tuple[np.ndarray, np.ndarray]:
+        """Get cached numpy arrays of centers and radii."""
+        if not self._cache_valid or self._centers_arr is None:
+            if len(self.centers) > 0:
+                self._centers_arr = np.array(self.centers)
+                self._radii_arr = np.array(self.radii)
+            else:
+                self._centers_arr = np.empty((0, 2))
+                self._radii_arr = np.empty(0)
+            self._cache_valid = True
+        return self._centers_arr, self._radii_arr
 
     def _sample_candidate_points(self, count: int) -> np.ndarray:
         points = np.random.uniform(
@@ -208,16 +233,37 @@ class CirclePacker:
         return max_radius - self.config.padding
 
     def _compute_max_radii_batch(self, points: np.ndarray) -> np.ndarray:
-        """Vectorized max radius computation for multiple points."""
+        """
+        Vectorized max radius computation for multiple points.
+        
+        Uses hybrid approach:
+        - Fully vectorized numpy for small circle counts (faster due to no Python loop)
+        - Spatial index for large circle counts (faster due to fewer distance calculations)
+        """
         if len(points) == 0:
             return np.array([])
 
+        # Boundary distances (fully vectorized)
         max_radii = self.geometry.distances_to_boundary_batch(points)
 
-        if len(self.centers) > 0:
-            centers_arr = np.array(self.centers)
-            radii_arr = np.array(self.radii)
-
+        if len(self.centers) == 0:
+            return max_radii - self.config.padding
+
+        centers_arr, radii_arr = self._get_arrays()
+
+        if len(self.centers) < VECTORIZED_THRESHOLD:
+            # Fully vectorized approach for small circle counts
+            # Compute distance from each point to each circle: (n_points, n_circles)
+            dists = np.linalg.norm(
+                points[:, np.newaxis, :] - centers_arr[np.newaxis, :, :],
+                axis=2
+            ) - radii_arr
+            
+            # Min distance to any circle for each point
+            min_circle_dists = np.min(dists, axis=1)
+            max_radii = np.minimum(max_radii, min_circle_dists)
+        else:
+            # Spatial index approach for large circle counts
             for i, point in enumerate(points):
                 indices = list(self.spatial_index.get_nearby_indices(point))
                 if indices:
@@ -255,6 +301,7 @@ class CirclePacker:
         self.centers.append(center)
         self.radii.append(radius)
         self.spatial_index.add_circle(idx, center, radius)
+        self._invalidate_cache()
 
     def _generate_hex_grid(self, radius: float) -> np.ndarray:
         """
@@ -329,22 +376,11 @@ class CirclePacker:
 
         return circles
 
-    def generate(self) -> Iterator[Circle]:
+    def _pack_random(self) -> Iterator[Circle]:
         """
-        Generate circles until no more can be placed.
-
-        For fixed_radius mode, uses optimized hex grid placement.
-        For variable radius mode, uses random sampling with best-fit selection.
-
-        Yields:
-            Tuples of (x, y, radius) for each placed circle.
+        Pack circles using random sampling.
+        Used for variable radius mode or when organic placement is desired.
         """
-        # Use hex grid for fixed radius - much faster and denser
-        if self.config.fixed_radius is not None:
-            yield from self._pack_hex_grid()
-            return
-
-        # Variable radius mode - use random sampling
         self.progress = PackingProgress(max_failed_attempts=self.config.max_failed_attempts)
 
         while self.progress.failed_attempts < self.config.max_failed_attempts:
@@ -370,6 +406,25 @@ class CirclePacker:
         if self.config.verbose:
             print(f"Done! {self.progress}")
 
+    def generate(self) -> Iterator[Circle]:
+        """
+        Generate circles until no more can be placed.
+
+        For fixed_radius mode with use_hex_grid=True (default), uses optimized hex grid.
+        For fixed_radius mode with use_hex_grid=False, uses random sampling for organic look.
+        For variable radius mode, uses random sampling with best-fit selection.
+
+        Yields:
+            Tuples of (x, y, radius) for each placed circle.
+        """
+        # Use hex grid for fixed radius (unless disabled)
+        if self.config.fixed_radius is not None and self.config.use_hex_grid:
+            yield from self._pack_hex_grid()
+            return
+
+        # Random sampling mode (variable radius OR fixed radius with organic placement)
+        yield from self._pack_random()
+
     def pack(self) -> List[Circle]:
         """Pack circles and return them as a list."""
         return list(self.generate())

{diskpack-0.4.0 → diskpack-0.6.0/src/diskpack.egg-info}/PKG-INFO

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