WebCAD-Lib-TS API 文档 - v1.0.0
    Preparing search index...

    Class GeometryCalculator

    几何计算工具类

    提供各种几何计算的静态方法,包括点线关系判断、角度调整等。 这是一个专门的几何算法工具类。

    Index

    Constructors

    Properties

    Methods

    Constructors

    Properties

    ArcToArc: (firstArc: ArcEnt, secondArc: ArcEnt) => Point2D[]
    ArcExtToArc: (extendedArc: ArcEnt, targetArc: ArcEnt) => Point2D[]
    ArcExtToArcExt: (
        firstExtendedArc: ArcEnt,
        secondExtendedArc: ArcEnt,
    ) => Point2D[]
    ArcExtToCircle: (extendedArc: ArcEnt, circle: CircleEnt) => Point2D[]
    ArcExtToLine: (extendedArc: ArcEnt, line: LineEnt) => Point2D[]
    ArcExtToLineExt: (extendedArc: ArcEnt, extendedLine: LineEnt) => Point2D[]
    ArcExtToPline: (extendedArc: ArcEnt, polyline: PolylineEnt) => Point2D[]
    ArcExtToPlineExt: (
        extendedArc: ArcEnt,
        extendedPolyline: PolylineEnt,
    ) => Point2D[]
    ArcExtToRay: (extendedArc: ArcEnt, ray: RayEnt) => Point2D[]
    ArcExtToRayExt: (extendedArc: ArcEnt, extendedRay: RayEnt) => Point2D[]
    ArcExtToXline: (extendedArc: ArcEnt, xline: XLineEnt) => Point2D[]
    ArcToArcExt: (arc: ArcEnt, extendedArc: ArcEnt) => Point2D[]
    ArcToCircle: (arc: ArcEnt, circle: CircleEnt) => Point2D[]
    ArcToLine: (arc: ArcEnt, line: LineEnt) => Point2D[]
    ArcToLineExt: (arc: ArcEnt, extendedLine: LineEnt) => Point2D[]
    ArcToPline: (arc: ArcEnt, polyline: PolylineEnt) => Point2D[]
    ArcToPlineExt: (arc: ArcEnt, extendedPolyline: PolylineEnt) => Point2D[]
    ArcToRay: (arc: ArcEnt, ray: RayEnt) => Point2D[]
    ArcToRayExt: (arc: ArcEnt, extendedRay: RayEnt) => Point2D[]
    ArcToXline: (arc: ArcEnt, xline: XLineEnt) => Point2D[]
    CircleToArc: (circle: CircleEnt, arc: ArcEnt) => Point2D[]
    CircleToArcExt: (circle: CircleEnt, extendedArc: ArcEnt) => Point2D[]
    CircleToCircle: (firstCircle: CircleEnt, secondCircle: CircleEnt) => Point2D[]
    CircleToLine: (circle: CircleEnt, line: LineEnt) => Point2D[]
    CircleToLineExt: (circle: CircleEnt, extendedLine: LineEnt) => Point2D[]
    CircleToPline: (circle: CircleEnt, polyline: PolylineEnt) => Point2D[]
    CircleToPlineExt: (
        circle: CircleEnt,
        extendedPolyline: PolylineEnt,
    ) => Point2D[]
    CircleToRay: (circle: CircleEnt, ray: RayEnt) => Point2D[]
    CircleToRayExt: (circle: CircleEnt, extendedRay: RayEnt) => Point2D[]
    CircleToXline: (circle: CircleEnt, xline: XLineEnt) => Point2D[]
    HatchToLine: (hatch: HatchEnt, line: LineEnt) => Point2D[]
    HatchToLineExt: (hatch: HatchEnt, extendedLine: LineEnt) => Point2D[]
    HatchToRay: (hatch: HatchEnt, ray: RayEnt) => Point2D[]
    HatchToRayExt: (hatch: HatchEnt, extendedRay: RayEnt) => Point2D[]
    LineExtToArc: (extendedLine: LineEnt, arc: ArcEnt) => Point2D[]
    LineExtToArcExt: (extendedLine: LineEnt, extendedArc: ArcEnt) => Point2D[]
    LineExtToCircle: (extendedLine: LineEnt, circle: CircleEnt) => Point2D[]
    LineExtToHatch: (extendedLine: LineEnt, hatch: HatchEnt) => Point2D[]
    LineExtToLine: (extendedLine: LineEnt, line: LineEnt) => Point2D[]
    LineExtToLineExt: (
        firstExtendedLine: LineEnt,
        secondExtendedLine: LineEnt,
    ) => Point2D[]
    LineExtToPline: (extendedLine: LineEnt, polyline: PolylineEnt) => Point2D[]
    LineExtToPlineExt: (
        extendedLine: LineEnt,
        extendedPolyline: PolylineEnt,
    ) => Point2D[]
    LineExtToRay: (extendedLine: LineEnt, ray: RayEnt) => Point2D[]
    LineExtToRayExt: (extendedLine: LineEnt, extendedRay: RayEnt) => Point2D[]
    LineExtToXline: (extendedLine: LineEnt, xline: XLineEnt) => Point2D[]
    LineToArc: (line: LineEnt, arc: ArcEnt) => Point2D[]
    LineToArcExt: (line: LineEnt, extendedArc: ArcEnt) => Point2D[]
    LineToCircle: (line: LineEnt, circle: CircleEnt) => Point2D[]
    LineToHatch: (line: LineEnt, hatch: HatchEnt) => Point2D[]
    LineToLine: (firstLine: LineEnt, secondLine: LineEnt) => Point2D[]
    LineToLineExt: (line: LineEnt, extendedLine: LineEnt) => Point2D[]
    LineToPline: (line: LineEnt, polyline: PolylineEnt) => Point2D[]
    LineToPlineExt: (line: LineEnt, extendedPolyline: PolylineEnt) => Point2D[]
    LineToRay: (line: LineEnt, ray: RayEnt) => Point2D[]
    LineToRayExt: (line: LineEnt, extendedRay: RayEnt) => Point2D[]
    LineToXline: (line: LineEnt, xline: XLineEnt) => Point2D[]
    PlineExtToArc: (extendedPolyline: PolylineEnt, arc: ArcEnt) => Point2D[]
    PlineExtToArcExt: (
        extendedPolyline: PolylineEnt,
        extendedArc: ArcEnt,
    ) => Point2D[]
    PlineExtToCircle: (
        extendedPolyline: PolylineEnt,
        circle: CircleEnt,
    ) => Point2D[]
    PlineExtToLine: (extendedPolyline: PolylineEnt, line: LineEnt) => Point2D[]
    PlineExtToLineExt: (
        extendedPolyline: PolylineEnt,
        extendedLine: LineEnt,
    ) => Point2D[]
    PlineExtToPline: (
        firstExtendedPolyline: PolylineEnt,
        secondExtendedPolyline: PolylineEnt,
    ) => Point2D[]
    PlineExtToPlineExt: (
        extendedPolyline: PolylineEnt,
        extendedPolyline2: PolylineEnt,
    ) => Point2D[]
    PlineExtToRay: (extendedPolyline: PolylineEnt, ray: RayEnt) => Point2D[]
    PlineExtToRayExt: (
        extendedPolyline: PolylineEnt,
        extendedRay: RayEnt,
    ) => Point2D[]
    PlineToArc: (polyline: PolylineEnt, arc: ArcEnt) => Point2D[]
    PlineToArcExt: (polyline: PolylineEnt, extendedArc: ArcEnt) => Point2D[]
    PlineToCircle: (polyline: PolylineEnt, circle: CircleEnt) => Point2D[]
    PlineToLine: (polyline: PolylineEnt, line: LineEnt) => Point2D[]
    PlineToLineExt: (polyline: PolylineEnt, extendedLine: LineEnt) => Point2D[]
    PlineToPline: (
        firstPolyline: PolylineEnt,
        secondPolyline: PolylineEnt,
    ) => Point2D[]
    PlineToPlineExt: (
        polyline: PolylineEnt,
        extendedPolyline: PolylineEnt,
    ) => Point2D[]
    PlineToRay: (polyline: PolylineEnt, ray: RayEnt) => Point2D[]
    PlineToRayExt: (polyline: PolylineEnt, extendedRay: RayEnt) => Point2D[]
    PlineToXline: (polyline: PolylineEnt, xline: XLineEnt) => Point2D[]
    RayExtToArc: (extendedRay: RayEnt, arc: ArcEnt) => Point2D[]
    RayExtToArcExt: (extendedRay: RayEnt, extendedArc: ArcEnt) => Point2D[]
    RayExtToCircle: (extendedRay: RayEnt, circle: CircleEnt) => Point2D[]
    RayExtToHatch: (extendedRay: RayEnt, hatch: HatchEnt) => Point2D[]
    RayExtToLine: (extendedRay: RayEnt, line: LineEnt) => Point2D[]
    RayExtToLineExt: (extendedRay: RayEnt, extendedLine: LineEnt) => Point2D[]
    RayExtToPline: (extendedRay: RayEnt, polyline: PolylineEnt) => Point2D[]
    RayExtToPlineExt: (
        extendedRay: RayEnt,
        extendedPolyline: PolylineEnt,
    ) => Point2D[]
    RayExtToRay: (extendedRay: RayEnt, ray: RayEnt) => Point2D[]
    RayExtToRayExt: (
        firstExtendedRay: RayEnt,
        secondExtendedRay: RayEnt,
    ) => Point2D[]
    RayExtToXline: (extendedRay: RayEnt, xline: XLineEnt) => Point2D[]
    RayToArc: (ray: RayEnt, arc: ArcEnt) => Point2D[]
    RayToArcExt: (ray: RayEnt, extendedArc: ArcEnt) => Point2D[]
    RayToCircle: (ray: RayEnt, circle: CircleEnt) => Point2D[]
    RayToHatch: (ray: RayEnt, hatch: HatchEnt) => Point2D[]
    RayToLine: (ray: RayEnt, line: LineEnt) => Point2D[]
    RayToLineExt: (ray: RayEnt, extendedLine: LineEnt) => Point2D[]
    RayToPline: (ray: RayEnt, polyline: PolylineEnt) => Point2D[]
    RayToPlineExt: (ray: RayEnt, extendedPolyline: PolylineEnt) => Point2D[]
    RayToRay: (firstRay: RayEnt, secondRay: RayEnt) => Point2D[]
    RayToRayExt: (ray: RayEnt, extendedRay: RayEnt) => Point2D[]
    RayToXline: (ray: RayEnt, xline: XLineEnt) => Point2D[]
    XlineToArc: (xline: XLineEnt, arc: ArcEnt) => Point2D[]
    XlineToArcExt: (xline: XLineEnt, extendedArc: ArcEnt) => Point2D[]
    XlineToCircle: (xline: XLineEnt, circle: CircleEnt) => Point2D[]
    XlineToLine: (xline: XLineEnt, line: LineEnt) => Point2D[]
    XlineToLineExt: (xline: XLineEnt, extendedLine: LineEnt) => Point2D[]
    XlineToPline: (xline: XLineEnt, polyline: PolylineEnt) => Point2D[]
    XlineToRay: (xline: XLineEnt, ray: RayEnt) => Point2D[]
    XlineToRayExt: (xline: XLineEnt, extendedRay: RayEnt) => Point2D[]
    XlineToXline: (firstXline: XLineEnt, secondXline: XLineEnt) => Point2D[]

    Methods

    • 判断点相对于直线的位置

      使用叉积计算点相对于直线的位置关系。 这是一个基础的几何算法,用于判断点在直线的哪一侧。

      Parameters

      Returns number

      -1=点在直线左侧,0=点在直线上,1=点在直线右侧

    • 调整角度到正值范围

      将角度调整到[0, 2π)范围内。

      Parameters

      • angle: number

        输入角度(弧度)

      Returns number

      调整后的角度

    • 根据位置判断获取有效交点

      这是一个复杂的逻辑判断函数,根据两个端点相对于交点的位置关系, 确定哪些交点是有效的(在线段范围内)。

      Parameters

      • firstEndpointPosition: string

        第一个端点的位置关系

      • secondEndpointPosition: string

        第二个端点的位置关系

      • firstIntersection: Point2D

        第一个交点

      • secondIntersection: Point2D

        第二个交点

      Returns Point2D[]

      有效交点数组

    • 数值相等判断

      在指定容差范围内判断两个数值是否相等。

      Parameters

      • firstValue: number

        第一个数值

      • secondValue: number

        第二个数值

      • tolerance: number

        容差值

      Returns boolean

      如果在容差范围内相等返回true

    • 判断点相对于两个边界点的位置

      判断一个点相对于两个边界点的位置关系。

      Parameters

      • pointCoordinate: number

        要判断的点的坐标

      • leftBoundary: number

        左边界点坐标

      • rightBoundary: number

        右边界点坐标

      Returns string

      位置关系字符串