Enum Octant 

#[repr(u8)]
pub enum Octant {
    Nnn = 0,
    Nnp = 1,
    Npn = 2,
    Npp = 3,
    Pnn = 4,
    Pnp = 5,
    Ppn = 6,
    Ppp = 7,
}

Identifies one of eight octants, or elements of a 2×2×2 cube.

Used with OctantMask and OctantMap.

This enum’s discriminants are not currently to be considered stable; they may be reordered.

Variants

Nnn = 0

The -X, -Y, -Z octant.

Nnp = 1

The -X, -Y, +Z octant.

Npn = 2

The -X, +Y, -Z octant.

Npp = 3

The -X, +Y, +Z octant.

Pnn = 4

The +X, -Y, -Z octant.

Pnp = 5

The +X, -Y, +Z octant.

Ppn = 6

The +X, +Y, -Z octant.

Ppp = 7

The +X, +Y, +Z octant.

Implementations

impl Octant

pub const ALL: [Self; 8]

All values of the enum.

pub fn try_from_positive_cube(cube: Cube) -> Option<Self>

Given a cube in the volume (0..2)³, return which octant of that volume it is.

pub fn try_from_01<T: Copy + NumCast, U>( corner_or_translation: Vector3D<T, U>, ) -> Option<Self>

Given the low corner of an octant in the volume (0..2)³, return which octant it is.

That is, each coordinate of the returned Vector3D is either 0 or 1. This is equivalent to Self::try_from_positive_cube() but with more flexible input.

TODO: better trait bounds would be Zero + One

pub fn from_vector(vector: FreeVector) -> Self

Returns the octant the given vector points toward, when interpreted as pointing away from the center point where all octants meet.

Ties due to zero components are broken in the positive direction.

pub fn to_positive_cube(self) -> Cube

Returns this octant of the volume (0..2)³.

That is, each coordinate of the returned Cube is either 0 or 1.

pub fn to_01<U>(self) -> Vector3D<u8, U>

Returns this octant of the volume (0..2)³ expressed as a translation vector from the origin.

That is, each coordinate of the returned Vector3D is either 0 or 1.

pub fn reflect<T, U>(self, vector: Vector3D<T, U>) -> Vector3D<T, U>

where T: Neg<Output = T>,

For each component of vector, negate it if self is on the negative side of that axis.

This may be used to transform between positive-octant-only data and data mirrored into arbitrary octants.

Trait Implementations

impl Clone for Octant

fn clone(&self) -> Octant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Octant

impl Debug for Octant

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

Formats the value using the given formatter.

impl Eq for Octant

impl Exhaust for Octant

type Iter = ExhaustOctantIter

Iterator type returned by Self::exhaust_factories(). See the trait documentation for what properties this iterator should have.

type Factory = ExhaustOctantFactory

Data which can be used to construct Self.

fn exhaust_factories() -> Self::Iter

Returns an iterator over factories for all values of this type.

fn from_factory(factory: Self::Factory) -> Self

Construct a concrete value of this type from a Self::Factory value produced by its Self::Iter.

fn exhaust() -> Iter<Self>

Returns an iterator over all values of this type.

impl From<Octant> for OctantMask

fn from(octant: Octant) -> Self

Converts to this type from the input type.

impl FromIterator<Octant> for OctantMask

fn from_iter<T: IntoIterator<Item = Octant>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for Octant

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<Octant> for OctantMap<T>

type Output = T

The returned type after indexing.

fn index(&self, octant: Octant) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Octant> for OctantMap<T>

fn index_mut(&mut self, octant: Octant) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq for Octant

fn eq(&self, other: &Octant) -> 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 StructuralPartialEq for Octant