Struct Coord

pub struct Coord<T = f64>
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 Coord 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> Coord<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::coord;

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

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

impl<T> Coord<T>

where T: CoordNum,

Create a coordinate at the origin.

Examples

use geo_types::Coord;
use num_traits::Zero;

let p: Coord = Zero::zero();

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

pub fn zero() -> Coord<T>

Trait Implementations

impl<T> AbsDiffEq for Coord<T>

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

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

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

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

fn abs_diff_eq( &self, other: &Coord<T>, epsilon: <T as AbsDiffEq>::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 for Coord<T>

where T: CoordNum,

Add two coordinates.

Examples

use geo_types::coord;

let p = coord! { x: 1.25, y: 2.5 };
let q = coord! { x: 1.5, y: 2.5 };
let sum = p + q;

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

type Output = Coord<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> BoundingRect<T> for Coord<T>

where T: CoordNum,

fn bounding_rect(&self) -> Self::Output

Return the bounding rectangle for a Coord. It will have zero width and zero height.

type Output = Rect<T>

impl<T> Clone for Coord<T>

where T: Clone + CoordNum,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: GeoFloat> ClosestPoint<F> for Coord<F>

fn closest_point(&self, p: &Point<F>) -> Closest<F>

Find the closest point between self and p.

impl<T> Contains<Coord<T>> for Geometry<T>

where T: GeoNum,

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

impl<T> Contains<Coord<T>> for GeometryCollection<T>

where T: GeoNum,

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

impl<T> Contains<Coord<T>> for Line<T>

where T: GeoNum,

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

impl<T> Contains<Coord<T>> for LineString<T>

where T: GeoNum,

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

impl<T> Contains<Coord<T>> for MultiPoint<T>

where T: CoordNum,

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

impl<T> Contains<Coord<T>> for MultiPolygon<T>

where T: GeoNum,

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

impl<T> Contains<Coord<T>> for Point<T>

where T: CoordNum,

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

impl<T> Contains<Coord<T>> for Polygon<T>

where T: GeoNum,

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

impl<T> Contains<Coord<T>> for Rect<T>

where T: CoordNum,

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

impl<T> Contains<Coord<T>> for Triangle<T>

where T: GeoNum,

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

impl<T> CoordinatePosition for Coord<T>

where T: GeoNum,

type Scalar = T

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

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

impl<T> Debug for Coord<T>

where T: Debug + CoordNum,

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

Formats the value using the given formatter.

impl<T> Default for Coord<T>

where T: Default + CoordNum,

fn default() -> Coord<T>

Returns the “default value” for a type.

impl<F> Distance<F, &Line<F>, Coord<F>> for Euclidean

where F: CoordFloat,

fn distance(a: &Line<F>, b: Coord<F>) -> F

Note that not all implementations support all geometry combinations, but at least Point to Point is supported. See specific implementations for details.

impl<F: CoordFloat> Distance<F, Coord<F>, &Line<F>> for Euclidean

fn distance(coord: Coord<F>, line: &Line<F>) -> F

Note that not all implementations support all geometry combinations, but at least Point to Point is supported. See specific implementations for details.

impl<F: CoordFloat> Distance<F, Coord<F>, Coord<F>> for Euclidean

fn distance(origin: Coord<F>, destination: Coord<F>) -> F

Note that not all implementations support all geometry combinations, but at least Point to Point is supported. See specific implementations for details.

impl<T> Div<T> for Coord<T>

where T: CoordNum,

Divide coordinate wise by a scalar.

Examples

use geo_types::coord;

let p = coord! { x: 5., y: 10. };
let q = p / 4.;

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

type Output = Coord<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> EuclideanDistance<T> for Coord<T>

where T: GeoFloat,

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

👎Deprecated since 0.29.0: Please use the Euclidean::distance method from the Distance trait instead

Minimum distance between two Coords

impl<T> EuclideanDistance<T, Coord<T>> for Line<T>

where T: GeoFloat,

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

👎Deprecated since 0.29.0: Please use the Euclidean::distance method from the Distance trait instead

Minimum distance from a Line to a Coord

impl<T> EuclideanDistance<T, Line<T>> for Coord<T>

where T: GeoFloat,

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

👎Deprecated since 0.29.0: Please use the Euclidean::distance method from the Distance trait instead

Minimum distance from a Coord to a Line

impl<T> From<[T; 2]> for Coord<T>

where T: CoordNum,

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

Converts to this type from the input type.

impl<T> From<(T, T)> for Coord<T>

where T: CoordNum,

fn from(coords: (T, T)) -> Coord<T>

Converts to this type from the input type.

impl<T: GeoNum> From<Coord<T>> for LineOrPoint<T>

Convert from a Coord

fn from(c: Coord<T>) -> Self

Converts to this type from the input type.

impl<T> From<Coord<T>> for Point<T>

where T: CoordNum,

fn from(x: Coord<T>) -> Point<T>

Converts to this type from the input type.

impl<T> From<Point<T>> for Coord<T>

where T: CoordNum,

fn from(point: Point<T>) -> Coord<T>

Converts to this type from the input type.

impl<T> Hash for Coord<T>

where T: Hash + CoordNum,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> HausdorffDistance<T> for Coord<T>

where T: GeoFloat,

fn hausdorff_distance<Rhs>(&self, rhs: &Rhs) -> T

where Rhs: CoordsIter<Scalar = T>,

impl<T> HaversineClosestPoint<T> for Coord<T>

where T: GeoFloat + FromPrimitive,

fn haversine_closest_point(&self, pt: &Point<T>) -> Closest<T>

impl<T> Intersects<Coord<T>> for Line<T>

where T: GeoNum,

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

impl<T: GeoNum> Intersects<Coord<T>> for MonoPoly<T>

fn intersects(&self, other: &Coord<T>) -> bool

impl<T: GeoNum> Intersects<Coord<T>> for MonotonicPolygons<T>

fn intersects(&self, other: &Coord<T>) -> bool

impl<T> Intersects<Coord<T>> for Polygon<T>

where T: GeoNum,

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

impl<T> Intersects<Coord<T>> for Rect<T>

where T: CoordNum,

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

impl<T> Intersects<Coord<T>> for Triangle<T>

where T: GeoNum,

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

impl<T> Intersects<Geometry<T>> for Coord<T>

where Geometry<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<GeometryCollection<T>> for Coord<T>

where GeometryCollection<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<Line<T>> for Coord<T>

where Line<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<LineString<T>> for Coord<T>

where LineString<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<MultiPoint<T>> for Coord<T>

where MultiPoint<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<Point<T>> for Coord<T>

where T: CoordNum,

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

impl<T> Intersects<Polygon<T>> for Coord<T>

where Polygon<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<Rect<T>> for Coord<T>

where Rect<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects<Triangle<T>> for Coord<T>

where Triangle<T>: Intersects<Coord<T>>, T: CoordNum,

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

impl<T> Intersects for Coord<T>

where T: CoordNum,

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

impl<T> Mul<T> for Coord<T>

where T: CoordNum,

Multiply coordinate wise by a scalar.

Examples

use geo_types::coord;

let p = coord! { x: 1.25, y: 2.5 };
let q = p * 4.;

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

type Output = Coord<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Neg for Coord<T>

where T: CoordNum + Neg<Output = T>,

Negate a coordinate.

Examples

use geo_types::coord;

let p = coord! { x: 1.25, y: 2.5 };
let q = -p;

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

type Output = Coord<T>

The resulting type after applying the - operator.

fn neg(self) -> Coord<T>

Performs the unary - operation.

impl<T> PartialEq for Coord<T>

where T: PartialEq + CoordNum,

fn eq(&self, other: &Coord<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> Point for Coord<T>

where T: Float + RTreeNum,

const DIMENSIONS: usize = 2usize

The number of dimensions of this point type.

type Scalar = T

The number type used by this point type.

fn generate( generator: impl FnMut(usize) -> <Coord<T> as Point>::Scalar, ) -> Coord<T>

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

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

Returns a single coordinate of this point.

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

Mutable variant of nth.

impl<T> RelativeEq for Coord<T>

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

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

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

fn relative_eq( &self, other: &Coord<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::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 for Coord<T>

where T: CoordNum,

Subtract a coordinate from another.

Examples

use geo_types::coord;

let p = coord! { x: 1.5, y: 2.5 };
let q = coord! { x: 1.25, y: 2.5 };
let diff = p - q;

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

type Output = Coord<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> UlpsEq for Coord<T>

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

fn default_max_ulps() -> u32

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

fn ulps_eq( &self, other: &Coord<T>, epsilon: <T as AbsDiffEq>::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> Vector2DOps for Coord<T>

where T: CoordFloat,

type Scalar = T

fn wedge_product(self, other: Coord<T>) -> Self::Scalar

The calculates the wedge product between two vectors.

fn dot_product(self, other: Self) -> Self::Scalar

The inner product of the coordinate components

fn magnitude(self) -> Self::Scalar

The euclidean distance between this coordinate and the origin

fn magnitude_squared(self) -> Self::Scalar

The squared distance between this coordinate and the origin. (Avoids the square root calculation when it is not needed)

fn left(self) -> Self

Rotate this coordinate around the origin by 90 degrees clockwise.

fn right(self) -> Self

Rotate this coordinate around the origin by 90 degrees anti-clockwise.

fn try_normalize(self) -> Option<Self>

Try to find a vector of unit length in the same direction as this vector.

fn is_finite(self) -> bool

Returns true if both the x and y components are finite

impl<T> Zero for Coord<T>

where T: CoordNum,

fn zero() -> Coord<T>

Returns the additive identity element of Self, 0.

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 Coord<T>

where T: Copy + CoordNum,

impl<T> Eq for Coord<T>

where T: Eq + CoordNum,

impl<T> StructuralPartialEq for Coord<T>

where T: CoordNum,