engeom 0.2.9__tar.gz → 0.2.11__tar.gz

{engeom-0.2.9 → engeom-0.2.11}/Cargo.lock

@@ -231,7 +231,7 @@ dependencies = [
 
 [[package]]
 name = "engeom"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "faer",
  "itertools 0.14.0",
@@ -1025,7 +1025,7 @@ dependencies = [
 
 [[package]]
 name = "py-engeom"
-version = "0.2.9"
+version = "0.2.11"
 dependencies = [
  "engeom",
  "numpy",

{engeom-0.2.9 → engeom-0.2.11}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "py-engeom"
-version = "0.2.9"
+version = "0.2.11"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{engeom-0.2.9 → engeom-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engeom
-Version: 0.2.9
+Version: 0.2.11
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{engeom-0.2.9 → engeom-0.2.11}/engeom/Cargo.lock

@@ -358,7 +358,7 @@ dependencies = [
 
 [[package]]
 name = "engeom"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "approx",
  "criterion",

{engeom-0.2.9 → engeom-0.2.11}/engeom/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "engeom"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 readme = "README.md"
 

{engeom-0.2.9 → engeom-0.2.11}/engeom/src/common/surface_point.rs

@@ -80,6 +80,33 @@ impl<const D: usize> SurfacePoint<D> {
         let projection = self.projection(other);
         (projection - other).norm()
     }
+
+    /// Returns a new surface point shifted from the original surface point by the given distance
+    /// along the normal. This is useful for creating a new surface point that is a certain distance
+    /// away from the original surface point, in the direction of the normal.
+    ///
+    /// # Arguments
+    ///
+    /// * `shift`: the distance to offset the surface point along the normal
+    ///
+    /// returns: SurfacePoint<{ D }>
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use engeom::{Point2, SurfacePoint2, Vector2};
+    /// use approx::assert_relative_eq;
+    ///
+    /// let sp = SurfacePoint2::new_normalize(Point2::new(0.0, 0.0), Vector2::new(0.0, 1.0));
+    ///
+    /// let shifted = sp.shift(2.0);
+    /// assert_relative_eq!(shifted.point, Point2::new(0.0, 2.0), epsilon = 1e-6);
+    /// assert_relative_eq!(shifted.normal.into_inner(), Vector2::new(0.0, 1.0), epsilon = 1e-6);
+    /// ```
+    pub fn shift(&self, offset: f64) -> Self {
+        let new_point = self.point + self.normal.as_ref() * offset;
+        Self::new(new_point, self.normal)
+    }
 }
 
 /// Created a vector of `SurfacePoint` instances from a vector of points and a vector of normals.

{engeom-0.2.9 → engeom-0.2.11}/engeom/src/geom3/curve3.rs

@@ -255,6 +255,7 @@ impl Curve3 {
         let new_points = ramer_douglas_peucker(self.line.vertices(), tol);
         Self::from_points(&new_points, tol).unwrap()
     }
+
 }
 
 fn resample_by_max_spacing(curve: &Curve3, max_spacing: f64) -> Curve3 {

engeom-0.2.11/engeom/src/geom3/iso3.rs

@@ -0,0 +1,375 @@
+//! This module has additional tools and functions for working with 3D isometries
+
+use crate::{Iso3, Point3, Result, UnitVec3, Vector3};
+use parry3d_f64::na::{try_convert, Matrix4, UnitQuaternion};
+use parry3d_f64::na::{Matrix3, Translation3};
+
+pub trait IsoExtensions3 {
+    fn flip_around_x(&self) -> Iso3;
+    fn flip_around_y(&self) -> Iso3;
+    fn flip_around_z(&self) -> Iso3;
+    fn try_from_array(array: &[f64; 16]) -> Result<Iso3>;
+
+    fn try_from_basis_xy(e0: &Vector3, e1: &Vector3, origin: Option<Point3>) -> Result<Iso3>;
+    fn try_from_basis_xz(e0: &Vector3, e2: &Vector3, origin: Option<Point3>) -> Result<Iso3>;
+    fn try_from_basis_yz(e1: &Vector3, e2: &Vector3, origin: Option<Point3>) -> Result<Iso3>;
+    fn try_from_basis_yx(e1: &Vector3, e0: &Vector3, origin: Option<Point3>) -> Result<Iso3>;
+    fn try_from_basis_zx(e2: &Vector3, e0: &Vector3, origin: Option<Point3>) -> Result<Iso3>;
+    fn try_from_basis_zy(e2: &Vector3, e1: &Vector3, origin: Option<Point3>) -> Result<Iso3>;
+
+    fn from_rx(angle: f64) -> Iso3;
+    fn from_ry(angle: f64) -> Iso3;
+    fn from_rz(angle: f64) -> Iso3;
+}
+
+impl IsoExtensions3 for Iso3 {
+    /// Rotate the isometry in place by 180 degrees around the x-axis. The location of the origin
+    /// is not changed, but the y and z directions are reversed.
+    fn flip_around_x(&self) -> Self {
+        let r = Iso3::rotation(Vector3::x() * std::f64::consts::PI);
+        self.translation * r * self.rotation
+    }
+
+    /// Rotate the isometry in place by 180 degrees around the y-axis. The location of the origin
+    /// is not changed, but the x and z directions are reversed.
+    fn flip_around_y(&self) -> Self {
+        let r = Iso3::rotation(Vector3::y() * std::f64::consts::PI);
+        self.translation * r * self.rotation
+    }
+
+    /// Rotate the isometry in place by 180 degrees around the z-axis. The location of the origin
+    /// is not changed, but the x and y directions are reversed.
+    fn flip_around_z(&self) -> Self {
+        let r = Iso3::rotation(Vector3::z() * std::f64::consts::PI);
+        self.translation * r * self.rotation
+    }
+
+    /// Try to convert a 16 element array into an Iso3. The array is expected to be in row-major
+    /// order.
+    fn try_from_array(array: &[f64; 16]) -> Result<Self> {
+        try_convert(Matrix4::from_row_slice(array)).ok_or("Could not convert to Iso3".into())
+    }
+
+    /// Try to create an isometry from two basis vectors and an optional origin. The primary basis
+    /// vector will become the x-axis in the isometry, the secondary basis vector will be projected
+    /// onto the primary and the remaining component will be the y-axis. The final axis will be
+    /// computed by cross product for a right-handed coordinate system.
+    ///
+    /// The isometry produced by this method will move a point in the basis coordinate system to
+    /// where it would be located in the world coordinate system.
+    ///
+    /// If you want to take features in the world coordinate system and move them into the basis
+    /// coordinate system, you need to use the inverse of the isometry.
+    ///
+    /// # Arguments
+    ///
+    /// * `e0`: A vector in the world coordinate system that will become the x-axis in the basis
+    ///   coordinate system, will be normalized to unit length automatically.
+    /// * `e1`: A vector in the world coordinate system whose component linearly independent of `e0`
+    ///   will become the y-axis in the basis coordinate system, will be normalized to unit length.
+    /// * `origin`: An optional point in the world coordinate system that will be the origin of the
+    ///   basis coordinate system. If not provided, the origin of the basis coordinate system will
+    ///   be coincident with the origin of the world coordinate system.
+    ///
+    /// returns: Result<Isometry<f64, Unit<Quaternion<f64>>, 3>, Box<dyn Error, Global>>
+    fn try_from_basis_xy(e0: &Vector3, e1: &Vector3, origin: Option<Point3>) -> Result<Iso3> {
+        let e0 = e0.try_normalize(1e-10).ok_or("Could not normalize e0")?;
+        let e2 = e0.cross(e1).try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        let e1 = e2.cross(&e0).try_normalize(1e-10).ok_or("Could not normalize e1")?;
+
+        from_bases(e0, e1, e2, origin)
+    }
+
+    /// Try to create an isometry from two basis vectors and an optional origin. The primary basis
+    /// vector will become the x-axis in the isometry, the secondary basis vector will be projected
+    /// onto the primary and the remaining component will be the z-axis. The final axis will be
+    /// computed by cross product for a right-handed coordinate system.
+    ///
+    /// The isometry produced by this method will move a point in the basis coordinate system to
+    /// where it would be located in the world coordinate system.
+    ///
+    /// If you want to take features in the world coordinate system and move them into the basis
+    /// coordinate system, you need to use the inverse of the isometry.
+    ///
+    /// # Arguments
+    ///
+    /// * `e0`: A vector in the world coordinate system that will become the x-axis in the basis
+    ///   coordinate system, will be normalized to unit length automatically.
+    /// * `e2`: A vector in the world coordinate system whose component linearly independent of `e0`
+    ///   will become the z-axis in the basis coordinate system, will be normalized to unit length.
+    /// * `origin`: An optional point in the world coordinate system that will be the origin of the
+    ///   basis coordinate system. If not provided, the origin of the basis coordinate system will
+    ///   be coincident with the origin of the world coordinate system.
+    ///
+    /// returns: Result<Isometry<f64, Unit<Quaternion<f64>>, 3>, Box<dyn Error, Global>>
+    fn try_from_basis_xz(e0: &Vector3, e2: &Vector3, origin: Option<Point3>) -> Result<Iso3> {
+        let e0 = e0.try_normalize(1e-10).ok_or("Could not normalize e0")?;
+        let e1 = e2.cross(&e0).try_normalize(1e-10).ok_or("Could not normalize e1")?;
+        let e2 = e0.cross(&e1).try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        from_bases(e0, e1, e2, origin)
+    }
+
+    /// Try to create an isometry from two basis vectors and an optional origin. The primary basis
+    /// vector will become the y-axis in the isometry, the secondary basis vector will be projected
+    /// onto the primary and the remaining component will be the z-axis. The final axis will be
+    /// computed by cross product for a right-handed coordinate system.
+    ///
+    /// The isometry produced by this method will move a point in the basis coordinate system to
+    /// where it would be located in the world coordinate system.
+    ///
+    /// If you want to take features in the world coordinate system and move them into the basis
+    /// coordinate system, you need to use the inverse of the isometry.
+    ///
+    /// # Arguments
+    ///
+    /// * `e1`: A vector in the world coordinate system that will become the y-axis in the basis
+    ///   coordinate system, will be normalized to unit length automatically.
+    /// * `e2`: A vector in the world coordinate system whose component linearly independent of `e1`
+    ///   will become the z-axis in the basis coordinate system, will be normalized to unit length.
+    /// * `origin`: An optional point in the world coordinate system that will be the origin of the
+    ///   basis coordinate system. If not provided, the origin of the basis coordinate system will
+    ///   be coincident with the origin of the world coordinate system.
+    ///
+    /// returns: Result<Isometry<f64, Unit<Quaternion<f64>>, 3>, Box<dyn Error, Global>>
+    fn try_from_basis_yz(e1: &Vector3, e2: &Vector3, origin: Option<Point3>) -> Result<Iso3> {
+        let e1 = e1.try_normalize(1e-10).ok_or("Could not normalize e1")?;
+        let e0 = e1.cross(&e2).try_normalize(1e-10).ok_or("Could not normalize e0")?;
+        let e2 = e0.cross(&e1).try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        from_bases(e0, e1, e2, origin)
+    }
+
+    /// Try to create an isometry from two basis vectors and an optional origin. The primary basis
+    /// vector will become the y-axis in the isometry, the secondary basis vector will be projected
+    /// onto the primary and the remaining component will be the x-axis. The final axis will be
+    /// computed by cross product for a right-handed coordinate system.
+    ///
+    /// The isometry produced by this method will move a point in the basis coordinate system to
+    /// where it would be located in the world coordinate system.
+    ///
+    /// If you want to take features in the world coordinate system and move them into the basis
+    /// coordinate system, you need to use the inverse of the isometry.
+    ///
+    /// # Arguments
+    ///
+    /// * `e1`: A vector in the world coordinate system that will become the y-axis in the basis
+    ///   coordinate system, will be normalized to unit length automatically.
+    /// * `e0`: A vector in the world coordinate system whose component linearly independent of `e1`
+    ///   will become the x-axis in the basis coordinate system, will be normalized to unit length.
+    /// * `origin`: An optional point in the world coordinate system that will be the origin of the
+    ///   basis coordinate system. If not provided, the origin of the basis coordinate system will
+    ///   be coincident with the origin of the world coordinate system.
+    ///
+    /// returns: Result<Isometry<f64, Unit<Quaternion<f64>>, 3>, Box<dyn Error, Global>>
+    fn try_from_basis_yx(e1: &Vector3, e0: &Vector3, origin: Option<Point3>) -> Result<Iso3> {
+        let e1 = e1.try_normalize(1e-10).ok_or("Could not normalize e1")?;
+        let e2 = e0.cross(&e1).try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        let e0 = e1.cross(&e2).try_normalize(1e-10).ok_or("Could not normalize e0")?;
+        from_bases(e0, e1, e2, origin)
+    }
+
+    /// Try to create an isometry from two basis vectors and an optional origin. The primary basis
+    /// vector will become the z-axis in the isometry, the secondary basis vector will be projected
+    /// onto the primary and the remaining component will be the x-axis. The final axis will be
+    /// computed by cross product for a right-handed coordinate system.
+    ///
+    /// The isometry produced by this method will move a point in the basis coordinate system to
+    /// where it would be located in the world coordinate system.
+    ///
+    /// If you want to take features in the world coordinate system and move them into the basis
+    /// coordinate system, you need to use the inverse of the isometry.
+    ///
+    /// # Arguments
+    ///
+    /// * `e2`: A vector in the world coordinate system that will become the z-axis in the basis
+    ///   coordinate system, will be normalized to unit length automatically.
+    /// * `e0`: A vector in the world coordinate system whose component linearly independent of `e2`
+    ///   will become the x-axis in the basis coordinate system, will be normalized to unit length.
+    /// * `origin`: An optional point in the world coordinate system that will be the origin of the
+    ///   basis coordinate system. If not provided, the origin of the basis coordinate system will
+    ///   be coincident with the origin of the world coordinate system.
+    ///
+    /// returns: Result<Isometry<f64, Unit<Quaternion<f64>>, 3>, Box<dyn Error, Global>>
+    fn try_from_basis_zx(e2: &Vector3, e0: &Vector3, origin: Option<Point3>) -> Result<Iso3> {
+        let e2 = e2.try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        let e1 = e2.cross(&e0).try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        let e0 = e1.cross(&e2).try_normalize(1e-10).ok_or("Could not normalize e0")?;
+        from_bases(e0, e1, e2, origin)
+    }
+
+    /// Try to create an isometry from two basis vectors and an optional origin. The primary basis
+    /// vector will become the z-axis in the isometry, the secondary basis vector will be projected
+    /// onto the primary and the remaining component will be the y-axis. The final axis will be
+    /// computed by cross product for a right-handed coordinate system.
+    ///
+    /// The isometry produced by this method will move a point in the basis coordinate system to
+    /// where it would be located in the world coordinate system.
+    ///
+    /// If you want to take features in the world coordinate system and move them into the basis
+    /// coordinate system, you need to use the inverse of the isometry.
+    ///
+    /// # Arguments
+    ///
+    /// * `e2`: A vector in the world coordinate system that will become the z-axis in the basis
+    ///   coordinate system, will be normalized to unit length automatically.
+    /// * `e1`: A vector in the world coordinate system whose component linearly independent of `e2`
+    ///   will become the y-axis in the basis coordinate system, will be normalized to unit length.
+    /// * `origin`: An optional point in the world coordinate system that will be the origin of the
+    ///   basis coordinate system. If not provided, the origin of the basis coordinate system will
+    ///   be coincident with the origin of the world coordinate system.
+    ///
+    /// returns: Result<Isometry<f64, Unit<Quaternion<f64>>, 3>, Box<dyn Error, Global>>
+    fn try_from_basis_zy(e2: &Vector3, e1: &Vector3, origin: Option<Point3>) -> Result<Iso3> {
+        let e2 = e2.try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        let e0 = e1.cross(&e2).try_normalize(1e-10).ok_or("Could not normalize e0")?;
+        let e1 = e2.cross(&e0).try_normalize(1e-10).ok_or("Could not normalize e2")?;
+        from_bases(e0, e1, e2, origin)
+    }
+
+    fn from_rx(angle: f64) -> Iso3 {
+        Iso3::rotation(Vector3::x() * angle)
+    }
+
+    fn from_ry(angle: f64) -> Iso3 {
+        Iso3::rotation(Vector3::y() * angle)
+    }
+
+    fn from_rz(angle: f64) -> Iso3 {
+        Iso3::rotation(Vector3::z() * angle)
+    }
+}
+
+fn from_bases(e0: Vector3, e1: Vector3, e2: Vector3, origin: Option<Point3>) -> Result<Iso3> {
+    let rot_m = Matrix3::from_columns(&[e0, e1, e2]);
+    let r = UnitQuaternion::from_matrix(&rot_m);
+    let t = if let Some(o) = origin {
+        Translation3::from(o.coords)
+    } else {
+        Translation3::identity()
+    };
+
+    Ok(Iso3::from_parts(t, r))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::f64::consts::PI;
+    use super::*;
+    use crate::Point3;
+    use approx::assert_relative_eq;
+
+    struct BasisCheck {
+        o: Point3,
+        e0: Vector3,
+        e1: Vector3,
+        e2: Vector3,
+        fwd: Iso3,
+    }
+
+    impl BasisCheck {
+        fn new() -> Self {
+            let o = Point3::new(1.0, 2.0, 3.0);
+            let angle = UnitVec3::new_normalize(Vector3::new(1.0, 1.0, 1.0));
+            let fwd = Iso3::from_parts(
+                Translation3::from(o.coords),
+                UnitQuaternion::new(PI / 4.0 * angle.into_inner()),
+            );
+            let e0 = fwd * Vector3::x();
+            let e1 = fwd * Vector3::y();
+            let e2 = fwd * Vector3::z();
+
+            Self { o, e0, e1, e2, fwd }
+        }
+    }
+
+    #[test]
+    fn iso3_try_from_basis_xy() -> Result<()> {
+        let check = BasisCheck::new();
+        let iso = Iso3::try_from_basis_xy(&check.e0, &check.e1, Some(check.o))?;
+        assert_relative_eq!(iso, check.fwd, epsilon = 1e-6);
+        Ok(())
+    }
+
+    #[test]
+    fn iso3_try_from_basis_xz() -> Result<()> {
+        let check = BasisCheck::new();
+        let iso = Iso3::try_from_basis_xz(&check.e0, &check.e2, Some(check.o))?;
+        assert_relative_eq!(iso, check.fwd, epsilon = 1e-6);
+        Ok(())
+    }
+
+    #[test]
+    fn iso3_try_from_basis_yx() -> Result<()> {
+        let check = BasisCheck::new();
+        let iso = Iso3::try_from_basis_yx(&check.e1, &check.e0, Some(check.o))?;
+        assert_relative_eq!(iso, check.fwd, epsilon = 1e-6);
+        Ok(())
+    }
+
+    #[test]
+    fn iso3_try_from_basis_yz() -> Result<()> {
+        let check = BasisCheck::new();
+        let iso = Iso3::try_from_basis_yz(&check.e1, &check.e2, Some(check.o))?;
+        assert_relative_eq!(iso, check.fwd, epsilon = 1e-6);
+        Ok(())
+    }
+
+    #[test]
+    fn iso3_try_from_basis_zx() -> Result<()> {
+        let check = BasisCheck::new();
+        let iso = Iso3::try_from_basis_zx(&check.e2, &check.e0, Some(check.o))?;
+        assert_relative_eq!(iso, check.fwd, epsilon = 1e-6);
+        Ok(())
+    }
+
+    #[test]
+    fn iso3_try_from_basis_zy() -> Result<()> {
+        let check = BasisCheck::new();
+        let iso = Iso3::try_from_basis_zy(&check.e2, &check.e1, Some(check.o))?;
+        assert_relative_eq!(iso, check.fwd, epsilon = 1e-6);
+        Ok(())
+    }
+
+    #[test]
+    fn iso3_try_from_basis_xy_manual() {
+        let o = Point3::new(1.0, 2.0, 3.0);
+        let e0 = UnitVec3::new_normalize(Vector3::new(1.0, 1.0, 0.0));
+        let e1 = Vector3::new(0.0, 1.0, 1.0);
+
+        let iso = Iso3::try_from_basis_xy(&e0.into_inner(), &e1, Some(o)).unwrap();
+
+        assert_relative_eq!(iso * Point3::origin(), o, epsilon = 1e-6);
+        assert_relative_eq!(
+            iso * Point3::new(1.0, 0.0, 0.0),
+            o + e0.into_inner() * 1.0,
+            epsilon = 1e-6
+        );
+    }
+
+    #[test]
+    fn iso3_try_from_array_simple() {
+        let array = [
+            1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 2.0, 0.0, 0.0, 1.0, 3.0, 0.0, 0.0, 0.0, 1.0,
+        ];
+        let iso = Iso3::try_from_array(&array).unwrap();
+        let m = iso.to_matrix();
+        let expected = Matrix4::new(
+            1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 2.0, 0.0, 0.0, 1.0, 3.0, 0.0, 0.0, 0.0, 1.0,
+        );
+        assert_relative_eq!(m, expected);
+    }
+
+    #[test]
+    fn iso3_flip_x() {
+        let iso = Iso3::new(Vector3::new(1.0, 2.0, 3.0), Vector3::new(0.0, 0.0, 0.0));
+        let flipped = iso.flip_around_x();
+
+        let p = Point3::new(0.0, 0.0, 0.0);
+        assert_relative_eq!(flipped * p, Point3::new(1.0, 2.0, 3.0));
+
+        let p1 = Point3::new(1.0, 0.0, 0.0);
+        assert_relative_eq!(flipped * p1, Point3::new(2.0, 2.0, 3.0));
+
+        let p2 = Point3::new(0.0, 1.0, 0.0);
+        assert_relative_eq!(flipped * p2, Point3::new(1.0, 1.0, 3.0));
+    }
+}

engeom-0.2.11/engeom/src/geom3/mesh/collisions.rs

@@ -0,0 +1,194 @@
+//! Mesh collision detection and distance checks
+
+use std::cmp::PartialEq;
+use crate::{Iso3, Mesh, Result};
+use std::collections::{HashMap, HashSet};
+use parry3d_f64::query::intersection_test;
+
+#[derive(Debug, Clone, PartialEq)]
+enum MeshType {
+    Stationary,
+    Moving,
+}
+
+struct MeshItem {
+    mesh: Mesh,
+    mesh_type: MeshType,
+}
+
+pub struct MeshCollisionSet {
+    meshes: HashMap<usize, MeshItem>,
+    exceptions: HashSet<(usize, usize)>,
+}
+
+impl MeshCollisionSet {
+    pub fn new() -> Self {
+        Self {
+            meshes: HashMap::new(),
+            exceptions: HashSet::new(),
+        }
+    }
+
+    pub fn add_exception(&mut self, id1: usize, id2: usize) {
+        let lower = id1.min(id2);
+        let upper = id1.max(id2);
+        self.exceptions.insert((lower, upper));
+    }
+
+    fn skip_collision(&self, id1: usize, id2: usize) -> bool {
+        let lower = id1.min(id2);
+        let upper = id1.max(id2);
+        self.exceptions.contains(&(lower, upper))
+    }
+
+    fn add_mesh(&mut self, mesh: Mesh, mesh_type: MeshType) -> usize {
+        let id = self.meshes.len();
+        self.meshes.insert(id, MeshItem { mesh, mesh_type });
+
+        id
+    }
+
+    pub fn add_stationary(&mut self, mesh: Mesh) -> usize {
+        self.add_mesh(mesh, MeshType::Stationary)
+    }
+
+    pub fn add_moving(&mut self, mesh: Mesh) -> usize {
+        self.add_mesh(mesh, MeshType::Moving)
+    }
+
+    /// This function will check for all collisions between the meshes in the set, according to the
+    /// following rules:
+    ///
+    /// - Moving meshes will be checked against all meshes that don't contain an exception,
+    ///   including both stationary and other moving meshes
+    /// - Stationary meshes will not be checked against any other meshes, and so a collision will
+    ///   only be reported if it is with a stationary mesh
+    ///
+    /// # Arguments
+    ///
+    /// * `transforms`: transforms for the moving meshes
+    /// * `stop_at_first`: If true, the function will stop at the first collision found for each
+    ///   moving mesh. If false, it will check all collisions.
+    ///
+    /// returns: Vec<(usize, usize), Global>
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///
+    /// ```
+    pub fn check_all(
+        &self,
+        transforms: &[(usize, Iso3)],
+        stop_at_first: bool,
+    ) -> Result<Vec<(usize, usize)>> {
+        // Create the fast isometry lookup:
+        let lookups = self.quick_lookups(transforms)?;
+
+        // We'll iterate through all the moving meshes (this can be parallelized later).
+        // For each moving mesh, we'll iterate through all stationary meshes and then all moving
+        // meshes. Whether a collision check occurs depends on the following:
+        // - Is the current mesh id lower than the other mesh id?
+        // - Is there an exception for the current pair of meshes?
+        let mut pairs = Vec::new();
+
+        for (&id1, mesh1) in self.meshes.iter() {
+            if mesh1.mesh_type == MeshType::Stationary {
+                continue;
+            }
+
+            let iso1 = &lookups[id1];
+
+            for (&id2, mesh2) in self.meshes.iter() {
+                if mesh2.mesh_type == MeshType::Moving && id1 >= id2 {
+                    continue;
+                }
+
+                if self.skip_collision(id1, id2) {
+                    continue;
+                }
+
+                let iso2 = &lookups[id2];
+
+                // Check for collision
+                if let Ok(check) = intersection_test(iso1, mesh1.mesh.tri_mesh(), iso2, mesh2.mesh.tri_mesh()) {
+                    if check {
+                        pairs.push((id1, id2));
+                        if stop_at_first {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(pairs)
+    }
+
+    fn quick_lookups(&self, transforms: &[(usize, Iso3)]) -> Result<Vec<Iso3>> {
+        let mut lookups = vec![Iso3::identity(); self.meshes.len()];
+        for &(id, iso) in transforms.iter() {
+            if id >= self.meshes.len() {
+                return Err(format!("Transform id {} out of bounds", id).into());
+            }
+
+            lookups[id] = iso.clone();
+        }
+
+        Ok(lookups)
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::geom3::Mesh;
+    use crate::Iso3;
+
+    #[test]
+    fn collision_set() {
+        let mut set = MeshCollisionSet::new();
+        let mesh1 = Mesh::create_box(1.0, 1.0, 1.0, true);
+        let mesh2 = Mesh::create_box(1.0, 1.0, 1.0, true);
+
+        let id1 = set.add_stationary(mesh1);
+        let id2 = set.add_moving(mesh2);
+
+        let transforms = vec![(id2, Iso3::translation(0.5, 0.5, 0.5))];
+
+        let pairs = set.check_all(&transforms, false).unwrap();
+        assert_eq!(pairs.len(), 1);
+    }
+
+    #[test]
+    fn collision_set_exception_skips() {
+        let mut set = MeshCollisionSet::new();
+        let mesh1 = Mesh::create_box(1.0, 1.0, 1.0, true);
+        let mesh2 = Mesh::create_box(1.0, 1.0, 1.0, true);
+
+        let id1 = set.add_stationary(mesh1);
+        let id2 = set.add_moving(mesh2);
+        set.add_exception(id2, id1);
+
+        let transforms = vec![(id2, Iso3::translation(0.5, 0.5, 0.5))];
+
+        let pairs = set.check_all(&transforms, false).unwrap();
+        assert_eq!(pairs.len(), 0);
+    }
+
+    #[test]
+    fn collision_set_misses() {
+        let mut set = MeshCollisionSet::new();
+        let mesh1 = Mesh::create_box(1.0, 1.0, 1.0, true);
+        let mesh2 = Mesh::create_box(1.0, 1.0, 1.0, true);
+
+        let id1 = set.add_stationary(mesh1);
+        let id2 = set.add_moving(mesh2);
+
+        let transforms = vec![(id2, Iso3::translation(2.5, 0.5, 0.5))];
+
+        let pairs = set.check_all(&transforms, false).unwrap();
+        assert_eq!(pairs.len(), 0);
+    }
+}