Struct Tetrahedron 

pub struct Tetrahedron<S> { /* private fields */ }

A 3-simplex or tetrahedron in 3D space

Creation methods will fail with a debug assertion if the points are coplanar.

Implementations

impl<S: OrderedField> Tetrahedron<S>

pub fn new( a: Point3<S>, b: Point3<S>, c: Point3<S>, d: Point3<S>, ) -> Option<Self>

where S: AbsDiffEq<Epsilon = S>,

Returns None if the points are coplanar:

assert!(Tetrahedron::new (
  [-1.0, -1.0, -1.0].into(),
  [ 1.0,  1.0,  1.0].into(),
  [-1.0,  1.0,  0.0].into(),
  [ 1.0, -1.0,  0.0].into()
).is_none());

pub fn noisy(a: Point3<S>, b: Point3<S>, c: Point3<S>, d: Point3<S>) -> Self

where S: AbsDiffEq<Epsilon = S>,

Panics if the points are coplanar:

let s = Tetrahedron::noisy (
  [-1.0, -1.0, -1.0].into(),
  [ 1.0,  1.0,  1.0].into(),
  [-1.0,  1.0,  0.0].into(),
  [ 1.0, -1.0,  0.0].into());

pub fn unchecked(a: Point3<S>, b: Point3<S>, c: Point3<S>, d: Point3<S>) -> Self

where S: AbsDiffEq<Epsilon = S>,

Debug panic if the points are coplanar:

let s = Tetrahedron::unchecked (
  [-1.0, -1.0, -1.0].into(),
  [ 1.0,  1.0,  1.0].into(),
  [-1.0,  1.0,  0.0].into(),
  [ 1.0, -1.0,  0.0].into());

pub fn from_array([a, b, c, d]: [Point3<S>; 4]) -> Option<Self>

where S: AbsDiffEq<Epsilon = S>,

pub const fn point_a(self) -> Point3<S>

pub const fn point_b(self) -> Point3<S>

pub const fn point_c(self) -> Point3<S>

pub const fn point_d(self) -> Point3<S>

pub const fn points(self) -> [Point3<S>; 4]

pub const fn edge_ab(self) -> Segment3<S>

pub const fn edge_ac(self) -> Segment3<S>

pub const fn edge_ad(self) -> Segment3<S>

pub const fn edge_bc(self) -> Segment3<S>

pub const fn edge_bd(self) -> Segment3<S>

pub const fn edge_cd(self) -> Segment3<S>

pub const fn edges(self) -> [Segment3<S>; 6]

pub fn face_abc(self) -> Triangle<S>

Note that the points in the returned triangle will be ordered so that the triangle.normal() will face away from the tetrahedron.

pub fn face_abd(self) -> Triangle<S>

Note that the points in the returned triangle will be ordered so that the triangle.normal() will face away from the tetrahedron.

pub fn face_acd(self) -> Triangle<S>

Note that the points in the returned triangle will be ordered so that the triangle.normal() will face away from the tetrahedron.

pub fn face_bcd(self) -> Triangle<S>

Note that the points in the returned triangle will be ordered so that the triangle.normal() will face away from the tetrahedron.

pub fn faces(self) -> [Triangle<S>; 4]

pub fn normal_abc(self) -> NonZero3<S>

pub fn normal_abd(self) -> NonZero3<S>

pub fn normal_acd(self) -> NonZero3<S>

pub fn normal_bcd(self) -> NonZero3<S>

pub fn volume(self) -> Positive<S>

pub fn translate(&mut self, displacement: Vector3<S>)

pub fn contains(self, point: Point3<S>) -> bool

Checks if a point is contained in the tetrahedron:

let s = Tetrahedron::noisy (
  [ 0.0,  0.0,  1.0].into(),
  [ 0.0,  1.0, -1.0].into(),
  [-1.0, -1.0, -1.0].into(),
  [ 1.0, -1.0, -1.0].into()
);
assert!(s.contains (Point3::origin()));
assert!(!s.contains ([0.0, 0.0, 2.0].into()));

Trait Implementations

impl<S: Clone> Clone for Tetrahedron<S>

fn clone(&self) -> Tetrahedron<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for Tetrahedron<S>

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

Formats the value using the given formatter.

impl<S: Field + Sqrt> Default for Tetrahedron<S>

fn default() -> Self

A default simplex is arbitrarily chosen to be the simplex with vertices at unit distance from the origin with A at [0.0, 0.0, 1.0] and B at [0.0, sqrt(8.0/9.0), -1.0/3.0], and points C and D at [ sqrt(2.0/3.0), -sqrt(2.0/9.0), -1.0/3.0] and [-sqrt(2.0/3.0), -sqrt(2.0/9.0), -1.0/3.0].

let s = Tetrahedron::default();
let t = Tetrahedron::noisy (
  [                0.0,                 0.0,      1.0].into(),
  [                0.0,  f64::sqrt(8.0/9.0), -1.0/3.0].into(),
  [ f64::sqrt(2.0/3.0), -f64::sqrt(2.0/9.0), -1.0/3.0].into(),
  [-f64::sqrt(2.0/3.0), -f64::sqrt(2.0/9.0), -1.0/3.0].into());
approx::assert_relative_eq!(
  Matrix4::from_col_arrays ([
    s.point_a().0.with_w (0.0).into_array(),
    s.point_b().0.with_w (0.0).into_array(),
    s.point_c().0.with_w (0.0).into_array(),
    s.point_d().0.with_w (0.0).into_array()
  ]),
  Matrix4::from_col_arrays ([
    t.point_a().0.with_w (0.0).into_array(),
    t.point_b().0.with_w (0.0).into_array(),
    t.point_c().0.with_w (0.0).into_array(),
    t.point_d().0.with_w (0.0).into_array()
  ]));

impl<S> From<Tetrahedron<S>> for Hull3<S>

where S: Real + RelativeEq<Epsilon = S>,

fn from(tetrahedron: Tetrahedron<S>) -> Self

Converts to this type from the input type.

impl<S> Index<usize> for Tetrahedron<S>

where S: Copy,

type Output = Point3<S>

The returned type after indexing.

fn index(&self, index: usize) -> &Point3<S>

Performs the indexing (container[index]) operation.

impl<S: PartialEq> PartialEq for Tetrahedron<S>

fn eq(&self, other: &Tetrahedron<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> TryFrom<[Point3<S>; 4]> for Tetrahedron<S>

where S: OrderedField + RelativeEq<Epsilon = S>,

type Error = [Point3<S>; 4]

The type returned in the event of a conversion error.

fn try_from([a, b, c, d]: [Point3<S>; 4]) -> Result<Self, Self::Error>

Performs the conversion.

impl<S: Copy> Copy for Tetrahedron<S>

impl<S: Eq> Eq for Tetrahedron<S>

impl<S> StructuralPartialEq for Tetrahedron<S>