rustmap3d 0.2.3__cp314-cp314-win_amd64.whl

rustmap3d/__init__.py

@@ -0,0 +1,5 @@
+from .rustmap3d import *
+
+__doc__ = rustmap3d.__doc__
+if hasattr(rustmap3d, "__all__"):
+    __all__ = rustmap3d.__all__

rustmap3d/__init__.pyi

@@ -0,0 +1,855 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+
+def aer2ecef(
+    a_d: builtins.float,
+    e_d: builtins.float,
+    r_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts AER from a given lat/lon to a new ECEF location
+
+    # Arguments
+
+    * `a_d` - Azimuth in degrees [float]
+    * `e_d` - Elevation in degrees [float]
+    * `r_m` - Range in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ecef` - Absolute ECEF position in meters
+    """
+
+def aer2ecef_uvw(
+    a_d: builtins.float,
+    e_d: builtins.float,
+    r_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts a vector direction and distance given in AER to ECEF uvw
+
+    # Arguments
+
+    * `a_d` - Azimuth in degrees [float]
+    * `e_d` - Elevation in degrees [float]
+    * `r_m` - Range in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ecef_uvw` - Vector represented in ECEF frame. Not an absolute position [[meters]].
+    """
+
+def aer2enu(
+    a_d: builtins.float, e_d: builtins.float, r_m: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts AER vector direction and magnitude to ENU.
+
+    # Arguments
+
+    * `a_d` - Azimuth in degrees [float]
+    * `e_d` - Elevation in degrees [float]
+    * `r_m` - Range in meters [float]
+
+    # Returns
+
+    * `enu` - Vector represented in ENU coordinates [meters].
+    """
+
+def aer2ned(
+    a_d: builtins.float, e_d: builtins.float, r_m: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts AER vector direction and magnitude to NED.
+
+    # Arguments
+
+    * `a_d` - Azimuth in degrees [float]
+    * `e_d` - Elevation in degrees [float]
+    * `r_m` - Range in meters [float]
+
+    # Returns
+
+    * `ned` - Vector represented in NED coordinates [meters].
+    """
+
+def angle_between(
+    ax: builtins.float,
+    ay: builtins.float,
+    az: builtins.float,
+    bx: builtins.float,
+    by: builtins.float,
+    bz: builtins.float,
+) -> builtins.float:
+    r"""
+    Computes the angle between two vectors in radians. Dot product is clamped to [-1, 1] so this always outputs a number
+
+    # Arguments
+
+    * `ax` - a vector x [float]
+    * `ay` - a vector y [float]
+    * `az` - a vector z [float]
+    * `bx` - b vector x [float]
+    * `by` - b vector y [float]
+    * `bz` - b vector z [float]
+
+    # Returns
+
+    * `angle` - angle between the two vectors in radians
+    """
+
+def dd2dms(dd: builtins.float, is_lat: builtins.bool) -> builtins.str:
+    r"""
+    Converts decimal degrees (DD) to degrees-minutes-seconds (DMS).
+
+    # Arguments
+
+    * `dd` - Decimal degrees [degrees].
+    * `is_lat` - Flag to denote if this decimal value describes a latitude [bool]
+
+    # Returns
+
+    * `dms` - Format "{Degrees}:{Minutes}:{Seconds}.{DecSeconds}{Direction}" where Direction is one of N, E, S, or W.
+
+    # Examples
+    ```
+    dms = map3d.dd2dms(25.37909389, true) #> "25:22:44.738N"
+    ```
+    """
+
+def dms2dd(dms: builtins.str) -> builtins.float:
+    r"""
+    Converts degrees-minutes-seconds (DMS) to decimal degrees (DD).
+
+    # Arguments
+
+    * `dms` - Format "{Degrees}:{Minutes}:{Seconds}.{DecSeconds}{Direction}" where Direction is one of N, E, S, or W.
+
+    # Returns
+
+    * `dd` - Decimal degrees [degrees].
+
+    # Examples
+    ```
+    dd = map3d.dms2dd("25:22:44.738N")  #> 25.37909389
+    ```
+    """
+
+def ecef2aer(
+    x_m: builtins.float,
+    y_m: builtins.float,
+    z_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts an absolute ECEF to AER (az el range).
+
+    # Arguments
+
+    * `x_m` - ECEF x in meters [float]
+    * `y_m` - ECEF y in meters [float]
+    * `z_m` - ECEF z in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `aer` - Vector represented in AER coordinates [degrees-degrees-meters].
+    """
+
+def ecef2enu(
+    x_m: builtins.float,
+    y_m: builtins.float,
+    z_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts an ECEF position to ENU.
+
+    # Arguments
+
+    * `x_m` - ECEF x in meters [float]
+    * `y_m` - ECEF y in meters [float]
+    * `z_m` - ECEF z in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `enu` - Vector represented in ENU coordinates [meters].
+    """
+
+def ecef2enu_dcm(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+]:
+    r"""
+    Calculates the direction cosine matrix that yields an ECEF to ENU transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `dcm` - ECEF to ENU direction cosine matrix [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]]
+    """
+
+def ecef2enu_quat(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float, builtins.float]:
+    r"""
+    Calculates the quaternion that yields an ECEF to ENU transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `quat` - Normalized ECEF to ENU quaternion.
+    """
+
+def ecef2lla(
+    x_m: builtins.float, y_m: builtins.float, z_m: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ECEF to WGS84 LLA
+
+    # Arguments
+
+    * `x_m` - ECEF x in meters [float]
+    * `y_m` - ECEF y in meters [float]
+    * `z_m` - ECEF z in meters [float]
+
+    # Returns
+
+    * `lla` - Vector represented in WGS84 LLA [degrees-degrees-meters].
+    """
+
+def ecef2ned(
+    x_m: builtins.float,
+    y_m: builtins.float,
+    z_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts an absolute ECEF location to NED.
+
+    # Arguments
+
+    * `x_m` - ECEF x in meters [float]
+    * `y_m` - ECEF y in meters [float]
+    * `z_m` - ECEF z in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ned` - Vector represented in NED coordinates [meters].
+    """
+
+def ecef2ned_dcm(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+]:
+    r"""
+    Calculates the direction cosine matrix that yields an ECEF to NED transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `dcm` - ECEF to NED direction cosine matrix [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]]
+    """
+
+def ecef2ned_quat(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float, builtins.float]:
+    r"""
+    Calculates the quaternion that yields an ECEF to NED transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `quat` - Normalized ECEF to NED quaternion (w, x, y, z).
+    """
+
+def ecef_quat2heading(
+    w: builtins.float,
+    x: builtins.float,
+    y: builtins.float,
+    z: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> builtins.float:
+    r"""
+    Computes the clockwise angle from North of a local body-frame's x-axis
+
+    # Arguments
+
+    * `w` - Scalar part of quaternion [float]
+    * `x` - x part of quaternion [float]
+    * `y` - y part of quaternion [float]
+    * `z` - z part of quaternion [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    *  `heading` - Clockwise angle off true north [[degrees]] of the body's x axis
+    """
+
+def ecef_uvw2aer(
+    u_m: builtins.float,
+    v_m: builtins.float,
+    w_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ECEF uvw to AER (az el range).
+
+    # Arguments
+
+    * `u_m` - ECEF u in meters [float]
+    * `v_m` - ECEF v in meters [float]
+    * `w_m` - ECEF w in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `aer` - Vector represented in AER coordinates [degrees-degrees-meters].
+    """
+
+def ecef_uvw2enu(
+    u_m: builtins.float,
+    v_m: builtins.float,
+    w_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts an ECEF uvw vector to ENU.
+
+    # Arguments
+
+    * `u_m` - ECEF u in meters [float]
+    * `v_m` - ECEF v in meters [float]
+    * `w_m` - ECEF w in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `enu` - Vector represented in ENU coordinates [meters].
+    """
+
+def ecef_uvw2ned(
+    u_m: builtins.float,
+    v_m: builtins.float,
+    w_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ECEF UVW Vector to NED.
+
+    # Arguments
+
+    * `u_m` - ECEF u in meters [float]
+    * `v_m` - ECEF v in meters [float]
+    * `w_m` - ECEF w in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ned` - Vector represented in NED coordinates [meters].
+    """
+
+def enu2aer(
+    e_m: builtins.float, n_m: builtins.float, u_m: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ENU to AER.
+
+    # Arguments
+
+    * `e_m` - East in meters [float]
+    * `n_m` - North in meters [float]
+    * `u_m` - Up in meters [float]
+
+    # Returns
+
+    * `aer` - Vector represented in AER coordinates [degrees-degrees-meters].
+    """
+
+def enu2ecef(
+    e_m: builtins.float,
+    n_m: builtins.float,
+    u_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ENU to an ECEF position
+
+    # Arguments
+
+    * `e_m` - East in meters [float]
+    * `n_m` - North in meters [float]
+    * `u_m` - Up in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ecef` - Absolute ECEF position in meters
+    """
+
+def enu2ecef_dcm(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+]:
+    r"""
+    Calculates the direction cosine matrix that yields an ENU to ECEF transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `dcm` - ENU to ECEF direction cosine matrix [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]]
+    """
+
+def enu2ecef_quat(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float, builtins.float]:
+    r"""
+    Calculates the quaternion that yields an ENU to ECEF transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `quat` - Normalized ENU to ECEF quaternion (w, x, y, z).
+    """
+
+def enu2ecef_uvw(
+    e_m: builtins.float,
+    n_m: builtins.float,
+    u_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ENU to ECEF uvw vector
+
+    # Arguments
+
+    * `e_m` - East in meters [float]
+    * `n_m` - North in meters [float]
+    * `u_m` - Up in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ecef_uvw` - Vector represented in ECEF frame. Not an absolute position [[meters]].
+    """
+
+def enu2heading(
+    e_m: builtins.float, n_m: builtins.float, u_m: builtins.float
+) -> builtins.float:
+    r"""
+    Calculates heading angle from ENU.
+
+    # Arguments
+
+    * `e_m` - East in meters [float]
+    * `n_m` - North in meters [float]
+    * `u_m` - Up in meters [float]
+
+    # Returns
+
+    * `heading_deg` - Heading angle relative to true north [degrees].
+    """
+
+def enu2lla(
+    e_m: builtins.float,
+    n_m: builtins.float,
+    u_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts ENU to an absolute LLA position
+
+    # Arguments
+
+    * `e_m` - East in meters [float]
+    * `n_m` - North in meters [float]
+    * `u_m` - Up in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `lla` - Absolute LLA position [deg-deg-m]
+    """
+
+def ll2dms(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[builtins.str, builtins.str]:
+    r"""
+    Convenience function to convert lat/lon to a tuple of (lat dms, lon dms)
+
+    # Arguments
+
+    * `lat` - Latitude in decimal degrees
+    * `lon` - Longitude in decimal degrees
+
+    # Returns
+
+    * `(lat dms, lon dms)` - Tuple of lat/lon as degrees:minutes:seconds [Tuple[String, String]]
+    ```
+    """
+
+def lla2ecef(
+    lat_d: builtins.float, lon_d: builtins.float, alt_m: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts WGS84 LLA to ECEF.
+
+    # Arguments
+
+    * `lat_d` - WGS84 Lat in degrees [float]
+    * `lon_d` - WGS84 Lon in degrees [float]
+    * `alt_m` - WGS84 MSL alt in meters [float]
+
+    # Returns
+
+    * `ecef` - Vector represented in ECEF coordinates [meters].
+    """
+
+def lla2enu(
+    lat_d: builtins.float,
+    lon_d: builtins.float,
+    alt_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts an absolute LLA position to an ENU vector relative to a lla reference
+
+    # Arguments
+
+    * `lat_d` - WGS84 Lat in degrees [float]
+    * `lon_d` - WGS84 Lon in degrees [float]
+    * `alt_m` - WGS84 MSL alt in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `enu` - Vector represented in ENU coordinates [meters].
+    """
+
+def lla2ned(
+    lat_d: builtins.float,
+    lon_d: builtins.float,
+    alt_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts an absolute LLA location to a NED vector relative to a lla reference point
+
+    # Arguments
+
+    * `lat_d` - WGS84 Lat in degrees [float]
+    * `lon_d` - WGS84 Lon in degrees [float]
+    * `alt_m` - WGS84 MSL alt in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ned` - Vector represented in NED coordinates [meters].
+    """
+
+def ned2aer(
+    n_m: builtins.float, e_m: builtins.float, d_m: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts NED to AER.
+
+    # Arguments
+
+    * `n_m` - North in meters [float]
+    * `e_m` - East in meters [float]
+    * `d_m` - Down in meters [float]
+
+    # Returns
+
+    * `aer` - Vector represented in AER coordinates [degrees-degrees-meters].
+    """
+
+def ned2ecef(
+    n_m: builtins.float,
+    e_m: builtins.float,
+    d_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts NED to an absolute ECEF location
+
+    # Arguments
+
+    * `n_m` - North in meters [float]
+    * `e_m` - East in meters [float]
+    * `d_m` - Down in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ecef` - Absolute ECEF position in meters
+    """
+
+def ned2ecef_dcm(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+    builtins.float,
+]:
+    r"""
+    Calculates the direction cosine matrix that yields an NED to ECEF transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `dcm` - NED to ECEF direction cosine matrix  [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]]
+    """
+
+def ned2ecef_quat(
+    lat_d: builtins.float, lon_d: builtins.float
+) -> tuple[builtins.float, builtins.float, builtins.float, builtins.float]:
+    r"""
+    Calculates the quaternion that yields an NED to ECEF transformation at this LLA.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+
+    # Returns
+
+    * `quat` - Normalized NED to ECEF quaternion (w, x, y, z).
+    """
+
+def ned2ecef_uvw(
+    n_m: builtins.float,
+    e_m: builtins.float,
+    d_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts NED to ECEF uvw
+
+    # Arguments
+
+    * `n_m` - North in meters [float]
+    * `e_m` - East in meters [float]
+    * `d_m` - Down in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `ecef_uvw` - Vector represented in ECEF frame. Not an absolute position [[meters]].
+    """
+
+def ned2lla(
+    n_m: builtins.float,
+    e_m: builtins.float,
+    d_m: builtins.float,
+    lat_ref_d: builtins.float,
+    lon_ref_d: builtins.float,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Converts a NED vector to an absolute lat lon alt
+
+    # Arguments
+
+    * `n_m` - North in meters [float]
+    * `e_m` - East in meters [float]
+    * `d_m` - Down in meters [float]
+    * `lat_ref_d` - Reference WGS84 Lat in degrees [float]
+    * `lon_ref_d` - Reference WGS84 Lon in degrees [float]
+
+    # Returns
+
+    * `lla` - Absolute lat lon alt [deg-deg-m]
+    """
+
+def rand_ecef() -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Generates a uniform random ECEF point on the surface of a spherical Earth.
+
+    # Returns
+
+    * `ecef` - Random ECEF location [meters].
+    """
+
+def rand_lla() -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Generates a uniform random LLA point. Altitude is generated in the domain [0.0, 10000.0].
+
+    # Returns
+
+    * `lla` - Random LLA location [degrees-degrees-meters].
+    """
+
+def rand_orientation() -> tuple[
+    builtins.float, builtins.float, builtins.float, builtins.float
+]:
+    r"""
+    Generates a random normalized quaternion.
+
+    # Returns
+
+    * `quat` - Random normalized quaternion (w, x, y, z).
+    """
+
+def vincenty_direct(
+    lat_d: builtins.float,
+    lon_d: builtins.float,
+    range_m: builtins.float,
+    bearing_d: builtins.float,
+    atol: builtins.float = ...,
+    max_iters: builtins.int = ...,
+) -> tuple[builtins.float, builtins.float]:
+    r"""
+    Calculates the LLA location that is a fixed range and bearing from a reference LLA. This function uses an iterative
+    solution to determine outputs using the WGS84 ellipsoidal Earth model.
+
+    See reference:
+    https://en.wikipedia.org/wiki/Vincenty%27s_formulae.
+
+    # Arguments
+
+    * `lat_d` - Latitude reference in degrees [float].
+    * `lon_d` - Longitude reference in degrees [float].
+    * `range_m` - Range (i.e., distance) from point A to point B [meters].
+    * `bearing_d` - Bearing (i.e., azimuth) from point A to point B relative to true north [degrees].
+    * `abs_tol` - Absolute tolerance used for convergence.
+    * `max_iters` - Maximum possible number of iterations before early termination.
+
+    # Returns
+
+    A tuple `(lat_deg, lon_deg)` where:
+    * `lat_deg` - Latitude location [degrees].
+    * `lon_deg` - Longitude location [degrees].
+    """
+
+def vincenty_inverse(
+    lat_a_deg: builtins.float,
+    lon_a_deg: builtins.float,
+    lat_b_deg: builtins.float,
+    lon_b_deg: builtins.float,
+    atol: builtins.float = ...,
+    max_iters: builtins.int = ...,
+) -> tuple[builtins.float, builtins.float, builtins.float]:
+    r"""
+    Calculates range and bearings between two latitude-longitude points. This function uses an iterative solution to
+    determine outputs using the WGS84 ellipsoidal Earth model.
+
+    See reference:
+    https://en.wikipedia.org/wiki/Vincenty%27s_formulae.
+
+    # Arguments
+
+    * `lat_a_deg` - Latitude point A [degrees].
+    * `lon_a_deg` - Longitude point A [degrees].
+    * `lat_b_deg` - Latitude point A [degrees].
+    * `lon_b_deg` - Longitude point A [degrees].
+    * `atol` - Absolute tolerance used for convergence.
+    * `max_iters` - Maximum possible number of iterations before early termination.
+
+    # Returns
+
+    A tuple `(range_m, bearing_ab_deg, bearing_ba_deg)` where:
+    * `range_m` - Range (i.e., distance) from point A to point B [meters].
+    * `bearing_ab_deg` - Bearing (i.e., azimuth) from point A to point B relative to true north [degrees].
+    * `bearing_ba_deg` - Bearing (i.e., azimuth) from point B to point A relative to true north [degrees].
+    """

rustmap3d-0.2.3.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: rustmap3d
+Version: 0.2.3
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE
+License-File: LICENSE
+Summary: Python geodetic coordinate conversions written in rust
+Author-email: weiler <lucas.l.weiler@leidos.com>, molnar <andrew.b.molnar@leidos.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/lskyweiler/rustmap3d
+
+# rustmap3d
+
+[![License](https://img.shields.io/badge/license-MIT%2FApache-blue.svg)](https://github.com/lskyweiler/rustmap3d#license)
+![Python](https://img.shields.io/badge/Python_3.8_|_3.9_|_3.10_|_3.11_|_3.12_|_3.13-blue?logo=python&logoColor=fff)
+[![PyPI](https://img.shields.io/badge/PyPI-3775A9?logo=pypi&logoColor=fff)](https://pypi.org/project/rustmap3d/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+<p align="center"><img src="docs/rustmap3d.logo.svg" width="300px" height="300px"/></p>
+
+**Simple, fast, and ergonomic geodetic coordinate conversions**
+
+---
+### Installation
+```bash
+# add to an existing project
+uv add rustmap3d
+# pip install it directly
+uv pip install rustmap3d
+
+# pip install without uv
+pip install rustmap3d
+```
+---
+### Examples
+```python
+import rustmap3d
+
+
+# wgs84 geodetic conversions
+lla = rustmap3d.ecef2lla(x, y, z)
+ecef = rustmap3d.lla2ecef(lat, lon, alt)
+...
+
+# local conversions
+ecef_uvw = rustmap3d.enu2ecef_uvw(e, n, u, lat_ref, lon_ref)
+ecef = rustmap3d.enu2ecef(e, n, u, lat_ref, lon_ref)
+ecef_uvw = rustmap3d.ned2ecef_uvw(n, e, d, lat_ref, lon_ref)
+ecef = rustmap3d.ned2ecef(n, e, d, lat_ref, lon_ref)
+# enu, ned, aer
+...  
+
+# local rotations
+enu_quat = rustmap3d.enu2ecef_quat(lat, lon)
+enu_dcm = rustmap3d.enu2ecef_dcm(lat, lon) 
+# enu, ned
+
+# Conversions
+dd = rustmap3d.dms2dd("25:22:44.738N")  #> 25.37909389
+dms = rustmap3d.dd2dms(25.37909389, is_lat=true) #> "25:22:44.738N"
+lat, lon = rustmap3d.ll2dms(25.37909389, -138.7895679)  #> "25:22:44.738N", "138:47:22.444W"
+...  
+
+# distance functions
+lat, lon = rustmap3d.vincenty_direct(lat_deg, lon_deg, range_m, bearing_deg)
+range_m, bearing_ab, bearing_ba = rustmap3d.vincenty_inverse(lat_a, lon_a, lat_b, lon_b)
+```
+
+## Comparison with similar packages
+
+- 🚀🚀 Blazingly fast - written in rust (see [benchmarks](#benchmarks))
+- Zero dependencies
+- Dead simple api modeled after [pymap3d](https://github.com/geospace-code/pymap3d) and [matlab](https://www.mathworks.com/matlabcentral/fileexchange/15285-geodetic-toolbox)
+- Exposes rotations (both quaternions and 3x3 matrices)
+
+## Benchmarks
+
+Compared to [pymap3d](https://github.com/geospace-code/pymap3d)
+> Note: This is comparing single calls of python floats, not vectorized numpy performance. Vectorized batched conversions will be implemented in the future
+
+- *~50x* faster for lla2ecef
+- *~400x* faster for ecef2lla
+
+<p align="center"><img src="docs/benchmarks.svg"></p>
+
+```bash
+# Run benchmarks
+uv run pytest --benchmark-histogram="./docs/benchmarks" bench/
+```
+
+## Build From Source
+
+Uses standard [maturin](https://github.com/PyO3/maturin) build process
+
+```bash
+uv run maturin build -r   # build a whl
+uv run maturin dev -r     # build a dev package similar to -e
+```
+

rustmap3d-0.2.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+rustmap3d/__init__.py,sha256=3KvRU840onBHW4lM0rI1gngSINaQf2XjWebzsEnLULo,119
+rustmap3d/__init__.pyi,sha256=4VKlAGbeyYr2EYv0sVZBQk-wBYEDR0dUdNkBbZIPqZQ,22918
+rustmap3d/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustmap3d/rustmap3d.cp314-win_amd64.pyd,sha256=G6FY4VEBR1KRFsmWJ02uN8ILirOfx5BpDybm713j1og,1792000
+rustmap3d-0.2.3.dist-info/METADATA,sha256=tjFxvGNw7IA3zd2gFDcFQviGMhiRjTCu9U7Skg0BtgY,3429
+rustmap3d-0.2.3.dist-info/WHEEL,sha256=TASrtxyeL-Pi7odwPBMCgR1YebCHdBFZvgqiADG_4b0,97
+rustmap3d-0.2.3.dist-info/licenses/LICENSE,sha256=nPus_5ylrEEVZWLoXU2-Sz5VWnp4BPaNUt0bP2FY52o,1070
+rustmap3d-0.2.3.dist-info/RECORD,,

rustmap3d-0.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64

rustmap3d-0.2.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [rustmap3d]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.