Struct Location

pub struct Location(/* private fields */);

Location defines a point using its latitude and longitude.

Implementations

impl Location

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

Create a new Location with its degree values of latitude and longitude.

Examples found in repository

examples/location.rs (line 5)

fn main() {
    // Create two locations
    let berlin = Location::new(52.518611, 13.408056);
    let moscow = Location::new(55.751667, 37.617778);

    // Get distance between two locations
    let distance = berlin.distance_to(&moscow).unwrap();
    println!(
        "Distance between berlin and moscow: {} meters",
        distance.meters()
    );

    // Get the center of a number of locations
    let center = Location::center(&[&berlin, &moscow]);
    println!(
        "Center of berlin and moscow: Lat={}, Lon={}",
        center.latitude(),
        center.longitude()
    );

    // Check radial bounds
    let is_in_radius = berlin
        .is_in_circle(&moscow, Distance::from_meters(1000))
        .unwrap();
    println!("Is Berlin in a 1000m radius of Moscow? {}", is_in_radius);
}

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

Create a new const Location with its degree values of latitude and longitude.

pub fn latitude(&self) -> f64

Get the latitude.

Examples found in repository

examples/location.rs (line 19)

fn main() {
    // Create two locations
    let berlin = Location::new(52.518611, 13.408056);
    let moscow = Location::new(55.751667, 37.617778);

    // Get distance between two locations
    let distance = berlin.distance_to(&moscow).unwrap();
    println!(
        "Distance between berlin and moscow: {} meters",
        distance.meters()
    );

    // Get the center of a number of locations
    let center = Location::center(&[&berlin, &moscow]);
    println!(
        "Center of berlin and moscow: Lat={}, Lon={}",
        center.latitude(),
        center.longitude()
    );

    // Check radial bounds
    let is_in_radius = berlin
        .is_in_circle(&moscow, Distance::from_meters(1000))
        .unwrap();
    println!("Is Berlin in a 1000m radius of Moscow? {}", is_in_radius);
}

pub fn longitude(&self) -> f64

Get the longitude.

Examples found in repository

examples/location.rs (line 20)

fn main() {
    // Create two locations
    let berlin = Location::new(52.518611, 13.408056);
    let moscow = Location::new(55.751667, 37.617778);

    // Get distance between two locations
    let distance = berlin.distance_to(&moscow).unwrap();
    println!(
        "Distance between berlin and moscow: {} meters",
        distance.meters()
    );

    // Get the center of a number of locations
    let center = Location::center(&[&berlin, &moscow]);
    println!(
        "Center of berlin and moscow: Lat={}, Lon={}",
        center.latitude(),
        center.longitude()
    );

    // Check radial bounds
    let is_in_radius = berlin
        .is_in_circle(&moscow, Distance::from_meters(1000))
        .unwrap();
    println!("Is Berlin in a 1000m radius of Moscow? {}", is_in_radius);
}

pub fn distance_to(&self, to: &Location) -> Result<Distance, String>

Find the distance from itself to another point. Internally uses Vincenty’s inverse formula. For better performance and lesser accuracy, consider haversine_distance_to. This method returns Err if the formula fails to converge within 100 iterations.

Examples found in repository

examples/location.rs (line 9)

fn main() {
    // Create two locations
    let berlin = Location::new(52.518611, 13.408056);
    let moscow = Location::new(55.751667, 37.617778);

    // Get distance between two locations
    let distance = berlin.distance_to(&moscow).unwrap();
    println!(
        "Distance between berlin and moscow: {} meters",
        distance.meters()
    );

    // Get the center of a number of locations
    let center = Location::center(&[&berlin, &moscow]);
    println!(
        "Center of berlin and moscow: Lat={}, Lon={}",
        center.latitude(),
        center.longitude()
    );

    // Check radial bounds
    let is_in_radius = berlin
        .is_in_circle(&moscow, Distance::from_meters(1000))
        .unwrap();
    println!("Is Berlin in a 1000m radius of Moscow? {}", is_in_radius);
}

pub fn haversine_distance_to(&self, to: &Location) -> Distance

Find the distance from itself to another point using Haversine formula. This is usually computationally less intensive than distance_to but is generally not as accurate.

pub fn is_in_circle( &self, center: &Location, radius: Distance, ) -> Result<bool, String>

Check if the point is within a fixed radius of another point.

Examples found in repository

examples/location.rs (line 25)

fn main() {
    // Create two locations
    let berlin = Location::new(52.518611, 13.408056);
    let moscow = Location::new(55.751667, 37.617778);

    // Get distance between two locations
    let distance = berlin.distance_to(&moscow).unwrap();
    println!(
        "Distance between berlin and moscow: {} meters",
        distance.meters()
    );

    // Get the center of a number of locations
    let center = Location::center(&[&berlin, &moscow]);
    println!(
        "Center of berlin and moscow: Lat={}, Lon={}",
        center.latitude(),
        center.longitude()
    );

    // Check radial bounds
    let is_in_radius = berlin
        .is_in_circle(&moscow, Distance::from_meters(1000))
        .unwrap();
    println!("Is Berlin in a 1000m radius of Moscow? {}", is_in_radius);
}

pub fn center(coords: &[&Location]) -> Location

Find the center of given locations.

Examples found in repository

examples/location.rs (line 16)

fn main() {
    // Create two locations
    let berlin = Location::new(52.518611, 13.408056);
    let moscow = Location::new(55.751667, 37.617778);

    // Get distance between two locations
    let distance = berlin.distance_to(&moscow).unwrap();
    println!(
        "Distance between berlin and moscow: {} meters",
        distance.meters()
    );

    // Get the center of a number of locations
    let center = Location::center(&[&berlin, &moscow]);
    println!(
        "Center of berlin and moscow: Lat={}, Lon={}",
        center.latitude(),
        center.longitude()
    );

    // Check radial bounds
    let is_in_radius = berlin
        .is_in_circle(&moscow, Distance::from_meters(1000))
        .unwrap();
    println!("Is Berlin in a 1000m radius of Moscow? {}", is_in_radius);
}

Trait Implementations

impl Clone for Location

fn clone(&self) -> Location

Returns a copy 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 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 Copy for Location

impl StructuralPartialEq for Location