diff --git a/nblast-py/src/lib.rs b/nblast-py/src/lib.rs index f449867..0489026 100644 --- a/nblast-py/src/lib.rs +++ b/nblast-py/src/lib.rs @@ -12,8 +12,8 @@ use numpy::{IntoPyArray, PyArray1, PyArray2, PyReadonlyArray1, PyReadonlyArray2} use nblast::nalgebra::base::{Unit, Vector3}; use nblast::{ - neurons::kiddo::ExactKiddoTangentsAlphas as Neuron, BinLookup, NblastArena, NeuronIdx, - Precision, RangeTable, ScoreCalc, ScoreMatrixBuilder, Symmetry, TangentAlpha, + neurons::kiddo::ExactKiddoNeuron as Neuron, BinLookup, NblastArena, NeuronIdx, Precision, + RangeTable, ScoreCalc, ScoreMatrixBuilder, Symmetry, TangentAlpha, }; use nblast::rayon; diff --git a/nblast-rs/benches/bench.rs b/nblast-rs/benches/bench.rs index 1cc8385..6d7c5c5 100644 --- a/nblast-rs/benches/bench.rs +++ b/nblast-rs/benches/bench.rs @@ -7,12 +7,12 @@ use csv::ReaderBuilder; use fastrand::Rng; #[cfg(feature = "bosque")] -use nblast::neurons::bosque::BosqueTangentsAlphas; +use nblast::neurons::bosque::BosqueNeuron; #[cfg(feature = "kiddo")] -use nblast::neurons::kiddo::{ExactKiddoTangentsAlphas, KiddoTangentsAlphas}; +use nblast::neurons::kiddo::{ExactKiddoNeuron, KiddoNeuron}; #[cfg(feature = "nabo")] -use nblast::neurons::nabo::NaboTangentsAlphas; -use nblast::neurons::rstar::RStarTangentsAlphas; +use nblast::neurons::nabo::NaboNeuron; +use nblast::neurons::rstar::RstarNeuron; use nblast::{ BinLookup, NblastArena, NblastNeuron, Point3, Precision, QueryNeuron, RangeTable, ScoreCalc, ScoreMatrixBuilder, TangentAlpha, @@ -250,74 +250,72 @@ fn get_score_fn() -> ScoreCalc { fn bench_query_rstar(b: &mut Bencher) { let score_fn = get_score_fn(); - let query = - RStarTangentsAlphas::new(&read_points(NAMES[0]), N_NEIGHBORS).expect("couldn't parse"); - let target = - RStarTangentsAlphas::new(&read_points(NAMES[1]), N_NEIGHBORS).expect("couldn't parse"); + let query = RstarNeuron::new(&read_points(NAMES[0]), N_NEIGHBORS).expect("couldn't parse"); + let target = RstarNeuron::new(&read_points(NAMES[1]), N_NEIGHBORS).expect("couldn't parse"); b.iter(|| query.query(&target, false, &score_fn)) } fn bench_construction_rstar(b: &mut Bencher) { let points = read_points(NAMES[0]); - b.iter(|| RStarTangentsAlphas::new(&points, N_NEIGHBORS).expect("couldn't parse")); + b.iter(|| RstarNeuron::new(&points, N_NEIGHBORS).expect("couldn't parse")); } fn bench_construction_nabo(b: &mut Bencher) { let points = read_points(NAMES[0]); - b.iter(|| NaboTangentsAlphas::new(points.clone(), N_NEIGHBORS)) + b.iter(|| NaboNeuron::new(points.clone(), N_NEIGHBORS)) } fn bench_construction_kiddo(b: &mut Bencher) { let points = read_points(NAMES[0]); - b.iter(|| KiddoTangentsAlphas::new(points.clone(), N_NEIGHBORS)) + b.iter(|| KiddoNeuron::new(points.clone(), N_NEIGHBORS)) } fn bench_construction_exact_kiddo(b: &mut Bencher) { let points = read_points(NAMES[0]); - b.iter(|| ExactKiddoTangentsAlphas::new(points.clone(), N_NEIGHBORS)) + b.iter(|| ExactKiddoNeuron::new(points.clone(), N_NEIGHBORS)) } fn bench_construction_bosque(b: &mut Bencher) { let points = read_points(NAMES[0]); - b.iter(|| BosqueTangentsAlphas::new(points.clone(), N_NEIGHBORS)) + b.iter(|| BosqueNeuron::new(points.clone(), N_NEIGHBORS)) } fn bench_query_nabo(b: &mut Bencher) { let score_fn = get_score_fn(); - let query = NaboTangentsAlphas::new(read_points(NAMES[0]), N_NEIGHBORS); - let target = NaboTangentsAlphas::new(read_points(NAMES[1]), N_NEIGHBORS); + let query = NaboNeuron::new(read_points(NAMES[0]), N_NEIGHBORS); + let target = NaboNeuron::new(read_points(NAMES[1]), N_NEIGHBORS); b.iter(|| query.query(&target, false, &score_fn)) } fn bench_query_kiddo(b: &mut Bencher) { let score_fn = get_score_fn(); - let query = KiddoTangentsAlphas::new(read_points(NAMES[0]), N_NEIGHBORS).unwrap(); - let target = KiddoTangentsAlphas::new(read_points(NAMES[1]), N_NEIGHBORS).unwrap(); + let query = KiddoNeuron::new(read_points(NAMES[0]), N_NEIGHBORS).unwrap(); + let target = KiddoNeuron::new(read_points(NAMES[1]), N_NEIGHBORS).unwrap(); b.iter(|| query.query(&target, false, &score_fn)) } fn bench_query_exact_kiddo(b: &mut Bencher) { let score_fn = get_score_fn(); - let query = ExactKiddoTangentsAlphas::new(read_points(NAMES[0]), N_NEIGHBORS).unwrap(); - let target = ExactKiddoTangentsAlphas::new(read_points(NAMES[1]), N_NEIGHBORS).unwrap(); + let query = ExactKiddoNeuron::new(read_points(NAMES[0]), N_NEIGHBORS).unwrap(); + let target = ExactKiddoNeuron::new(read_points(NAMES[1]), N_NEIGHBORS).unwrap(); b.iter(|| query.query(&target, false, &score_fn)) } fn bench_query_bosque(b: &mut Bencher) { let score_fn = get_score_fn(); - let query = BosqueTangentsAlphas::new(read_points(NAMES[0]), N_NEIGHBORS).unwrap(); - let target = BosqueTangentsAlphas::new(read_points(NAMES[1]), N_NEIGHBORS).unwrap(); + let query = BosqueNeuron::new(read_points(NAMES[0]), N_NEIGHBORS).unwrap(); + let target = BosqueNeuron::new(read_points(NAMES[1]), N_NEIGHBORS).unwrap(); b.iter(|| query.query(&target, false, &score_fn)) } fn bench_construction_with_tangents_rstar(b: &mut Bencher) { let points = read_points(NAMES[0]); - let neuron = RStarTangentsAlphas::new(&points, N_NEIGHBORS).expect("couldn't parse"); + let neuron = RstarNeuron::new(&points, N_NEIGHBORS).expect("couldn't parse"); let tangents_alphas: Vec<_> = neuron .tangents() .zip(neuron.alphas()) @@ -326,14 +324,14 @@ fn bench_construction_with_tangents_rstar(b: &mut Bencher) { alpha: a, }) .collect(); - b.iter(|| RStarTangentsAlphas::new_with_tangents_alphas(&points, tangents_alphas.clone())); + b.iter(|| RstarNeuron::new_with_tangents_alphas(&points, tangents_alphas.clone())); } fn bench_arena_construction(b: &mut Bencher) { let score_fn = get_score_fn(); let pointtangents: Vec<_> = NAMES .iter() - .map(|n| RStarTangentsAlphas::new(&read_points(n), N_NEIGHBORS).expect("couldn't parse")) + .map(|n| RstarNeuron::new(&read_points(n), N_NEIGHBORS).expect("couldn't parse")) .collect(); b.iter(|| { let mut arena = NblastArena::new(score_fn.clone(), false); @@ -346,11 +344,9 @@ fn bench_arena_construction(b: &mut Bencher) { fn bench_arena_query(b: &mut Bencher) { let mut arena = NblastArena::new(get_score_fn(), false); let p0 = read_points(NAMES[0]); - let idx0 = - arena.add_neuron(RStarTangentsAlphas::new(&p0, N_NEIGHBORS).expect("couldn't parse")); + let idx0 = arena.add_neuron(RstarNeuron::new(&p0, N_NEIGHBORS).expect("couldn't parse")); let p1 = read_points(NAMES[1]); - let idx1 = - arena.add_neuron(RStarTangentsAlphas::new(&p1, N_NEIGHBORS).expect("couldn't parse")); + let idx1 = arena.add_neuron(RstarNeuron::new(&p1, N_NEIGHBORS).expect("couldn't parse")); b.iter(|| arena.query_target(idx0, idx1, false, &None)); } @@ -358,11 +354,9 @@ fn bench_arena_query(b: &mut Bencher) { fn bench_arena_query_norm(b: &mut Bencher) { let mut arena = NblastArena::new(get_score_fn(), false); let p0 = read_points(NAMES[0]); - let idx0 = - arena.add_neuron(RStarTangentsAlphas::new(&p0, N_NEIGHBORS).expect("couldn't parse")); + let idx0 = arena.add_neuron(RstarNeuron::new(&p0, N_NEIGHBORS).expect("couldn't parse")); let p1 = read_points(NAMES[1]); - let idx1 = - arena.add_neuron(RStarTangentsAlphas::new(&p1, N_NEIGHBORS).expect("couldn't parse")); + let idx1 = arena.add_neuron(RstarNeuron::new(&p1, N_NEIGHBORS).expect("couldn't parse")); b.iter(|| arena.query_target(idx0, idx1, true, &None)); } @@ -370,11 +364,9 @@ fn bench_arena_query_norm(b: &mut Bencher) { fn bench_arena_query_geom(b: &mut Bencher) { let mut arena = NblastArena::new(get_score_fn(), false); let p0 = read_points(NAMES[0]); - let idx0 = - arena.add_neuron(RStarTangentsAlphas::new(&p0, N_NEIGHBORS).expect("couldn't parse")); + let idx0 = arena.add_neuron(RstarNeuron::new(&p0, N_NEIGHBORS).expect("couldn't parse")); let p1 = read_points(NAMES[1]); - let idx1 = - arena.add_neuron(RStarTangentsAlphas::new(&p1, N_NEIGHBORS).expect("couldn't parse")); + let idx1 = arena.add_neuron(RstarNeuron::new(&p1, N_NEIGHBORS).expect("couldn't parse")); b.iter(|| arena.query_target(idx0, idx1, false, &Some(nblast::Symmetry::GeometricMean))); } @@ -382,11 +374,9 @@ fn bench_arena_query_geom(b: &mut Bencher) { fn bench_arena_query_norm_geom(b: &mut Bencher) { let mut arena = NblastArena::new(get_score_fn(), false); let p0 = read_points(NAMES[0]); - let idx0 = - arena.add_neuron(RStarTangentsAlphas::new(&p0, N_NEIGHBORS).expect("couldn't parse")); + let idx0 = arena.add_neuron(RstarNeuron::new(&p0, N_NEIGHBORS).expect("couldn't parse")); let p1 = read_points(NAMES[1]); - let idx1 = - arena.add_neuron(RStarTangentsAlphas::new(&p1, N_NEIGHBORS).expect("couldn't parse")); + let idx1 = arena.add_neuron(RstarNeuron::new(&p1, N_NEIGHBORS).expect("couldn't parse")); b.iter(|| arena.query_target(idx0, idx1, true, &Some(nblast::Symmetry::GeometricMean))); } @@ -397,9 +387,7 @@ fn bench_all_to_all_serial_rstar(b: &mut Bencher) { for name in NAMES.iter() { let points = read_points(name); idxs.push( - arena.add_neuron( - RStarTangentsAlphas::new(&points, N_NEIGHBORS).expect("couldn't parse"), - ), + arena.add_neuron(RstarNeuron::new(&points, N_NEIGHBORS).expect("couldn't parse")), ); } @@ -411,7 +399,7 @@ fn bench_all_to_all_serial_nabo(b: &mut Bencher) { let mut idxs = Vec::new(); for name in NAMES.iter() { let points = read_points(name); - idxs.push(arena.add_neuron(NaboTangentsAlphas::new(points, N_NEIGHBORS))); + idxs.push(arena.add_neuron(NaboNeuron::new(points, N_NEIGHBORS))); } b.iter(|| arena.queries_targets(&idxs, &idxs, false, &None, None)); @@ -422,7 +410,7 @@ fn bench_all_to_all_serial_kiddo(b: &mut Bencher) { let mut idxs = Vec::new(); for name in NAMES.iter() { let points = read_points(name); - idxs.push(arena.add_neuron(KiddoTangentsAlphas::new(points, N_NEIGHBORS).unwrap())); + idxs.push(arena.add_neuron(KiddoNeuron::new(points, N_NEIGHBORS).unwrap())); } b.iter(|| arena.queries_targets(&idxs, &idxs, false, &None, None)); @@ -433,7 +421,7 @@ fn bench_all_to_all_serial_exact_kiddo(b: &mut Bencher) { let mut idxs = Vec::new(); for name in NAMES.iter() { let points = read_points(name); - idxs.push(arena.add_neuron(ExactKiddoTangentsAlphas::new(points, N_NEIGHBORS).unwrap())); + idxs.push(arena.add_neuron(ExactKiddoNeuron::new(points, N_NEIGHBORS).unwrap())); } b.iter(|| arena.queries_targets(&idxs, &idxs, false, &None, None)); @@ -444,7 +432,7 @@ fn bench_all_to_all_serial_bosque(b: &mut Bencher) { let mut idxs = Vec::new(); for name in NAMES.iter() { let points = read_points(name); - idxs.push(arena.add_neuron(BosqueTangentsAlphas::new(points, N_NEIGHBORS).unwrap())); + idxs.push(arena.add_neuron(BosqueNeuron::new(points, N_NEIGHBORS).unwrap())); } b.iter(|| arena.queries_targets(&idxs, &idxs, false, &None, None)); @@ -457,20 +445,18 @@ fn bench_all_to_all_parallel(b: &mut Bencher) { for name in NAMES.iter() { let points = read_points(name); idxs.push( - arena.add_neuron( - RStarTangentsAlphas::new(&points, N_NEIGHBORS).expect("couldn't parse"), - ), + arena.add_neuron(RstarNeuron::new(&points, N_NEIGHBORS).expect("couldn't parse")), ); } b.iter(|| arena.queries_targets(&idxs, &idxs, false, &None, None)); } -fn make_smatb_kiddo() -> ScoreMatrixBuilder { +fn make_smatb_kiddo() -> ScoreMatrixBuilder { let (all_points, matches, nonmatches) = match_nonmatch(10); let neurons: Vec<_> = all_points .into_iter() - .map(|ps| ExactKiddoTangentsAlphas::new(ps, N_NEIGHBORS).unwrap()) + .map(|ps| ExactKiddoNeuron::new(ps, N_NEIGHBORS).unwrap()) .collect(); let mut smatb = ScoreMatrixBuilder::new(neurons.clone(), 1991); diff --git a/nblast-rs/src/lib.rs b/nblast-rs/src/lib.rs index 00a8d90..94f9be7 100644 --- a/nblast-rs/src/lib.rs +++ b/nblast-rs/src/lib.rs @@ -50,7 +50,7 @@ //! Both are [Neuron](trait.Neuron.html)s. //! //! [PointsTangentsAlphas](struct.PointsTangentsAlphas.html) and -//! [RStarTangentsAlphas](struct.RStarTangentsAlphas.html) implement these, respectively. +//! [RstarNeuron](struct.RstarNeuron.html) implement these, respectively. //! Both can be created with pre-calculated tangents and alphas, or calculate them on instantiation. //! //! The [NblastArena](struct.NblastArena.html) contains a collection of `TargetNeuron`s @@ -523,6 +523,14 @@ pub enum ScoreCalc { } impl ScoreCalc { + /// Construct a table from `N` dist bins, `M` dot bins, + /// and the values in `(N-1)*(M-1)` cells. + /// + /// The bins vecs must be monotonically increasing. + /// The first and last values of each + /// are effectively ignored and replaced by -inf and +inf respectively. + /// Values are given in dot-major order, i.e. + /// cells in the same dist bin are next to each other. pub fn table_from_bins( dists: Vec, dots: Vec, @@ -534,6 +542,7 @@ impl ScoreCalc { )?)) } + /// Apply the score function. pub fn calc(&self, dist_dot: &DistDot) -> Precision { match self { // Self::Func(func) => func(dist_dot), @@ -1068,8 +1077,8 @@ mod test { // let q_points = make_points(&[0., 0., 0.], &[1.0, 0.0, 0.0], 10); // let query = PointsTangentsAlphas::new(q_points.clone(), N_NEIGHBORS) // .expect("Query construction failed"); - // let query2 = RStarTangentsAlphas::new(&q_points, N_NEIGHBORS).expect("Construction failed"); - // let target = RStarTangentsAlphas::new( + // let query2 = RstarNeuron::new(&q_points, N_NEIGHBORS).expect("Construction failed"); + // let target = RstarNeuron::new( // &make_points(&[0.5, 0., 0.], &[1.1, 0., 0.], 10), // N_NEIGHBORS, // ) @@ -1173,7 +1182,7 @@ mod test { // #[test] // fn alpha_changes_results() { // let (points, _, _) = tangent_data(); - // let neuron = RStarTangentsAlphas::new(points, N_NEIGHBORS).unwrap(); + // let neuron = RstarNeuron::new(points, N_NEIGHBORS).unwrap(); // let score_calc = ScoreCalc::Func(Box::new(|dd: &DistDot| dd.dot)); // let sh = neuron.self_hit(&score_calc, false); diff --git a/nblast-rs/src/neurons/bosque.rs b/nblast-rs/src/neurons/bosque.rs index 677cd7e..37c7fd1 100644 --- a/nblast-rs/src/neurons/bosque.rs +++ b/nblast-rs/src/neurons/bosque.rs @@ -5,12 +5,12 @@ use crate::{ use bosque::tree::{build_tree, build_tree_with_indices, nearest_k, nearest_one}; #[derive(Debug, Clone, PartialEq)] -pub struct BosqueTangentsAlphas { +pub struct BosqueNeuron { points: Vec, tangents_alphas: Vec, } -impl BosqueTangentsAlphas { +impl BosqueNeuron { pub fn new(mut points: Vec, k: usize) -> Result { if points.len() < k { return Err("Not enough points to calculate neighborhood"); @@ -54,7 +54,7 @@ impl BosqueTangentsAlphas { } } -impl NblastNeuron for BosqueTangentsAlphas { +impl NblastNeuron for BosqueNeuron { fn len(&self) -> usize { self.points.len() } @@ -72,7 +72,7 @@ impl NblastNeuron for BosqueTangentsAlphas { } } -impl QueryNeuron for BosqueTangentsAlphas { +impl QueryNeuron for BosqueNeuron { fn query_dist_dots<'a>( &'a self, target: &'a impl crate::TargetNeuron, @@ -118,7 +118,7 @@ impl QueryNeuron for BosqueTangentsAlphas { } } -impl TargetNeuron for BosqueTangentsAlphas { +impl TargetNeuron for BosqueNeuron { fn nearest_match_dist_dot( &self, point: &Point3, @@ -153,15 +153,15 @@ mod tests { #[cfg(feature = "kiddo")] #[test] fn expected_idxs() { - use crate::neurons::kiddo::ExactKiddoTangentsAlphas; + use crate::neurons::kiddo::ExactKiddoNeuron; let mut rng = Rng::with_seed(1991); let pts = random_points(100, &mut rng); - let t_kid = ExactKiddoTangentsAlphas::new(pts.clone(), 5).unwrap(); - let b_kid = BosqueTangentsAlphas::new(pts, 5).unwrap(); + let t_kid = ExactKiddoNeuron::new(pts.clone(), 5).unwrap(); + let b_kid = BosqueNeuron::new(pts, 5).unwrap(); let pts2 = random_points(5, &mut rng); - let query = ExactKiddoTangentsAlphas::new(pts2, 5).unwrap(); + let query = ExactKiddoNeuron::new(pts2, 5).unwrap(); let t_res: Vec<_> = query.query_dist_dots(&t_kid, false).collect(); let b_res: Vec<_> = query.query_dist_dots(&b_kid, false).collect(); diff --git a/nblast-rs/src/neurons/kiddo.rs b/nblast-rs/src/neurons/kiddo.rs index f1f737b..8df572e 100644 --- a/nblast-rs/src/neurons/kiddo.rs +++ b/nblast-rs/src/neurons/kiddo.rs @@ -9,14 +9,14 @@ type KdTree = ImmutableKdTree; /// /// By default, this uses approximate nearest neighbour for one-off lookups (as used in NBLAST scoring). /// However, in tests it is *very* approximate. -/// See the [ExactKiddoTangentsAlphas] for exact 1NN. +/// See the [ExactKiddoNeuron] for exact 1NN. #[derive(Clone, Debug)] -pub struct KiddoTangentsAlphas { +pub struct KiddoNeuron { tree: KdTree, points_tangents_alphas: Vec<(Point3, TangentAlpha)>, } -impl KiddoTangentsAlphas { +impl KiddoNeuron { /// Calculate tangents from constructed R*-tree. /// `k` is the number of points to calculate each tangent with. pub fn new(points: Vec, k: usize) -> Result { @@ -82,7 +82,7 @@ impl KiddoTangentsAlphas { } } -impl NblastNeuron for KiddoTangentsAlphas { +impl NblastNeuron for KiddoNeuron { fn len(&self) -> usize { self.points_tangents_alphas.len() } @@ -100,7 +100,7 @@ impl NblastNeuron for KiddoTangentsAlphas { } } -impl QueryNeuron for KiddoTangentsAlphas { +impl QueryNeuron for KiddoNeuron { fn query_dist_dots<'a>( &'a self, target: &'a impl TargetNeuron, @@ -138,7 +138,7 @@ impl QueryNeuron for KiddoTangentsAlphas { } } -impl TargetNeuron for KiddoTangentsAlphas { +impl TargetNeuron for KiddoNeuron { fn nearest_match_dist_dot( &self, point: &Point3, @@ -150,13 +150,13 @@ impl TargetNeuron for KiddoTangentsAlphas { } #[derive(Debug, Clone)] -pub struct ExactKiddoTangentsAlphas(KiddoTangentsAlphas); +pub struct ExactKiddoNeuron(KiddoNeuron); -impl ExactKiddoTangentsAlphas { +impl ExactKiddoNeuron { /// Calculate tangents from constructed R*-tree. /// `k` is the number of points to calculate each tangent with. pub fn new(points: Vec, k: usize) -> Result { - KiddoTangentsAlphas::new(points, k).map(Self) + KiddoNeuron::new(points, k).map(Self) } /// Use pre-calculated tangents. @@ -164,11 +164,11 @@ impl ExactKiddoTangentsAlphas { points: Vec, tangents_alphas: Vec, ) -> Result { - KiddoTangentsAlphas::new_with_tangents_alphas(points, tangents_alphas).map(Self) + KiddoNeuron::new_with_tangents_alphas(points, tangents_alphas).map(Self) } } -impl NblastNeuron for ExactKiddoTangentsAlphas { +impl NblastNeuron for ExactKiddoNeuron { fn len(&self) -> usize { self.0.len() } @@ -186,7 +186,7 @@ impl NblastNeuron for ExactKiddoTangentsAlphas { } } -impl QueryNeuron for ExactKiddoTangentsAlphas { +impl QueryNeuron for ExactKiddoNeuron { fn query_dist_dots<'a>( &'a self, target: &'a impl TargetNeuron, @@ -200,7 +200,7 @@ impl QueryNeuron for ExactKiddoTangentsAlphas { } } -impl TargetNeuron for ExactKiddoTangentsAlphas { +impl TargetNeuron for ExactKiddoNeuron { fn nearest_match_dist_dot( &self, point: &Point3, diff --git a/nblast-rs/src/neurons/mod.rs b/nblast-rs/src/neurons/mod.rs index bbbff4f..3edd0dd 100644 --- a/nblast-rs/src/neurons/mod.rs +++ b/nblast-rs/src/neurons/mod.rs @@ -1,4 +1,8 @@ //! Neurites which can be queried against each other. +//! +//! Spatial lookups are the slowest part of NBLAST. +//! As such, there are [NblastNeuron] implementations here using a number of different backends selected at compile time using cargo features. +//! [Neuron] is a convenient type alias for our recommended backend given those available. use crate::{centroid, DistDot, Normal3, Point3, Precision, ScoreCalc}; #[cfg(feature = "bosque")] @@ -12,13 +16,13 @@ pub mod rstar; cfg_if::cfg_if! { if #[cfg(feature = "kiddo")] { - pub type Neuron = self::kiddo::ExactKiddoTangentsAlphas; + pub type Neuron = self::kiddo::ExactKiddoNeuron; } else if #[cfg(feature = "bosque")] { - pub type Neuron = self::bosque::BosqueTangentsAlphas; + pub type Neuron = self::bosque::BosqueNeuron; } else if #[cfg(feature = "rstar")] { - pub type Neuron = self::rstar::RStarTangentsAlphas; + pub type Neuron = self::rstar::RstarNeuron; } else if #[cfg(feature = "nabo")] { - pub type Neuron = self::nabo::NaboTangentsAlphas; + pub type Neuron = self::nabo::NaboNeuron; } else { compile_error!("No spatial query backend selected"); } @@ -56,7 +60,7 @@ pub trait NblastNeuron { /// Trait for objects which can be used as queries /// (not necessarily as targets) with NBLAST. -/// See [TargetNeuron](trait.TargetNeuron.html). +/// See [TargetNeuron]. pub trait QueryNeuron: NblastNeuron { /// Calculate the distance and (alpha-scaled) absolute dot products for point matches /// between this and a target neuron. diff --git a/nblast-rs/src/neurons/nabo.rs b/nblast-rs/src/neurons/nabo.rs index 0440e0a..18e4381 100644 --- a/nblast-rs/src/neurons/nabo.rs +++ b/nblast-rs/src/neurons/nabo.rs @@ -91,12 +91,12 @@ fn points_to_nabo_tangents_alphas( } /// Target neuron using a KDTree from the nabo crate -pub struct NaboTangentsAlphas { +pub struct NaboNeuron { tree: KDTree, points_tangents_alphas: Vec<(Point3, TangentAlpha)>, } -impl NaboTangentsAlphas { +impl NaboNeuron { /// Calculate tangents from constructed R*-tree. /// `k` is the number of points to calculate each tangent with. pub fn new(points: Vec, k: usize) -> Self { @@ -120,7 +120,7 @@ impl NaboTangentsAlphas { } } -impl NblastNeuron for NaboTangentsAlphas { +impl NblastNeuron for NaboNeuron { fn len(&self) -> usize { self.points_tangents_alphas.len() } @@ -138,7 +138,7 @@ impl NblastNeuron for NaboTangentsAlphas { } } -impl QueryNeuron for NaboTangentsAlphas { +impl QueryNeuron for NaboNeuron { fn query_dist_dots<'a>( &'a self, target: &'a impl TargetNeuron, @@ -176,7 +176,7 @@ impl QueryNeuron for NaboTangentsAlphas { } } -impl TargetNeuron for NaboTangentsAlphas { +impl TargetNeuron for NaboNeuron { fn nearest_match_dist_dot( &self, point: &Point3, diff --git a/nblast-rs/src/neurons/rstar.rs b/nblast-rs/src/neurons/rstar.rs index 7c91842..e2b0df0 100644 --- a/nblast-rs/src/neurons/rstar.rs +++ b/nblast-rs/src/neurons/rstar.rs @@ -40,12 +40,12 @@ pub(crate) fn points_to_rtree_tangents_alphas( /// Target neuron using an [R*-tree](https://en.wikipedia.org/wiki/R*_tree) for spatial queries. #[derive(Clone)] -pub struct RStarTangentsAlphas { +pub struct RstarNeuron { rtree: RTree, tangents_alphas: Vec, } -impl RStarTangentsAlphas { +impl RstarNeuron { /// Calculate tangents from constructed R*-tree. /// `k` is the number of points to calculate each tangent with. pub fn new>( @@ -56,7 +56,7 @@ impl RStarTangentsAlphas { k: usize, ) -> Result { points_to_rtree_tangents_alphas(points.into_iter(), k).map(|(rtree, tangents_alphas)| { - RStarTangentsAlphas { + RstarNeuron { rtree, tangents_alphas, } @@ -86,7 +86,7 @@ impl RStarTangentsAlphas { } } -impl NblastNeuron for RStarTangentsAlphas { +impl NblastNeuron for RstarNeuron { fn len(&self) -> usize { self.tangents_alphas.len() } @@ -104,7 +104,7 @@ impl NblastNeuron for RStarTangentsAlphas { } } -impl QueryNeuron for RStarTangentsAlphas { +impl QueryNeuron for RstarNeuron { fn query_dist_dots<'a>( &'a self, target: &'a impl TargetNeuron, @@ -162,7 +162,7 @@ impl QueryNeuron for RStarTangentsAlphas { } } -impl TargetNeuron for RStarTangentsAlphas { +impl TargetNeuron for RstarNeuron { fn nearest_match_dist_dot( &self, point: &Point3,