@ccpc/math 0.1.0 → 0.1.3

package/types/base/matrix3.d.ts

@@ -0,0 +1,118 @@
+import { Matrix } from './matrix';
+import { Vec2 } from './vec2';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+/**
+ * 3X3的方阵
+ */
+declare class Matrix3 extends Matrix<types.numberArrs3X3> implements types.IMatrix3 {
+    /**
+     * 从给定矩阵构造矩阵
+     * @param mat 源矩阵
+     * @param copyData 是否拷贝数据，为假时，直接在原数据基础上构造矩阵
+     */
+    static make(mat: types.IMatrix3 | types.numberArrs3X3, copyData?: boolean): Matrix3;
+    /**
+     * 构造一个平移矩阵
+     */
+    static makeTranslate({ x, y }: types.IXY): Matrix3;
+    /**
+     * 构造一个旋转矩阵
+     * @param pivot 旋转中心点
+     * @param theta 旋转角度
+     */
+    static makeRotate(pivot: types.IXY, theta: number): Matrix3;
+    /**
+     * 构造一个缩放矩阵
+     * @param pos 缩放中心点
+     * @param scale 缩放因子
+     */
+    static makeScale(pos: types.IXY, scale: number | types.IXY): Matrix3;
+    /**
+     * 构造一个镜像矩阵
+     * @param origin 镜像轴上一点
+     * @param dir 镜像轴的方向
+     */
+    static makeMirror(origin: types.IXY, dir: types.IXY): Matrix3;
+    /**
+     * 判断给定 svd 分解结果是否包含镜像变化
+     * @param svd
+     */
+    static isSvdMirror(svd: types.IMatrix3Svd): boolean;
+    /**
+     * 判断给定 svd 是否为等比缩放
+     * @param svd
+     */
+    static assertScaleEqual(scale: types.IXY): boolean;
+    /**
+     * 单位阵
+     */
+    constructor(data?: types.numberArrs3X3, copyData?: boolean);
+    /**
+     * 返回矩阵内部的数据
+     */
+    get data(): types.numberArrs3X3;
+    /**
+     * 按照列优先序将矩阵转为数组输出
+     * @param array 目标数组
+     * @param offset 输出在数组中的下标偏移
+     */
+    toArray(array?: number[], offset?: number): number[];
+    /**
+     * 按照列优先序从数组中读取数据
+     * @param array 源数组
+     * @param offset 输入在数组中的下标偏移
+     */
+    fromArray(array: number[], offset?: number): this;
+    /**
+     * 获取基础分量（两个轴和平移分量）
+     * @param index
+     */
+    getBasicVec(index: number): Vec2;
+    /**
+     * 是镜像矩阵
+     */
+    isMirror(): boolean;
+    /**
+     * 左乘一个平移矩阵，改变自己
+     * @param param0
+     */
+    applyTranslate({ x, y }: types.IXY): this;
+    /**
+     * 左乘一个旋转矩阵，改变自己
+     * @param pivot 旋转中心点
+     * @param theta 旋转角度
+     */
+    applyRotate(pivot: types.IXY, theta: number): this;
+    /**
+     * 左乘一个镜像矩阵，改变自己
+     * @param origin 轴上一点
+     * @param dir 轴的方向
+     */
+    applyMirror(origin: types.IXY, dir: types.IXY): this;
+    /**
+     * 左乘一个缩放矩阵，改变自己
+     * @param pos
+     * @param scale
+     */
+    applyScale(pos: types.IXY, scale: number | types.IXY): this;
+    /**
+     * 将矩阵分解为平移、旋转、缩放矩阵，M = T*R*S
+     * 对于非正交矩阵的情况，则返回空数组
+     */
+    decomposeTRS(): Matrix3[];
+    /**
+     * 将矩阵分解为平移旋转、缩放、旋转矩阵，M = TR*S*R
+     */
+    decompose(): types.IMatrix3Svd;
+    multiplied(matrix: types.IMatrix3 | types.numberArrs3X3): Matrix3;
+    preMultiplied(matrix: types.IMatrix3 | types.numberArrs3X3): Matrix3;
+    multipliedScalar(s: number): Matrix3;
+    multipliedVector3(vect: types.numberArr3): types.numberArr3;
+    inversed(): Matrix3 | undefined;
+    transposed(): Matrix3;
+    getType(): EN_GEO_TYPE.MATRIX_3;
+    clone(): Matrix3;
+    dump(): types.IDBMatrix3;
+}
+export { Matrix3 };

package/types/base/matrix4.d.ts

@@ -0,0 +1,166 @@
+import { Matrix } from './matrix';
+import { Vec3 } from './vec3';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { types } from '../type_define/i_types';
+import { Quaternion } from './quaternion';
+/**
+ * 4X4的方阵
+ */
+declare class Matrix4 extends Matrix<types.numberArrs4X4> implements types.IMatrix4 {
+    /**
+     * 从给定矩阵构造矩阵
+     * @param mat 源数据
+     * @param copyData 是否拷贝数据，为假时，直接在原数据基础上构造矩阵
+     */
+    static make(mat: types.IMatrix4 | types.numberArrs4X4, copyData?: boolean): Matrix4;
+    /**
+     * 构造一个平移矩阵
+     */
+    static makeTranslate({ x, y, z }: types.IXYZ): Matrix4;
+    /**
+     * 构造一个旋转矩阵
+     * @param ptOnAxis 旋转轴上的某个点
+     * @param axisDir 旋转轴
+     * @param angle 旋转角度
+     */
+    static makeRotate(ptOnAxis: types.IXYZ, axisDir: types.IXYZ, angle: number): Matrix4;
+    /**
+     * 构造一个绕X轴正向旋转的矩阵
+     * @param angle
+     */
+    static makeRotateX(angle: number): Matrix4;
+    /**
+     * 构造一个绕Y轴正向旋转的矩阵
+     * @param angle
+     */
+    static makeRotateY(angle: number): Matrix4;
+    /**
+     * 构造一个绕Z轴正向旋转的矩阵
+     * @param angle
+     */
+    static makeRotateZ(angle: number): Matrix4;
+    /**
+     * 由四元素构造一个旋转矩阵
+     * @param q
+     */
+    static makeRotateFromQuaternion(q: Quaternion): Matrix4;
+    /**
+     * 构造一个缩放矩阵
+     * number:等比缩放
+     *
+     * types.IXYZ:非等比缩放
+     */
+    static makeScale(pos: types.IXYZ, scale: number | types.IXYZ): Matrix4;
+    /**
+     * 构造一个镜像矩阵
+     * @param origin 镜像平面上一点
+     * @param normal 镜像平面的normal
+     */
+    static makeMirror(origin: types.IXYZ, normal: types.IXYZ): Matrix4;
+    /**
+     * 从3阶矩阵构造一个z轴不变的4阶矩阵
+     * @param m 三阶矩阵
+     */
+    static makeByMatrix3(matrix: types.IMatrix3 | types.numberArrs3X3): Matrix4;
+    /**
+     * 判断给定 svd 是否包含镜像变化
+     * @param svd
+     */
+    static isSvdMirror(svd: types.IMatrix4Svd): boolean;
+    /**
+     * 判断给定 svd 是否为等比缩放
+     * @param svd
+     */
+    static isScaleEqual(scale: types.IXYZ): boolean;
+    /**
+     * 判断给定 svd 是否包含缩放或者镜像等。判断是否只有刚体变换
+     * @param svd
+     */
+    static isOnlyTranslateAndRotate(scale: types.IXYZ): boolean;
+    /**
+     * 判断给定 svd 是否为等比缩放
+     * @param svd
+     */
+    static assertScaleEqual(scale: types.IXYZ): boolean;
+    constructor(data?: types.numberArrs4X4, copyData?: boolean);
+    /**
+     * 返回矩阵内部的数据
+     */
+    get data(): types.numberArrs4X4;
+    /**
+     * 按照列优先序输出矩阵
+     * @param array 输出的目标数组
+     * @param offset 输出的下标偏移量
+     */
+    toArray(array?: number[], offset?: number): number[];
+    /**
+     * 按照列优先序从数组中读取数据
+     * @param array 源数组
+     * @param offset 输入在数组中的下标偏移
+     */
+    fromArray(array: number[], offset?: number): this;
+    /**
+     * 获取基础分量（三个坐标轴和平移分量）
+     * @param index
+     */
+    getBasicVec(index: number): Vec3;
+    /**
+     * 左乘一个旋转矩阵，改变自己
+     * @param ptOnAxis 旋转轴上一点
+     * @param axisDir 旋转轴方向
+     * @param angle 旋转角度
+     */
+    applyRotate(ptOnAxis: types.IXYZ, axisDir: types.IXYZ, angle: number): this;
+    /**
+     * 左乘一个平移矩阵，改变自己
+     */
+    applyTranslate({ x, y, z }: types.IXYZ): this;
+    /**
+     * 左乘一个缩放矩阵，改变自己
+     * @param pos 缩放中心点
+     * @param scales 缩放因子
+     */
+    applyScale(pos: types.IXYZ, scales: number | types.IXYZ): this;
+    /**
+     * 左乘一个镜像矩阵，改变自己
+     * @param origin 镜像平面上一点
+     * @param normal 镜像平面的法向
+     */
+    applyMirror(origin: types.IXYZ, normal: types.IXYZ): this;
+    /**
+     * 获取平移分量
+     */
+    getTranslation(): Vec3;
+    /**
+     * 设置当前矩阵的平移分量
+     * @param translation
+     */
+    setTranslation(translation: types.IXYZ): this;
+    /**
+     * 获取缩放分量
+     */
+    getScale(): Vec3;
+    /**
+     * 将矩阵分解为平移、旋转、缩放矩阵，M = T*R*S
+     * 对于非正交矩阵的情况，则返回空数组
+     */
+    decomposeTRS(): Matrix4[];
+    /**
+     * 将矩阵分解为平移旋转、缩放、旋转矩阵，M = TR*S*R。分解保证 TR 与 R 的行列式 > 0，若输入矩阵含镜像分量，则 S.x < 0。
+     */
+    decompose(): types.IMatrix4Svd;
+    /**
+     * 是否包含镜像
+     */
+    isMirror(): boolean;
+    multiplied(matrix: types.IMatrix4 | types.numberArrs4X4): Matrix4;
+    preMultiplied(matrix: types.IMatrix4 | types.numberArrs4X4): Matrix4;
+    multipliedScalar(s: number): Matrix4;
+    multipliedVector4(vect: types.numberArr4): types.numberArr4;
+    inversed(): Matrix4 | undefined;
+    transposed(): Matrix4;
+    getType(): EN_GEO_TYPE.MATRIX_4;
+    dump(): types.IDBMatrix4;
+    clone(): Matrix4;
+}
+export { Matrix4 };

package/types/base/matrix_util.d.ts

@@ -0,0 +1,5 @@
+import { types } from '../type_define/i_types';
+export declare function isExpectedSqureMatrix(m: number[][], expectDim: number): boolean;
+export declare function convertToMatrix3(matrix: types.IMatrix3 | types.IMatrix4 | types.numberArrs3X3 | types.numberArrs4X4): types.numberArrs3X3;
+export declare function convertToMatrix4(matrix: types.IMatrix3 | types.IMatrix4 | types.numberArrs3X3 | types.numberArrs4X4): types.numberArrs4X4;
+export declare function isMirror(m: types.IMatrix3 | types.IMatrix4 | types.numberArrs3X3 | types.numberArrs4X4): boolean;

package/types/base/period_inverval.d.ts

@@ -0,0 +1,127 @@
+import { Interval } from './interval';
+import { types } from '../type_define/i_types';
+/**
+ * 周期区间
+ * min in [0, period)
+ * (max - min) in [0, period]
+ * min 和 max 设置后需调用 Regularize 使其满足上述条件
+ */
+declare class PeriodInterval extends Interval {
+    /**
+     * 判断输入区间是否为周期区间
+     * @param range
+     */
+    static isPeriod(range: PeriodInterval | Interval): range is PeriodInterval;
+    static areEqual(a: number, b: number, period?: number, eps?: number): boolean;
+    /**
+     * 将参数正规化至 [0, period)，会根据容差自动将结果吸附至端点
+     * @param param 待调整参数
+     * @param period 周期
+     * @param toler 容差
+     */
+    static RegularizeParam(param: number, period?: number, refParam?: number, eps?: number): number;
+    /**
+     * 一组区间的合并，仅支持同周期的区间
+     * 要求输入为正规化的周期区间
+     * @param ranges
+     */
+    static merge(ranges: PeriodInterval[]): PeriodInterval[];
+    static make(min: number, max: number, period: number): Interval;
+    private _period;
+    /**
+     * 构造方法，最小点和最大点
+     * @param min 最小值
+     * @param max 最大值
+     * @param period 周期
+     */
+    constructor(pMin: number, pMax: number, period?: number);
+    get min(): number;
+    set min(v: number);
+    get max(): number;
+    set max(v: number);
+    get period(): number;
+    set period(v: number);
+    set(min: number, max: number): this;
+    setInfinit(min?: number): this;
+    toArray(): types.IInterval;
+    toArrayWithPeriod(): types.IPeriodInterval;
+    /**
+     * 调整参数，将其拉回参数域
+     * @param param
+     */
+    clamp(param: number): number;
+    /**
+     * 调整 param 所在周期，使得返回结果 ret in [min, min + period)
+     * @param param
+     */
+    getRegularParam(param: number, eps?: number): number;
+    /**
+     * 包含坐标轴上的一个点
+     * @param param
+     * @param tolerance
+     */
+    containsPt(param: number, tolerance?: number): boolean;
+    /**
+     * 点在区间端点上
+     * @param param
+     * @param tolerance
+     */
+    containsPtAtStartOrEnd(param: number, tolerance?: number): boolean;
+    /**
+     * 完全包含另一个区间
+     * @param param
+     * @param tolerance
+     */
+    containsInterval(another: PeriodInterval, tolerance?: number): boolean;
+    /**
+     * 返回范围内的参数，返回的参数在区间 [min, min + period) 内
+     * @param params
+     * @param eps
+     * @returns
+     */
+    filterParams(params: number[]): number[];
+    /**
+     * 与另一个区间相等
+     * @param param
+     * @param tolerance
+     */
+    equals(that: PeriodInterval, tolerance?: number): boolean;
+    isClosed(tolerance?: number): boolean;
+    /**
+     * 与区间/点的距离，可使用该距离判断位置关系
+     * @param another
+     */
+    distanceTo(another: PeriodInterval | number): number;
+    /**
+     * 两个区间求交集，若区间没有交，则返回 []
+     * @param another
+     */
+    intersected(another: PeriodInterval, eps?: number): PeriodInterval[];
+    /**
+     * 减掉一组区间,若区间长度小于1e-6则自动舍掉
+     * @param ranges
+     */
+    subtracted(...ranges: PeriodInterval[]): PeriodInterval[];
+    /**
+     * 扩展
+     * @param pt
+     */
+    expandByPt(pt: number): this;
+    /**
+     * 区间的缩放，改变自己
+     * @param scale
+     */
+    multiply(scale: number): this;
+    /**
+     * 调整后，min in [0, period)
+     * (max - min) in [0, period)
+     */
+    regularize(): this;
+    /**
+     * 区间的打断算法
+     * @param ranges
+     */
+    splited(...ranges: (PeriodInterval | number)[]): PeriodInterval[];
+    clone(): PeriodInterval;
+}
+export { PeriodInterval };

package/types/base/quaternion.d.ts

@@ -0,0 +1,39 @@
+import { Euler } from './euler';
+import { Matrix4 } from './matrix4';
+import { Vec3 } from './vec3';
+/**
+ * 四元素
+ */
+export declare class Quaternion {
+    private _x;
+    private _y;
+    private _z;
+    private _w;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    set(x: number, y: number, z: number, w: number): void;
+    clone(): Quaternion;
+    copy(quaternion: Quaternion): this;
+    setFromEuler(euler: Euler): this;
+    setFromAxisAngle(axis: Vec3, angle: number): this;
+    setFromRotationMatrix(m: Matrix4): this;
+    setFromUnitVectors(vFrom: Vec3, vTo: Vec3): this;
+    reverse(): this;
+    conjugate(): this;
+    dot(v: Quaternion): number;
+    lengthSq(): number;
+    length(): number;
+    normalize(): this;
+    multiply(q: Quaternion): this;
+    premultiply(q: Quaternion): this;
+    multiplyQuaternions(a: Quaternion, b: Quaternion): this;
+    fromArray(array: number[]): this;
+    toArray(): number[];
+}

package/types/base/tangent_cone.d.ts

@@ -0,0 +1,11 @@
+import { Vec3 } from './vec3';
+export declare class TangentCone {
+    dir: Vec3;
+    angle: number;
+    constructor(theDir: Vec3, theAngle: number);
+    isConeEmpty(): boolean;
+    isConeValid(): boolean;
+    copy(rCone: TangentCone): void;
+    mergeCone(rVt: Vec3, bApprox?: boolean): boolean;
+    mergeTwoCone(rCone: TangentCone, rSrcCone: TangentCone): boolean;
+}

package/types/base/tilt_box.d.ts

@@ -0,0 +1,11 @@
+import { Box3 } from './box3';
+import { Coord3 } from './coord3';
+import { Vec3 } from './vec3';
+export declare class TiltBox3 extends Box3 {
+    coord: Coord3;
+    constructor(box: Box3, coord: Coord3);
+    getCoord(): Coord3;
+    getBox(): Box3;
+    getCornerPts(): Vec3[];
+    union(box: Box3): this;
+}

package/types/base/tol.d.ts

@@ -0,0 +1,120 @@
+import { types } from '../type_define/i_types';
+export declare class Tol {
+    readonly lengthEps: number;
+    readonly angleEps: number;
+    readonly processLengthEps: number;
+    readonly edgeLengthEps: number;
+    /**
+     * 默认的double数值级别的容差
+     */
+    static NUMBER: number;
+    static NUMBER_2: number;
+    /**
+     * 默认的长度容差 1e-6mm
+     */
+    static LENGTH: number;
+    static LENGTH_2: number;
+    /**
+     * 几何体的默认长度容差 0.001mm。譬如说edge和vertex之间可能存在容差，但是要小于0.001
+     */
+    static EDGE_LENGTH_EPS: number;
+    static EDGE_LENGTH_EPS2: number;
+    /**
+     * 计算中间过程的容差，比长度容差略小
+     */
+    static PROCESS_LENGTH_EPS: number;
+    /**
+     * 默认的角度容差
+     */
+    static ANGLE: number;
+    /**
+     * 粗糙角度容差，用于退化情况的判断
+     */
+    static ROUGH_ANGLE_EPS: number;
+    static DELTA_EPS: number;
+    static NUMBER_CALC_EPS: number;
+    static ZERO_JUDGE_EPS: number;
+    static ZERO_JUDGE_EPS2: number;
+    static CALCULATE_EPS: number;
+    static CALCULATE_EPS2: number;
+    static CALCULATE_EPS4: number;
+    static CLIPPER_SCALE: number;
+    static readonly DEFAULT: Tol;
+    readonly lengthEps2: number;
+    readonly processLengthEps2: number;
+    readonly edgeLengthEps2: number;
+    /**
+     * 设置全局默认的容差
+     * @param lengthEps 判定用长度容差
+     * @param angleEps 判定用角度容差
+     * @param processLengthEps 生成几何用的长度容差
+     */
+    constructor(lengthEps?: number, angleEps?: number, processLengthEps?: number, edgeLengthEps?: number);
+    /**
+     * @deprecated
+     * 请使用this.numberEps代替
+     */
+    get numEps(): number;
+    /**
+     * 判定用数值容差。不鼓励使用此值，应尽量根据几何信息进行容差判断
+     */
+    get numberEps(): number;
+    /**
+     * 判断两个角度是否相等
+     * @param a
+     * @param b
+     */
+    areAnglesEqual(a: number, b: number): boolean;
+    /**
+     * 判断两个长度是否相等
+     * @param a
+     * @param b
+     */
+    areLengthEqual(a: number, b: number): boolean;
+    /**
+     * 判断两个参数是否相等
+     * @param a
+     * @param b
+     */
+    areParamEqual(a: number, b: number): boolean;
+    /**
+     * 判断长度是否接近 0
+     * @param a
+     */
+    isLengthZero(a: number): boolean;
+    /**
+     * 判断长度的平方是否接近 0
+     * @param a
+     */
+    isSquareLengthZero(a: number): boolean;
+    /**
+     * 判断参数是否在周期参数域的0点或周期点上
+     * @param a
+     * @param period
+     */
+    isParamOnPeriodEnd(a: number, period?: number): boolean;
+    /**
+     * 判断两个向量是否平行
+     * @param a
+     * @param b
+     */
+    areParralel(a: types.IXY, b: types.IXY): boolean;
+    /**
+     * 判断两个向量是否平行
+     * @param a
+     * @param b
+     */
+    areParralel(a: types.IXYZ, b: types.IXYZ): boolean;
+    /**
+     * 判断两个顶点是否重合
+     * @param a
+     * @param b
+     */
+    areNear(a: types.IXY, b: types.IXY): boolean;
+    /**
+     * 判断两个顶点是否重合
+     * @param a
+     * @param b
+     */
+    areNear(a: types.IXYZ, b: types.IXYZ): boolean;
+}

package/types/base/vec.d.ts

@@ -0,0 +1,46 @@
+import { types } from '../type_define/i_types';
+import { IVector } from './ivector';
+/**
+ *  向量
+ */
+export declare abstract class Vec extends IVector {
+    constructor();
+    get x(): number;
+    get y(): number;
+    set x(x: number);
+    set y(y: number);
+    abstract clone(): Vec;
+    /**
+     * 向量加等于，会改变this，返回this
+     * @param another
+     */
+    abstract add(another: types.IXY | Vec): this;
+    /**
+     * 向量减等于，会改变this，返回this
+     * @param another
+     */
+    abstract subtract(another: types.IXY | Vec): this;
+    /**
+     * 向量线性插值等于，会改变this，返回this
+     * this = (1 - alpha)* this + alpha * another
+     * @param anotherVector
+     */
+    abstract interpolate(another: types.IXY | Vec, alpha: number): this;
+    abstract copy(another: types.IXY | Vec): this;
+    /**
+     * 向量乘等于，会改变this，返回this
+     * @param scale
+     */
+    multiply(scale: number): this;
+    /**
+     * 向量反向，会改变this，返回this
+     */
+    reverse(): this;
+    /**
+     * 单位化向量，会改变this
+     * @returns 返回this
+     */
+    normalize(): this;
+    translate(vec: types.IXY | Vec): this;
+    resetFromArray(array: number[]): this;
+}