Stop exporting units via geometry crate and exports mod

geometry/src/lib.rs

@@ -3,7 +3,5 @@ mod vector;
 
 pub use point::{Point, RatioPoint};
 pub use vector::{Vector, RatioVec};
-pub use units::Quantity;
-pub use units::{Angle, TWOPI, Length, Time, Velocity, Ratio, PerLength, AreaPerMass};
 
 pub mod mix;

geometry/src/point.rs

@@ -1,5 +1,5 @@
 use std::ops::{Add, AddAssign, Index, Sub, IndexMut};
-use crate::{Length, Ratio};
+use units::{Length, Ratio};
 use crate::{Vector, RatioVec};
 
 #[derive(Clone, Copy, Debug, PartialEq)]

src/bin/foms.rs

@@ -25,13 +25,12 @@ pub struct Cli {
 
 // --------------------------------------------------------------------------------
 use std::error::Error;
+use units::{Length, mm, mm_};
 use petalo::{fom::{InRoiFn, PointValue}, io::raw::Image3D};
 use petalo::Intensityf32;
-use petalo::{Length};
 use petalo::image::Image;
 use petalo::fom;
 use petalo::fom::{Sphere, ROI, centres_of_slices_closest_to};
-use units::{mm, mm_};
 
 fn main() -> Result<(), Box<dyn Error>> {
     let args = Cli::from_args();

src/bin/imageprimaries.rs

@@ -32,8 +32,7 @@ pub struct Cli {
 
 use std::error::Error;
 use petalo::Lengthf32;
-use petalo::Length;
-use units::{mm, mm_};
+use units::{Length, mm, mm_};
 use petalo::fov::FOV;
 use petalo::image::Image;
 use petalo::io::hdf5::{read_table, Primary};

src/bin/make_sensitivity_image.rs

@@ -42,8 +42,7 @@ use std::path::PathBuf;
 use petalo::{utils::group_digits, fov::FOV, Lengthf32};
 use petalo::image::Image;
 
-use petalo::{Length, Time, AreaPerMass};
-use units::{ratio, kg, mm};
+use units::{Length, Time, AreaPerMass, ratio, kg, mm};
 use units::uom::ConstZero;
 use petalo::system_matrix as sm;
 

src/bin/makelor.rs

@@ -2,10 +2,11 @@ use std::path::{Path, PathBuf};
 use structopt::StructOpt;
 use itertools::Itertools;
 use indicatif::{ProgressBar, ProgressStyle};
+use units::{Length, Time, Ratio};
+use petalo::Point;
 use petalo::io;
 use petalo::io::hdf5::{SensorXYZ, Hdf5Lor};
 use petalo::Energyf32;
-use petalo::{Length, Time, Point, Ratio};
 use units::mmps::f32::Area;
 use units::uom::ConstZero;
 use petalo::utils::group_digits;

src/bin/mlem.rs

@@ -32,13 +32,12 @@ use std::error::Error;
 use std::path::PathBuf;
 use std::fs::create_dir_all;
 
-use petalo::Length;
+use units::{Length, mm_};
 use petalo::lorogram::Scattergram;
 use petalo::fov::FOV;
 use petalo::image::Image;
 use petalo::io;
 use petalo::utils::timing::Progress;
-use units::mm_;
 
 
 fn main() -> Result<(), Box<dyn Error>> {

src/bin/vislor.rs

@@ -2,8 +2,8 @@ use std::error::Error;
 use std::path::PathBuf;
 use structopt::StructOpt;
 
+use units::{Time, Ratio};
 use petalo::Lengthf32;
-use petalo::{Time, Ratio};
 use petalo::{system_matrix::LOR, fov::FOV};
 use petalo::visualize::{lor_weights, Shape};
 

src/config/mlem.rs

@@ -6,8 +6,7 @@ use std::path::PathBuf;
 
 use serde::{Deserialize, Deserializer, de};
 
-
-use crate::{Length, Ratio, Time};
+use units::{Length, Ratio, Time};
 
 #[cfg(test)]
 fn deserialize_uom_opt<'d, D, T>(deserializer: D) -> Result<Option<T>, D::Error>

src/exports.rs

@@ -4,29 +4,14 @@ use ncollide3d as nc;
 
 pub use units::uom::si::Quantity;
 pub use units::uom::typenum::{Z0, N1};
-use units::in_base_unit;
 
-pub type Lengthf32  = f32;
-pub use geometry::Length;
-
-pub type PerLength = geometry::PerLength;
-
-pub type Timef32 = f32;
-pub use geometry::Time;
-
-pub type Velocity = geometry::Velocity;
-
-pub type Weightf32 = f32;  // TODO uom Weight
-
-pub type Ratiof32 = f32;
-pub use geometry::Ratio;
-
-pub use geometry::{Angle, TWOPI};
+pub type Lengthf32 = f32;
+pub type Timef32   = f32;
+pub type Weightf32 = f32; // TODO uom Weight
+pub type Ratiof32  = f32;
 pub type Anglef32  = f32; // TODO eliminate
-
 pub type Energyf32 = f32; // TODO uom Energy
 pub type Chargef32 = f32; // TODO uom Charge
-
 pub type Intensityf32 = f32; // TODO uom Intensity
 
 pub use geometry::RatioVec;
@@ -40,24 +25,3 @@ pub type Point    = geometry::Point;
 pub use crate::index::{BoxDim_u, Index1_u, Index3_u, Index3Weightf32, LengthI, LengthU};
 
 pub type BoundPair<T> = (std::ops::Bound<T>, std::ops::Bound<T>);
-
-pub use geometry::AreaPerMass;
-
-
-#[allow(clippy::excessive_precision)]
-pub const C: Velocity = in_base_unit!(0.299_792_458);
-// `f32` will truncate this to        0.299_792_47
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use units::{m_s_, mm_ps_};
-    use float_eq::assert_float_eq;
-
-    #[test]
-    fn test_speed_of_light() {
-        println!("C visual check: {:?}", C);
-        assert_float_eq!(  m_s_(C),   299_792_458.0, ulps <= 1);
-        assert_float_eq!(mm_ps_(C), 0.299_792_458  , ulps <= 1);
-    }
-}

src/fom.rs

@@ -1,7 +1,6 @@
+use units::{Length, Quantity};
 use crate::io::raw;
-use crate::{Intensityf32, Ratiof32};
-use crate::{Length, Point};
-use geometry::Quantity;
+use crate::{Point, Intensityf32, Ratiof32};
 use units::ratio_;
 use crate::image::{Image, ImageData};
 use crate::fov::FOV;

src/fov.rs

@@ -1,10 +1,10 @@
 /// The size and granularity of the Field of View (FOV) in which images should
 /// be reconstructed
 
+use units::{Length, mm_};
 use crate::{Lengthf32, Pointf32};
-use crate::{Length, Point, Vector, LOR, find_tof_peak, find_entry_point, voxel_size, first_boundaries};
+use crate::{Point, Vector, LOR, find_tof_peak, find_entry_point, voxel_size, first_boundaries};
 use crate::index::{BoxDim_u, Index3_u, Index1_u, index1_to_3, index3_to_1};
-use units::mm_;
 use geometry::RatioPoint;
 use uom::ConstZero;
 

src/gauss.rs

@@ -1,8 +1,7 @@
-use crate::{Angle, Length, PerLength, Ratio, TWOPI, C};
-use crate::config::mlem::Tof;
-
+use units::{Angle, Length, PerLength, Ratio, TWOPI, C, mm};
 use units::uom::ConstZero; // num_traits::Zero;
-use units::mm;
+
+use crate::config::mlem::Tof;
 
 // How would you make this generic over Length -> T ?
 fn make_gauss(sigma: Length, cutoff: Option<Ratio>) -> impl Fn(Length) -> PerLength {

src/lorogram.rs

@@ -8,7 +8,7 @@ use crate::system_matrix::LOR;
 use std::f32::consts::TAU;
 
 use crate::Lengthf32;
-use crate::{Angle, Length, Time, Ratio};
+use units::{Angle, Length, Time, Ratio};
 use units::{mm, mm_, ps_, ratio, radian_, turn};
 
 

src/lorogram/build_scattergram.rs

@@ -1,6 +1,5 @@
-use crate::{Length, Time};
+use units::{Length, Time, mm, ps};
 use crate::lorogram::Scattergram;
-use units::{mm, ps};
 
 pub struct BuildScattergram {
     phi_bins: Option<usize>,

src/mlem.rs

@@ -3,8 +3,8 @@ use ndarray::azip;
 
 use rayon::prelude::*;
 
+use units::{Length, PerLength, AreaPerMass};
 use crate::{io, Lengthf32, Index1_u, Intensityf32};
-use crate::{Length, PerLength, AreaPerMass};
 use crate::{fov::{lor_fov_hit, FovHit}, system_matrix::{system_matrix_elements, LOR}};
 use crate::fov::FOV;
 use crate::gauss::make_gauss_option;

src/system_matrix.rs

@@ -13,13 +13,12 @@
 //!    indices calculated by the algorithm, must be flipped back to the original
 //!    coordinate system.
 
-use units::in_base_unit;
+use units::{C, Length, Ratio, PerLength, Time, in_base_unit};
+use units::{mm, mm_, ns_, ratio_};
 use crate::{Index3Weightf32, Lengthf32};
-use crate::{Length, PerLength, Time, C,
-            Point, Vector, Ratio, RatioPoint, RatioVec};
+use crate::{Point, Vector, RatioPoint, RatioVec};
 use crate::fov::FOV;
 
-use units::{mm, mm_, ns_, ratio_};
 use crate::gauss::make_gauss_option;
 use crate::index::index1_to_3;
 use crate::config::mlem::Tof;
@@ -33,8 +32,7 @@ mod test {
     use super::*;
     #[allow(unused)] use pretty_assertions::{assert_eq, assert_ne};
     use rstest::rstest;
-    use crate::TWOPI;
-    use units::ratio;
+    use units::{TWOPI, ratio};
 
     // --------------------------------------------------------------------------------
     // This set of hand-picked values should be easy to verify by humans. The

src/utils.rs

@@ -1,8 +1,8 @@
 use std::error::Error;
 use std::ops::{Bound, Range};
 
-use crate::{Timef32, Lengthf32, BoundPair};
-use crate::{Point, Ratio};
+use units::Ratio;
+use crate::{Point, Timef32, Lengthf32, BoundPair};
 use crate::system_matrix::LOR;
 use units::{mm, ns, ratio};
 

units/src/lib.rs

@@ -162,3 +162,22 @@ mod tests {
         assert_uom_eq!(nanometer, total, mm(11.0), ulps <= 1);
     }
 }
+
+
+
+#[allow(clippy::excessive_precision)]
+pub const C: Velocity = in_base_unit!(0.299_792_458);
+// `f32` will truncate this to        0.299_792_47
+
+#[cfg(test)]
+mod test_speed_of_light {
+    use super::*;
+    use float_eq::assert_float_eq;
+
+    #[test]
+    fn test_speed_of_light() {
+        println!("C visual check: {:?}", C);
+        assert_float_eq!(  m_s_(C),   299_792_458.0, ulps <= 1);
+        assert_float_eq!(mm_ps_(C), 0.299_792_458  , ulps <= 1);
+    }
+}