[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

details Geometry VIGRA

Classes

class  Polygon< POINT >
 

Functions

double arcLengthQuantile (double quantile) const
 
bool closed () const
 Returns true iff the last and first points are equal or the polygon is empty.
 
bool contains (const_reference point, coordinate_type tolerance) const
 
template<class PointArray1 , class PointArray2 >
void convexHull (const PointArray1 &points, PointArray2 &convex_hull)
 Compute convex hull of a 2D polygon. More...
 
template<class T , class S , class PointArray >
void extractContour (MultiArrayView< 2, T, S > const &label_image, Shape2 const &anchor_point, PointArray &contour_points)
 Create a polygon from the interpixel contour of a labeled region. More...
 
template<class Point , class T , class S , class Value >
void fillPolygon (Polygon< Point > const &p, MultiArrayView< 2, T, S > &output_image, Value value)
 Render closed polygon p into the image output_image. More...
 
Point interpolate (unsigned int index, double offset) const
 

Detailed Description

Function Documentation

Point interpolate ( unsigned int  index,
double  offset 
) const

Linearly interpolate at offset between knots index and index+1.

Preconditions: 0 <= index < size()-1 and 0 <= offset <= 1.

bool contains ( const_reference  point,
coordinate_type  tolerance 
) const

Tests whether the given point lies within this polygon. Requires that this polygon is closed.

Points which lie directly on the polylines or coincide with a knot are considered inside (this behavior is consistent with fillPolygon()). Parameter tolerance (interpreted as an absolute error bound) controls the numerical accuracy of this test.

double arcLengthQuantile ( double  quantile) const

Find the point on the polygon that corresponds to the given quantile.

quantile must be in [0.0, 1.0]. The result of this function can be used as input to interpolate(). For example, the following code computes the point in the middle of the polygon:

double c = poly.arcLengthQuantile(0.5);
Point center = poly.interpolate((int)floor(c), c - floor(c));
void vigra::extractContour ( MultiArrayView< 2, T, S > const &  label_image,
Shape2 const &  anchor_point,
PointArray &  contour_points 
)

Create a polygon from the interpixel contour of a labeled region.

The point anchor_point must be in the region whose contour we want to extract, and must be adjacent to the contour. The algorithm uses the 'left hand on the wall' algorithm to trace the connected component whose label equals the label of the anchor_point. The contour is returned in countour_points as a closed polygon that circles the region counter-clockwise in the image coordinate system (i.e. the coordinate system where x points to the right and y points downwards). Since the resulting polygon represents the interpixel contour, all points will have one integer and one half-integer coordinate.

void vigra::convexHull ( const PointArray1 &  points,
PointArray2 &  convex_hull 
)

Compute convex hull of a 2D polygon.

The input array points contains a (not necessarily ordered) set of 2D points whose convex hull is to be computed. The array's value_type (i.e. the point type) must be compatible with std::vector (in particular, it must support indexing, copying, and have size() == 2). The points of the convex hull will be appended to the output array convex_hull (which must support std::back_inserter(convex_hull)). Since the convex hull is a closed polygon, the first and last point of the output will be the same (i.e. the first point will simply be inserted at the end again). The points of the convex hull will be ordered counter-clockwise, starting with the leftmost point of the input. The function implements Andrew's Monotone Chain algorithm.

void vigra::fillPolygon ( Polygon< Point > const &  p,
MultiArrayView< 2, T, S > &  output_image,
Value  value 
)

Render closed polygon p into the image output_image.

All pixels on the polygon's contour and in its interior are set to the given value. Parts of the polygon outside the image region are clipped. The function uses a robust X-intersection array algorithm that is able to handle all corner cases (concave and self-intersecting polygons, knots on integer coordinates).

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.11.1 (Fri May 19 2017)