Struct rgeometry::data::polygon::Polygon

pub struct Polygon<T> { /* private fields */ }

Implementations

impl<T> Polygon<T>

pub fn new_unchecked(vertices: Vec<Point<T, 2>>) -> Polygon<T> where
    T: PolygonScalar, 

$O(1)$

pub fn new(points: Vec<Point<T, 2>>) -> Result<Polygon<T>, Error> where
    T: PolygonScalar, 

$O(n^2)$

impl<T> Polygon<T>

pub fn validate(&self) -> Result<(), Error> where
    T: PolygonScalar, 

pub fn validate_weakly(&self) -> Result<(), Error> where
    T: PolygonScalar, 

pub fn locate(&self, origin: &Point<T, 2>) -> PointLocation where
    T: PolygonScalar, 

pub fn triangulate(
    &self
) -> impl Iterator<Item = (Cursor<'_, T>, Cursor<'_, T>, Cursor<'_, T>)> + '_ where
    T: PolygonScalar, 

pub fn centroid(&self) -> Point<T, 2> where
    T: PolygonScalar, 

pub fn bounding_box(&self) -> (Point<T, 2>, Point<T, 2>) where
    T: PolygonScalar, 

pub fn signed_area<F>(&self) -> F where
    T: PolygonScalar + Into<F>,
    F: NumOps<F, F> + Sum + FromPrimitive, 

Computes the area of a polygon. If the polygon winds counter-clockwise, the area will be a positive number. If the polygon winds clockwise, the area will be negative.

Return type

This function is polymorphic for the same reason as signed_area_2x.

Time complexity

$O(n)$

Examples

// The area of this polygon is 1/2 and won't fit in an `i32`
let p = Polygon::new(vec![
  Point::new([0, 0]),
  Point::new([1, 0]),
  Point::new([0, 1]),
 ])?;
assert_eq!(p.signed_area::<i32>(), 0);

// The area of this polygon is 1/2 and will fit in a `Ratio<i32>`.
let p = Polygon::new(vec![
  Point::new([0, 0]),
  Point::new([1, 0]),
  Point::new([0, 1]),
 ])?;
assert_eq!(p.signed_area::<Ratio<i32>>(), Ratio::from((1,2)));

pub fn signed_area_2x<F>(&self) -> F where
    T: PolygonScalar + Into<F>,
    F: NumOps<F, F> + Sum, 

Compute double the area of a polygon. If the polygon winds counter-clockwise, the area will be a positive number. If the polygon winds clockwise, the area will be negative.

Why compute double the area? If you are using integer coordinates then the doubled area will also be an integer value. Computing the exact requires a division which may leave you with a non-integer result.

Return type

Storing the area of a polygon may require more bits of precision than are used for the coordinates. For example, if 32bit integers are used for point coordinates then you might need 65 bits to store the area doubled. For this reason, the return type is polymorphic and should be selected with care. If you are unsure which type is appropriate, use BigInt or BigRational.

Time complexity

$O(n)$

Examples:

// The area of this polygon is 1/2 and cannot fit in an `i32` variable
// so lets compute twice the area.
let p = Polygon::new(vec![
  Point::new([0, 0]),
  Point::new([1, 0]),
  Point::new([0, 1]),
 ])?;
assert_eq!(p.signed_area_2x::<i32>(), 1);

// The area of a polygon may require more bits of precision than are
// used for the coordinates.
let p = Polygon::new(vec![
  Point::new([0, 0]),
  Point::new([i32::MAX, 0]),
  Point::new([0, i32::MAX]),
 ])?;
assert_eq!(p.signed_area_2x::<i64>(), 4611686014132420609_i64);

pub fn orientation(&self) -> Orientation where
    T: PolygonScalar, 

pub fn point(&self, idx: PointId) -> &Point<T, 2>

Access point of a given vertex.

Time complexity

$O(1)$

pub fn cursor(&self, idx: PointId) -> Cursor<'_, T>

Access cursor of a given vertex.

Time complexity

$O(1)$

pub fn boundary_slice(&self) -> &[PointId]

pub fn iter_boundary(&self) -> CursorIter<'_, T>

pub fn iter_boundary_edges(&self) -> EdgeIter<'_, T>

pub fn map_points<F>(self, f: F) -> Polygon<T> where
    T: Clone,
    F: Fn(Point<T, 2>) -> Point<T, 2>, 

pub fn iter(&self) -> Iter<'_, T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

pub fn map<U, F>(self, f: F) -> Polygon<U> where
    T: Clone,
    U: Clone,
    F: Fn(T) -> U + Clone, 

pub fn cast<U>(self) -> Polygon<U> where
    T: Clone + Into<U>, 

pub fn float(self) -> Polygon<OrderedFloat<f64>> where
    T: Clone + Into<f64>, 

pub fn vertices_reverse(&mut self, pt1: Position, pt2: Position)

pub fn vertices_join(&mut self, pt1: Position, pt2: Position)

pub fn direct(&self, edge: IndexEdge) -> DirectedIndexEdge

Panics if the edge isn’t part of the polygon.

pub fn ensure_ccw(&mut self) where
    T: PolygonScalar, 

impl Polygon<OrderedFloat<f64>>

pub fn normalize(&self) -> Polygon<OrderedFloat<f64>>

Trait Implementations

impl<T: Clone> Clone for Polygon<T>

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: Debug> Debug for Polygon<T>

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

Formats the value using the given formatter.

impl<T> Default for Polygon<T>

fn default() -> Polygon<T>

Returns the “default value” for a type.

impl<'a, T> From<&'a PolygonConvex<T>> for &'a Polygon<T>

fn from(convex: &'a PolygonConvex<T>) -> &'a Polygon<T>

Converts to this type from the input type.

impl<T> From<PolygonConvex<T>> for Polygon<T>

fn from(convex: PolygonConvex<T>) -> Polygon<T>

Converts to this type from the input type.

impl<'a, T> Mul<&'a Polygon<T>> for Transform<T, 2> where
    T: TransformScalar, 

type Output = Polygon<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Polygon<T>> for &'a Transform<T, 2> where
    T: TransformScalar, 

type Output = Polygon<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<Polygon<T>> for &'a Transform<T, 2> where
    T: TransformScalar, 

type Output = Polygon<T>

The resulting type after applying the * operator.

fn mul(self, other: Polygon<T>) -> Polygon<T>

Performs the * operation.

impl<T> Mul<Polygon<T>> for Transform<T, 2> where
    T: TransformScalar, 

type Output = Polygon<T>

The resulting type after applying the * operator.

fn mul(self, other: Polygon<T>) -> Polygon<T>

Performs the * operation.