@ccpc/math 0.1.0 → 0.1.7

package/types/type_define/i_geometry.d.ts

@@ -0,0 +1,191 @@
+import type { types } from './i_types';
+import type { Vec } from '../base/vec';
+import type { Box } from '../base/box';
+import type { Vec2 } from '../base/vec2';
+import type { Vec3 } from '../base/vec3';
+import type { Box2 } from '../base/box2';
+import type { Curve } from '../geometry/curve';
+import type { PeriodInterval } from '../base/period_inverval';
+import type { Interval } from '../base/interval';
+import type { Coord } from '../base/coord';
+import type { OffsetParameterMapper } from '../geometry/offset_parameter_mapper';
+export interface ITransformExtra {
+    svd?: types.IMatrix3Svd | types.IMatrix4Svd;
+    range?: Interval | Box2;
+}
+export interface ICurve2dTransformExtra extends ITransformExtra {
+    svd?: types.IMatrix3Svd;
+    range?: Interval;
+}
+export interface ICurve3dTransformExtra extends ITransformExtra {
+    svd?: types.IMatrix4Svd;
+    range?: Interval;
+}
+export interface ISurfaceTransformExtra extends ITransformExtra {
+    svd?: types.IMatrix4Svd;
+    range?: Box2;
+}
+/**
+ * @author tiansk
+ *  所有几何对象的基类
+ */
+export interface IGeometry<IMatrixArray extends number[][], PointType extends Vec> {
+    /**
+     * 乘上一个变换矩阵，改变自己
+     */
+    transform(m: types.IMatrix<IMatrixArray> | IMatrixArray, extra?: ITransformExtra): this;
+    /**
+     * 计算包围盒
+     */
+    getBBox(): Box<PointType>;
+    /**
+     * 平移，改变自己
+     */
+    translate(offset: types.IXY | PointType): this;
+    /**
+     * 绕坐标轴/点的旋转，改变自己
+     * @param angle 旋转的角度
+     * @param pivot 旋转轴上一点
+     * @param axis  绕哪个轴旋转
+     */
+    rotate(angle: number, pivot: types.IXY, axis?: types.IXY): this;
+    /**
+     * 缩放，改变自己
+     * 直线支持非等比，其他情况都是等比例缩放
+     * @param factor 放大因子
+     * @param center 缩放中心
+     */
+    scale(factor: number, center: types.IXY): this;
+}
+export interface IGeometry2d extends IGeometry<types.numberArrs3X3, Vec2> {
+    /**
+     * 乘上一个变换矩阵，改变自己
+     */
+    transform(m: types.IMatrix3 | types.numberArrs3X3, extra?: ITransformExtra): this;
+}
+export interface IGeometry3d extends IGeometry<types.numberArrs4X4, Vec3> {
+    /**
+     * 乘上一个变换矩阵，改变自己
+     */
+    transform(m: types.IMatrix4 | types.numberArrs4X4, extra?: ITransformExtra): this;
+}
+export interface ILine<VectorType extends Vec> extends Curve<VectorType> {
+    reset(start: types.IXY, end: types.IXY): void;
+    /**
+     * 获取原点（参数为零的点）
+     */
+    getOrigin(): VectorType;
+    /**
+     * 设置原点（参数为零的点）
+     */
+    setOrigin(origin: types.IXY): void;
+    /**
+     *  获取方向向量
+     */
+    getDirection(): VectorType;
+    /**
+     *  获取方向向量
+     */
+    setDirection(dir: types.IXY): void;
+    /**
+     * 转换成无限长直线，返回新对象
+     */
+    toInfiniteLine(): ILine<VectorType>;
+    clone(): ILine<VectorType>;
+}
+export interface IArc<VectorType extends Vec> extends Curve<VectorType> {
+    /**
+     * 获取 a 轴长度
+     */
+    getA(): number;
+    /**
+     * 设置 a 轴长度
+     */
+    setA(v: number): void;
+    /**
+     * 获取 b 轴长度
+     */
+    getB(): number;
+    /**
+     * 设置 b 轴长度
+     */
+    setB(v: number): void;
+    /**
+     * 获取参数范围
+     */
+    getRange(): PeriodInterval;
+    /**
+     * 获取圆心
+     */
+    getCenter(): VectorType;
+    /**
+     * 获取半径长度
+     * @deprecated 目前已支持 ab 长短周，请以获取半轴长替代
+     */
+    getRadius(): number;
+    /**
+     * 获取当前坐标系
+     */
+    getCoord(): Coord<VectorType>;
+    /**
+     * 判断是否为封闭圆形
+     */
+    isClosed(): boolean;
+    /**
+     * 获取圆弧上，两点之间的参数域范围，沿着参数增加的方向
+     * @param startPt
+     * @param endPt
+     */
+    getParamRangeAt(startPt: types.IXY, endPt: types.IXY): PeriodInterval;
+    /**
+     * 椭圆长短轴是否相等
+     */
+    isEqualAB(): boolean;
+    clone(): IArc<VectorType>;
+}
+export interface IExtendCurve<VectorType extends Vec> extends Curve<VectorType> {
+    getBaseCurve(): Curve<VectorType>;
+    setBaseCurve(curve: Curve<VectorType>): void;
+    updateExtension(): void;
+    /**
+     * 根据参数域，将其分割为多条简单曲线
+     */
+    toSimpleCurves(): Curve<VectorType>[];
+    getHeadScale(): number;
+    getTailScale(): number;
+    clone(): IExtendCurve<VectorType>;
+}
+export interface INurbsCurve<VectorType extends Vec> extends Curve<VectorType> {
+    getDegree(): number;
+    getWeights(): number[];
+    getKnots(): number[];
+    getControlPoints(): VectorType[];
+    /**
+     * 获取定义域，参数 t 超过该范围无法求值
+     * range 为定义域上的一部分，用于裁切曲线
+     */
+    getDomain(): Interval;
+    /**
+     * 获取曲线上的弧长等分点，返回的第一个和最后一个分别为曲线的起点和终点
+     * @param count 等分点数量，数目限制最小为3
+     * @returns 单位切向量
+     */
+    getEqualDiversionPts(count: number): VectorType[];
+    /**
+     * 在参数 t 处将 Nurbs 曲线切分为两部分 // 分割成两条完全独立的nurbs，对控制顶点做了重新计算
+     * @param t 切分点处的参数
+     * @param useRange 若真，则根据原参数域进行同步切分；若假，则切分得到的曲线以定义域作为参数域
+     * @return 返回切分得到的参数曲线，并会根据原参数域设置新的参数域。若参数有误则返回空数组
+     */
+    splitCurve(t: number, useRange?: boolean): INurbsCurve<VectorType>[];
+    clone(): INurbsCurve<VectorType>;
+}
+export interface IOffsetCurve<VectorType extends Vec> extends Curve<VectorType> {
+    /**
+     * curve should be emutable!
+     */
+    getBaseCurve(): Curve<VectorType>;
+    getDomain(): Interval;
+    getParamMapper(): OffsetParameterMapper;
+    clone(): IOffsetCurve<VectorType>;
+}

package/types/type_define/i_types.d.ts

@@ -0,0 +1,280 @@
+import { Matrix3 } from '../base/matrix3';
+import { Matrix4 } from '../base/matrix4';
+import { Vec2 } from '../base/vec2';
+import { Vec3 } from '../base/vec3';
+import { EN_GEO_TYPE } from './i_element_type';
+declare namespace types {
+    interface Class<T> {
+        new (): T;
+    }
+    type numberArr2 = [number, number];
+    type numberArr3 = [number, number, number];
+    type numberArrs3X3 = [numberArr3, numberArr3, numberArr3];
+    type numberArr4 = [number, number, number, number];
+    type numberArrs4X4 = [numberArr4, numberArr4, numberArr4, numberArr4];
+    type IInterval = numberArr2;
+    type IPeriodInterval = numberArr3;
+    type IXYArr = numberArr2;
+    type IXYZArr = numberArr3;
+    type IXY = {
+        x: number;
+        y: number;
+    };
+    type IXYZ = {
+        x: number;
+        y: number;
+        z: number;
+    };
+    interface IMatrix<IMatrixArray extends number[][]> {
+        data: IMatrixArray;
+    }
+    interface IMatrix3 extends IMatrix<numberArrs3X3> {
+    }
+    interface IMatrix4 extends IMatrix<numberArrs4X4> {
+    }
+    interface IMatrix3Svd {
+        uTransform: Matrix3;
+        scale: Vec2;
+        vRotate: Matrix3;
+    }
+    interface IMatrix4Svd {
+        uTransform: Matrix4;
+        scale: Vec3;
+        vRotate: Matrix4;
+    }
+    interface IRenderDebug {
+        id?: number;
+        name: string;
+        visible: boolean;
+        selectedId?: number;
+        color?: string;
+    }
+    type IFlatMeshBase = {
+        [key: string]: number[];
+    };
+    /** 离散得到的三角面片，高效存储 */
+    interface IFlatMesh extends IFlatMeshBase {
+        /** 离散后的所有顶点, 每3个一组表示一个顶点 */
+        vertices: number[];
+        /** 三角片集，一个三角面片，每3个一组表示一个三角面片的三个顶点索引 */
+        faces: number[];
+        /** 顶点法矢，与vertices对应，每3个一组表示一个顶点的法向方向 */
+        normals: number[];
+        /** 顶点UV，与vertices对应，2个一组 */
+        uvs: number[];
+    }
+    type IFlatMeshPlus = IFlatMesh & {
+        uvs1?: number[];
+    };
+    /** 含有骨骼信息的网格 */
+    interface IBoneFlatMesh extends IFlatMesh {
+        /** 骨架索引，4个一组 */
+        boneIndices: number[];
+        /** 骨架权重，4个一组 */
+        boneWeights: number[];
+    }
+    interface IMesh {
+        vertices: numberArr3[];
+        faces: numberArr3[];
+        normals: numberArr3[];
+        uvs: numberArr2[];
+    }
+    interface IRenderNode {
+        points?: numberArr3[];
+        edges?: numberArr3[][];
+        mesh?: IMesh;
+        children?: IRenderNode[];
+    }
+    interface IRenderMesh {
+        mesh: IMesh;
+    }
+    interface IRenderEdge extends IRenderNode {
+        edges: numberArr3[][];
+    }
+    interface IRenderPoint extends IRenderNode {
+        points: numberArr3[];
+    }
+    interface IDBLibGeo {
+        type: EN_GEO_TYPE;
+        _d?: any;
+    }
+    interface IDBVector {
+        type: EN_GEO_TYPE;
+        data: number[];
+    }
+    interface IDBVector2 extends IDBVector {
+        type: EN_GEO_TYPE.VEC_2;
+        data: IXYArr;
+    }
+    interface IDBVector3 extends IDBVector {
+        type: EN_GEO_TYPE.VEC_3;
+        data: IXYZArr;
+    }
+    interface IDBMatrix {
+        type: EN_GEO_TYPE;
+        data: number[][];
+    }
+    interface IDBMatrix3 extends IDBMatrix {
+        type: EN_GEO_TYPE.MATRIX_3;
+        data: numberArrs3X3;
+    }
+    interface IDBMatrix4 extends IDBMatrix {
+        type: EN_GEO_TYPE.MATRIX_4;
+        data: numberArrs4X4;
+    }
+    interface IDBCoordinate2 extends IDBLibGeo {
+        type: EN_GEO_TYPE.COORD_2;
+        data: [
+            IXYArr,
+            IXYArr
+        ];
+    }
+    interface IDBCoordinate3 extends IDBLibGeo {
+        type: EN_GEO_TYPE.COORD_3;
+        data: [
+            IXYZArr,
+            IXYZArr,
+            IXYZArr
+        ];
+    }
+    interface IDBCurve2d extends IDBLibGeo {
+        type: EN_GEO_TYPE;
+    }
+    interface IDBLine2d extends IDBCurve2d {
+        type: EN_GEO_TYPE;
+        data: [
+            IXYArr,
+            IXYArr,
+            IInterval
+        ];
+    }
+    interface IDBArc2d extends IDBCurve2d {
+        type: EN_GEO_TYPE;
+        data: [
+            number,
+            number,
+            IDBCoordinate2,
+            1 | -1,
+            IInterval
+        ];
+    }
+    interface IDBSmoothPoly2d extends IDBCurve2d {
+        type: EN_GEO_TYPE;
+        data: [
+            numberArr2[]
+        ];
+    }
+    interface IDBSmoothPoly3d extends IDBCurve3d {
+        type: EN_GEO_TYPE;
+        data: [
+            numberArr3[]
+        ];
+    }
+    interface IDBCircle3d extends IDBCurve3d {
+        type: EN_GEO_TYPE;
+        data: [
+            IDBCoordinate3,
+            number
+        ];
+    }
+    interface IDBArc3d extends IDBCurve3d {
+        type: EN_GEO_TYPE;
+        data: [
+            IDBCoordinate3,
+            number,
+            number,
+            IInterval
+        ];
+    }
+    interface IDBPolyCurve extends IDBLibGeo {
+        type: EN_GEO_TYPE;
+        data: IDBCurve2d[];
+    }
+    interface IDBLoop extends IDBPolyCurve {
+        type: EN_GEO_TYPE.POLY_CURVE;
+    }
+    interface IDBPolygon extends IDBLibGeo {
+        type: EN_GEO_TYPE.POLYGON;
+        data: IDBLoop[];
+    }
+    interface IDBCurve3d extends IDBLibGeo {
+        type: EN_GEO_TYPE;
+    }
+    interface IDBLine3d extends IDBCurve3d {
+        type: EN_GEO_TYPE;
+        data: [
+            IXYZArr,
+            IXYZArr,
+            IInterval
+        ];
+    }
+    interface IDBNurbsCurve2d extends IDBCurve2d {
+        type: EN_GEO_TYPE.NURBS_CURVE_2D;
+        data: [
+            number,
+            numberArr2[],
+            number[],
+            number[],
+            numberArr2
+        ];
+    }
+    interface IDBNurbsCurve3d extends IDBCurve3d {
+        type: EN_GEO_TYPE.NURBS_CURVE_3D;
+        data: [
+            number,
+            numberArr3[],
+            number[],
+            number[],
+            numberArr2
+        ];
+    }
+    interface IDBOffsetCurve2d extends IDBCurve2d {
+        type: EN_GEO_TYPE;
+        data: [
+            IDBLibGeo,
+            number,
+            IInterval
+        ];
+    }
+    interface IDBOffsetCurve3d extends IDBCurve3d {
+        type: EN_GEO_TYPE;
+        data: [
+            IDBLibGeo,
+            types.numberArr3,
+            number,
+            number,
+            IInterval
+        ];
+    }
+    interface IDBExtendCurve2d extends IDBCurve2d {
+        type: EN_GEO_TYPE;
+        data: [
+            IDBLibGeo,
+            types.numberArr2
+        ];
+    }
+    interface IDBSurface extends IDBLibGeo {
+        type: EN_GEO_TYPE;
+    }
+    interface IDBPlane extends IDBSurface {
+        type: EN_GEO_TYPE;
+        data: [IDBCoordinate3];
+    }
+    interface IDBCylinder extends IDBSurface {
+        type: EN_GEO_TYPE;
+        data: [
+            IDBCoordinate3,
+            number,
+            number
+        ];
+    }
+    interface IDBTrimmedSur extends IDBSurface {
+        type: EN_GEO_TYPE.TRIM;
+        data: [
+            IDBSurface,
+            boolean,
+            IDBPolygon
+        ];
+    }
+}
+export type { types };

package/types/util/array_util.d.ts

@@ -0,0 +1,8 @@
+export declare class ArrayUtil {
+    /**
+     * 给定增序数组，进行二分查找，找到最小包含 t 的区间，并返回区间的序号
+     * @param ts
+     * @param t
+     */
+    static binarySearch(ts: number[], t: number): number;
+}

package/types/util/assert.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 调试警告
+ * @deprecated 使用 MathError 来替代
+ */
+export declare class MathAssert {
+    /**
+     * 使用 MathError.assert() 来替代
+     * @param value
+     * @param message
+     * @param args
+     */
+    static assert(value: any, message?: string, ...args: any[]): void;
+    /**
+     * 使用 MathError.warn() 来替代
+     * @param value
+     * @param message
+     * @param args
+     */
+    static warn(value: any, message?: string, ...args: any[]): void;
+    static mutedWarn(value: any, message?: string, ...args: any[]): void;
+}

package/types/util/clipper2_util.d.ts

@@ -0,0 +1,5 @@
+import * as ClipperLib from 'clipper2-wasm/dist/clipper2z';
+export declare class Clipper2Util {
+    static clipper2Z: ClipperLib.MainModule;
+    static initialize(Clipper2ZFactory: any): Promise<void>;
+}

package/types/util/clipper_format_converter.d.ts

@@ -0,0 +1,21 @@
+import * as ClipperLib from '../clipperlib/clipperlib';
+import { Polygon } from '../topology/polygon';
+import { Loop } from '../topology/loop';
+import { PolyCurve } from '../topology/polycurve';
+import { types } from '../type_define/i_types';
+/**
+ * 格式转换类
+ */
+declare class ClipperFormatConverter {
+    static vector2ToXY(vec: types.IXY): ClipperLib.IntPoint;
+    static vector2sToXY(vector2s: types.IXY[]): ClipperLib.IntPoint[];
+    static pathsToPolygon(solutionPolytree: ClipperLib.IntPoint[][]): Polygon;
+    static pathToLoop(path: ClipperLib.IntPoint[]): Loop;
+    static loopToPath(loop: Loop): ClipperLib.IntPoint[];
+    static pathToPolyline(path: ClipperLib.IntPoint[]): PolyCurve;
+    static polylineToPath(polyline: PolyCurve): ClipperLib.IntPoint[];
+    static polygonToPaths(polygon: Polygon): ClipperLib.IntPoint[][];
+    static clpExPolygonToPolygon(exPolygon: ClipperLib.ExPolygon): Polygon;
+    static clipperExPolygonsToPolygon(exPolygons: ClipperLib.ExPolygons): Polygon[];
+}
+export { ClipperFormatConverter };

package/types/util/clipper_util.d.ts

@@ -0,0 +1,10 @@
+import * as ClipperLib from '../clipperlib/clipperlib';
+import { types } from '../type_define/i_types';
+export declare class ClipperUtil {
+    static clipperTreeToPathLists(polyTree: ClipperLib.PolyTree): ClipperLib.Paths[];
+    static xyLoopsToClipper(loops: types.IXY[][], scale?: number): ClipperLib.IntPoint[][];
+    static clipperPathsToXys(clipPaths: ClipperLib.Paths, scale?: number): types.IXY[][];
+    static boolAsClipperPoint(polygons1: types.IXY[][][] | ClipperLib.IntPoint[][][], polygons2: types.IXY[][][] | ClipperLib.IntPoint[][][], operationType: ClipperLib.ClipType): ClipperLib.Paths[];
+    static boolAsXys(polygons1: types.IXY[][][] | ClipperLib.IntPoint[][][], polygons2: types.IXY[][][] | ClipperLib.IntPoint[][][], operationType: ClipperLib.ClipType): types.IXY[][][];
+    static removeGapByOffset(loops: types.IXY[][], gapWidth: number): types.IXY[][];
+}

package/types/util/curve_util.d.ts

@@ -0,0 +1,72 @@
+import { Vec3 } from '../base/vec3';
+import { Arc3 } from '../geometry/arc3d';
+import { Curve2 } from '../geometry/curve2';
+import { Curve3 } from '../geometry/curve3d';
+import { Ln2 } from '../geometry/ln2';
+import { EvolutionMap } from '../topology/evolution_map';
+import { types } from '../type_define/i_types';
+export interface ICurveSimplifyOption {
+    clone?: boolean;
+    splitOffsetCurve?: boolean;
+    smoothPolyToNurbs?: boolean;
+    smoothPolyToLines?: boolean;
+}
+export declare class CurveUtil {
+    /**
+     * 获取平面曲线所在平面的法向。当曲线为直线时，若给定 hint 方向，则返回 hint；否则，将任意返回一垂直于直线的方向
+     * @param curve
+     * @param hint
+     */
+    static getDzByCurve(curve: Curve3, hint?: Vec3): Vec3;
+    /**
+     * 计算曲线所在平面的法向。当曲线为直线时，返回向量长度为 0；当曲线非平面曲线时，返回 undefined
+     * @param curve
+     * @param angleEps
+     */
+    static getDzByPlaneCurve(curve: Curve3, angleEps?: number): Vec3 | undefined;
+    /**
+     * 获取平面曲线所在平面的法向
+     * @param curve
+     * @param hint
+     */
+    static getDzByCurves(curves: Curve3[], hint?: Vec3): Vec3;
+    static getDzByPoints(pts: Vec3[]): Vec3 | undefined;
+    static makeRectangleByXY(x1: number, x2: number, y1: number, y2: number): Ln2[];
+    /**
+     * 根据曲线中的奇异点，将曲线进行分割
+     * @param curves
+     * @param options 简化选项，默认全为 true
+     * @returns splittedCurves: 分段结果；evolution：新曲线到旧曲线的映射关系
+     */
+    static simplifyCurves2d(curves: Curve2[], options?: ICurveSimplifyOption): {
+        curves: Curve2[];
+        evolution: EvolutionMap<Curve2>;
+    };
+    /**
+     * 根据曲线中的奇异点，将曲线进行分割；将 SmoothPolyline 转为 NurbsCurve
+     * @param curves
+     * @param options 简化选项，默认全为 true
+     * @returns splittedCurves: 分段结果；evolution：新曲线到旧曲线的映射关系
+     */
+    static simplifyCurves3d(curves: Curve3[], options?: ICurveSimplifyOption): {
+        curves: Curve3[];
+        evolution: EvolutionMap<Curve3>;
+    };
+    static filterParamsByDistance(params: number[], point: types.IXY, curve: Curve2, lengthEps?: number): number[];
+    static filterParamsByDistance(params: number[], point: types.IXYZ, curve: Curve3, lengthEps?: number): number[];
+    static getArc3dPoles(arc: Arc3): Vec3[];
+    /**
+     * 毛刺去除算法，扫掠的路径存在毛刺时会产生一些奇怪的结果
+     * 目前采用角度容差，距离容差的情况去除毛刺
+     */
+    static filterCurvesBurr(curves: Curve3[], angleEps: number, disEps: number): Curve3[];
+    /**
+     * 根据所给的两个点pt1和pt2设置曲线的参数域
+     * @param curve 曲线
+     * @param pt1 在曲线上的点
+     * @param pt2 在曲线上的点
+     * @param refPt 参考点，对于周期性曲线，会存在两段，refPt用于判断取哪一段。所以对于周期性曲线，要传入refPt
+     * @returns 返回是否交换起点和终点。譬如说直线，pt1的参数大于pt2的参数值，说明是从pt2到pt1方向的，就需要交换两个点的顺序
+     */
+    static setCurveRange(theCurve: Curve3, pt1: Vec3, pt2: Vec3, refPt?: Vec3): boolean;
+}

package/types/util/geom_util.d.ts

@@ -0,0 +1,23 @@
+import { Curve3 } from '../geometry/curve3d';
+import { Curve2 } from '../geometry/curve2';
+import { Vec3 } from '../base/vec3';
+import { Vec2 } from '../base/vec2';
+import { Curve } from '../geometry/curve';
+import { Vec } from '../base/vec';
+/**
+ * 和几何对象相关的一些公用方法，比较零散
+ */
+export declare class GeomUtil {
+    /**
+     * 判断线条依次连接
+     * @param curves
+     * @param tol
+     */
+    static curvesConnected<VectorType extends Vec>(curves: Curve<VectorType>[], tol?: number): boolean;
+    /**
+     * 从一堆不重复的点集计算平面
+     * @param points
+     */
+    static createPlaneFromPts(points: Vec3[]): Vec3 | undefined;
+    static splitCurveByPoints(curve: Curve2 | Curve3, pts: (Vec2 | Vec3)[], tol?: number): (Curve2 | Curve3)[];
+}

package/types/util/log.d.ts

@@ -0,0 +1,19 @@
+import { IGeo } from '../type_define/i_element';
+/**
+ * 调试信息工具类
+ */
+export declare class Log {
+    static showError: boolean;
+    private static _instance;
+    static instance(): Log;
+    /**
+     * 传入几何对象或者几何对象的数组，打印出几何的字符串
+     * @param geos
+     * @param prefix
+     * @param postfix
+     */
+    static d(geos: IGeo[] | IGeo, prefix?: string, postfix?: string): void;
+    static e(geos: IGeo[] | IGeo, prefix?: string, postfix?: string): void;
+    static w(geos: IGeo[] | IGeo, prefix?: string, postfix?: string): void;
+    static toString(geos: IGeo[] | IGeo): string;
+}

package/types/util/math_error.d.ts

@@ -0,0 +1,37 @@
+import { IGeo } from '../type_define/i_element';
+export type MathErrorParamType = IGeo | IGeo[] | number | Object;
+export declare enum MathErrorType {
+    /** 输入错误 */
+    Input = "input",
+    /** 运算中发生异常 */
+    Algorithm = "algorithm",
+    /** 运算结果有误 */
+    Geometry = "geometry",
+    /** 未实现功能 */
+    Unimplemented = "unimplemented",
+    /** 未知 */
+    Unknown = "unknown",
+    /** 默认 */
+    Default = "default",
+    /** 成功，无报错 */
+    None = "none"
+}
+export declare class MathError extends Error {
+    private _algorithm;
+    private _type;
+    private _params;
+    static showMutedWarn: boolean;
+    static assert(value: (() => boolean) | any, message?: string, type?: MathErrorType, ...params: MathErrorParamType[]): void;
+    static warn(value: (() => boolean) | any, message?: string, type?: MathErrorType, ...params: MathErrorParamType[]): void;
+    static mutedWarn(value: (() => boolean) | any, message?: string, type?: MathErrorType, ...params: MathErrorParamType[]): void;
+    constructor(message?: string, _algorithm?: string, _type?: MathErrorType, _params?: MathErrorParamType[]);
+    get algorithm(): string;
+    set algorithm(value: string);
+    get type(): MathErrorType;
+    set type(type: MathErrorType);
+    get name(): string;
+    get params(): MathErrorParamType[];
+    set params(params: MathErrorParamType[]);
+    get fullMessage(): string;
+    toString(): string;
+}