Enum shapefile::record::polygon::PolygonRing

pub enum PolygonRing<PointType> {
    Outer(Vec<PointType>),
    Inner(Vec<PointType>),
}

Rings composing a Polygon

Inner rings define holes in polygons.

In shapefile, the point ordering is what is used to know if a ring is an outer or inner one:

• Outer ring => points in clockwise order
• Inner ring => points in counter-clockwise order

Note

Rings you get access from a GenericPolygon will always have its points ordered according to its type (outer, inner).

But PolygonRings you create won’t be reordered until you move them into a GenericPolygon.

Example

use shapefile::{PolygonRing, Polygon, Point};
// Here the points are not in the correct order to be an Outer ring for a shapefile
let mut points = vec![
    Point::new(-12.0, 6.0),
    Point::new(-12.0, -6.0),
    Point::new(12.0, -6.0),
    Point::new(12.0, 6.0),
    Point::new(-12.0, 6.0),
];

let mut reversed_points = points.clone();
reversed_points.reverse();

let ring = PolygonRing::Outer(points);
assert_ne!(ring.points(), reversed_points.as_slice());
assert_eq!(ring[0], Point::new(-12.0, 6.0));

// Now the points will be reversed
let polygon = Polygon::new(ring);
assert_eq!(polygon.rings()[0].points(), reversed_points.as_slice());

Variants

Outer(Vec<PointType>)

The outer ring of a polygon.

Inner(Vec<PointType>)

Defines a hole in a polygon

Implementations

impl<PointType> PolygonRing<PointType>

pub fn len(&self) -> usize

Returns the number of points inside the ring

Example

use shapefile::{PolygonRing, Point};
let ring = PolygonRing::Inner(vec![
    Point::new(-12.0, 6.0),
    Point::new(-12.0, -6.0),
    Point::new(12.0, -6.0),
    Point::new(12.0, 6.0),
    Point::new(-12.0, 6.0),
]);
assert_eq!(ring.len(), 5);

pub fn is_empty(&self) -> bool

Returns whether the rings contains any points

pub fn points(&self) -> &[PointType]

Returns a non-mutable slice to the points inside the ring

use shapefile::{PolygonRing, Point};
let ring = PolygonRing::Inner(vec![
    Point::new(-12.0, 6.0),
    Point::new(-12.0, -6.0),
    Point::new(12.0, -6.0),
    Point::new(12.0, 6.0),
    Point::new(-12.0, 6.0),
]);
assert_eq!(ring.points()[2], Point::new(12.0, -6.0));

pub fn into_inner(self) -> Vec<PointType>

Consumes the ring and returns its points

Trait Implementations

impl<PointType> AsRef<[PointType]> for PolygonRing<PointType>

fn as_ref(&self) -> &[PointType]

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

impl<PointType: Clone> Clone for PolygonRing<PointType>

fn clone(&self) -> PolygonRing<PointType>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<PointType: Debug> Debug for PolygonRing<PointType>

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

Formats the value using the given formatter.

impl<PointType: HasXY> From<Vec<PointType>> for PolygonRing<PointType>

fn from(p: Vec<PointType>) -> Self

Converts to this type from the input type.

impl<PointType, I: SliceIndex<[PointType]>> Index<I> for PolygonRing<PointType>

type Output = <I as SliceIndex<[PointType]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<PointType: PartialEq> PartialEq for PolygonRing<PointType>

fn eq(&self, other: &PolygonRing<PointType>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<PointType> StructuralPartialEq for PolygonRing<PointType>