@ccpc/math 0.1.0 → 0.1.3

package/types/base/coord3.d.ts

@@ -0,0 +1,139 @@
+import { Vec3 } from './vec3';
+import { Matrix4 } from './matrix4';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Coord } from './coord';
+/**
+ * 坐标系
+ */
+declare class Coord3 extends Coord<Vec3> {
+    /**
+     * 构造XOY坐标系
+     * @param z 原点的Z坐标，默认为零
+     */
+    static XOY(z?: number): Coord3;
+    /**
+     * 构造YOZ坐标系
+     * @param x 原点的X坐标，默认为零
+     */
+    static YOZ(x?: number): Coord3;
+    /**
+     * 构造ZOX坐标系
+     * @param y 原点的Y坐标，默认为零
+     */
+    static ZOX(y?: number): Coord3;
+    /**
+     * 构造XOZ坐标系
+     * @param y 原点的Y坐标，默认为零
+     */
+    static XOZ(y?: number): Coord3;
+    /**
+     * 从局部坐标系1到局部坐标系2的变换矩阵
+     * Lp1 = Wp.M1
+     * @param coor1
+     * @param coor2
+     */
+    static getTransformFrom1To2(coor1: Coord3, coor2: Coord3): Matrix4 | undefined;
+    private _origin;
+    private _xDir;
+    private _yDir;
+    private _zDir;
+    constructor();
+    constructor(origin: types.IXYZ, zDir?: types.IXYZ);
+    constructor(origin: types.IXYZ, xDir: types.IXYZ, yDir: types.IXYZ);
+    /**
+     * 获取X方向
+     */
+    getDx(): Vec3;
+    /**
+     * 设置X方向
+     * @param v
+     */
+    setDx(v: types.IXYZ): void;
+    /**
+     * 获取Y方向
+     */
+    getDy(): Vec3;
+    /**
+     * 设置Y方向
+     * @param v
+     */
+    setDy(v: types.IXYZ): void;
+    /**
+     * 获取Z方向
+     */
+    getDz(): Vec3;
+    /**
+     * 获取原点
+     */
+    getOrigin(): Vec3;
+    /**
+     * 设置原点
+     * @param o 原点
+     */
+    setOrigin(o: types.IXYZ): void;
+    /**
+     * 设置XY方向
+     * @param xDir X方向
+     * @param yDir Y方向
+     */
+    setXYDirs(xDir: types.IXYZ, yDir: types.IXYZ): this;
+    /**
+     * z轴反向 (Y轴也会反向)
+     */
+    reverseZDir(): this;
+    /**
+     * 平移，改变自己
+     * @param delta
+     */
+    translate(delta: types.IXYZ): this;
+    /**
+     * 平移，得到一个新的对象
+     * @param delta
+     */
+    translated(delta: types.IXYZ): Coord3;
+    /**
+     * 矩阵变换，改变自己。非等比缩放时，保证 dx 方向变换
+     * @param m
+     */
+    transform(m: types.IMatrix4 | types.numberArrs4X4): this;
+    /**
+     * 矩阵变换，得到一个新的对象。非等比缩放时，保证 dx 方向变换
+     * @param m
+     */
+    transformed(m: types.IMatrix4 | types.numberArrs4X4): Coord3;
+    /**
+     * 根据当前局部坐标系的点获取世界坐标系的点
+     * @param uvw
+     */
+    getWorldPtAt(uvw: types.IXY | types.IXYZ): Vec3;
+    /**
+     * 根据世界坐标系的点获取当前局部坐标系的点
+     * @param worldPt
+     */
+    getLocalPtAt(worldPt: types.IXYZ): Vec3;
+    /**
+     * 根据当前局部坐标系的向量获取世界坐标系的向量
+     * @param localVec
+     */
+    getWorldVectorAt(localVec: types.IXY | types.IXYZ): Vec3;
+    /**
+     * 根据世界坐标系的向量获取当前局部坐标系的向量
+     * @param worldVec
+     */
+    getLocalVectorAt(worldVec: types.IXYZ): Vec3;
+    /**
+     * 构造一个矩阵，将当前局部坐标系的位置变换到世界坐标系
+     */
+    getLocalToWorldMatrix(): Matrix4;
+    /**
+     * 构造一个矩阵，将世界坐标系位置变换到当前局部坐标系
+     */
+    getWorldToLocalMatrix(): Matrix4;
+    clone(): Coord3;
+    dump(): types.IDBCoordinate3;
+    load({ data: [o, x, y] }: types.IDBCoordinate3): this;
+    getType(): EN_GEO_TYPE.COORD_3;
+    private _update;
+}
+export { Coord3 };

package/types/base/discrete_param.d.ts

@@ -0,0 +1,28 @@
+import { Tol } from './tol';
+export declare class DiscreteParam {
+    tolerance: Tol;
+    crossEps: number;
+    hintSegmentCount: number;
+    maxSegmentCount: number;
+    maxFaceletCount: number;
+    enableSurfaceRefiner: boolean;
+    static readonly LOW: DiscreteParam;
+    static readonly NORMAL: DiscreteParam;
+    static readonly HIGH: DiscreteParam;
+    static readonly BorderScale = 0.1;
+    static readonly UvDisEps = 0.1;
+    static readonly CALCULATE: DiscreteParam;
+    private static readonly _MIN_HINT_SEGMENT_COUNT;
+    private static readonly _MIN_TOLER_ANGLE_EPS;
+    constructor(tolerance: Tol, crossEps: number, // 差乘容差，用于面离散时判断是否需要拆分边
+    hintSegmentCount: number, maxSegmentCount: number, maxFaceletCount: number, enableSurfaceRefiner: boolean);
+    clone({ tolerance, crossEps, hintSegmentCount, maxSegmentCount, maxFaceletCount, enableSurfaceRefiner, }: {
+        tolerance?: Tol | undefined;
+        crossEps?: number | undefined;
+        hintSegmentCount?: number | undefined;
+        maxSegmentCount?: number | undefined;
+        maxFaceletCount?: number | undefined;
+        enableSurfaceRefiner?: boolean | undefined;
+    }): DiscreteParam;
+    ratioed(ratio?: number, enableSurfaceRefiner?: boolean): DiscreteParam;
+}

package/types/base/euler.d.ts

@@ -0,0 +1,102 @@
+import { Vec3 } from './vec3';
+import { Matrix4 } from './matrix4';
+export declare enum EulerOrder {
+    XYZ = 0,
+    YZX = 1,
+    ZXY = 2,
+    XZY = 3,
+    YXZ = 4,
+    ZYX = 5
+}
+/**
+ * 欧拉角
+ */
+export declare class Euler {
+    isEuler: boolean;
+    private _x;
+    private _y;
+    private _z;
+    private _order;
+    /**
+     * 构造函数
+     * @param x 绕X轴的旋转角度
+     * @param y 绕Y轴的旋转角度
+     * @param z 绕Z轴的旋转角度
+     * @param order 旋转顺序
+     */
+    constructor(x?: number, y?: number, z?: number, order?: EulerOrder);
+    /**
+     * 获取X轴的旋转角度
+     */
+    get x(): number;
+    /**
+     * 设置X轴的旋转角度
+     */
+    set x(value: number);
+    /**
+     * 获取Y轴的旋转角度
+     */
+    get y(): number;
+    /**
+     * 设置Y轴的旋转角度
+     */
+    set y(value: number);
+    /**
+     * 获取Z轴的旋转角度
+     */
+    get z(): number;
+    /**
+     * 设置Z轴的旋转角度
+     */
+    set z(value: number);
+    /**
+     * 获取旋转顺序
+     */
+    get order(): EulerOrder;
+    /**
+     * 设置旋转顺序
+     */
+    set order(value: EulerOrder);
+    /**
+     * 设置角度及旋转顺序
+     * @param x
+     * @param y
+     * @param z
+     * @param order
+     */
+    set(x: number, y: number, z: number, order: EulerOrder): void;
+    clone(): Euler;
+    /**
+     * 从另一个欧拉角复制，改变自己
+     * @param euler
+     */
+    copyFrom(euler: Euler): void;
+    /**
+     * 从旋转矩阵，旋转顺序，计算出旋转角度
+     * @param m
+     * @param order
+     */
+    setFromRotationMatrix(m: Matrix4, order: EulerOrder): void;
+    /**
+     * 设置旋转角度和顺序（角度分别为向量的三个分量）
+     * @param v
+     * @param order
+     */
+    setFromVector3(v: Vec3, order?: EulerOrder): void;
+    isEqual(euler: Euler): boolean;
+    /**
+     * 设置旋转角度和顺序（依次为数组0~3个元素）
+     * @param array
+     */
+    fromArray(array: any[]): this;
+    /**
+     * 将旋转角度及顺序转成数组
+     * @param array
+     * @param offset
+     */
+    toArray(): any[];
+    /**
+     * 将旋转角度转成向量
+     */
+    toVector(): Vec3;
+}

package/types/base/geo_element.d.ts

@@ -0,0 +1,54 @@
+import { types } from '../type_define/i_types';
+import { IGeo } from '../type_define/i_element';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Vec2 } from './vec2';
+import { Vec3 } from './vec3';
+import { Ln2 } from '../geometry/ln2';
+import { Arc2 } from '../geometry/arc2d';
+import { NurbsCurve2 } from '../geometry/nurbs_curve2';
+import { OffsetCurve2 } from '../geometry/offset_curve2';
+import { SmoothPoly2 } from '../geometry/smooth_poly2';
+import { SmoothPoly3 } from '../geometry/smooth_poly3';
+import { Loop } from '../topology/loop';
+import { Ln3 } from '../geometry/ln3';
+import { Arc3 } from '../geometry/arc3d';
+import { Circle3d } from '../geometry/circle3d';
+import { OffsetCurve3 } from '../geometry/offset_curve3';
+import { NurbsCurve3 } from '../geometry/nurbs_curve3';
+import { Plane } from '../geometry/plane';
+import { Cylinder } from '../geometry/cylinder';
+import { IArc, ILine, INurbsCurve, IOffsetCurve } from '../type_define/i_geometry';
+import { Vec } from './vec';
+export declare abstract class GeoElement implements IGeo {
+    userData: {
+        [key: string]: any;
+    };
+    dUserData: {
+        [key: string]: any;
+    };
+    abstract getType(): EN_GEO_TYPE;
+    dump(): types.IDBLibGeo;
+    load(json: types.IDBLibGeo): this;
+    clone(): IGeo;
+    toString(): string;
+    isVector2(): this is Vec2;
+    isVector3(): this is Vec3;
+    isLine2d(): this is Ln2;
+    isArc2d(): this is Arc2;
+    isNurbsCurve2d(): this is NurbsCurve2;
+    isOffsetCurve2d(): this is OffsetCurve2;
+    isSmoothPoly2d(): this is SmoothPoly2;
+    isSmoothPoly3d(): this is SmoothPoly3;
+    isLoop(): this is Loop;
+    isLine3d(): this is Ln3;
+    isArc3d(): this is Arc3;
+    isCircle3d(): this is Circle3d;
+    isOffsetCurve3d(): this is OffsetCurve3;
+    isNurbsCurve3d(): this is NurbsCurve3;
+    isLine(): this is ILine<Vec>;
+    isArc(): this is IArc<Vec>;
+    isNurbsCurve(): this is INurbsCurve<Vec>;
+    isOffsetCurve(): this is IOffsetCurve<Vec>;
+    isPlane(): this is Plane;
+    isCylinder(): this is Cylinder;
+}

package/types/base/interval.d.ts

@@ -0,0 +1,122 @@
+import { types } from '../type_define/i_types';
+/**
+ * 区间
+ */
+declare class Interval {
+    /**
+     * 返回默认的无限大参数域
+     */
+    static infinit(): Interval;
+    /**
+     * 返回默认的无限大参数域
+     */
+    static infinitArray(): types.IInterval;
+    /**
+     * 一组区间的合并
+     * @param ranges
+     */
+    static merge(ranges: Interval[]): Interval[];
+    protected _min: number;
+    protected _max: number;
+    constructor();
+    /**
+     * 构造方法，最小点和最大点
+     * @param min
+     * @param max
+     * @param autoReset 若min>max 是否自动交换min与max
+     */
+    constructor(min: number, max: number, autoRest?: boolean);
+    get min(): number;
+    set min(v: number);
+    get max(): number;
+    set max(v: number);
+    set(min: number, max: number): this;
+    setInfinit(min?: number): this;
+    toArray(): types.IInterval;
+    /**
+     * 包含坐标轴上的一个点
+     * @param param
+     * @param tolerance
+     */
+    containsPt(param: number, tolerance?: number): boolean;
+    /**
+     * 判断如果param出了参数域，将param拉回到参数域边界
+     * @param param
+     */
+    clamp(param: number): number;
+    /**
+     * 点在区间端点上
+     * @param param
+     * @param tolerance
+     */
+    containsPtAtStartOrEnd(param: number, tolerance?: number): boolean;
+    /**
+     * 完全包含另一个区间
+     * @param param
+     * @param tolerance
+     */
+    containsInterval(another: Interval, tolerance?: number): boolean;
+    /**
+     * 返回范围内的参数
+     * @param params
+     * @param eps
+     * @returns
+     */
+    filterParams(params: number[]): number[];
+    /**
+     * 与另一个区间相等
+     * @param param
+     * @param tolerance
+     */
+    equals(another: Interval, tolerance?: number): boolean;
+    /**
+     * 返回区间长度
+     */
+    getLength(): number;
+    /**
+     * 返回区间中点
+     */
+    getMid(): number;
+    /**
+     * 与区间/点的距离，可使用该距离判断位置关系
+     * @param another
+     */
+    distanceTo(another: Interval | number): number;
+    /**
+     * 两个区间求交集，若区间没有交，则返回 []
+     * @param another
+     */
+    intersected(another: Interval, eps?: number): Interval[];
+    /**
+     * 减掉一组区间,若区间长度小于1e-6则自动舍掉
+     * @param ranges
+     */
+    subtracted(...ranges: Interval[]): Interval[];
+    /**
+     * 扩展
+     * @param pt
+     */
+    expandByPt(pt: number): this;
+    /**
+     * 区间的缩放，改变自己
+     * @param scale
+     */
+    multiply(scale: number): this;
+    /**
+     * 区间的打断算法
+     * @param ranges
+     */
+    splited(...ranges: (Interval | number)[]): Interval[];
+    clone(): Interval;
+    /**
+     * 减掉另一个区间
+     * @param another
+     */
+    protected _sub(another: Interval): Interval[];
+    /**
+     * 加上另一个区间
+     * @param another
+     */
+    protected _add(another: Interval): this;
+}
+export { Interval };

package/types/base/ivector.d.ts

@@ -0,0 +1,126 @@
+import { types } from '../type_define/i_types';
+import { GeoElement } from './geo_element';
+/**
+ *  向量和点
+ */
+export declare abstract class IVector extends GeoElement {
+    protected abstract readonly _data: number[];
+    constructor();
+    abstract clone(): IVector;
+    /**
+     * 向量相加，返回一个新对象
+     * @param another
+     */
+    abstract added(another: types.IXY | IVector): IVector;
+    /**
+     * 向量相减，返回一个新对象
+     * @param another
+     */
+    abstract subtracted(another: types.IXY | IVector): IVector;
+    /**
+     * 向量相乘，返回一个新对象
+     * @param scale
+     */
+    abstract multiplied(scale: number): IVector;
+    /**
+     * 向量反向，返回一个新对象
+     */
+    abstract reversed(): IVector;
+    /**
+     * 向量插值，返回一个新对象
+     * @param another
+     */
+    abstract interpolated(another: types.IXY | IVector, alpha: number): IVector;
+    /**
+     * 向量插值，返回两者中点
+     * @param another
+     */
+    abstract midTo(another: types.IXY | IVector): IVector;
+    /**
+     * 单位化向量，返回一个新对象
+     */
+    abstract normalized(): IVector;
+    /**
+     * 点的平移，返回一个新对象
+     * @param vector
+     */
+    abstract translated(vector: types.IXY | IVector): IVector;
+    /**
+     * 两向量之间的夹角，区间[0,PI]
+     * @param another
+     */
+    abstract angle(another: types.IXY | IVector): number;
+    /**
+     * 两向量是否垂直
+     * @param another
+     * @param eps 容差
+     */
+    abstract isPerpendicular(another: types.IXY | IVector, eps: number): boolean;
+    /**
+     * 两向量是否平行（同向或反向）
+     * @param another
+     * @param eps  容差
+     */
+    abstract isParallel(another: types.IXY | IVector, eps: number): boolean;
+    /**
+     * 向量点乘
+     * @param another
+     */
+    abstract dot(another: types.IXY | IVector): number;
+    /**
+     * 与另外一个向量的距离
+     */
+    abstract distanceTo(another: types.IXY | IVector): number;
+    /**
+     * 与另外一个向量的平方距离
+     */
+    abstract sqDistanceTo(another: types.IXY | IVector): number;
+    /**
+     * 向量是否相等
+     * @param param
+     * @param eps 容差
+     */
+    abstract equals(another: types.IXY | IVector, eps?: number): boolean;
+    get data(): number[];
+    /**
+     * 两向量是否同向(平行且方向相同)
+     * @param another
+     * @param eps 容差
+     */
+    isSameDirection(another: types.IXY | IVector, eps?: number): boolean;
+    /**
+     * 两向量是否反向(平行且方向相反)
+     * @param another
+     * @param eps 容差
+     */
+    isOpposite(another: types.IXY | IVector, eps?: number): boolean;
+    /**
+     * 向量的长度是否为0
+     * @param eps 容差
+     */
+    isZero(eps?: number): boolean;
+    /**
+     * 转成数组
+     */
+    toArray2(): types.IXYArr;
+    toArray3(): types.IXYZArr;
+    /**
+     * 转成types.types.IXY
+     */
+    toXY(): types.IXY;
+    /**
+     * 转成types.IXYZ
+     */
+    toXYZ(): types.IXYZ;
+    /**
+     *  计算向量的模长
+     */
+    getLength(): number;
+    /**
+     *  计算平方距离
+     */
+    getSqLength(): number;
+    dump(): types.IDBVector;
+    load({ data }: types.IDBVector): this;
+    private _resetData;
+}

package/types/base/matrix.d.ts

@@ -0,0 +1,108 @@
+import { GeoElement } from './geo_element';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+/**
+ * 矩阵的基类,目前的矩阵只能是方阵，按列优先存储
+ */
+declare abstract class Matrix<IMatrixArray extends number[][]> extends GeoElement {
+    protected _dim: number;
+    protected readonly _data: number[][];
+    constructor(_dim: number, data?: IMatrixArray, copy?: boolean);
+    /**
+     * 将矩阵元素按列输出到一维数组中
+     * @param array (可选参数) 存储结果的一维数组
+     * @param offset (可选参数) 一维数组中的偏移量
+     */
+    abstract toArray(array?: number[], offset?: number): number[];
+    /**
+     * 设置矩阵元素（依次设置每列）
+     * @param array
+     * @param offset ( 可选参数 ) 一维数组中的偏移量
+     */
+    abstract fromArray(array: number[], offset?: number): this;
+    /**
+     * 右乘一个矩阵，得到新的矩阵对象
+     * @param matrix
+     */
+    abstract multiplied(matrix: types.IMatrix<IMatrixArray> | IMatrixArray): Matrix<IMatrixArray>;
+    /**
+     * 左乘一个矩阵，得到新的矩阵对象
+     * @param matrix
+     */
+    abstract preMultiplied(matrix: types.IMatrix<IMatrixArray> | IMatrixArray): Matrix<IMatrixArray>;
+    /**
+     * 右乘以缩放系数，得到新的矩阵对象
+     * @param s
+     */
+    abstract multipliedScalar(s: number): Matrix<IMatrixArray>;
+    /**
+     * 矩阵求逆，得到新的逆矩阵对象
+     */
+    abstract inversed(): Matrix<IMatrixArray> | undefined;
+    /**
+     * 矩阵转置，得到新的转置矩阵对象
+     */
+    abstract transposed(): Matrix<IMatrixArray>;
+    /**
+     * 行列式
+     */
+    determinant(): number;
+    /**
+     * 将当前矩阵重置为逆矩阵,若矩阵行列式为0，没有逆矩阵，则返回undefined，否则返回this
+     */
+    inverse(): this | undefined;
+    /**
+     * 返回矩阵的维度
+     * @property dim
+     */
+    get dim(): number;
+    /**
+     * 返回矩阵内部的数据
+     */
+    get data(): number[][];
+    /**
+     * 设置某个特定值
+     * @param row 行
+     * @param col 列
+     * @param value 值
+     */
+    set(row: number, col: number, value: number): void;
+    /**
+     * 使当前矩阵变为单位阵
+     */
+    resetIdentity(): this;
+    /**
+     * 是否是单位阵
+     */
+    isIdentity(): boolean;
+    /**
+     * 右乘以另外一个矩阵，this * m，改变this
+     * @param m
+     */
+    multiply(matrix: types.IMatrix<IMatrixArray> | IMatrixArray): this;
+    /**
+     * 左乘以另外一个矩阵，m * this，改变this
+     * @param m
+     */
+    preMultiply(matrix: types.IMatrix<IMatrixArray> | IMatrixArray): this;
+    /**
+     * 右乘等于一个标量，改变自己
+     * @param s
+     */
+    multiplyScalar(s: number): this;
+    /**
+     * 矩阵转置，改变自己
+     */
+    transpose(): this;
+    /**
+     * 将二维数组拷贝到矩阵内部，改变自己
+     * @param another
+     */
+    copy(another: types.IMatrix<IMatrixArray> | IMatrixArray): this;
+    dump(): types.IDBMatrix;
+    load({ data }: {
+        type: EN_GEO_TYPE;
+        data: IMatrixArray;
+    }): this;
+}
+export { Matrix };