fastquadtree 0.5.1__tar.gz → 0.6.0__tar.gz

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/Cargo.lock

@@ -22,9 +22,10 @@ checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
 [[package]]
 name = "fastquadtree"
-version = "0.5.1"
+version = "0.6.0"
 dependencies = [
  "pyo3",
+ "smallvec",
 ]
 
 [[package]]

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fastquadtree"
-version = "0.5.1"
+version = "0.6.0"
 edition = "2021"
 readme = "README.md"
 
@@ -9,6 +9,7 @@ crate-type = ["rlib", "cdylib"]
 
 [dependencies]
 pyo3 = { version = "0.21", features = ["extension-module", "abi3-py38"] }
+smallvec = "1.15.1"
 
 [profile.release]
 opt-level = 3

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastquadtree
-Version: 0.5.1
+Version: 0.6.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Rust
@@ -35,15 +35,14 @@ Project-URL: Issues, https://github.com/Elan456/fastquadtree/issues
 [![Wheels](https://img.shields.io/pypi/wheel/fastquadtree.svg)](https://pypi.org/project/fastquadtree/#files)
 [![License: MIT](https://img.shields.io/pypi/l/fastquadtree.svg)](LICENSE)
 
-[![Downloads total](https://static.pepy.tech/badge/fastquadtree)](https://pepy.tech/projects/fastquadtree)
-[![Downloads month](https://static.pepy.tech/badge/fastquadtree/month)](https://pepy.tech/projects/fastquadtree)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/fastquadtree?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=BLUE&left_text=Total+Downloads)](https://pepy.tech/projects/fastquadtree)
 
 [![Build](https://github.com/Elan456/fastquadtree/actions/workflows/release.yml/badge.svg)](https://github.com/Elan456/fastquadtree/actions/workflows/ci.yml)
 [![Codecov](https://codecov.io/gh/Elan456/fastquadtree/branch/main/graph/badge.svg)](https://codecov.io/gh/Elan456/fastquadtree)
 
 [![Rust core via PyO3](https://img.shields.io/badge/Rust-core%20via%20PyO3-orange)](https://pyo3.rs/)
 [![Built with maturin](https://img.shields.io/badge/Built%20with-maturin-1f6feb)](https://www.maturin.rs/)
-[![Lint and format: Ruff](https://img.shields.io/badge/Lint%20and%20format-Ruff-46a758?logo=ruff&logoColor=white)](https://docs.astral.sh/ruff/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 
 
@@ -66,18 +65,27 @@ fastquadtree **outperforms** all other quadtree Python packages, including the R
 ![Throughput](https://raw.githubusercontent.com/Elan456/fastquadtree/main/assets/quadtree_bench_throughput.png)
 
 ### Summary (largest dataset, PyQtree baseline)
-- Points: **500,000**, Queries: **500**
+- Points: **250,000**, Queries: **500**
 --------------------
-- Fastest total: **fastquadtree** at **1.591 s**
+- Fastest total: **fastquadtree** at **0.120 s**
 
 | Library | Build (s) | Query (s) | Total (s) | Speed vs PyQtree |
 |---|---:|---:|---:|---:|
-| fastquadtree | 0.165 | 1.427 | 1.591 | 5.09× |
-| Rtree        | 1.320 | 2.369 | 3.688 | 2.20× |
-| PyQtree      | 2.687 | 5.415 | 8.102 | 1.00× |
-| nontree-QuadTree | 1.284 | 9.891 | 11.175 | 0.73× |
-| quads        | 2.346 | 10.129 | 12.475 | 0.65× |
-| e-pyquadtree | 1.795 | 11.855 | 13.650 | 0.59× |
+| fastquadtree | 0.031 | 0.089 | 0.120 | 14.64× |
+| Shapely STRtree | 0.179 | 0.100 | 0.279 | 6.29× |
+| nontree-QuadTree | 0.595 | 0.605 | 1.200 | 1.46× |
+| Rtree        | 0.961 | 0.300 | 1.261 | 1.39× |
+| e-pyquadtree | 1.005 | 0.660 | 1.665 | 1.05× |
+| PyQtree      | 1.492 | 0.263 | 1.755 | 1.00× |
+| quads        | 1.407 | 0.484 | 1.890 | 0.93× |
+
+#### Benchmark Configuration
+| Parameter | Value |
+|---|---:|
+| Bounds | (0, 0, 1000, 1000) |
+| Max points per node | 128 |
+| Max depth | 16 |
+| Queries per experiment | 500 |
 
 ## Install
 
@@ -281,7 +289,7 @@ MIT. See `LICENSE`.
 
 ## Acknowledgments
 
-* Python libraries compared: [PyQtree], [e-pyquadtree], [Rtree], [nontree], [quads]
+* Python libraries compared: [PyQtree], [e-pyquadtree], [Rtree], [nontree], [quads], [Shapely]
 * Built with [PyO3] and [maturin]
 
 [PyQtree]: https://pypi.org/project/pyqtree/
@@ -291,3 +299,5 @@ MIT. See `LICENSE`.
 [Rtree]: https://pypi.org/project/Rtree/
 [nontree]: https://pypi.org/project/nontree/
 [quads]: https://pypi.org/project/quads/
+[Shapely]: https://pypi.org/project/Shapely/
+

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/README.md

@@ -5,15 +5,14 @@
 [![Wheels](https://img.shields.io/pypi/wheel/fastquadtree.svg)](https://pypi.org/project/fastquadtree/#files)
 [![License: MIT](https://img.shields.io/pypi/l/fastquadtree.svg)](LICENSE)
 
-[![Downloads total](https://static.pepy.tech/badge/fastquadtree)](https://pepy.tech/projects/fastquadtree)
-[![Downloads month](https://static.pepy.tech/badge/fastquadtree/month)](https://pepy.tech/projects/fastquadtree)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/fastquadtree?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=BLUE&left_text=Total+Downloads)](https://pepy.tech/projects/fastquadtree)
 
 [![Build](https://github.com/Elan456/fastquadtree/actions/workflows/release.yml/badge.svg)](https://github.com/Elan456/fastquadtree/actions/workflows/ci.yml)
 [![Codecov](https://codecov.io/gh/Elan456/fastquadtree/branch/main/graph/badge.svg)](https://codecov.io/gh/Elan456/fastquadtree)
 
 [![Rust core via PyO3](https://img.shields.io/badge/Rust-core%20via%20PyO3-orange)](https://pyo3.rs/)
 [![Built with maturin](https://img.shields.io/badge/Built%20with-maturin-1f6feb)](https://www.maturin.rs/)
-[![Lint and format: Ruff](https://img.shields.io/badge/Lint%20and%20format-Ruff-46a758?logo=ruff&logoColor=white)](https://docs.astral.sh/ruff/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 
 
@@ -36,18 +35,27 @@ fastquadtree **outperforms** all other quadtree Python packages, including the R
 ![Throughput](https://raw.githubusercontent.com/Elan456/fastquadtree/main/assets/quadtree_bench_throughput.png)
 
 ### Summary (largest dataset, PyQtree baseline)
-- Points: **500,000**, Queries: **500**
+- Points: **250,000**, Queries: **500**
 --------------------
-- Fastest total: **fastquadtree** at **1.591 s**
+- Fastest total: **fastquadtree** at **0.120 s**
 
 | Library | Build (s) | Query (s) | Total (s) | Speed vs PyQtree |
 |---|---:|---:|---:|---:|
-| fastquadtree | 0.165 | 1.427 | 1.591 | 5.09× |
-| Rtree        | 1.320 | 2.369 | 3.688 | 2.20× |
-| PyQtree      | 2.687 | 5.415 | 8.102 | 1.00× |
-| nontree-QuadTree | 1.284 | 9.891 | 11.175 | 0.73× |
-| quads        | 2.346 | 10.129 | 12.475 | 0.65× |
-| e-pyquadtree | 1.795 | 11.855 | 13.650 | 0.59× |
+| fastquadtree | 0.031 | 0.089 | 0.120 | 14.64× |
+| Shapely STRtree | 0.179 | 0.100 | 0.279 | 6.29× |
+| nontree-QuadTree | 0.595 | 0.605 | 1.200 | 1.46× |
+| Rtree        | 0.961 | 0.300 | 1.261 | 1.39× |
+| e-pyquadtree | 1.005 | 0.660 | 1.665 | 1.05× |
+| PyQtree      | 1.492 | 0.263 | 1.755 | 1.00× |
+| quads        | 1.407 | 0.484 | 1.890 | 0.93× |
+
+#### Benchmark Configuration
+| Parameter | Value |
+|---|---:|
+| Bounds | (0, 0, 1000, 1000) |
+| Max points per node | 128 |
+| Max depth | 16 |
+| Queries per experiment | 500 |
 
 ## Install
 
@@ -251,7 +259,7 @@ MIT. See `LICENSE`.
 
 ## Acknowledgments
 
-* Python libraries compared: [PyQtree], [e-pyquadtree], [Rtree], [nontree], [quads]
+* Python libraries compared: [PyQtree], [e-pyquadtree], [Rtree], [nontree], [quads], [Shapely]
 * Built with [PyO3] and [maturin]
 
 [PyQtree]: https://pypi.org/project/pyqtree/
@@ -260,4 +268,5 @@ MIT. See `LICENSE`.
 [maturin]: https://www.maturin.rs/
 [Rtree]: https://pypi.org/project/Rtree/
 [nontree]: https://pypi.org/project/nontree/
-[quads]: https://pypi.org/project/quads/
+[quads]: https://pypi.org/project/quads/
+[Shapely]: https://pypi.org/project/Shapely/

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/benchmarks/quadtree_bench/engines.py

@@ -7,10 +7,13 @@ allowing fair comparison of their performance characteristics.
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
+import numpy as np
 from pyqtree import Index as PyQTree  # Pyqtree
 
 # Built-in engines (always available in this repo)
 from pyquadtree.quadtree import QuadTree as EPyQuadTree  # e-pyquadtree
+from shapely import box as shp_box, points  # Shapely 2.x
+from shapely.strtree import STRtree
 
 from fastquadtree import QuadTree as RustQuadTree  # fastquadtree
 
@@ -101,8 +104,7 @@ def _create_fastquadtree_engine(
 
     def build(points):
         qt = RustQuadTree(bounds, max_points, max_depth=max_depth)
-        for p in points:
-            qt.insert(p)
+        qt.insert_many_points(points)
         return qt
 
     def query(qt, queries):
@@ -239,6 +241,40 @@ def _create_rtree_engine(
     return Engine("Rtree", "#e377c2", build, query)
 
 
+def _create_strtree_engine(
+    bounds: Tuple[int, int, int, int], max_points: int, max_depth: int
+) -> Optional[Engine]:
+    """Create engine adapter for Shapely STRtree (optional)."""
+
+    def build(points_list: List[Tuple[int, int]]):
+        # Build geometries efficiently
+
+        xs = np.fromiter(
+            (x for x, _ in points_list), dtype="float32", count=len(points_list)
+        )
+        ys = np.fromiter(
+            (y for _, y in points_list), dtype="float32", count=len(points_list)
+        )
+        geoms = points(xs, ys)  # vectorized Point creation
+        assert type(geoms) is np.ndarray
+        tree = STRtree(geoms, node_capacity=max_points)
+        # Keep geoms alive next to the tree
+        return (tree, geoms)
+
+    def query(built, queries: List[Tuple[int, int, int, int]]):
+        tree, _geoms = built
+        for xmin, ymin, xmax, ymax in queries:
+            window = shp_box(xmin, ymin, xmax, ymax)
+            # Shapely 2.x returns ndarray of indices for a single geometry
+            res = tree.query(window)
+            # Consume results without materializing to keep parity with other engines
+            if hasattr(res, "__iter__"):
+                for _ in res:
+                    pass
+
+    return Engine("Shapely STRtree", "#7f7f7f", build, query)
+
+
 def get_engines(
     bounds: Tuple[int, int, int, int] = (0, 0, 1000, 1000),
     max_points: int = 20,
@@ -268,6 +304,7 @@ def get_engines(
         _create_quads_engine,
         _create_nontree_engine,
         _create_rtree_engine,
+        _create_strtree_engine,
     ]
 
     for engine_creator in optional_engines:

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/benchmarks/quadtree_bench/main.py

@@ -25,10 +25,10 @@ def main():
     parser.add_argument(
         "--max-points",
         type=int,
-        default=20,
+        default=128,
         help="Maximum points per node before splitting",
     )
-    parser.add_argument("--max-depth", type=int, default=10, help="Maximum tree depth")
+    parser.add_argument("--max-depth", type=int, default=16, help="Maximum tree depth")
     parser.add_argument(
         "--n-queries", type=int, default=500, help="Number of queries per experiment"
     )
@@ -41,7 +41,7 @@ def main():
     parser.add_argument(
         "--max-experiment-points",
         type=int,
-        default=500_000,
+        default=250_000,
         help="Maximum number of points in largest experiment",
     )
     parser.add_argument(

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/benchmarks/quadtree_bench/runner.py

@@ -23,12 +23,12 @@ class BenchmarkConfig:
     """Configuration for benchmark runs."""
 
     bounds: Tuple[int, int, int, int] = (0, 0, 1000, 1000)
-    max_points: int = 20  # node capacity where supported
-    max_depth: int = 10  # depth cap for fairness where supported
-    n_queries: int = 500  # queries per experiment
+    max_points: int = 64  # node capacity where supported
+    max_depth: int = 1_000  # depth cap for fairness where supported
+    n_queries: int = 100  # queries per experiment
     repeats: int = 3  # median over repeats
     rng_seed: int = 42  # random seed for reproducibility
-    max_experiment_points: int = 500_000
+    max_experiment_points: int = 100_000
 
     def __post_init__(self):
         """Generate experiment point sizes."""
@@ -69,8 +69,8 @@ class BenchmarkRunner:
         for _ in range(m):
             x = rng.randint(x_min, x_max)
             y = rng.randint(y_min, y_max)
-            w = rng.randint(0, x_max - x)
-            h = rng.randint(0, y_max - y)
+            w = rng.randint(0, x_max - x) // rng.randint(1, 8)
+            h = rng.randint(0, y_max - y) // rng.randint(1, 8)
             queries.append((x, y, x + w, y + h))
         return queries
 
@@ -306,3 +306,12 @@ class BenchmarkRunner:
             print(f"| {name:12} | {fmt(b)} | {fmt(q)} | {fmt(t)} | {rel_speed(name)} |")
 
         print("")
+
+        # Config table
+        print("#### Benchmark Configuration")
+        print("| Parameter | Value |")
+        print("|---|---:|")
+        print(f"| Bounds | {config.bounds} |")
+        print(f"| Max points per node | {config.max_points} |")
+        print(f"| Max depth | {config.max_depth} |")
+        print(f"| Queries per experiment | {config.n_queries} |")

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/benchmarks/requirements.txt

@@ -11,4 +11,5 @@ fastquadtree>=0.1.0
 # Added libraries
 quads>=1.1.0         # pure-Python quadtree
 nontree>=1.0.5       # pure-Python PR quadtree (TreeMap mode=4)
-rtree>=1.3.0         # R-tree comparator with wheels for Win/macOS/Linux
+rtree>=1.3.0         # R-tree comparator with wheels for Win/macOS/Linux
+shapely>=2.0.0       # STRtree comparator

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/pyproject.toml

@@ -41,7 +41,7 @@ module-name = "fastquadtree._native"
 compatibility = "manylinux2014"
 
 [tool.pytest.ini_options]
-addopts = "--cov=fastquadtree --cov-branch --cov-report=xml --cov-fail-under=95"
+addopts = "--cov=fastquadtree --cov-branch --cov-report=xml --cov-fail-under=100"
 testpaths = ["tests"]  # still run tests
 
 [tool.coverage.run]
@@ -110,6 +110,7 @@ ignore = [
   "PLR0915",
   "PLR0913",
   "PLR0912",
+  "PLC0415",
 ]
 
 # Make pytest files less strict where asserts and fixtures are common.

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/pysrc/fastquadtree/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Literal, Tuple, overload
+from typing import Any, Literal, Tuple, overload
 
 from ._bimap import BiMap  # type: ignore[attr-defined]
 from ._item import Item
@@ -103,37 +103,33 @@ class QuadTree:
         self._count += 1
         return id_
 
-    def insert_many_points(self, points: Iterable[Point]) -> int:
+    def insert_many_points(self, points: list[Point]) -> int:
         """
         Bulk insert points with auto-assigned ids.
 
         Args:
-            points: Iterable of (x, y) points.
+            points: List of (x, y) points.
 
         Returns:
-            Number of points successfully inserted.
-
-        Raises:
-            ValueError: If any point is outside tree bounds.
+            The number of points inserted
         """
-        ins = self._native.insert
-        nid = self._next_id
-        inserted = 0
-        bx0, by0, bx1, by1 = self._bounds
-        for xy in points:
-            id_ = nid
-            nid += 1
-            if not ins(id_, xy):
-                x, y = xy
-                raise ValueError(
-                    f"Point ({x}, {y}) is outside bounds ({bx0}, {by0}, {bx1}, {by1})"
-                )
-            inserted += 1
-            if self._items is not None:
-                self._items.add(Item(id_, xy[0], xy[1], None))
-        self._next_id = nid
-        self._count += inserted
-        return inserted
+        start_id = self._next_id
+        last_id = self._native.insert_many_points(start_id, points)
+
+        num_inserted = last_id - start_id + 1
+
+        if num_inserted < len(points):
+            raise ValueError("One or more points are outside tree bounds")
+
+        self._next_id = last_id + 1
+
+        # Update the item tracker if needed
+        if self._items is not None:
+            for i, id_ in enumerate(range(start_id, last_id + 1)):
+                x, y = points[i]
+                self._items.add(Item(id_, x, y, None))
+
+        return num_inserted
 
     def attach(self, id_: int, obj: Any) -> None:
         """
@@ -263,7 +259,7 @@ class QuadTree:
 
         if self._items is None:
             raise ValueError("Cannot return result as item with track_objects=False")
-        id_, x, y = t
+        id_, _x, _y = t
         item = self._items.by_id(id_)
         if item is None:
             raise RuntimeError(

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/pysrc/fastquadtree/__init__.pyi

@@ -31,7 +31,6 @@ class QuadTree:
     # Inserts
     def insert(self, xy: Point, *, id_: int | None = ..., obj: Any = ...) -> int: ...
     def insert_many_points(self, points: Iterable[Point]) -> int: ...
-    def insert_many(self, items: Iterable[tuple[Point, Any]]) -> int: ...
     def attach(self, id_: int, obj: Any) -> None: ...
 
     # Deletions

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/src/lib.rs

@@ -7,6 +7,7 @@ pub use crate::geom::{Point, Rect, dist_sq_point_to_rect, dist_sq_points};
 pub use crate::quadtree::{Item, QuadTree};
 
 use pyo3::prelude::*;
+use pyo3::types::{PyList};
 
 fn item_to_tuple(it: Item) -> (u64, f32, f32) {
     (it.id, it.point.x, it.point.y)
@@ -35,20 +36,33 @@ impl PyQuadTree {
         self.inner.insert(Item { id, point: Point { x, y } })
     }
 
+    // Insert many points with auto ids starting at `start_id`: [(x, y), ...]
+    // Returns the last id used
+    pub fn insert_many_points(&mut self, start_id: u64, points: Vec<(f32, f32)>) -> u64 {
+        let mut id = start_id;
+        for (x, y) in points {
+            if self.inner.insert(Item { id, point: Point { x, y } }) {
+                id += 1;
+            }
+        }
+        id - 1  // -1 because id was incremented after last successful insert
+    }
+
     pub fn delete(&mut self, id: u64, xy: (f32, f32)) -> bool {
         let (x, y) = xy;
         self.inner.delete(id, Point { x, y })
     }
 
-    pub fn query(&self, rect: (f32, f32, f32, f32)) -> Vec<(u64, f32, f32)> {
+    // Build the Python list of (id, x, y) directly from the Vec<Item>.
+    // Public behavior is unchanged: returns list[(id, x, y)].
+    pub fn query<'py>(&self, py: Python<'py>, rect: (f32, f32, f32, f32)) -> Bound<'py, PyList> {
         let (min_x, min_y, max_x, max_y) = rect;
-        self.inner
-            .query(Rect { min_x, min_y, max_x, max_y })
-            .into_iter()
-            .map(item_to_tuple)
-            .collect()
+        let tuples = self.inner.query(Rect { min_x, min_y, max_x, max_y });
+        // PyO3 will turn Vec<(u64,f32,f32)> into a Python list of tuples
+        PyList::new_bound(py, &tuples)
     }
 
+
     pub fn nearest_neighbor(&self, xy: (f32, f32)) -> Option<(u64, f32, f32)> {
         let (x, y) = xy;
         self.inner.nearest_neighbor(Point { x, y }).map(item_to_tuple)

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/src/quadtree.rs

@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 use crate::geom::{Point, Rect, dist_sq_point_to_rect, dist_sq_points};
+use smallvec::SmallVec;
 
 #[derive(Copy, Clone, Debug, PartialEq, Default)]
 pub struct Item {
@@ -120,26 +121,83 @@ impl QuadTree {
         self.children = Some(Box::new(kids));
     }
 
-    pub fn query(&self, range: Rect) -> Vec<Item> {
-        let mut out = Vec::new();
-        let mut stack: Vec<&QuadTree> = Vec::new();
-        stack.push(self);
+    #[inline(always)]
+    fn rect_contains_rect(a: &Rect, b: &Rect) -> bool {
+        a.min_x <= b.min_x && a.min_y <= b.min_y &&
+        a.max_x >= b.max_x && a.max_y >= b.max_y
+    }
 
-        while let Some(node) = stack.pop() {
-            for it in &node.items {
-                if range.contains(&it.point) {
-                    out.push(*it);
+    pub fn query(&self, range: Rect) -> Vec<(u64, f32, f32)> {
+        #[derive(Copy, Clone)]
+        enum Mode { Filter, ReportAll }
+
+        // Hoist bounds for tight leaf checks
+        let rx0 = range.min_x;
+        let ry0 = range.min_y;
+        let rx1 = range.max_x;
+        let ry1 = range.max_y;
+
+        let mut out: Vec<(u64, f32, f32)> = Vec::with_capacity(128);
+        let mut stack: SmallVec<[(&QuadTree, Mode); 64]> = SmallVec::new();
+        stack.push((self, Mode::Filter));
+
+        while let Some((node, mode)) = stack.pop() {
+            match mode {
+                Mode::ReportAll => {
+                    if let Some(children) = node.children.as_ref() {
+                        // Entire subtree is inside the query.
+                        // No filtering, just recurse in ReportAll.
+                        stack.push((&children[0], Mode::ReportAll));
+                        stack.push((&children[1], Mode::ReportAll));
+                        stack.push((&children[2], Mode::ReportAll));
+                        stack.push((&children[3], Mode::ReportAll));
+                    } else {
+                        // Leaf: append all items, no per-point test
+                        let items = &node.items;
+                        out.reserve(items.len());
+                        out.extend(items.iter().map(|it| (it.id, it.point.x, it.point.y)));
+                    }
                 }
-            }
-            if let Some(children) = node.children.as_ref() {
-                // Push children that intersect the query range
-                for child in children.iter() {
-                    if range.intersects(&child.boundary) {
-                        stack.push(child);
+
+                Mode::Filter => {
+                    // Node cull
+                    if !range.intersects(&node.boundary) {
+                        continue;
+                    }
+
+                    // Full cover: switch to ReportAll
+                    if Self::rect_contains_rect(&range, &node.boundary) {
+                        stack.push((node, Mode::ReportAll));
+                        continue;
+                    }
+
+                    // Partial overlap
+                    if let Some(children) = node.children.as_ref() {
+                        // Only push intersecting children
+                        let c0 = &children[0];
+                        if range.intersects(&c0.boundary) { stack.push((c0, Mode::Filter)); }
+                        let c1 = &children[1];
+                        if range.intersects(&c1.boundary) { stack.push((c1, Mode::Filter)); }
+                        let c2 = &children[2];
+                        if range.intersects(&c2.boundary) { stack.push((c2, Mode::Filter)); }
+                        let c3 = &children[3];
+                        if range.intersects(&c3.boundary) { stack.push((c3, Mode::Filter)); }
+                    } else {
+                        // Leaf scan with tight predicate
+                        let items = &node.items;
+                        // Reserve a little to reduce reallocs if many will pass
+                        out.reserve(items.len().min(64));
+                        for it in items {
+                            let p = &it.point;
+                            if p.x >= rx0 && p.x < rx1 && p.y >= ry0 && p.y < ry1 {
+                                out.push((it.id, p.x, p.y));
+                            }
+                        }
                     }
                 }
             }
         }
+
         out
     }
 

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/tests/query.rs

@@ -4,8 +4,8 @@ fn r(x0: f32, y0: f32, x1: f32, y1: f32) -> Rect {
     Rect { min_x: x0, min_y: y0, max_x: x1, max_y: y1 }
 }
 fn pt(x: f32, y: f32) -> Point { Point { x, y } }
-fn ids(v: &[Item]) -> Vec<u64> {
-    let mut out: Vec<u64> = v.iter().map(|it| it.id).collect();
+fn ids(v: &Vec<(u64, f32, f32)>) -> Vec<u64> {
+    let mut out: Vec<u64> = v.iter().map(|it| it.0).collect();
     out.sort_unstable();
     out
 }

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/tests/test_delete.rs

@@ -166,7 +166,7 @@ fn test_delete_preserves_other_operations() {
     let query_rect = Rect { min_x: 5.0, min_y: 5.0, max_x: 25.0, max_y: 25.0 };
     let results = tree.query(query_rect);
     assert_eq!(results.len(), 1); // Should only find point (10,10)
-    assert_eq!(results[0].id, 1);
+    assert_eq!(results[0].0, 1);
     
     // Test nearest neighbor
     let nearest = tree.nearest_neighbor(Point { x: 15.0, y: 15.0 });
@@ -230,7 +230,7 @@ fn test_delete_multiple_items_same_location() {
     assert_eq!(results.len(), 2);
     
     // Verify we can find both remaining items
-    let ids: Vec<u64> = results.iter().map(|item| item.id).collect();
+    let ids: Vec<u64> = results.iter().map(|item| item.0).collect();
     assert!(ids.contains(&10));
     assert!(ids.contains(&30));
     assert!(!ids.contains(&20)); // Should be deleted

{fastquadtree-0.5.1 → fastquadtree-0.6.0}/tests/unconventional_bounds.rs

@@ -12,8 +12,8 @@ fn item(id: u64, x: f32, y: f32) -> Item {
     Item { id, point: pt(x, y) }
 }
 
-fn ids(v: &[Item]) -> Vec<u64> {
-    let mut out: Vec<u64> = v.iter().map(|it| it.id).collect();
+fn ids(v: &Vec<(u64, f32, f32)>) -> Vec<u64> {
+    let mut out: Vec<u64> = v.iter().map(|it| it.0).collect();
     out.sort_unstable();
     out
 }