Merge branch 'leo/rstar-capi'

Author: leo-collins

rstar-capi/Cargo.lock

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 rstar = "0.12.2"
-
+interval-tree = { path = "../interval-tree" }
 
 [build-dependencies]
 cbindgen = "0.29"

rstar-capi/Cargo.toml

@@ -9,7 +9,6 @@ enum RTreeError {
   Success = 0,
   NullPointer = 1,
   InvalidDimension = 2,
-  NodeNotLeaf = 3,
 };
 typedef uint16_t RTreeError;
 
@@ -47,6 +46,4 @@ RTreeError rtree_node_envelope(const struct RTreeNodeH *node, double *min_out, d
 
 RTreeError rtree_node_free(struct RTreeNodeH *node);
 
-RTreeError rtree_node_id(const struct RTreeNodeH *node, size_t *id);
-
 RTreeError rtree_root_node(const struct RTreeH *tree, struct RTreeNodeH **node);

rstar-capi/include/rstar-capi.h

@@ -3,5 +3,4 @@ pub enum RTreeError {
     Success = 0,
     NullPointer = 1,
     InvalidDimension = 2,
-    NodeNotLeaf = 3,
 }

rstar-capi/src/error.rs

@@ -1,9 +1,11 @@
 use rstar::{ParentNode, RTreeNode, RTreeObject, AABB};
+use interval_tree::IntervalTreeNode;
 
 use crate::error::RTreeError;
 use crate::rtree::{Object2D, Object3D, RTreeDim, RTreeH};
 
 enum NodeRef {
+    ITreeNode(*const IntervalTreeNode),
     Parent2D(*const ParentNode<Object2D>),
     Parent3D(*const ParentNode<Object3D>),
     Node2D(*const RTreeNode<Object2D>),
@@ -19,6 +21,7 @@ pub extern "C" fn rtree_root_node(tree: *const RTreeH, node: *mut *mut RTreeNode
     }
     let rtree = unsafe { &*(tree as *const RTreeDim) };
     let node_ref = match rtree {
+        RTreeDim::D1(tree) => NodeRef::ITreeNode(tree.root().unwrap()),
         RTreeDim::D2(tree) => NodeRef::Parent2D(tree.root() as *const _),
         RTreeDim::D3(tree) => NodeRef::Parent3D(tree.root() as *const _),
     };
@@ -38,6 +41,17 @@ pub extern "C" fn rtree_node_children(
     let node_ref = unsafe { &*(node as *const NodeRef) };
 
     let child_node_refs: Vec<NodeRef> = match node_ref {
+        NodeRef::ITreeNode(ptr) => {
+            let node = unsafe { &**ptr };
+            let mut children = Vec::new();
+            if let Some(left) = &node.left {
+                children.push(NodeRef::ITreeNode(left.as_ref() as *const _));
+            }
+            if let Some(right) = &node.right {
+                children.push(NodeRef::ITreeNode(right.as_ref() as *const _));
+            }
+            children
+        }
         NodeRef::Parent2D(ptr) => unsafe { &**ptr }
             .children()
             .iter()
@@ -79,31 +93,6 @@ pub extern "C" fn rtree_node_children(
     RTreeError::Success
 }
 
-#[no_mangle]
-pub extern "C" fn rtree_node_id(node: *const RTreeNodeH, id: *mut usize) -> RTreeError {
-    if node.is_null() || id.is_null() {
-        return RTreeError::NullPointer;
-    }
-    let node_ref = unsafe { &*(node as *const NodeRef) };
-
-    let node_id = match node_ref {
-        NodeRef::Parent2D(_) | NodeRef::Parent3D(_) => {
-            return RTreeError::NodeNotLeaf
-        }
-        NodeRef::Node2D(ptr) => match unsafe { &**ptr } {
-            RTreeNode::Leaf(leaf) => leaf.data,
-            RTreeNode::Parent(_) => return RTreeError::NodeNotLeaf,
-        },
-        NodeRef::Node3D(ptr) => match unsafe { &**ptr } {
-            RTreeNode::Leaf(leaf) => leaf.data,
-            RTreeNode::Parent(_) => return RTreeError::NodeNotLeaf,
-        },
-    };
-
-    unsafe { *id = node_id };
-    RTreeError::Success
-}
-
 /// Writes the lower and upper corners of the AABB into `min_out` and `max_out`.
 fn write_aabb<const DIM: usize>(aabb: AABB<[f64; DIM]>, min_out: *mut f64, max_out: *mut f64) {
     let lower = aabb.lower();
@@ -126,6 +115,15 @@ pub extern "C" fn rtree_node_envelope(
     let node_ref = unsafe { &*(node as *const NodeRef) };
 
     match node_ref {
+        NodeRef::ITreeNode(ptr) => {
+            let node = unsafe { &**ptr };
+            let min = node.min;
+            let max = node.max;
+            unsafe {
+                *min_out = min;
+                *max_out = max;
+            }
+        },
         NodeRef::Parent2D(ptr) => write_aabb(unsafe { &**ptr }.envelope(), min_out, max_out),
         NodeRef::Parent3D(ptr) => write_aabb(unsafe { &**ptr }.envelope(), min_out, max_out),
         NodeRef::Node2D(ptr) => write_aabb(unsafe { &**ptr }.envelope(), min_out, max_out),

rstar-capi/src/node.rs

@@ -1,12 +1,14 @@
 use rstar::primitives::{GeomWithData, Rectangle};
 use rstar::RTree;
+use interval_tree::IntervalTree;
 
 use crate::error::RTreeError;
 
 pub type Object2D = GeomWithData<Rectangle<[f64; 2]>, usize>;
 pub type Object3D = GeomWithData<Rectangle<[f64; 3]>, usize>;
 
 pub enum RTreeDim {
+    D1(IntervalTree),
     D2(RTree<Object2D>),
     D3(RTree<Object3D>),
 }
@@ -20,6 +22,7 @@ pub extern "C" fn rtree_create(tree: *mut *mut RTreeH, dim: u32) -> RTreeError {
         return RTreeError::NullPointer;
     }
     let rtree = match dim {
+        1 => RTreeDim::D1(IntervalTree::bulk_load(&[], &[], &[])),
         2 => RTreeDim::D2(RTree::new()),
         3 => RTreeDim::D3(RTree::new()),
         _ => return RTreeError::InvalidDimension,
@@ -39,6 +42,7 @@ pub extern "C" fn rtree_free(tree: *mut RTreeH) -> RTreeError {
 
 fn _rtree_get_dimension(tree: &RTreeDim) -> u32 {
     match tree {
+        RTreeDim::D1(_) => 1,
         RTreeDim::D2(_) => 2,
         RTreeDim::D3(_) => 3,
     }
@@ -75,6 +79,19 @@ fn _rtree_bulk_load<const DIM: usize>(
     RTree::bulk_load(objects)
 }
 
+fn _interval_tree_bulk_load(
+    mins: *const f64,
+    maxs: *const f64,
+    data: *const usize,
+    n: usize,
+) -> IntervalTree {
+    let mins = unsafe { std::slice::from_raw_parts(mins, n) };
+    let maxs = unsafe { std::slice::from_raw_parts(maxs, n) };
+    let data = unsafe { std::slice::from_raw_parts(data, n) };
+
+    IntervalTree::bulk_load(mins, maxs, data)
+}
+
 #[no_mangle]
 pub extern "C" fn rtree_bulk_load(
     tree: *mut *mut RTreeH,
@@ -89,6 +106,7 @@ pub extern "C" fn rtree_bulk_load(
     }
 
     let rtree = match dim {
+        1 => RTreeDim::D1(_interval_tree_bulk_load(mins, maxs, ids, n)),
         2 => RTreeDim::D2(_rtree_bulk_load::<2>(mins, maxs, ids, n)),
         3 => RTreeDim::D3(_rtree_bulk_load::<3>(mins, maxs, ids, n)),
         _ => return RTreeError::InvalidDimension,
@@ -110,6 +128,10 @@ pub extern "C" fn rtree_locate_all_at_point(
     }
     let rtree = unsafe { &*(tree as *const RTreeDim) };
     let mut ids: Vec<usize> = match rtree {
+        RTreeDim::D1(tree) => {
+            let p: f64 = unsafe { *(point as *const f64) };
+            tree.locate_all_at_point(p)
+        }
         RTreeDim::D2(tree) => {
             let p: [f64; 2] = unsafe { *(point as *const [f64; 2]) };
             tree.locate_all_at_point(&p).map(|obj| obj.data).collect()