geometry: rename Aabb and Mbr

to BoundingBox and OrientedBoundingBox

also make the BoundingBox fields public for simplicity.

Author: hhirtz

src/algorithms/hilbert_curve.rs

@@ -10,7 +10,8 @@
 //!
 //! The complexity of encoding a point is O(order)
 
-use crate::geometry::{Mbr, Point2D};
+use crate::geometry::OrientedBoundingBox;
+use crate::Point2D;
 use rayon::prelude::*;
 use std::fmt;
 
@@ -97,14 +98,12 @@ fn segment_to_segment(min: f64, max: f64, order: usize) -> impl Fn(f64) -> u64 {
 }
 
 fn hilbert_index_computer(points: &[Point2D], order: usize) -> impl Fn(&Point2D) -> u64 {
-    let mbr = Mbr::from_points(points);
+    let mbr = OrientedBoundingBox::from_points(points);
     let aabb = mbr.aabb();
-    let p_min = aabb.p_min();
-    let p_max = aabb.p_max();
-    let x_mapping = segment_to_segment(p_min.x, p_max.x, order);
-    let y_mapping = segment_to_segment(p_min.y, p_max.y, order);
+    let x_mapping = segment_to_segment(aabb.p_min.x, aabb.p_max.x, order);
+    let y_mapping = segment_to_segment(aabb.p_min.y, aabb.p_max.y, order);
     move |p| {
-        let p = mbr.mbr_to_aabb(p);
+        let p = mbr.obb_to_aabb(p);
         encode(x_mapping(p.x), y_mapping(p.y), order)
     }
 }

src/algorithms/k_means.rs

@@ -2,8 +2,9 @@
 //! "Balanced k-means for Parallel Geometric Partitioning" by Moritz von Looz,
 //! Charilaos Tzovas and Henning Meyerhenke (2018, University of Cologne)
 
-use crate::geometry::Mbr;
-use crate::geometry::{self, PointND};
+use crate::geometry;
+use crate::geometry::OrientedBoundingBox;
+use crate::PointND;
 use nalgebra::allocator::Allocator;
 use nalgebra::ArrayStorage;
 use nalgebra::Const;
@@ -315,7 +316,7 @@ fn assign_and_balance<const D: usize>(
     } = clusters;
     // compute the distances from each cluster center to the minimal
     // bounding rectangle of the set of points
-    let mbr = Mbr::from_points(points);
+    let mbr = OrientedBoundingBox::from_points(points);
     let distances_to_mbr = centers
         .par_iter()
         .zip(influences.par_iter())

src/algorithms/recursive_bisection.rs

@@ -1,5 +1,5 @@
 use super::Error;
-use crate::geometry::Mbr;
+use crate::geometry::OrientedBoundingBox;
 use crate::geometry::PointND;
 use async_lock::Mutex;
 use async_lock::MutexGuard;
@@ -892,8 +892,8 @@ where
     W::Item: RcbWeight,
     W::Iter: rayon::iter::IndexedParallelIterator,
 {
-    let mbr = Mbr::from_points(points);
-    let points = points.par_iter().map(|p| mbr.mbr_to_aabb(p));
+    let mbr = OrientedBoundingBox::from_points(points);
+    let points = points.par_iter().map(|p| mbr.obb_to_aabb(p));
     // When the rotation is done, we just apply RCB
     simple_rcb(partition, points, weights, n_iter, tolerance)
 }

src/algorithms/z_curve.rs

@@ -17,7 +17,8 @@
 //! Finally, the points are reordered according to the order of their hash.
 
 use super::multi_jagged::split_at_mut_many;
-use crate::geometry::{Mbr, PointND};
+use crate::geometry::OrientedBoundingBox;
+use crate::PointND;
 
 use nalgebra::allocator::Allocator;
 use nalgebra::ArrayStorage;
@@ -54,8 +55,8 @@ fn z_curve_partition<const D: usize>(
         max_order,
     );
 
-    // Mbr used to construct Point hashes
-    let mbr = Mbr::from_points(points);
+    // Bounding box used to construct Point hashes
+    let mbr = OrientedBoundingBox::from_points(points);
 
     let mut permutation: Vec<_> = (0..points.len()).into_par_iter().collect();
 
@@ -90,7 +91,7 @@ fn z_curve_partition<const D: usize>(
 fn z_curve_partition_recurse<const D: usize>(
     points: &[PointND<D>],
     order: u32,
-    mbr: &Mbr<D>,
+    mbr: &OrientedBoundingBox<D>,
     permu: &mut [usize],
 ) {
     // we stop recursion if there is only 1 point left to avoid useless calls
@@ -164,7 +165,7 @@ pub(crate) fn z_curve_reorder_permu<const D: usize>(
     DefaultAllocator: Allocator<f64, Const<D>, Const<D>, Buffer = ArrayStorage<f64, D, D>>
         + Allocator<f64, DimDiff<Const<D>, Const<1>>>,
 {
-    let mbr = Mbr::from_points(points);
+    let mbr = OrientedBoundingBox::from_points(points);
     let hashes = permu
         .par_iter()
         .map(|idx| compute_hash(&points[*idx], order, &mbr))
@@ -173,7 +174,11 @@ pub(crate) fn z_curve_reorder_permu<const D: usize>(
     permu.par_sort_by_key(|idx| hashes[*idx]);
 }
 
-fn compute_hash<const D: usize>(point: &PointND<D>, order: u32, mbr: &Mbr<D>) -> HashType {
+fn compute_hash<const D: usize>(
+    point: &PointND<D>,
+    order: u32,
+    mbr: &OrientedBoundingBox<D>,
+) -> HashType {
     let current_hash = mbr
         .region(point)
         .expect("Cannot compute the z-hash of a point outside of the current Mbr.");