Unit FastGEO

Description

uses

Classes, Interfaces and Objects

Functions and Procedures

Types

Constants

Variables

Description

*********************************************************************

Classes, Interfaces and Objects

Name	Description
record `TPoint2D`
record `TPoint3D`
record `TCircle`
record `TSphere`
record `TVector2D`
record `TVector3D`
record `TPlane2D`
record `TPlane3D`
record `TGeometricObject`

Functions and Procedures

Overview

function Orientation(const x1,y1,x2,y2,Px,Py:Double):Integer; overload;

function Orientation(const x1,y1,z1,x2,y2,z2,x3,y3,z3,Px,Py,Pz:Double):Integer; overload;

function Orientation(const Pnt1,Pnt2:TPoint2D; const Px,Py:Double):Integer; overload;

function Orientation(const Pnt1,Pnt2,Pnt3:TPoint2D):Integer; overload;

function Orientation(const Ln:TLine2D; const Pnt:TPoint2D):Integer; overload;

function Orientation(const Seg:TSegment2D; const Pnt:TPoint2D):Integer; overload;

function Orientation(const Pnt1,Pnt2,Pnt3:TPoint3D; const Px,Py,Pz:Double):Integer; overload;

function Orientation(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Integer; overload;

function Orientation(const Tri:TTriangle3D; const Pnt:TPoint3D):Integer; overload;

function Signed(const x1,y1,x2,y2,Px,Py:Double):Double; overload;

function Signed(const x1,y1,z1,x2,y2,z2,x3,y3,z3,Px,Py,Pz:Double):Double; overload;

function Signed(const Pnt1,Pnt2:TPoint2D; const Px,Py:Double):Double; overload;

function Signed(const Pnt1,Pnt2,Pnt3:TPoint2D):Double; overload;

function Signed(const Ln:TLine2D; const Pnt:TPoint2D):Double; overload;

function Signed(const Seg:TSegment2D; const Pnt:TPoint2D):Double; overload;

function Signed(const Pnt1,Pnt2,Pnt3:TPoint3D; const Px,Py,Pz:Double):Double; overload;

function Signed(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Double; overload;

function Signed(const Tri:TTriangle3D; const Pnt:TPoint3D):Double; overload;

function Collinear(const x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function Collinear(const PntA,PntB,PntC:TPoint2D):Boolean; overload;

function Collinear(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean; overload;

function Collinear(const PntA,PntB,PntC:TPoint3D):Boolean; overload;

function Coplanar(const x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean; overload;

function Coplanar(const PntA,PntB,PntC,PntD:TPoint3D):Boolean; overload;

function IsPointCollinear(const x1,y1,x2,y2,Px,Py:Double):Boolean; overload;

function IsPointCollinear(const PntA,PntB,PntC:TPoint2D):Boolean; overload;

function IsPointCollinear(const PntA,PntB:TPoint2D; const Px,Py:Double):Boolean; overload;

function IsPointCollinear(const Segment:TSegment2D; const PntC:TPoint2D):Boolean; overload;

function IsPointCollinear(const x1,y1,z1,x2,y2,z2,Px,Py,Pz:Double):Boolean; overload;

function IsPointCollinear(const PntA,PntB,PntC:TPoint3D):Boolean; overload;

function IsPointCollinear(const Segment:TSegment3D; const PntC:TPoint3D):Boolean; overload;

function IsPointOnRightSide(const x,y:Double; const Seg:TSegment2D):Boolean; overload;

function IsPointOnRightSide(const Pnt:TPoint2D; const Seg:TSegment2D):Boolean; overload;

function IsPointOnLeftSide(const x,y:Double; const Seg:TSegment2D):Boolean; overload;

function IsPointOnLeftSide(const Pnt:TPoint2D; const Seg:TSegment2D):Boolean; overload;

function Intersect(const x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean; overload;

function Intersect(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Boolean; overload;

function Intersect(const Seg1,Seg2:TSegment2D):Boolean; overload;

function Intersect(const x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean; overload;

function Intersect(const P1,P2,P3,P4:TPoint3D):Boolean; overload;

function Intersect(const Seg1,Seg2:TSegment3D):Boolean; overload;

function Intersect(const Seg:TSegment2D; const Rec:TRectangle):Boolean; overload;

function Intersect(const Seg:TSegment2D; const Tri:TTriangle2D):Boolean; overload;

function Intersect(const Seg:TSegment2D; const Quad:TQuadix2D):Boolean; overload;

function Intersect(Seg:TSegment2D; const Cir:TCircle):Boolean; overload;

function Intersect(const Seg:TSegment3D; const Sphere:TSphere):Boolean; overload;

function Intersect(const Cir1,Cir2:TCircle):Boolean; overload;

procedure IntersectionPoint(const x1,y1,x2,y2,x3,y3,x4,y4:Double; out Nx,Ny:Double); overload;

procedure IntersectionPoint(const P1,P2,P3,P4:TPoint2D; out Nx,Ny:Double); overload;

function IntersectionPoint(const P1,P2,P3,P4:TPoint2D):TPoint2D; overload;

function IntersectionPoint(const Seg1,Seg2:TSegment2D):TPoint2D; overload;

procedure IntersectionPoint(const Cir1,Cir2:TCircle; out Pnt1,Pnt2:TPoint2D); overload;

function VertexAngle(x1,y1,x2,y2,x3,y3:Double):Double; overload;

function VertexAngle(const Pnt1,Pnt2,Pnt3:TPoint2D):Double; overload;

function VertexAngle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Double; overload;

function VertexAngle(const Pnt1,Pnt2,Pnt3:TPoint3D):Double; overload;

function SegmentIntersectAngle(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Double; overload;

function SegmentIntersectAngle(const Seg1,Seg2:TSegment2D):Double; overload;

function SegmentIntersectAngle(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Double; overload;

function SegmentIntersectAngle(const Seg1,Seg2:TSegment3D):Double; overload;

function InPortal(const P:TPoint2D):Boolean; overload;

function InPortal(const P:TPoint3D):Boolean; overload;

function HighestPoint(const Polygon: TPolygon2D):TPoint2D; overload;

function HighestPoint(const Tri:TTriangle2D):TPoint2D; overload;

function HighestPoint(const Tri:TTriangle3D):TPoint3D; overload;

function HighestPoint(const Quadix:TQuadix2D):TPoint2D; overload;

function HighestPoint(const Quadix:TQuadix3D):TPoint3D; overload;

function LowestPoint(const Polygon: TPolygon2D):TPoint2D; overload;

function LowestPoint(const Tri:TTriangle2D):TPoint2D; overload;

function LowestPoint(const Tri:TTriangle3D):TPoint3D; overload;

function LowestPoint(const Quadix:TQuadix2D):TPoint2D; overload;

function LowestPoint(const Quadix:TQuadix3D):TPoint3D; overload;

function Coincident(const Pnt1,Pnt2:TPoint2D):Boolean; overload;

function Coincident(const Pnt1,Pnt2:TPoint3D):Boolean; overload;

function Coincident(const Seg1,Seg2:TSegment2D):Boolean; overload;

function Coincident(const Seg1,Seg2:TSegment3D):Boolean; overload;

function Coincident(const Tri1,Tri2:TTriangle2D):Boolean; overload;

function Coincident(const Tri1,Tri2:TTriangle3D):Boolean; overload;

function Coincident(const Rect1,Rect2:TRectangle):Boolean; overload;

function Coincident(const Quad1,Quad2:TQuadix2D):Boolean; overload;

function Coincident(const Quad1,Quad2:TQuadix3D):Boolean; overload;

function Coincident(const Cir1,Cir2:TCircle):Boolean; overload;

function Coincident(const Sphr1,Sphr2:TSphere):Boolean; overload;

procedure PerpendicularPntToSegment(const x1,y1,x2,y2,Px,Py:Double; out Nx,Ny:Double); overload;

function PerpendicularPntToSegment(const Seg:TSegment2D; const Pnt:TPoint2D):TPoint2D; overload;

procedure PerpendicularPntToRay(const Rx1,Ry1,Rx2,Ry2,Px,Py:Double; out Nx,Ny:Double); overload;

function PerpendicularPntToRay(const Seg:TSegment2D; const Pnt:TPoint2D):TPoint2D; overload;

function PointToSegmentDistance(const Px,Py,x1,y1,x2,y2:Double):Double; overload;

function PointToSegmentDistance(const Pnt:TPoint2D; const Seg:TSegment2D):Double; overload;

function PointToRayDistance(const Px,Py,x1,y1,x2,y2:Double):Double; overload;

function PointToRayDistance(const Pnt:TPoint2D; const Seg:TSegment2D):Double; overload;

function SegmentsParallel(const x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean; overload;

function SegmentsParallel(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Boolean; overload;

function SegmentsParallel(const Seg1,Seg2:TSegment2D):Boolean; overload;

function SegmentsParallel(const x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean; overload;

function SegmentsParallel(const Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Boolean; overload;

function SegmentsParallel(const Seg1,Seg2:TSegment3D):Boolean; overload;

function SegmentsPerpendicular(const x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean; overload;

function SegmentsPerpendicular(const Ln1,Ln2:TLine2D):Boolean; overload;

function SegmentsPerpendicular(const x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean; overload;

function SegmentsPerpendicular(const Ln1,Ln2:TLine3D):Boolean; overload;

procedure SetPlane(const xh,xl,yh,yl:Double); overload;

procedure SetPlane(const Pnt1,Pnt2:TPoint2D); overload;

procedure SetPlane(const Rec:TRectangle); overload;

function RectangleToRectangleIntersect(const x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean; overload;

function RectangleToRectangleIntersect(const Rec1,Rec2:TRectangle):Boolean; overload;

function CircleInCircle(const Cir1,Cir2:TCircle):Boolean;

function IsTangent(Seg:TSegment2D; const Cir:TCircle):Boolean;

function PointOfReflection(const Sx1,Sy1,Sx2,Sy2,P1x,P1y,P2x,P2y:Double; out RPx,RPy:Double):Boolean; overload;

function PointOfReflection(const Seg:TSegment2D; const P1,P2:tPoint2D; out RP:TPoint2D):Boolean; overload;

function Distance(const x1,y1,x2,y2:Double):Double; overload;

function Distance(const Pnt1,Pnt2:TPoint2D):Double; overload;

function Distance(const x1,y1,z1,x2,y2,z2:Double):Double; overload;

function Distance(const Pnt1,Pnt2:TPoint3D):Double; overload;

function Distance(const Segment:TSegment2D):Double; overload;

function Distance(const Segment:TSegment3D):Double; overload;

function Distance(const Cir1,Cir2:TCircle):Double; overload;

function LayDistance(const x1,y1,x2,y2:Double):Double; overload;

function LayDistance(const Pnt1,Pnt2:TPoint2D):Double; overload;

function LayDistance(const x1,y1,z1,x2,y2,z2:Double):Double; overload;

function LayDistance(const Pnt1,Pnt2:TPoint3D):Double; overload;

function LayDistance(const Seg:TSegment2D):Double; overload;

function LayDistance(const Seg:TSegment3D):Double; overload;

function LayDistance(const Cir1,Cir2:TCircle):Double; overload;

function ManhattanDistance(const x1,y1,x2,y2:Double):Double; overload;

function ManhattanDistance(const Pnt1,Pnt2:TPoint2D):Double; overload;

function ManhattanDistance(const x1,y1,z1,x2,y2,z2:Double):Double; overload;

function ManhattanDistance(const Pnt1,Pnt2:TPoint3D):Double; overload;

function ManhattanDistance(const Segment:TSegment2D):Double; overload;

function ManhattanDistance(const Segment:TSegment3D):Double; overload;

function ManhattanDistance(const Cir1,Cir2:TCircle):Double; overload;

function TriangleType(const x1,y1,x2,y2,x3,y3:Double):TTriangleType; overload;

function TriangleType(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TTriangleType; overload;

function TriangleType(const Pnt1,Pnt2,Pnt3:TPoint2D):TTriangleType; overload;

function TriangleType(const Pnt1,Pnt2,Pnt3:TPoint3D):TTriangleType; overload;

function TriangleType(const Tri:TTriangle2D):TTriangleType; overload;

function TriangleType(const Tri:TTriangle3D):TTriangleType; overload;

function IsEquilateralTriangle(const x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function IsEquilateralTriangle(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean; overload;

function IsEquilateralTriangle(const Pnt1,Pnt2,Pnt3:TPoint2D):Boolean; overload;

function IsEquilateralTriangle(const Pnt1,Pnt2,Pnt3:TPoint3D):Boolean; overload;

function IsEquilateralTriangle(const Tri:TTriangle2D):Boolean; overload;

function IsEquilateralTriangle(const Tri:TTriangle3D):Boolean; overload;

function IsIsoscelesTriangle(const x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function IsIsoscelesTriangle(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean; overload;

function IsIsoscelesTriangle(const Pnt1,Pnt2,Pnt3:TPoint2D):Boolean; overload;

function IsIsoscelesTriangle(const Pnt1,Pnt2,Pnt3:TPoint3D):Boolean; overload;

function IsIsoscelesTriangle(const Tri:TTriangle2D):Boolean; overload;

function IsIsoscelesTriangle(const Tri:TTriangle3D):Boolean; overload;

function IsRightTriangle(const x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function IsRightTriangle(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean; overload;

function IsRightTriangle(const Pnt1,Pnt2,Pnt3:TPoint2D):Boolean; overload;

function IsRightTriangle(const Pnt1,Pnt2,Pnt3:TPoint3D):Boolean; overload;

function IsRightTriangle(const Tri:TTriangle2D):Boolean; overload;

function IsRightTriangle(const Tri:TTriangle3D):Boolean; overload;

function IsScaleneTriangle(const x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function IsScaleneTriangle(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean; overload;

function IsScaleneTriangle(const Pnt1,Pnt2,Pnt3:TPoint2D):Boolean; overload;

function IsScaleneTriangle(const Pnt1,Pnt2,Pnt3:TPoint3D):Boolean; overload;

function IsScaleneTriangle(const Tri:TTriangle2D):Boolean; overload;

function IsScaleneTriangle(const Tri:TTriangle3D):Boolean; overload;

function IsObtuseTriangle(const x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function IsObtuseTriangle(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean; overload;

function IsObtuseTriangle(const Pnt1,Pnt2,Pnt3:TPoint2D):Boolean; overload;

function IsObtuseTriangle(const Pnt1,Pnt2,Pnt3:TPoint3D):Boolean; overload;

function IsObtuseTriangle(const Tri:TTriangle2D):Boolean; overload;

function IsObtuseTriangle(const Tri:TTriangle3D):Boolean; overload;

function PointInTriangle(const Px,Py,x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function PointInTriangle(const Pnt:TPoint2D; const Tri:TTriangle2D):Boolean; overload;

function PointInCircle(const Px,Py:Double; const Circle:TCircle):Boolean; overload;

function PointInCircle(const Pnt:TPoint2D; const Circle:TCircle):Boolean; overload;

function PointOnCircle(const Px,Py:Double; const Circle:TCircle):Boolean; overload;

function PointOnCircle(const Pnt:TPoint2D; const Circle:TCircle):Boolean; overload;

function TriangleInCircle(const Tri:TTriangle2D; const Circle:TCircle):Boolean;

function TriangleOutsideCircle(const Tri:TTriangle2D; const Circle:TCircle):Boolean;

function RectangleInCircle(const Rect:TRectangle; const Circle:TCircle):Boolean;

function RectangleOutsideCircle(const Rect:TRectangle; const Circle:TCircle):Boolean;

function QuadixInCircle(const Quad:TQuadix2D; const Circle:TCircle):Boolean;

function QuadixOutsideCircle(const Quad:TQuadix2D; const Circle:TCircle):Boolean;

function PointInRectangle(const Px,Py:Double; const x1,y1,x2,y2:Double):Boolean; overload;

function PointInRectangle(const Pnt:TPoint2D; const x1,y1,x2,y2:Double):Boolean; overload;

function PointInRectangle(const Px,Py:Double; const Rec:TRectangle):Boolean; overload;

function PointInRectangle(const Pnt:TPoint2D; const Rec:TRectangle):Boolean; overload;

function TriangleInRectangle(const Tri:TTriangle2D; const Rec:TRectangle):Boolean;

function TriangleOutsideRectangle(const Tri:TTriangle2D; const Rec:TRectangle):Boolean;

function QuadixInRectangle(const Quad:TQuadix2D; const Rec:TRectangle):Boolean;

function QuadixOutsideRectangle(const Quad:TQuadix2D; const Rec:TRectangle):Boolean;

function PointInQuadix(const Px,Py,x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean; overload;

function PointInQuadix(const Pnt,Pnt1,Pnt2,Pnt3,Pnt4: TPoint2D):Boolean; overload;

function PointInQuadix(const Pnt:TPoint2D; const Quad:TQuadix2D):Boolean; overload;

function TriangleInQuadix(const Tri:TTriangle2D; const Quad:TQuadix2D):Boolean;

function TriangleOutsideQuadix(const Tri:TTriangle2D; const Quad:TQuadix2D):Boolean;

function PointInSphere(const x,y,z:Double; const Sphere:TSphere):Boolean; overload;

function PointInSphere(const Pnt3D:TPoint3D; const Sphere:TSphere):Boolean; overload;

function PointOnSphere(const Pnt3D:TPoint3D; const Sphere:TSphere):Boolean; overload;

function PolyhedronInSphere(const Poly:TPolyhedron; const Sphere:TSphere):TInclusion;

function PointOnPerimeter(const Px,Py,x1,y1,x2,y2:Double):Boolean; overload;

function PointOnPerimeter(const Px,Py,x1,y1,x2,y2,x3,y3:Double):Boolean; overload;

function PointOnPerimeter(const Px,Py,x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean; overload;

function PointOnPerimeter(const Point: TPoint2D; const Rect: TRectangle):Boolean; overload;

function PointOnPerimeter(const Point: TPoint2D; const Tri: TTriangle2D):Boolean; overload;

function PointOnPerimeter(const Point: TPoint2D; const Quad: TQuadix2D):Boolean; overload;

function PointOnPerimeter(const Point: TPoint2D; const Cir: TCircle):Boolean; overload;

function GeometricSpan(const Pnt: array of TPoint2D):Double; overload;

function GeometricSpan(const Pnt: array of TPoint3D):Double; overload;

procedure CreateEquilateralTriangle(x1,y1,x2,y2:Double; out x3,y3:Double); overload;

procedure CreateEquilateralTriangle(const Pnt1,Pnt2:TPoint2D; out Pnt3:TPoint2D); overload;

procedure TorricelliPoint(const x1,y1,x2,y2,x3,y3:Double; out Px,Py:Double); overload;

function TorricelliPoint(const Pnt1,Pnt2,Pnt3:TPoint2D):TPoint2D; overload;

function TorricelliPoint(const Tri:TTriangle2D):TPoint2D; overload;

procedure Incenter(const x1,y1,x2,y2,x3,y3:Double; out Px,Py:Double); overload;

function Incenter(const Pnt1,Pnt2,Pnt3:TPoint2D):TPoint2D; overload;

function Incenter(const Tri:TTriangle2D):TPoint2D; overload;

procedure Circumcenter(const x1,y1,x2,y2,x3,y3:Double; out Px,Py:Double); overload;

function Circumcenter(const Pnt1,Pnt2,Pnt3:TPoint2D):TPoint2D; overload;

function Circumcenter(const Tri:TTriangle2D):TPoint2D; overload;

function Circumcircle(const P1,P2,P3:TPoint2D):TCircle; overload;

function Circumcircle(const Tri:TTriangle2D):TCircle; overload;

function InscribedCircle(const P1,P2,P3:TPoint2D):TCircle; overload;

function InscribedCircle(const Tri:TTriangle2D):TCircle; overload;

function SegmentMidPoint(const P1,P2:TPoint2D):TPoint2D; overload;

function SegmentMidPoint(const Seg:TSegment2D):TPoint2D; overload;

function SegmentMidPoint(const P1,P2:TPoint3D):TPoint3D; overload;

function SegmentMidPoint(const Seg:TSegment3D):TPoint3D; overload;

function OrthoCenter(const x1,y1,x2,y2,x3,y3:Double):TPoint2D; overload;

function OrthoCenter(const Pnt1,Pnt2,CPnt:TPoint2D):TPoint2D; overload;

function OrthoCenter(const Ln1,Ln2,Ln3:TLine2D):TPoint2D; overload;

function OrthoCenter(const Tri:TTriangle2D):TPoint2D; overload;

function PolygonCentroid(const Polygon :TPolygon2D):TPoint2D; overload;

function PolygonCentroid(const Polygon : array of TPoint3D):TPoint3D; overload;

function PolygonSegmentIntersect(const Seg:TSegment2D; const Poly: TPolygon2D):Boolean;

function PolygonInPolygon(const Poly1,Poly2: TPolygon2D):Boolean;

function PolygonIntersect(const Poly1,Poly2: TPolygon2D):Boolean;

function PointInConvexPolygon(const Px,Py:Double; const Poly: TPolygon2D):Boolean; overload;

function PointInConvexPolygon(const Pnt:TPoint2D; const Poly: TPolygon2D):Boolean; overload;

function PointInConcavePolygon(const Px,Py:Double; const Poly: TPolygon2D):Boolean; overload;

function PointInConcavePolygon(const Pnt:TPoint2D; const Poly: TPolygon2D):Boolean; overload;

function PointOnPolygon(const Px,Py:Double; const Poly: TPolygon2D):Boolean; overload;

function PointOnPolygon(const Pnt:TPoint2D; const Poly: TPolygon2D):Boolean; overload;

function PointInPolygon(const Px,Py:Double; const Poly: TPolygon2D):Boolean; overload;

function PointInPolygon(const Pnt:TPoint2D; const Poly: TPolygon2D):Boolean; overload;

function ConvexQuadix(const Quad:TQuadix2D):Boolean;

function ComplexPolygon(const Poly: TPolygon2D):Boolean;

function SimplePolygon(const Poly: TPolygon2D):Boolean;

function ConvexPolygon(const Poly: TPolygon2D):Boolean;

function ConcavePolygon(const Poly: TPolygon2D):Boolean;

function RectangularHull(const Point: array of TPoint2D):TRectangle; overload;

function RectangularHull(const Poly:TPolygon2D):TRectangle; overload;

function CircularHull(const Poly:TPolygon2D):TCircle;

function SphereHull(const Poly: array of TPoint3D):TSphere;

function Clip(Seg:TSegment2D; const Rec:TRectangle):TSegment2D; overload;

function Clip(const Seg:TSegment2D; const Tri:TTriangle2D):TSegment2D; overload;

function Clip(const Seg:TSegment2D; const Quad:TQuadix2D):TSegment2D; overload;

function Area(const Pnt1,Pnt2,Pnt3:TPoint2D):Double; overload;

function Area(const Pnt1,Pnt2,Pnt3:TPoint3D):Double; overload;

function Area(const Tri:TTriangle2D):Double; overload;

function Area(const Tri:TTriangle3D):Double; overload;

function Area(const Quad:TQuadix2D):Double; overload;

function Area(const Quad:TQuadix3D):Double; overload;

function Area(const Rec:TRectangle):Double; overload;

function Area(const Cir:TCircle):Double; overload;

function Area(const Poly:TPolygon2D):Double; overload;

function Perimeter(const Tri:TTriangle2D):Double; overload;

function Perimeter(const Tri:TTriangle3D):Double; overload;

function Perimeter(const Quad:TQuadix2D):Double; overload;

function Perimeter(const Quad:TQuadix3D):Double; overload;

function Perimeter(const Rec:TRectangle):Double; overload;

function Perimeter(const Cir:TCircle):Double; overload;

function Perimeter(const Poly:TPolygon2D):Double; overload;

procedure Rotate(RotAng:Double; const x,y:Double; out Nx,Ny:Double); overload;

procedure Rotate(const RotAng:Double; const x,y,ox,oy:Double; out Nx,Ny:Double); overload;

function Rotate(const RotAng:Double; const Pnt:TPoint2D):TPoint2D; overload;

function Rotate(const RotAng:Double; const Pnt,OPnt:TPoint2D):TPoint2D; overload;

function Rotate(const RotAng:Double; const Seg:TSegment2D):TSegment2D; overload;

function Rotate(const RotAng:Double; const Seg:TSegment2D; const OPnt: TPoint2D):TSegment2D; overload;

function Rotate(const RotAng:Double; const Tri:TTriangle2D):TTriangle2D; overload;

function Rotate(const RotAng:Double; const Tri:TTriangle2D; const OPnt:TPoint2D):TTriangle2D; overload;

function Rotate(const RotAng:Double; const Quad:TQuadix2D):TQuadix2D; overload;

function Rotate(const RotAng:Double; const Quad:TQuadix2D; const OPnt:TPoint2D):TQuadix2D; overload;

function Rotate(const RotAng:Double; Poly:TPolygon2D):TPolygon2D; overload;

function Rotate(const RotAng:Double; Poly:TPolygon2D; const OPnt:TPoint2D):TPolygon2D; overload;

procedure Rotate(const Rx,Ry,Rz:Double; const x,y,z:Double; out Nx,Ny,Nz:Double); overload;

procedure Rotate(const Rx,Ry,Rz:Double; const x,y,z,ox,oy,oz:Double; out Nx,Ny,Nz:Double); overload;

function Rotate(const Rx,Ry,Rz:Double; const Pnt:TPoint3D):TPoint3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Pnt,OPnt:TPoint3D):TPoint3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Seg:TSegment3D):TSegment3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Seg:TSegment3D; const OPnt: TPoint3D):TSegment3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Tri:TTriangle3D):TTriangle3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Tri:TTriangle3D; const OPnt:TPoint3D):TTriangle3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Quad:TQuadix3D):TQuadix3D; overload;

function Rotate(const Rx,Ry,Rz:Double; const Quad:TQuadix3D; const OPnt:TPoint3D):TQuadix3D; overload;

function Rotate(const Rx,Ry,Rz:Double; Poly:TPolygon3D):TPolygon3D; overload;

function Rotate(const Rx,Ry,Rz:Double; Poly:TPolygon3D; const OPnt:TPoint3D):TPolygon3D; overload;

procedure FastRotate(RotAng:Integer; const x,y:Double; out Nx,Ny:Double); overload;

procedure FastRotate(RotAng:Integer; x,y,ox,oy:Double; out Nx,Ny:Double); overload;

function FastRotate(const RotAng:Integer; const Pnt:TPoint2D):TPoint2D; overload;

function FastRotate(const RotAng:Integer; const Pnt,OPnt:TPoint2D):TPoint2D; overload;

function FastRotate(const RotAng:Integer; const Seg:TSegment2D):TSegment2D; overload;

function FastRotate(const RotAng:Integer; const Seg:TSegment2D; const OPnt: TPoint2D):TSegment2D; overload;

function FastRotate(const RotAng:Integer; const Tri:TTriangle2D):TTriangle2D; overload;

function FastRotate(const RotAng:Integer; const Tri:TTriangle2D; const OPnt:TPoint2D):TTriangle2D; overload;

function FastRotate(const RotAng:Integer; const Quad:TQuadix2D):TQuadix2D; overload;

function FastRotate(const RotAng:Integer; const Quad:TQuadix2D; const OPnt:TPoint2D):TQuadix2D; overload;

function FastRotate(const RotAng:Integer; Poly:TPolygon2D):TPolygon2D; overload;

function FastRotate(const RotAng:Integer; Poly:TPolygon2D; const OPnt:TPoint2D):TPolygon2D; overload;

procedure FastRotate(Rx,Ry,Rz:Integer; const x,y,z:Double; out Nx,Ny,Nz:Double); overload;

procedure FastRotate(const Rx,Ry,Rz:Integer; const x,y,z,ox,oy,oz:Double; out Nx,Ny,Nz:Double); overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Pnt:TPoint3D):TPoint3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Pnt,OPnt:TPoint3D):TPoint3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Seg:TSegment3D):TSegment3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Seg:TSegment3D; const OPnt: TPoint3D):TSegment3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Tri:TTriangle3D):TTriangle3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Tri:TTriangle3D; const OPnt:TPoint3D):TTriangle3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Quad:TQuadix3D):TQuadix3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; const Quad:TQuadix3D; const OPnt:TPoint3D):TQuadix3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; Poly:TPolygon3D):TPolygon3D; overload;

function FastRotate(const Rx,Ry,Rz:Integer; Poly:TPolygon3D; const OPnt:TPoint3D):TPolygon3D; overload;

function Translate(const Dx,Dy:Double; const Pnt:TPoint2D):TPoint2D; overload;

function Translate(const Dx,Dy:Double; const Ln:TLine2D):TLine2D; overload;

function Translate(const Dx,Dy:Double; const Seg:TSegment2D):TSegment2D; overload;

function Translate(const Dx,Dy:Double; const Tri:TTriangle2D):TTriangle2D; overload;

function Translate(const Dx,Dy:Double; const Quad:TQuadix2D):TQuadix2D; overload;

function Translate(const Dx,Dy:Double; const Rec:TRectangle):TRectangle; overload;

function Translate(const Dx,Dy:Double; const Cir:TCircle):TCircle; overload;

function Translate(const Dx,Dy:Double; const Poly: TPolygon2D):TPolygon2D; overload;

function Translate(const Pnt:TPoint2D; const Poly: TPolygon2D):TPolygon2D; overload;

function Translate(const Dx,Dy,Dz:Double; const Pnt:TPoint3D):TPoint3D; overload;

function Translate(const Dx,Dy,Dz:Double; const Ln:TLine3D):TLine3D; overload;

function Translate(const Dx,Dy,Dz:Double; const Seg:TSegment3D):TSegment3D; overload;

function Translate(const Dx,Dy,Dz:Double; const Tri:TTriangle3D):TTriangle3D; overload;

function Translate(const Dx,Dy,Dz:Double; const Quad:TQuadix3D):TQuadix3D; overload;

function Translate(const Dx,Dy,Dz:Double; const Sphere:TSphere):TSphere; overload;

function Translate(const Dx,Dy,Dz:Double; const Poly: TPolygon3D):TPolygon3D; overload;

function Translate(const Pnt:TPoint3D; const Poly: TPolygon3D):TPolygon3D; overload;

function Scale(const Dx,Dy:Double; const Pnt:TPoint2D):TPoint2D; overload;

function Scale(const Dx,Dy:Double; const Ln:TLine2D):TLine2D; overload;

function Scale(const Dx,Dy:Double; const Seg:TSegment2D):TSegment2D; overload;

function Scale(const Dx,Dy:Double; const Tri:TTriangle2D):TTriangle2D; overload;

function Scale(const Dx,Dy:Double; const Quad:TQuadix2D):TQuadix2D; overload;

function Scale(const Dx,Dy:Double; const Rec:TRectangle):TRectangle; overload;

function Scale(const Dr:Double; const Cir:TCircle):TCircle; overload;

function Scale(const Dx,Dy:Double; const Poly: TPolygon2D):TPolygon2D; overload;

function Scale(const Dx,Dy,Dz:Double; const Pnt:TPoint3D):TPoint3D; overload;

function Scale(const Dx,Dy,Dz:Double; const Ln:TLine3D):TLine3D; overload;

function Scale(const Dx,Dy,Dz:Double; const Seg:TSegment3D):TSegment3D; overload;

function Scale(const Dx,Dy,Dz:Double; const Tri:TTriangle3D):TTriangle3D; overload;

function Scale(const Dx,Dy,Dz:Double; const Quad:TQuadix3D):TQuadix3D; overload;

function Scale(const Dr:Double; const Sphere:TSphere):TSphere; overload;

function Scale(const Dx,Dy,Dz:Double; const Poly: TPolygon3D):TPolygon3D; overload;

procedure ShearXAxis(const Shear,x,y:Double; out Nx,Ny:Double); overload;

function ShearXAxis(const Shear:Double; const Pnt:TPoint2D):TPoint2D; overload;

function ShearXAxis(const Shear:Double; const Seg:TSegment2D):TSegment2D; overload;

function ShearXAxis(const Shear:Double; const Tri:TTriangle2D):TTriangle2D; overload;

function ShearXAxis(const Shear:Double; const Quad:TQuadix2D):TQuadix2D; overload;

function ShearXAxis(const Shear:Double; Poly:TPolygon2D):TPolygon2D; overload;

procedure ShearYAxis(const Shear,x,y:Double; out Nx,Ny:Double); overload;

function ShearYAxis(const Shear:Double; const Pnt:TPoint2D):TPoint2D; overload;

function ShearYAxis(const Shear:Double; const Seg:TSegment2D):TSegment2D; overload;

function ShearYAxis(const Shear:Double; const Tri:TTriangle2D):TTriangle2D; overload;

function ShearYAxis(const Shear:Double; const Quad:TQuadix2D):TQuadix2D; overload;

function ShearYAxis(const Shear:Double; Poly:TPolygon2D):TPolygon2D; overload;

function EquatePoint(const x,y:Double):TPoint2D; overload;

function EquatePoint(const x,y,z:Double):TPoint3D; overload;

procedure EquatePoint(const x,y:Double; out Point:TPoint2D); overload;

procedure EquatePoint(const x,y,z:Double; out Point:TPoint3D); overload;

function EquateSegment(const x1,y1,x2,y2:Double):TSegment2D; overload;

function EquateSegment(const x1,y1,z1,x2,y2,z2:Double):TSegment3D; overload;

procedure EquateSegment(const x1,y1,x2,y2:Double; out Seg:TSegment2D); overload;

procedure EquateSegment(const x1,y1,z1,x2,y2,z2:Double; out Seg:TSegment3D); overload;

function EquateQuadix(const x1,y1,x2,y2,x3,y3,x4,y4:Double):TQuadix2D; overload;

function EquateQuadix(const x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):TQuadix3D; overload;

function EquateRectangle(const x1,y1,x2,y2:Double):TRectangle;

function EquateTriangle(const x1,y1,x2,y2,x3,y3:Double):TTriangle2D; overload;

function EquateTriangle(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TTriangle3D; overload;

function EquateTriangle(const Pnt1,Pnt2,Pnt3: TPoint2D):TTriangle2D; overload;

function EquateTriangle(const Pnt1,Pnt2,Pnt3: TPoint3D):TTriangle3D; overload;

function EquateCircle(const x,y,r:Double):TCircle;

function EquateSphere(const x,y,z,r:Double):TSphere;

function EquatePlane(const x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TPlane3D; overload;

function EquatePlane(const Pnt1,Pnt2,Pnt3:TPoint3D):TPlane3D; overload;

procedure GenerateRandomPoints(const Bx1,By1,Bx2,By2:Double; out Point: array of TPoint2D);

function Add(const Vec1,Vec2:TVector2D):TVector2D; overload;

function Add(const Vec1,Vec2:TVector3D):TVector3D; overload;

function Add(const Vec:TVector2DArray):TVector2D; overload;

function Add(const Vec:TVector3DArray):TVector3D; overload;

function Sub(const Vec1,Vec2:TVector2D):TVector2D; overload;

function Sub(const Vec1,Vec2:TVector3D):TVector3D; overload;

function Mul(const Vec1,Vec2:TVector2D):TVector3D; overload;

function Mul(const Vec1,Vec2:TVector3D):TVector3D; overload;

function UnitVector(const Vec:TVector2D):TVector2D; overload;

function UnitVector(const Vec:TVector3D):TVector3D; overload;

function Magnitude(const Vec:TVector2D):Double; overload;

function Magnitude(const Vec:TVector3D):Double; overload;

function DotProduct(const Vec1,Vec2:TVector2D):Double; overload;

function DotProduct(const Vec1,Vec2:TVector3D):Double; overload;

function Scale(const Vec:TVector2D; const Factor:Double):TVector2D; overload;

function Scale(const Vec:TVector3D; const Factor:Double):TVector3D; overload;

function Scale(Vec:TVector2DArray; const Factor:Double):TVector2DArray; overload;

function Scale(Vec:TVector3DArray; const Factor:Double):TVector3DArray; overload;

function Negate(const Vec:TVector2D):TVector2D; overload;

function Negate(const Vec:TVector3D):TVector3D; overload;

function Negate(Vec:TVector2DArray):TVector2DArray; overload;

function Negate(Vec:TVector3DArray):TVector3DArray; overload;

function IsEqual(const Val1,Val2,Epsilon:Double):Boolean; overload;

function IsEqual(const Pnt1,Pnt2:TPoint2D; const Epsilon:Double):Boolean; overload;

function IsEqual(const Pnt1,Pnt2:TPoint3D; const Epsilon:Double):Boolean; overload;

function IsEqual(const Val1,Val2:Double):Boolean; overload;

function IsEqual(const Pnt1,Pnt2:TPoint2D):Boolean; overload;

function IsEqual(const Pnt1,Pnt2:TPoint3D):Boolean; overload;

function NotEqual(const Val1,Val2,Epsilon:Double):Boolean; overload;

function NotEqual(const Pnt1,Pnt2:TPoint2D; const Epsilon:Double):Boolean; overload;

function NotEqual(const Pnt1,Pnt2:TPoint3D; const Epsilon:Double):Boolean; overload;

function NotEqual(const Val1,Val2:Double):Boolean; overload;

function NotEqual(const Pnt1,Pnt2:TPoint2D):Boolean; overload;

function NotEqual(const Pnt1,Pnt2:TPoint3D):Boolean; overload;

function LessThanOrEqual(const Val1,Val2,Epsilon:Double):Boolean; overload;

function LessThanOrEqual(const Val1,Val2:Double):Boolean; overload;

function GreaterThanOrEqual(const Val1,Val2,Epsilon:Double):Boolean; overload;

function GreaterThanOrEqual(const Val1,Val2:Double):Boolean; overload;

function CalculateSystemEpsilon:Double;

procedure InitialiseTrigonometryTables;