Struct geo::Point

pub struct Point<T>(pub Coordinate<T>)
 where
    T: CoordNum;

A single point in 2D space.

Points can be created using the Point::new constructor, the [point!] macro, or from a Coordinate, two-element tuples, or arrays – see the From impl section for a complete list.

Semantics

The interior of the point is itself (a singleton set), and its boundary is empty. A point is valid if and only if the Coordinate is valid.

Examples

use geo_types::{Coordinate, Point};
let p1: Point<f64> = (0., 1.).into();
let c = Coordinate { x: 10., y: 20. };
let p2: Point<f64> = c.into();

Tuple Fields

0: Coordinate<T>

Implementations

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

pub fn new(x: T, y: T) -> Point<T>

Creates a new point.

Examples

use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.x(), 1.234);
assert_eq!(p.y(), 2.345);

pub fn x(self) -> T

Returns the x/horizontal component of the point.

Examples

use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.x(), 1.234);

pub fn set_x(&mut self, x: T) -> &mut Point<T>

Sets the x/horizontal component of the point.

Examples

use geo_types::Point;

let mut p = Point::new(1.234, 2.345);
p.set_x(9.876);

assert_eq!(p.x(), 9.876);

pub fn y(self) -> T

Returns the y/vertical component of the point.

Examples

use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.y(), 2.345);

pub fn set_y(&mut self, y: T) -> &mut Point<T>

Sets the y/vertical component of the point.

Examples

use geo_types::Point;

let mut p = Point::new(1.234, 2.345);
p.set_y(9.876);

assert_eq!(p.y(), 9.876);

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

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

Examples

use geo_types::Point;

let mut p = Point::new(1.234, 2.345);
let (x, y) = p.x_y();

assert_eq!(y, 2.345);
assert_eq!(x, 1.234);

pub fn lng(self) -> T

👎 Deprecated:

use Point::x instead, it’s less ambigous

Returns the longitude/horizontal component of the point.

Examples

use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.x(), 1.234);

pub fn set_lng(&mut self, lng: T) -> &mut Point<T>

👎 Deprecated:

use Point::set_x instead, it’s less ambigous

Sets the longitude/horizontal component of the point.

Examples

use geo_types::Point;

let mut p = Point::new(1.234, 2.345);
#[allow(deprecated)]
p.set_lng(9.876);

assert_eq!(p.x(), 9.876);

pub fn lat(self) -> T

👎 Deprecated:

use Point::y instead, it’s less ambigous

Returns the latitude/vertical component of the point.

Examples

use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.y(), 2.345);

pub fn set_lat(&mut self, lat: T) -> &mut Point<T>

👎 Deprecated:

use Point::set_y instead, it’s less ambigous

Sets the latitude/vertical component of the point.

Examples

use geo_types::Point;

let mut p = Point::new(1.234, 2.345);
#[allow(deprecated)]
p.set_lat(9.876);

assert_eq!(p.y(), 9.876);

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

pub fn dot(self, other: Point<T>) -> T

Returns the dot product of the two points: dot = x1 * x2 + y1 * y2

Examples

use geo_types::{Coordinate, Point};

let point = Point(Coordinate { x: 1.5, y: 0.5 });
let dot = point.dot(Point(Coordinate { x: 2.0, y: 4.5 }));

assert_eq!(dot, 5.25);

pub fn cross_prod(self, point_b: Point<T>, point_c: Point<T>) -> T

Returns the cross product of 3 points. A positive value implies self → point_b → point_c is counter-clockwise, negative implies clockwise.

Examples

use geo_types::{Coordinate, Point};

let point_a = Point(Coordinate { x: 1., y: 2. });
let point_b = Point(Coordinate { x: 3., y: 5. });
let point_c = Point(Coordinate { x: 7., y: 12. });

let cross = point_a.cross_prod(point_b, point_c);

assert_eq!(cross, 2.0)

impl<T> Point<T> where
    T: CoordFloat, 

pub fn to_degrees(self) -> Point<T>

Converts the (x,y) components of Point to degrees

Example

use geo_types::Point;

let p = Point::new(1.234, 2.345);
let (x, y): (f32, f32) = p.to_degrees().x_y();
assert_eq!(x.round(), 71.0);
assert_eq!(y.round(), 134.0);

pub fn to_radians(self) -> Point<T>

Converts the (x,y) components of Point to radians

Example

use geo_types::Point;

let p = Point::new(180.0, 341.5);
let (x, y): (f32, f32) = p.to_radians().x_y();
assert_eq!(x.round(), 3.0);
assert_eq!(y.round(), 6.0);

Trait Implementations

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

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

Equality assertion with an absolute limit.

Examples

use geo_types::Point;

let a = Point::new(2.0, 3.0);
let b = Point::new(2.0, 3.0000001);

approx::assert_relative_eq!(a, b, epsilon=0.1)

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

Used for specifying relative comparisons.

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

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

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

The inverse of [AbsDiffEq::abs_diff_eq].

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

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

Add a point to the given point.

Examples

use geo_types::Point;

let p = Point::new(1.25, 2.5) + Point::new(1.5, 2.5);

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

type Output = Point<T>

The resulting type after applying the + operator.

impl<T> AddAssign<Point<T>> for Point<T> where
    T: CoordNum, 

pub fn add_assign(&mut self, rhs: Point<T>)

Add a point to the given point and assign it to the original point.

Examples

use geo_types::Point;

let mut p = Point::new(1.25, 2.5);
p += Point::new(1.5, 2.5);

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

impl<T> Area<T> for Point<T> where
    T: CoordNum, 

fn signed_area(&self) -> T

fn unsigned_area(&self) -> T

impl<T> Bearing<T> for Point<T> where
    T: CoordFloat, 

fn bearing(&self, point: Point<T>) -> T

Returns the bearing to another Point in degrees, where North is 0° and East is 90°.

impl<T> BoundingRect<T> for Point<T> where
    T: CoordNum, 

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

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

type Output = Rect<T>

impl<T> Centroid for Point<T> where
    T: GeoFloat, 

type Output = Point<T>

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

See: https://en.wikipedia.org/wiki/Centroid

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, F, C> ClosestPoint<F, Point<F>> for &'a C where
    C: ClosestPoint<F>,
    F: GeoFloat, 

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Point<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for MultiLineString<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for GeometryCollection<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Geometry<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Line<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for LineString<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Polygon<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Coordinate<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Triangle<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for Rect<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for MultiPolygon<F>

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

Find the closest point between self and p.

impl<F: GeoFloat> ClosestPoint<F, Point<F>> for MultiPoint<F>

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

Find the closest point between self and p.

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

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

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

fn contains(&self, point: &Point<T>) -> bool

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

fn contains(&self, point: &Point<T>) -> bool

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

fn contains(&self, p: &Point<T>) -> bool

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

fn contains(&self, p: &Point<T>) -> bool

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

fn contains(&self, p: &Point<T>) -> bool

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

fn contains(&self, p: &Point<T>) -> bool

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

fn contains(&self, p: &Point<T>) -> bool

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

fn contains(&self, p: &Point<T>) -> bool

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

fn contains(&self, point: &Point<T>) -> bool

impl<T> CoordinatePosition for Point<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<'a, T: CoordNum> CoordsIter<'a> for Point<T>

fn coords_count(&'a self) -> usize

Return the number of coordinates in the Point.

type Iter = Once<Coordinate<T>>

type ExteriorIter = Self::Iter

type Scalar = T

fn coords_iter(&'a self) -> Self::Iter

Iterate over all exterior and (if any) interior coordinates of a geometry.

fn exterior_coords_iter(&'a self) -> Self::ExteriorIter

Iterate over all exterior coordinates of a geometry.

impl<T> Debug for Point<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 Point<T> where
    T: Default + CoordNum, 

pub fn default() -> Point<T>

Returns the “default value” for a type.

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

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

Scaler division of a point

Examples

use geo_types::Point;

let p = Point::new(2.0, 3.0) / 2.0;

assert_eq!(p.x(), 1.0);
assert_eq!(p.y(), 1.5);

type Output = Point<T>

The resulting type after applying the / operator.

impl<T> DivAssign<T> for Point<T> where
    T: CoordNum, 

pub fn div_assign(&mut self, rhs: T)

Scaler division of a point in place

Examples

use geo_types::Point;

let mut p = Point::new(2.0, 3.0);
p /= 2.0;

assert_eq!(p.x(), 1.0);
assert_eq!(p.y(), 1.5);

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

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

Minimum distance from a Line to a Point

impl<T> EuclideanDistance<T, LineString<T>> for Point<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, linestring: &LineString<T>) -> T

Minimum distance from a Point to a LineString

impl<T> EuclideanDistance<T, MultiLineString<T>> for Point<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, mls: &MultiLineString<T>) -> T

Minimum distance from a Point to a MultiLineString

impl<T> EuclideanDistance<T, MultiPoint<T>> for Point<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, points: &MultiPoint<T>) -> T

Minimum distance from a Point to a MultiPoint

impl<T> EuclideanDistance<T, MultiPolygon<T>> for Point<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, mpolygon: &MultiPolygon<T>) -> T

Minimum distance from a Point to a MultiPolygon

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

fn euclidean_distance(&self, p: &Point<T>) -> T

Minimum distance between two Points

impl<T> EuclideanDistance<T, Point<T>> for MultiPoint<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, point: &Point<T>) -> T

Minimum distance from a MultiPoint to a Point

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

fn euclidean_distance(&self, point: &Point<T>) -> T

Minimum distance from a Line to a Point

impl<T> EuclideanDistance<T, Point<T>> for LineString<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, point: &Point<T>) -> T

Minimum distance from a LineString to a Point

impl<T> EuclideanDistance<T, Point<T>> for MultiLineString<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, point: &Point<T>) -> T

Minimum distance from a MultiLineString to a Point

impl<T> EuclideanDistance<T, Point<T>> for Polygon<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, point: &Point<T>) -> T

Minimum distance from a Polygon to a Point

impl<T> EuclideanDistance<T, Point<T>> for MultiPolygon<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, point: &Point<T>) -> T

Minimum distance from a MultiPolygon to a Point

impl<T> EuclideanDistance<T, Point<T>> for Triangle<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, point: &Point<T>) -> T

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Polygon<T>> for Point<T> where
    T: GeoFloat, 

fn euclidean_distance(&self, polygon: &Polygon<T>) -> T

Minimum distance from a Point to a Polygon

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

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

Performs the conversion.

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

pub fn from(coords: (T, T)) -> Point<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 Geometry<T> where
    T: CoordNum, 

pub fn from(x: Point<T>) -> Geometry<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 GeodesicDistance<f64, Point<f64>> for Point<f64>

fn geodesic_distance(&self, rhs: &Point<f64>) -> f64

Determine the distance between two geometries on an ellipsoidal model of the earth.

impl GeodesicIntermediate<f64> for Point<f64>

fn geodesic_intermediate(&self, other: &Point<f64>, f: f64) -> Point<f64>

Returns a new Point along a route between two existing points on an ellipsoidal model of the earth

fn geodesic_intermediate_fill(
    &self,
    other: &Point<f64>,
    max_dist: f64,
    include_ends: bool
) -> Vec<Point<f64>>

impl<C: CoordNum> HasDimensions for Point<C>

fn is_empty(&self) -> bool

Some geometries, like a MultiPoint, can have zero coordinates - we call these empty.

fn dimensions(&self) -> Dimensions

The dimensions of some geometries are fixed, e.g. a Point always has 0 dimensions. However for others, the dimensionality depends on the specific geometry instance - for example typical Rects are 2-dimensional, but it’s possible to create degenerate Rects which have either 1 or 0 dimensions.

fn boundary_dimensions(&self) -> Dimensions

The dimensions of the Geometry’s boundary, as used by OGC-SFA.

impl<T> Hash for Point<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> HaversineDestination<T> for Point<T> where
    T: CoordFloat + FromPrimitive, 

fn haversine_destination(&self, bearing: T, distance: T) -> Point<T>

Returns a new Point using distance to the existing Point and a bearing for the direction

impl<T> HaversineDistance<T, Point<T>> for Point<T> where
    T: CoordFloat + FromPrimitive, 

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

Determine the distance between two geometries using the haversine formula.

impl<T> HaversineIntermediate<T> for Point<T> where
    T: CoordFloat + FromPrimitive, 

fn haversine_intermediate(&self, other: &Point<T>, f: T) -> Point<T>

Returns a new Point along a great circle route between two existing points.

fn haversine_intermediate_fill(
    &self,
    other: &Point<T>,
    max_dist: T,
    include_ends: bool
) -> Vec<Point<T>>

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

fn intersects(&self, rhs: &G) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> LineLocatePoint<T, Point<T>> for Line<T> where
    T: CoordFloat, 

type Output = Option<T>

type Rhs = Point<T>

fn line_locate_point(&self, p: &Self::Rhs) -> Self::Output

impl<T> LineLocatePoint<T, Point<T>> for LineString<T> where
    T: CoordFloat + AddAssign,
    Line<T>: EuclideanDistance<T, Point<T>> + EuclideanLength<T>,
    LineString<T>: EuclideanLength<T>, 

type Output = Option<T>

type Rhs = Point<T>

fn line_locate_point(&self, p: &Self::Rhs) -> Self::Output

impl<T: CoordNum, NT: CoordNum> MapCoords<T, NT> for Point<T>

type Output = Point<NT>

fn map_coords(&self, func: impl Fn(&(T, T)) -> (NT, NT) + Copy) -> Self::Output

Apply a function to all the coordinates in a geometric object, returning a new object.

impl<T: CoordNum> MapCoordsInplace<T> for Point<T>

fn map_coords_inplace(&mut self, func: impl Fn(&(T, T)) -> (T, T))

Apply a function to all the coordinates in a geometric object, in place

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

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

Scaler multiplication of a point

Examples

use geo_types::Point;

let p = Point::new(2.0, 3.0) * 2.0;

assert_eq!(p.x(), 4.0);
assert_eq!(p.y(), 6.0);

type Output = Point<T>

The resulting type after applying the * operator.

impl<T> MulAssign<T> for Point<T> where
    T: CoordNum, 

pub fn mul_assign(&mut self, rhs: T)

Scaler multiplication of a point in place

Examples

use geo_types::Point;

let mut p = Point::new(2.0, 3.0);
p *= 2.0;

assert_eq!(p.x(), 4.0);
assert_eq!(p.y(), 6.0);

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

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

Returns a point with the x and y components negated.

Examples

use geo_types::Point;

let p = -Point::new(-1.25, 2.5);

assert_eq!(p.x(), 1.25);
assert_eq!(p.y(), -2.5);

type Output = Point<T>

The resulting type after applying the - operator.

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

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

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

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

This method tests for !=.

impl<T> Point for Point<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) -> <Point<T> as Point>::Scalar
) -> Point<T>

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

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

Returns a single coordinate of this point.

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

Mutable variant of nth.

impl<F: GeoFloat> Relate<F, GeometryCollection<F>> for Point<F>

fn relate(&self, other: &GeometryCollection<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Line<F>> for Point<F>

fn relate(&self, other: &Line<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, LineString<F>> for Point<F>

fn relate(&self, other: &LineString<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, MultiLineString<F>> for Point<F>

fn relate(&self, other: &MultiLineString<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, MultiPoint<F>> for Point<F>

fn relate(&self, other: &MultiPoint<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, MultiPolygon<F>> for Point<F>

fn relate(&self, other: &MultiPolygon<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for Point<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for Line<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for LineString<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for Polygon<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for MultiPoint<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for MultiLineString<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for MultiPolygon<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for Rect<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for Triangle<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Point<F>> for GeometryCollection<F>

fn relate(&self, other: &Point<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Polygon<F>> for Point<F>

fn relate(&self, other: &Polygon<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Rect<F>> for Point<F>

fn relate(&self, other: &Rect<F>) -> IntersectionMatrix

impl<F: GeoFloat> Relate<F, Triangle<F>> for Point<F>

fn relate(&self, other: &Triangle<F>) -> IntersectionMatrix

impl<T> RelativeEq<Point<T>> for Point<T> where
    T: AbsDiffEq<T, Epsilon = T> + CoordNum + RelativeEq<T>, 

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

Equality assertion within a relative limit.

Examples

use geo_types::Point;

let a = Point::new(2.0, 3.0);
let b = Point::new(2.0, 3.01);

approx::assert_relative_eq!(a, b, max_relative=0.1)

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

The default relative tolerance for testing values that 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> Rotate<T> for Point<T> where
    T: CoordFloat, 

fn rotate(&self, _angle: T) -> Self

👎 Deprecated:

Equivalent to rotate_around_centroid except for Polygon<T>, where it is equivalent to rotating around the polygon’s outer ring. Call that instead, or rotate_around_center if you’d like to rotate around the geometry’s bounding box center.

Rotate the Point about itself by the given number of degrees This operation leaves the point coordinates unchanged

fn rotate_around_centroid(&self, _angle: T) -> Self

Rotate a geometry around its centroid by an angle, in degrees

fn rotate_around_center(&self, _angle: T) -> Self

Rotate a geometry around the center of its bounding box by an angle, in degrees.

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

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

Subtract a point from the given point.

Examples

use geo_types::Point;

let p = Point::new(1.25, 3.0) - Point::new(1.5, 2.5);

assert_eq!(p.x(), -0.25);
assert_eq!(p.y(), 0.5);

type Output = Point<T>

The resulting type after applying the - operator.

impl<T> SubAssign<Point<T>> for Point<T> where
    T: CoordNum, 

pub fn sub_assign(&mut self, rhs: Point<T>)

Subtract a point from the given point and assign it to the original point.

Examples

use geo_types::Point;

let mut p = Point::new(1.25, 2.5);
p -= Point::new(1.5, 2.5);

assert_eq!(p.x(), -0.25);
assert_eq!(p.y(), 0.0);

impl<T> TryFrom<Geometry<T>> for Point<T> where
    T: CoordNum, 

Convert a Geometry enum into its inner type.

Fails if the enum case does not match the type you are trying to convert it to.

type Error = Error

The type returned in the event of a conversion error.

pub fn try_from(
    geom: Geometry<T>
) -> Result<Point<T>, <Point<T> as TryFrom<Geometry<T>>>::Error>

Performs the conversion.

impl<T: CoordNum, NT: CoordNum, E> TryMapCoords<T, NT, E> for Point<T>

type Output = Point<NT>

fn try_map_coords(
    &self,
    func: impl Fn(&(T, T)) -> Result<(NT, NT), E>
) -> Result<Self::Output, E>

Map a fallible function over all the coordinates in a geometry, returning a Result

impl<T> VincentyDistance<T, Point<T>> for Point<T> where
    T: CoordFloat + FromPrimitive, 

fn vincenty_distance(&self, rhs: &Point<T>) -> Result<T, FailedToConvergeError>

Determine the distance between two geometries using Vincenty’s formulae.

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

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

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

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