@ccpc/math 0.1.0 → 0.1.3

package/types/geometry/nurbs_curve3.d.ts

@@ -0,0 +1,191 @@
+import * as verb from '../verb/verb';
+import { Curve3 } from './curve3d';
+import { Vec3 } from '../base/vec3';
+import { Interval } from '../base/interval';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { DiscreteParam } from '../base/discrete_param';
+import { INurbsCurve } from '../type_define/i_geometry';
+import { TangentCone } from '../base/tangent_cone';
+import { Ln3 } from './ln3';
+import { ICurvesOverlapInfo } from '../algorithm/overlap/i_overlap';
+import { Coord3 } from '../base/coord3';
+import { Box3 } from '../base/box3';
+/**
+ * Nurbs曲线
+ */
+export declare class NurbsCurve3 extends Curve3 implements INurbsCurve<Vec3> {
+    /**
+     * 合并nurbs曲线，目前仅支持合并三阶曲线
+     * @param curve1
+     * @param curve2
+     * @param overlap 保证第一条曲线对应的重合区间为第一段，且第一条曲线的重合段为后半段
+     */
+    static merge(curve1: NurbsCurve3, curve2: NurbsCurve3, overlap?: ICurvesOverlapInfo, degree?: number): NurbsCurve3 | undefined;
+    /**
+     * 构造Bezier曲线，degree 为控制点数-1，最大度数为 8.
+     */
+    static makeBezier(controlPoints: types.IXYZ[], weights?: number[]): NurbsCurve3;
+    /**
+     * 通过控制点和次数构造准均匀nurbs curve
+     */
+    static makeByControlPoints(controlPoints: types.IXYZ[], degree?: number, knots?: number[], weights?: number[], range?: types.IInterval): NurbsCurve3;
+    /**
+     * 插值构造nurbs curve
+     * 曲线将插值经过所有传入的点，曲线默认为三次
+     */
+    static makeByInterpolationPts(pts: types.IXYZ[], degree?: number, closeSmooth?: boolean): NurbsCurve3;
+    static makeByInterpolationPointsInPlane(pts: types.IXYZ[], planeCoord: Coord3, degree?: number, closeSmooth?: boolean): NurbsCurve3;
+    static getBezierKnots(degree: number): number[];
+    /**
+     * 过滤重复点，只过滤连续的重复点
+     * @param pts 输入点列
+     */
+    private static _fiterCoPoint;
+    /**
+     * 针对verb库中插值方法点修改，大致流程基本不变，主要修改解方程的方式
+     * @param points 输入插值点
+     * @returns
+     */
+    private static _make3dNurbsByInterPoint;
+    /**
+     * 快速求解的方式采用基于追赶法的方式，由于矩阵并不是很整齐的原因，条状矩阵外扩保证了整齐，然后采用多次追赶的方式
+     * 先“追”3次，然后“赶”3次，得到对角矩阵后，归一化直接得到解
+     * 相比与LU分解常规求解，时间得到很大的提升
+     * @param A 输入矩阵
+     * @param b 系数
+     * @returns
+     */
+    private static _quickSolve;
+    private _verbCurve;
+    private _degree;
+    private _knots;
+    private _controlPoints;
+    private _weights;
+    constructor(verbCurve?: verb.geom.NurbsCurve, range?: types.IInterval);
+    toVerbNurbs(): verb.geom.NurbsCurve;
+    getDegree(): number;
+    getWeights(): number[];
+    getKnots(): number[];
+    getControlPoints(): Vec3[];
+    /**
+     * 获取定义域，参数 t 超过该范围无法求值
+     * range 为定义域上的一部分，用于裁切曲线
+     */
+    getDomain(): Interval;
+    isBezier(): boolean;
+    /**
+     * 判断nurbs是否近似为一条直线
+     */
+    getCoincideLine(angleTol?: number): Ln3 | undefined;
+    /**
+     * 判断NurbsCurve3d是否是平面曲线
+     * 如果是平面曲线：并且控制顶点能构造一个平面，则返回平面的法向；不能构造平面的，例如是一条直线的，只返回true；
+     * 如果不是平面曲线，返回false
+     */
+    isPlaneCurve3d(angleTol?: number): boolean | Vec3;
+    /**
+     * 获取参数值对应的曲线上的点
+     * @param t 参数(弧长)
+     */
+    getPtAt(t: number): Vec3;
+    /**
+     * 利用nurbs导数连续的特性，比较两个连续离散点与求取垂足点的关系，看是否满足关系然后在进行迭代求解
+     * @param point 求取垂足的点
+     * @param distEps 距离容差
+     * @param angleEps 角度容差
+     * @returns
+     */
+    getAllFootParams(point: types.IXYZ, distEps?: number, angleEps?: number): number[];
+    /**
+     * 获取点在曲线上的参数
+     * @param point
+     */
+    getParamAt(point: types.IXYZ): number;
+    private _getParamAtWithPoints;
+    /**
+     * 计算参数域内的最近点参数
+     * @param point 给定点
+     * @returns 参数
+     */
+    getNearestT(point: Vec3, rRange?: Interval): number;
+    /**
+     * 获取参数值对应的曲线上的点处的切向量
+     * @param t
+     * @returns 单位切向量
+     */
+    getTangentAt(t: number): Vec3;
+    /**
+     *  获取某参数t处的几阶导数
+     * t : 参数t
+     * n : 导数的阶数 // 譬如n = 2，会计算曲线在参数t处的0阶导(即曲线点)、1阶导、2阶导
+     */
+    getDerivatives(t: number, nth: number): Vec3[];
+    getTangentCone(range?: Interval, approx?: boolean): TangentCone;
+    /**
+     * 获取曲线上的弧长等分点，返回的第一个和最后一个分别为曲线的起点和终点
+     * @param count 等分点数量，数目限制最小为3
+     * @returns 单位切向量
+     */
+    getEqualDiversionPts(count?: number): Vec3[];
+    getKontIndex(knot: number, eps?: number): number;
+    getMultiplicityOfKnot(knot: number, k: number, eps?: number): number;
+    /**
+     * 插入单个节点
+     * @param knot
+     * @param eps
+     */
+    insertKnot(knot: number, eps?: number): void;
+    /**
+     * 插入单个节点重复插入multi次
+     * @param knot
+     * @param insertTimes
+     * @param eps
+     */
+    insertMultiKnot(knot: number, insertTimes: number, eps?: number): void;
+    /**
+     * 插入多个节点(暂未实现)
+     * @param knot
+     * @param eps
+     */
+    insertKnots(knot: number[], eps?: number): void;
+    getBox(range?: Interval): Box3;
+    /**
+     * 节点细化
+     * @param useDomainOrRange true就是要对整个domain范围作节点细化，false只对range内的节点细化（待完善）。
+     */
+    knotRefinement(useDomainOrRange?: boolean): void;
+    /**
+     * 在参数 t 处将 Nurbs 曲线切分为两部分 // 分割成两条完全独立的nurbs，对控制顶点做了重新计算
+     * @param t 切分点处的参数
+     * @param useRange 若真，则根据原参数域进行同步切分；若假，则切分得到的曲线以定义域作为参数域
+     * @return 返回切分得到的参数曲线，并会根据原参数域设置新的参数域。若参数有误则返回空数组
+     */
+    splitCurve(t: number, useRange?: boolean): NurbsCurve3[];
+    reverse(): this;
+    clone(): NurbsCurve3;
+    /**
+     * 获取曲线长度
+     */
+    getLength(range?: Interval): number;
+    transform(m: types.IMatrix4 | types.numberArrs4X4): this;
+    /**
+     * 离散曲线
+     * @param tolerance  相邻三点组成的三角形面积的最大值
+     * @returns 离散点
+     */
+    discrete(params?: DiscreteParam): Vec3[];
+    getType(): EN_GEO_TYPE;
+    dump(): types.IDBNurbsCurve3d;
+    load({ data: [degree, controlPts, _knots, _weights, range] }: types.IDBNurbsCurve3d): this;
+    private _updateParameters;
+    private _newCtrlPtsAtInsertKnot;
+    /**
+     *
+     * @param k 位置索引
+     * @param t 插入的节点参数
+     * @param times 插入次数
+     * @param multi 已有重复度
+     */
+    private _newCtrlPtsAtInsertMultiKnot;
+}

package/types/geometry/offset_curve2.d.ts

@@ -0,0 +1,63 @@
+import { Vec2 } from '../base/vec2';
+import { Interval } from '../base/interval';
+import { DiscreteParam } from '../base/discrete_param';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { OffsetParameterMapper } from './offset_parameter_mapper';
+import { Curve2 } from './curve2';
+import { ICurve2dTransformExtra, IOffsetCurve } from '../type_define/i_geometry';
+import { NurbsCurve2 } from './nurbs_curve2';
+export declare class OffsetCurve2 extends Curve2 implements IOffsetCurve<Vec2> {
+    static makeByOffset(curve: Curve2, offset?: number): Curve2;
+    private _paramMapper;
+    private _baseCurve;
+    private _offset;
+    constructor(curve?: Curve2, offset?: number, range?: types.IInterval);
+    /**
+     * curve should be emutable!
+     */
+    getBaseCurve(): Curve2;
+    getParamMapper(): OffsetParameterMapper;
+    getDomain(): Interval;
+    /**
+     * 判断该曲线是否为周期曲线
+     */
+    isPeriodic(): boolean;
+    /**
+     * 判断该曲线是否为直线
+     * @returns
+     */
+    isLineLike(): boolean;
+    getOffset(): number;
+    setOffset(offset: number): void;
+    getPtAt(t: number): Vec2;
+    getParamAt(point: types.IXY): number;
+    getAllFootParams(point: types.IXY, lengthEps?: number): number[];
+    /**
+     * 获取某参数t处的几阶导数，例如 n = 2 时，会返回曲线在参数t处的坐标、1阶导、2阶导
+     * @param t 参数
+     * @param n 需要计算的导数的最大阶数
+     * @param snapToPreviousEnd true时吸附到前一段domain的末尾，false时吸附到后一段domain的起始。当 t === range.min 时，默认为 false，否则默认为 true。
+     */
+    getDerivatives(t: number, nth: number, snapToPreviousEnd?: boolean): Vec2[];
+    getSingularities(): number[];
+    getContinuousRanges(): Interval[];
+    reverse(): this;
+    offset(dDist: number): boolean;
+    /**
+     * 拟合成nurbscurve2d
+     */
+    toNurbs(degree?: number, lengthEps?: number): NurbsCurve2;
+    transform(m: types.IMatrix3 | types.numberArrs3X3, extra?: ICurve2dTransformExtra): this;
+    transformed(m: types.IMatrix3 | types.numberArrs3X3, extra?: ICurve2dTransformExtra): Curve2;
+    discrete(params?: DiscreteParam): Vec2[];
+    getType(): EN_GEO_TYPE.OFFSET_CURVE_2D;
+    clone(): OffsetCurve2;
+    dump(): types.IDBOffsetCurve2d;
+    load(json: types.IDBOffsetCurve2d): this;
+    protected _refineDegerateTangent(t: number, snapPre: boolean, tan: Vec2): Vec2;
+    private _updateParamMapper;
+    private _initRange;
+    private _startSettingChange;
+    private _endSettingChange;
+}

package/types/geometry/offset_curve3.d.ts

@@ -0,0 +1,97 @@
+import { Interval } from '../base/interval';
+import { DiscreteParam } from '../base/discrete_param';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { OffsetParameterMapper } from './offset_parameter_mapper';
+import { Curve3 } from './curve3d';
+import { Vec3 } from '../base/vec3';
+import { ICurve3dTransformExtra, IOffsetCurve } from '../type_define/i_geometry';
+import { NurbsCurve3 } from './nurbs_curve3';
+import { verb } from '../verb/export_verb';
+/**
+ * 仅支持三维空间中的平面曲线
+ */
+export declare class OffsetCurve3 extends Curve3 implements IOffsetCurve<Vec3> {
+    /**
+     * 基于给定曲线，根据偏移量生成偏置曲线
+     * @param curve 基曲线
+     * @param dz 偏移的 z 轴方向
+     * @param offsetXY 在 xy 平面上的偏移量
+     * @param offsetZ 在 z 轴方向上的偏移量
+     */
+    static makeByOffset(curve: Curve3, dz: Vec3, offsetXY: number, offsetZ?: number): Curve3;
+    /**
+     * 基于给定曲线，生成一条过给定目标点的偏置曲线
+     * @param curve 基曲线
+     * @param point 给定的目标点
+     */
+    static makeByTargetPoint(curve: Curve3, point: types.IXYZ): Curve3;
+    private _paramMapper;
+    private _baseCurve;
+    private _dz;
+    private _offsetXY;
+    private _offsetZ;
+    constructor();
+    /**
+     * 基于 curve 创建一条偏置曲线
+     * @param curve 基曲线
+     * @param dz 基曲线所在平面的法向
+     * @param offsetXY 偏置后在所在平面上的偏移量
+     * @param offsetZ 偏置后在所在平面法向上的偏移量
+     */
+    constructor(curve: Curve3, dz: Vec3, offsetXY?: number, offsetZ?: number, range?: types.IInterval);
+    getBaseCurve(): Curve3;
+    getParamMapper(): OffsetParameterMapper;
+    getDomain(): Interval;
+    /**
+     * 判断该曲线是否为直线
+     * @returns
+     */
+    isLineLike(): boolean;
+    toVerbNurbs(): verb.geom.NurbsCurve;
+    getOffsetXY(): number;
+    setOffsetXY(offsetXY: number): void;
+    getOffsetZ(): number;
+    setOffsetZ(offsetZ: number): void;
+    getDz(): Vec3;
+    getPtAt(t: number): Vec3;
+    getParamAt(point: types.IXYZ): number;
+    /**
+     * 判断Curve3d是否是平面曲线
+     * 如果是平面曲线：并且能构造一个平面，则返回平面的法向；不能构造平面的，例如是一条直线的，只返回true；如果不是平面曲线(即空间曲线)，返回false
+     */
+    isPlaneCurve3d(angleTol?: number): boolean | Vec3;
+    getAllFootParams(point: types.IXYZ, lengthEps?: number): number[];
+    /**
+     * 获取某参数t处的几阶导数，例如 n = 2 时，会返回曲线在参数t处的坐标、1阶导、2阶导
+     * @param t 参数
+     * @param n 需要计算的导数的最大阶数
+     * @param snapToPreviousEnd true时吸附到前一段domain的末尾，false时吸附到后一段domain的起始。当 t === range.min 时，默认为 false，否则默认为 true。
+     */
+    getDerivatives(t: number, nth: number, snapToPreviousEnd?: boolean): Vec3[];
+    getSingularities(): number[];
+    getContinuousRanges(): Interval[];
+    reverse(): this;
+    /**
+     * 拟合成nurbscurve3d
+     */
+    toNurbs(degree?: number, lengthEps?: number): NurbsCurve3;
+    transform(m: types.IMatrix4 | types.numberArrs4X4, extra?: ICurve3dTransformExtra): this;
+    transformed(m: types.IMatrix4 | types.numberArrs4X4, extra?: ICurve3dTransformExtra): Curve3;
+    discrete(params?: DiscreteParam): Vec3[];
+    getType(): EN_GEO_TYPE.OFFSET_CURVE_3D;
+    clone(): OffsetCurve3;
+    dump(): types.IDBOffsetCurve3d;
+    load(json: types.IDBOffsetCurve3d): this;
+    protected _refineDegerateTangent(t: number, snapPre: boolean, tan: Vec3): Vec3;
+    private _updateParamMapper;
+    private _initRange;
+    /**
+     * 参数域发生变化时，可调用该 start/end 方法，以保留原 range
+     */
+    private _startSettingChange;
+    /**
+     * 参数域发生变化时，可调用该 start/end 方法，以保留原 range
+     */
+    private _endSettingChange;
+}

package/types/geometry/offset_parameter_mapper.d.ts

@@ -0,0 +1,72 @@
+import { Interval } from '../base/interval';
+import { Vec } from '../base/vec';
+import { IArc, IOffsetCurve } from '../type_define/i_geometry';
+import { types } from '../type_define/i_types';
+interface IDomain {
+    min: number;
+    baseMin: number;
+    length: number;
+    isReversed: boolean;
+}
+/**
+ * 参数种类。当映射结果为周期域中的非线性映射、或非周期域中的中间非线性映射部分为 MidGap；当映射结果为非周期定义域时，若小于定义域最小值则为 StartGap，若大于定义域最大值则为 EndGap；
+ */
+export declare enum ParamType {
+    Normal = 0,
+    Reversed = 1,
+    StartGap = 2,// period === 0 时，参数小于最小定义域
+    MidGap = 3,
+    EndGap = 4
+}
+export declare class OffsetParameterMapper {
+    private _domains?;
+    private _period;
+    private _basePeriod;
+    private _singularities;
+    /**
+     * 生成基于椭圆弧的偏置曲线的参数映射器
+     * case 1. 正常周期曲线（dr > -rho_min || dr < -r_max）
+     * case 2. 周期曲线，含 4 奇异点（-r_max < dr < -r_min)
+     * case 3. 曲线自交，根据参数域进行裁剪和映射
+     * case 3.1 两头裁剪的周期，含 2 奇异点
+     * case 3.2 一端延长、一端裁剪的曲线，含 1 奇异点
+     * case 3.3 两端延长的曲线
+     * @param ofsCrv 待生成参数映射器的偏置曲线，需采用 Simple 映射器进行初始化。
+     * @param arc
+     * @param dr
+     */
+    static ByArc<VectorType extends Vec>(ofsCrv: IOffsetCurve<VectorType>, arc: IArc<VectorType>, dr: number): OffsetParameterMapper;
+    static periodicBaseCurve<VectorType extends Vec>(ofsCrv: IOffsetCurve<VectorType>, offset: number): OffsetParameterMapper;
+    static Simple(): OffsetParameterMapper;
+    private static _calcSelfIntersect;
+    constructor(_domains?: IDomain[] | undefined, _period?: number, _basePeriod?: number, _singularities?: number[]);
+    /**
+     * 计算在基曲线上的参数
+     * @param t 在映射曲线上的参数
+     * @param snapToPreviousEnd true时吸附到前一段domain的末尾，false时吸附到后一段domain的起始
+     */
+    getBaseParam(t: number, snapToPreviousEnd?: boolean, eps?: number): number;
+    /**
+     * 计算在映射曲线上的参数
+     * @param baseT 在基曲线上的参数
+     * @param snapToPreviousEnd true时吸附到前一段domain的末尾，false时吸附到后一段domain的起始
+     */
+    getParam(baseT: number, snapToPreviousEnd?: boolean): number;
+    /**
+     * 计算在映射曲线上的参数，并返回参数种类信息
+     * @param baseT
+     * @param snapToPreviousEnd 当基曲线为周期曲线时，若 bastT 位于首尾 gap 处：当传入参数为 true 时吸附到前一段domain的末尾，false时吸附到后一段domain的起始
+     */
+    getParamInfo(baseT: number, snapToPreviousEnd?: boolean): {
+        param: number;
+        type: ParamType;
+    };
+    isPeriod(): boolean;
+    getPeriod(): number;
+    getBasePeriod(): number;
+    getRange(baseRange: Interval | types.IInterval): Interval;
+    getSingularities(): number[];
+    getDomain(): Interval;
+    clone(): OffsetParameterMapper;
+}
+export {};

package/types/geometry/plane.d.ts

@@ -0,0 +1,109 @@
+import { Coord3 } from '../base/coord3';
+import { Vec2 } from '../base/vec2';
+import { Vec3 } from '../base/vec3';
+import { Ln2 } from './ln2';
+import { Ln3 } from './ln3';
+import { CoordBasedSurface } from './coord_based_surface';
+import { Curve2 } from './curve2';
+import { Curve3 } from './curve3d';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Tol } from '../base/tol';
+import { Surface } from './surface';
+/**
+ * 平面
+ */
+declare class Plane extends CoordBasedSurface {
+    static XOY(z?: number): Plane;
+    static YOZ(x?: number): Plane;
+    static ZOX(y?: number): Plane;
+    /**
+     * 通过三个点创建平面. 如果三点共线则为undefined
+     */
+    static makeBy3Pts(pt1: types.IXYZ, pt2: types.IXYZ, pt3: types.IXYZ): Plane | undefined;
+    /**
+     * 从一堆不重复的点集计算平面，请尽量保证所有点共面。如果这些点共线，则计算不出平面，返回undefined
+     * @param points 一堆点集。根据一堆点集能计算出平面的法向
+     * @param refXDir 平面参考的x方向
+     */
+    static makeByPoints(points: Vec3[], refXDir?: Vec3): Plane | undefined;
+    /**
+     * 通过点，法向创建一个平面
+     * @param pt
+     * @param normal
+     * @param xDir（可选参数）如果不传，则会自动算出xy的方向
+     */
+    static makeByPtNormal(pt: types.IXYZ, normal: types.IXYZ, xDir?: types.IXYZ): Plane;
+    /**
+     * 原点+UV方向,当uv方向不垂直时，以U向为准，调整v向
+     * @param origin
+     * @param dirU
+     * @param dirV
+     */
+    constructor(origin: types.IXYZ, dirU: types.IXYZ, dirV: types.IXYZ);
+    /**
+     * 原点+法向， UV方向会自动计算出来
+     * @param origin
+     * @param norm
+     */
+    constructor(origin: types.IXYZ, norm: types.IXYZ);
+    constructor(coordinate: Coord3);
+    getOrigin(): Vec3;
+    getNorm(): Vec3;
+    reverse(): this;
+    getUDir(): Vec3;
+    getVDir(): Vec3;
+    getPtAt(uv: types.IXY): Vec3;
+    getNormAt(uv: Vec2): Vec3;
+    /**
+     *  获取某参数t处的n阶偏导数
+     * t : 参数t
+     * n : 导数的阶数 // 譬如n = 2，会计算曲线在参数t处的0阶导(即曲线点)，1阶偏导（包含偏u、偏v），2阶偏导（包含偏uu、偏uv、偏vv）
+     */
+    getDerivatives(uv: types.IXY, n?: number): Vec3[];
+    getUVAt(pt: types.IXYZ): Vec2;
+    getLine3DByPts(uv1: types.IXY, uv2: types.IXY): Ln3;
+    getLine3D(line2d: Curve2): Ln3;
+    isRuled(): boolean;
+    isParellel(other: Plane, tol?: number): boolean;
+    isPerpendicular(other: Plane, tol?: number): boolean;
+    isCoplanar(other: Surface, tol?: Tol): boolean;
+    containsCurve(curve: Curve3, lengthTol?: number, angleTol?: number): boolean;
+    /**
+     * 获取等参曲线
+     * @param param 等参曲线处的参数
+     * @param useV true 时返回等 v 参数曲线，false 时返回等 u 参数曲线
+     */
+    getIsoCurve(param: number, useV: boolean): Curve3;
+    /**
+     * 返回undefined说明line3d投影成了1个点
+     * @param line3d
+     */
+    getLine2D(line3d: Ln3): Ln2 | undefined;
+    /**
+     * 将三维曲线，转成参数域的二维曲线，保证曲线的精确性
+     * @param curveOnSurface 在平面上的曲线 // 传入参数时，请保证曲线必须在平面上
+     */
+    getCurve2d(curveOnSurface: Curve3): Curve2;
+    /**
+     * 将参数域中的二维曲线映射到平面上的三维曲线
+     * @param curve
+     */
+    getCurve3d(curve: Curve2): Curve3;
+    /**
+     * 乘上一个变换矩阵
+     */
+    transform(m: types.IMatrix4 | types.numberArrs4X4): this;
+    /**
+     *  深拷贝
+     */
+    clone(): Plane;
+    getType(): EN_GEO_TYPE.PLANE;
+    /**
+     * 抽取元数据，用于序列化
+     * @returns 返回js对象
+     */
+    dump(): types.IDBPlane;
+    load(json: types.IDBPlane): this;
+}
+export { Plane };

package/types/geometry/polyline.d.ts

@@ -0,0 +1,12 @@
+export declare abstract class Polyline<PointType> {
+    protected _points: PointType[];
+    protected _ts: number[];
+    constructor(points: PointType[], ts: number[]);
+    protected abstract _getInterpolator(): (p1: PointType, p2: PointType, ratio: number) => PointType;
+    get ts(): ReadonlyArray<number>;
+    get points(): ReadonlyArray<PointType>;
+    getPtAt(t: number): PointType;
+}
+export declare class PolylineFunction extends Polyline<number> {
+    protected _getInterpolator(): (p1: number, p2: number, ratio: number) => number;
+}

package/types/geometry/smooth_poly2.d.ts

@@ -0,0 +1,78 @@
+import { Curve2 } from './curve2';
+import { types } from '../type_define/i_types';
+import { Vec2 } from '../base/vec2';
+import { Box2 } from '../base/box2';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Ln2 } from './ln2';
+import { Interval } from '../base/interval';
+import { DiscreteParam } from '../base/discrete_param';
+/**
+ * 二维多段直线
+ * 主要用在拉伸，扫掠算法中，形成光滑的面
+ */
+export declare class SmoothPoly2 extends Curve2 {
+    private _pts;
+    private _ts;
+    constructor();
+    constructor(pts: types.IXY[]);
+    /**
+     * 获取连续点的数组
+     */
+    getPoints(): ReadonlyArray<Vec2>;
+    /**
+     * 获取连续点对应参数的数组
+     */
+    getTs(): ReadonlyArray<number>;
+    /**
+     * 获取所有的直线段
+     */
+    getSegments(): Ln2[];
+    /**
+     * 获取某参数对应的点
+     */
+    getPtAt(t: number): Vec2;
+    /**
+     *  获取某参数对应的点
+     */
+    getParamAt(point: types.IXY): number;
+    /**
+     * 获取某参数处的切线
+     */
+    getTangentAt(t: number): Vec2;
+    /**
+     *  获取某参数t处的几阶导数
+     * t : 参数t
+     * n : 导数的阶数 // 譬如n = 2，会计算曲线在参数t处的0阶导(即曲线点)、1阶导、2阶导
+     */
+    getDerivatives(t: number, n: number): Vec2[];
+    /**
+     *  获取曲线(给定参数域区间段的)长度
+     */
+    getLength(range?: Interval): number;
+    /**
+     * 反向
+     */
+    reverse(): this;
+    offset(dDist: number): boolean;
+    /**
+     * 分割SmoothPoly为两段，如果分割点不在直线上，则返回空数组
+     * @param param
+     * @param tolerance
+     */
+    split(params: number[], tolerance?: number): Curve2[];
+    transform(m: types.IMatrix3 | types.numberArrs3X3): this;
+    /**
+     * 计算包围盒
+     */
+    getBBox(range?: Interval): Box2;
+    discrete(params?: DiscreteParam): Vec2[];
+    getType(): EN_GEO_TYPE.SMOOTHPOLY_2D;
+    clone(): SmoothPoly2;
+    /**
+     * 抽取元数据，用于序列化
+     */
+    dump(): types.IDBSmoothPoly2d;
+    load(json: types.IDBSmoothPoly2d): this;
+    private _getSegment;
+    private _calParams;
+}