Struct kd_tree::KdSliceN

pub struct KdSliceN<T, N: Unsigned>(_, _);

A slice of kd-tree. This type implements std::ops::Deref to [T]. This is an unsized type, meaning that it must always be used as a reference. For an owned version of this type, see KdTree.

Implementations

impl<T, N: Unsigned> KdSliceN<T, N>

pub fn items(&self) -> &[T]

pub fn sort_by<F>(items: &mut [T], compare: F) -> &Self where
    F: Fn(&T, &T, usize) -> Ordering + Copy, 

Example

struct Item {
    point: [i32; 3],
    id: usize,
}
let mut items: Vec<Item> = vec![
    Item { point: [1, 2, 3], id: 111 },
    Item { point: [3, 1, 2], id: 222 },
    Item { point: [2, 3, 1], id: 333 },
];
let kdtree = kd_tree::KdSlice3::sort_by(&mut items, |item1, item2, k| item1.point[k].cmp(&item2.point[k]));
assert_eq!(kdtree.nearest_by(&[3, 1, 2], |item, k| item.point[k]).unwrap().item.id, 222);

pub fn sort_by_key<Key: Ord, F>(items: &mut [T], kd_key: F) -> &Self where
    F: Fn(&T, usize) -> Key + Copy, 

Example

struct Item {
    point: [f64; 3],
    id: usize,
}
let mut items: Vec<Item> = vec![
    Item { point: [1.0, 2.0, 3.0], id: 111 },
    Item { point: [3.0, 1.0, 2.0], id: 222 },
    Item { point: [2.0, 3.0, 1.0], id: 333 },
];
use ordered_float::OrderedFloat;
let kdtree = kd_tree::KdSlice3::sort_by_key(&mut items, |item, k| OrderedFloat(item.point[k]));
assert_eq!(kdtree.nearest_by(&[3.1, 0.9, 2.1], |item, k| item.point[k]).unwrap().item.id, 222);

pub fn sort_by_ordered_float(points: &mut [T]) -> &Self where
    T: KdPoint<Dim = N>,
    T::Scalar: Float, 

Example

use kd_tree::KdSlice;
let mut items: Vec<[f64; 3]> = vec![[1.0, 2.0, 3.0], [3.0, 1.0, 2.0], [2.0, 3.0, 1.0]];
let kdtree: &KdSlice<[f64; 3]> = KdSlice::sort_by_ordered_float(&mut items);
assert_eq!(kdtree.nearest(&[3.1, 0.9, 2.1]).unwrap().item, &[3.0, 1.0, 2.0]);

pub fn sort(points: &mut [T]) -> &Self where
    T: KdPoint<Dim = N>,
    T::Scalar: Ord, 

Example

use kd_tree::KdSlice;
let mut items: Vec<[i32; 3]> = vec![[1, 2, 3], [3, 1, 2], [2, 3, 1]];
let kdtree: &KdSlice<[i32; 3]> = KdSlice::sort(&mut items);
assert_eq!(kdtree.nearest(&[3, 1, 2]).unwrap().item, &[3, 1, 2]);

pub fn nearest_by<Q: KdPoint<Dim = N>>(
    &self,
    query: &Q,
    coord: impl Fn(&T, usize) -> Q::Scalar + Copy
) -> Option<ItemAndDistance<'_, T, Q::Scalar>>

Returns the nearest item from the input point. Returns None if self.is_empty().

Example

struct Item {
    point: [f64; 3],
    id: usize,
}
let mut items: Vec<Item> = vec![
    Item { point: [1.0, 2.0, 3.0], id: 111 },
    Item { point: [3.0, 1.0, 2.0], id: 222 },
    Item { point: [2.0, 3.0, 1.0], id: 333 },
];
use ordered_float::OrderedFloat;
let kdtree = kd_tree::KdSlice3::sort_by_key(&mut items, |item, k| OrderedFloat(item.point[k]));
assert_eq!(kdtree.nearest_by(&[3.1, 0.9, 2.1], |item, k| item.point[k]).unwrap().item.id, 222);

pub fn nearest(
    &self,
    query: &impl KdPoint<Scalar = T::Scalar, Dim = N>
) -> Option<ItemAndDistance<'_, T, T::Scalar>> where
    T: KdPoint<Dim = N>, 

Returns the nearest item from the input point. Returns None if self.is_empty().

Example

let mut items: Vec<[i32; 3]> = vec![[1, 2, 3], [3, 1, 2], [2, 3, 1]];
let kdtree = kd_tree::KdSlice::sort(&mut items);
assert_eq!(kdtree.nearest(&[3, 1, 2]).unwrap().item, &[3, 1, 2]);

pub fn nearests_by<Q: KdPoint<Dim = N>>(
    &self,
    query: &Q,
    num: usize,
    coord: impl Fn(&T, usize) -> Q::Scalar + Copy
) -> Vec<ItemAndDistance<'_, T, Q::Scalar>>

Returns the nearest item from the input point. Returns None if self.is_empty().

Example

struct Item {
    point: [f64; 3],
    id: usize,
}
let mut items: Vec<Item> = vec![
    Item { point: [1.0, 2.0, 3.0], id: 111 },
    Item { point: [3.0, 1.0, 2.0], id: 222 },
    Item { point: [2.0, 3.0, 1.0], id: 333 },
];
use ordered_float::OrderedFloat;
let kdtree = kd_tree::KdSlice3::sort_by_key(&mut items, |item, k| OrderedFloat(item.point[k]));
let nearests = kdtree.nearests_by(&[2.5, 2.0, 1.4], 2, |item, k| item.point[k]);
assert_eq!(nearests.len(), 2);
assert_eq!(nearests[0].item.id, 333);
assert_eq!(nearests[1].item.id, 222);

pub fn nearests(
    &self,
    query: &impl KdPoint<Scalar = T::Scalar, Dim = N>,
    num: usize
) -> Vec<ItemAndDistance<'_, T, T::Scalar>> where
    T: KdPoint<Dim = N>, 

Returns kNN(k nearest neighbors) from the input point.

Example

let mut items: Vec<[i32; 3]> = vec![[1, 2, 3], [3, 1, 2], [2, 3, 1], [3, 2, 2]];
let kdtree = kd_tree::KdSlice::sort(&mut items);
let nearests = kdtree.nearests(&[3, 1, 2], 2);
assert_eq!(nearests.len(), 2);
assert_eq!(nearests[0].item, &[3, 1, 2]);
assert_eq!(nearests[1].item, &[3, 2, 2]);

pub fn within_by_cmp(
    &self,
    compare: impl Fn(&T, usize) -> Ordering + Copy
) -> Vec<&T>

pub fn within_by<Q: KdPoint<Dim = N>>(
    &self,
    query: &[Q; 2],
    coord: impl Fn(&T, usize) -> Q::Scalar + Copy
) -> Vec<&T>

pub fn within(
    &self,
    query: &[impl KdPoint<Scalar = T::Scalar, Dim = N>; 2]
) -> Vec<&T> where
    T: KdPoint<Dim = N>, 

search points within a rectangular region

pub fn within_radius_by<Q: KdPoint<Dim = N>>(
    &self,
    query: &Q,
    radius: Q::Scalar,
    coord: impl Fn(&T, usize) -> Q::Scalar + Copy
) -> Vec<&T>

pub fn within_radius(
    &self,
    query: &impl KdPoint<Scalar = T::Scalar, Dim = N>,
    radius: T::Scalar
) -> Vec<&T> where
    T: KdPoint<Dim = N>, 

search points within k-dimensional sphere

Trait Implementations

impl<T, N: Unsigned> AsRef<KdSliceN<T, N>> for KdTreeN<T, N>

fn as_ref(&self) -> &KdSliceN<T, N>

Performs the conversion.

impl<T, N: Unsigned> Borrow<KdSliceN<T, N>> for KdTreeN<T, N>

fn borrow(&self) -> &KdSliceN<T, N>

Immutably borrows from an owned value.

impl<T: Debug, N: Debug + Unsigned> Debug for KdSliceN<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, N: Unsigned> Deref for KdSliceN<T, N>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T: PartialEq, N: PartialEq + Unsigned> PartialEq<KdSliceN<T, N>> for KdSliceN<T, N>

fn eq(&self, other: &KdSliceN<T, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &KdSliceN<T, N>) -> bool

This method tests for !=.

impl<T: Clone, N: Unsigned> ToOwned for KdSliceN<T, N>

type Owned = KdTreeN<T, N>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning.

impl<T: Eq, N: Eq + Unsigned> Eq for KdSliceN<T, N>

impl<T, N: Unsigned> StructuralEq for KdSliceN<T, N>

impl<T, N: Unsigned> StructuralPartialEq for KdSliceN<T, N>