@ccpc/math 0.1.0 → 0.1.7

package/types/algorithm/distance/base_calc_distance/curves_distance_util.d.ts

@@ -0,0 +1,20 @@
+import { Vec3 } from '../../../base/vec3';
+import { Curve3 } from '../../../geometry/curve3d';
+import { Curve3dSegment, Curve3dSegmentPair } from '../../calculate_util/geometry_subdevide_infos';
+import { Curve2 } from '../../../geometry/curve2';
+import { Vec2 } from '../../../base/vec2';
+/**
+ * 曲线集到曲线集的最近距离
+ */
+export declare class CurvedDistanceUtil {
+    static minAtEnds2d(curve1: Curve2, curve2: Curve2, point1?: Vec2, point2?: Vec2): number;
+    static minAtEnds3d(curve1: Curve3, curve2: Curve3, point1?: Vec3, point2?: Vec3): number;
+    /**
+     * 曲线集到曲线集的最近距离
+     * oldMinDis 用于包围盒加速计算，传入一个已知的距离，如果没有已知距离，就不用传入该参数，用默认值就行。譬如说，前面
+     *           已经计算了曲线顶点之间的最近距离为2.015，就可以跳过很多包围盒最小距离都大于此距离的曲线，提高效率。
+     */
+    static execute(curve3dSegments1: Curve3dSegment[], curve3dSegments2: Curve3dSegment[], curve3dSegPairs: Curve3dSegmentPair[], minDisPt1: Vec3, minDisPt2: Vec3, oldMinDis?: number): number;
+    private static _calCurvSegmentPairsDist;
+    private static _calcCurvCurvIteration;
+}

package/types/algorithm/distance/base_calc_distance/define_of_calculate_distance.d.ts

@@ -0,0 +1,12 @@
+import { Vec2 } from '../../../base/vec2';
+import { Vec3 } from '../../../base/vec3';
+export interface IPoint2dPair {
+    point1: Vec2;
+    point2: Vec2;
+    sqrDistance: number;
+}
+export interface IPoint3dPair {
+    point1: Vec3;
+    point2: Vec3;
+    sqrDistance: number;
+}

package/types/algorithm/distance/curve2ds_distance/arc2s_distance.d.ts

@@ -0,0 +1,17 @@
+import { Arc2 } from '../../../geometry/arc2d';
+import { Vec2 } from '../../../base/vec2';
+/**
+ * 二维圆弧到二维圆弧的最近距离
+ */
+export declare class Arc2sDistance {
+    /**
+     * 二维圆弧到二维圆弧的距离
+     * @param arc1  二维圆弧
+     * @param arc2  二维圆弧
+     * @param footPoint1 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     * @param footPoint2 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     */
+    static execute(arc1: Arc2, arc2: Arc2, minDisPoint1?: Vec2, minDisPoint2?: Vec2): number;
+    private static _IsIntsectTwoArc2d;
+    private static _IsIntPtInRange;
+}

package/types/algorithm/distance/curve2ds_distance/line2d_to_arc2d_distance.d.ts

@@ -0,0 +1,17 @@
+import { Ln2 } from '../../../geometry/ln2';
+import { Arc2 } from '../../../geometry/arc2d';
+import { Vec2 } from '../../../base/vec2';
+/**
+ * 二维线段到二维圆弧的最近距离
+ */
+export declare class Line2dToArc2dDistance {
+    /**
+     * 二维线段到二维圆弧的距离
+     * @param line  二维线段
+     * @param arc  二维圆弧
+     * @param point1 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     * @param point2 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     */
+    static execute(line: Ln2, arc: Arc2, point1?: Vec2, point2?: Vec2): number;
+    private static _IsIntPtInRange;
+}

package/types/algorithm/distance/curve2ds_distance/line2s_distance.d.ts

@@ -0,0 +1,15 @@
+import { Ln2 } from '../../../geometry/ln2';
+import { Vec2 } from '../../../base/vec2';
+/**
+ * 二维线段到二维线段的最近距离
+ */
+export declare class Line2sDistance {
+    /**
+     * 二维直线段到二维直线段的距离
+     * @param line1  二维线段
+     * @param line2  二维线段
+     * @param footPoint1 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     * @param footPoint2 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     */
+    static execute(line1: Ln2, line2: Ln2, point1?: Vec2, point2?: Vec2): number;
+}

package/types/algorithm/distance/curve2s_distance.d.ts

@@ -0,0 +1,15 @@
+import { Vec2 } from '../../base/vec2';
+import { Curve2 } from '../../geometry/curve2';
+/**
+ * 二维曲线到二维曲线的最近距离
+ */
+export declare class Curve2sDistance {
+    /**
+     * 二维曲线到二维曲线的最近距离
+     * @param curve  二维曲线
+     * @param curve  二维曲线
+     * @param footPoint1 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     * @param footPoint2 [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     */
+    static execute(curve1: Curve2, curve2: Curve2, footPoint1?: Vec2, footPoint2?: Vec2): number;
+}

package/types/algorithm/distance/curve3ds_distance/line3d_to_line3d_distance_paramed.d.ts

@@ -0,0 +1,12 @@
+import { types } from '../../../type_define/i_types';
+export declare class Line3dToLine3dDistanceParamed {
+    /**
+     * 方程求解三维直线到三维直线的距离
+     * @param origin1 原点1
+     * @param origin2 原点2
+     * @param dir1 直线方向1
+     * @param dir2 直线方向2
+     * @returns 交点在直线1、2上的参数
+     */
+    static execute(origin1: types.IXYZ, origin2: types.IXYZ, dir1: types.IXYZ, dir2: types.IXYZ): types.numberArr2;
+}

package/types/algorithm/distance/curve3s_distance.d.ts

@@ -0,0 +1,31 @@
+import { Vec3 } from '../../base/vec3';
+import { Curve3 } from '../../geometry/curve3d';
+/**
+ * 三维曲线到三维曲线的最近距离
+ */
+export declare class Curve3sDistance {
+    /**
+     * 三维曲线到三维曲线的距离
+     * @param curve  三维曲线
+     * @param curve  三维曲线
+     * @param minDisPoint1 [out] 输出参数(可选)，若用户想要获取最近距离点，则传入该参数
+     * @param minDisPoint2 [out] 输出参数(可选)，若用户想要获取最近距离点，则传入该参数
+     */
+    static execute(curve1: Curve3, curve2: Curve3, minDisPoint1?: Vec3, minDisPoint2?: Vec3): number;
+    /**
+     * 空间中两三维直线间的距离
+     * @param line1
+     * @param line2
+     * @param point1 [out] 输出参数(可选)，若用户想要获取最近距离点，则传入该参数
+     * @param point2 [out] 输出参数(可选)，若用户想要获取最近距离点，则传入该参数
+     */
+    private static _Line3dToLine3dDistance;
+    /**
+     * 空间中两三维曲线间的距离
+     * @param curve3d1
+     * @param curve3d2
+     * @param point1 [out] 输出参数(可选)，若用户想要获取最近距离点，则传入该参数
+     * @param point2 [out] 输出参数(可选)，若用户想要获取最近距离点，则传入该参数
+     */
+    private static _Curve3dToCurve3dDistance;
+}

package/types/algorithm/distance/pt_to_curve2_signed_distance.d.ts

@@ -0,0 +1,17 @@
+import { Curve2 } from '../../geometry/curve2';
+import { types } from '../../type_define/i_types';
+import { IPtCvDistanceInfo2 } from './pt_to_curve_distance_info';
+/**
+ * 点到二维曲线的有向距离
+ */
+export declare class PtToCv2Distance {
+    /**
+     * 点到二维曲线的有向距离
+     * 点在直线右侧距离为正，否则为负
+     * @param point 任一点
+     * @param curve  二维曲线
+     */
+    static execute(point: types.IXY, curve: Curve2, signedDistance?: boolean): IPtCvDistanceInfo2;
+    static simple(point: types.IXY, curve: Curve2, signedDistance?: boolean): IPtCvDistanceInfo2;
+    private static _toCurveEnd;
+}

package/types/algorithm/distance/pt_to_curve3_distance.d.ts

@@ -0,0 +1,25 @@
+import { Curve3 } from '../../geometry/curve3d';
+import { types } from '../../type_define/i_types';
+import { IPtCvDistanceInfo3 } from './pt_to_curve_distance_info';
+/**
+ * 点到三维曲线的距离
+ */
+export declare class PtToCurve3Distance {
+    /**
+     * 点到三维曲线的距离，直线支持传入有限长和无限长
+     * @param point 任一点
+     * @param curve  三维曲线
+     * @param minDistPoint [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     */
+    static execute(point: types.IXYZ, curve: Curve3): IPtCvDistanceInfo3;
+    /**
+     * 点到三维简单曲线的距离，可传入无限长直线，返回值为正
+     * @param point
+     * @param line
+     */
+    static simple(point: types.IXYZ, curve: Curve3): IPtCvDistanceInfo3;
+    static general(point: types.IXYZ, curve: Curve3): IPtCvDistanceInfo3;
+    static curves(point: types.IXYZ, curves: Curve3[], eps?: number): IPtCvDistanceInfo3[];
+    private static _sqDistanceToCurveEndAndSingularities;
+    private static _getMinDistFootParamInRange;
+}

package/types/algorithm/distance/pt_to_curve_distance_info.d.ts

@@ -0,0 +1,12 @@
+import { Vec } from '../../base/vec';
+import { Vec2 } from '../../base/vec2';
+import { Vec3 } from '../../base/vec3';
+export interface IPtCvDistanceInfo<VectorType extends Vec> {
+    foot: VectorType;
+    param: number;
+    distance: number;
+}
+export interface IPtCvDistanceInfo2 extends IPtCvDistanceInfo<Vec2> {
+}
+export interface IPtCvDistanceInfo3 extends IPtCvDistanceInfo<Vec3> {
+}

package/types/algorithm/distance/pt_to_surface_distance.d.ts

@@ -0,0 +1,17 @@
+import { Surface } from '../../geometry/surface';
+import { Vec3 } from '../../base/vec3';
+/**
+ * 点到三维曲线的距离
+ */
+export declare class PtToSurfDistance {
+    /**
+     * 点到三维曲面的距离，目前支持无限大平面、无限大圆柱面
+     * 结果为有向距离，点在法线同侧为正，在反向为负
+     * @param point 任一点
+     * @param curve  面
+     * @param footPoint [out] 输出参数(可选)，若用户想要获取垂足点，则传入该参数
+     */
+    static execute(point: Vec3, surface: Surface, footPoint?: Vec3): number;
+    private static _PtToPlaneDistance;
+    private static _PtToCylinderDistance;
+}

package/types/algorithm/distance/pts_to_curves_distance.d.ts

@@ -0,0 +1,13 @@
+import { Vec3 } from '../../base/vec3';
+import { Curve3 } from '../../geometry/curve3d';
+/**
+ * 点集到曲线集的最近距离
+ */
+export declare class PtsToCurvesDistance {
+    /**
+     * 点集到曲线集的最近距离
+     * oldMinDis 用于包围盒加速计算，传入一个已知的距离，如果没有已知距离，就不用传入该参数，用默认值就行。譬如说，前面已
+     *           经计算了曲线顶点之间的最近距离为2.015，就可以筛选跳过很多包围盒最小距离都大于此距离的曲线，提高效率。
+     */
+    static execute(ptSet: Array<Vec3>, curve3dSet: Array<Curve3>, minDisPoint1: Vec3, minDisPoint2: Vec3, oldMinDis?: number): number;
+}

package/types/algorithm/distance/pts_to_pts_distance.d.ts

@@ -0,0 +1,7 @@
+import { Vec } from '../../base/vec';
+/**
+ * 点集到点集的最近距离
+ */
+export declare class PtsToPtsDistance {
+    static execute(ptSet1: Array<Vec>, ptSet2: Array<Vec>, minDisPoint1: Vec, minDisPoint2: Vec): number;
+}

package/types/algorithm/geometry_merge.d.ts

@@ -0,0 +1,22 @@
+import { Curve2 } from '../geometry/curve2';
+import { Tol } from '../base/tol';
+import { Curve3 } from '../geometry/curve3d';
+import { MergeReverseMode } from './overlap/curves_merge';
+export interface IMergeCurveInfo {
+    result: Curve2[];
+    mapper: Map<Curve2, Curve2[]>;
+}
+export declare class GeometryMerge {
+    /**
+     * 仅支持 arc 和 line
+     * 默认容差为1e-6
+     */
+    static mergeCurve2ds(curves: Curve2[], eps?: number): Curve2[];
+    static mergeCurve2dsEx(curves: Curve2[], eps?: number): IMergeCurveInfo;
+    static mergePoints(points: ([number, number] | [number, number, number])[], eps?: number): {
+        index: number[];
+        points: ([number, number] | [number, number, number])[];
+    };
+    static mergeTwoCurve2ds(curve1: Curve2, curve2: Curve2, mode?: MergeReverseMode, tol?: Tol): Curve2[] | undefined;
+    static mergeTwoCurve3ds(curve1: Curve3, curve2: Curve3, mode?: MergeReverseMode, tol?: Tol): Curve3[] | undefined;
+}

package/types/algorithm/index.d.ts

@@ -0,0 +1,32 @@
+export { D } from './calc_d';
+export type { IPtCvDistanceInfo, IPtCvDistanceInfo2, IPtCvDistanceInfo3, } from './distance/pt_to_curve_distance_info';
+export { X } from './calc_x';
+export { CurvesColinear } from './overlap/curves_colinear';
+export { CurvesMerge } from './overlap/curves_merge';
+export { GeometryMerge } from './geometry_merge';
+export { Project } from './calc_project';
+export { Offset } from './calc_offset';
+export { CalcOverlap, Overlap } from './calc_overlap';
+export type { ICurvesOverlapInfo } from './overlap/i_overlap';
+export type { ICurvesXInfo, ICurvesXInfo2d, ICurvesXInfo3d, ICvSurfXInfo, ISurfacesXInfo, } from './intersect/x_info';
+export { BoolOperate2d } from './bool_operate_2d';
+export { Bool2d, Bool2dType, Bool2dType as BoolType } from './bool_operate/bool2d/bool2d';
+export type { IFace2D } from './bool_operate/bool2d/utils';
+export { PolygonOffset, type IPolygonOffsetResult } from './offset/polygon_offset';
+export { SearchGraph } from './search_graph';
+export { BoolOperateClipper } from './bool_operate/bool_operate_clipper';
+export { TopologyEdit } from './topology_edit';
+export { LoopArea } from './loop_property/loop-area';
+export { LoopCentroid } from './loop_property/loop-centroid';
+export { PJ, type IPtLoopResult } from './position_judge';
+export { PtPolygonPositionJudger } from './pj/pt_polygon_position_judger';
+export { CurvesPJType, PtLoopPJType, LoopsPJType } from './pj/pj_type';
+export { ILoopsToPolygonExes } from './search_graph/iloops_polygonex';
+export { ClipMesh, type IMeshClipResult } from './mesh/clip_mesh';
+export { MeshUtil } from './mesh/mesh_util';
+export { ExtrudeClip, Extruder } from './mesh/extrude_clip';
+export { DiscreteUtil } from './discrete/discrete_util';
+export type { IDirectedCurve, IDirectedCurve2d, IDirectedCurve3d } from './discrete/discrete_surface';
+export { DiscreteTopology } from './discrete/discrete_topology';
+export { boxCutLine, boxToTrimmedSurfaces } from './intersect/box_cut_line';
+export { PatternUtil, IPavePattern, IPolygon, RegionMesh } from './pattern/pattern_util';

package/types/algorithm/intersect/box_cut_line.d.ts

@@ -0,0 +1,6 @@
+import { Ln3 } from '../../geometry/ln3';
+import { Box3 } from '../../base/box3';
+import { Interval } from '../../base/interval';
+import { TrimmedSurface } from '../../topology/trimmed_surface';
+export declare function boxToTrimmedSurfaces(box3d: Box3): TrimmedSurface[];
+export declare function boxCutLine(line: Ln3, box3d: Box3): Interval | undefined;

package/types/algorithm/intersect/curve_self_x.d.ts

@@ -0,0 +1,13 @@
+import { Tol } from '../../base/tol';
+import { ICurvesXInfo2d, ICurvesXInfo3d } from './x_info';
+import { Curve3 } from '../../geometry/curve3d';
+import { Curve2 } from '../../geometry/curve2';
+export declare class CurveSelfX {
+    static isCurve2dSelfX(curve: Curve2, tol?: Tol): boolean;
+    static curve2dSelfX(curve: Curve2, tol?: Tol): ICurvesXInfo2d[];
+    static curve3dSelfX(curve: Curve3, tol?: Tol): ICurvesXInfo3d[];
+    private static _dealRedundant;
+    private static _selfIntersectSimple;
+    private static _isNurbs3dCtrlPtsIsIntersect;
+    private static _isNurbs2dCtrlPtsIsIntersect;
+}

package/types/algorithm/intersect/curve_surface_x.d.ts

@@ -0,0 +1,34 @@
+import { Curve3 } from '../../geometry/curve3d';
+import { Surface } from '../../geometry/surface';
+import { Vec3 } from '../../base/vec3';
+import { Tol } from '../../base/tol';
+import { ICvSurfXInfo, ICurveSurfXPointInfo } from './x_info';
+import { Interval } from '../../base/interval';
+import { types } from '../../type_define/i_types';
+import { Polygon } from '../../topology/polygon';
+/**
+ * 三维曲线与曲面的交点, 交点可能不止一个，故返回交点的数组
+ * @returns
+ */
+declare class CurveSurfaceX {
+    /**
+     * 【注意：曲线有参数域，曲面没有，因此求交要判断是否在曲线参数域内】
+     * 三维曲线与曲面的求交：直线+平面，直线+圆柱，（直线+圆锥；）圆弧+平面，（圆弧+圆柱，圆弧+圆锥；通用曲线+平面，通用曲线+圆柱，通用曲线+圆锥）
+     * @param curve  曲线
+     * @param surface 曲面
+     * @returns 交点可能不止一个，故返回交点的数组
+     */
+    static execute(curve: Curve3, surface: Surface, tol?: Tol, surfRangeUV?: Interval[]): ICvSurfXInfo[];
+    static allPoints(curve: Curve3, surface: Surface, tol?: Tol, surfRangeUV?: Interval[]): Vec3[];
+    static hasIntersect(curve: Curve3, surf: Surface, surfPoly?: Polygon, tol?: Tol): boolean;
+    static nearPoint(curve: Curve3, surf: Surface, refPoint: Vec3 | ICurveSurfXPointInfo, tol?: Tol): ICvSurfXInfo | undefined;
+    static nearParam(curve: Curve3, surf: Surface, refT: number, refUV: types.IXY, tol?: Tol): ICvSurfXInfo | undefined;
+    private static _complexMethod;
+    private static _getSurfaceLocalCoord;
+    private static _getCurveEndPtIntersects;
+    private static _preciseMethod;
+    private static _line3dPlane;
+    private static _circle3dPlane;
+    private static _line3dCylinder;
+}
+export { CurveSurfaceX };

package/types/algorithm/intersect/curve_surface_x_util.d.ts

@@ -0,0 +1,32 @@
+import { Interval } from '../../base/interval';
+import { Tol } from '../../base/tol';
+import { Vec3 } from '../../base/vec3';
+import { Curve3 } from '../../geometry/curve3d';
+import { Surface } from '../../geometry/surface';
+import { ICvSurfXInfo, ICurveSurfXPointInfo } from './x_info';
+export declare class CurveSurfaceXUtil {
+    static dealRedundantIntersect(curv: Curve3, surf: Surface, newInt: ICvSurfXInfo, intRes: ICvSurfXInfo[], tol?: Tol): boolean;
+    private _curve;
+    private _surface;
+    private _surfaceRangeUV;
+    private _tol;
+    constructor(curve: Curve3, surface: Surface, tol?: Tol);
+    calAllIntersects(surfRanges?: Interval[]): ICvSurfXInfo[];
+    calSingleIntersect(referPoint: Vec3 | ICurveSurfXPointInfo, surfRanges?: Interval[]): ICvSurfXInfo | undefined;
+    hasIntersect(surfRanges?: Interval[], tol?: Tol): boolean;
+    /**
+     * 返回false表示无交
+     * @param curveSeg
+     * @param surfPatch
+     */
+    private _shrinkCurveRange;
+    private _shrinkSurfacePatchRanges;
+    private _calCurveSurfacePairsIntersect;
+    private _findCurveSurfacePairsIntersect;
+    private _curveSurfacePairIntersect;
+    private _calcCurveSurfaceDeltaParams;
+    private _curveSurfaceIteration;
+    private _combineCurveSurfacePairs;
+    private _FilterCurveSurfacePairs;
+    private _refreshSegmentPatchs;
+}

package/types/algorithm/intersect/curves_x/circulars_x.d.ts

@@ -0,0 +1,35 @@
+import { Arc2 } from '../../../geometry/arc2d';
+import { Arc3 } from '../../../geometry/arc3d';
+import { Tol } from '../../../base/tol';
+import { ICurvesXInfo2d, ICurvesXInfo3d } from '../x_info';
+/**
+ * 圆和圆求交
+ */
+declare class CircularsX {
+    /**
+     * 求两圆弧的交点,若圆弧重合，则返回某一个交点+重合段
+     * > 此接口是求两有限长圆弧的交点
+     * @param arc1
+     * @param arc2
+     */
+    static arc2dAndArc2d(arc1: Arc2, arc2: Arc2, tol?: Tol): ICurvesXInfo2d[];
+    /**
+     * 求两圆（椭圆）弧的交点，若圆弧重合，则返回某一个交点+重合段
+     * @param arc1
+     * @param arc2
+     */
+    static arc3dAndArc3d(arc1: Arc3, arc2: Arc3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 求两椭圆弧的交点：两个圆中至少有一个是椭圆
+     * @param ellipse1
+     * @param ellipse2
+     */
+    private static _ellipse2s;
+    /**
+     * 求两圆弧的交点
+     * @param arc1
+     * @param arc2
+     */
+    private static _circle2dAndCircle2d;
+}
+export { CircularsX };

package/types/algorithm/intersect/curves_x/linear_circular_x.d.ts

@@ -0,0 +1,40 @@
+import { ICurvesXInfo2d, ICurvesXInfo3d } from '../x_info';
+import { Ln2 } from '../../../geometry/ln2';
+import { Arc2 } from '../../../geometry/arc2d';
+import { Ln3 } from '../../../geometry/ln3';
+import { Arc3 } from '../../../geometry/arc3d';
+import { Tol } from '../../../base/tol';
+/**
+ * 直线和圆求交
+ */
+declare class LineCircleX {
+    /**
+     * 求两直线段的交点,若直线重合，则返回某一个交点+重合段
+     * > 此接口是求两直线段的交点，直线段是有限长的，若求无限长的直线的交点，可将直线extend至无限长
+     * @param line
+     * @param arc
+     */
+    static line2dAndArc2d(line: Ln2, arc: Arc2, tol?: Tol): ICurvesXInfo2d[];
+    /**
+     * 求两直线段的交点,若直线重合，则返回某一个交点+重合段
+     * > 此接口是求两直线段的交点，直线段是有限长的，若求无限长的直线的交点，可将直线extend至无限长
+     * @param line
+     * @param arc
+     */
+    static line3dAndArc3d(line: Ln3, arc: Arc3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 求三维直线和整圆的交点
+     * > 此接口中直线段是无限长的，圆也是一整圈
+     * @param line
+     * @param circle
+     */
+    static line3dAndCircle3d(line: Ln3, arc3: Arc3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 求二维直线和椭圆弧的交点
+     * @param line
+     * @param ellipse
+     */
+    private static _line2dAndEllipse2d;
+    private static _line3dAndEllipse3d;
+}
+export { LineCircleX };

package/types/algorithm/intersect/curves_x/lines_x.d.ts

@@ -0,0 +1,17 @@
+import { Tol } from '../../../base/tol';
+import { Ln2 } from '../../../geometry/ln2';
+import { Ln3 } from '../../../geometry/ln3';
+import { ICurvesXInfo2d, ICurvesXInfo3d } from '../x_info';
+/**
+ * 两直线段求交
+ */
+export declare class LinesX {
+    /**
+     * 求两直线段的交点,若直线重合，则返回某一个交点+重合段
+     * > 此接口是求两直线段的交点，直线段是有限长的，若求无限长的直线的交点，可将直线extend至无限长
+     * @param line1
+     * @param line2
+     */
+    static line2ds(line1: Ln2, line2: Ln2, tol?: Tol): ICurvesXInfo2d[];
+    static line3ds(line1: Ln3, line2: Ln3, tol?: Tol): ICurvesXInfo3d[];
+}

package/types/algorithm/intersect/curves_x/lines_x_util.d.ts

@@ -0,0 +1,4 @@
+import { types } from '../../../type_define/i_types';
+export declare class LinesXUtil {
+    static line2dsParamed(origin1: types.IXY, origin2: types.IXY, dir1: types.IXY, dir2: types.IXY): types.numberArr2;
+}

package/types/algorithm/intersect/curves_x.d.ts

@@ -0,0 +1,26 @@
+import { Tol } from '../../base/tol';
+import { Curve3 } from '../../geometry/curve3d';
+import { Curve2 } from '../../geometry/curve2';
+import { ICurvesXInfo2d, ICurvesXInfo3d } from './x_info';
+import { Vec3 } from '../../base/vec3';
+/**
+ * 曲线与曲线的交点：直线+直线，直线+圆弧，（直线+通用曲线）；圆弧+圆弧；（圆弧+通用曲线；通用曲线+通用曲线）
+ * 若两曲线重合，则交点为重合段内的某个交点
+ * > 此接口是求两曲线段的交点，曲线段是有限长的，若求无限长的曲线的交点，可将曲线extend至无限长
+ * @param curve1
+ * @param curve2
+ * @param extraInfo [out]如果需要知道交点的额外信息（交点在各个曲线上的参数），则传入该参数,
+ */
+declare class CurvesX {
+    static curve2ds(curve1: Curve2, curve2: Curve2, tol?: Tol): ICurvesXInfo2d[];
+    static curve3ds(curve1: Curve3, curve2: Curve3, tol?: Tol): ICurvesXInfo3d[];
+    static curve3dsNearPoint(curve1: Curve3, curve2: Curve3, point: Vec3, tol?: Tol): ICurvesXInfo3d | undefined;
+    private static _curve3dsSimple;
+    private static _byGeometricOrAnalyticMethod;
+    private static _isLineXPlaneCurve3d;
+    private static _isTwoPlaneCurve3dsCoplane;
+    private static _curve3dAndExtendCurve3d;
+    private static _getOriginParamForExtendCurve;
+    private static _swapParams;
+}
+export { CurvesX };

package/types/algorithm/intersect/curves_x_util.d.ts

@@ -0,0 +1,35 @@
+import { Tol } from '../../base/tol';
+import { Curve3 } from '../../geometry/curve3d';
+import { ICurvesXInfo, ICurvesXInfo2d, ICurvesXInfo3d } from './x_info';
+import { Curve2 } from '../../geometry/curve2';
+import { Vec3 } from '../../base/vec3';
+import { Curve } from '../../geometry/curve';
+import { Vec } from '../../base/vec';
+import { Vec2 } from '../../base/vec2';
+export declare class CurvesXUtil {
+    static curve2dCurve2d(curve2d1: Curve2, curve2d2: Curve2, tol?: Tol): ICurvesXInfo2d[];
+    static curve3dCurve3d(origCurve3d1: Curve3, origCurve3d2: Curve3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 只计算一个交点（或者没有交点）就返回
+     * @param curve2d1 曲线1
+     * @param curve2d2 曲线2
+     * @param ref 参考点或在两曲线上的参数
+     */
+    static curve2dsSingleX(curve2d1: Curve2, curve2d2: Curve2, ref: Vec2 | number[], tol?: Tol): ICurvesXInfo2d | undefined;
+    /**
+     * 只计算一个交点（或者没有交点）就返回
+     * @param curve3d1 曲线1
+     * @param curve3d2 曲线2
+     * @param ref 参考点或在两曲线上的参数
+     */
+    static curve3dsSingleX(curve3d1: Curve3, curve3d2: Curve3, ref: Vec3 | number[], tol?: Tol): ICurvesXInfo3d | undefined;
+    static getEndPtIntersect<VectorType extends Vec>(curve1: Curve<VectorType>, curve2: Curve<VectorType>, tol: Tol): ICurvesXInfo<VectorType>[];
+    private static _getNearestSingularityIntersect;
+    private static _calCurve2dSegmentsIntersect;
+    private static _calCurve3dSegmentsIntersect;
+    private static _dealSingularityIntersect;
+    private static _isRedundantPt;
+    private static _dealRedundantIntersect;
+    private static _FilterCurvSegmentPairs;
+    private static _calCurveSegmentPairIntersect;
+}

package/types/algorithm/intersect/intersect_info_util.d.ts

@@ -0,0 +1,9 @@
+import { Tol } from '../../base/tol';
+import { ICurvesOverlapInfo } from '../overlap/i_overlap';
+import { ICurvesXInfo2d, ICurvesXInfo3d } from './x_info';
+import { Curve2 } from '../../geometry/curve2';
+import { Curve3 } from '../../geometry/curve3d';
+export declare class XInfoUtil {
+    static curvesFromOverlap(info: ICurvesOverlapInfo, curve1: Curve2, curve2: Curve2, tol: Tol): ICurvesXInfo2d;
+    static curvesFromOverlap(info: ICurvesOverlapInfo, curve1: Curve3, curve2: Curve3, tol: Tol): ICurvesXInfo3d;
+}

package/types/algorithm/intersect/surface_self_x.d.ts

@@ -0,0 +1,8 @@
+import { Surface } from '../../geometry/surface';
+import { types } from '../../type_define/i_types';
+import { Vec3 } from '../../base/vec3';
+import { Tol } from '../../base/tol';
+import { Curve3 } from '../../geometry/curve3d';
+export declare class SurfaceSelfX {
+    static singleIntersectCurve(surf: Surface, refUV1: types.IXY, refUV2: types.IXY, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+}

package/types/algorithm/intersect/surfaces_x.d.ts

@@ -0,0 +1,53 @@
+import { Surface } from '../../geometry/surface';
+import { Interval } from '../../base/interval';
+import { Tol } from '../../base/tol';
+import { Vec3 } from '../../base/vec3';
+import { ISurfacesXInfo } from './x_info';
+import { Curve3 } from '../../geometry/curve3d';
+import { types } from '../../type_define/i_types';
+/**
+ * Surface 与 Surface求交，返回值为交线：平面+平面，平面+圆柱，平面+圆锥，平面+通用曲面；圆柱+圆柱，圆柱+圆锥；圆锥+圆锥；通用曲面+通用曲面；
+ */
+declare class SurfacesX {
+    /**
+     * 计算返回所有的交（交线、交点、重合面（未实现））
+     * 曲面与曲面相交为交线
+     * @param surface 曲面
+     * @param surface 曲面
+     * @returns 交线可能不止一条，故返回交线的数组
+     */
+    static allIntersections(surface1: Surface, surface2: Surface, rangeU1?: Interval, rangeV1?: Interval, rangeU2?: Interval, rangeV2?: Interval, tol?: Tol, useHighPrecision?: boolean): ISurfacesXInfo[];
+    /**
+     * 计算返回一条（离给定参考点最近的）交线
+     * 曲面与曲面相交为交线
+     * @param surface 曲面
+     * @param surface 曲面
+     * @param refPoint 距离交线很近的参考点
+     * @returns 只返回一条交线，如果没有交返回空
+     */
+    static singleCurveBetweenTwoPoints(surf1: Surface, surf2: Surface, point1: Vec3, point2: Vec3, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    /**
+     * 计算返回一条（离给定参考点最近的）交线
+     * 曲面与曲面相交为交线
+     * @param surface 曲面
+     * @param surface 曲面
+     * @param refPoint 距离交线很近的参考点
+     * @returns 只返回一条交线，如果没有交返回空
+     */
+    static singleCurveNearPointSimple(surf1: Surface, surf2: Surface, refPoint: Vec3, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    /**
+     * 计算返回一条（离给定参考点最近的）交线.如果convertNurbs=false，返回的曲线类型可能为intersectCurve3d，不建议外部使用，算法库内部使用
+     * 曲面与曲面相交为交线
+     * @param surface 曲面
+     * @param surface 曲面
+     * @param refPoint 距离交线很近的参考点
+     * @returns 只返回一条交线，如果没有交返回空
+     */
+    static singleCurveNearPoint(surf1: Surface, surf2: Surface, refPoint: Vec3, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean, convertNurbs?: boolean): Curve3 | undefined;
+    static selfIntersectCurve(surf: Surface, refUV1: types.IXY, refUV2: types.IXY, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    static singleCurveNearParam(surf1: Surface, surf2: Surface, refUV1: types.IXY, refUV2: types.IXY, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    static getNearstCurve(intCurves: Curve3[], refPoint: Vec3, refDir?: Vec3): Curve3 | undefined;
+    private static _isComplexSurface;
+    private static _singleCurveNearPoint;
+}
+export { SurfacesX };