@ccpc/math 0.1.0 → 0.1.7

package/package.json

@@ -1,38 +1,20 @@
 {
-    "name": "@ccpc/math",
-    "version": "0.1.0",
-    "private": false,
-    "description": "2D geometry and curve math library",
-    "license": "MIT",
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
-        }
-    },
-    "files": [
-        "dist",
-        "README.md",
-        "LICENSE"
-    ],
-    "publishConfig": {
-        "access": "public"
-    },
-    "scripts": {
-        "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
-        "build": "tsc -p tsconfig.json",
-        "lint": "eslint . --ext .ts",
-        "lint:fix": "eslint . --ext .ts --fix",
-        "test": "vitest",
-        "test:run": "vitest run",
-        "test:coverage": "vitest run --coverage",
-        "prepublishOnly": "pnpm run build && pnpm run test:run"
-    },
-    "devDependencies": {
-        "@vitest/coverage-v8": "^4.0.18",
-        "vitest": "^4.0.18"
-    }
-}
+  "name": "@ccpc/math",
+  "version": "0.1.7",
+  "description": "2D geometry and curve math library",
+  "license": "MIT",
+  "type": "module",
+  "main": "./index.cjs",
+  "types": "./types/index.d.ts",
+  "dependencies": {
+    "clipper2-wasm": "^0.2.1",
+    "earcut": "^3.0.2",
+    "libtess": "^1.2.2",
+    "lodash": "^4.17.23",
+    "numeric": "^1.2.6",
+    "poly2tri": "^1.5.0",
+    "priorityqueuejs": "^2.0.0",
+    "quadtree-lib": "^1.0.9",
+    "uuid": "^10.0.0"
+  }
+}

package/types/algorithm/bool_operate/bool2d/bool2d.d.ts

@@ -0,0 +1,22 @@
+import { Loop } from '../../../topology/loop';
+import { Polygon } from '../../../topology/polygon';
+import { Curve2 } from '../../../geometry/curve2';
+import { IFace2D } from './utils';
+export declare enum Bool2dType {
+    union = 0,
+    intersect = 1,
+    difference = 2,
+    xor = 3,
+    split = 4
+}
+export { Bool2dType as BoolType };
+/**
+ *
+ * 二维布尔运算，暂时支持直线、圆弧的交、并、差、分割
+ */
+declare class Bool2d {
+    static boolOperate(loopOrPolygons1: (Loop | Polygon)[], loopOrPolygons2: (Loop | Polygon)[], type: Bool2dType, distanceTol?: number, angleTol?: number): Polygon[];
+    static boolOperateCore(faces1: IFace2D[], faces2: IFace2D[], type: Bool2dType, distanceTol?: number, angleTol?: number, newCurveMap?: Map<Curve2, Curve2>, noOverlap1?: boolean, noOverlap2?: boolean): IFace2D[];
+    private static _toFace2d;
+}
+export { Bool2d };

package/types/algorithm/bool_operate/bool2d/difference.d.ts

@@ -0,0 +1,9 @@
+import { Curve2 } from '../../../geometry/curve2';
+import { IFace2D } from './utils';
+/**
+ * 两组二维面域相减
+ * @param faces1
+ * @param faces2
+ * @param newCurveMap 可选参数, map<new bounded curve, origin bounded curve>.
+ */
+export declare function faces2DDifference(faces1: IFace2D[], faces2: IFace2D[], distanceTol: number, angleTol: number, newCurveMap?: Map<Curve2, Curve2>): IFace2D[];

package/types/algorithm/bool_operate/bool2d/intersect.d.ts

@@ -0,0 +1,9 @@
+import { Curve2 } from '../../../geometry/curve2';
+import { IFace2D } from './utils';
+/**
+ * 两组二维面域相交
+ * @param faces1
+ * @param faces2
+ * @param newCurveMap 可选参数, map<new bounded curve, origin bounded curve>.
+ */
+export declare function faces2DIntersect(faces1: IFace2D[], faces2: IFace2D[], distanceTol: number, angleTol: number, newCurveMap?: Map<Curve2, Curve2>): IFace2D[];

package/types/algorithm/bool_operate/bool2d/split.d.ts

@@ -0,0 +1,3 @@
+import { IFace2D } from './utils';
+import { Curve2 } from '../../../geometry/curve2';
+export declare function faces2DSplit(faces1: IFace2D[], faces2: IFace2D[], distanceTol: number, angleTol: number, newCurveMap?: Map<Curve2, Curve2>): IFace2D[];

package/types/algorithm/bool_operate/bool2d/union.d.ts

@@ -0,0 +1,9 @@
+import { Curve2 } from '../../../geometry/curve2';
+import { IFace2D } from './utils';
+/**
+ * 两组二维面域求并集
+ * @param faces1
+ * @param faces2
+ * @param newCurveMap 可选参数, map<new bounded curve, origin bounded curve>.
+ */
+export declare function faces2DUnion(faces1: IFace2D[], faces2: IFace2D[], distanceTol: number, angleTol: number, newCurveMap?: Map<Curve2, Curve2>): IFace2D[];

package/types/algorithm/bool_operate/bool2d/utils.d.ts

@@ -0,0 +1,40 @@
+import { Curve2 } from '../../../geometry/curve2';
+import { Box2 } from '../../../base/box2';
+import { Vec2 } from '../../../base/vec2';
+import { Bool2dType } from './bool2d';
+export interface IFace2D {
+    loops: Curve2[][];
+    bcGroups?: Curve2dGroup[];
+    box?: Box2;
+    bPositive?: boolean;
+    bBlankFace?: boolean;
+    originFaces?: IFace2D[];
+}
+export declare class Curve2dGroup {
+    static curvesEqual(g1: Curve2dGroup, g2: Curve2dGroup, disTol: number, angleTol: number): boolean;
+    face: IFace2D;
+    curves: Curve2[];
+    box: Box2;
+    bValid: boolean;
+    insideFaces: IFace2D[];
+    onFaces: IFace2D[];
+    outsideFaces: IFace2D[];
+    constructor(face: IFace2D, bcs: Curve2[]);
+    addInsideFace(face: IFace2D): void;
+    addOnFace(face: IFace2D): void;
+    getReversedCurves(newCurveMap?: Map<Curve2, Curve2>): Curve2[];
+    cloneCurves(newCurveMap?: Map<Curve2, Curve2>): Curve2[];
+}
+export declare function intersectFaces(faces1: IFace2D[], faces2: IFace2D[], distanceTol: number, angleTol: number): void;
+export declare function splitLoopByPoints(loop: Curve2[], points: Vec2[], result: Curve2[][], distanceTol: number): void;
+export declare function splitLoopsIntoGroup(faces1: IFace2D[], faces2: IFace2D[], distanceTol: number): void;
+export declare function calculateFaceBBox(face: IFace2D): void;
+export declare function calculatePositionInfo(face: IFace2D, otherFaces: IFace2D[], distanceTol: number, angleTol: number, insideFaceMap?: Map<IFace2D, Curve2dGroup[]>): void;
+/**
+ * check if the bounded curve group is valid. it's on the other face's boundary.
+ * @param group input bounded curve group.
+ * @param reverseResult flag means reverse the result.
+ */
+export declare function validateOverlapCurveGroup(group: Curve2dGroup, distTol?: number, reverseResult?: boolean): void;
+export declare function areFacesTotallyOverlap(face1: IFace2D, face2: IFace2D, disTol: number, angleTol: number): boolean;
+export declare function generateResult(allFaces: IFace2D[], resultFaces: IFace2D[], type: Bool2dType, getOriginFaces: (newFace: IFace2D, candidates: Set<IFace2D>) => IFace2D[], distanceTol: number, angleTol: number, newCurveMap?: Map<Curve2, Curve2>): void;

package/types/algorithm/bool_operate/bool_operate_clipper.d.ts

@@ -0,0 +1,18 @@
+import { Curve2 } from '../../geometry/curve2';
+import { Loop } from '../../topology/loop';
+import { Polygon } from '../../topology/polygon';
+import { Vec2 } from '../../base/vec2';
+/**
+ * 二维布尔运算，封装的clipper算法
+ */
+declare class BoolOperateClipper {
+    /**
+     * 差
+     * @param loopOrPolygons1
+     * @param loopOrPolygons2
+     */
+    static curvePolygon(curve: Curve2, loopOrPolygons2: (Loop | Polygon)[], isIntersect: boolean): Vec2[][];
+    static boolOperate(loopOrPolygons1: (Loop | Polygon)[], type: 0 | 1 | 2, loopOrPolygons2: (Loop | Polygon)[]): Polygon;
+    static boolOperateEx(loopOrPolygons1: (Loop | Polygon)[], type: 0 | 1 | 2, loopOrPolygons2: (Loop | Polygon)[]): Polygon[];
+}
+export { BoolOperateClipper };

package/types/algorithm/bool_operate/polycurve_polygon_bool.d.ts

@@ -0,0 +1,13 @@
+import { PolyCurve } from '../../topology/polycurve';
+import { Loop } from '../../topology/loop';
+import { Polygon } from '../../topology/polygon';
+export declare class PolycurvePolygonBool {
+    /**
+     * 布尔运算， 区域裁剪线段, 支持曲线
+     * @param polyline
+     * @param polygon
+     * @param isIntersect 内部还是外部
+     * @param isTangentKeep 保留边界重叠部分
+     */
+    static execute(polyline: PolyCurve, loopOrPolygons: (Loop | Polygon)[], isIntersect: boolean, isTangentKeep: boolean, _torlerance: number): PolyCurve[];
+}

package/types/algorithm/bool_operate_2d.d.ts

@@ -0,0 +1,67 @@
+import { Polygon } from '../topology/polygon';
+import { Loop } from '../topology/loop';
+import { PolyCurve } from '../topology/polycurve';
+/**
+ * 布尔运算
+ * -
+ */
+declare class BoolOperate2d {
+    /**
+     * 并
+     * 使用Clipper, 支持直线
+     * @param loopOrPolygons
+     */
+    static union(loopOrPolygons: (Loop | Polygon)[]): Polygon;
+    /**
+     * 交
+     * 使用Clipper, 支持直线
+     * @param loopOrPolygons
+     */
+    static intersect(loopOrPolygons: (Loop | Polygon)[]): Polygon;
+    /**
+     * 差 loopOrPolygons1 - loopOrPolygons2
+     * 使用Clipper, 支持直线
+     * @param loopOrPolygons1
+     * @param loopOrPolygons2
+     */
+    static difference(loopOrPolygon1: Loop | Polygon, loopOrPolygons2: (Loop | Polygon)[]): Polygon;
+    /**
+     * 求并集，适用于Loop, PolygonEx
+     * 支持直线、圆弧
+     * @param loopOrPolygonExs
+     * @return 得到PolygonEx数组
+     */
+    static polygonExUnion(loopOrPolygonExs: (Loop | Polygon)[], disTol?: number, angleTol?: number): Polygon[];
+    /**
+     * 两组之间求交集，适用于Loop, PolygonEx
+     * 支持直线、圆弧
+     * @param loopOrPolygonExs1
+     * @param loopOrPolygonExs2
+     * @return 得到PolygonEx数组
+     */
+    static polygonExIntersect(loopOrPolygonExs1: (Loop | Polygon)[], loopOrPolygonExs2: (Loop | Polygon)[], disTol?: number, angleTol?: number): Polygon[];
+    /**
+     * 两组之间求差集，适用于Loop, PolygonEx
+     * 支持直线、圆弧
+     * @param loopOrPolygonExs1
+     * @param loopOrPolygonExs2
+     * @return 得到PolygonEx数组
+     */
+    static polygonExDifference(loopOrPolygonExs1: (Loop | Polygon)[], loopOrPolygonExs2: (Loop | Polygon)[], disTol?: number, angleTol?: number): Polygon[];
+    /**
+     * 返回polyline在loop/polygon内部的部分
+     * @param polyline
+     * @param loopOrPolygons
+     * @param isTangentKeep 保留边界重叠部分
+     * @param tolerance
+     */
+    static polylineIntersect(polyline: PolyCurve, loopOrPolygons: (Polygon | Loop)[], isTangentKeep: boolean, tolerance?: number): PolyCurve[];
+    /**
+     * 返回polyline在loop/polygon外部的部分
+     * @param polyline
+     * @param polygon
+     * @param torlerance
+     */
+    static polylineDifference(polyline: PolyCurve, loopOrPolygons: (Polygon | Loop)[], isTangentKeep: boolean, torlerance?: number): PolyCurve[];
+}
+export { BoolOperate2d };

package/types/algorithm/calc_d.d.ts

@@ -0,0 +1,85 @@
+import { Vec2 } from '../base/vec2';
+import { Curve2 } from '../geometry/curve2';
+import { Vec3 } from '../base/vec3';
+import { Surface } from '../geometry/surface';
+import { Curve3 } from '../geometry/curve3d';
+import { IPtCvDistanceInfo2, IPtCvDistanceInfo3 } from './distance/pt_to_curve_distance_info';
+import { types } from '../type_define/i_types';
+/**
+ * - 点到二维曲线的距离
+ * - 点到三维曲线的距离
+ * - 点到Surface的有向距离
+ * - 点到Surface的距离
+ * - 二维曲线到二维曲线最近距离
+ */
+export declare class D {
+    /**
+     * 点到曲线距离
+     * @param point 点
+     * @param curve 二维曲线，可以是无限长Line
+     * @param minDistancePoint 最小距离曲线上的点
+     */
+    static ptToCurve2d(point: types.IXY, curve: Curve2, minDistancePoint?: Vec2): number;
+    /**
+     * 点到曲线的有向距离，点在直线右侧返回正，否则返回负值
+     * @param point 点
+     * @param curve 二维曲线，可以是无限长Line
+     * @param minDistancePoint 最小距离曲线上的点
+     */
+    static ptToCurve2dSigned(point: types.IXY, curve: Curve2, minDistancePoint?: Vec2): number;
+    /**
+     * 点到曲线的有向距离，点在直线右侧返回正，否则返回负值
+     * @param point
+     * @param curve
+     * @param minDistancePoint
+     */
+    static ptToCurve2dSignedInfo(point: types.IXY, curve: Curve2): IPtCvDistanceInfo2;
+    /**
+     * 点到三维曲线的距离，直线支持传入有限长和无限长
+     * @returns 距离值 >= 0
+     */
+    static ptToCurve3d(point: types.IXYZ, curve: Curve3, footPoint?: Vec3): number;
+    /**
+     * 点到三维曲线的距离，直线支持传入有限长和无限长
+     */
+    static ptToCurve3dInfo(point: types.IXYZ, curve: Curve3): IPtCvDistanceInfo3;
+    /**
+     * 点到三围曲线组的距离
+     * @param point
+     * @param curves
+     * @param eps
+     */
+    static ptToCurve3dsInfos(point: types.IXYZ, curves: Curve3[], eps?: number): IPtCvDistanceInfo3[];
+    /**
+     * 点到Surface的距离,返回结果 >= 0
+     * @param point 三维点
+     * @param surface 曲面
+     * @param footPoint  [out] 输出参数，若用户想要获取垂足点，则传入该参数
+     * @returns 距离值，≥0
+     */
+    static ptToSurf(point: Vec3, surface: Surface, footPoint?: Vec3): number;
+    /**
+     *  点到Surface的有向距离
+     * @param point 三维点
+     * @param surface 曲面
+     * @param footPoint  [out] 输出参数，若用户想要获取垂足点，则传入该参数
+     * @returns 有向距离,在法线同侧为正，
+     */
+    static ptToSurfSigned(point: Vec3, surface: Surface, footPoint?: Vec3): number;
+    /**
+     * 二维曲线到二维曲线最近距离
+     * @param curve1 二维曲线
+     * @param curve2 二维曲线
+     * @param minDistPoint1 最小距离曲线1上的点
+     * @param minDistPoint2 最小距离曲线2上的点
+     */
+    static curve2s(curve1: Curve2, curve2: Curve2, minDistPoint1?: Vec2, minDistPoint2?: Vec2): number;
+    /**
+     * 三维曲线到三维曲线最近距离
+     * @param curve1 三维曲线
+     * @param curve2 三维曲线
+     * @param minDistPoint1 最小距离曲线1上的点
+     * @param minDistPoint2 最小距离曲线2上的点
+     */
+    static curve3s(curve1: Curve3, curve2: Curve3, minDistPoint1?: Vec3, minDistPoint2?: Vec3): number;
+}

package/types/algorithm/calc_offset.d.ts

@@ -0,0 +1,70 @@
+import { Curve3 } from '../geometry/curve3d';
+import { Vec3 } from '../base/vec3';
+import { Tol } from '../base/tol';
+import { types } from '../type_define/i_types';
+import { EvolutionMap } from '../topology/evolution_map';
+import { Curve2 } from '../geometry/curve2';
+export declare class Offset {
+    /**
+     * 偏置平面曲线闭环，使其过 point 点。得到的结果可能为多个 Loop
+     * @param curves 闭合曲线组
+     * @param point 目标点
+     */
+    static curve3dsByPoint(curves: Curve3[], point: types.IXYZ, tol?: Tol): {
+        loops: Curve3[][];
+        evolution: EvolutionMap<Curve3>;
+    };
+    /**
+     * 根据给定偏移量，偏置平面曲线闭环
+     * @param curves 待偏置的曲线组
+     * @param offsetXY 平面方向偏移量
+     * @param offsetZ 法向偏移量
+     * @param directionZ 偏置 z 方向
+     */
+    static curve3dsByOffsets(curves: Curve3[], offsetXY: number, offsetZ: number, directionZ?: Vec3, tol?: Tol): {
+        loops: Curve3[][];
+        evolution: EvolutionMap<Curve3>;
+    };
+    /**
+     * 根据给定偏移量，偏置平面曲线，传入曲线请保证首尾相接
+     * @param curves 待偏置的曲线组
+     * @param offsetDist 平面方向偏移量。关于偏移方向：从directionZ方向看过去，曲线的左边的offset为负；右边offset为正
+     */
+    static offsetCurve3dList(curves: Curve3[], offsetDist: number, directionZ: Vec3): {
+        curveList: Curve3[];
+        evolution: EvolutionMap<Curve3>;
+    };
+    /**
+     * 根据给定偏移量，偏置平面曲线闭环
+     * @param curves 待偏置的曲线组
+     * @param offsetDist 偏移量
+     * @param tol 容差
+     * @param imMerge 路径是否闭合
+     * @param offsetIndexes 偏移边index（如果不传，则所有边都偏移）
+     */
+    static offsetLoop2d(curves: Curve2[], offsetDist: number, tol?: Tol, isMerge?: boolean, offsetIndexes?: number[]): {
+        loops: Curve2[][];
+        evolution: EvolutionMap<Curve2>;
+    };
+    /**
+     * 根据给定偏移量，偏置平面曲线，保证曲线首尾相接
+     * @param curves 待偏置的曲线组
+     * @param offsetDist 平面方向偏移量。关于偏移方向：以第一条curve为准，正值的offset就是第一条curve的右边；负值的offset就是第一条curve的左边
+     */
+    static offsetCurve2dList(curves: Curve2[], offsetDist: number): {
+        curveList: Curve2[];
+        evolution: EvolutionMap<Curve2>;
+    };
+    private static _isDegeneratedCurve;
+    /**
+     * 通过延长线连接相邻曲线
+     * @param curves
+     * @param dz
+     * @param offsetXY
+     * @param tol
+     * @returns 从新曲线映射到原曲线的映射集
+     */
+    private static _connectCurves;
+    private static _makeJoints;
+    private static _findLoops;
+}

package/types/algorithm/calc_overlap.d.ts

@@ -0,0 +1,56 @@
+import { Tol } from '../base/tol';
+import { Curve2 } from '../geometry/curve2';
+import { Curve3 } from '../geometry/curve3d';
+import { Surface } from '../geometry/surface';
+import { ICurvesOverlapInfo } from './overlap/i_overlap';
+declare class CalcOverlap {
+    /**
+     * 判断曲线是否共线，不需要有重合
+     * @param curve1
+     * @param curve2
+     * @param tol
+     * @returns 返回是否共线
+     */
+    static curve2dsColinear(curve1: Curve2, curve2: Curve2, tol?: Tol): boolean;
+    /**
+     * 计算曲线与曲线重合部分
+     * @param curve1
+     * @param curve2
+     * @param tol
+     * @returns 返回曲线重合部分，若无重合部分，则返回空集
+     */
+    static curve2ds(curve1: Curve2, curve2: Curve2, tol?: Tol): ICurvesOverlapInfo[];
+    /**
+     * 判断曲线是否共线，不需要有重合
+     * @param curve1
+     * @param curve2
+     * @param tol
+     * @returns 返回是否共线
+     */
+    static curve3dsColinear(curve1: Curve3, curve2: Curve3, tol?: Tol): boolean;
+    /**
+     * 计算曲线与曲线重合部分
+     * @param curve1
+     * @param curve2
+     * @param tol
+     * @returns 返回曲线重合部分，若无重合部分，则返回空集
+     */
+    static curve3ds(curve1: Curve3, curve2: Curve3, tol?: Tol): ICurvesOverlapInfo[];
+    /**
+     * 计算曲面与曲面重合部分，不支持 SweepSurface，暂不支持 NurbsSurface
+     * @param surface1
+     * @param surface2
+     * @param tol
+     * @returns 当两个曲面重合时返回 true
+     */
+    static isSurfacesCoplaner(surface1: Surface, surface2: Surface, tol?: Tol): boolean;
+    /**
+     * 计算曲线与曲面重合部分，不支持 SweepSurface，暂不支持 NurbsSurface
+     * @param curve1
+     * @param surface
+     * @param tol
+     * @returns 返回曲线与曲面是否重合
+     */
+    static isCurveSurfaceOverlap(curve1: Curve3, surface: Surface, tol?: Tol): boolean;
+}
+export { CalcOverlap, CalcOverlap as Overlap };

package/types/algorithm/calc_project.d.ts

@@ -0,0 +1,29 @@
+import { Ln2 } from '../geometry/ln2';
+import { Curve2 } from '../geometry/curve2';
+import { Plane } from '../geometry/plane';
+import { Curve3 } from '../geometry/curve3d';
+import { Ln3 } from '../geometry/ln3';
+import { Interval } from '../base/interval';
+import { Coord3 } from '../base/coord3';
+/**
+ * 投影算法
+ */
+export declare class Project {
+    /**
+     * curve沿coordinate z轴向coordinate XOY面投影. 调用此接口请保证曲线必须在coord的XOY平面上。
+     */
+    static curve3dTo2d(curve: Curve3, coord: Coord3): Curve2 | undefined;
+    /**
+     * (支持斜投影)将三维曲线投影到平面上，得到在平面上的二维投影。与curve3dTo2d的区别是，curve3d可以不在平面上。
+     */
+    static curveToPlane(curve: Curve3, plane: Plane): Curve2 | undefined;
+    /**
+     * line1向line2投影，返回一个区间，该区间代表投影后的线在line2参数域上的区间
+     */
+    static line1ToLine2(line1: Ln2, line2: Ln2): Interval;
+    static line1ToLine2(line1: Ln3, line2: Ln3): Interval;
+    /**
+     * 将二维曲线根据坐标系转换至三维空间
+     */
+    static curve2dTo3d(curve: Curve2, coord: Coord3): Curve3;
+}