Struct Spherical 

pub struct Spherical<T: Float> {
    pub radius: T,
    pub polar_angle: T,
    pub azimuthal_angle: T,
}

A point in 3D space using spherical coordinates as defined by ISO 80000-2:2019.

This means that the coordinates are provided in the order radius (r), polar angle (theta), and finally azimuthal angle (phi)

Examples

let right = Spherical::<f64>::new(1.0, 0.0, 0.0);
assert_eq!(right, Spherical::<f64>::UP);

Fields

radius: T

Distance from the origin

polar_angle: T

Angle from the positive z direction

azimuthal_angle: T

angle from the positive x direction along the xy plane

Implementations

impl<T: Float + TrigConsts> Spherical<T>

pub fn new(radius: T, polar_angle: T, azimuthal_angle: T) -> Spherical<T>

Maps parameters into appropriate domains.

Mapping

• azimuthal angle ∈ [0,τ)
  • Doesn’t have side effects
• Polar angle ∈ [0,π]
  • Mutates azimuthal angle
• radius ∈ [0,∞)
  • Mutates polar angle and azimuthal angle

Examples

Clamping Azimuthal angle

let right = Spherical::<f64>::new(1.0, std::f64::consts::FRAC_PI_2, 0.0);
let also_right = Spherical::<f64>::new(1.0, std::f64::consts::FRAC_PI_2, std::f64::consts::TAU);

assert!(right.angle_to(&also_right) < std::f64::EPSILON);

Clamping Polar Angle

let up = Spherical::<f64>::new(1.0, 0.0, 0.0);
let also_up = Spherical::<f64>::new(1.0, std::f64::consts::TAU, 0.0);
assert!(up.angle_to(&also_up) < std::f64::EPSILON);

Clamping Radius

let left = Spherical::<f64>::new(1.0, std::f64::consts::FRAC_PI_2, std::f64::consts::PI);
let also_left = Spherical::<f64>::new(-1.0, std::f64::consts::FRAC_PI_2, 0.0);

assert!(left.angle_to(&also_left) < std::f64::EPSILON);

pub fn get_elevation(&self) -> T

Returns the latitude/elevation of the point.

i.e. the polar angle with respect to the equator instead of the north pole

pub fn set_azimuthal_angle(&mut self, azimuthal_angle: T)

Ensures the azimuth is always in the range [0,tau)

pub fn set_polar_angle(&mut self, polar_angle: T)

Ensures polar angle is always in the range [0,pi)

pub fn set_radius(&mut self, radius: T)

Ensures radius is always in the range [0,+infinity]

Trait Implementations

impl<T: Float> Add for Spherical<T>

type Output = Spherical<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Clone + Float> Clone for Spherical<T>

fn clone(&self) -> Spherical<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Float> Cross3D for Spherical<T>

fn cross(&self, other: &Self) -> Self

impl<T: Debug + Float> Debug for Spherical<T>

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

Formats the value using the given formatter.

impl<T: Display + Float> Display for Spherical<T>

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

Formats the value using the given formatter.

impl<T: Float> Div<T> for Spherical<T>

type Output = Spherical<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Float> Dot<T> for Spherical<T>

fn dot(&self, other: &Self) -> T

impl<T: Float> From<&Cylindrical<T>> for Spherical<T>

fn from(cyl: &Cylindrical<T>) -> Self

Converts to this type from the input type.

impl<T: Float> From<&Spherical<T>> for Vector3<T>

fn from(sph: &Spherical<T>) -> Self

Converts to this type from the input type.

impl<T: Float> From<&Vector3<T>> for Spherical<T>

fn from(cart: &Vector3<T>) -> Self

Converts to this type from the input type.

impl<T: Float> From<(T, T, T)> for Spherical<T>

fn from(tuple: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T: Float> From<Cylindrical<T>> for Spherical<T>

fn from(cyl: Cylindrical<T>) -> Self

Converts to this type from the input type.

impl<T: Float> From<Spherical<T>> for (T, T, T)

fn from(sph: Spherical<T>) -> Self

Converts to this type from the input type.

impl<T: Float> From<Spherical<T>> for Vector3<T>

fn from(sph: Spherical<T>) -> Self

Converts to this type from the input type.

impl<T: Float> From<Vector3<T>> for Spherical<T>

fn from(cart: Vector3<T>) -> Self

Converts to this type from the input type.

impl<T: Hash + Float> Hash for Spherical<T>

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: Float> Magnitude<T> for Spherical<T>

fn magnitude(&self) -> T

Returns the exact magnitude of the vector

fn quick_magnitude(&self) -> T

Returns the magnitude of a vector in as few operations as possible

fn normalize(self) -> Self

impl<T: Float> Mul<T> for Spherical<T>

type Output = Spherical<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Float + TrigConsts> Neg for Spherical<T>

type Output = Spherical<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Float + TrigConsts> PartialEq for Spherical<T>

fn eq(&self, other: &Self) -> 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<T: Float + TrigConsts> PartialOrd for Spherical<T>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: Float + TrigConsts> Positional<T> for Spherical<T>

fn angle_to(&self, other: &Self) -> T

Using the spherical law of cosines

impl<T: Float> Sub for Spherical<T>

type Output = Spherical<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Float + TrigConsts> ThreeDimensionalConsts<T> for Spherical<T>

const ORIGIN: Self

Center of the coordinate space

const UP: Self

Unit vector pointing in the positive z direction

const DOWN: Self

Unit vector pointing in the negative z direction

const FORWARD: Self

Unit vector pointing in the positive y direction

const BACK: Self

Unit vector pointing in the negative y direction

const LEFT: Self

Unit vector pointing in the positive x direction

const RIGHT: Self

Unit vector pointing in the negative x direction

impl<T: Copy + Float> Copy for Spherical<T>

impl<T: Float + TrigConsts> Eq for Spherical<T>