@ccpc/math 0.1.0 → 0.1.7

package/types/algorithm/calc_x.d.ts

@@ -0,0 +1,215 @@
+import { Curve2 } from '../geometry/curve2';
+import { Curve3 } from '../geometry/curve3d';
+import { Surface } from '../geometry/surface';
+import { ICurvesXInfo2d, ICurvesXInfo3d, ICvSurfXInfo, ISurfacesXInfo } from './intersect/x_info';
+import { Tol } from '../base/tol';
+import { Interval } from '../base/interval';
+import { Vec3 } from '../base/vec3';
+import { Vec2 } from '../base/vec2';
+import { types } from '../type_define/i_types';
+import { Polygon } from '../topology/polygon';
+/**
+ * 几何元素求交，线线求交，线面求交
+ */
+declare class X {
+    /**
+     * 曲线与曲线的交点，目前支持Line2d与Line2d的交点, Line2d和Arc2d的交点，Arc2d和Arc2d的交点
+     * 若两曲线重合，则交点为重合段内的某个交点
+     * @param curve1
+     * @param curve2
+     * @param tol 容差
+     */
+    static curve2ds(curve1: Curve2, curve2: Curve2, tol?: Tol): ICurvesXInfo2d[];
+    /**
+     * 曲线与曲线的交点
+     * 若两曲线重合，则交点为重合段内的某个交点
+     * @param curve1
+     * @param curve2
+     * @param tol 容差
+     */
+    static curve3ds(curve1: Curve3, curve2: Curve3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 在给定点附近，计算曲线与曲线的交点
+     * @param curve1
+     * @param curve2
+     * @param point 二维维参考点
+     */
+    static curve2dsNearPoint(curve1: Curve2, curve2: Curve2, point: Vec2, tol?: Tol): ICurvesXInfo2d | undefined;
+    /**
+     * 在给定参数附近，计算曲线与曲线的交点
+     * @param curve1
+     * @param curve2
+     * @param param1 curve1 上的参考参数
+     * @param param2 curve2 上的参考参数
+     */
+    static curve2dsNearParams(curve1: Curve2, curve2: Curve2, param1: number, param2: number, tol?: Tol): ICurvesXInfo2d | undefined;
+    /**
+     * 在给定点附近，计算曲线与曲线的交点
+     * @param curve1
+     * @param curve2
+     * @param point 三维参考点
+     */
+    static curve3dsNearPoint(curve1: Curve3, curve2: Curve3, point: Vec3, tol?: Tol): ICurvesXInfo3d | undefined;
+    /**
+     * 在给定参数附近，计算曲线与曲线的交点
+     * @param curve1
+     * @param curve2
+     * @param param1 curve1 上的参考参数
+     * @param param2 curve2 上的参考参数
+     */
+    static curve3dsNearParams(curve1: Curve3, curve2: Curve3, param1: number, param2: number, tol?: Tol): ICurvesXInfo3d | undefined;
+    /**
+     * 二维曲线间的重合判断
+     * @param curve1
+     * @param curve2
+     * @param tol
+     * @deprecated 请使用 Overlap.Curve2ds 替代
+     */
+    static curve2dsOverlap(curve1: Curve2, curve2: Curve2, tol?: Tol): ICurvesXInfo2d[];
+    /**
+     * 三维曲线间的重合判断
+     * @param curve1
+     * @param curve2
+     * @param tol
+     * @deprecated 请使用 Overlap.Curve3ds 替代
+     */
+    static curve3dsOverlap(curve1: Curve3, curve2: Curve3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 二维曲线的自交点计算，主要针对nurbs曲线和extend曲线。(目前还未完善，计算自交点不全，不建议外部使用)
+     * @param curve
+     * @param tol
+     */
+    static curve2dSelfX(curve: Curve2, tol?: Tol): ICurvesXInfo2d[];
+    /**
+     * 判断二维曲线是否自相交
+     * @param curve
+     * @param tol
+     * @returns
+     */
+    static isCurve2dSelfX(curve: Curve2, tol?: Tol): boolean;
+    /**
+     * 三维曲线的自交点计算，主要针对nurbs曲线和extend曲线。(目前还未完善，计算自交点不全，不建议外部使用)
+     * @param curve
+     * @param tol
+     */
+    static curve3dSelfX(curve: Curve3, tol?: Tol): ICurvesXInfo3d[];
+    /**
+     * 计算三维曲线与曲面的交点集
+     * @param curve 曲线
+     * @param surface 曲面
+     * @param tol 容差
+     * @param surfRangeUV 给定曲面的参数域UV
+     * @returns 交可能不止一个，故返回交点的数组
+     */
+    static curveSurface(curve: Curve3, surface: Surface, tol?: Tol, surfRangeUV?: Interval[]): Vec3[];
+    /**
+     * 三维曲线与曲面的交：可能包含交线，交点
+     * @param curve 曲线
+     * @param surface 曲面
+     * @param tol 容差
+     * @param surfRangeUV 给定曲面的参数域UV
+     * @returns 交可能不止一个，故返回交点的数组
+     */
+    static curveSurfaceAll(curve: Curve3, surface: Surface, tol?: Tol, surfRangeUV?: Interval[]): ICvSurfXInfo[];
+    /**
+     * 给定一个参考点，返回距离参考点最近的一个交点
+     * @param curve  曲线
+     * @param surface 曲面
+     * @returns 交点
+     */
+    static curveSurfaceNearPoint(curve: Curve3, surface: Surface, refPoint: Vec3, tol?: Tol): Vec3 | undefined;
+    /**
+     * 给定一个参考参数uv和t，返回附近的一个交点
+     * @param curve  曲线
+     * @param surface 曲面
+     * @returns 交点
+     */
+    static curveSurfaceNearParams(curve: Curve3, surface: Surface, refT: number, refUV: types.IXY, tol?: Tol): Vec3 | undefined;
+    /**
+     * 判断曲线曲面是否有交
+     * @param curve 曲线
+     * @param surface 曲面
+     * @param surfBoundary 曲面的参数区间
+     * @returns 返回是否有交
+     */
+    static isIntersectCurveSurface(curve: Curve3, surface: Surface, surfBoundary?: Polygon, tol?: Tol): boolean;
+    /**
+     * ！！！注意：暂不完善，请不要调用此接口
+     * 曲面与曲面相交：可能为交线，交点，或者重合的surface
+     * 使用建议：求交最好能传入求交曲面的大概参数域，特别是对于平面、柱面、锥面这样参数域无穷大的，传入UV有利于提高计算效率
+     * @param surf1 曲面1
+     * @param surf2 曲面2
+     * @param rangeU1 曲面1的参数域U
+     * @param rangeV1 曲面1的参数域V
+     * @param rangeU2 曲面2的参数域U
+     * @param rangeV2 曲面2的参数域V
+     * @param tol:
+     * @returns 交线可能不止一条，故返回交线的数组
+     */
+    static surfaces(surf1: Surface, surf2: Surface, rangeU1?: Interval, rangeV1?: Interval, rangeU2?: Interval, rangeV2?: Interval, tol?: Tol): ISurfacesXInfo[];
+    /**
+     * ！！！注意：暂不完善，请不要调用此接口
+     * 曲面与曲面相交: 只返回交线（忽略交点、重合面），重合的情况返回重合区域边界curve3d
+     * 使用建议：求交最好能传入求交曲面的大概参数域，特别是对于平面、柱面、锥面这样参数域无穷大的，传入UV有利于提高计算效率
+     * @param surf1 曲面1
+     * @param surf2 曲面2
+     * @param rangeU1 曲面1的参数域U
+     * @param rangeV1 曲面1的参数域V
+     * @param rangeU2 曲面2的参数域U
+     * @param rangeV2 曲面2的参数域V
+     * @param tol
+     * @returns 交线可能不止一条，故返回交线的数组
+     */
+    static surfacesSimplified(surf1: Surface, surf2: Surface, rangeU1?: Interval, rangeV1?: Interval, rangeU2?: Interval, rangeV2?: Interval, tol?: Tol, useHighPrecision?: boolean, convertToNurbs?: boolean): Curve3[];
+    /**
+     * 曲面与曲面相交: 给定一个参考点，返回交线距离参考点最近的一条交线（使用简单方法计算交线，不使用混合求交方法，没有surfacesNearPoint方法稳定）
+     * @param surf1 曲面
+     * @param surf2 曲面
+     * @param refPoint 参考点，最好是交线上的点，或者是距离交线很近的点
+     * @param refDir 参考点位置的参考切向
+     * @returns 返回距离参考点最近的一条交线 // 如果没有交线或者计算失败返回undefined
+     */
+    static surfacesNearPointSimple(surf1: Surface, surf2: Surface, refPoint: Vec3, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    /**
+     * 曲面与曲面相交: 给定两个点之间的交线段。用于已经计算到了交线curve的两个端点，需要求出两点之间的那一段交线。
+     * @param surf1 曲面
+     * @param surf2 曲面
+     * @param point1 交线上的起点
+     * @param point2 交线上的终点
+     * @param refDir 起点位置的参考切向.如果交线是周期性的，建议给出refDir，否则不知道取哪一段交线（类似圆被分割为两段，取优弧还是劣弧）
+     * @returns 返回距离参考点最近的一条交线 // 如果没有交线或者计算失败返回undefined
+     */
+    static surfacesBetweenTwoPoints(surf1: Surface, surf2: Surface, point1: Vec3, point2: Vec3, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    /**
+     * 曲面与曲面相交: 给定一个参考点，返回交线距离参考点最近的一条交线
+     * @param surf1 曲面
+     * @param surf2 曲面
+     * @param refPoint 参考点，最好是交线上的点，或者是距离交线很近的点
+     * @param refDir 参考点位置的参考切向
+     * @param tol 求交容差参数
+     * @param useHighPrecision 是否使用高精度求交
+     * @param convertToNurbs 是否将求交结果为IntersectCurve3d的转为nurbs曲线
+     * @returns 返回距离参考点最近的一条交线 // 如果没有交线或者计算失败返回undefined
+     */
+    static surfacesNearPoint(surf1: Surface, surf2: Surface, refPoint: Vec3, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean, convertToNurbs?: boolean): Curve3 | undefined;
+    /**
+     * 给定一个参考点，返回交线距离参考点最近的交线（可用于曲面自交求交线）
+     * @param surf1 曲面
+     * @param surf2 曲面
+     * @param refUV1 参考uv
+     * @param refUV2 参考uv
+     * @param refDir 参考点位置的参考切向
+     * @returns 返回距离参考点最近的一条自交交线 // 如果没有交线或者计算失败返回undefined
+     */
+    static surfacesNearParams(surf1: Surface, surf2: Surface, refUV1: types.IXY, refUV2: types.IXY, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+    /**
+     * 曲面自交求交线: 给定一个参考点，返回交线距离参考点最近的交线
+     * @param surf 曲面
+     * @param refUV1 参考uv
+     * @param refUV2 参考uv
+     * @param refDir 参考点位置的参考切向
+     * @returns 返回距离参考点最近的一条自交交线 // 如果没有交线或者计算失败返回undefined
+     */
+    static surfacesSelfIntersect(surf: Surface, refUV1: types.IXY, refUV2: types.IXY, refDir?: Vec3, tol?: Tol, useHighPrecision?: boolean): Curve3 | undefined;
+}
+export { X };

package/types/algorithm/calculate_util/geometry_subdevide_infos.d.ts

@@ -0,0 +1,73 @@
+import { Interval } from '../../base/interval';
+import { Curve3 } from '../../geometry/curve3d';
+import { Curve2 } from '../../geometry/curve2';
+import { Box3 } from '../../base/box3';
+import { Surface } from '../../geometry/surface';
+import { Vec2 } from '../../base/vec2';
+import { Box2 } from '../../base/box2';
+import { Vec3 } from '../../base/vec3';
+import { Vec } from '../../base/vec';
+import { Curve } from '../../geometry/curve';
+import { Box } from '../../base/box';
+export declare abstract class CurveSegment<VectorType extends Vec> {
+    static getEndPoints<VectorType extends Vec>(segs: CurveSegment<VectorType>[]): VectorType[];
+    static subdivideCurveSegment<VectorType extends Vec>(curveSeg: CurveSegment<VectorType>, subCurveSegs: CurveSegment<VectorType>[]): void;
+    curve: Curve<VectorType>;
+    range: Interval;
+    child: CurveSegment<VectorType>[];
+    depth: number;
+    protected _box?: Box<VectorType>;
+    abstract getSegBox(): Box2 | Box3;
+}
+export declare class Curve2dSegment extends CurveSegment<Vec2> {
+    curve: Curve2;
+    child: Curve2dSegment[];
+    protected _box?: Box2;
+    constructor(curv: Curve2);
+    getSegBox(): Box2;
+}
+export declare class Curve3dSegment extends CurveSegment<Vec3> {
+    curve: Curve3;
+    child: Curve3dSegment[];
+    protected _box?: Box3;
+    constructor(curv: Curve3);
+    getSegBox(): Box3;
+}
+export declare class CurveSegmentPair<VectorType extends Vec> {
+    static combineCurveSegmentPairs<VectorType extends Vec>(curveSegmentPairs: CurveSegmentPair<VectorType>[], newCurveSegmentPairs: CurveSegmentPair<VectorType>[]): boolean;
+    static refreshCurveSegments<VectorType extends Vec>(curveSegmentPair: CurveSegmentPair<VectorType>[], curveSegments1: CurveSegment<VectorType>[], curveSegments2: CurveSegment<VectorType>[]): void;
+    protected _segment1: CurveSegment<VectorType>;
+    protected _segment2: CurveSegment<VectorType>;
+    get segment1(): CurveSegment<VectorType>;
+    get segment2(): CurveSegment<VectorType>;
+    protected _boxMinDist?: number;
+    constructor(segm1: CurveSegment<VectorType>, segm2: CurveSegment<VectorType>);
+    getTwoBoxsMinDistance(): number;
+}
+export declare class Curve2dSegmentPair extends CurveSegmentPair<Vec2> {
+    get segment1(): Curve2dSegment;
+    get segment2(): Curve2dSegment;
+}
+export declare class Curve3dSegmentPair extends CurveSegmentPair<Vec3> {
+    get segment1(): Curve3dSegment;
+    get segment2(): Curve3dSegment;
+}
+export declare class SurfacePatch {
+    static subdivideSurfacePatch(surfPatch: SurfacePatch, maxSubTimes?: number): SurfacePatch[];
+    surface: Surface;
+    rangeU: Interval;
+    rangeV: Interval;
+    child: SurfacePatch[];
+    depth: number;
+    private _box?;
+    constructor(surf: Surface, rangeUV?: Interval[]);
+    getPatchBox3d(): Box3;
+}
+export interface ICurveSurfacePair {
+    segment: Curve3dSegment;
+    patch: SurfacePatch;
+}
+export interface ISurfacePatchPair {
+    patch1: SurfacePatch;
+    patch2: SurfacePatch;
+}

package/types/algorithm/calculate_util/iterative_method.d.ts

@@ -0,0 +1,30 @@
+import { Tol } from '../../base/tol';
+import { Vec } from '../../base/vec';
+import { Vec2 } from '../../base/vec2';
+import { Vec3 } from '../../base/vec3';
+import { Curve } from '../../geometry/curve';
+import { Curve3 } from '../../geometry/curve3d';
+import { Surface } from '../../geometry/surface';
+import { types } from '../../type_define/i_types';
+export interface ICurvePtInfo<PointType extends Vec> {
+    t: number;
+    pt: PointType;
+}
+export interface ICurve2dPtInfo extends ICurvePtInfo<Vec2> {
+}
+export interface ICurve3dPtInfo extends ICurvePtInfo<Vec3> {
+}
+export interface ISurfacePtInfo {
+    uv: types.IXY;
+    pt: Vec3;
+}
+export declare function calSurfaceFootParamIteratively(pt: Vec, surf: Surface, refT: types.IXY, tol?: number): ISurfacePtInfo | undefined;
+export declare function estimateRootMultiplicity(sqrDistProportions: number[]): number;
+export declare function calcNextCurvesIteration<VectorType extends Vec>(curve1: Curve<VectorType>, curve2: Curve<VectorType>, iteration: number[]): number[];
+export declare function curvesIteration<VectorType extends Vec>(curve1: Curve<VectorType>, curve2: Curve<VectorType>, params: number[], tol?: Tol): boolean;
+export declare function calcNextSurfaceSurfaceIterationSimple(surface1: Surface, surface2: Surface, iteration: types.IXY[]): number[];
+export declare function calcNextSurfaceSurfaceIteration(surface1: Surface, surface2: Surface, iteration: types.IXY[]): number[];
+export declare function calcNextIterationCurveSurface(curve: Curve3, surf: Surface, iteration: number[], newIteration: number[]): boolean;
+export declare function calcNextIterationThreeSurfaces(surface1: Surface, surface2: Surface, surface3: Surface, iteration: types.IXY[]): number[];
+export declare function surfaceSurfaceIteration(surface1: Surface, surface2: Surface, iteration: types.IXY[], lengthEps?: number, normalIteration?: boolean): boolean;
+export declare function threeSurfacesIteration(surface1: Surface, surface2: Surface, surface3: Surface, iteration: types.IXY[], lengthEps?: number): boolean;

package/types/algorithm/discrete/discrete_curve.d.ts

@@ -0,0 +1,31 @@
+import { DiscreteParam } from '../../base/discrete_param';
+import { Vec } from '../../base/vec';
+import { Vec2 } from '../../base/vec2';
+import { Vec3 } from '../../base/vec3';
+import { Curve } from '../../geometry/curve';
+import { types } from '../../type_define/i_types';
+export interface IParamedPoint<PointType extends Vec> {
+    point: PointType;
+    param: number;
+}
+export type IParamedPoint2d = IParamedPoint<Vec2>;
+export type IParamedPoint3d = IParamedPoint<Vec3>;
+export declare class DiscreteCurve {
+    /**
+     * 离散三维曲线
+     * @param curve 曲线
+     * @param params 离散参数
+     */
+    static execute<PointType extends Vec>(curve: Curve<PointType>, params: DiscreteParam): {
+        point: PointType;
+        param: number;
+    }[];
+    static nurbsDiscrete<PointType extends Vec>(curve: Curve<PointType>, start: number, end: number, params: DiscreteParam): {
+        point: PointType;
+        param: number;
+    }[];
+    static general<PointType extends Vec>(getPoint: (t: number) => PointType, getTangent: (t: number) => PointType, range: types.IInterval, singularities: number[] | undefined, params: DiscreteParam): IParamedPoint<PointType>[];
+    static getSpecificParams<PointType extends Vec>(curve: Curve<PointType>, params: DiscreteParam): DiscreteParam;
+    private static _getArcHintSegment;
+    private static _getNurbsHintSegment;
+}

package/types/algorithm/discrete/discrete_refiner.d.ts

@@ -0,0 +1,35 @@
+import { Vec3 } from '../../base/vec3';
+import { Surface } from '../../geometry/surface';
+import { types } from '../../type_define/i_types';
+import { DiscreteParam } from '../../base/discrete_param';
+export interface IMesh2d {
+    vertices: types.IXY[];
+    faces: number[];
+}
+export declare class DiscreteRefiner {
+    static refine(surface: Surface, mesh2d: IMesh2d, params?: DiscreteParam): types.IMesh;
+    surface: Surface;
+    uvs: types.IXY[];
+    faces: number[];
+    params: DiscreteParam;
+    pts: Vec3[];
+    private _twinMap;
+    private _nodeMap;
+    private _queue;
+    private constructor();
+    private _execute;
+    private _init;
+    private _getNodeIndex;
+    private _remesh;
+    /** 对需要优化拆分的边进行排序 */
+    private _enQueue;
+    /** 拆分三角边 */
+    private _dequeue;
+    /**
+     * split triangle
+     * @param fi coedge to split
+     * @param idx3 new point's index
+     * @param toenQueue new coedges to enqueue
+     */
+    private _splitCoedge;
+}

package/types/algorithm/discrete/discrete_surface.d.ts

@@ -0,0 +1,74 @@
+import { DiscreteParam } from '../../base/discrete_param';
+import { Tol } from '../../base/tol';
+import { Vec3 } from '../../base/vec3';
+import { Curve2 } from '../../geometry/curve2';
+import { Curve3 } from '../../geometry/curve3d';
+import { Surface } from '../../geometry/surface';
+import { types } from '../../type_define/i_types';
+import { IMesh2d } from './discrete_refiner';
+export type IDirectedCurve = IDirectedCurve2d | IDirectedCurve3d;
+export interface IDirectedCurve3d {
+    curve: Curve3;
+    isSameDirection: boolean;
+    startPoint: Vec3;
+    endPoint: Vec3;
+    discretePts?: Vec3[];
+}
+export interface IDirectedCurve2d {
+    pCurve: Curve2;
+}
+export declare class DiscreteSurface {
+    /**
+     * 根据各参数曲线的离散结果来离散曲面。圆柱、圆锥支持跨周期域造型，椭球暂不支持跨周期域造型（受插点时的内外判定算法限制）
+     * @param surface 待离散的曲面
+     * @param curveLoops 由有向曲线组成的 Loops。第一个 Loop 为外环，其余为内环。数据会根据需要优化
+     * @param surfaceDirection 离散结果是否与曲面默认方向一致
+     * @param params 离散参数
+     * @param tol 计算容差
+     * @param constrainPt3ds 边界约束点
+     */
+    static execute(surface: Surface, curveLoops: IDirectedCurve[][], surfaceDirection?: boolean, params?: DiscreteParam, tol?: Tol, constrainPt3ds?: Vec3[]): types.IMesh;
+    /**
+     * 根据已知曲面的loop2ds的离散点，计算surface的离散mesh数据
+     * @param surface 曲面
+     * @param pt2dsFromLoops loop2ds的离散点，二维数组。一个loop一个数组，多个loop就是二维数组
+     * @param surfaceDirection face方向是否与surface同向
+     * @param params 离散参数
+     */
+    static dircreteFromLoopPts(surface: Surface, p2Loops: types.IXY[][], surfaceDirection: boolean | undefined, params: DiscreteParam | undefined, uvEps: types.IXY): types.IMesh;
+    /**
+     * 计算插值点，用于计算包围盒
+     * @param surface
+     * @param curveLoops
+     * @param params
+     * @param tol
+     * @returns
+     */
+    static simplePoints(surface: Surface, curveLoops: IDirectedCurve[][], params?: DiscreteParam, tol?: Tol): types.IXYZ[];
+    static mesh2dto3d(surface: Surface, mesh2d: IMesh2d): types.IMesh;
+    /**
+     * 尝试快速离散类矩形无洞边界
+     * @param p2Loops
+     * @param faceDir
+     * @param uvHint
+     * @returns
+     */
+    /** 将三维曲线转化为二维点环 */
+    private static _discreteSurfaceLoops;
+    /** 将三维曲线转为离散参数曲线点 */
+    private static _getPCurvePoints;
+    /** 尝试获取一些复杂曲面的简单参数曲线，用于边面每次都反求参数，以提升离散速度 */
+    private static _getSimplePCurve;
+    /**
+     * 给定极点处参数曲线的首尾端点，返回需要差值的点
+     * @param pt1 首点
+     * @param pt2 尾点
+     * @param uHintCache 插值时的参考u值，范围为 [0～2 period]，包含首尾点
+     * @param uEps u向容差
+     */
+    private static _getPoleDiscreteUvs;
+    /** 根据曲面类型分别计算u向、v向插值点密度 */
+    private static _getInnerPointHint;
+    /** 筛选插值点，得到处于 loop 范围内的插值点 */
+    private static _getPointsInside;
+}

package/types/algorithm/discrete/discrete_topology.d.ts

@@ -0,0 +1,32 @@
+import { PolyCurve, Vec2 } from '../..';
+import { DiscreteParam } from '../../base/discrete_param';
+import { Polygon } from '../../topology/polygon';
+import { IMesh2d } from './discrete_refiner';
+export declare class DiscreteTopology {
+    /**
+     * 网格化PolygonEx，得到三角面片
+     * @param polygon
+     * @param params 离散精度
+     * @param startIdx
+     */
+    static tessPolygonEx(polygon: Polygon, params?: DiscreteParam, _startIdx?: number): IMesh2d;
+    /**
+     * 网格化polygon，得到三角面片
+     * @param _polygon
+     * @param params 离散精度
+     * @param bCalPolygonEx
+     */
+    static tessPolygon(_polygon: Polygon, params?: DiscreteParam, bCalPolygonEx?: boolean): IMesh2d;
+    /**
+     * 离散polycurve，得到离散的点集
+     * @param curve2ds
+     * @param params 离散精度
+     */
+    static discretePolyline(curve2ds: PolyCurve, params?: DiscreteParam): Vec2[];
+    /**
+     * 离散polygon的边界，得到离散的点集
+     * @param polygon
+     * @param params 离散精度
+     */
+    static discretePolygon(polygon: Polygon, params?: DiscreteParam): Vec2[][];
+}

package/types/algorithm/discrete/discrete_util.d.ts

@@ -0,0 +1,96 @@
+import { types } from '../../type_define/i_types';
+import { Vec } from '../../base/vec';
+import { Vec2 } from '../../base/vec2';
+import { Vec3 } from '../../base/vec3';
+import { Tol } from '../../base/tol';
+import { DiscreteParam } from '../../base/discrete_param';
+import { Curve2 } from '../../geometry/curve2';
+import { Curve3 } from '../../geometry/curve3d';
+import { Surface } from '../../geometry/surface';
+import { Ln2 } from '../../geometry/ln2';
+import { IMesh2d } from './discrete_refiner';
+import { Curve } from '../../geometry/curve';
+import { IDirectedCurve } from './discrete_surface';
+import { IParamedPoint } from './discrete_curve';
+/**
+ * @author tiansk
+ * 离散算法，对曲线、曲面离散算法进行了封装
+ */
+declare class DiscreteUtil {
+    private static readonly _POLY2TRI_ANGLE_EPS;
+    /**
+     * 调用 Libtess 进行离散，适用于直纹面
+     * @param loops
+     * @param stepLenth
+     * @param startIdx
+     */
+    static tessVector2(loops: types.IXY[][]): IMesh2d;
+    /**
+     * 调用 poly2tri 进行离散，适用一般曲面
+     * @param loops
+     * @param points
+     * @returns
+     */
+    static tessByPoly2tri(loops: types.IXY[][], points?: types.IXY[]): IMesh2d;
+    /**
+     * 离散二维直线段，按照给定的步距
+     * @param line2d
+     * @param stepLenth
+     */
+    static discreteLine2d(line2d: Ln2, stepLenth: number): Ln2[];
+    /**
+     * 离散二维曲线
+     * @param curve 曲线
+     * @param params 离散参数
+     */
+    static discreteCurve2d(curve: Curve2, params?: DiscreteParam): Vec2[];
+    /**
+     * 离散三维曲线
+     * @param curve 曲线
+     * @param params 离散参数
+     */
+    static discreteCurve3d(curve: Curve3, params?: DiscreteParam): Vec3[];
+    /**
+     * 离散三维曲线
+     * @param curve 曲线
+     * @param params 离散参数
+     */
+    static discreteCurve<PointType extends Vec>(curve: Curve<PointType>, params: DiscreteParam): IParamedPoint<PointType>[];
+    /**
+     * 根据曲面曲率离散其参数曲线
+     * @param curve 参数曲线
+     * @param surface 曲面
+     * @param params 离散参数
+     */
+    static discreteCurve2dOnSurface(curve: Curve2, surface: Surface, params?: DiscreteParam): {
+        points: Vec3[];
+        uvs: Vec2[];
+    };
+    static discreteGeneralCurve<PointType extends Vec>(getPoint: (t: number) => PointType, getTangent: (t: number) => PointType, range: types.IInterval, singularities: number[] | undefined, params: DiscreteParam): IParamedPoint<PointType>[];
+    /**
+     * 根据各参数曲线的离散结果来离散曲面。圆柱、圆锥支持跨周期域造型，椭球暂不支持跨周期域造型（受插点时的内外判定算法限制）
+     * @param surface 待离散的曲面
+     * @param curveLoops 由有向曲线组成的 Loops。第一个 Loop 为外环，其余为内环。数据会根据需要优化
+     * @param surfaceDirection 离散结果是否与曲面默认方向一致
+     * @param params 离散参数
+     * @param tol 计算容差
+     */
+    static discreteSurface(surface: Surface, curveLoops: IDirectedCurve[][], surfaceDirection?: boolean, params?: DiscreteParam, tol?: Tol, constrainPt3ds?: Vec3[]): types.IMesh;
+    /**
+     * 将面离散成点
+     * @param surface
+     * @param curveLoops
+     * @param params
+     * @param tol
+     * @returns
+     */
+    static discreteSurfaceIntoPoints(surface: Surface, curveLoops: IDirectedCurve[][], params?: DiscreteParam, tol?: Tol): types.IXYZ[];
+    /**
+     * 使用细分三角边的方式对 Mesh 进行优化
+     * @param surface 待离散的曲面
+     * @param mesh2d 二维离散结果
+     * @param params 离散参数
+     */
+    static refineMesh3d(surface: Surface, mesh2d: IMesh2d, params?: DiscreteParam): types.IMesh;
+}
+export { DiscreteUtil };

package/types/algorithm/discrete/grid_discrete_data.d.ts

@@ -0,0 +1,58 @@
+import { types } from '../..';
+export interface IPoint extends types.IXY {
+    id: number;
+}
+export interface IEdge {
+    pt1: IPoint;
+    pt2: IPoint;
+}
+/**
+ * 仅供网格离散的三角形数据结构
+ *
+ *                0
+ *               / \
+ *              /   \
+ *             /     \
+ *      n2    /       \  n1
+ *           /         \
+ *          /           \
+ *         1-------------2
+ *           neighbors0
+ *
+ * neighbors和constrainedEdge以及delaunayEdge序号一致
+ */
+export declare class Triangle {
+    pts: IPoint[];
+    neighbors: (Triangle | undefined)[];
+    constrainedEdge: boolean[];
+    delaunayEdge: boolean[];
+    visit: boolean;
+    constructor(p1: IPoint, p2: IPoint, p3: IPoint);
+    containsPt(point: IPoint): boolean;
+    containsEdge(edge: IEdge): boolean;
+    containsPts(p1: IPoint, p2: IPoint): boolean;
+    markNeighborPointers(p1: IPoint, p2: IPoint, t: Triangle): void;
+    markNeighbor(t: Triangle): void;
+    clearNeighbors(): void;
+    clearDelaunayEdges(): void;
+    pointCW(p: IPoint): IPoint | null;
+    pointCCW(p: IPoint): IPoint | undefined;
+    neighborCW(p: IPoint): Triangle | undefined;
+    neighborCCW(p: IPoint): Triangle | undefined;
+    getConstrainedEdgeCW(p: IPoint): boolean;
+    getConstrainedEdgeCCW(p: IPoint): boolean;
+    getConstrainedEdgeAcross(p: IPoint): boolean;
+    setConstrainedEdgeCW(p: IPoint, ce: boolean): void;
+    setConstrainedEdgeCCW(p: IPoint, ce: boolean): void;
+    getDelaunayEdgeCW(p: IPoint): boolean;
+    getDelaunayEdgeCCW(p: IPoint): boolean;
+    setDelaunayEdgeCW(p: IPoint, e: boolean): void;
+    setDelaunayEdgeCCW(p: IPoint, e: boolean): void;
+    neighborAcross(p: IPoint): Triangle | undefined;
+    oppositePoint(t: Triangle, p: IPoint): IPoint | null;
+    legalize(opoint: IPoint, npoint: IPoint): void;
+    index(p: IPoint): 2 | 1 | 0;
+    edgeIndex(p1: IPoint, p2: IPoint): 2 | 1 | 0 | -1;
+    markConstrainedEdgeByEdge(edge: IEdge): void;
+    markConstrainedEdgeByPoints(p: IPoint, q: IPoint): void;
+}

package/types/algorithm/discrete/libtess.d.ts

@@ -0,0 +1,12 @@
+export declare function tessTriangulate(contours: number[][][], normal: number[]): number[][];
+/**
+ * Represent a vertex with index, internally used to improve performance.
+ */
+export declare class LibtessVertex extends Array<number> {
+    index: number;
+    constructor(v: {
+        x: number;
+        y: number;
+        z?: number;
+    }, idx: number);
+}

package/types/algorithm/discrete/uniform_grid_discrete.d.ts

@@ -0,0 +1,3 @@
+import { types } from '../../type_define/i_types';
+import { IMesh2d } from './discrete_refiner';
+export declare function uniformGridDiscrete(inputs: types.IXY[][], maxFaceCount: number): IMesh2d;