@ccpc/math 0.1.0 → 0.1.7

package/types/algorithm/mesh/mesh_util.d.ts

@@ -0,0 +1,115 @@
+import { Box2 } from '../../base/box2';
+import { Box3 } from '../../base/box3';
+import { Coord3 } from '../../base/coord3';
+import { Ln3 } from '../../geometry/ln3';
+import { Surface } from '../../geometry/surface';
+import { types } from '../../type_define/i_types';
+import { IMesh2d } from '../discrete/discrete_refiner';
+import { BrepBody, Shell } from '../../brep-src';
+import { DiscreteParam } from '../..';
+import { Curve3, Polygon } from '../..';
+export declare class MeshUtil {
+    /**
+     *
+     * @param box
+     * @param mesh 被切割mesh
+     * @param fillClip 是否对切割mesh补面
+     */
+    static boxClip(box: types.IFlatMesh, mesh: types.IFlatMesh, fillClip?: boolean): types.IFlatMesh;
+    static createFlatMeshByMesh2d(mesh2d: IMesh2d, surface?: Surface): types.IFlatMesh;
+    static createFlatMesh(): types.IFlatMesh;
+    static createFlatMeshByBox2(box: Box2, z?: number): types.IFlatMesh;
+    static createFlatMeshByBox3(box: Box3): types.IFlatMesh;
+    static toFlatMesh(mesh: types.IMesh): types.IFlatMesh;
+    static toMesh(mesh: types.IFlatMesh): types.IMesh;
+    static clone<MeshType extends types.IFlatMesh>(mesh: MeshType): MeshType;
+    static merge(...meshes: types.IFlatMesh[]): types.IFlatMesh;
+    /**
+     * 将 mesh 投影到 xy 平面，并返回其轮廓线
+     * @param mesh
+     * @returns 返回的轮廓线按含内环多边形列表进行组织
+     */
+    static getContour(mesh: types.IFlatMesh): types.IXY[][][];
+    /**
+     * 计算 mesh 与 line 的交点
+     * @param mesh
+     * @param line
+     * @returns 返回交点在 line 上的参数，并按从小到大排序
+     */
+    static intersectLine(mesh: types.IFlatMesh, line: Ln3): number[];
+    /**
+     * 裁切 mesh，仅保留 plane 上方的三角面片。方法支持多组 uv,支持多组mesh,输出为裁切后的mesh以及对应的之前的mesh,补面生成的mesh对应为undefined
+     * @example 若有 a、b 两组 uv，则 uv 的表达为： [a0.x, a0.y, a1.x, a1.y ... aN.x, aN.y, b0.x, b0.y, b1.x, b1.y ... bN.x, bN.y]
+     * @param mesh 待裁切网格，支持多组 uv 数据
+     * @param coord 切平面所在坐标系
+     * @param fillClip 是否要对裁切面进行补面
+     * @param xRange 当指定 xRange 参数时，仅对 xRange 范围内部分进行裁切
+     * @param interpolateFunction 额外插值函数。clip 函数会默认对顶点坐标、法向、uv进行插值，可通过该插值函数进行额外插值。例如，对于含有骨骼的模型，可传入 MeshUtil.clipBoneInterpolation
+     */
+    static clipSeperate<MeshType extends types.IFlatMesh>(meshes: MeshType[], coord: Coord3, fillClip?: boolean, xRange?: types.IInterval[], interpolateFunction?: (oldMesh: MeshType, newMesh: MeshType, vertexIndex1: number, vertexIndex2: number, weight1: number) => void): Map<MeshType, MeshType | undefined>;
+    /**
+     * 裁切 mesh，仅保留 plane 上方的三角面片。方法支持多组 uv。
+     * @example 若有 a、b 两组 uv，则 uv 的表达为： [a0.x, a0.y, a1.x, a1.y ... aN.x, aN.y, b0.x, b0.y, b1.x, b1.y ... bN.x, bN.y]
+     * @param mesh 待裁切网格，支持多组 uv 数据
+     * @param coord 切平面所在坐标系
+     * @param fillClip 是否要对裁切面进行补面
+     * @param xRange 当指定 xRange 参数时，仅对 xRange 范围内部分进行裁切
+     * @param interpolateFunction 额外插值函数。clip 函数会默认对顶点坐标、法向、uv进行插值，可通过该插值函数进行额外插值。例如，对于含有骨骼的模型，可传入 MeshUtil.clipBoneInterpolation
+     */
+    static clip<MeshType extends types.IFlatMeshPlus>(mesh: MeshType, coord: Coord3, fillClip?: boolean, xRange?: types.IInterval, interpolateFunction?: (oldMesh: MeshType, newMesh: MeshType, vertexIndex1: number, vertexIndex2: number, weight1: number) => void): MeshType;
+    /**
+     * clip 函数可选用的插值函数
+     * @param oldMesh
+     * @param newMesh
+     * @param vertexIndex1
+     * @param vertexIndex2
+     * @param weight1
+     */
+    static clipBoneInterpolation(oldMesh: types.IBoneFlatMesh, newMesh: types.IBoneFlatMesh, vertexIndex1: number, vertexIndex2: number, weight1: number): void;
+    /**
+     * brep转mesh
+     * @param brep BrepBody
+     * @param discreteParams 离散参数
+     * @returns types.IFlatMesh
+     */
+    static brepToMesh(brep: BrepBody | Shell, discreteParams?: DiscreteParam): types.IFlatMesh;
+    /**
+     * 扫掠算法
+     * @param coordinate 扫描轮廓所在的局部坐标系
+     * @param polygon2d 扫描轮廓
+     * @param path3d 扫描路径
+     * @param discreteParams 离散参数
+     * @param adjustProfile 自动调整扫描轮廓，垂直于路径
+     * @param adjustPath 自动调整扫描路径，寻找起始路径（距离近，且角度大）
+     * @returns types.IFlatMesh
+     */
+    static sweep(coordinate: Coord3, polygon2d: Polygon, path3d: Curve3[], discreteParams?: DiscreteParam, adjustProfile?: boolean, adjustPath?: boolean): types.IFlatMesh;
+    /**
+     * 拉伸算法
+     * @param loop2ds 二维点集合
+     * @param coord 二维平面在三维空间中的坐标系
+     * @param offset 世界坐标系下的挤出方向
+     * @param isSmooth 法向量是否为均匀过渡，默认法向为非光滑，若指定该参数，需与loop2ds维度一致
+     */
+    static extrude(loop2ds: types.IXY[][], coord: Coord3, offset: types.IXYZ, isSmooth?: boolean[][]): types.IFlatMesh;
+    /**
+     * 拉伸算法
+     * @param loop2ds 二维点集合
+     * @param coord 二维平面在三维空间中的坐标系
+     * @param offset 世界坐标系下的挤出方向
+     * @param isSmooth 法向量是否为均匀过渡，默认法向为非光滑，若指定该参数，需与loop2ds维度一致
+     */
+    static extrudeSeperateFaces(loop2ds: types.IXY[][], coord: Coord3, offset: types.IXYZ, isSmooth?: boolean[][]): {
+        top: types.IFlatMesh;
+        bottom: types.IFlatMesh;
+        sides: types.IFlatMesh[][];
+    };
+    /**
+     * 平面切割mesh，同时计算平面切割时部分，补面的uvTransform
+     */
+    private static _clip;
+    private static _fillClip;
+    private static _fillClipSeperate;
+    private static _distanceToPlane;
+    private static _isNext;
+}

package/types/algorithm/offset/loop2d_offset.d.ts

@@ -0,0 +1,22 @@
+import { Tol } from '../../base/tol';
+import { Curve2 } from '../../geometry/curve2';
+import { EvolutionMap } from '../../topology/evolution_map';
+export declare class Loop2dOffset {
+    static execute(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 _isDegeneratedCurve2d;
+    private static _connectCurve2ds;
+    private static _makeJoints;
+    private static _findLoop2ds;
+}

package/types/algorithm/offset/polygon_offset.d.ts

@@ -0,0 +1,27 @@
+import { Polygon } from '../../topology/polygon';
+import { Curve2 } from '../../geometry/curve2';
+export interface IPolygonOffsetResult {
+    /**
+     * 偏移的结果
+     */
+    offsetPolygon: Polygon;
+    /**
+     * 结果和原始曲线之间的对应关系 new --> origin
+     */
+    evolution?: Map<Curve2, Curve2>;
+}
+/**
+ * polygon的offset
+ */
+export declare class PolygonOffset {
+    static execute(loop: Polygon, _delta: number, withEvolution?: boolean): IPolygonOffsetResult;
+    /**
+     * 偏移polygon中部分曲线
+     * @param polygon 路径
+     * @param _delta 偏移距离
+     * @param offsetIndexes 偏移曲线角标 number[][], [[loop角标, curve角标]]
+     * @param isMerge 是否合并和简化线段，默认true，如果不简化，有部分polygon可能会有一定问题。
+     */
+    static offsetCurves(polygon: Polygon, _delta: number, offsetIndexes: number[][], isMerge?: boolean): Polygon;
+    private static _calEvolution;
+}

package/types/algorithm/overlap/curve_surface_coincide.d.ts

@@ -0,0 +1,6 @@
+import { Curve3 } from '../../geometry/curve3d';
+import { Surface } from '../../geometry/surface';
+import { Tol } from '../../base/tol';
+export declare class CurveSurfaceCoincide {
+    static execute(curve: Curve3, surface: Surface, tol: Tol): boolean;
+}

package/types/algorithm/overlap/curves_colinear.d.ts

@@ -0,0 +1,38 @@
+import { Tol } from '../../base/tol';
+import { Vec } from '../../base/vec';
+import { IArc, ILine, IOffsetCurve, INurbsCurve, IExtendCurve } from '../../type_define/i_geometry';
+import { Arc2 } from '../../geometry/arc2d';
+import { Arc3 } from '../../geometry/arc3d';
+import { Ln2 } from '../../geometry/ln2';
+import { Ln3 } from '../../geometry/ln3';
+import { OffsetCurve3 } from '../../geometry/offset_curve3';
+import { OffsetCurve2 } from '../../geometry/offset_curve2';
+import { Curve3 } from '../../geometry/curve3d';
+import { Curve2 } from '../../geometry/curve2';
+import { Curve } from '../../geometry/curve';
+export declare class CurvesColinear {
+    static curve3ds(curve1: Curve3, curve2: Curve3, tol?: Tol): boolean;
+    static curve2ds(curve1: Curve2, curve2: Curve2, tol?: Tol): boolean;
+    static lines(line1: Ln2, line2: Ln2, tol?: Tol): boolean;
+    static lines(line1: Ln3, line2: Ln3, tol?: Tol): boolean;
+    static lines<VectorType extends Vec>(line1: ILine<VectorType>, line2: ILine<VectorType>, tol?: Tol): boolean;
+    static arcs(arc1: Arc3, arc2: Arc3, tol?: Tol): boolean;
+    static arcs(arc1: Arc2, arc2: Arc2, tol?: Tol): boolean;
+    static arcs<VectorType extends Vec>(arc1: IArc<VectorType>, arc2: IArc<VectorType>, tol: Tol): boolean;
+    static areArcsSameDirection<VectorType extends Vec>(arc1: IArc<VectorType>, arc2: IArc<VectorType>): boolean;
+    static offsetCurves(offCurv1: OffsetCurve3, offCurv2: OffsetCurve3, tol?: Tol): boolean;
+    static offsetCurves(offCurv1: OffsetCurve2, offCurv2: OffsetCurve2, tol?: Tol): boolean;
+    static offsetCurves<VectorType extends Vec>(offCurv1: IOffsetCurve<VectorType>, offCurv2: IOffsetCurve<VectorType>, tol: Tol): boolean;
+    static extendCurves<VectorType extends Vec>(etdCurv1: IExtendCurve<VectorType>, etdCurv2: IExtendCurve<VectorType>, tol: Tol): boolean;
+    /**
+     * 采用采样的方式，判断 crv 在 range 范围内是否与 crv0 重合
+     * @param crv0
+     * @param crv
+     * @param range
+     * @param tol
+     * @param pointCount
+     * @returns
+     */
+    static testBySamples<VectorType extends Vec>(crv0: Curve<VectorType>, crv: Curve<VectorType>, range?: import("../..").Interval, tol?: Tol, pointCount?: number): boolean;
+    static nurbsCurves<VectorType extends Vec>(nurbsCurv1: INurbsCurve<VectorType>, nurbsCurv2: INurbsCurve<VectorType>, tol: Tol): boolean;
+}

package/types/algorithm/overlap/curves_merge.d.ts

@@ -0,0 +1,74 @@
+import { Tol } from '../../base/tol';
+import { Vec } from '../../base/vec';
+import { Arc2 } from '../../geometry/arc2d';
+import { Arc3 } from '../../geometry/arc3d';
+import { Curve2 } from '../../geometry/curve2';
+import { Curve3 } from '../../geometry/curve3d';
+import { Ln2 } from '../../geometry/ln2';
+import { Ln3 } from '../../geometry/ln3';
+import { EvolutionMap } from '../../topology/evolution_map';
+import { IArc, ILine, INurbsCurve, IOffsetCurve } from '../../type_define/i_geometry';
+export declare enum MergeReverseMode {
+    merge = 0,
+    remove = 1
+}
+/**
+ * 尝试将两曲线的合并，并返回合并后的曲线
+ */
+export declare class CurvesMerge {
+    /**
+     * 将loop简化：合并相邻的共线的curve
+     * @param curves
+     * @param tol
+     */
+    static mergeLoopCurve3ds(curves: Curve3[], tol?: Tol): Curve3[];
+    static mergeCurves3ds(curves: Curve3[], tol?: Tol): Curve3[];
+    static mergeCurves2ds(curves: Curve2[], tol?: Tol): Curve2[];
+    /**
+     * 尝试合并曲线，返回合并后的结果。若无法合并，则返回 undefined
+     * @param curve1
+     * @param curve2
+     * @param mode merge：无论曲线方向，一律合并；remove：当曲线反向时，会将反向部分从合并结果中去除
+     * @param tol
+     */
+    static curve2ds(curve1: Curve2, curve2: Curve2, mode?: MergeReverseMode, tol?: Tol): Curve2[] | undefined;
+    /**
+     * 尝试合并曲线，返回合并后的结果。若无法合并，则返回 undefined
+     * @param curve1
+     * @param curve2
+     * @param mode merge：无论曲线方向，一律合并；remove：当曲线反向时，会将反向部分从合并结果中去除
+     * @param tol
+     * @returns 演化关系，从新曲线映射到旧曲线
+     */
+    static curve2dsEvolution(curve1: Curve2, curve2: Curve2, mode?: MergeReverseMode, tol?: Tol): EvolutionMap<Curve2> | undefined;
+    /**
+     * 尝试合并曲线，返回合并后的结果。若无法合并，则返回 undefined
+     * @param curve1
+     * @param curve2
+     * @param mode merge：无论曲线方向，一律合并；remove：当曲线反向时，会将反向部分从合并结果中去除
+     * @param tol
+     */
+    static curve3ds(curve1: Curve3, curve2: Curve3, mode?: MergeReverseMode, tol?: Tol): Curve3[] | undefined;
+    /**
+     * 尝试合并曲线，返回合并后的结果。若无法合并，则返回 undefined
+     * @param curve1
+     * @param curve2
+     * @param mode merge：无论曲线方向，一律合并；remove：当曲线反向时，会将反向部分从合并结果中去除
+     * @param tol
+     * @returns 演化关系，从新曲线映射到旧曲线
+     */
+    static curve3dsEvolution(curve1: Curve3, curve2: Curve3, mode?: MergeReverseMode, tol?: Tol): EvolutionMap<Curve3> | undefined;
+    static lines(line1: Ln2, line2: Ln2, mode?: MergeReverseMode, tol?: Tol): Ln2[] | undefined;
+    static lines(line1: Ln3, line2: Ln3, mode?: MergeReverseMode, tol?: Tol): Ln3[] | undefined;
+    static lines<VectorType extends Vec>(line1: ILine<VectorType>, line2: ILine<VectorType>, mode?: MergeReverseMode, tol?: Tol): ILine<VectorType>[] | undefined;
+    static linesEvolution<VectorType extends Vec>(line1: ILine<VectorType>, line2: ILine<VectorType>, mode?: MergeReverseMode, tol?: Tol): EvolutionMap<ILine<VectorType>> | undefined;
+    static arcs(arc1: Arc2, arc2: Arc2, mode?: MergeReverseMode, tol?: Tol): Arc2[] | undefined;
+    static arcs(arc1: Arc3, arc2: Arc3, mode?: MergeReverseMode, tol?: Tol): Arc3[] | undefined;
+    static arcs<VectorType extends Vec>(arc1: IArc<VectorType>, arc2: IArc<VectorType>, mode?: MergeReverseMode, tol?: Tol): IArc<VectorType>[] | undefined;
+    static arcsEvolution<VectorType extends Vec>(arc1: IArc<VectorType>, arc2: IArc<VectorType>, mode?: MergeReverseMode, tol?: Tol): EvolutionMap<IArc<VectorType>> | undefined;
+    static nurbsEvolution<VectorType extends Vec>(nurbs1: INurbsCurve<VectorType>, nurbs2: INurbsCurve<VectorType>, mode?: MergeReverseMode, tol?: Tol): EvolutionMap<INurbsCurve<VectorType>> | undefined;
+    static offsetCurvesEvolution<VectorType extends Vec>(crv1: IOffsetCurve<VectorType>, crv2: IOffsetCurve<VectorType>, mode?: MergeReverseMode, tol?: Tol): EvolutionMap<IOffsetCurve<VectorType>> | undefined;
+    private static _simpleCurves;
+    private static _nurbsRange;
+    private static _periodCurves;
+}

package/types/algorithm/overlap/curves_overlap.d.ts

@@ -0,0 +1,34 @@
+import { Tol } from '../../base/tol';
+import { Vec } from '../../base/vec';
+import { Curve2 } from '../../geometry/curve2';
+import { Curve3 } from '../../geometry/curve3d';
+import { IArc, ILine, IOffsetCurve, INurbsCurve, IExtendCurve } from '../../type_define/i_geometry';
+import { ICurvesOverlapInfo } from './i_overlap';
+import { Curve } from '../../geometry/curve';
+/**
+ * 计算两曲线的重合情况
+ */
+export declare class CurvesOverlap {
+    static curve2ds(curve1: Curve2, curve2: Curve2, tol?: Tol): ICurvesOverlapInfo[];
+    static curve3ds(curve1: Curve3, curve2: Curve3, tol?: Tol): ICurvesOverlapInfo[];
+    static lines<VectorType extends Vec>(line1: ILine<VectorType>, line2: ILine<VectorType>, tol?: Tol): ICurvesOverlapInfo[];
+    static arcs<VectorType extends Vec>(arc1: IArc<VectorType>, arc2: IArc<VectorType>, tol?: Tol): ICurvesOverlapInfo[];
+    static offsetCurves<VectorType extends Vec>(offCurv1: IOffsetCurve<VectorType>, offCurv2: IOffsetCurve<VectorType>, tol?: Tol): ICurvesOverlapInfo[] | undefined;
+    static extendCurves<VectorType extends Vec>(etdCurv1: IExtendCurve<VectorType>, etdCurv2: IExtendCurve<VectorType>, tol?: Tol): ICurvesOverlapInfo[] | undefined;
+    static nurbsCurves<VectorType extends Vec>(nurbsCurv1: INurbsCurve<VectorType>, nurbsCurv2: INurbsCurve<VectorType>, tol?: Tol): ICurvesOverlapInfo[] | undefined;
+    static generalCurves<VectorType extends Vec>(crv1: Curve<VectorType>, crv2: Curve<VectorType>, tol?: Tol, testPointCount?: number): ICurvesOverlapInfo[];
+    private static _linesOverlap;
+    private static _arcsOverlap;
+    private static _offsetCurvesOverlap;
+    private static _extendCurvesOverlap;
+    private static _nurbsCurvesOverlap;
+    /**
+     *
+     * @param crv1 openCrv
+     * @param crv2
+     * @param tol
+     * @param testPointCount
+     * @returns
+     */
+    private static _generalOpenCurves;
+}

package/types/algorithm/overlap/i_overlap.d.ts

@@ -0,0 +1,9 @@
+import { Interval } from '../../base/interval';
+export interface ICurvesOverlapInfo {
+    /** 重合段在第一条曲线上的参数 */
+    range1: Interval;
+    /** 重合段在第二条曲线上的参数 */
+    range2: Interval;
+    /** 重合段同向时为 true */
+    isSameDirection: boolean;
+}

package/types/algorithm/overlap/surfaces_coplaner.d.ts

@@ -0,0 +1,5 @@
+import { Tol } from '../../base/tol';
+import { Surface } from '../../geometry/surface';
+export declare class SurfacesCoplaner {
+    static simple(surface1: Surface, surface2: Surface, tol: Tol): boolean;
+}

package/types/algorithm/pattern/blocks2Geometry.d.ts

@@ -0,0 +1,50 @@
+import { IPoint, Paths } from "./pave";
+export declare function clipBlocks2Geometry(result: {
+    blocks: {
+        data: Map<number, Paths[] | boolean>;
+        offset: IPoint;
+    };
+    joints: Paths[];
+}[], unitDefs: {
+    joint: Paths;
+    blocks: Paths[];
+    coords: number[][][];
+}): {
+    joints: {
+        vertices: number[];
+        indices: number[];
+        uvs: number[];
+    };
+    blocks: {
+        vertices: Float32Array<ArrayBuffer>;
+        uvs: Float32Array<ArrayBuffer>;
+        indices: Uint32Array<ArrayBuffer>;
+        unitIndex: number;
+    }[];
+};
+export declare function fullBlocks2Geometry(fullBlocks: IPoint[], unitDef: {
+    joint: Paths;
+    blocks: Paths[];
+    coords: number[][][];
+}): {
+    blocks: {
+        uvs: Float32Array<ArrayBuffer>;
+        vertices: Float32Array<ArrayBuffer>;
+        indices: Uint32Array<ArrayBuffer>;
+    }[];
+    joints: {
+        vertices: Float32Array<ArrayBuffer>;
+        indices: Uint32Array<ArrayBuffer>;
+        uvs: Float32Array<ArrayBuffer>;
+    };
+};
+/**
+ * 三角化
+ * @param paths
+ * @returns
+ */
+export declare function triangle(paths: Paths): {
+    uvs: number[];
+    indices: number[];
+    vertices: number[];
+};

package/types/algorithm/pattern/math.d.ts

@@ -0,0 +1,42 @@
+import { Paths64, PolyPath64 } from 'clipper2-wasm/dist/clipper2z';
+import { IPoint, Path, Paths } from './pave';
+export interface Point<T extends bigint | number> {
+    x: T;
+    y: T;
+}
+export declare function dot(v1: IPoint, another: IPoint): number;
+export declare function getUVMinMax(uDirNormal: IPoint, vDirNormal: IPoint, path: IPoint[], origin: IPoint): {
+    uMin: number;
+    uMax: number;
+    vMin: number;
+    vMax: number;
+};
+export declare function getParamAtUV(uDirNormal: IPoint, vDirNormal: IPoint, another: IPoint): number[];
+export declare function getPointAt(dir: IPoint, param: number): {
+    x: number;
+    y: number;
+};
+/**
+ *
+ * @param data  [
+                [this._xDir.x, this._xDir.y, 0],
+                [this._yDir.x, this._yDir.y, 0],
+                [this._origin.x, this._origin.y, 1],
+            ],
+ */
+export declare function applyMatrix(arr: number[], start: number, matrix: number[][]): void;
+export declare function applyMatrixToPt(pt: IPoint, matrix: number[][]): {
+    x: number;
+    y: number;
+};
+export declare function multiplyMatrix(A: number[][], B: number[][]): number[][];
+export declare function inv(square: number[][]): number[][];
+export declare function getBBox(bg: IPoint[][], offset?: number): {
+    right: number;
+    left: number;
+    bottom: number;
+    top: number;
+};
+export declare function convert2Js(solution: Paths64, precise: number): Paths;
+export declare function toArray(path: Path, reversed?: boolean): number[];
+export declare function addPolyPathToResult(solution: PolyPath64, joints: Paths[], precise: number, holes: Point<bigint>[][]): void;

package/types/algorithm/pattern/pattern.d.ts

@@ -0,0 +1,43 @@
+import { IPoint, Paths } from './pave';
+import { IPavePattern, IPolygon } from './pattern_util';
+export declare class Pattern {
+    private precise;
+    private recOffset;
+    private jointOffset;
+    private _clip;
+    private _clipLines;
+    private _unitJoints;
+    private _unitsBlock;
+    private _holes;
+    private _unitRect;
+    private _unitsPaths;
+    private _bgRects;
+    patternData: IPavePattern;
+    private _clipper;
+    private _enableGap;
+    constructor(patternData: IPavePattern, background: IPolygon, enableGap?: boolean);
+    getUnit(): {
+        joint: Paths;
+        blocks: Paths[];
+        coords: number[][][];
+    };
+    /**
+     * 单元box与边界是否相交
+     * @param offset
+     * @returns  -1: outer, 0: 不与线相交， 1： 与线相交, 2: box中有洞
+     */
+    isUnitXBackground(offset: IPoint): 2 | 1 | 0 | -1;
+    /**
+     * 计算clip
+     * @param offset 偏移
+     * @param canUseHole 是否可以使用切砖缝的洞作为砖
+     * @returns
+     */
+    execute(offset: IPoint, canUseHole?: boolean): {
+        blocks: {
+            data: Map<number, boolean | Paths[]>;
+            offset: IPoint;
+        };
+        joints: Paths[];
+    } | undefined;
+}

package/types/algorithm/pattern/pattern_util.d.ts

@@ -0,0 +1,53 @@
+import { Coord2, Curve2 } from '../..';
+import { types } from '../../type_define/i_types';
+import { IPoint, Paths } from './pave';
+export declare class RegionMesh {
+    buffer: types.IFlatMesh;
+    material: number;
+}
+export declare class IPavePattern {
+    gap: {
+        unit: number;
+        material: number;
+    };
+    units: {
+        outer: Curve2[];
+        holes: Curve2[][];
+        materials: number[];
+        seed: number;
+        coord: Coord2;
+    }[];
+    udir: types.IXY;
+    vdir: types.IXY;
+    coord: Coord2;
+}
+export declare class IPolygon {
+    outer: Curve2[];
+    holes: Curve2[][];
+}
+export declare class PatternUtil {
+    /**
+     * 铺贴
+     * @param pattern 铺贴模板
+     * @param background 铺贴区域
+     * @param enableGap 是否生成砖缝
+     * @returns
+     */
+    static getRegionMesh(pavePattern: IPavePattern, background: IPolygon, enableGap?: boolean): RegionMesh[];
+    static executeClip(patternData: IPavePattern, background: IPolygon, enableGap?: boolean): {
+        clipBlocks: {
+            blocks: {
+                data: Map<number, Paths[] | boolean>;
+                offset: IPoint;
+            };
+            joints: Paths[];
+        }[];
+        fullBlocks: IPoint[];
+        unit: {
+            joint: Paths;
+            blocks: Paths[];
+            coords: number[][][];
+        };
+    };
+    private static geos2IMesh;
+}

package/types/algorithm/pattern/pave.d.ts

@@ -0,0 +1,33 @@
+import { MainModule } from "clipper2-wasm/dist/clipper2z";
+export interface IPoint {
+    x: number;
+    y: number;
+}
+export type Path = IPoint[];
+export type Paths = Path[];
+export declare const allUnits: {
+    x: number;
+    y: number;
+}[][];
+export declare const unit: {
+    x: number;
+    y: number;
+}[];
+export declare const unitBlock: {
+    x: number;
+    y: number;
+}[];
+export declare function toArray(path: Path, reversed?: boolean): number[];
+export declare function clipBlock(unit: Path, block: Path, bg: Paths, clipperLib: MainModule): (offset: IPoint, onlyEdgeX?: boolean) => {
+    joint: Paths;
+    tile: Paths;
+    isX: boolean;
+    isFull: boolean;
+    offset: IPoint;
+} | undefined;
+export declare function getBBox(bg: IPoint[]): {
+    maxX: number;
+    minX: number;
+    maxY: number;
+    minY: number;
+};

package/types/algorithm/pj/curves_oj.d.ts

@@ -0,0 +1,19 @@
+import { Curve } from '../../geometry/curve';
+import { CurvesPJType } from './pj_type';
+import { Vec } from '../../base/vec';
+import { Interval } from '../../base/interval';
+export interface ISimpleXInfo {
+    param1: number;
+    param2: number;
+    isOverlap: boolean;
+    overlap1?: Interval;
+    overlap2?: Interval;
+    overlapDirection?: boolean;
+}
+/**
+ *
+ * 两曲线间的重叠关系判断：不重叠、重叠、完全重叠
+ */
+export declare class CurvesOverlapJudge {
+    static execute<PointType extends Vec>(curve1: Curve<PointType>, curve2: Curve<PointType>, distanceTol?: number, angleTol?: number): CurvesPJType;
+}

package/types/algorithm/pj/curves_pj.d.ts

@@ -0,0 +1,19 @@
+import { CurvesPJType } from './pj_type';
+import { Vec } from '../../base/vec';
+import { Curve } from '../../geometry/curve';
+/**
+ * #### 2.两曲线间的位置关系`curveToCurve`：重叠，相交，不相交
+ */
+declare class CurvesPJ {
+    /**
+     * 曲线与曲线的位置关系判断:相交，重叠，不相交
+     *
+     * 支持 Ln2 Arc2
+     * @param curve1
+     * @param curve2
+     * @param tolerance
+     * @returns `CurvesPJType`
+     */
+    static execute<PointType extends Vec>(curve1: Curve<PointType>, curve2: Curve<PointType>, distanceTol?: number, angleTol?: number): CurvesPJType;
+}
+export { CurvesPJ };

package/types/algorithm/pj/loops_pj.d.ts

@@ -0,0 +1,13 @@
+import { LoopsPJType } from './pj_type';
+import { Loop } from '../../topology/loop';
+declare class LoopsPJ {
+    /**
+     * Loop1与Loop2的位置关系判断,以loop2位基准
+     * @param loop1
+     * @param loop2
+     * @param tolerance
+     */
+    static execute(loop1: Loop, loop2: Loop, tol?: number, tangentIsIntersect?: boolean): LoopsPJType;
+    private static _polygonIsValid;
+}
+export { LoopsPJ };

package/types/algorithm/pj/pj_type.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 曲线间位置关系类型
+ *
+ * 重叠，十位数为1：
+ * - OVERLAP 部分或完全重叠x
+
+
+
+ *
+ * 相交，十位数为2
+ * - INTERSECT_IN 在曲线内部相交
+ * - INTERSECT_ON 在曲线端点处相交
+ *
+ * 不相交（为0）
+ * - NOT_INTERSECT 不相交
+ */
+declare enum CurvesPJType {
+    NOT_INTERSECT = 0,
+    OVERLAP = 10,
+    TOTALLY_OVERLAP = 11,
+    INTERSECT_IN = 21,
+    INTERSECT_ON = 22
+}
+/**
+ * 点与loop的关系类型:
+ * - OUT 点在loop外部
+ * - ON  点在loop边界上
+ * - IN 点在loop内部
+ */
+declare enum PtLoopPJType {
+    OUT = 0,
+    ONEDGE = -1,
+    ONVERTEX = -2,
+    IN = 1
+}
+/**
+ * loop与loop的关系
+ */
+declare enum LoopsPJType {
+    INTERSECT = "x",
+    EQUAL = "eq",
+    IN = "in",
+    CONTAIN = "ct",
+    OUT = "out"
+}
+export { CurvesPJType, PtLoopPJType, LoopsPJType };