Struct FlatPoint 

pub struct FlatPoint<T> {
    pub x: T,
    pub y: T,
}

Representation of a geographical point on Earth as projected by a FlatProjection instance.

let (lon, lat) = (6.186389, 50.823194);

let proj = FlatProjection::new(6., 51.);

let flat_point = proj.project(lon, lat);

Fields

x: T

X-axis component of the flat-surface point in kilometers

y: T

Y-axis component of the flat-surface point in kilometers

Implementations

impl<T: Float> FlatPoint<T>

pub fn distance(&self, other: &FlatPoint<T>) -> T

Calculates the approximate distance in kilometers from this FlatPoint to another.

let (lon1, lat1) = (6.186389, 50.823194);
let (lon2, lat2) = (6.953333, 51.301389);

let proj = FlatProjection::new(6.5, 51.05);

let p1 = proj.project(lon1, lat1);
let p2 = proj.project(lon2, lat2);

let distance = p1.distance(&p2);
// -> 75.648 km

pub fn distance_squared(&self, other: &FlatPoint<T>) -> T

Calculates the approximate squared distance from this FlatPoint to another.

This method can be used for fast distance comparisons.

pub fn bearing(&self, other: &FlatPoint<T>) -> T

Calculates the approximate average bearing in degrees between -180 and 180 from this FlatPoint to another.

let (lon1, lat1) = (6.186389, 50.823194);
let (lon2, lat2) = (6.953333, 51.301389);

let proj = FlatProjection::new(6.5, 51.05);

let p1 = proj.project(lon1, lat1);
let p2 = proj.project(lon2, lat2);

let bearing = p1.bearing(&p2);
// -> 45.3°

pub fn distance_bearing(&self, other: &FlatPoint<T>) -> (T, T)

Calculates the approximate distance and average bearing from this FlatPoint to another.

let (lon1, lat1) = (6.186389, 50.823194);
let (lon2, lat2) = (6.953333, 51.301389);

let proj = FlatProjection::new(6.5, 51.05);

let p1 = proj.project(lon1, lat1);
let p2 = proj.project(lon2, lat2);

let (distance, bearing) = p1.distance_bearing(&p2);
// -> 75.648 km and 45.3°

pub fn destination(&self, dist: T, bearing: T) -> FlatPoint<T>

Returns a new FlatPoint given distance and bearing from this FlatPoint.

let (lon, lat) = (30.5, 50.5);

let proj = FlatProjection::new(31., 50.);

let p1 = proj.project(lon, lat);
let (distance, bearing) = (1., 45.0);
let p2 = p1.destination(distance, bearing);

pub fn offset(&self, dx: T, dy: T) -> FlatPoint<T>

Returns a new FlatPoint given easting and northing offsets (in kilometers) from this FlatPoint.

let (lon, lat) = (30.5, 50.5);

let proj = FlatProjection::new(31., 50.);

let p1 = proj.project(lon, lat);
let p2 = p1.offset(10., 10.);

Trait Implementations

impl<T: Clone> Clone for FlatPoint<T>

fn clone(&self) -> FlatPoint<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FlatPoint<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for FlatPoint<T>

fn eq(&self, other: &FlatPoint<T>) -> 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<T: PartialOrd> PartialOrd for FlatPoint<T>

fn partial_cmp(&self, other: &FlatPoint<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy> Copy for FlatPoint<T>

impl<T> StructuralPartialEq for FlatPoint<T>