Struct Polygon

source

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

Implementations§

source §

impl<T> Polygon<T>

source

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

$O(1)$

source

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

$O(n^2)$

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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