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::*;

#[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).

Type Parameter

• SourceU: length unit of the input Position

Example

use affn::ellipsoidal::Position;
use affn::centers::ReferenceCenter;
use qtty::*;

#[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);
}

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: 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> 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: Copy + ReferenceCenter, F: Copy + ReferenceFrame, U: Copy + LengthUnit> Copy for Position<C, F, U>

where C::Params: Copy,