Struct geom::polygon::Polygon

pub struct Polygon {
    points: Vec<Pt2D>,
    indices: Vec<u16>,
    rings: Option<Vec<Ring>>,
}

Fields

points: Vec<Pt2D>

indices: Vec<u16>

Groups of three indices make up the triangles

rings: Option<Vec<Ring>>

If the polygon has holes, explicitly store all the rings (the one outer and all of the inner) so they can later be used to generate outlines and such. If the polygon has no holes, then this will just be None, since the points form a ring.

Implementations

impl Polygon

pub fn buggy_new(orig_pts: Vec<Pt2D>) -> Polygon

pub fn with_holes(outer: Ring, inner: Vec<Ring>) -> Polygon

pub fn from_rings(rings: Vec<Ring>) -> Polygon

pub fn from_geojson(raw: &Vec<Vec<Vec<f64>>>) -> Result<Polygon>

pub fn precomputed(points: Vec<Pt2D>, indices: Vec<usize>) -> Polygon

pub fn from_triangle(tri: &Triangle) -> Polygon

pub fn triangles(&self) -> Vec<Triangle>

pub fn raw_for_rendering(&self) -> (&Vec<Pt2D>, &Vec<u16>)

pub fn contains_pt(&self, pt: Pt2D) -> bool

Does this polygon contain the point either in the interior or right on the border? Haven't tested carefully for polygons with holes.

pub fn get_bounds(&self) -> Bounds

fn transform<F: Fn(&Pt2D) -> Pt2D>(&self, f: F) -> Polygon

pub fn translate(&self, dx: f64, dy: f64) -> Polygon

pub fn scale(&self, factor: f64) -> Polygon

pub fn scale_xy(&self, x_factor: f64, y_factor: f64) -> Polygon

pub fn rotate(&self, angle: Angle) -> Polygon

pub fn rotate_around(&self, angle: Angle, pivot: Pt2D) -> Polygon

pub fn points(&self) -> &Vec<Pt2D>

The order of these points depends on the constructor! The first and last point may or may not match. Polygons constructed from PolyLines will have a very weird order.

pub fn into_points(self) -> Vec<Pt2D>

pub fn into_ring(self) -> Ring

pub fn center(&self) -> Pt2D

pub fn rectangle(width: f64, height: f64) -> Polygon

Top-left at the origin. Doesn't take Distance, because this is usually pixels, actually.

pub fn rectangle_centered(
    center: Pt2D,
    width: Distance,
    height: Distance
) -> Polygon

pub fn rectangle_two_corners(pt1: Pt2D, pt2: Pt2D) -> Option<Polygon>

pub fn maybe_rounded_rectangle<R: Into<CornerRadii>>(
    w: f64,
    h: f64,
    r: R
) -> Option<Polygon>

Top-left at the origin. Doesn't take Distance, because this is usually pixels, actually.

pub fn pill(w: f64, h: f64) -> Polygon

A rectangle, two sides of which are fully rounded half-circles.

pub fn rounded_rectangle<R: Into<CornerRadii>>(w: f64, h: f64, r: R) -> Polygon

Top-left at the origin. Doesn't take Distance, because this is usually pixels, actually. If it's not possible to apply the specified radius, fallback to a regular rectangle.

pub fn union(self, other: Polygon) -> Polygon

pub fn union_all(list: Vec<Polygon>) -> Polygon

pub fn intersection(&self, other: &Polygon) -> Vec<Polygon>

pub fn convex_hull(list: Vec<Polygon>) -> Polygon

pub fn concave_hull(list: Vec<Polygon>, concavity: f64) -> Polygon

pub fn polylabel(&self) -> Pt2D

pub fn intersects(&self, other: &Polygon) -> bool

Do two polygons intersect at all?

pub fn to_outline(&self, thickness: Distance) -> Result<Polygon>

Creates the outline around the polygon, with the thickness half straddling the polygon and half of it just outside. Only works for polygons that're formed from rings. Those made from PolyLines won't work, for example.

pub fn strip_rings(&self) -> Polygon

Remove the internal rings used for to_outline. This is fine to do if the polygon is being added to some larger piece of geometry that won't need an outline.

pub fn area(&self) -> f64

Usually m^2, unless the polygon is in screen-space

pub fn clip_polyline(&self, input: &PolyLine) -> Option<Vec<Pt2D>>

Doesn't handle multiple crossings in and out.

pub fn clip_ring(&self, input: &Ring) -> Option<Vec<Pt2D>>

pub fn to_geojson(&self, gps: Option<&GPSBounds>) -> Geometry

If the polygon is just a single outer ring, produces a GeoJSON polygon. Otherwise, produces a GeoJSON multipolygon consisting of individual triangles. Optionally map the world-space points back to GPS.

Trait Implementations

impl Clone for Polygon

fn clone(&self) -> Polygon

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Polygon

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Polygon

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Polygon

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

Formats the value using the given formatter.

impl From<Polygon<f64>> for Polygon

fn from(poly: Polygon<f64>) -> Self

Performs the conversion.

impl PartialEq<Polygon> for Polygon

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

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

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

This method tests for !=.

impl Serialize for Polygon

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Polygon