Struct soft_edge::InteriorHull

pub struct InteriorHull { /* fields omitted */ }

Triangles which lie on the planes of the faces of an atom are taken care of by Faces. However, we still need to complete the picture by adding back in any missing facets which lie “inside” that cube (and not on its faces.) There are 8 ways to choose 3 triangles from eight vertices. Of these 56 possible triangles, there are 4 times 24 which exist on the faces of the cube, and which are therefore superseded by the Face calculations. We now have 32 triangles remaining. Of these, we have six “symmetry planes” of the cube; these are the planes that run through an edge each, and both contain four vertices. Like the face quads, these contain 24 possible triangles, which leaves us with a total of 8 anomalous configurations. To sum up (pun intended):

• 56 total triangles (8 choose 3). (Given a quad, there are four triangles in it; divide it in half, then flip the edge to get the other two.)
  • 6 quads in cube faces = 24 triangle configurations
  • 6 quads in symmetry planes = 24 triangle configurations
  • 8 remaining triangles (anomalous configurations)

32 of these configurations are ones we’re interested in. 24 of these can be enumerated by enumerating the symmetry planes, and at the same time can be collapsed into a quad in order to remain as simplified as possible (or we can triangulate them for good measure.) The remaining 8 are more troublesome, but can be enumerated as sets where no vertex shares an edge. How can we know this? Let’s think through it.

Suppose a vertex shares an edge with another vertex in this triangle. There are three other edges on which to choose the last vertex. Two of them would put the triangle on the faces of the cube. The remaining option will place the triangle on one of the symmetry planes.

So, it seems obvious that the remaining configurations are those where the vertices don’t even share an edge, let alone a face. The number of these is only eight, so we can enumerate them (see ANOMALOUS_CONFIGURATIONS.) These are simple to deal with as well, as they can never be collapsed into a quad, at least not within a single Atom, because these are the groups of three vertices which are alone on their plane within the cube.

Implementations

impl InteriorHull

pub fn new(atom: Atom) -> Self

Generate the interior hull of an atom.

pub fn facets(&self) -> impl Iterator<Item = HullFacet>

Return an iterator over all facets on the interior hull.

Trait Implementations

impl Clone for InteriorHull

fn clone(&self) -> InteriorHull

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InteriorHull

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

Formats the value using the given formatter.

impl Hash for InteriorHull

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<InteriorHull> for InteriorHull

fn eq(&self, other: &InteriorHull) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<InteriorHull> for InteriorHull

fn partial_cmp(&self, other: &InteriorHull) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for InteriorHull

impl StructuralEq for InteriorHull

impl StructuralPartialEq for InteriorHull