Struct Position 

pub struct Position<C: ReferenceCenter, F: ReferenceFrame, U: LengthUnit = Meter> {
    pub lon: Degrees,
    pub lat: Degrees,
    pub height: Quantity<U>,
    /* private fields */
}

An ellipsoidal position (center + frame + height above ellipsoid).

This is the fundamental ellipsoidal (geodetic) coordinate type, analogous to spherical::Position for spherical coordinates.

Type Parameters

• C: The reference center (e.g., Geocentric)
• F: The reference frame; determines the ellipsoid via HasEllipsoid
• U: The length unit for the height (defaults to Meter)

Field conventions

Field	Meaning
lon	Geodetic longitude, positive eastward
lat	Geodetic latitude, positive northward
height	Height above the reference ellipsoid

Correctness note

Do not convert this value using spherical-to-Cartesian formulas. Always use the ellipsoid-aware to_cartesian method.

Fields

lon: Degrees

Geodetic longitude (positive eastward), in degrees.

lat: Degrees

Geodetic latitude (positive northward), in degrees.

height: Quantity<U>

Height above the reference ellipsoid.

Implementations

impl<C, F, U> Position<C, F, U>

where C: ReferenceCenter, F: ReferenceFrame, U: LengthUnit,

pub const fn new_raw_with_params( center_params: C::Params, lon: Degrees, lat: Degrees, height: Quantity<U>, ) -> Self

Const-fn constructor with explicit center parameters.

Longitude and latitude are stored as-is (no normalisation). Use new_with_params if you want automatic normalisation.

pub fn new_with_params( center_params: C::Params, lon: Degrees, lat: Degrees, height: Quantity<U>, ) -> Self

Constructor with explicit center parameters and lon/lat normalisation.

Longitude is normalised to [-180°, +180°) and latitude to [-90°, +90°] (pole-crossing is reflected into longitude).

pub fn center_params(&self) -> &C::Params

Returns a reference to the center parameters.

impl<C, F, U> Position<C, F, U>

where C: ReferenceCenter<Params = ()>, F: ReferenceFrame, U: LengthUnit,

pub const ORIGIN: Self

The geodetic origin: (0°E, 0°N, 0 height-units).

pub const fn new_raw(lon: Degrees, lat: Degrees, height: Quantity<U>) -> Self

Const-fn constructor (no normalisation) for centers with Params = ().

pub fn new(lon: Degrees, lat: Degrees, height: Quantity<U>) -> Self

Normalising constructor for centers with Params = ().

pub fn try_new( lon: Degrees, lat: Degrees, height: Quantity<U>, ) -> Result<Self, Infallible>

Normalising constructor (infallible Result wrapper kept for API compat).

impl<C, F, U> Position<C, F, U>

where C: ReferenceCenter, F: ReferenceFrame + HasEllipsoid, U: LengthUnit,

pub fn to_cartesian<TargetU: LengthUnit>(&self) -> Position<C, F, TargetU>

where C::Params: Clone,

Converts to a Cartesian ECEF position using the ellipsoid of frame F.

The ellipsoid constants are obtained from F::Ellipsoid at compile time.

Type Parameter

• TargetU: length unit for the output Position

Example

use affn::ellipsoidal::Position;
use affn::centers::ReferenceCenter;
use qtty::units::*; use qtty::{Quantity, M, KM, DEG, RAD, SEC}; use qtty::angular::{Degrees, Radians}; use qtty::length::{Meters, Kilometers};

#[derive(Debug, Copy, Clone)]
struct Geocentric;
impl ReferenceCenter for Geocentric {
    type Params = ();
    fn center_name() -> &'static str { "Geocentric" }
}

{
    let obs = Position::<Geocentric, affn::frames::ECEF, Meter>::new(
        -17.89 * DEG, 28.76 * DEG, 2200.0 * M,
    );
    let cart: affn::cartesian::Position<Geocentric, affn::frames::ECEF, Meter> =
        obs.to_cartesian();
    // X ≈ 5 390 km, Y ≈ −1 730 km, Z ≈ 3 050 km (approx. La Palma)
}

pub fn from_cartesian<SourceU: LengthUnit>( pos: &Position<C, F, SourceU>, ) -> Self

where C::Params: Clone,

Constructs an ellipsoidal position from a Cartesian ECEF position using the ellipsoid of frame F.

Uses the iterative Bowring algorithm (typically 2–3 iterations for sub-millimetre accuracy).

This is an infallible best-effort wrapper; prefer try_from_cartesian when convergence guarantees matter. If the Bowring iteration does not converge within the iteration cap, this method returns the last computed iterate without signalling the failure.

Type Parameter

• SourceU: length unit of the input Position

Example

use affn::ellipsoidal::Position;
use affn::centers::ReferenceCenter;
use qtty::units::*; use qtty::{Quantity, M, KM, DEG, RAD, SEC}; use qtty::angular::{Degrees, Radians}; use qtty::length::{Meters, Kilometers};

#[derive(Debug, Copy, Clone)]
struct Geocentric;
impl ReferenceCenter for Geocentric {
    type Params = ();
    fn center_name() -> &'static str { "Geocentric" }
}

{
    let obs = Position::<Geocentric, affn::frames::ECEF, Meter>::new(
        -17.89 * DEG, 28.76 * DEG, 2200.0 * M,
    );
    let cart = obs.to_cartesian::<Meter>();
    let back = Position::<Geocentric, affn::frames::ECEF, Meter>::from_cartesian(&cart);
    assert!((back.lat.value() - obs.lat.value()).abs() < 1e-10);
}

pub fn try_from_cartesian<SourceU: LengthUnit>( pos: &Position<C, F, SourceU>, ) -> Result<Self, GeodeticConvergenceError>

where C::Params: Clone,

Fallible counterpart of from_cartesian.

Runs the same Bowring iteration, but returns Err(GeodeticConvergenceError) when the latitude residual (lat_new - lat_prev).abs() still exceeds the convergence threshold (1e-14 rad) after the iteration cap.

Type Parameter

• SourceU: length unit of the input Position

Trait Implementations

impl<C: Clone + ReferenceCenter, F: Clone + ReferenceFrame, U: Clone + LengthUnit> Clone for Position<C, F, U>

where C::Params: Clone,

fn clone(&self) -> Position<C, F, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Copy + ReferenceCenter, F: Copy + ReferenceFrame, U: Copy + LengthUnit> Copy for Position<C, F, U>

where C::Params: Copy,

impl<C: Debug + ReferenceCenter, F: Debug + ReferenceFrame, U: Debug + LengthUnit> Debug for Position<C, F, U>

where C::Params: Debug,

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

Formats the value using the given formatter.

impl<C, F> Default for Position<C, F, Meter>

where C: ReferenceCenter<Params = ()>, F: ReferenceFrame,

fn default() -> Self

Returns the geodetic origin: (0°E, 0°N, 0 m).

impl<C, F, U> Display for Position<C, F, U>

where C: ReferenceCenter, F: ReferenceFrame, U: LengthUnit, Quantity<U>: Display,

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

Formats the value using the given formatter.

impl<C, F, U> LowerExp for Position<C, F, U>

where C: ReferenceCenter, F: ReferenceFrame, U: LengthUnit, Quantity<U>: LowerExp,

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

Formats the value using the given formatter.

impl<C, F, U> PartialEq for Position<C, F, U>

where C: ReferenceCenter, C::Params: PartialEq, F: ReferenceFrame, U: LengthUnit,

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<C, F, U> UpperExp for Position<C, F, U>

where C: ReferenceCenter, F: ReferenceFrame, U: LengthUnit, Quantity<U>: UpperExp,

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

Formats the value using the given formatter.