Struct Point 

pub struct Point<T = f64>(pub Coord<T>)
where
    T: CoordNum;

A single point in 2D space.

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 Coord is valid.

Creating a Point

There are many ways to construct a point.

use geo_types::{coord, point, Point};

let p1 = Point::new(0., 1.);

let p2 = point! { x: 1000.0, y: 2000.0 };

let p3: Point = (0., 1.).into();

let c = coord! { x: 10., y: 20. };
let p4: Point = c.into();

See the From impl section for a complete list of conversions.

Coordinate order for geographic points

For geographic points, typically x corresponds to longitude and y to latitude.

Geographic methods in the geo crate expect this common lon/lat order, but different conventions exist in other coordinate systems, notably EPSG:4326, which uses lat/lon ordering.

use geo_types::{coord, point, Point};

let lon = 179.9;
let lat = 45.0;
let geographic_point = Point::new(lon, lat);

Tuple Fields

0: Coord<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.

Typically, x is the horizontal position, or longitude for geographic coordinates, but its interpretation can vary across coordinate systems.

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.

Typically, x is the horizontal position, or longitude for geographic coordinates, but its interpretation can vary across coordinate systems.

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 x_mut(&mut self) -> &mut T

Returns a mutable reference to the x/horizontal component of the point

Typically, x is the horizontal position, or longitude for geographic coordinates, but its interpretation can vary across coordinate systems.

Examples

use approx::assert_relative_eq;
use geo_types::Point;
let mut p = Point::new(1.234, 2.345);
let mut p_x = p.x_mut();
*p_x += 1.0;
assert_relative_eq!(p.x(), 2.234);

pub fn y(self) -> T

Returns the y/vertical component of the point.

Typically, y is the vertical position, or latitude for geographic coordinates, but its interpretation can vary across coordinate systems.

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.

Typically, y is the vertical position, or latitude for geographic coordinates, but its interpretation can vary across coordinate systems.

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 y_mut(&mut self) -> &mut T

Returns a mutable reference to the x/horizontal component of the point

Typically, y is the vertical position, or latitude for geographic coordinates, but its interpretation can vary across coordinate systems.

Examples

use approx::assert_relative_eq;
use geo_types::Point;
let mut p = Point::new(1.234, 2.345);
let mut p_y = p.y_mut();
*p_y += 1.0;
assert_relative_eq!(p.y(), 3.345);

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 ambiguous

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 ambiguous

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 ambiguous

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 ambiguous

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::{point, Point};

let point = point! { x: 1.5, y: 0.5 };
let dot = point.dot(point! { 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.

Note on Robustness

This function is not robust against floating-point errors. The geo crate offers robust predicates for standard numeric types using the Kernel trait, and these should be preferred if possible.

Examples

use geo_types::point;

let point_a = point! { x: 1., y: 2. };
let point_b = point! { x: 3., y: 5. };
let point_c = point! { 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 for Point<T>

where T: CoordNum + AbsDiffEq<Epsilon = T>,

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

Used for specifying relative comparisons.

fn default_epsilon() -> <Point<T> as AbsDiffEq>::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 for Point<T>

where T: CoordNum,

fn add(self, rhs: Point<T>) -> <Point<T> as Add>::Output

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 for Point<T>

where T: CoordNum,

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> AsRef<Coord<T>> for Point<T>

where T: CoordNum,

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

Converts this type into a shared reference of the (usually inferred) input type.

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<F: BoolOpsNum + 'static> Buffer for Point<F>

type Scalar = F

fn buffer_with_style( &self, style: BufferStyle<Self::Scalar>, ) -> MultiPolygon<Self::Scalar>

Create a new geometry whose boundary is offset the specified distance from the input using the specific styling options where lines intersect (line joins) and end (end caps). For default (rounded) styling, see buffer.

fn buffer(&self, distance: Self::Scalar) -> MultiPolygon<Self::Scalar>

Create a new geometry whose boundary is offset the specified distance from the input.

impl<T> Centroid for Point<T>

where T: GeoFloat,

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

The Centroid of a Point is the point itself

Examples

use geo::Centroid;
use geo::point;

let point = point!(x: 1.0f32, y: 2.0);

assert_eq!(
    point!(x: 1.0f32, y: 2.0),
    point.centroid(),
);

type Output = Point<T>

impl<T> ChamberlainDuquetteArea<T> for Point<T>

where T: CoordFloat,

fn chamberlain_duquette_signed_area(&self) -> T

fn chamberlain_duquette_unsigned_area(&self) -> T

impl<T> Clone for Point<T>

where T: Clone + CoordNum,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Find the closest point between self and p.

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

where T: CoordNum,

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

impl<T> Contains<Geometry<T>> for Point<T>

where T: GeoFloat,

fn contains(&self, geometry: &Geometry<T>) -> bool

impl<T> Contains<GeometryCollection<T>> for Point<T>

where T: GeoFloat,

fn contains(&self, geometry_collection: &GeometryCollection<T>) -> bool

impl<T> Contains<Line<T>> for Point<T>

where T: CoordNum,

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

impl<T> Contains<LineString<T>> for Point<T>

where T: CoordNum,

fn contains(&self, line_string: &LineString<T>) -> bool

impl<T> Contains<MultiLineString<T>> for Point<T>

where T: CoordNum,

fn contains(&self, multi_line_string: &MultiLineString<T>) -> bool

impl<T> Contains<MultiPoint<T>> for Point<T>

where T: CoordNum,

fn contains(&self, multi_point: &MultiPoint<T>) -> bool

impl<T> Contains<MultiPolygon<T>> for Point<T>

where T: CoordNum,

fn contains(&self, multi_polygon: &MultiPolygon<T>) -> bool

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

where T: CoordNum,

fn contains(&self, p: &Point<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: GeoNum> Contains<Point<T>> for IntervalTreeMultiPolygon<T>

fn contains(&self, rhs: &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 MultiLineString<T>

where T: CoordNum, LineString<T>: Contains<Point<T>>,

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

impl<T> Contains<Point<T>> for MultiPoint<T>

where T: CoordNum,

fn contains(&self, point: &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 Polygon<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> Contains<Polygon<T>> for Point<T>

where T: CoordNum,

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

impl<T> Contains<Rect<T>> for Point<T>

where T: CoordNum,

fn contains(&self, rect: &Rect<T>) -> bool

impl<T> Contains<Triangle<T>> for Point<T>

where T: CoordNum,

fn contains(&self, triangle: &Triangle<T>) -> bool

impl<T> Contains for Point<T>

where T: CoordNum,

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

impl<T> ContainsProperly<Geometry<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, geometry: &Geometry<T>) -> bool

impl<T> ContainsProperly<GeometryCollection<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &GeometryCollection<T>) -> bool

impl<T> ContainsProperly<Line<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Line<T>) -> bool

impl<T> ContainsProperly<LineString<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &LineString<T>) -> bool

impl<T> ContainsProperly<MultiLineString<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &MultiLineString<T>) -> bool

impl<T> ContainsProperly<MultiPoint<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &MultiPoint<T>) -> bool

impl<T> ContainsProperly<MultiPolygon<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &MultiPolygon<T>) -> bool

impl<T> ContainsProperly<Point<T>> for GeometryCollection<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for Line<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for LineString<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for MultiLineString<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for MultiPoint<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for MultiPolygon<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for Polygon<T>

where T: GeoNum,

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

impl<T> ContainsProperly<Point<T>> for Rect<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Point<T>> for Triangle<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

impl<T> ContainsProperly<Polygon<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Polygon<T>) -> bool

impl<T> ContainsProperly<Rect<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Rect<T>) -> bool

impl<T> ContainsProperly<Triangle<T>> for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Triangle<T>) -> bool

impl<T> ContainsProperly for Point<T>

where T: GeoFloat,

fn contains_properly(&self, target: &Point<T>) -> bool

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

fn coords_count(&self) -> usize

Return the number of coordinates in the Point.

type Iter<'a> = Once<Coord<T>> where T: 'a

type ExteriorIter<'a> = <Point<T> as CoordsIter>::Iter<'a> where T: 'a

type Scalar = T

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

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

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

Iterate over all exterior coordinates of a geometry.

impl<T> Covers<Geometry<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Geometry<T>) -> bool

impl<T> Covers<GeometryCollection<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &GeometryCollection<T>) -> bool

impl<T> Covers<Line<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Line<T>) -> bool

impl<T> Covers<LineString<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &LineString<T>) -> bool

impl<T> Covers<MultiLineString<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &MultiLineString<T>) -> bool

impl<T> Covers<MultiPoint<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &MultiPoint<T>) -> bool

impl<T> Covers<MultiPolygon<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &MultiPolygon<T>) -> bool

impl<T> Covers<Point<T>> for Coord<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for Geometry<T>

where T: GeoFloat,

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

impl<T> Covers<Point<T>> for GeometryCollection<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for Line<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for LineString<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for MultiLineString<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for MultiPoint<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for MultiPolygon<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for Polygon<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for Rect<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Point<T>> for Triangle<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> Covers<Polygon<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Polygon<T>) -> bool

impl<T> Covers<Rect<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Rect<T>) -> bool

impl<T> Covers<Triangle<T>> for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Triangle<T>) -> bool

impl<T> Covers for Point<T>

where T: GeoNum, Self: Intersects<Coord<T>>,

fn covers(&self, target: &Point<T>) -> bool

impl<T> CrossTrackDistance<T> for Point<T>

where T: CoordFloat + FromPrimitive,

fn cross_track_distance( &self, line_point_a: &Point<T>, line_point_b: &Point<T>, ) -> T

Determine the cross track distance between this point and a line which passes through line_point_a and line_point_b

impl<T> Debug for Point<T>

where T: CoordNum,

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,

fn default() -> Point<T>

Returns the “default value” for a type.

impl<F> Distance<F, &Geometry<F>, &Point<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Geometry<F>, b: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &GeometryCollection<F>, &Point<F>> for Euclidean

fn distance( &self, iter_geometry: &GeometryCollection<F>, to_geometry: &Point<F>, ) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

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

where F: CoordFloat,

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

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &LineString<F>, &Point<F>> for Euclidean

where F: CoordFloat,

fn distance(&self, a: &LineString<F>, b: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &MultiLineString<F>, &Point<F>> for Euclidean

fn distance( &self, iter_geometry: &MultiLineString<F>, to_geometry: &Point<F>, ) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &MultiPoint<F>, &Point<F>> for Euclidean

fn distance(&self, iter_geometry: &MultiPoint<F>, to_geometry: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &MultiPolygon<F>, &Point<F>> for Euclidean

fn distance(&self, iter_geometry: &MultiPolygon<F>, to_geometry: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &Point<F>, &Geometry<F>> for Euclidean

fn distance(&self, origin: &Point<F>, destination: &Geometry<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Point<F>, &GeometryCollection<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Point<F>, b: &GeometryCollection<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

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

fn distance(&self, origin: &Point<F>, destination: &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.

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: CoordFloat> Distance<F, &Point<F>, &LineString<F>> for Euclidean

fn distance(&self, origin: &Point<F>, destination: &LineString<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Point<F>, &MultiLineString<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Point<F>, b: &MultiLineString<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Point<F>, &MultiPoint<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Point<F>, b: &MultiPoint<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Point<F>, &MultiPolygon<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Point<F>, b: &MultiPolygon<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: CoordFloat> Distance<F, &Point<F>, &Point<F>> for Euclidean

fn distance(&self, origin: &Point<F>, destination: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &Point<F>, &Polygon<F>> for Euclidean

fn distance(&self, point: &Point<F>, polygon: &Polygon<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Point<F>, &Rect<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Point<F>, b: &Rect<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Point<F>, &Triangle<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Point<F>, b: &Triangle<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<F, &Polygon<F>, &Point<F>> for Euclidean

where F: GeoFloat,

fn distance(&self, a: &Polygon<F>, b: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &Rect<F>, &Point<F>> for Euclidean

fn distance(&self, polygonlike: &Rect<F>, geometry_b: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: GeoFloat> Distance<F, &Triangle<F>, &Point<F>> for Euclidean

fn distance(&self, polygonlike: &Triangle<F>, geometry_b: &Point<F>) -> F

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

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

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

Calculate the Euclidean distance (a.k.a. pythagorean distance) between two Points

fn distance(&self, origin: Point<F>, destination: Point<F>) -> F

Calculate the Euclidean distance (a.k.a. pythagorean distance) between two Points

Units

• origin, destination: Point where the units of x/y represent non-angular units, e.g. meters or miles, not lon/lat. For lon/lat points, use the Haversine or Geodesic metric spaces.
• returns: distance in the same units as the origin and destination points

Example

use geo::{Euclidean, Distance};
use geo::Point;
// web mercator
let new_york_city = Point::new(-8238310.24, 4942194.78);
// web mercator
let london = Point::new(-14226.63, 6678077.70);
let distance: f64 = Euclidean.distance(new_york_city, london);

assert_eq!(
    8_405_286., // meters in web mercator
    distance.round()
);

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: CoordFloat + FromPrimitive> Distance<F, Point<F>, Point<F>> for HaversineMeasure

fn distance(&self, origin: Point<F>, destination: Point<F>) -> F

Determine the distance between two points using the haversine formula.

Units

• origin, destination: Points where x/y are lon/lat degree coordinates
• returns: meters

Examples

use geo::{Haversine, Distance};
use geo::Point;

let new_york_city = Point::new(-74.006f64, 40.7128f64);
let london = Point::new(-0.1278f64, 51.5074f64);

let distance = Haversine.distance(new_york_city, london);

assert_relative_eq!(
    5_570_230., // meters
    distance.round()
);

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F: CoordFloat + FromPrimitive> Distance<F, Point<F>, Point<F>> for Rhumb

fn distance(&self, origin: Point<F>, destination: Point<F>) -> F

Determine the distance along the rhumb line between two points.

Units

• origin, destination: Points where x/y are lon/lat degree coordinates
• returns: meters

Examples

use geo::{Rhumb, Distance};
use geo::point;

// New York City
let p1 = point!(x: -74.006f64, y: 40.7128);

// London
let p2 = point!(x: -0.1278, y: 51.5074);

let distance = Rhumb.distance(p1, p2);

assert_eq!(
    5_794_129., // meters
    distance.round()
);

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<F> Distance<f64, Point, Point> for GeodesicMeasure<F>

where F: FnOnce() -> Geodesic,

fn distance(&self, origin: Point<f64>, destination: Point<f64>) -> f64

Determine the length of the geodesic line between two geometries on an ellipsoidal model of the earth.

Units

• origin, destination: Point where x/y are lon/lat degree coordinates/
• returns: meters

Examples

use geo::Point;
use geo::{Distance, Geodesic};

// New York City
let new_york_city = Point::new(-74.006, 40.7128);

// London
let london = Point::new(-0.1278, 51.5074);

let distance = Geodesic.distance(new_york_city, london);

assert_eq!(
    5_585_234., // meters
    distance.round()
);

References

This uses the geodesic methods given by Karney (2013).

fn distance_within( &self, origin: Origin, destination: Destination, distance: F, ) -> bool

where F: PartialOrd,

Returns true if the minimum distance between origin and destination is less than or equal to distance

impl<T> Div<T> for Point<T>

where T: CoordNum,

fn div(self, rhs: T) -> <Point<T> as Div<T>>::Output

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,

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> for Point<T>

where T: GeoFloat,

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

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

Minimum distance between two Points

impl<T> EuclideanDistance<T, Geometry<T>> for Point<T>

where T: GeoFloat + FloatConst + RTreeNum,

fn euclidean_distance(&self, geom: &Geometry<T>) -> T

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, GeometryCollection<T>> for Point<T>

where T: GeoFloat + FloatConst + RTreeNum,

fn euclidean_distance(&self, target: &GeometryCollection<T>) -> T

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Line<T>> for Point<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 Line to a Point

impl<T> EuclideanDistance<T, LineString<T>> for Point<T>

where T: GeoFloat,

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

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

Minimum distance from a Point to a LineString

impl<T> EuclideanDistance<T, MultiLineString<T>> for Point<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, MultiPoint<T>> for Point<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, MultiPolygon<T>> for Point<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Point<T>> for Geometry<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Point<T>> for GeometryCollection<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

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

where T: GeoFloat,

fn euclidean_distance(&self, point: &Point<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 Point

impl<T> EuclideanDistance<T, Point<T>> for LineString<T>

where T: GeoFloat,

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

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

Minimum distance from a LineString to a Point

impl<T> EuclideanDistance<T, Point<T>> for MultiLineString<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Point<T>> for MultiPoint<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Point<T>> for MultiPolygon<T>

where T: GeoFloat + FloatConst + RTreeNum,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Point<T>> for Polygon<T>

where T: GeoFloat,

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

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

Minimum distance from a Polygon to a Point

impl<T> EuclideanDistance<T, Point<T>> for Rect<T>

where T: GeoFloat + Signed + RTreeNum + FloatConst,

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

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Point<T>> for Triangle<T>

where T: GeoFloat + Signed + RTreeNum + FloatConst,

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

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

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

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

Minimum distance from a Point to a Polygon

impl<T> EuclideanDistance<T, Rect<T>> for Point<T>

where T: GeoFloat + Signed + RTreeNum + FloatConst,

fn euclidean_distance(&self, other: &Rect<T>) -> T

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

Returns the distance between two geometries

impl<T> EuclideanDistance<T, Triangle<T>> for Point<T>

where T: GeoFloat + Signed + RTreeNum + FloatConst,

fn euclidean_distance(&self, other: &Triangle<T>) -> T

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

Returns the distance between two geometries

impl<'a, F: GeoFloat> From<&'a Point<F>> for PreparedGeometry<'a, &'a Point<F>, F>

fn from(geometry: &'a Point<F>) -> Self

Converts to this type from the input type.

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

where T: CoordNum,

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

Converts to this type from the input type.

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

where T: CoordNum,

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

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<F: GeoFloat> From<Point<F>> for PreparedGeometry<'static, Point<F>, F>

fn from(geometry: Point<F>) -> Self

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> From<Point<T>> for Geometry<T>

where T: CoordNum,

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

Converts to this type from the input type.

impl GeodesicArea<f64> for Point

fn geodesic_perimeter(&self) -> f64

Determine the perimeter of a geometry on an ellipsoidal model of the earth.

fn geodesic_area_signed(&self) -> f64

Determine the area of a geometry on an ellipsoidal model of the earth.

fn geodesic_area_unsigned(&self) -> f64

Determine the area of a geometry on an ellipsoidal model of the earth. Supports very large geometries that cover a significant portion of the earth.

fn geodesic_perimeter_area_signed(&self) -> (f64, f64)

Determine the perimeter and area of a geometry on an ellipsoidal model of the earth, all in one operation.

fn geodesic_perimeter_area_unsigned(&self) -> (f64, f64)

Determine the perimeter and area of a geometry on an ellipsoidal model of the earth, all in one operation. Supports very large geometries that cover a significant portion of the earth.

impl GeodesicBearing<f64> for Point<f64>

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

👎Deprecated since 0.29.0: Please use the Geodesic.bearing method from the Bearing trait instead

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

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

Returns the bearing and distance to another Point in a (bearing, distance) tuple.

impl GeodesicDestination<f64> for Point<f64>

fn geodesic_destination(&self, bearing: f64, distance: f64) -> Point<f64>

👎Deprecated since 0.29.0: Please use the Geodesic.destination method from the Destination trait instead

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

impl GeodesicDistance<f64> for Point

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

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

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

impl GeodesicIntermediate<f64> for Point

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

👎Deprecated since 0.29.0: Please use Geodesic.point_at_ratio_between from the InterpolatePoint trait instead

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, max_dist: f64, include_ends: bool, ) -> Vec<Point>

👎Deprecated since 0.29.0: Please use Geodesic.points_along_line from the InterpolatePoint trait instead

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,

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> HaversineBearing<T> for Point<T>

where T: CoordFloat,

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

👎Deprecated since 0.29.0: Please use the Haversine.bearing method from the Bearing trait instead

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

impl<T> HaversineClosestPoint<T> for Point<T>

where T: GeoFloat + FromPrimitive,

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

impl<T> HaversineDestination<T> for Point<T>

where T: CoordFloat + FromPrimitive,

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

👎Deprecated since 0.29.0: Please use the Haversine.destination method from the Destination trait instead

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

impl<T> HaversineDistance<T> for Point<T>

where T: CoordFloat + FromPrimitive,

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

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

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>, ratio: T) -> Point<T>

👎Deprecated since 0.29.0: Please use Haversine.point_at_ratio_between from the InterpolatePoint trait instead

Returns a new Point along a great circle route between self and other.

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

👎Deprecated since 0.29.0: Please use Haversine.points_along_line from the InterpolatePoint trait instead

Interpolates Points along a great circle route between self and other.

impl<T> InteriorPoint for Point<T>

where T: GeoFloat,

type Output = Point<T>

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

Calculates a representative point inside the Geometry

impl<T, G> Intersects<G> for Point<T>

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

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

impl<T> Intersects<Point<T>> for Coord<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 LineString<T>

where T: GeoNum,

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> Intersects<Point<T>> for Triangle<T>

where Point<T>: Intersects<Triangle<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(Coord<T>) -> Coord<NT> + Copy, ) -> Self::Output

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

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

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

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

fn map_coords_in_place(&mut self, func: impl Fn(Coord<T>) -> Coord<T>)

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

fn try_map_coords_in_place<E>( &mut self, func: impl Fn(Coord<T>) -> Result<Coord<T>, E>, ) -> Result<(), E>

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

impl<T> Mul<T> for Point<T>

where T: CoordNum,

fn mul(self, rhs: T) -> <Point<T> as Mul<T>>::Output

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,

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>,

fn neg(self) -> <Point<T> as Neg>::Output

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 for Point<T>

where T: PartialEq + CoordNum,

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

where T: Float + RTreeNum,

Available on crate feature rstar_0_12 only.

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

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

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

Returns a single coordinate of this point.

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

Mutable variant of nth.

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

fn geometry_graph(&self, arg_index: usize) -> GeometryGraph<'_, F>

Returns a noded topology graph for the geometry.

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

where Self: Sized,

impl<T> RelativeEq for Point<T>

where T: CoordNum + RelativeEq<Epsilon = T>,

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

fn default_max_relative() -> <Point<T> as AbsDiffEq>::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: CoordNum> RemoveRepeatedPoints<T> for Point<T>

fn remove_repeated_points(&self) -> Self

Create a new geometry with (consecutive) repeated points removed.

fn remove_repeated_points_mut(&mut self)

Remove (consecutive) repeated points inplace.

impl<T> RhumbBearing<T> for Point<T>

where T: CoordFloat + FromPrimitive,

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

👎Deprecated since 0.29.0: Please use the Rhumb.bearing method from the Bearing trait instead

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

impl<T> RhumbDestination<T> for Point<T>

where T: CoordFloat + FromPrimitive,

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

👎Deprecated since 0.29.0: Please use the Rhumb.destination method from the Destination trait instead

Returns the destination Point having travelled the given distance along a rhumb line from the origin Point with the given bearing

impl<T> RhumbDistance<T> for Point<T>

where T: CoordFloat + FromPrimitive,

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

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

Determine the distance between along the rhumb line between two geometries.

impl<T> RhumbIntermediate<T> for Point<T>

where T: CoordFloat + FromPrimitive,

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

👎Deprecated since 0.29.0: Please use Rhumb.point_at_ratio_between from the InterpolatePoint trait instead

Returns a new Point along a rhumb line between two existing points.

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

👎Deprecated since 0.29.0: Please use Rhumb.points_along_line from the InterpolatePoint trait instead

impl<T> Sub for Point<T>

where T: CoordNum,

fn sub(self, rhs: Point<T>) -> <Point<T> as Sub>::Output

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 for Point<T>

where T: CoordNum,

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.

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

Performs the conversion.

impl<T> UlpsEq for Point<T>

where T: CoordNum + UlpsEq<Epsilon = T>,

fn default_max_ulps() -> u32

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

fn ulps_eq( &self, other: &Point<T>, epsilon: <Point<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<F: GeoFloat> Validation for Point<F>

type Error = InvalidPoint

fn visit_validation<T>( &self, handle_validation_error: Box<dyn FnMut(Self::Error) -> Result<(), T> + '_>, ) -> Result<(), T>

Visit the validation of the geometry.

fn is_valid(&self) -> bool

Check if the geometry is valid.

fn validation_errors(&self) -> Vec<Self::Error>

Return the reason(s) of invalidity of the geometry.

fn check_validation(&self) -> Result<(), Self::Error>

Return the first reason of invalidity of the geometry.

impl<T> VincentyDistance<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> StructuralPartialEq for Point<T>

where T: CoordNum,