Struct Location 

pub struct Location {
    pub lat: f64,
    pub lon: f64,
    pub elevation: Option<f64>,
    pub uncertainty_meters: Option<f64>,
    pub name: Option<String>,
}

A geographic location using WGS84 coordinates.

Locations are the fundamental spatial unit in spatial narratives. They support optional elevation and uncertainty for real-world data.

Examples

use spatial_narrative::core::Location;

// Create a location (New York City)
let nyc = Location::new(40.7128, -74.0060);
assert!(nyc.is_valid());

// With elevation (Mount Everest)
let peak = Location::with_elevation(27.9881, 86.9250, 8848.86);

// Using the builder for more options
let approximate = Location::builder()
    .coordinates(40.7, -74.0)
    .uncertainty_meters(1000.0)
    .name("Approximate NYC")
    .build()
    .unwrap();

Coordinate System

Locations use WGS84 (EPSG:4326):

• Latitude: -90° to +90° (negative = South)
• Longitude: -180° to +180° (negative = West)
• Elevation: meters above sea level (optional)

Fields

lat: f64

Latitude in decimal degrees (-90 to 90).

lon: f64

Longitude in decimal degrees (-180 to 180).

elevation: Option<f64>

Elevation in meters above sea level.

uncertainty_meters: Option<f64>

Uncertainty radius in meters.

name: Option<String>

Human-readable place name.

Implementations

impl Location

pub fn new(lat: f64, lon: f64) -> Self

Creates a new location with the given latitude and longitude.

Arguments

• lat - Latitude in decimal degrees (-90 to 90)
• lon - Longitude in decimal degrees (-180 to 180)

Examples

use spatial_narrative::core::Location;

let loc = Location::new(51.5074, -0.1278); // London

pub fn with_elevation(lat: f64, lon: f64, elevation: f64) -> Self

Creates a new location with elevation.

Arguments

• lat - Latitude in decimal degrees
• lon - Longitude in decimal degrees
• elevation - Elevation in meters above sea level

pub fn builder() -> LocationBuilder

Creates a new builder for constructing a Location.

pub fn is_valid(&self) -> bool

Checks if the coordinates are valid WGS84 values.

Returns true if latitude is between -90 and 90, and longitude is between -180 and 180.

pub fn validate(&self) -> Result<()>

Validates the location, returning an error if invalid.

pub fn as_tuple(&self) -> (f64, f64)

Returns the coordinates as a tuple (lat, lon).

pub fn to_geo_point(&self) -> Point<f64>

Returns the coordinates as a geo-types Point.

pub fn from_geo_point(point: Point<f64>) -> Self

Creates a Location from a geo-types Point.

Trait Implementations

impl Clone for Location

fn clone(&self) -> Location

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Location

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

Formats the value using the given formatter.

impl Default for Location

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Location

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(f64, f64)> for Location

fn from((lat, lon): (f64, f64)) -> Self

Converts to this type from the input type.

impl From<Point> for Location

fn from(point: Point<f64>) -> Self

Converts to this type from the input type.

impl PartialEq for Location

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Location