Struct geo::Coordinate

pub struct Coordinate<T> where
    T: CoordNum,  {
    pub x: T,
    pub y: T,
}

A lightweight struct used to store coordinates on the 2-dimensional Cartesian plane.

Unlike Point (which in the future may contain additional information such as an envelope, a precision model, and spatial reference system information), a Coordinate only contains ordinate values and accessor methods.

This type implements the vector space operations: Add, Sub, Neg, Zero, Mul<T>, and Div<T> traits.

Semantics

This type does not represent any geospatial primitive, but is used in their definitions. The only requirement is that the coordinates it contains are valid numbers (for eg. not f64::NAN).

Fields

x: T

y: T

Implementations

impl<T> Coordinate<T> where
    T: CoordNum, 

pub fn x_y(&self) -> (T, T)

Returns a tuple that contains the x/horizontal & y/vertical component of the coordinate.

Examples

use geo_types::Coordinate;

let c = Coordinate {
    x: 40.02f64,
    y: 116.34,
};
let (x, y) = c.x_y();

assert_eq!(y, 116.34);
assert_eq!(x, 40.02f64);

impl<T> Coordinate<T> where
    T: CoordNum, 

Create a coordinate at the origin.

Examples

use geo_types::Coordinate;
use num_traits::Zero;

let p: Coordinate<f64> = Zero::zero();

assert_eq!(p.x, 0.);
assert_eq!(p.y, 0.);

pub fn zero() -> Coordinate<T>

Trait Implementations

impl<T> AbsDiffEq<Coordinate<T>> for Coordinate<T> where
    T: CoordNum + AbsDiffEq<T>,
    <T as AbsDiffEq<T>>::Epsilon: Copy, 

type Epsilon = <T as AbsDiffEq<T>>::Epsilon

Used for specifying relative comparisons.

pub fn default_epsilon() -> <T as AbsDiffEq<T>>::Epsilon

The default tolerance to use when testing values that are close together.

pub fn abs_diff_eq(
    &self,
    other: &Coordinate<T>,
    epsilon: <T as AbsDiffEq<T>>::Epsilon
) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T> Add<Coordinate<T>> for Coordinate<T> where
    T: CoordNum, 

Add two coordinates.

Examples

use geo_types::Coordinate;

let p: Coordinate<_> = (1.25, 2.5).into();
let q: Coordinate<_> = (1.5, 2.5).into();
let sum = p + q;

assert_eq!(sum.x, 2.75);
assert_eq!(sum.y, 5.0);

type Output = Coordinate<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: Coordinate<T>) -> Coordinate<T>

Performs the + operation.

impl<T> Clone for Coordinate<T> where
    T: Clone + CoordNum, 

pub fn clone(&self) -> Coordinate<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Contains<Coordinate<T>> for Geometry<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for GeometryCollection<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for Line<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for LineString<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for Point<T> where
    T: CoordNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for Polygon<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for MultiPolygon<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for Rect<T> where
    T: CoordNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> Contains<Coordinate<T>> for Triangle<T> where
    T: GeoNum, 

fn contains(&self, coord: &Coordinate<T>) -> bool

impl<T> CoordinatePosition for Coordinate<T> where
    T: GeoNum, 

type Scalar = T

fn calculate_coordinate_position(
    &self,
    coord: &Coordinate<T>,
    is_inside: &mut bool,
    _boundary_count: &mut usize
)

fn coordinate_position(&self, coord: &Coordinate<Self::Scalar>) -> CoordPos

impl<T> Debug for Coordinate<T> where
    T: Debug + CoordNum, 

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

Formats the value using the given formatter.

impl<T> Default for Coordinate<T> where
    T: Default + CoordNum, 

pub fn default() -> Coordinate<T>

Returns the “default value” for a type.

impl<T> Div<T> for Coordinate<T> where
    T: CoordNum, 

Divide coordinate wise by a scalar.

Examples

use geo_types::Coordinate;

let p: Coordinate<_> = (5., 10.).into();
let q: Coordinate<_> = p / 4.;

assert_eq!(q.x, 1.25);
assert_eq!(q.y, 2.5);

type Output = Coordinate<T>

The resulting type after applying the / operator.

pub fn div(self, rhs: T) -> Coordinate<T>

Performs the / operation.

impl<T> EuclideanDistance<T, Coordinate<T>> for Coordinate<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, c: &Coordinate<T>) -> T

Minimum distance between two Coordinates

impl<T> EuclideanDistance<T, Coordinate<T>> for Line<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, coord: &Coordinate<T>) -> T

Minimum distance from a Line to a Coordinate

impl<T> EuclideanDistance<T, Line<T>> for Coordinate<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, line: &Line<T>) -> T

Minimum distance from a Coordinate to a Line

impl<T> From<[T; 2]> for Coordinate<T> where
    T: CoordNum, 

pub fn from(coords: [T; 2]) -> Coordinate<T>

Performs the conversion.

impl<T> From<(T, T)> for Coordinate<T> where
    T: CoordNum, 

pub fn from(coords: (T, T)) -> Coordinate<T>

Performs the conversion.

impl<T> From<Coordinate<T>> for Point<T> where
    T: CoordNum, 

pub fn from(x: Coordinate<T>) -> Point<T>

Performs the conversion.

impl<T> From<Point<T>> for Coordinate<T> where
    T: CoordNum, 

pub fn from(point: Point<T>) -> Coordinate<T>

Performs the conversion.

impl<T> Hash for Coordinate<T> where
    T: Hash + CoordNum, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> Intersects<Coordinate<T>> for Coordinate<T> where
    T: CoordNum, 

fn intersects(&self, rhs: &Coordinate<T>) -> bool

impl<T> Intersects<Coordinate<T>> for Line<T> where
    T: GeoNum, 

fn intersects(&self, rhs: &Coordinate<T>) -> bool

impl<T> Intersects<Coordinate<T>> for Polygon<T> where
    T: GeoNum, 

fn intersects(&self, p: &Coordinate<T>) -> bool

impl<T> Intersects<Coordinate<T>> for Rect<T> where
    T: CoordNum, 

fn intersects(&self, rhs: &Coordinate<T>) -> bool

impl<T> Intersects<Geometry<T>> for Coordinate<T> where
    Geometry<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &Geometry<T>) -> bool

impl<T> Intersects<GeometryCollection<T>> for Coordinate<T> where
    GeometryCollection<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &GeometryCollection<T>) -> bool

impl<T> Intersects<Line<T>> for Coordinate<T> where
    Line<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &Line<T>) -> bool

impl<T> Intersects<LineString<T>> for Coordinate<T> where
    LineString<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &LineString<T>) -> bool

impl<T> Intersects<MultiPoint<T>> for Coordinate<T> where
    MultiPoint<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &MultiPoint<T>) -> bool

impl<T> Intersects<Point<T>> for Coordinate<T> where
    T: CoordNum, 

fn intersects(&self, rhs: &Point<T>) -> bool

impl<T> Intersects<Polygon<T>> for Coordinate<T> where
    Polygon<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &Polygon<T>) -> bool

impl<T> Intersects<Rect<T>> for Coordinate<T> where
    Rect<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &Rect<T>) -> bool

impl<T> Intersects<Triangle<T>> for Coordinate<T> where
    Triangle<T>: Intersects<Coordinate<T>>,
    T: CoordNum, 

fn intersects(&self, rhs: &Triangle<T>) -> bool

impl<T> Mul<T> for Coordinate<T> where
    T: CoordNum, 

Multiply coordinate wise by a scalar.

Examples

use geo_types::Coordinate;

let p: Coordinate<_> = (1.25, 2.5).into();
let q: Coordinate<_> = p * 4.;

assert_eq!(q.x, 5.0);
assert_eq!(q.y, 10.0);

type Output = Coordinate<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: T) -> Coordinate<T>

Performs the * operation.

impl<T> Neg for Coordinate<T> where
    T: CoordNum + Neg<Output = T>, 

Negate a coordinate.

Examples

use geo_types::Coordinate;

let p: Coordinate<_> = (1.25, 2.5).into();
let q = -p;

assert_eq!(q.x, -p.x);
assert_eq!(q.y, -p.y);

type Output = Coordinate<T>

The resulting type after applying the - operator.

pub fn neg(self) -> Coordinate<T>

Performs the unary - operation.

impl<T> PartialEq<Coordinate<T>> for Coordinate<T> where
    T: PartialEq<T> + CoordNum, 

pub fn eq(&self, other: &Coordinate<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Coordinate<T>) -> bool

This method tests for !=.

impl<T> Point for Coordinate<T> where
    T: Float + RTreeNum, 

type Scalar = T

The number type used by this point type.

pub const DIMENSIONS: usize

The number of dimensions of this point type.

pub fn generate(
    generator: impl Fn(usize) -> <Coordinate<T> as Point>::Scalar
) -> Coordinate<T>

Creates a new point value with given values for each dimension.

pub fn nth(&self, index: usize) -> <Coordinate<T> as Point>::Scalar

Returns a single coordinate of this point.

pub fn nth_mut(&mut self, index: usize) -> &mut <Coordinate<T> as Point>::Scalar

Mutable variant of nth.

impl<T> RelativeEq<Coordinate<T>> for Coordinate<T> where
    T: CoordNum + RelativeEq<T>,
    <T as AbsDiffEq<T>>::Epsilon: Copy, 

pub fn default_max_relative() -> <T as AbsDiffEq<T>>::Epsilon

The default relative tolerance for testing values that are far-apart.

pub fn relative_eq(
    &self,
    other: &Coordinate<T>,
    epsilon: <T as AbsDiffEq<T>>::Epsilon,
    max_relative: <T as AbsDiffEq<T>>::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T> Sub<Coordinate<T>> for Coordinate<T> where
    T: CoordNum, 

Subtract a coordinate from another.

Examples

use geo_types::Coordinate;

let p: Coordinate<_> = (1.5, 2.5).into();
let q: Coordinate<_> = (1.25, 2.5).into();
let diff = p - q;

assert_eq!(diff.x, 0.25);
assert_eq!(diff.y, 0.);

type Output = Coordinate<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: Coordinate<T>) -> Coordinate<T>

Performs the - operation.

impl<T> UlpsEq<Coordinate<T>> for Coordinate<T> where
    T: CoordNum + UlpsEq<T>,
    <T as AbsDiffEq<T>>::Epsilon: Copy, 

pub fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

pub fn ulps_eq(
    &self,
    other: &Coordinate<T>,
    epsilon: <T as AbsDiffEq<T>>::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T> Zero for Coordinate<T> where
    T: CoordNum, 

pub fn zero() -> Coordinate<T>

Returns the additive identity element of Self, 0.

pub fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T> Copy for Coordinate<T> where
    T: Copy + CoordNum, 

impl<T> Eq for Coordinate<T> where
    T: Eq + CoordNum, 

impl<T> StructuralEq for Coordinate<T> where
    T: CoordNum, 

impl<T> StructuralPartialEq for Coordinate<T> where
    T: CoordNum,