[][src]Struct geo_types::Polygon

pub struct Polygon<T> where
    T: CoordinateType
{ /* fields omitted */ }

A bounded two-dimensional area.

A Polygon’s outer boundary (exterior ring) is represented by a LineString. It may contain zero or more holes (interior rings), also represented by LineStrings.

The Polygon structure guarantees that all exterior and interior rings will be closed, such that the first and last Coordinate of each ring has the same value.

Validity

Besides the closed LineString rings guarantee, the Polygon structure does not enforce validity at this time. For example, it is possible to construct a Polygon that has:

  • fewer than 3 coordinates per LineString ring
  • interior rings that intersect other interior rings
  • interior rings that extend beyond the exterior ring

LineString closing operation

Some APIs on Polygon result in a closing operation on a LineString. The operation is as follows:

If a LineString’s first and last Coordinate have different values, a new Coordinate will be appended to the LineString with a value equal to the first Coordinate.

Methods

impl<T> Polygon<T> where
    T: CoordinateType
[src]

pub fn new(exterior: LineString<T>, interiors: Vec<LineString<T>>) -> Polygon<T>[src]

Create a new Polygon with the provided exterior LineString ring and interior LineString rings.

Upon calling new, the exterior and interior LineString rings will be closed.

Examples

Creating a Polygon with no interior rings:

use geo_types::{LineString, Polygon};

let polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![]);

Creating a Polygon with an interior ring:

use geo_types::{LineString, Polygon};

let polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![
    LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])
]);

If the first and last Coordinates of the exterior or interior LineStrings no longer match, those LineStrings will be closed:

use geo_types::{Coordinate, LineString, Polygon};

let mut polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
]), vec![]);

assert_eq!(polygon.exterior(), &LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]));

pub fn into_inner(self) -> (LineString<T>, Vec<LineString<T>>)[src]

Consume the Polygon, returning the exterior LineString ring and a vector of the interior LineString rings.

Examples

use geo_types::{LineString, Polygon};

let mut polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![
    LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])
]);

let (exterior, interiors) = polygon.into_inner();

assert_eq!(exterior, LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]));

assert_eq!(interiors, vec![LineString::from(vec![
    (0.1, 0.1),
    (0.9, 0.9),
    (0.9, 0.1),
    (0.1, 0.1),
])]);

pub fn exterior(&self) -> &LineString<T>[src]

Return a reference to the exterior LineString ring.

Examples

use geo_types::{LineString, Polygon};

let exterior = LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]);

let polygon = Polygon::new(exterior.clone(), vec![]);

assert_eq!(polygon.exterior(), &exterior);

pub fn exterior_mut<F>(&mut self, f: F) where
    F: FnMut(&mut LineString<T>), 
[src]

Execute the provided closure f, which is provided with a mutable reference to the exterior LineString ring.

After the closure executes, the exterior LineString will be closed.

Examples

use geo_types::{Coordinate, LineString, Polygon};

let mut polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![]);

polygon.exterior_mut(|exterior| {
    exterior.0[1] = Coordinate { x: 1., y: 2. };
});

assert_eq!(polygon.exterior(), &LineString::from(vec![
    (0., 0.),
    (1., 2.),
    (1., 0.),
    (0., 0.),
]));

If the first and last Coordinates of the exterior LineString no longer match, the LineString will be closed:

use geo_types::{Coordinate, LineString, Polygon};

let mut polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![]);

polygon.exterior_mut(|exterior| {
    exterior.0[0] = Coordinate { x: 0., y: 1. };
});

assert_eq!(polygon.exterior(), &LineString::from(vec![
    (0., 1.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
    (0., 1.),
]));

pub fn interiors(&self) -> &[LineString<T>][src]

Return a slice of the interior LineString rings.

Examples

use geo_types::{Coordinate, LineString, Polygon};

let interiors = vec![LineString::from(vec![
    (0.1, 0.1),
    (0.9, 0.9),
    (0.9, 0.1),
    (0.1, 0.1),
])];

let polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), interiors.clone());

assert_eq!(interiors, polygon.interiors());

pub fn interiors_mut<F>(&mut self, f: F) where
    F: FnMut(&mut [LineString<T>]), 
[src]

Execute the provided closure f, which is provided with a mutable reference to the interior LineString rings.

After the closure executes, each of the interior LineStrings will be closed.

Examples

use geo_types::{Coordinate, LineString, Polygon};

let mut polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![
    LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])
]);

polygon.interiors_mut(|interiors| {
    interiors[0].0[1] = Coordinate { x: 0.8, y: 0.8 };
});

assert_eq!(polygon.interiors(), &[
    LineString::from(vec![
        (0.1, 0.1),
        (0.8, 0.8),
        (0.9, 0.1),
        (0.1, 0.1),
    ])
]);

If the first and last Coordinates of any interior LineString no longer match, those LineStrings will be closed:

use geo_types::{Coordinate, LineString, Polygon};

let mut polygon = Polygon::new(LineString::from(vec![
    (0., 0.),
    (1., 1.),
    (1., 0.),
    (0., 0.),
]), vec![
    LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])
]);

polygon.interiors_mut(|interiors| {
    interiors[0].0[0] = Coordinate { x: 0.1, y: 0.2 };
});

assert_eq!(polygon.interiors(), &[
    LineString::from(vec![
        (0.1, 0.2),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
        (0.1, 0.2),
    ])
]);

impl<T> Polygon<T> where
    T: Float + Signed
[src]

pub fn is_convex(&self) -> bool[src]

Determine whether a Polygon is convex

Trait Implementations

impl<T: Clone> Clone for Polygon<T> where
    T: CoordinateType
[src]

fn clone_from(&mut self, source: &Self)
1.0.0
[src]

Performs copy-assignment from source. Read more

impl<T: CoordinateType> From<Rect<T>> for Polygon<T>[src]

impl<T: CoordinateType> From<Polygon<T>> for Geometry<T>[src]

impl<T: PartialEq> PartialEq<Polygon<T>> for Polygon<T> where
    T: CoordinateType
[src]

impl<T: Debug> Debug for Polygon<T> where
    T: CoordinateType
[src]

Auto Trait Implementations

impl<T> Send for Polygon<T> where
    T: Send

impl<T> Sync for Polygon<T> where
    T: Sync

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = !

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.