Struct rgeometry::data::polygon::PolygonConvex

pub struct PolygonConvex<T>(_);

Implementations

impl<T> PolygonConvex<T> where
    T: PolygonScalar, 

pub fn new_unchecked(poly: Polygon<T>) -> PolygonConvex<T>

Assume that a polygon is convex.

Safety

The input polygon has to be strictly convex, ie. no vertices are allowed to be concave or colinear.

Time complexity

$O(1)$

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

Locate a point relative to a convex polygon.

Time complexity

$O(\log n)$

Examples

pub fn validate(&self) -> Result<(), Error>

Validates the following properties:

• Each vertex is convex, ie. not concave or colinear.
• All generate polygon properties hold true (eg. no duplicate points, no self-intersections).

Time complexity

$O(n \log n)$

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

pub fn polygon(&self) -> &Polygon<T>

$O(1)$

pub fn random<R>(n: usize, rng: &mut R) -> PolygonConvex<T> where
    T: Bounded + PolygonScalar + SampleUniform + Copy,
    R: Rng + ?Sized, 

Uniformly sample a random convex polygon.

The output polygon is rooted in (0,0), grows upwards, and has a height and width of T::max_value().

Time complexity

$O(n \log n)$

Examples

PolygonConvex::random(3, &mut rand::thread_rng())

impl PolygonConvex<OrderedFloat<f64>>

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

Methods from Deref<Target = 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 iter(&self) -> Iter<'_, T>

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

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

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

Trait Implementations

impl<T: Clone> Clone for PolygonConvex<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for PolygonConvex<T>

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

Formats the value using the given formatter.

impl<T> Deref for PolygonConvex<T>

type Target = Polygon<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Distribution<PolygonConvex<isize>> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> PolygonConvex<isize>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S> where
    F: Fn(T) -> S, 

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

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.