Removed sorting in query_circled_points

Author: radevgit

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.7.0] - 2025-11-15
+- `query_circle_points` returns unsorted points
+- Fix documentation
+
 ## [0.6.13] - 2025-11-08
 - Fix documentation
 

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 
 name = "aabb"
-version = "0.6.14"
+version = "0.7.0"
 description = "Static AABB spatial index for 2D queries"
 rust-version = "1.88"
 edition = "2024"

Cargo.toml

@@ -4,7 +4,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 
-A Rust library providing a simple and efficient Hilbert R-tree implementation for spatial queries on axis-aligned bounding boxes (AABBs).
+A Rust library providing efficient Hilbert R-tree implementation for spatial queries on axis-aligned bounding boxes (AABBs).
 
 ## Features
 
@@ -20,7 +20,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-aabb = "0.6"
+aabb = "0.7"
 ```
 
 ### Basic Example
@@ -71,7 +71,6 @@ fn main() {
     tree.query_circle_points(0.0, 0.0, 2.5, &mut results);
 
     println!("Found {} points within radius 2.5", results.len());
-    // Results are sorted by distance (closest first)
 
     // Find K nearest points
     let mut results = Vec::new();
@@ -122,10 +121,10 @@ The curve preserves spatial locality - points close to each other in 2D space te
 - `query_circle(center_x, center_y, radius, results)` `(f64)` - Find boxes intersecting a circular region
 
 #### Point-Specific Optimized Queries
-- `query_nearest_k_points(x, y, k, results)` `(f64)` - **Optimized** - Find K nearest points (stored as (x, x, y, y)) - ~30% faster than `query_nearest_k` for point clouds
-- `query_circle_points(center_x, center_y, radius, results)` `(f64)` - **Optimized** - Find points within a circular region with distance-sorted results - ~30% faster than `query_circle` for point clouds
+- `query_nearest_k_points(x, y, k, results)` `(f64)` - Find K nearest points (stored as (x, x, y, y)), sorted by distance
+- `query_circle_points(center_x, center_y, radius, results)` `(f64)` - Find points within a circular region (optimized for point data)
 
-**Note:** Point-specific methods assume all items in the tree are stored as degenerate boxes (points) where `min_x == max_x` and `min_y == max_y`. For mixed data (both points and boxes), use the general methods instead. Results from point-specific queries are automatically sorted by distance (closest first).
+**Note:** Point-specific methods assume all items in the tree are stored as degenerate boxes (points) where `min_x == max_x` and `min_y == max_y`. For mixed data (both points and boxes), use the general methods instead.
 
 #### Directional Queries
 - `query_in_direction(rect_min_x, rect_min_y, rect_max_x, rect_max_y, direction_x, direction_y, distance, results)` `(f64)` - Find boxes intersecting a rectangle's movement path

README.md

@@ -273,6 +273,69 @@ fn main() {
         results.len() as f64
     );
 
+    // Build a tree with point data for point-specific queries
+    println!("\n\nPoint Cloud Queries");
+    println!("====================");
+    println!("\nBuilding point cloud index {} points...", num_items);
+    
+    let mut point_tree = HilbertRTree::with_capacity(num_items);
+    for _ in 0..num_items {
+        let x = rng.random_range(0.0..100.0);
+        let y = rng.random_range(0.0..100.0);
+        point_tree.add_point(x, y);
+    }
+    let build_point_start = Instant::now();
+    point_tree.build();
+    let build_point_time = build_point_start.elapsed();
+    println!("  Built in {:.2}ms\n", build_point_time.as_secs_f64() * 1000.0);
+
+    // Profile query_circle_points
+    println!("Profiling query_circle_points:");
+    println!("{}", "-".repeat(40));
+
+    let query_start = Instant::now();
+    for i in 0..num_tests {
+        results.clear();
+        let x = coords[4 * i];
+        let y = coords[4 * i + 1];
+        point_tree.query_circle_points(x, y, 5.0, &mut results);
+    }
+    let elapsed = query_start.elapsed();
+    println!(
+        "  {} queries (radius=5):    {:.2}ms ({:.3}µs/query, avg {:.1} results)",
+        num_tests,
+        elapsed.as_secs_f64() * 1000.0,
+        elapsed.as_secs_f64() * 1_000_000.0 / num_tests as f64,
+        results.len() as f64
+    );
+
+    // Profile query_nearest_k_points with different K values
+    println!("\nProfiling query_nearest_k_points:");
+    println!("{}", "-".repeat(40));
+
+    let k_values = vec![1, 10, 100, 1000];
+
+    for k in k_values {
+        let num_queries = if k == 1000 { 100 } else { num_tests };
+
+        let query_start = Instant::now();
+        for i in 0..num_queries {
+            let x = coords[4 * i];
+            let y = coords[4 * i + 1];
+            point_tree.query_nearest_k_points(x, y, k, &mut results);
+        }
+        let elapsed = query_start.elapsed();
+
+        println!(
+            "  {} queries k={}:          {:.2}ms ({:.3}µs/query, avg {:.1} results)",
+            num_queries,
+            k,
+            elapsed.as_secs_f64() * 1000.0,
+            elapsed.as_secs_f64() * 1_000_000.0 / num_queries as f64,
+            results.len() as f64
+        );
+    }
+
     println!("\n{}", "=".repeat(50));
     println!("\nSummary:");
     println!("--------");
@@ -395,6 +458,7 @@ Summary:
 --------
 Build dominates: 21.1%
 Queries (total): 356.81ms
+___________________________________________________________________________________
 
 
 */

benches/profile_bench.rs

@@ -1497,8 +1497,9 @@ impl HilbertRTree {
     ///
     /// This is an optimized version of `query_circle()` specifically for point data.
     /// For point items where min_x==max_x and min_y==max_y, this method computes
-    /// distances directly without the axis_distance() helper function, providing
-    /// approximately 30% faster queries on point clouds.
+    /// distances directly without the axis_distance() helper function for leaf nodes.
+    /// For parent nodes, axis_distance is used to maintain correctness.
+    /// This optimization provides approximately 30% faster queries on point clouds.
     ///
     /// **Important:** This method assumes all items in the tree are stored as points.
     /// If the tree contains mixed data (both points and boxes), use `query_circle()` instead
@@ -1509,7 +1510,7 @@ impl HilbertRTree {
     /// * `center_y` - Y coordinate of circle center
     /// * `radius` - Radius of the circular region
     /// * `results` - Output vector; will be cleared and populated with indices of all point items
-    ///              within the circular region, sorted by distance (closest first)
+    ///              within the circular region
     ///
     /// # Example
     /// ```
@@ -1522,7 +1523,7 @@ impl HilbertRTree {
     ///
     /// let mut results = Vec::new();
     /// tree.query_circle_points(0.0, 0.0, 1.5, &mut results);
-    /// // Results include points 0 and 1 (within radius), ordered by distance
+    /// // Results include points 0 and 1 (within radius)
     /// ```
     pub fn query_circle_points(&self, center_x: f64, center_y: f64, radius: f64, results: &mut Vec<usize>) {
         if self.num_items == 0 || self.level_bounds.is_empty() || radius < 0.0 {
@@ -1533,8 +1534,6 @@ impl HilbertRTree {
         results.clear();
         let radius_sq = radius * radius;
         let mut queue = VecDeque::new();
-        let mut candidates: Vec<(f64, usize)> = Vec::new();
-        
         let mut node_index = self.total_nodes - 1;
 
         loop {
@@ -1563,7 +1562,7 @@ impl HilbertRTree {
                     if pos >= self.num_items {
                         queue.push_back((index >> 2) as usize);
                     } else {
-                        candidates.push((dist_sq, index as usize));
+                        results.push(index as usize);
                     }
                 }
             }
@@ -1574,12 +1573,6 @@ impl HilbertRTree {
 
             node_index = queue.pop_front().unwrap();
         }
-
-        // Sort by distance ascending
-        candidates.sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
-        for (_, idx) in candidates {
-            results.push(idx);
-        }
     }
 
     /// Finds all boxes that intersect with a rectangle's directional movement path.

src/hilbert_rtree.rs

@@ -96,6 +96,13 @@
 //! - [`query_nearest_k`] `(f64)` - Find K nearest boxes to a point (use k=1 for single nearest)
 //! - [`query_circle`] `(f64)` - Find boxes intersecting a circular region
 //!
+//! ### Point-Specific Optimized Queries
+//! - [`query_nearest_k_points`] `(f64)` - Find K nearest points (stored as (x, x, y, y)), sorted by distance
+//! - [`query_circle_points`] `(f64)` - Find points within a circular region (optimized for point data)
+//!
+//! **Note:** Point-specific methods assume all items in the tree are stored as degenerate boxes (points)
+//! where `min_x == max_x` and `min_y == max_y`. For mixed data (both points and boxes), use the general methods instead.
+//!
 //! ### Directional Queries  
 //! - [`query_in_direction`] `(f64)` - Find boxes intersecting a rectangle's movement path
 //! - [`query_in_direction_k`] `(f64)` - Find K nearest boxes intersecting a rectangle's movement path
@@ -108,6 +115,8 @@
 //! [`query_contained_within`]: HilbertRTree::query_contained_within
 //! [`query_nearest_k`]: HilbertRTree::query_nearest_k
 //! [`query_circle`]: HilbertRTree::query_circle
+//! [`query_nearest_k_points`]: HilbertRTree::query_nearest_k_points
+//! [`query_circle_points`]: HilbertRTree::query_circle_points
 //! [`query_in_direction`]: HilbertRTree::query_in_direction
 //! [`query_in_direction_k`]: HilbertRTree::query_in_direction_k
 //!

src/lib.rs

@@ -162,14 +162,13 @@ mod test_point_optimizations {
         let mut results = Vec::new();
         tree.query_circle_points(0.0, 0.0, 6.0, &mut results);
 
-        // All 4 points within radius 6
+        // All 4 points within radius 6 (order depends on tree traversal)
         assert_eq!(results.len(), 4);
-        // Should be sorted by distance
-        // Point 3 (dist 0), Point 1 (dist 1), Point 2 (dist 2), Point 0 (dist 5)
-        assert_eq!(results[0], 3);
-        assert_eq!(results[1], 1);
-        assert_eq!(results[2], 2);
-        assert_eq!(results[3], 0);
+        // Verify all expected points are in results (unordered)
+        assert!(results.contains(&0));
+        assert!(results.contains(&1));
+        assert!(results.contains(&2));
+        assert!(results.contains(&3));
     }
 
     /// Test query_nearest_k_points with negative coordinates