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, 

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

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

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>

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

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

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

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),
    ])
]);

pub fn interiors_push(&mut self, new_interior: impl Into<LineString<T>>)

Add an interior ring to the Polygon.

The new LineString interior ring 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![]);

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

polygon.interiors_push(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
    ]);

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

impl<T> Polygon<T> where
    T: Float + Signed, 

pub fn is_convex(&self) -> bool

Determine whether a Polygon is convex

Trait Implementations

impl<T: Clone> Clone for Polygon<T> where
    T: CoordinateType, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PartialEq> PartialEq<Polygon<T>> for Polygon<T> where
    T: CoordinateType, 

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

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

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

This method tests for !=.

impl<T: CoordinateType> From<Rect<T>> for Polygon<T>

fn from(r: Rect<T>) -> Polygon<T>

Performs the conversion.

impl<T: CoordinateType> From<Polygon<T>> for Geometry<T>

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

Performs the conversion.

impl<T: Debug> Debug for Polygon<T> where
    T: CoordinateType, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.