Namespaces
	base
	Holds base classes, not part of API.

	detail
	This namespace holds some private stuff, types here are not to be used directly by end-user code.

	err
	Holds static counters, for runtime errors and warnings.

	fct
	Holds functors, used to manage runtime polymorphism using `std::variant`. See https://github.com/skramm/homog2d/blob/master/docs/homog2d_manual.md#section_rtp.

	img
	Holds drawing related code, independent of back-end library.

	ppair
	Holds free functions returning a pair of points.

	priv
	Holds private stuff.

	rtp
	Holds pointer-based runtime polymorphism stuff.

	svg
	Holds stuff related to SVG import.

	thr
	Holds threshold values and api to access these.

	trait
	Holds traits classes.

	typ
	Holds the types needed for policy based design.

Classes
class	Circle_
	A circle. More...

class	Ellipse_
	Ellipse as a conic in matrix form. More...

class	FRect_
	A Flat Rectangle, modeled by its two opposite points. More...

class	Hmatrix_
	A 2D homography, defining a planar transformation. More...

struct	OffsetPolyParams
	Parameters for base::PolylineBase::getOffsetPoly() More...

Typedefs
using	Circle = Circle_< HOMOG2D_INUMTYPE >
	Default circle type. More...

using	CircleD = Circle_< double >

using	CircleF = Circle_< float >

using	CircleL = Circle_< long double >

using	CommonType = CommonType_< HOMOG2D_INUMTYPE >

template<typename FPT >
using	CommonType_ = std::variant< Segment_< FPT >, OSegment_< FPT >, Point2d_< FPT >, Line2d_< FPT >, Circle_< FPT >, Ellipse_< FPT >, FRect_< FPT >, CPolyline_< FPT >, OPolyline_< FPT > >
	A variant type, holding all possible types. Used to achieve runtime polymorphism. More...

using	CommonTypeD = CommonType_< double >

using	CommonTypeF = CommonType_< float >

using	CommonTypeL = CommonType_< long double >

using	CPolyline = CPolyline_< HOMOG2D_INUMTYPE >
	Default polyline type. More...

template<typename T >
using	CPolyline_ = base::PolylineBase< typ::IsClosed, T >

using	CPolylineD = CPolyline_< double >

using	CPolylineF = CPolyline_< float >

using	CPolylineL = CPolyline_< long double >

using	Ellipse = Ellipse_< HOMOG2D_INUMTYPE >
	Default ellipse type. More...

using	EllipseD = Ellipse_< double >

using	EllipseF = Ellipse_< float >

using	EllipseL = Ellipse_< long double >

using	Epipmat = Hmatrix_< typ::IsEpipmat, HOMOG2D_INUMTYPE >
	Default homogeneous matrix, uses `double` as numerical type. More...

using	FRect = FRect_< HOMOG2D_INUMTYPE >
	Default rectangle type. More...

using	FRectD = FRect_< double >

using	FRectF = FRect_< float >

using	FRectL = FRect_< long double >

using	Homogr = Homogr_< HOMOG2D_INUMTYPE >
	Default homography (3x3 matrix) type, uses `double` as numerical type. More...

template<typename T >
using	Homogr_ = Hmatrix_< typ::IsHomogr, T >

using	HomogrD = Homogr_< double >

using	HomogrF = Homogr_< float >

using	HomogrL = Homogr_< long double >

using	Line2d = Line2d_< HOMOG2D_INUMTYPE >
	Default line type, uses `double` as numerical type. More...

template<typename T >
using	Line2d_ = base::LPBase< typ::IsLine, T >

using	Line2dD = Line2d_< double >

using	Line2dF = Line2d_< float >

using	Line2dL = Line2d_< long double >

using	OPolyline = OPolyline_< HOMOG2D_INUMTYPE >

template<typename T >
using	OPolyline_ = base::PolylineBase< typ::IsOpen, T >

using	OPolylineD = OPolyline_< double >

using	OPolylineF = OPolyline_< float >

using	OPolylineL = OPolyline_< long double >

using	OSegment = OSegment_< HOMOG2D_INUMTYPE >

template<typename T >
using	OSegment_ = base::SegVec< typ::IsOSeg, T >

using	OSegmentD = OSegment_< double >

using	OSegmentF = OSegment_< float >

using	OSegmentL = OSegment_< long double >

using	Point2d = Point2d_< HOMOG2D_INUMTYPE >
	Default point type, uses `double` as numerical type. More...

template<typename T >
using	Point2d_ = base::LPBase< typ::IsPoint, T >

using	Point2dD = Point2d_< double >

using	Point2dF = Point2d_< float >

using	Point2dL = Point2d_< long double >

using	PointPair = PointPair_< double >

template<typename T1 , typename T2 >
using	PointPair2_ = std::pair< Point2d_< T1 >, Point2d_< T2 > >

template<typename T >
using	PointPair_ = std::pair< Point2d_< T >, Point2d_< T > >

using	PointPairD = PointPair_< double >

using	PointPairF = PointPair_< float >

using	PointPairL = PointPair_< long double >

using	Segment = Segment_< HOMOG2D_INUMTYPE >
	Default segment type. More...

template<typename T >
using	Segment_ = base::SegVec< typ::IsSegment, T >

using	SegmentD = Segment_< double >

using	SegmentF = Segment_< float >

using	SegmentL = Segment_< long double >

Enumerations
enum	CardDir : int8_t { CardDir::Bottom, CardDir::Top, CardDir::Left, CardDir::Right }

enum	Dtype : uint8_t { Dtype::Float, Dtype::Double, Dtype::LongDouble, Dtype::Other, Dtype::Ttmath }
	Type of underlying floating point, see LPBase::dtype(). Maybe printed out with getString() More...

enum	GivenCoord : uint8_t { GivenCoord::X, GivenCoord::Y }
	Used in Line2d::getValue() and getOrthogLine() More...

enum	LineDir : uint8_t { LineDir::H, LineDir::V }
	Used in line constructor, to instanciate a H or V line, see base::LPBase( LineDir, T ) More...

enum	PointSide : uint8_t { PointSide::Left, PointSide::Right, PointSide::Neither }
	Point related to a OSegment. More...

enum	Rotate : int8_t { Rotate::CCW, Rotate::CW, Rotate::Full, Rotate::VMirror, Rotate::HMirror }
	Used in base::PolylineBase_::rotate() member function. More...

enum	Type : uint8_t { Type::Line2d, Type::Point2d, Type::Segment, Type::OSegment, Type::FRect, Type::Circle, Type::Ellipse, Type::OPolyline, Type::CPolyline }
	Type of Root object, see rtp::Root::type(). Maybe printed out with getString() More...

Functions
template<typename FPT >
HOMOG2D_INUMTYPE	angle (const Ellipse_< FPT > &ell)
	Return angle of ellipse (free function) More...

template<typename T >
HOMOG2D_INUMTYPE	area (const T &elem)
	Returns area of element or variant (free function) More...

template<typename FPT >
bool	areCollinear (const Point2d_< FPT > &pt1, const Point2d_< FPT > &pt2, const Point2d_< FPT > &pt3)
	Returns true if the 3 points are on the same line. More...

template<typename T1 , typename T2 >
bool	areParallel (const T1 &t1, const T2 &t2)
	Returns true is lines (or segments) are parallel. More...

template<typename FPT >
Homogr_< FPT >	buildFrom4Points (const std::vector< Point2d_< FPT >> &vpt1, const std::vector< Point2d_< FPT >> &vpt2, int method=1)
	Build Homography from 2 sets of 4 points (free function) More...

template<typename FPT >
Point2d_< FPT > &	center (Circle_< FPT > &cir)
	Returns reference on center of circle (free function), non-const version. More...

template<typename FPT >
const Point2d_< FPT > &	center (const Circle_< FPT > &cir)
	Returns reference on center of circle (free function), const version. More...

template<typename PLT , typename FPT >
base::LPBase< typ::IsPoint, FPT >	centroid (const base::PolylineBase< PLT, FPT > &pl)
	Returns centroid of Polyline (free function) More...

template<typename CT , typename FPT >
CPolyline_< FPT >	convexHull (const base::PolylineBase< CT, FPT > &input)
	Compute Convex Hull of a Polyline (free function) More...

template<typename FPT1 , typename FPT2 >
HOMOG2D_INUMTYPE	dist (const Point2d_< FPT1 > &pt1, const Point2d_< FPT2 > &pt2)
	Free function, distance between points. More...

template<typename U , typename Prim , typename std::enable_if< trait::IsDrawable< Prim >::value, Prim >::type * = nullptr>
void	draw (img::Image< U > &img, const Prim &prim, const img::DrawParams &dp=img::DrawParams())
	Free function, draws any of the primitives by calling the relevant member function. More...

template<typename U , typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
void	draw (img::Image< U > &img, const T &cont, const img::DrawParams &dp=img::DrawParams())
	Free function, draws a set of primitives. More...

template<typename U , typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
void	draw (img::Image< U > &img, const T &cont, std::function< img::DrawParams(int)> &func)
	This version holds a `std::function` as 3th parameter. It can be used to pass a function that will return a different img::DrawParams for a given index of the container. More...

template<typename T1 , typename T2 , typename U >
void	draw (img::Image< U > &img, const std::pair< T1, T2 > &pa, const img::DrawParams &dp=img::DrawParams())
	Free function, draws a pair of objects. More...

template<typename U , typename FPT >
void	drawText (img::Image< U > &im, std::string str, Point2d_< FPT > pt, img::DrawParams dp=img::DrawParams())
	Free function, draws text `str` at position `pt`. More...

template<typename T >
std::pair< int, int >	dsize (const T &t)
	Get data size expressed as number of bits for, respectively, mantissa and exponent. More...

template<typename T >
Dtype	dtype (const T &elem)
	Returns the underlying data type of object or variant. More...

template<typename FPT , typename T >
size_t	findFarthestPoint (const Point2d_< FPT > &pt, const T &cont)
	Returns index of point in container `cont` that is the farthest to `pt`. More...

template<typename FPT , typename T >
auto	findNearestFarthestPoint (const Point2d_< FPT > &pt, const T &cont)
	Returns indexes of points in container `cont` that are nearest/farthest. More...

template<typename FPT , typename T >
size_t	findNearestPoint (const Point2d_< FPT > &pt, const T &cont)
	Returns index of point in container `cont` that is the nearest to `pt`. More...

template<typename FPT >
std::array< Point2d_< FPT >, 4 >	get4Pts (const FRect_< FPT > &rect)
	Returns the 4 points of the rectangle (free function) More...

template<typename T1 , typename T2 >
HOMOG2D_INUMTYPE	getAngle (const T1 &t1, const T2 &t2)
	Free function, returns angle between two segments/lines. More...

template<typename FPT >
std::pair< Line2d_< FPT >, Line2d_< FPT > >	getAxisLines (const Ellipse_< FPT > &ell)
	Returns ellipse axis lines. More...

template<typename T >
FRect_< HOMOG2D_INUMTYPE >	getBB (const T &t)
	Return Bounding Box of primitive or container holding primitives (free function) More...

template<typename T1 , typename T2 , typename T3 , typename T4 >
auto	getBB (const PointPair2_< T1, T2 > &pp1, const PointPair2_< T3, T4 > &pp2)
	Returns bounding box of two pairs of points. More...

template<typename T1 , typename T2 >
auto	getBB (const T1 &elem1, const T2 &elem2)
	Overload 1/3. This one is called if NONE of the args are a Line2d. More...

template<typename FPT >
Line2d_< FPT >	getBisector (const Segment_< FPT > &seg)
	Free function, returns bisector line of segment. More...

template<typename PLT , typename FPT >
std::vector< Line2d_< HOMOG2D_INUMTYPE > >	getBisectorLines (const base::PolylineBase< PLT, FPT > &pl)
	Returns bisector lines of a Polyline. More...

template<typename T >
auto	getBmPoint (const T &t)
	Return Bottom-most point of container holding points. More...

template<typename PLT , typename FPT >
Point2d_< FPT >	getBmPoint (const base::PolylineBase< PLT, FPT > &poly)
	Return Bottom-most point of Polyline (free function) More...

template<typename FPT >
Circle_< FPT >	getBoundingCircle (const FRect_< FPT > &rect)
	Returns circle passing through 4 points of flat rectangle (free function) More...

template<typename FPT >
Point2d_< FPT >	getCenter (const Segment_< FPT > &seg)
	Free function, returns middle point of segment. More...

template<typename T >
Point2d_< typename T::FType >	getCenter (const T &other)
	Return center of Segment_, FRect_, or Ellipse_ (free function) More...

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
auto	getCenters (const T &vsegs)
	Free function, returns middle points of set of segments/circles. More...

template<typename PLT1 , typename FPT1 , typename PLT2 , typename FPT2 >
priv::ClosestPoints< PLT1, FPT1, PLT2, FPT2 >	getClosestPoints (const base::PolylineBase< PLT1, FPT1 > &poly1, const base::PolylineBase< PLT2, FPT2 > &poly2)
	Computes the closest points between two polylines (types can be different) More...

template<typename FPT >
cv::Point2d	getCvPtd (const Point2d_< FPT > &pt)
	Free function to return an OpenCv point (double) More...

template<typename FPT >
cv::Point2f	getCvPtf (const Point2d_< FPT > &pt)
	Free function to return an OpenCv point (float) More...

template<typename FPT >
cv::Point2i	getCvPti (const Point2d_< FPT > &pt)
	Free function to return an OpenCv point (integer) More...

template<typename FPT >
std::pair< Segment_< FPT >, Segment_< FPT > >	getDiagonals (const FRect_< FPT > &rect)
	Free function. More...

template<typename FPT >
Segment_< FPT >	getExtended (const Segment_< FPT > &seg)
	Returns Extended Segment (free function) More...

template<typename FPT >
FRect_< FPT >	getExtended (const FRect_< FPT > &rect)
	Free function. More...

template<typename T >
auto	getExtremePoint (CardDir dir, const T &t)
	Get Top-most / Bottom-most / Left-most / Right-most point, depending on `dir` (free function) More...

template<typename FPT >
FRect_< FPT >	getFRect (cv::Mat &mat)

template<typename FPT >
Circle_< FPT >	getInscribedCircle (const FRect_< FPT > &rect)
	Return circle inscribed in rectangle. More...

template<typename FPT >
Line2d_< FPT >	getLine (const Segment_< FPT > &seg)
	Returns Segment supporting line (free function) More...

template<typename FPT1 , typename FPT2 , typename FPT3 >
Line2d_< FPT1 >	getLine (const Circle_< FPT2 > &c1, const Circle_< FPT3 > &c2)
	Free function, returns line between two circle centers. More...

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
auto	getLines (const T &vsegs)
	Free function, returns a set of lines from a set of segments. More...

template<typename T >
auto	getLmPoint (const T &t)
	Return Left-most point of container as a pair holding: More...

template<typename PLT , typename FPT >
Point2d_< FPT >	getLmPoint (const base::PolylineBase< PLT, FPT > &poly)
	Return Left-most point of Polyline (free function) More...

template<typename T1 , typename T2 , typename T3 , typename T4 >
auto	getMinMax (const PointPair2_< T1, T2 > &pp1, const PointPair2_< T3, T4 > &pp2)
	Returns a pair of points holding min and max coordinates of the two input pair of points. More...

template<typename FPT >
CPolyline_< FPT >	getOBB (const Ellipse_< FPT > &ell)
	Returns Bounding Box of Ellipse_ (free function) More...

template<typename FPT >
std::array< Point2d_< FPT >, 4 >	getOrthogPts (const Segment_< FPT > &seg)
	Returns the 4 orthogonal points to the segment. More...

template<typename FPT >
std::array< Segment_< FPT >, 4 >	getOrthogSegs (const Segment_< FPT > &seg)
	Returns the 4 orthogonal segments to the segment. More...

template<typename FPT >
HOMOG2D_INUMTYPE	getParallelDistance (const Line2d_< FPT > &li1, const Line2d_< FPT > &li2)
	Returns the distance between 2 parallel lines (free function) More...

template<typename FPT , typename T >
std::pair< Line2d_< FPT >, Line2d_< FPT > >	getParallelLines (const Line2d_< FPT > &li, T dist)
	Returns the 2 parallel lines at distance `dist` from `li` (free function) More...

template<typename FPT , typename T >
std::pair< Segment_< FPT >, Segment_< FPT > >	getParallelSegs (const Segment_< FPT > &seg, T dist)
	Free function, returns a pair of parallel segments at a distance `dist`. More...

template<typename RT , typename FPT >
RT	getPt (const Point2d_< FPT > &pt)
	Generic free function to return a point of other type. More...

template<typename RT , typename FPT >
std::vector< RT >	getPts (const std::vector< Point2d_< FPT >> &vpt)
	Free function, returns a vector of points of other type from a vector of h2d points. More...

template<typename FPT >
auto	getPts (const Segment_< FPT > &seg)
	Returns the points of Segment as a std::pair (free function) More...

template<typename FPT >
auto	getPts (const FRect_< FPT > &rect)
	Returns the 2 major points of the rectangle (free function) More...

template<typename CONT , typename PRIM >
CONT	getPtsInside (const CONT &input_set, const PRIM &prim)
	Returns set of points that are inside primitive `prim`. More...

template<typename T >
auto	getRmPoint (const T &t)
	Return Right-most point of container holding points. More...

template<typename PLT , typename FPT >
Point2d_< FPT >	getRmPoint (const base::PolylineBase< PLT, FPT > &poly)
	Return Right-most point of Polyline (free function) More...

template<typename T1 , typename T2 >
Segment_< typename T1::FType >	getSegment (const T1 &c1, const T2 &c2)
	Free function, returns segment between two circle centers (or ellipse) More...

template<typename PLT , typename FPT >
std::vector< Segment_< FPT > >	getSegs (const base::PolylineBase< PLT, FPT > &pl)
	Returns the segments of the polyline (free function) More...

template<typename FPT >
std::array< Segment_< FPT >, 4 >	getSegs (const FRect_< FPT > &seg)
	Free function, returns segments of the rectangle. More...

const char *	getString (Type t)
	Returns stringified version of type() More...

const char *	getString (Dtype t)

const char *	getString (PointSide t)

template<typename FPT1 , typename FPT2 >
std::pair< Segment_< FPT1 >, Segment_< FPT1 > >	getTanSegs (const Circle_< FPT1 > &c1, const Circle_< FPT2 > &c2)
	Free function, returns the pair of segments tangential to the two circles. More...

template<typename T >
auto	getTmPoint (const T &t)
	Return Top-most point of container. More...

template<typename PLT , typename FPT >
Point2d_< FPT >	getTmPoint (const base::PolylineBase< PLT, FPT > &poly)
	Return Top-most point of Polyline (free function) More...

template<typename FPT >
FPT	getX (const Point2d_< FPT > &pt)

template<typename FPT >
FPT	getY (const Point2d_< FPT > &pt)

template<typename FPT >
HOMOG2D_INUMTYPE	height (const FRect_< FPT > &rect)
	Free function. More...

template<typename FPT1 , typename FPT2 >
detail::RectArea< FPT1 >	intersectArea (const FRect_< FPT1 > &r1, const FRect_< FPT2 > &r2)
	Free function, see FRect_::intersectArea() More...

template<typename FPT1 , typename FPT2 >
HOMOG2D_INUMTYPE	IoU (const FRect_< FPT1 > &r1, const FRect_< FPT2 > &r2)
	Intersection area over Union area (free function) More...

template<typename FPT >
bool	isCircle (const Ellipse_< FPT > &ell, HOMOG2D_INUMTYPE thres=1.E-10)
	Returns true if ellipse is a circle. More...

template<typename PLT , typename FPT >
bool	isConvex (const base::PolylineBase< PLT, FPT > &poly)
	Returns true if polygon is convex (free function) More...

template<typename PLT , typename FPT >
bool	isSimple (const base::PolylineBase< PLT, FPT > &pl)
	Returns true if is a polygon (free function) More...

template<typename T >
HOMOG2D_INUMTYPE	length (const T &elem)
	Returns length of element or variant (free function) More...

template<typename T , typename FP >
void	moveTo (T &prim, const Point2d_< FP > &pt)
	Move primitive to other location (free function) More...

template<typename T , typename FP1 , typename FP2 >
void	moveTo (T &prim, FP1 x, FP2 y)
	Move primitive to other location (free function) More...

template<typename PLT , typename FPT >
size_t	nbSegs (const base::PolylineBase< PLT, FPT > &pl)
	Returns the number of segments (free function) More...

template<typename T , typename U >
Line2d_< T >	operator* (const Homogr_< U > &h, const Line2d_< T > &in)
	Free function, apply homography to a line. More...

template<typename FPT , typename FPT2 >
Line2d_< FPT >	operator* (const Point2d_< FPT > &lhs, const Point2d_< FPT2 > &rhs)
	Free function template, product of two points, returns a line. More...

template<typename FPT1 , typename FPT2 >
Line2d_< FPT1 >	operator* (const Point2d_< FPT1 > &, const Point2d_< FPT2 > &)

template<typename FPT1 , typename FPT2 >
Point2d_< FPT1 >	operator* (const Line2d_< FPT1 > &, const Line2d_< FPT2 > &)

template<typename FPT1 , typename FPT2 >
CPolyline_< FPT1 >	operator* (const h2d::Homogr_< FPT2 > &h, const h2d::FRect_< FPT1 > &rin)
	Apply homography to a flat rectangle produces a closed polyline. More...

template<typename FPT1 , typename FPT2 , typename PLT2 >
auto	operator* (const Homogr_< FPT2 > &, const base::PolylineBase< PLT2, FPT1 > &) -> base::PolylineBase< PLT2, FPT1 >

template<typename FPT , typename FPT2 >
Point2d_< FPT >	operator* (const Line2d_< FPT > &lhs, const Line2d_< FPT2 > &rhs)
	Free function template, product of two lines, returns a point. More...

template<typename SV1 , typename SV2 , typename FPT1 , typename FPT2 >
Point2d_< FPT1 >	operator* (const base::SegVec< SV1, FPT1 > &lhs, const base::SegVec< SV2, FPT2 > &rhs)
	Free function template, product of two segments/vector, returns a point. More...

template<typename T , typename U >
Point2d_< T >	operator* (const Homogr_< U > &h, const Point2d_< T > &in)
	Free function, apply homography to a point. More...

template<typename SV , typename FPT1 , typename FPT2 >
Segment_< FPT1 >	operator* (const Homogr_< FPT1 > &h, const base::SegVec< SV, FPT2 > &seg)
	Apply homography to a Segment. More...

template<typename FPT1 , typename FPT2 , typename PLT >
base::PolylineBase< PLT, FPT1 >	operator* (const Homogr_< FPT2 > &h, const base::PolylineBase< PLT, FPT1 > &pl)
	Apply homography to a Polyline. More...

template<typename FPT1 , typename FPT2 >
Ellipse_< FPT1 >	operator* (const Homogr_< FPT2 > &h, const Ellipse_< FPT1 > &ell_in)
	Apply homography to a Ellipse, produces an Ellipse. More...

template<typename FPT1 , typename FPT2 >
Ellipse_< FPT1 >	operator* (const Homogr_< FPT2 > &h, const Circle_< FPT1 > &cir)
	Apply homography to a Circle, produces an Ellipse. More...

template<typename FPT , typename Cont >
std::enable_if< trait::IsContainer< Cont >::value, Cont >::type	operator* (const Hmatrix_< typ::IsHomogr, FPT > &h, const Cont &vin)
	Used to proceed multiple products, whatever the container (`std::list`, `std::vector`, or `std::array`). Returned container is of same type as given input. More...

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
std::ostream &	operator<< (std::ostream &f, const T &vec)
	Stream operator for a container of points/lines, free function. More...

template<typename LP1 , typename LP2 , typename FPT >
std::ostream &	operator<< (std::ostream &f, const std::pair< base::LPBase< LP1, FPT >, base::LPBase< LP2, FPT >> &pr)
	Stream operator for a pair of points/lines, free function. More...

template<typename T >
std::ostream &	operator<< (std::ostream &f, const FRect_< T > &r)

template<typename T >
std::ostream &	operator<< (std::ostream &f, const Circle_< T > &r)

template<typename T >
std::ostream &	operator<< (std::ostream &f, const Ellipse_< T > &ell)

template<typename FPT >
FPT &	radius (Circle_< FPT > &cir)
	Returns reference on radius of circle (free function), non-const version. More...

template<typename FPT >
const FPT &	radius (const Circle_< FPT > &cir)
	Returns reference on radius of circle (free function), const version. More...

template<typename T >
void	rotate (T &prim, Rotate rot)
	Rotates the primitive (only available for Polyline and FRect) around (0,0) More...

template<typename T , typename FPT >
void	rotate (T &prim, Rotate rot, const Point2d_< FPT > &refpt)
	Rotates the primitive (only available for Polyline and FRect) around `refpt`. More...

template<typename FPT1 , typename FPT2 >
int	side (const Point2d_< FPT1 > &pt, const Line2d_< FPT2 > &li)
	Free function, returns -1 or +1 depending on the side of `pt`, related to `li`. More...

template<typename T >
HOMOG2D_INUMTYPE	size (const T &elem)
	Returns size of element or variant (free function) More...

template<typename SV , typename FPT >
std::pair< base::SegVec< SV, FPT >, base::SegVec< SV, FPT > >	split (const base::SegVec< SV, FPT > &seg)
	Returns a pair of segments, corresponding to the input segment split by middle point (free function) More...

template<typename FPT , typename T >
std::pair< OSegment_< FPT >, OSegment_< FPT > >	split (const OSegment_< FPT > &seg, T dist)
	Returns a pair of segments, corresponding to the input segment split by point at distance `dist` (free function) More...

template<typename T , typename FPT >
CommonType_< FPT >	transform (const Homogr_< FPT > &h, const T &elem)
	Apply homography to primitive. More...

template<typename T , typename FP1 , typename FP2 >
void	translate (T &prim, FP1 dx, FP2 dy)
	Translate primitive `prim` (free function) More...

template<typename T , typename FP1 , typename FP2 >
void	translate (T &prim, const std::pair< FP1, FP2 > &ppt)
	Translate primitive `prim` with values in a `std::pair` (free function) More...

template<typename T >
Type	type (const T &elem)
	Free function. Returns the type of object or variant. More...

template<typename FPT1 , typename FPT2 >
CPolyline_< FPT1 >	unionArea (const FRect_< FPT1 > &r1, const FRect_< FPT2 > &r2)
	Free function, see FRect_::unionArea() More...

template<typename FPT >
HOMOG2D_INUMTYPE	width (const FRect_< FPT > &rect)
	Free function. More...

Typedef Documentation

◆ Circle

using h2d::Circle = typedef Circle_<HOMOG2D_INUMTYPE>

Default circle type.

◆ CircleD

using h2d::CircleD = typedef Circle_<double>

◆ CircleF

using h2d::CircleF = typedef Circle_<float>

◆ CircleL

using h2d::CircleL = typedef Circle_<long double>

◆ CommonType

using h2d::CommonType = typedef CommonType_<HOMOG2D_INUMTYPE>

◆ CommonType_

template<typename FPT >

using h2d::CommonType_ = typedef std::variant< Segment_<FPT>, OSegment_<FPT>, Point2d_<FPT>, Line2d_<FPT>, Circle_<FPT>, Ellipse_<FPT>, FRect_<FPT>, CPolyline_<FPT>, OPolyline_<FPT> >

A variant type, holding all possible types. Used to achieve runtime polymorphism.

See https://github.com/skramm/homog2d/blob/master/docs/homog2d_manual.md#section_rtp

◆ CommonTypeD

using h2d::CommonTypeD = typedef CommonType_<double>

◆ CommonTypeF

using h2d::CommonTypeF = typedef CommonType_<float>

◆ CommonTypeL

using h2d::CommonTypeL = typedef CommonType_<long double>

◆ CPolyline

using h2d::CPolyline = typedef CPolyline_<HOMOG2D_INUMTYPE>

Default polyline type.

◆ CPolyline_

template<typename T >

using h2d::CPolyline_ = typedef base::PolylineBase<typ::IsClosed,T>

◆ CPolylineD

using h2d::CPolylineD = typedef CPolyline_<double>

◆ CPolylineF

using h2d::CPolylineF = typedef CPolyline_<float>

◆ CPolylineL

using h2d::CPolylineL = typedef CPolyline_<long double>

◆ Ellipse

using h2d::Ellipse = typedef Ellipse_<HOMOG2D_INUMTYPE>

Default ellipse type.

◆ EllipseD

using h2d::EllipseD = typedef Ellipse_<double>

◆ EllipseF

using h2d::EllipseF = typedef Ellipse_<float>

◆ EllipseL

using h2d::EllipseL = typedef Ellipse_<long double>

◆ Epipmat

using h2d::Epipmat = typedef Hmatrix_<typ::IsEpipmat,HOMOG2D_INUMTYPE>

Default homogeneous matrix, uses double as numerical type.

◆ FRect

using h2d::FRect = typedef FRect_<HOMOG2D_INUMTYPE>

Default rectangle type.

◆ FRectD

using h2d::FRectD = typedef FRect_<double>

◆ FRectF

using h2d::FRectF = typedef FRect_<float>

◆ FRectL

using h2d::FRectL = typedef FRect_<long double>

◆ Homogr

using h2d::Homogr = typedef Homogr_<HOMOG2D_INUMTYPE>

Default homography (3x3 matrix) type, uses double as numerical type.

◆ Homogr_

template<typename T >

using h2d::Homogr_ = typedef Hmatrix_<typ::IsHomogr,T>

◆ HomogrD

using h2d::HomogrD = typedef Homogr_<double>

◆ HomogrF

using h2d::HomogrF = typedef Homogr_<float>

◆ HomogrL

using h2d::HomogrL = typedef Homogr_<long double>

◆ Line2d

using h2d::Line2d = typedef Line2d_<HOMOG2D_INUMTYPE>

Default line type, uses double as numerical type.

◆ Line2d_

template<typename T >

using h2d::Line2d_ = typedef base::LPBase<typ::IsLine,T>

◆ Line2dD

using h2d::Line2dD = typedef Line2d_<double>

◆ Line2dF

using h2d::Line2dF = typedef Line2d_<float>

◆ Line2dL

using h2d::Line2dL = typedef Line2d_<long double>

◆ OPolyline

using h2d::OPolyline = typedef OPolyline_<HOMOG2D_INUMTYPE>

◆ OPolyline_

template<typename T >

using h2d::OPolyline_ = typedef base::PolylineBase<typ::IsOpen,T>

◆ OPolylineD

using h2d::OPolylineD = typedef OPolyline_<double>

◆ OPolylineF

using h2d::OPolylineF = typedef OPolyline_<float>

◆ OPolylineL

using h2d::OPolylineL = typedef OPolyline_<long double>

◆ OSegment

using h2d::OSegment = typedef OSegment_<HOMOG2D_INUMTYPE>

◆ OSegment_

template<typename T >

using h2d::OSegment_ = typedef base::SegVec<typ::IsOSeg,T>

◆ OSegmentD

using h2d::OSegmentD = typedef OSegment_<double>

◆ OSegmentF

using h2d::OSegmentF = typedef OSegment_<float>

◆ OSegmentL

using h2d::OSegmentL = typedef OSegment_<long double>

◆ Point2d

using h2d::Point2d = typedef Point2d_<HOMOG2D_INUMTYPE>

Default point type, uses double as numerical type.

◆ Point2d_

template<typename T >

using h2d::Point2d_ = typedef base::LPBase<typ::IsPoint,T>

◆ Point2dD

using h2d::Point2dD = typedef Point2d_<double>

◆ Point2dF

using h2d::Point2dF = typedef Point2d_<float>

◆ Point2dL

using h2d::Point2dL = typedef Point2d_<long double>

◆ PointPair

using h2d::PointPair = typedef PointPair_<double>

◆ PointPair2_

template<typename T1 , typename T2 >

using h2d::PointPair2_ = typedef std::pair<Point2d_<T1>,Point2d_<T2> >

◆ PointPair_

template<typename T >

using h2d::PointPair_ = typedef std::pair<Point2d_<T>,Point2d_<T> >

◆ PointPairD

using h2d::PointPairD = typedef PointPair_<double>

◆ PointPairF

using h2d::PointPairF = typedef PointPair_<float>

◆ PointPairL

using h2d::PointPairL = typedef PointPair_<long double>

◆ Segment

using h2d::Segment = typedef Segment_<HOMOG2D_INUMTYPE>

Default segment type.

◆ Segment_

template<typename T >

using h2d::Segment_ = typedef base::SegVec<typ::IsSegment,T>

◆ SegmentD

using h2d::SegmentD = typedef Segment_<double>

◆ SegmentF

using h2d::SegmentF = typedef Segment_<float>

◆ SegmentL

using h2d::SegmentL = typedef Segment_<long double>

Enumeration Type Documentation

◆ CardDir

enum h2d::CardDir : int8_t

strong

Enumerator
Bottom
Top
Left
Right

922 : int8_t { Bottom,Top, Left, Right };

◆ Dtype

enum h2d::Dtype : uint8_t

strong

Type of underlying floating point, see LPBase::dtype(). Maybe printed out with getString()

Enumerator
Float
Double
LongDouble
Other
Ttmath	only if HOMOG2D_USE_TTMATH is defined, see manual

                 : uint8_t {
     Float, Double, LongDouble,
     Other,  // ?
 #ifdef HOMOG2D_USE_TTMATH
     Ttmath  
 #endif
 };

◆ GivenCoord

enum h2d::GivenCoord : uint8_t

strong

Used in Line2d::getValue() and getOrthogLine()

Enumerator
X
Y

925 : uint8_t { X, Y };

h2d::GivenCoord::X

h2d::GivenCoord::Y

◆ LineDir

enum h2d::LineDir : uint8_t

strong

Used in line constructor, to instanciate a H or V line, see base::LPBase( LineDir, T )

Enumerator
H
V

928 : uint8_t { H, V };

h2d::LineDir::V

h2d::LineDir::H

◆ PointSide

enum h2d::PointSide : uint8_t

strong

Point related to a OSegment.

See also: SegVec::getPointSide()

Enumerator
Left
Right
Neither

                     : uint8_t
 {
     Left,Right,Neither
 };

◆ Rotate

enum h2d::Rotate : int8_t

strong

Used in base::PolylineBase_::rotate() member function.

Enumerator
CCW	Counter ClockWise rotation.
CW	ClockWise rotation.
Full	180° rotation
VMirror	vertical symmetry
HMirror	horizontal symmetry

                  : int8_t
 {
     CCW,      
     CW,       
     Full,     
     VMirror,  
     HMirror   
 };

◆ Type

enum h2d::Type : uint8_t

strong

Type of Root object, see rtp::Root::type(). Maybe printed out with getString()

See also: type()

Enumerator
Line2d
Point2d
Segment
OSegment
FRect
Circle
Ellipse
OPolyline
CPolyline

933 : uint8_t { Line2d, Point2d, Segment, OSegment, FRect, Circle, Ellipse, OPolyline, CPolyline };

h2d::OPolyline

OPolyline_< HOMOG2D_INUMTYPE > OPolyline

Definition: homog2d.hpp:12400

h2d::FRect

FRect_< HOMOG2D_INUMTYPE > FRect

Default rectangle type.

Definition: homog2d.hpp:12396

h2d::Segment

Segment_< HOMOG2D_INUMTYPE > Segment

Default segment type.

Definition: homog2d.hpp:12389

h2d::Circle

Circle_< HOMOG2D_INUMTYPE > Circle

Default circle type.

Definition: homog2d.hpp:12393

h2d::Line2d

Line2d_< HOMOG2D_INUMTYPE > Line2d

Default line type, uses double as numerical type.

Definition: homog2d.hpp:12377

h2d::OSegment

OSegment_< HOMOG2D_INUMTYPE > OSegment

Definition: homog2d.hpp:12390

h2d::Ellipse

Ellipse_< HOMOG2D_INUMTYPE > Ellipse

Default ellipse type.

Definition: homog2d.hpp:12403

h2d::CPolyline

CPolyline_< HOMOG2D_INUMTYPE > CPolyline

Default polyline type.

Definition: homog2d.hpp:12399

h2d::Point2d

Point2d_< HOMOG2D_INUMTYPE > Point2d

Default point type, uses double as numerical type.

Definition: homog2d.hpp:12380

Function Documentation

◆ angle()

template<typename FPT >

HOMOG2D_INUMTYPE h2d::angle ( const Ellipse_< FPT > & ell )

Return angle of ellipse (free function)

See also: Ellipse_::angle()

 {
     return ell.angle();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ areCollinear()

template<typename FPT >

bool h2d::areCollinear	(	const Point2d_< FPT > &	pt1,
		const Point2d_< FPT > &	pt2,
		const Point2d_< FPT > &	pt3
	)

Returns true if the 3 points are on the same line.

Todo:: at present, defined by the distance between third point and line. Need to change that, and replace by computation of the angle between the two lines

 {
     if( pt1 == pt2 || pt2 == pt3 || pt1 == pt3 )
         return true;
 
     auto pt_arr = priv::getLargestDistancePoints( pt1, pt2, pt3 );
 
     auto li = pt_arr[0] * pt_arr[1];
     if( li.distTo( pt_arr[2] ) < thr::nullDistance() )
         return true;
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ areParallel()

template<typename T1 , typename T2 >

bool h2d::areParallel	(	const T1 &	t1,
		const T2 &	t2
	)

Returns true is lines (or segments) are parallel.

 {
     return t1.isParallelTo(t2);
 }

Here is the caller graph for this function:

◆ buildFrom4Points()

template<typename FPT >

Homogr_<FPT> h2d::buildFrom4Points	(	const std::vector< Point2d_< FPT >> &	vpt1,
		const std::vector< Point2d_< FPT >> &	vpt2,
		int	method = `1`
	)

Build Homography from 2 sets of 4 points (free function)

See also: Homogr_::buildFrom4Points()

Parameters

vpt1	source points
vpt2	destination points
method	0: Eigen, 1: Opencv

 {
     Homogr_<FPT> H;
     H.buildFrom4Points( vpt1, vpt2, method );
     return H;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ center() [1/2]

template<typename FPT >

Point2d_<FPT>& h2d::center ( Circle_< FPT > & cir )

Returns reference on center of circle (free function), non-const version.

See also: Circle_::center()

 {
     return cir.center();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ center() [2/2]

template<typename FPT >

const Point2d_<FPT>& h2d::center ( const Circle_< FPT > & cir )

Returns reference on center of circle (free function), const version.

See also: Circle_::center()

 {
     return cir.center();
 }

Here is the call graph for this function:

◆ centroid()

template<typename PLT , typename FPT >

base::LPBase<typ::IsPoint,FPT> h2d::centroid ( const base::PolylineBase< PLT, FPT > & pl )

Returns centroid of Polyline (free function)

See also: PolylineBase::centroid()

 {
     return pl.centroid();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ convexHull()

template<typename CT , typename FPT >

CPolyline_<FPT> h2d::convexHull ( const base::PolylineBase< CT, FPT > & input )

Compute Convex Hull of a Polyline (free function)

type T: can be either OPolyline, CPolyline, or std::vector<Point2d>
Graham scan algorithm: https://en.wikipedia.org/wiki/Graham_scan

 {
     return convexHull( input.getPts() );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dist()

template<typename FPT1 , typename FPT2 >

HOMOG2D_INUMTYPE h2d::dist	(	const Point2d_< FPT1 > &	pt1,
		const Point2d_< FPT2 > &	pt2
	)

Free function, distance between points.

See also: Point2d_::distTo()

 {
     return pt1.distTo( pt2 );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ draw() [1/3]

template<typename U , typename Prim , typename std::enable_if< trait::IsDrawable< Prim >::value, Prim >::type * = nullptr>

void h2d::draw	(	img::Image< U > &	img,
		const Prim &	prim,
		const img::DrawParams &	dp = `img::DrawParams()`
	)

Free function, draws any of the primitives by calling the relevant member function.

Todo:: 20240504: see note on the IsDrawable trait class

 {
     prim.draw( img, dp );
 }

Here is the caller graph for this function:

◆ draw() [2/3]

template<typename U , typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>

void h2d::draw	(	img::Image< U > &	img,
		const T &	cont,
		std::function< img::DrawParams(int)> &	func
	)

This version holds a std::function as 3th parameter. It can be used to pass a function that will return a different img::DrawParams for a given index of the container.

At present, cannot be used with container holding variants...

 {
     size_t c=0;
     for( const auto& elem: cont )
     {
         auto dp = func(c);
         elem.draw( img, dp );
         priv::impl_drawIndexes( img, c++, dp, elem );
     }
 }

Here is the call graph for this function:

◆ draw() [3/3]

template<typename T1 , typename T2 , typename U >

void h2d::draw	(	img::Image< U > &	img,
		const std::pair< T1, T2 > &	pa,
		const img::DrawParams &	dp = `img::DrawParams()`
	)

Free function, draws a pair of objects.

Type T1 and T2 can be anything drawable

 {
     pa.first.draw(  img, dp );
     pa.second.draw( img, dp );
 }

◆ drawText()

template<typename U , typename FPT >

void h2d::drawText	(	img::Image< U > &	im,
		std::string	str,
		Point2d_< FPT >	pt,
		img::DrawParams	dp = `img::DrawParams()`
	)

Free function, draws text str at position pt.

 {
     im.drawText( str, pt, dp );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dsize()

template<typename T >

std::pair<int,int> h2d::dsize ( const T & t )

Get data size expressed as number of bits for, respectively, mantissa and exponent.

See also: detail::Common::dsize()

 {
     return t.dsize();
 }

Here is the caller graph for this function:

◆ findFarthestPoint()

template<typename FPT , typename T >

size_t h2d::findFarthestPoint	(	const Point2d_< FPT > &	pt,
		const T &	cont
	)

Returns index of point in container cont that is the farthest to pt.

 {
     return priv::findPoint( pt, cont, priv::F_MAX() );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findNearestFarthestPoint()

template<typename FPT , typename T >

auto h2d::findNearestFarthestPoint	(	const Point2d_< FPT > &	pt,
		const T &	cont
	)

Returns indexes of points in container cont that are nearest/farthest.

return pair: first is nearest, second is farthest

 {
     if( cont.size() < 2 )
         HOMOG2D_THROW_ERROR_1( "container holds " << cont.size() \
             << " points, minimum is 2" );
 
     auto maxDist = priv::sqDist( pt, cont[0] );
     auto minDist = maxDist;
     size_t idxMin = 0;
     size_t idxMax = 0;
     size_t startIdx = 1;
     if( pt == cont[0] )
     {
         idxMin++;
         idxMax++;
         startIdx++;
         maxDist = priv::sqDist( pt, cont[1] );
         minDist = maxDist;
     }
     for( size_t i=startIdx; i<cont.size(); i++ )
     {
         if( pt != cont[i] )
         {
             auto currentDist = priv::sqDist( pt, cont[i] );
             if( currentDist > maxDist )
             {
                 idxMax  = i;
                 maxDist = currentDist;
             }
             if( currentDist < minDist )
             {
                 idxMin  = i;
                 minDist = currentDist;
             }
         }
     }
     return std::make_pair(idxMin, idxMax);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findNearestPoint()

template<typename FPT , typename T >

size_t h2d::findNearestPoint	(	const Point2d_< FPT > &	pt,
		const T &	cont
	)

Returns index of point in container cont that is the nearest to pt.

Todo:

add some sfinae and/or checking on type T

perform some speed analysis, and check if usage of squared distance is really better

add other distance computations (Manhattan?)

Would it be better to return an iterator?

 {
     return priv::findPoint( pt, cont, priv::F_MIN() );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get4Pts()

template<typename FPT >

std::array<Point2d_<FPT>,4> h2d::get4Pts ( const FRect_< FPT > & rect )

Returns the 4 points of the rectangle (free function)

See also: FRect_::get4Pts()

 {
     return rect.get4Pts();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAngle()

template<typename T1 , typename T2 >

HOMOG2D_INUMTYPE h2d::getAngle	(	const T1 &	t1,
		const T2 &	t2
	)

Free function, returns angle between two segments/lines.

See also: Segment_::getAngle(); Line2d_::getAngle()

 {
     static_assert(
         (
                std::is_same_v<typename T1::SType,typ::IsLine>
             || std::is_same_v<typename T1::SType,typ::IsSegment>
             || std::is_same_v<typename T1::SType,typ::IsOSeg>
         ) &&
         (
                std::is_same_v<typename T2::SType,typ::IsLine>
             || std::is_same_v<typename T2::SType,typ::IsSegment>
             || std::is_same_v<typename T2::SType,typ::IsOSeg>
         ),
         "Both types must be either a Line or a Segment"
     );
     return t1.getAngle( t2 );
 }

Here is the caller graph for this function:

◆ getAxisLines()

template<typename FPT >

std::pair<Line2d_<FPT>,Line2d_<FPT> > h2d::getAxisLines ( const Ellipse_< FPT > & ell )

Returns ellipse axis lines.

See also: Ellipse_::getAxisLines()

 {
     return ell.getAxisLines();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getBB() [1/2]

template<typename T1 , typename T2 , typename T3 , typename T4 >

auto h2d::getBB	(	const PointPair2_< T1, T2 > &	pp1,
		const PointPair2_< T3, T4 > &	pp2
	)

Returns bounding box of two pairs of points.

Warning: May throw in case of identical coordinates (for example with [0,0]-[1,0] and [10,0]-[20,0]

 {
     HOMOG2D_START;
     return FRect_<T1>( getMinMax( pp1, pp2 ) );
 }

Here is the call graph for this function:

◆ getBB() [2/2]

template<typename T1 , typename T2 >

auto h2d::getBB	(	const T1 &	elem1,
		const T2 &	elem2
	)

Overload 1/3. This one is called if NONE of the args are a Line2d.

Overload 3/3. Called if one of the args is a Line2d (=> no build!)

 {
     HOMOG2D_START;
 
     bool isPoly_1 = false;
     if( elem1.type() == Type::OPolyline || elem1.type() == Type::CPolyline )
         isPoly_1 = true;
 
     bool isPoly_2 = false;
     if( elem2.type() == Type::OPolyline || elem2.type() == Type::CPolyline )
         isPoly_1 = true;
 
     auto siz_1 = elem1.size();
     auto siz_2 = elem2.size();
 
     if( isPoly_1 && isPoly_2 )
         if( siz_1==0 && siz_2==0 )
             HOMOG2D_THROW_ERROR_1( "unable to compute bounding box of two empty polyline objects" );
 
     FRect_<typename T1::FType> out;
 // we need to do that in two steps: first, copy return value into `out`, then return
 // because the underlying floating point might not be the same for the two arguments.
     if( isPoly_2 && siz_1==0 )
     {
         auto pp = ppair::getPointPair( elem2 );
         if( shareCommonCoord(pp) )
         {
             HOMOG2D_THROW_ERROR_1( "Unable to build common Bounding Box of empty polyline and elem2:" << elem2 );
         }
         else
             return FRect_<typename T1::FType>( pp );
     }
     if( isPoly_1 && siz_2==0 )
     {
         auto pp = ppair::getPointPair( elem1 );
         if( shareCommonCoord(pp) )
         {
             HOMOG2D_THROW_ERROR_1( "Unable to build common Bounding Box of empty polyline and elem1:" << elem1 );
         }
         else
             return FRect_<typename T1::FType>( pp );
     }
 
     try
     {
         out = getBB(
             ppair::getPointPair( elem1 ),
             ppair::getPointPair( elem2 )
         );
     }
     catch( const std::exception& err )
     {
         HOMOG2D_THROW_ERROR_1( "unable to compute bounding box:\n -arg1="
             << elem1 << "\n -arg2=" << elem2 << "\n -err=" << err.what() );
     }
     return out;
 }

Here is the call graph for this function:

◆ getBisector()

template<typename FPT >

Line2d_<FPT> h2d::getBisector ( const Segment_< FPT > & seg )

Free function, returns bisector line of segment.

See also: Segment_::getBisector()

 {
     return seg.getBisector();
 }

Here is the call graph for this function:

◆ getBisectorLines()

template<typename PLT , typename FPT >

std::vector< Line2d_< HOMOG2D_INUMTYPE > > h2d::getBisectorLines ( const base::PolylineBase< PLT, FPT > & pl )

Returns bisector lines of a Polyline.

Size of vector will be:

equal to size() of polyline if closed
equal to size()-2 of polyline if open

Warning

:

if open: the FIRST line (index 0) will correspond to SECOND point of the polyline

 {
     if( pl.size() < 3 )
     {
         HOMOG2D_THROW_ERROR_1( "unable, minimum size is 3, currently=" << pl.size() );
     }
     const auto& pts  = pl.getPts();
     std::vector<Line2d_<HOMOG2D_INUMTYPE>> out;
 
     if constexpr ( std::is_same_v<PLT,typ::IsOpen> )
     {
         out.reserve( pl.size()-2 );
         OSegment_<HOMOG2D_INUMTYPE> seg1( pts[1], pts[0] );
         for( size_t i=0; i<pl.size()-2; i++ )
         {
             OSegment_<HOMOG2D_INUMTYPE> seg2( pts[i+1], pts[i+2] );
             auto angle = seg1.getAngle( seg2 );
             out.emplace_back( seg1.getLine().getRotatedLine( pts[i+1], angle/2. ) );
             seg1 = -seg2;
         }
     }
     else
     {
         out.reserve( pl.size() );
         OSegment_<HOMOG2D_INUMTYPE> seg1( pts[0], pts[pl.size()-1] );
         for( size_t i=0; i<pl.size(); i++ )
         {
             auto next = ( i != pl.size()-1 ? i+1 : 0 );
             OSegment_<HOMOG2D_INUMTYPE> seg2( pts[i], pts[next] );
             auto angle = seg1.getAngle( seg2 );
             out.emplace_back( seg1.getLine().getRotatedLine( pts[i], angle/2. ) );
             seg1 = -seg2;
         }
     }
     return out;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getBmPoint() [1/2]

template<typename T >

auto h2d::getBmPoint ( const T & t )

Return Bottom-most point of container holding points.

 {
 #ifndef HOMOG2D_NOCHECKS
     if( t.size() == 0 )
         HOMOG2D_THROW_ERROR_1( "invalid call, container is empty" );
 #endif
     auto it = priv::getBmPoint_helper( t );
     return std::make_pair(
         *it,
         std::distance( std::begin(t), it )
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getBmPoint() [2/2]

template<typename PLT , typename FPT >

Point2d_<FPT> h2d::getBmPoint ( const base::PolylineBase< PLT, FPT > & poly )

Return Bottom-most point of Polyline (free function)

 {
     return getBmPoint( poly.getPts() ).first;
 }

Here is the call graph for this function:

◆ getBoundingCircle()

template<typename FPT >

Circle_<FPT> h2d::getBoundingCircle ( const FRect_< FPT > & rect )

Returns circle passing through 4 points of flat rectangle (free function)

See also: FRect_::getBoundingCircle()

 {
     return rect.getBoundingCircle();
 }

Here is the call graph for this function:

◆ getCenter() [1/2]

template<typename FPT >

Point2d_<FPT> h2d::getCenter ( const Segment_< FPT > & seg )

Free function, returns middle point of segment.

See also: Segment_::getCenter()

 {
     return seg.getCenter();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCenter() [2/2]

template<typename T >

Point2d_<typename T::FType> h2d::getCenter ( const T & other )

Return center of Segment_, FRect_, or Ellipse_ (free function)

See also: Ellipse_::getCenter(); FRect_::getCenter(); Segment_::getCenter()

 {
     return other.getCenter();
 }

◆ getCenters()

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>

auto h2d::getCenters ( const T & vsegs )

Free function, returns middle points of set of segments/circles.

See also

Segment_::getCenter()

Circle_::getCenter()

input: set of segments
output: set of points (same container)

 {
     std::vector<Point2d_<typename T::value_type::FType>> vout( vsegs.size() );
 
     auto it = std::begin( vout );
     for( const auto& seg: vsegs )
         *it++ = getCenter( seg );
     return vout;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getClosestPoints()

template<typename PLT1 , typename FPT1 , typename PLT2 , typename FPT2 >

priv::ClosestPoints< PLT1, FPT1, PLT2, FPT2 > h2d::getClosestPoints	(	const base::PolylineBase< PLT1, FPT1 > &	poly1,
		const base::PolylineBase< PLT2, FPT2 > &	poly2
	)

Computes the closest points between two polylines (types can be different)

 {
 #ifndef HOMOG2D_NOCHECKS
     if( poly1.size() == 0 )
         HOMOG2D_THROW_ERROR_1( "arg 1 is empty" );
     if( poly2.size() == 0 )
         HOMOG2D_THROW_ERROR_1( "arg 2 is empty" );
 #endif
     priv::ClosestPoints<PLT1,FPT1,PLT2,FPT2> out( poly1, poly2 );
     for( size_t i=0; i<poly1.size(); i++ )
     {
         const auto& pt1 = poly1.getPoint(i);
         for( size_t j=0; j<poly2.size(); j++ )
         {
             const auto& pt2 = poly2.getPoint(j);
             auto currentDist = dist( pt1, pt2 );
             if( currentDist < out._minDist )
                 out.store( currentDist, i, j );
         }
     }
     return out;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCvPtd()

template<typename FPT >

cv::Point2d h2d::getCvPtd ( const Point2d_< FPT > & pt )

Free function to return an OpenCv point (double)

 {
     return pt.getCvPtd();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCvPtf()

template<typename FPT >

cv::Point2f h2d::getCvPtf ( const Point2d_< FPT > & pt )

Free function to return an OpenCv point (float)

 {
     return pt.getCvPtf();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCvPti()

template<typename FPT >

cv::Point2i h2d::getCvPti ( const Point2d_< FPT > & pt )

Free function to return an OpenCv point (integer)

 {
     return pt.getCvPti();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDiagonals()

template<typename FPT >

std::pair<Segment_<FPT>,Segment_<FPT> > h2d::getDiagonals ( const FRect_< FPT > & rect )

Free function.

 {
     return rect.getDiagonals();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getExtended() [1/2]

template<typename FPT >

Segment_<FPT> h2d::getExtended ( const Segment_< FPT > & seg )

Returns Extended Segment (free function)

See also: Segment_::geExtended()

 {
     return seg.getExtended();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getExtended() [2/2]

template<typename FPT >

FRect_<FPT> h2d::getExtended ( const FRect_< FPT > & rect )

Free function.

 {
     return rect.getExtended();
 }

Here is the call graph for this function:

◆ getExtremePoint()

template<typename T >

auto h2d::getExtremePoint	(	CardDir	dir,
		const T &	t
	)

Get Top-most / Bottom-most / Left-most / Right-most point, depending on dir (free function)

Type T can be either a Polyline (open or closed), or a container holding points, or a FRect_

 {
     switch( dir )
     {
         case CardDir::Top:    return getTmPoint(t); break;
         case CardDir::Bottom: return getBmPoint(t); break;
         case CardDir::Left:   return getLmPoint(t); break;
         case CardDir::Right:  return getRmPoint(t); break;
         default: assert(0);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFRect()

template<typename FPT >

FRect_<FPT> h2d::getFRect ( cv::Mat & mat )

 {
     if(  mat.cols == 0 || mat.rows == 0 )
         HOMOG2D_THROW_ERROR_1(
             "Illegal values: cols=" << mat.cols << ", rows=" << mat.rows
         );
 
     return FRect_<FPT>(
         Point2d_<FPT>(),                      // (0,0)
         Point2d_<FPT>( mat.cols, mat.rows )   // (w,h)
     );
 }

◆ getInscribedCircle()

template<typename FPT >

Circle_<FPT> h2d::getInscribedCircle ( const FRect_< FPT > & rect )

Return circle inscribed in rectangle.

See also: hFRect_::getInscribedCircle()

 {
     return rect.getInscribedCircle();
 }

Here is the call graph for this function:

◆ getLine() [1/2]

template<typename FPT >

Line2d_<FPT> h2d::getLine ( const Segment_< FPT > & seg )

Returns Segment supporting line (free function)

See also: Segment_::getLine()

 {
     return seg.getLine();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLine() [2/2]

template<typename FPT1 , typename FPT2 , typename FPT3 >

Line2d_<FPT1> h2d::getLine	(	const Circle_< FPT2 > &	c1,
		const Circle_< FPT3 > &	c2
	)

Free function, returns line between two circle centers.

 {
     return Line2d_<FPT1>( c1.center(), c2.center() );
 }

Here is the call graph for this function:

◆ getLines()

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>

auto h2d::getLines ( const T & vsegs )

Free function, returns a set of lines from a set of segments.

See also: Segment_::getLine()

 {
     std::vector<Line2d_<typename T::value_type::FType>> vout( vsegs.size() );
 
     auto it = std::begin( vout );
     for( const auto& seg: vsegs )
         *it++ = seg.getLine();
     return vout;
 }

Here is the caller graph for this function:

◆ getLmPoint() [1/2]

template<typename T >

auto h2d::getLmPoint ( const T & t )

Return Left-most point of container as a pair holding:

first: the point
second: the distance (index) from begin position

Todo:: 20250222: CHANGE RETURN TYPE! => should return an iterator, not a pair (so this allows usage of any non-random access container)

 {
     using FPT = typename T::value_type::FType;
 
 #ifndef HOMOG2D_NOCHECKS
     if( t.size() == 0 )
         HOMOG2D_THROW_ERROR_1( "invalid call, container is empty" );
 #endif
 
     auto it = std::min_element(
         std::begin(t),
         std::end(t),
         []                  // lambda
         ( const Point2d_<FPT>& pt1, const Point2d_<FPT>& pt2 )
         {
             if( pt1.getX() < pt2.getX() )
                 return true;
             if( pt1.getX() > pt2.getX() )
                 return false;
             return( pt1.getY() < pt2.getY() );
         }
     );
 
     return std::make_pair(
         *it,
         std::distance( std::begin(t), it )
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLmPoint() [2/2]

template<typename PLT , typename FPT >

Point2d_<FPT> h2d::getLmPoint ( const base::PolylineBase< PLT, FPT > & poly )

Return Left-most point of Polyline (free function)

 {
     return getLmPoint( poly.getPts() ).first;
 }

Here is the call graph for this function:

◆ getMinMax()

template<typename T1 , typename T2 , typename T3 , typename T4 >

auto h2d::getMinMax	(	const PointPair2_< T1, T2 > &	pp1,
		const PointPair2_< T3, T4 > &	pp2
	)

Returns a pair of points holding min and max coordinates of the two input pair of points.

Tests: search for [minmax]

 {
     HOMOG2D_START;
 
     std::array<Point2d_<HOMOG2D_INUMTYPE>,4> arr;
     arr[0] = pp1.first;
     arr[1] = pp2.first;
     arr[2] = pp1.second;
     arr[3] = pp2.second;
 
     return priv::getBB_Points( arr );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getOBB()

template<typename FPT >

CPolyline_<FPT> h2d::getOBB ( const Ellipse_< FPT > & ell )

Returns Bounding Box of Ellipse_ (free function)

See also: Ellipse_::getBB()

 {
     return ell.getOBB();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getOrthogPts()

template<typename FPT >

std::array<Point2d_<FPT>,4> h2d::getOrthogPts ( const Segment_< FPT > & seg )

Returns the 4 orthogonal points to the segment.

See also: Segment_::getOrthogPts()

 {
     return seg.getOrthogPts();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getOrthogSegs()

template<typename FPT >

std::array<Segment_<FPT>,4> h2d::getOrthogSegs ( const Segment_< FPT > & seg )

Returns the 4 orthogonal segments to the segment.

See also: Segment_::getOrthogSegs()

 {
     return seg.getOrthogSegs();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getParallelDistance()

template<typename FPT >

HOMOG2D_INUMTYPE h2d::getParallelDistance	(	const Line2d_< FPT > &	li1,
		const Line2d_< FPT > &	li2
	)

Returns the distance between 2 parallel lines (free function)

ref: https://en.wikipedia.org/wiki/Distance_between_two_parallel_lines

We first check that the two lines are indeed parallel. This should ensure that a1=a2 and b1=b2. But due to numeric issues they could by slightly different. In order to gain accuracy, we use the geometric mean of these.

 {
 #ifndef HOMOG2D_NOCHECKS
     if( !li1.isParallelTo(li2) )
         HOMOG2D_THROW_ERROR_1( "lines are not parallel" );
 #endif
     const auto ar1 = li1.get();
     const auto ar2 = li2.get();
     const HOMOG2D_INUMTYPE a1 = ar1[0];
     const HOMOG2D_INUMTYPE b1 = ar1[1];
     const HOMOG2D_INUMTYPE c1 = ar1[2];
     const HOMOG2D_INUMTYPE a2 = ar2[0];
     const HOMOG2D_INUMTYPE b2 = ar2[1];
     const HOMOG2D_INUMTYPE c2 = ar2[2];
 
     HOMOG2D_INUMTYPE a = homog2d_sqrt( a1*a2 );
     HOMOG2D_INUMTYPE b = homog2d_sqrt( b1*b2 );
     return homog2d_abs( c1 - c2 ) / homog2d_sqrt( a*a + b*b );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getParallelLines()

template<typename FPT , typename T >

std::pair<Line2d_<FPT>,Line2d_<FPT> > h2d::getParallelLines	(	const Line2d_< FPT > &	li,
		T	dist
	)

Returns the 2 parallel lines at distance dist from li (free function)

 {
     return li.getParallelLines( dist );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getParallelSegs()

template<typename FPT , typename T >

std::pair<Segment_<FPT>,Segment_<FPT> > h2d::getParallelSegs	(	const Segment_< FPT > &	seg,
		T	dist
	)

Free function, returns a pair of parallel segments at a distance dist.

See also: Segment_::getBisector()

 {
     return seg.getParallelSegs(dist);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPt()

template<typename RT , typename FPT >

RT h2d::getPt ( const Point2d_< FPT > & pt )

Generic free function to return a point of other type.

RT: return type
FPT: Floating Point Type

User code needs to provide the requested type as template argument, for example:

auto p1 = getPt<cv::Point2di>( pt ); // opencv type

auto p2 = getPt<boost::geometry::model::point_xy<double>>( pt ); // boost geometry type

See also: LPBase::getPt()

 {
     return pt.template getPt<RT>();
 }

◆ getPts() [1/3]

template<typename RT , typename FPT >

std::vector<RT> h2d::getPts ( const std::vector< Point2d_< FPT >> & vpt )

Free function, returns a vector of points of other type from a vector of h2d points.

RT: return type
FPT: Floating Point Type

User code needs to provide the requested type as template argument.

See also: h2d::getPt<>()

Todo:: 20230219: sfinae this to accept other containers using trait::IsContainer

 {
     std::vector<RT> vout( vpt.size() );
     auto it = vout.begin();
     for( const auto& pt: vpt )
         *it++ = getPt<RT>(pt);
     return vout;
 }

Here is the caller graph for this function:

◆ getPts() [2/3]

template<typename FPT >

auto h2d::getPts ( const Segment_< FPT > & seg )

Returns the points of Segment as a std::pair (free function)

See also: Segment_::getPts()

 {
     return seg.getPts();
 }

Here is the call graph for this function:

◆ getPts() [3/3]

template<typename FPT >

auto h2d::getPts ( const FRect_< FPT > & rect )

Returns the 2 major points of the rectangle (free function)

See also: FRect_::getPts()

 {
     return rect.getPts();
 }

Here is the call graph for this function:

◆ getPtsInside()

template<typename CONT , typename PRIM >

CONT h2d::getPtsInside	(	const CONT &	input_set,
		const PRIM &	prim
	)

Returns set of points that are inside primitive prim.

Output container will be of same type as input container (vector, list or array

Todo:: 20250123: maybe replace the bunch of static_asserts with something around trait::HasArea ?

Parameters

prim	geometrical primitive (FRect, Circle, ...?)

 {
     static_assert( !std::is_same_v<typename PRIM::SType, typ::T_OPol>,    "Cannot find points inside a Open Polyline" );
     static_assert( !std::is_same_v<typename PRIM::SType, typ::T_Line>,    "Cannot find points inside a Line" );
     static_assert( !std::is_same_v<typename PRIM::SType, typ::T_Point>,   "Cannot find points inside a Point" );
     static_assert( !std::is_same_v<typename PRIM::SType, typ::T_Segment>, "Cannot find points inside a Segment" );
     static_assert( !trait::IsArray<CONT>::value, "Cannot use std::array as container" );
 
     CONT out;
     out.reserve( input_set.size() );
 
     for( auto pt: input_set )
         if( pt.isInside( prim ) )
             out.push_back( pt );
     return out;
 }

Here is the call graph for this function:

◆ getRmPoint() [1/2]

template<typename T >

auto h2d::getRmPoint ( const T & t )

Return Right-most point of container holding points.

 {
     using FPT = typename T::value_type::FType;
 
 #ifndef HOMOG2D_NOCHECKS
     if( t.size() == 0 )
         HOMOG2D_THROW_ERROR_1( "invalid call, container is empty" );
 #endif
 
     auto it = std::min_element(
         std::begin(t),
         std::end(t),
         []                  // lambda
         ( const Point2d_<FPT>& pt1, const Point2d_<FPT>& pt2 )
         {
             if( pt1.getX() > pt2.getX() )
                 return true;
             if( pt1.getX() < pt2.getX() )
                 return false;
             return( pt1.getY() < pt2.getY() );
         }
     );
 
     return std::make_pair(
         *it,
         std::distance( std::begin(t), it )
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getRmPoint() [2/2]

template<typename PLT , typename FPT >

Point2d_<FPT> h2d::getRmPoint ( const base::PolylineBase< PLT, FPT > & poly )

Return Right-most point of Polyline (free function)

 {
     return getRmPoint( poly.getPts() ).first;
 }

Here is the call graph for this function:

◆ getSegment()

template<typename T1 , typename T2 >

Segment_<typename T1::FType> h2d::getSegment	(	const T1 &	c1,
		const T2 &	c2
	)

Free function, returns segment between two circle centers (or ellipse)

 {
     return Segment_<typename T1::FType>( c1.getCenter(), c2.getCenter() );
 }

Here is the caller graph for this function:

◆ getSegs() [1/2]

template<typename PLT , typename FPT >

std::vector<Segment_<FPT> > h2d::getSegs ( const base::PolylineBase< PLT, FPT > & pl )

Returns the segments of the polyline (free function)

See also: PolylineBase::getSegs()

 {
     return pl.getSegs();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSegs() [2/2]

template<typename FPT >

std::array<Segment_<FPT>,4> h2d::getSegs ( const FRect_< FPT > & seg )

Free function, returns segments of the rectangle.

See also: FRect_::getSegs()

 {
     return seg.getSegs();
 }

Here is the call graph for this function:

◆ getString() [1/3]

const char* h2d::getString ( Type t )

inline

Returns stringified version of type()

 {
     const char* s=0;
     switch( t )
     {
         case Type::Line2d:     s="Line2d";    break;
         case Type::Point2d:    s="Point2d";   break;
         case Type::Segment:    s="Segment";   break;
         case Type::OSegment:   s="OSegment";  break;
         case Type::FRect:      s="FRect";     break;
         case Type::Circle:     s="Circle";    break;
         case Type::Ellipse:    s="Ellipse";   break;
         case Type::OPolyline:  s="OPolyline"; break;
         case Type::CPolyline:  s="CPolyline"; break;
         assert(0);
     }
     return s;
 }

Here is the caller graph for this function:

◆ getString() [2/3]

const char* h2d::getString ( Dtype t )

inline

 {
     const char* s=0;
     switch( t )
     {
         case Dtype::Float:      s="Float";      break;
         case Dtype::Double:     s="Double";     break;
         case Dtype::LongDouble: s="LongDouble"; break;
         case Dtype::Other:      s="Other";      break;
 #ifdef HOMOG2D_USE_TTMATH
         case Dtype::Ttmath:     s="ttmath";     break;
 #endif
         assert(0);
     }
     return s;
 }

◆ getString() [3/3]

const char* h2d::getString ( PointSide t )

inline

 {
     const char* s=0;
     switch( t )
     {
         case PointSide::Left:    s="Left";    break;
         case PointSide::Right:   s="Right";   break;
         case PointSide::Neither: s="Neither"; break;
         assert(0);
     }
     return s;
 }

◆ getTanSegs()

template<typename FPT1 , typename FPT2 >

std::pair<Segment_<FPT1>,Segment_<FPT1> > h2d::getTanSegs	(	const Circle_< FPT1 > &	c1,
		const Circle_< FPT2 > &	c2
	)

Free function, returns the pair of segments tangential to the two circles.

Sources:

 {
 #ifndef HOMOG2D_NOCHECKS
     if( c1 == c2 )
         HOMOG2D_THROW_ERROR_1( "c1 and c2 identical" );
 #endif
 
 // if same radius, return the two segments parallel to the one joining the centers
     if( homog2d_abs( c1.radius() - c2.radius() ) < thr::nullDistance() )
     {
         Segment_<HOMOG2D_INUMTYPE> seg_center( c1.center(), c2.center() );
         return seg_center.getParallelSegs( c1.radius() );
     }
 
 // check which one is the smallest
     Circle_<HOMOG2D_INUMTYPE> cA = c1;
     Circle_<HOMOG2D_INUMTYPE> cB = c2;
     if( c1.radius() < c2.radius() )
         std::swap( cA, cB );
 
     auto h = dist( cA.center(), cB.center() );
 
     auto theta = homog2d_asin( ( cA.radius() - cB.radius() ) / h ) ;
     auto hcost = h * homog2d_cos(theta);
 
 // get rotated lines at center of CB
     auto l0 = cA.center() * cB.center();
     auto l1 = l0.getRotatedLine( cB.center(),  theta );
     auto l2 = l0.getRotatedLine( cB.center(), -theta );
 
 // build segments by getting the opposite point
 
     auto ppts1 = l1.getPoints( cB.center(), hcost );
     auto p1 = ppts1.first;
     if( ppts1.second.distTo( cA.center()) < p1.distTo( cA.center()) )
         p1 = ppts1.second;
 
     auto ppts2 = l2.getPoints( cB.center(), hcost );
     auto p2 = ppts2.first;
     if( ppts2.second.distTo( cA.center()) < p2.distTo( cA.center()) )
         p2 = ppts2.second;
 //  std::cout <<"p1=" << p1 << " p2=" << p2 << '\n';
 
     auto seg1 = Segment_<HOMOG2D_INUMTYPE>( p1, cB.center() );
     auto seg2 = Segment_<HOMOG2D_INUMTYPE>( p2, cB.center() );
 
     auto psegs1 = seg1.getParallelSegs( cB.radius() );
     if( psegs1.first.distTo(cA.center()) <  psegs1.second.distTo(cA.center()) )
         std::swap( psegs1.first, psegs1.second );
 
     auto psegs2 = seg2.getParallelSegs( cB.radius() );
     if( psegs2.second.distTo(cA.center()) <  psegs2.first.distTo(cA.center()) )
         std::swap( psegs2.first, psegs2.second );
 
     return std::make_pair(
         psegs1.first,
         psegs2.second
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTmPoint() [1/2]

template<typename T >

auto h2d::getTmPoint ( const T & t )

Return Top-most point of container.

 {
     using FPT = typename T::value_type::FType;
 
 #ifndef HOMOG2D_NOCHECKS
     if( t.size() == 0 )
         HOMOG2D_THROW_ERROR_1( "invalid call, container is empty" );
 #endif
 
     auto it = std::min_element(
         std::begin(t),
         std::end(t),
         []                  // lambda
         ( const Point2d_<FPT>& pt1, const Point2d_<FPT>& pt2 )
         {
             if( pt1.getY() > pt2.getY() )
                 return true;
             if( pt1.getY() < pt2.getY() )
                 return false;
             return( pt1.getX() < pt2.getX() );
         }
     );
     return std::make_pair(
         *it,
         std::distance( std::begin(t), it )
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTmPoint() [2/2]

template<typename PLT , typename FPT >

Point2d_<FPT> h2d::getTmPoint ( const base::PolylineBase< PLT, FPT > & poly )

Return Top-most point of Polyline (free function)

 {
     return getTmPoint( poly.getPts() ).first;
 }

Here is the call graph for this function:

◆ getX()

template<typename FPT >

FPT h2d::getX ( const Point2d_< FPT > & pt )

9821 { return pt.getX(); }

pt

Point2d pt

Definition: homog2d_test.cpp:4034

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getY()

template<typename FPT >

FPT h2d::getY ( const Point2d_< FPT > & pt )

9824 { return pt.getY(); }

pt

Point2d pt

Definition: homog2d_test.cpp:4034

Here is the call graph for this function:

Here is the caller graph for this function:

◆ height()

template<typename FPT >

HOMOG2D_INUMTYPE h2d::height ( const FRect_< FPT > & rect )

Free function.

 {
     return rect.height();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ intersectArea()

template<typename FPT1 , typename FPT2 >

detail::RectArea<FPT1> h2d::intersectArea	(	const FRect_< FPT1 > &	r1,
		const FRect_< FPT2 > &	r2
	)

Free function, see FRect_::intersectArea()

 {
     return r1.intersectArea(r2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IoU()

template<typename FPT1 , typename FPT2 >

HOMOG2D_INUMTYPE h2d::IoU	(	const FRect_< FPT1 > &	r1,
		const FRect_< FPT2 > &	r2
	)

Intersection area over Union area (free function)

 {
     auto ia = intersectArea( r1, r2 );
     if( ia() )
         return ia.get().area() / unionArea( r1, r2 ).area();
     return 0.;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isCircle()

template<typename FPT >

bool h2d::isCircle	(	const Ellipse_< FPT > &	ell,
		HOMOG2D_INUMTYPE	thres = `1.E-10`
	)

Returns true if ellipse is a circle.

See also: Ellipse_::isCircle()

 {
     return ell.isCircle( thres );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isConvex()

template<typename PLT , typename FPT >

bool h2d::isConvex ( const base::PolylineBase< PLT, FPT > & poly )

Returns true if polygon is convex (free function)

See also: PolylineBase::isConvex()

 {
     return poly.isConvex();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isSimple()

template<typename PLT , typename FPT >

bool h2d::isSimple ( const base::PolylineBase< PLT, FPT > & pl )

Returns true if is a polygon (free function)

See also: PolylineBase::isSimple()

 {
     return pl.isSimple();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ moveTo() [1/2]

template<typename T , typename FP >

void h2d::moveTo	(	T &	prim,
		const Point2d_< FP > &	pt
	)

Move primitive to other location (free function)

Calls the member function. Type checking is done there.

 {
     prim.moveTo( pt );
 }

Here is the caller graph for this function:

◆ moveTo() [2/2]

template<typename T , typename FP1 , typename FP2 >

void h2d::moveTo	(	T &	prim,
		FP1	x,
		FP2	y
	)

Move primitive to other location (free function)

Calls the member function. Type checking is done there.

     {
         prim.moveTo( x, y );
     }

◆ nbSegs()

template<typename PLT , typename FPT >

size_t h2d::nbSegs ( const base::PolylineBase< PLT, FPT > & pl )

Returns the number of segments (free function)

See also: PolylineBase::nbSegs()

 {
     return pl.nbSegs();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator*() [1/14]

template<typename T , typename U >

Line2d_< T > h2d::operator*	(	const Homogr_< U > &	h,
		const Line2d_< T > &	in
	)

Free function, apply homography to a line.

 {
     if( h._hmt == nullptr )             // if H^-T  not allocated yet, do it
     {
         h._hmt = std::unique_ptr<detail::Matrix_<U>>( new detail::Matrix_<U>() );
         h._hasChanged = true;
     }
 
     if( h._hasChanged )                  // if homography has changed, recompute inverse and transposed
     {
         auto hi = h;
         auto mat_inv = hi.inverse().transpose();
         *h._hmt = mat_inv;
         h._hasChanged = false;
     }
 
     Line2d_<T> out;
     detail::product( out, *h._hmt, in );
     out.p_normalizePL();
     return out;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator*() [2/14]

template<typename FPT , typename FPT2 >

Line2d_<FPT> h2d::operator*	(	const Point2d_< FPT > &	lhs,
		const Point2d_< FPT2 > &	rhs
	)

Free function template, product of two points, returns a line.

 {
 #ifndef HOMOG2D_NOCHECKS
     if( lhs == rhs )
         HOMOG2D_THROW_ERROR_1( "points are identical, unable to compute product:" << lhs );
 #endif
     Line2d_<FPT> line = detail::crossProduct<typ::IsLine,typ::IsPoint,FPT>(lhs, rhs);
     line.p_normalizePL();
     return line;
 }

◆ operator*() [3/14]

template<typename FPT1 , typename FPT2 >

Line2d_<FPT1> h2d::operator*	(	const Point2d_< FPT1 > &	,
		const Point2d_< FPT2 > &
	)

◆ operator*() [4/14]

template<typename FPT1 , typename FPT2 >

Point2d_<FPT1> h2d::operator*	(	const Line2d_< FPT1 > &	,
		const Line2d_< FPT2 > &
	)

◆ operator*() [5/14]

template<typename FPT1 , typename FPT2 >

CPolyline_< FPT1 > h2d::operator*	(	const Homogr_< FPT2 > &	h,
		const FRect_< FPT1 > &	rin
	)

Apply homography to a flat rectangle produces a closed polyline.

 {
     h2d::CPolyline_<FPT1> out;
     for( const auto& pt: rin.get4Pts() )
         out.p_addPoint( h * pt );
     return out;
 }

Here is the call graph for this function:

◆ operator*() [6/14]

template<typename FPT1 , typename FPT2 , typename PLT2 >

auto h2d::operator*	(	const Homogr_< FPT2 > &	,
		const base::PolylineBase< PLT2, FPT1 > &
	)		-> base::PolylineBase< PLT2, FPT1 >

Todo:: 20230215: check if this has to be moved in the 'base' namespace. Can it be called without using namespace std;. This was the case for the streaming operator...

◆ operator*() [7/14]

template<typename FPT , typename FPT2 >

Point2d_<FPT> h2d::operator*	(	const Line2d_< FPT > &	lhs,
		const Line2d_< FPT2 > &	rhs
	)

Free function template, product of two lines, returns a point.

 {
 #ifndef HOMOG2D_NOCHECKS
     if( lhs.isParallelTo(rhs) )
         HOMOG2D_THROW_ERROR_1( "lines are parallel, unable to compute product:\nlhs="
             << lhs << " rhs=" << rhs
         );
 #endif
 
     return detail::crossProduct<typ::IsPoint,typ::IsLine,FPT>(lhs, rhs);
 }

Here is the call graph for this function:

◆ operator*() [8/14]

template<typename SV1 , typename SV2 , typename FPT1 , typename FPT2 >

Point2d_<FPT1> h2d::operator*	(	const base::SegVec< SV1, FPT1 > &	lhs,
		const base::SegVec< SV2, FPT2 > &	rhs
	)

Free function template, product of two segments/vector, returns a point.

 {
     return lhs.getLine() * rhs.getLine();
 }

Here is the call graph for this function:

◆ operator*() [9/14]

template<typename T , typename U >

Point2d_<T> h2d::operator*	(	const Homogr_< U > &	h,
		const Point2d_< T > &	in
	)

Free function, apply homography to a point.

 {
     Point2d_<T> out;
     detail::product( out, h, in );
     return out;
 }

Here is the call graph for this function:

◆ operator*() [10/14]

template<typename SV , typename FPT1 , typename FPT2 >

Segment_<FPT1> h2d::operator*	(	const Homogr_< FPT1 > &	h,
		const base::SegVec< SV, FPT2 > &	seg
	)

Apply homography to a Segment.

 {
     const auto& pts = seg.getPts();
     Point2d_<FPT1> pt1 = h * pts.first;
     Point2d_<FPT1> pt2 = h * pts.second;
     return base::SegVec<SV,FPT2>( pt1, pt2 );
 }

Here is the call graph for this function:

◆ operator*() [11/14]

template<typename FPT1 , typename FPT2 , typename PLT >

base::PolylineBase<PLT,FPT1> h2d::operator*	(	const Homogr_< FPT2 > &	h,
		const base::PolylineBase< PLT, FPT1 > &	pl
	)

Apply homography to a Polyline.

 {
     base::PolylineBase<PLT,FPT1> out;
     const auto& pts = pl.getPts();
     for( const auto& pt: pts )
         out.p_addPoint( h * pt );
     return out;
 }

Here is the call graph for this function:

◆ operator*() [12/14]

template<typename FPT1 , typename FPT2 >

Ellipse_<FPT1> h2d::operator*	(	const Homogr_< FPT2 > &	h,
		const Ellipse_< FPT1 > &	ell_in
	)

Apply homography to a Ellipse, produces an Ellipse.

\[ Q' = H^{-T} \cdot Q \cdot H^{-1} \]

 {
     auto hm = static_cast<detail::Matrix_<HOMOG2D_INUMTYPE>>(h);
     hm.inverse();
     auto hmt = hm;
     hmt.transpose();
 
     const auto& ell_in2 = static_cast<detail::Matrix_<FPT1>>(ell_in);
     auto prod = hmt * ell_in2 * hm;
 
     Ellipse_<FPT1> out( prod );
     return out;
 }

Here is the call graph for this function:

◆ operator*() [13/14]

template<typename FPT1 , typename FPT2 >

Ellipse_<FPT1> h2d::operator*	(	const Homogr_< FPT2 > &	h,
		const Circle_< FPT1 > &	cir
	)

Apply homography to a Circle, produces an Ellipse.

Converts the circle to an ellipse, then calls the corresponding code

 {
     Ellipse_<FPT1> ell_in( cir );
     return h * ell_in;
 }

◆ operator*() [14/14]

template<typename FPT , typename Cont >

std::enable_if<trait::IsContainer<Cont>::value,Cont>::type h2d::operator*	(	const Hmatrix_< typ::IsHomogr, FPT > &	h,
		const Cont &	vin
	)

Used to proceed multiple products, whatever the container (std::list, std::vector, or std::array). Returned container is of same type as given input.

Parameters

h	Matrix
vin	Input container

 {
     Cont vout = priv::alloc<Cont>( vin.size() );
     auto it = std::begin( vout );
     for( const auto& elem: vin )
         *it++ = h * elem;
     return vout;
 }

◆ operator<<() [1/5]

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>

std::ostream& h2d::operator<<	(	std::ostream &	f,
		const T &	vec
	)

Stream operator for a container of points/lines, free function.

 {
     f << "#="<< vec.size() << '\n';
     for( const auto& elem: vec )
         f << elem << '\n';
     return f;
 }

Here is the caller graph for this function:

◆ operator<<() [2/5]

template<typename LP1 , typename LP2 , typename FPT >

std::ostream& h2d::operator<<	(	std::ostream &	f,
		const std::pair< base::LPBase< LP1, FPT >, base::LPBase< LP2, FPT >> &	pr
	)

Stream operator for a pair of points/lines, free function.

 {
     f << "std::pair (" << getString(pr.first.type()) << "-" << getString(pr.second.type())
         << "):\n -first="  << pr.first
         << "\n -second=" << pr.second
         << ' ';
     return f;
 }

Here is the call graph for this function:

◆ operator<<() [3/5]

template<typename T >

std::ostream& h2d::operator<<	(	std::ostream &	f,
		const FRect_< T > &	r
	)

 {
     f << "pt1: " << r._ptR1 << " pt2: " << r._ptR2;
     return f;
 }

◆ operator<<() [4/5]

template<typename T >

std::ostream& h2d::operator<<	(	std::ostream &	f,
		const Circle_< T > &	r
	)

 {
     f << "center: " << r._center << ", radius=" << r._radius;
     return f;
 }

◆ operator<<() [5/5]

template<typename T >

std::ostream& h2d::operator<<	(	std::ostream &	f,
		const Ellipse_< T > &	ell
	)

 {
     auto par = ell.template p_getParams<HOMOG2D_INUMTYPE>();
     f << par;
     return f;
 }

◆ radius() [1/2]

template<typename FPT >

FPT& h2d::radius ( Circle_< FPT > & cir )

Returns reference on radius of circle (free function), non-const version.

See also: Circle_::radius()

 {
     return cir.radius();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ radius() [2/2]

template<typename FPT >

const FPT& h2d::radius ( const Circle_< FPT > & cir )

Returns reference on radius of circle (free function), const version.

See also: Circle_::radius()

 {
     return cir.radius();
 }

Here is the call graph for this function:

◆ rotate() [1/2]

template<typename T >

void h2d::rotate	(	T &	prim,
		Rotate	rot
	)

Rotates the primitive (only available for Polyline and FRect) around (0,0)

 {
     prim.rotate( rot );
 }

Here is the caller graph for this function:

◆ rotate() [2/2]

template<typename T , typename FPT >

void h2d::rotate	(	T &	prim,
		Rotate	rot,
		const Point2d_< FPT > &	refpt
	)

Rotates the primitive (only available for Polyline and FRect) around refpt.

 {
     prim.rotate( rot, refpt );
 }

Here is the caller graph for this function:

◆ side()

template<typename FPT1 , typename FPT2 >

int h2d::side	(	const Point2d_< FPT1 > &	pt,
		const Line2d_< FPT2 > &	li
	)

Free function, returns -1 or +1 depending on the side of pt, related to li.

 {
     const auto& arr = li.get();
     HOMOG2D_INUMTYPE a = arr[0];
     HOMOG2D_INUMTYPE b = arr[1];
     HOMOG2D_INUMTYPE c = arr[2];
 
     auto dist = a * pt.getX() + b * pt.getY() + c;
     if( homog2d_abs(dist) < thr::nullDistance() )
         return 0;
     return (std::signbit( dist ) ? -1 : +1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ split() [1/2]

template<typename SV , typename FPT >

std::pair<base::SegVec<SV,FPT>,base::SegVec<SV,FPT> > h2d::split ( const base::SegVec< SV, FPT > & seg )

Returns a pair of segments, corresponding to the input segment split by middle point (free function)

See also: Segment_::split()

 {
     return seg.split();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ split() [2/2]

template<typename FPT , typename T >

std::pair<OSegment_<FPT>,OSegment_<FPT> > h2d::split	(	const OSegment_< FPT > &	seg,
		T	dist
	)

Returns a pair of segments, corresponding to the input segment split by point at distance dist (free function)

Note: : can only be used on oriented segments

See also: Segment_::split( T )

 {
     HOMOG2D_CHECK_IS_NUMBER(T);
     return seg.split( dist );
 }

Here is the call graph for this function:

◆ translate() [1/2]

template<typename T , typename FP1 , typename FP2 >

void h2d::translate	(	T &	prim,
		FP1	dx,
		FP2	dy
	)

Translate primitive prim (free function)

Calls the member function. Type checking is done there.

 {
     prim.translate( dx, dy );
 }

Here is the caller graph for this function:

◆ translate() [2/2]

template<typename T , typename FP1 , typename FP2 >

void h2d::translate	(	T &	prim,
		const std::pair< FP1, FP2 > &	ppt
	)

Translate primitive prim with values in a std::pair (free function)

Calls the member function. Type checking is done there.

 {
     prim.translate( ppt.first, ppt.second );
 }

◆ unionArea()

template<typename FPT1 , typename FPT2 >

CPolyline_<FPT1> h2d::unionArea	(	const FRect_< FPT1 > &	r1,
		const FRect_< FPT2 > &	r2
	)

Free function, see FRect_::unionArea()

 {
     return r1.unionArea(r2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ width()

template<typename FPT >

HOMOG2D_INUMTYPE h2d::width ( const FRect_< FPT > & rect )

Free function.

 {
     return rect.width();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ Circle

◆ CircleD

◆ CircleF

◆ CircleL

◆ CommonType

◆ CommonType_

◆ CommonTypeD

◆ CommonTypeF

◆ CommonTypeL

◆ CPolyline

◆ CPolyline_

◆ CPolylineD

◆ CPolylineF

◆ CPolylineL

◆ Ellipse

◆ EllipseD

◆ EllipseF

◆ EllipseL

◆ Epipmat

◆ FRect

◆ FRectD

◆ FRectF

◆ FRectL

◆ Homogr

◆ Homogr_

◆ HomogrD

◆ HomogrF

◆ HomogrL

◆ Line2d

◆ Line2d_

◆ Line2dD

◆ Line2dF

◆ Line2dL

◆ OPolyline

◆ OPolyline_

◆ OPolylineD

◆ OPolylineF

◆ OPolylineL

◆ OSegment

◆ OSegment_

◆ OSegmentD

◆ OSegmentF

◆ OSegmentL

◆ Point2d

◆ Point2d_

◆ Point2dD

◆ Point2dF

◆ Point2dL

◆ PointPair

◆ PointPair2_

◆ PointPair_

◆ PointPairD

◆ PointPairF

◆ PointPairL

◆ Segment

◆ Segment_

◆ SegmentD

◆ SegmentF

◆ SegmentL

Enumeration Type Documentation

◆ CardDir

◆ Dtype

◆ GivenCoord

◆ LineDir

◆ PointSide

◆ Rotate

◆ Type

Function Documentation

◆ angle()

◆ areCollinear()

◆ areParallel()

◆ buildFrom4Points()

◆ center() [1/2]

◆ center() [2/2]