graphmath.pas

这是图形处理中常用的数学计算方法。比较全面

{点是否在线段上}
function PointOnSeg(const x, y, x1, y1, x2, y2: Double; Err: Double = ERROR7): Boolean; overload;
function PointOnSeg(const x, y: Double; const lineS: TSecLine; Err: Double = ERROR7): Boolean; overload;
function PointOnSeg(const P: TRealPoint; const lineS: TSecLine; Err: Double = ERROR7): Boolean; overload;
function PointOnSeg(const dPnt, dPnt1, dPnt2: TRealPoint; Err: Double = ERROR7): Boolean; overload;
function PointOnSeg(const dPnt: TRealPoint; pEdge: pPolygonEdge; Err: Double = ERROR7): Boolean; overload;

{点是否在弧线上}
function PointOnArc(const x, y, R: Double; const OPnt: TRealPoint; const sAng, eAng: TRadian; Err: Double = ERROR7): Boolean; overload;
function PointOnArc(x, y: Double; pArc: pPolygonArc; Err: Double = ERROR7): Boolean; overload;
function PointOnArc(dPnt: TRealPoint; pArc: pPolygonArc; Err: Double = ERROR7): Boolean; overload;
function PointOnArc(x, y: Double; Arc: TCircleArc; Err: Double = ERROR7): Boolean; overload; // 弧(圆心式)
function PointOnArc(P: TRealPoint; Arc: TCircleArc; Err: Double = ERROR7): Boolean; overload; // 弧(圆心式)

{点是否在边(弧或线段)上}
function PointOnEdge(const Pnt: TRealPoint; const pEdge: pPolygonEdge; Err: Double = ERROR7): Boolean;

{点是否在多边形的边线上}
function PointOnPolygon(const APnt: TRealPoint; const pHeadEdge: pPolygonEdge; Err: Double = ERROR7): Boolean;

{线段是否在直线上}
function SegOnLine(const Pnt1, Pnt2, sPnt, ePnt: TRealPoint; Err: Double = ERROR7): Boolean; overload;
function SegOnLine(const pEdge: pPolygonEdge; const sPnt, ePnt: TRealPoint; Err: Double = ERROR7): Boolean; overload;

{线段是否在线段上}
function SegOnSeg(const Pnt1, Pnt2, sPnt, ePnt: TRealPoint; Err: Double = ERROR7): Boolean; overload;
function SegOnSeg(const pEdge1, pEdge2: pPolygonEdge; Err: Double = ERROR7): Boolean; overload;  

{点是否在圆线附近（可认为圆被选中)}
function PointNearCircle(const x, y, Ox, Oy, r: Double; OffVal: Double): Boolean;
function PointNearArc(const x, y, Ox, Oy, x1, y1, x2, y2: Double; OffVal: Double): Boolean;

{判断是否在图形内}
function InCircle(const x, y, ox, oy, R: Double; Err: Double = ERROR7): Boolean; //点是否在圆内
function InAnnular(const x, y: Double; const Sector: TAnnular; Err: Double = ERROR7): Boolean; //点是否在环内

function InTriangle(p, p1, p2, p3: TRealPoint): Boolean; overload; //点是否在三角形内
function InTriangle(const p, p1, p2, p3: TPoint): Boolean; OverLoad;

function InRectangle(const Pnt: TRealPoint; const Rect: TRectangle; Err: Double = ERROR7): TDotPolyPos; Overload;  //点是否在矩形内
function InRectangle(const x, y: Double; const Rect: TRectangle; Err: Double = ERROR7): TDotPolyPos; Overload;
function InRectangle(const x, y: Double; const Rect: TAnyRectangle; Err: Double = ERROR7): TDotPolyPos; Overload;
function InRectangle(const x, y: Double; const Rect: TRect; Err: Double = ERROR7): TDotPolyPos; overload;

{判断两直线是否垂直}
function IsLineVertical(const Ang1, Ang2: TRadian; Err: Double = ERROR7): Boolean; OverLoad; //直线的斜度(L1,L2)
function IsLineVertical(const L1, L2: TLineRecord): Boolean; OverLoad; // 线段

{判断两直线是否平行}
function IsLineParallel(const Ang1, Ang2: TRadian; Err: Double = ERROR7): Boolean; OverLoad; //由直线的角度判断L1,L2[0..pi) Bug?
function IsLineParallel(const L1, L2: TSecLine): Boolean; OverLoad;
function IsLineParallel(const L1, L2: TSecLine; var R: Double): Boolean; OverLoad; // Result=false L1,L2 不平行

{点相对于直线}
function PointLinePos(const x, y, sx, sy, ex, ey: Double): TPointLinePos; overload;
function PointLinePos(const APoint, sPoint, ePoint: TRealPoint): TPointLinePos; overload;      

{点和多边形的位置关系}
function PointPolyPos(const APoint: TRealPoint; pPoly: pPolygonRecord): TDotPolyPos; overload;
function PointPolyPos(const APoint: TRealPoint; pHeadEdge: pPolygonEdge): TDotPolyPos; overload;

{边和多边形的位置关系}
function EdgePolyPos(const pEdge: pPolygonEdge; const pPolygon: pPolygonRecord; NeedInAdj: Boolean = False): TEdgePolyPos;


{矩形间的相对位置}
function RectPosition(const R1, R2: TRectangle): TRectPosition;

{判断三点是否依次按顺时针排列;若三点在一条直线上或任意两重合，认为顺}
function IsClockWise(const x1, y1, x2, y2, x3, y3: Double): Boolean; overload;
function IsClockWise(const P1, P2, P3: TRealPoint): Boolean; overload;
function IsClockWise(const p1, p2, p3: TPoint): Boolean; overload;

{判断是否为顺时针多边形}
function IsClockWise(const pHeadEdge: pPolygonEdge): Boolean; overload; //true:顺

function IsRectangleValid(R: TRectangle): Boolean;

{矩形与圆有无交点}
function RectCirCross(const Rect: TRectangle; r, Ox, Oy: Double; Err: Double = ERROR7): Boolean;


{多边形是否为任意矩形}
function PolygonIsAngRect(const pPolygon: pPolygonRecord): Boolean;

{多边形与多边形}
function IsPolyAcross(var pa, pb: TList): Boolean;

{判断线性数据有无交叉数据,false没有}
function IsDataCross(const x1, x2, x3, x4: Double): Boolean;
function IsCrossData(var x1, x2, x3, x4: Double): Boolean; OverLoad; // 有交叉数据x1,x2,且x1<x2
function IsCrossData(var d1, d2, dd1, dd2: TRealPoint; XFlag: Boolean): Boolean; OverLoad;

{判断一个多边形是否存在弧形边}
function IsExistArcEdge(const pHeadEdge: pPolygonEdge): Boolean;

function IsNumber(const s: string): Boolean;
function IsInteger(s: string): Boolean;

//=============================计算点、线、弧、圆, 矩形===========================================>

{求点}
function GetIntPoint(const v1, v2: Double): TPoint; overload; //点取整，不是数学点与屏幕点的转换
function GetIntPoint(const RPoint: TRealPoint): TPoint; overload;
function RealPoint(const x, y: Double): TRealPoint;
procedure GetMaxMinPoint(const PointArr: TRealPointArray; out MinValue, MaxValue: TRealPoint; XOrder: Boolean = True);


{计算线段&弧线的中点}
function GetMidPoint(const SLine: TSecLine): TRealPoint; overload;
function GetMidPoint(const P1, P2: TRealPoint): TRealPoint; overload;
function GetMidPoint(const x1, y1, x2, y2: Double): TRealPoint; overload;
function GetMidPoint(const Arc: TCircleArc): TRealPoint; overload; //可去掉?
function GetMidPoint(const Arc: pPolygonArc): TRealPoint; overload;
function GetMidPoint(const oX, oY, R: Double; const SAng, EAng: TRadian): TRealPoint; overload;
function GetMidPoint(const pEdge: pPolygonEdge): TRealPoint; overload; //求多边形边的中点
function GetMidPoint(const Pnt1, Pnt2, OPnt: TRealPoint; const R: Double): TRealPoint; overload; //求弧边上任意两点的中点

{点(x,y)在直线(angle角度,b截距)上的投影}
function PointMapLine(const x, y, b: Double; const Angle: TRadian): TRealPoint; OverLoad;
function PointMapLine(const x, y: Double; const L: TLineRecord): TRealPoint; OverLoad;
function PointMapLine(const x, y, x1, y1, x2, y2: Double): TRealPoint; OverLoad; //点(x,y)在直线上的投影

{求镜像点}
function MirrorPoint(const Pnt: TRealPoint; const SL: TSecLine): TRealPoint; overload;
function MirrorPoint(const Pnt: TRealPoint; const BLine: TBeeLine): TRealPoint; overload; 

{得到点在线上的垂足}
function GetLopPoint(p: TRealPoint; P1, P2: TRealPoint): TRealPoint; overload;
function GetLopPoint(p: TRealPoint; Sline: TSecLine): TRealPoint; overload;
function GetLopPoint(p: TRealPoint; Bline: TBeeLine): TRealPoint; overload;
function GetLopPoint(x, y: Double; pEdge: pPolygonEdge): TRealPoint; overload;
function GetLopPoint(p: TRealPoint; ox, oy, R: Double): TRealPoint; overload;
function GetLopPoint(p: TRealPoint; Arcline: pPolygonArc): TRealPoint; overload;

{根据圆心，半径和角度求弧上某点坐标}
function GetArcPoint(cx, cy, R: Double; Angle: TRadian): TRealPoint; overload;
function GetArcPoint(O: TRealPoint; R: Double; Angle: TRadian): TRealPoint; overload;
function GetArcPoint(arcC: TCircleArc; Angle: TRadian): TRealPoint; overload;
function GetArcPoint(pArcEdge: pPolygonArc; Angle: TRadian): TRealPoint; overload;

{求取多边形内任意一个点，保证该点在多边形内即可。用途：该函数可用于判断两个多边形的位置关系}
function GetInPolyPoint(pHeadEdge: pPolygonEdge): TRealPoint;

{已知基点与角度求距离为AddR的点坐标}
function GetExtendPoint(BasePnt: TRealPoint; Angle: TRadian; AddR: Double): TRealPoint; overload;

{已知基点求活动点在相对角度上延长AddDis后的坐标}
function GetExtendPoint(BasePnt, DestPnt: TRealPoint; AddDis: Double): TRealPoint; overload;

{根据点，半径和角度求圆心}
function GetArcCenter(cx, cy, R: Double; Angle: TRadian): TRealPoint; overload;
function GetArcCenter(O: TRealPoint; R: Double; Angle: TRadian): TRealPoint; overload;
function GetArcCenter(arcC: TCircleArc; Angle: TRadian): TRealPoint; overload;
function GetArcCenter(pArcEdge: pPolygonArc; Angle: TRadian): TRealPoint; overload;

{直线与多边形的所有交点(数组形式结果)}
function LinePolygonJD(ALine: TBeeLine; pPolyHeadEdge: pPolygonEdge): TRealPointArray;

{求圆心,以APnt1APnt2为弦,半径为R(可能有两个)}
function GetCircleCenter(APnt1, APnt2: TRealPoint; R: Double): TCrossPoint;

{求直线的斜率Slope; 已知两点}
function GetLineSlope(sx, sy, ex, ey: Double): Double; overload;
function GetLineSlope(var sp, ep: TRealPoint): Double; overload;
procedure GetLineSlope(var sx, sy, ex, ey: Double; var K: Double); overload;

{求直线的截距B; 已知直线上一点,斜度}
function GetLineB(const x, y, Angle: Double): Double;

{求直线的斜率k,截距b; 没有k返回False}
procedure GetLineModulus(const x1, y1, x2, y2: Double; var K, b: Double; var kf: Boolean); OverLoad;
procedure GetLineModulus(const L: TLineRecord; var K, b: Double; var kf: Boolean); OverLoad;
procedure GetLineModulus(const SLine: TSecLine; var K, b: Double; var kf: Boolean); OverLoad;

{求直线的斜度Angle,截距b;}
procedure GetLineModulus(const SLine: TSecLine; var Angle, b: Double); OverLoad;
procedure GetLineModulus(const L: TLineRecord; var Angle, b: Double); OverLoad;
procedure GetLineModulus(const x1, y1, x2, y2: Double; var Angle, b: Double); OverLoad;

{计算直线上对应y的x坐标, 对应x的y坐标}
function GetLineX(const L: TLineRecord; y: Double): Double;
function GetLineY(const L: TLineRecord; x: Double): Double;

{获得直线. k斜率; b截距; ExistK是否有斜率(若无斜率，b=x)}
function BeeLine(P: TRealPoint; Agl: TRadian): TBeeLine; overload;
function BeeLine(x, y: Double; Agl: TRadian): TBeeLine; overload;
function BeeLine(x1, y1, x2, y2: Double): TBeeLine; overload;
function BeeLine(P1, P2: TRealPoint): TBeeLine; overload;
function BeeLine(lineS: TSecLine): TBeeLine; overload;
function BeeLine(L: TLineRecord): TBeeLine; overload;

{获得线段}
function SecLine(P1, P2: TRealPoint): TSecLine; overload;
function SecLine(x1, y1, x2, y2: Double): TSecLine; overload;
function SecLine(sPnt: TRealPoint; sectLen: Double; VectorAng: TRadian): TSecLine; overload;
function SecLine(pPolyEdge: PPolygonEdge): TSecLine; overload;

{计算直线上某一点处的垂线}

function VertLine(x1, y1, x2, y2, x, y: Double): TBeeLine; overload;
function VertLine(Pnt1, Pnt2, Pnt: TRealPoint): TBeeLine; overload;

{计算中垂线}
function VertBisector(x1, y1, x2, y2: Double): TBeeLine; overload;
function VertBisector(SLine: TSecLine): TBeeLine; overload; //a:

{返回直线L的标准格式(数据存储格式)}
function ReOrderLine(const L: TLineRecord): TLineRecord; //?

{求以弧的起点为起点、终点为终点的线段(弦)}
function GetArcSect(ts, te, xs, ys, xc, yc: Double): TSecLine; overload; // 起始角，终止角，弧上一点，圆心
function GetArcSect(ts, te, r, xc, yc: Double): TSecLine; overload; // 起始角，终止角，半径，圆心

{把线段(x1,y1,x2,y2)移动到点(x,y)所在的直线上,得新的线段}
function MoveLine(const x, y, x1, y1, x2, y2: Double): TRealLine;

{通过三个点计算圆的数据(圆心坐标、半径).注：r(出错：-2是直线，-1点重合)}
function GetCircleData(x1, y1, x2, y2, x3, y3: Double): TCircleArc; //del?
function CircleArc(pArcEdge: pPolygonEdge; IsCircle: Boolean = False): TCircleArc; overload;
function CircleArc(pArcEdge: pPolygonEdge; RadiusDelta: Double): TCircleArc; overload;

{通过三个点计算弧的数据(圆心坐标、半径、起始角、终止角、弦长).注：r(出错：-2是直线，-1点重合)}
function GetArcByPoint(x1, y1, x2, y2, x3, y3: Double): TCircleArc; overload;
function GetArcByPoint(ArcP: TPointArc): TCircleArc; overload;

{通过两点和半径计算弧的数据(圆心坐标、半径、起始角、终止角、弦长)
 Clock: (T:顺; F:逆)   Big: (T:大; F:小). 注：r(出错：0是点，-1点重合, -3半径小于弦长的一半)}
function GetArcByPointRadius(x1, y1, x2, y2, r: Double; Clock, Big: Boolean): TCircleArc; overload;
function GetArcByPointRadius(sPoint, ePoint: TRealPoint; r: Double; Clock, Big: Boolean): TCircleArc; overload;
function GetArcByPointRadius(sPoint, ePoint: TRealPoint; R: Double; out pArc: pPolygonArc;
  ClockWise: Boolean = True; BigArc: Boolean = False): Boolean; overload;

{计算弧形辅轴}
function GetArcAxes(x1, y1, x2, y2, x3, y3, R: Double): pPolygonArc;

procedure InitRectangle(var Rect: TRectangle);
function MyRect(const x1, y1, x2, y2: Integer): TRect;
function UnionRectangle(R1, R2: TRectangle): TRectangle;

{得到矩形}
function GetRectangle(const x1, y1, x2, y2: Double): TRectangle; OverLoad;
function GetRectangle(sPnt, ePnt: TRealPoint): TRectangle; OverLoad;
function GetRect(const x1, y1, x2, y2: Integer): TRect;

{线段外围矩形}
function GetBoxRect(const x1, y1, x2, y2, LineWidth: Double): TRectangle; OverLoad;
function GetBoxRect(const P1, P2: TRealPoint; LineWidth: Double): TAnyRectangle; OverLoad;

{弧外围矩形}
function GetBoxRect(const sAngle, eAngle: TRadian; Ox, Oy, r, ArcWidth: Double): TRectangle; OverLoad;
function GetBoxRect(const x1, y1, x2, y2, Ox, Oy, r, ArcWidth: Double): TRectangle; OverLoad;
function GetBoxRect(aArc: pPolygonArc; DeltaR: Double): TRectangle; overload;

{圆外围矩形}
function GetCircleBoxRect(const Ox, Oy, R, ArcWidth: Double): TRectangle; OverLoad;

{多边形外围矩形}
function GetBoxRect(APolygon: pPolygonRecord): TRectangle; overload;
function GetBoxRect(ACanvas: TCanvas; AText: string): TRectangle; OverLoad;

function GetBoxRect(p: pObjRec): TRectangle; OverLoad;

function GetSelectRect(const Rect, Rect1: TRect): TRect;
{返回通过点(x,y),直线(x1,y1,x2,y2)的矩形 (点(x,y)可能只在矩形边的延长线上)}
function LinePointRect(const x, y, x1, y1, x2, y2: Integer): TIntRect;

//====================================计算交点=====================================================>

{计算两条直线的交点}
function LineLineJD(const line1, line2: TBeeLine; Err: Double = ERROR7): TCrossPoint; overload;
function LineLineJD(const line1, line2: TSecLine; Err: Double = ERROR7): TCrossPoint; overload;
function LineLineJD(const lineB: TBeeLine; lineS: TSecLine; Err: Double = ERROR7): TCrossPoint; overload;
function LineLineJD(const L1, L2: TLineRecord; Err: Double = ERROR7): TCrossPoint; OverLoad;
function LineLineJD(const x1, y1, x2, y2: Double; L: TLineRecord; Err: Double = ERROR7): TCrossPoint; OverLoad;

{计算线段与直线的交点}
function SectLineJD(lineS: TSecLine; LineB: TBeeLine; Err: Double = ERROR7): TCrossPoint; overload;
function SectLineJD(pEdge: pPolygonEdge; dPnt1, dPnt2: TRealPoint; Err: Double = ERROR7): TCrossPoint; OverLoad;
function SectLineJD(pEdge: pPolygonEdge; LineB: TBeeLine; Err: Double = ERROR7): TCrossPoint; overload;

{线段与线段的交点}
function SectSectJD(line1, line2: TSecLine; Err: Double = ERROR7): TCrossPoint; overload;
function SectSectJD(const x1, y1, x2, y2, xx1, yy1, xx2, yy2: Double; Err: Double = ERROR7): TCrossPoint; OverLoad;
function SectSectJD(const L1, L2: TLineRecord; Err: Double = ERROR7): TCrossPoint; OverLoad;
function SectSectJD(sPnt1, ePnt1, sPnt2, ePnt2: TRealPoint; Err: Double = ERROR7): TCrossPoint; overload;
function SectSectJD(pEdge1, pEdge2: pPolygonEdge; Err: Double = ERROR7): TCrossPoint; OverLoad;

{求直线与圆的交点}
function LineCircleJD(lineB: TBeeLine; OPnt: TRealPoint; R: Double; Err: Double = ERROR7): TCrossPoint; overload;
function LineCircleJD(lineB: TBeeLine; circle: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function LineCircleJD(lineB: TBeeLine; pEdgeArc: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;

{求直线与弧的交点}
function LineArcJD(lineB: TBeeLine; arcC: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function LineArcJD(lineS: TSecLine; arcC: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function LineArcJD(lineS: TSecLine; arcP: TPointArc; Err: Double = ERROR7): TCrossPoint; overload;
function LineArcJD(lineB: TBeeLine; pEdgeArc: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;
function LineArcJD(dPnt1, dPnt2: TRealPoint; pEdgeArc: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;

{求线段与圆的交点}
function SectCircleJD(lineS: TSecLine; OPnt: TRealPoint; R: Double; Err: Double = ERROR7): TCrossPoint; overload;
function SectCircleJD(lineS: TSecLine; circle: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function SectCircleJD(lineS: TSecLine; pEdgeArc: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;

{求线段与弧的交点 }
function SectArcJD(lineS: TSecLine; arcC: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function SectArcJD(lineS: TSecLine; arcP: TPointArc; Err: Double = ERROR7): TCrossPoint; overload;
function SectArcJD(lineS: TSecLine; ArcEdge: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;
function SectArcJD(SecEdge: pPolygonEdge; ArcEdge: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;

{求圆与圆的交点}
function CircleCircleJD(OPnt1, OPnt2: TRealPoint; R1, R2: Double; Err: Double = ERROR7): TCrossPoint;

{求弧与圆的交点}
function ArcCircleJD(ArcC: TCircleArc; OPnt: TRealPoint; R: Double; Err: Double = ERROR7): TCrossPoint; Overload;
function ArcCircleJD(ArcC: TPointArc; OPnt: TRealPoint; R: Double; Err: Double = ERROR7): TCrossPoint; Overload;
function ArcCircleJD(pEdgeArc: pPolygonArc; OPnt: TRealPoint; R: Double; Err: Double = ERROR7): TCrossPoint; Overload;

{求弧与弧的交点}
function ArcArcJD(Arc1, Arc2: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function ArcArcJD(Arc1: TPointArc; Arc2: TCircleArc; Err: Double = ERROR7): TCrossPoint; overload;
function ArcArcJD(pEdgeArc1, pEdgeArc2: pPolygonArc; Err: Double = ERROR7): TCrossPoint; overload;

{直线与边的交点}
function LineEdgeJD(ALine: TBeeLine; pEdge: pPolygonEdge; Err: Double = ERROR7): TCrossPoint;

{边与边的交点}
function EdgeEdgeJD(pEdge1, pEdge2: pPolygonEdge; Err: Double = ERROR7): TCrossPoint;

{求垂直直线和圆的交点，不进行判断}
function VLineCircleJD(const x, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;

{求垂直线段与圆的交点，不进行判断x1<x2}
function VLineCircleJD(const x, y1, y2, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;

{求垂直线段与弧的交点 x1<x2}
function VLineArcJD(const x, y1, y2, Ax1, Ay1, Ax2, Ay2, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;
function VLineArcJD(const x, y1, y2, SL, EL, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;

{求水平直线和圆的交点，不进行判断}
function HLineCircleJD(const y, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;

{求水平线段与圆的交点, 不进行判断y1<y2}
function HLineCircleJD(const y, x1, x2, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;

{求水平线段与弧的交点 y1<y2}
function HLineArcJD(const y, x1, x2, Ax1, Ay1, Ax2, Ay2, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload; //
function HLineArcJD(const y, x1, x2, SL, EL, r, Ox, Oy: Double; Err: Double = ERROR7): TCrossPoint; overload;

{求矩形与直线的交点}
function RectLineJD(const Rect: TRectangle; ABeeLine: TBeeLine; Err: Double = ERROR7): TCrossPoint;

//================================计算距离或长度==================================================>

{得到两点之间的距离}
function DisPointPoint(x1, y1, x2, y2: Double): Double; overload;
function DisPointPoint(p1, p2: TRealPoint): Double; overload;

{线段长度}
function GetSecLineLength(const L: TSecLine): Double;
function GetArcLineLength(const L: TCircleArc): Double; overload;
function GetArcLineLength(const L: PPolygonArc): Double; overload;

{点到直线的距离}
function DisPointLine(const x, y, x1, y1, x2, y2: Double): Double; OverLoad; // 直线(两点式)
function DisPointLine(const x, y: Double; lineB: TBeeLine): Double; overload; // 直线(斜截式)
function DisPointLine(const dPnt: TRealPoint; aLine: TBeeLine): Double; overload;
function DisPointLine(const dPnt, dPnt1, dPnt2: TRealPoint): Double; overload; //
function DisPointLine(const x, y, B: Double; Angle: TRadian): Double; OverLoad; // 点(x,y)-- 直线(截距B,角度Angle)
function DisPointLine(const x, y: Double; lineS: TSecLine): Double; overload; //  直线(两点式SLine)
function DisPointLine(const dPnt: TRealPoint; lineS: TSecLine): Double; overload; //dPnt--线段ASect所在直线
function DisPointLine(const x, y: Double; Line: TLineRecord): Double; OverLoad;