@ccpc/math 0.1.0 → 0.1.7

package/types/geometry/smooth_poly3.d.ts

@@ -0,0 +1,85 @@
+import { Curve3 } from './curve3d';
+import { types } from '../type_define/i_types';
+import { Vec3 } from '../base/vec3';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Box3 } from '../base/box3';
+import { Ln3 } from './ln3';
+import { Interval } from '../base/interval';
+import { DiscreteParam } from '../base/discrete_param';
+import { geom } from '../verb/verb';
+/**
+ * 三维多段直线
+ * 主要用在拉伸，扫掠算法中，形成光滑的面
+ */
+export declare class SmoothPoly3 extends Curve3 {
+    private _pts;
+    private _ts;
+    private _curve?;
+    constructor();
+    constructor(pts: types.IXYZ[], refCurve?: Curve3);
+    /**
+     * 获取连续点的数组
+     */
+    getPoints(): ReadonlyArray<Vec3>;
+    toVerbNurbs(range?: Interval | undefined): geom.NurbsCurve;
+    /**
+     * 获取连续点对应参数的数组
+     */
+    getTs(): ReadonlyArray<number>;
+    /**
+     * 获取背后的光滑曲线
+     */
+    getCurve(): Curve3 | undefined;
+    /**
+     * 获取所有的直线段
+     */
+    getSegments(): Ln3[];
+    /**
+     * 获取某参数对应的点
+     */
+    getPtAt(t: number): Vec3;
+    /**
+     *  获取某参数对应的点
+     */
+    getParamAt(point: types.IXYZ): number;
+    /**
+     * 获取某参数处的切线
+     */
+    getTangentAt(t: number): Vec3;
+    /**
+     *  获取某参数t处的几阶导数
+     * t : 参数t
+     * n : 导数的阶数 // 譬如n = 2，会计算曲线在参数t处的0阶导(即曲线点)、1阶导、2阶导
+     */
+    getDerivatives(t: number, n: number): Vec3[];
+    /**
+     *  获取曲线(给定参数域区间段的)长度
+     */
+    getLength(range?: Interval): number;
+    /**
+     * 反向
+     */
+    reverse(): this;
+    offset(dDist: number): boolean;
+    /**
+     * 分割SmoothPoly为两段，如果分割点不在直线上，则返回空数组
+     * @param param
+     * @param tolerance
+     */
+    split(params: number[], tolerance?: number): Curve3[];
+    transform(m: types.IMatrix4 | types.numberArrs4X4): this;
+    /**
+     * 计算曲线在给定参数区间的包围盒，如果没有传入参数域则计算曲线默认参数域的包围盒
+     */
+    getBBox(range?: Interval): Box3;
+    discrete(params?: DiscreteParam): Vec3[];
+    getType(): EN_GEO_TYPE.SMOOTHPOLY_3D;
+    clone(): SmoothPoly3;
+    /**
+     * 抽取元数据，用于序列化
+     */
+    dump(): types.IDBSmoothPoly3d;
+    load(json: types.IDBSmoothPoly3d): this;
+    private _getSegment;
+    private _calParams;
+}

package/types/geometry/surface.d.ts

@@ -0,0 +1,173 @@
+import { Curve2 } from './curve2';
+import { Curve3 } from './curve3d';
+import { types } from '../type_define/i_types';
+import { Vec3 } from '../base/vec3';
+import { Vec2 } from '../base/vec2';
+import { Box3 } from '../base/box3';
+import { Tol } from '../base/tol';
+import { DiscreteParam } from '../base/discrete_param';
+import { Geometry3d } from '../geometry/geometry3d';
+import { Interval } from '../base/interval';
+import { ISurfaceTransformExtra } from '../type_define/i_geometry';
+/**
+ * 曲面基类
+ */
+declare abstract class Surface extends Geometry3d {
+    constructor();
+    /**
+     * 获取uv处的三维点
+     * @param uv
+     */
+    abstract getPtAt(uv: types.IXY): Vec3;
+    /**
+     * 获取三维点处的uv值，（反求参数）
+     * @param pt
+     */
+    abstract getUVAt(pt: types.IXYZ): Vec2;
+    /**
+     * 获取uv处的法矢
+     * @param uv
+     */
+    abstract getNormAt(uv: types.IXY): Vec3;
+    /**
+     *  获取某参数t处的n阶偏导数
+     * t : 参数t
+     * n : 导数的阶数 // 譬如n = 2，会计算曲线在参数t处的0阶导(即曲线点)，1阶偏导（包含偏u、偏v），2阶偏导（包含偏uu、偏uv、偏vv）
+     */
+    abstract getDerivatives(uv: types.IXY, n: number): Vec3[];
+    /**
+     * 几何变换，改变自己
+     * @param m
+     */
+    abstract transform(m: types.IMatrix4 | types.numberArrs4X4, extra?: ISurfaceTransformExtra): this;
+    /**
+     * 是否和另一个曲面面完全重叠
+     * @param other
+     * @param tol
+     */
+    abstract isCoplanar(other: Surface, tol: Tol): boolean;
+    /**
+     * 曲线是否在曲面上
+     * @param curve
+     * @param tolerance
+     */
+    abstract containsCurve(curve: Curve3, tolerance: number): boolean;
+    /**
+     * 获取等参曲线
+     * @param param 等参曲线处的参数
+     * @param useV true 时返回等 v 参数曲线，false 时返回等 u 参数曲线
+     */
+    abstract getIsoCurve(param: number, useV: boolean): Curve3;
+    /**
+     * U向是周期性的
+     */
+    isUPeriodic(): boolean;
+    /**
+     * V向是周期性的
+     */
+    isVPeriodic(): boolean;
+    /**
+     * 是否是直纹面
+     */
+    isRuled(): boolean;
+    /**
+     * 获取曲面的domainU
+     */
+    getDomainU(): Interval;
+    /**
+     * 获取曲面的domainV
+     */
+    getDomainV(): Interval;
+    clampInDomain(paraXY: types.IXY): void;
+    getBBox(): Box3;
+    getBox(theRangeU?: Interval, theRangeV?: Interval): Box3;
+    /**
+     * 获取三维点p处的法矢
+     * @param p
+     */
+    getNormAtPoint(p: types.IXYZ): Vec3;
+    /**
+     * 获取曲面的奇异点
+     */
+    getSingularPoints(): Vec3[];
+    /**
+     * 平移，改变自己
+     * @param offset 平移量
+     */
+    translate(offset: types.IXYZ): this;
+    /**
+     * 旋转，改变自己
+     * @param angle 旋转角度
+     * @param pivot 旋转轴上的一个点
+     * @param axis 旋转轴方向
+     */
+    rotate(angle: number, pivot: Vec3, axis: Vec3): this;
+    /**
+     *  克隆
+     */
+    clone(): any;
+    /**
+     * 几何变换，得到新的几何对象 // 处理镜像变换时，保留V向和法向
+     * @param m
+     */
+    transformed(m: types.IMatrix4 | types.numberArrs4X4, extra?: ISurfaceTransformExtra): Surface;
+    /**
+     * 点到曲面的垂足
+     */
+    getProjectedPtBy(point: types.IXYZ): Vec3;
+    /**
+     * 点是否在曲面上
+     * @param point
+     * @param tolerance
+     */
+    containsPt(point: types.IXYZ, tolerance?: number): boolean;
+    /**
+     * 点到曲面的距离
+     * @deprecated 请使用CalculateDistance.ptToSurf()接口
+     * @param point
+     */
+    distanceToPoint(point: types.IXYZ): number;
+    /**
+     * 点到曲面的有向距离， 点在正向，距离为正，否则为负
+     * @deprecated 请使用CalculateDistance.ptToSurfSigned()接口
+     * @param point
+     */
+    signDistanceToPoint(point: types.IXYZ): number;
+    /**
+     * 计算给定点的参数, 牛顿迭代法对曲面的投影点逐步求精
+     * @param pt3d 要反求参数的point
+     * @param refUV 参考参数UV
+     * @param lengthEps 距离误差
+     * @param angleEps 角度误差
+     * @param validLengthU 如果需要验证求到的参数是否距离给定参考的参数refUV.x太远，如果距离太远可能是计算的参数不准，用其他方法计算所有的参数，选一个最近的参数
+     * @param validLengthV 如果需要验证求到的参数是否距离给定参考的参数refUV.y太远，如果距离太远可能是计算的参数不准，用其他方法计算所有的参数，选一个最近的参数
+     */
+    getUVNearParam(pt3d: Vec3, refUV: types.IXY, lengthEps?: number, angleEps?: number, validLengthU?: number, validLengthV?: number): Vec2;
+    getCurve2dForIsoCurve(pt3ds: Vec3[]): Curve2 | undefined;
+    /**
+     * 将三维曲线，转成参数域的二维曲线：对于平面，得到的是精确的参数域曲线；对于其他曲面，得到的是精确表达的直线，或者是nurbs2d曲线
+     * 注：传入参数时，请保证曲线必须在曲面surface上。如果曲线不在曲面上，请调用投影接口。平面投影接口：Curve3ProjectToPlane
+     * @param curve 在曲面上的曲线
+     */
+    getCurve2d(curveOnSurface: Curve3): Curve2;
+    /**
+     * 将参数域中的二维曲线映射到曲面上的三维曲线
+     * @param curve 二维参数域曲线 // 对于NurbsSurface，请保证二维曲线在surface的domain内
+     */
+    getCurve3d(curve: Curve2): Curve3;
+    wireToUV(loop3d: Curve3[], tol?: Tol): {
+        loop: Curve2[];
+        mapping: Map<Curve3, Curve2>;
+    };
+    /**
+     *  the firs fundamental form: E, F, G
+     * @param u
+     * @param v
+     * @return [E, F, G]
+     */
+    firstFundamentalForm(uv: types.IXY): number[];
+    tessellate(params?: DiscreteParam, tol?: Tol): types.IRenderNode;
+    discrete(params?: DiscreteParam, tol?: Tol): types.IMesh;
+    protected _containsBaseCurve(curve: Curve3, tol?: number): boolean;
+}
+export { Surface };

package/types/index.d.ts

@@ -0,0 +1,78 @@
+import * as alg from './algorithm';
+import * as MatrixUtil from './base/matrix_util';
+import * as ClipperLib from './clipperlib/clipperlib';
+import * as brep from './brep-src';
+export { brep };
+export declare const VERSION = "\"@sk-3d/math\":\"0.1.1\"";
+export type { types } from './type_define/i_types';
+export { EN_GEO_TYPE } from './type_define/i_element_type';
+export type { IGeo } from './type_define/i_element';
+export { GeoElement } from './base/geo_element';
+export type { IGeometry, IGeometry2d, IGeometry3d } from './type_define/i_geometry';
+export { Interval } from './base/interval';
+export { PeriodInterval } from './base/period_inverval';
+export { Box } from './base/box';
+export { Box2 } from './base/box2';
+export { Box3 } from './base/box3';
+export { Vec } from './base/vec';
+export { Vec2 } from './base/vec2';
+export { Vec3 } from './base/vec3';
+export { Matrix } from './base/matrix';
+export { Matrix3 } from './base/matrix3';
+export { Matrix4 } from './base/matrix4';
+export { Quaternion } from './base/quaternion';
+export { Coord } from './base/coord';
+export { Coord2 } from './base/coord2';
+export { Coord3 } from './base/coord3';
+export { Euler } from './base/euler';
+export { Tol } from './base/tol';
+export { DiscreteParam } from './base/discrete_param';
+export { Curve } from './geometry/curve';
+export { Curve2 } from './geometry/curve2';
+export { Curve3 } from './geometry/curve3d';
+export { Ln2 } from './geometry/ln2';
+export { Ln3 } from './geometry/ln3';
+export { Arc2, ArcType } from './geometry/arc2d';
+export { Arc3 } from './geometry/arc3d';
+export { Circle3d } from './geometry/circle3d';
+export { Surface } from './geometry/surface';
+export { Plane } from './geometry/plane';
+export { Cylinder } from './geometry/cylinder';
+export { NurbsCurve2 } from './geometry/nurbs_curve2';
+export { NurbsCurve3 } from './geometry/nurbs_curve3';
+export { SmoothPoly2 } from './geometry/smooth_poly2';
+export { SmoothPoly3 } from './geometry/smooth_poly3';
+export { OffsetCurve2 } from './geometry/offset_curve2';
+export { OffsetCurve3 } from './geometry/offset_curve3';
+export { IntersectCurve3 } from './geometry/intersect_curve3';
+export { PolyCurve } from './topology/polycurve';
+export { Loop } from './topology/loop';
+export { Polygon } from './topology/polygon';
+export { TrimmedSurface } from './topology/trimmed_surface';
+export { EvolutionMap } from './topology/evolution_map';
+export { InvBilinear } from './math/inv_bilinear';
+export { gaussIntegration } from './math/gauss_integration';
+export { SolveEquationUtil } from './solve_equations/solve_equation_util';
+export { type ISVGData, SVGParser } from './io/svgparser';
+export { ObjParser } from './io/obj_parser';
+export { CONST } from './type_define/const';
+export { Loader } from './loader/loader';
+export { registerGeo } from './loader/register_geo';
+export { Util as Util } from './util/util';
+export { GeomUtil } from './util/geom_util';
+export { CurveUtil } from './util/curve_util';
+export { UvUtil } from './util/uv_util';
+export { SurfaceUtil } from './util/surface_util';
+export { ClipperUtil } from './util/clipper_util';
+export { Clipper2Util } from './util/clipper2_util';
+export { MathAssert } from './util/assert';
+export { UnitType, UnitsConversion, NormalUnitsConversion } from './conversion/units_conversion';
+export { Log } from './util/log';
+export { MathError, MathErrorType, type MathErrorParamType } from './util/math_error';
+export { alg };
+export { MatrixUtil };
+export { ClipperLib };
+export * from './wasm/grapher2d';
+export * from './wasm/grapherutil';
+export { loadWasmInstanceAsync, getGeomInstance } from './wasm/loader';
+export { GeomLibWrapper, Geom } from './wasm/wrapper';

package/types/io/obj_parser.d.ts

@@ -0,0 +1,4 @@
+import { types } from '../type_define/i_types';
+export declare class ObjParser {
+    static exportMeshes(meshes: types.IFlatMesh[]): string;
+}

package/types/io/svgparser.d.ts

@@ -0,0 +1,22 @@
+import { PolyCurve } from '../topology/polycurve';
+interface IIDPath {
+    id: string;
+    path: string;
+}
+export interface ISVGData {
+    innerFaces: IIDPath[];
+    outterFaces: IIDPath[];
+}
+export declare class SVGParser {
+    static stringToPolyCurves(svfPathString: string, _trimFloat?: boolean): PolyCurve[];
+    static svgDataToPolyCurves(svgData: ISVGData, trimFloat?: boolean): PolyCurve[];
+    private static _SVGStringToCommands;
+    private static _createBezierCurve;
+    /**
+     * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
+     * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
+     */
+    private static _computeEllipseInfo;
+    private static _computeArcInfo;
+}
+export {};

package/types/loader/loader.d.ts

@@ -0,0 +1,23 @@
+import { IGeo } from '../type_define/i_element';
+import { types } from '../type_define/i_types';
+/**
+ * 将字符串/Json反射为几何
+ */
+export declare class Loader {
+    private static _ctors;
+    static registerGeo(...ctors: types.Class<IGeo>[]): void;
+    /**
+     *  将字符串反序列化为几何，调试用
+     * @returns 返回几何元素或点
+     */
+    static reflect(str: string): IGeo[];
+    /**
+     *  根据元数据对象构造几何对象
+     * @returns 返回几何元素
+     */
+    static load(json: types.IDBLibGeo): IGeo;
+    /**
+     * load外部的mesh数据
+     */
+    static reflectMesh(jsonString: string): IGeo[];
+}

package/types/loader/register_geo.d.ts

@@ -0,0 +1,7 @@
+import { types } from '../type_define/i_types';
+import { IGeo } from '../type_define/i_element';
+/**
+ * 注册命令
+ * @param constructor
+ */
+export declare function registerGeo(constructor: types.Class<IGeo> | any): void;

package/types/math/gauss_integration.d.ts

@@ -0,0 +1,13 @@
+export interface IFunc {
+    (t: number): number;
+}
+/**
+ *   preform intergration for f between xlow and xhigh
+ * @param f
+ * @param xlow
+ * @param xhigh
+ * @param err 绝对误差
+ * @param rel 相对误差
+ * @return
+ */
+export declare function gaussIntegration(f: IFunc, xlow: number, xhigh: number, err: number, rel: number): number;

package/types/math/inv_bilinear.d.ts

@@ -0,0 +1,33 @@
+import { Vec2 } from '../base/vec2';
+import { types } from '../type_define/i_types';
+/**
+ * 逆双线性插值.
+ * 已知四个二维点和每个点处的uv值, 计算中间任意二维点处的uv值
+ * https://gameinstitute.qq.com/community/detail/121581
+ *
+ *              /                  \
+ *         D   /                    \ C
+ *     -------P2---------------------P3--------
+ *           /                        \
+ *          /                          \
+ *         /                            \
+ * -------P0----------------------------P1--------
+ *    A  /                                \ B
+ *      /                                  \
+ * P0's uv is (u0, v0),
+ * p1's uv is (u1, v0),
+ * p2's uv is (u0, v1),
+ * p3's uv is (u1, v1)
+ */
+export declare class InvBilinear {
+    private _u0;
+    private _u1;
+    private _v0;
+    private _v1;
+    private _p0;
+    private _p1;
+    private _p2;
+    private _p3;
+    constructor(u0: number, u1: number, v0: number, v1: number, p0: Vec2, p1: Vec2, p2: Vec2, p3: Vec2);
+    solve(p: Vec2): types.numberArr2 | undefined;
+}

package/types/solve_equations/cubic_equation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 三次方程求根（只求实数根）: a * x^3 + b * x^2 + c * x + d = 0 (a != 0)
+ */
+export declare class CubicEquation {
+    static solve(a: number, b: number, c: number, d: number): number[];
+    static solve2(a: number, b: number, c: number, d: number): number[] | undefined;
+}

package/types/solve_equations/linear_system.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 求解线性方程组：包装了LU和SVD分解解方程，可求解非满秩方程组，但A必须是方阵。// 解不了矛盾方程组
+ */
+export declare class LinearSystem {
+    static execute(A: number[][], b: number[]): number[] | undefined;
+}

package/types/solve_equations/nonlinear_system.d.ts

@@ -0,0 +1,11 @@
+export declare class NonlinearSystem {
+    /**
+     * 两个非线性方程的求解
+     * @func 方程组函数
+     * @calcJacbiFunc 计算雅各比矩阵
+     * @initParams 初始化函数初值
+     * @paramEps 容差
+     * @validFunc 额外的验证是否结束的函数 // 这个主要是求交用于验证距离满不满足容差的，不是求交可不必传入此函数
+     */
+    static execute(func: (params: number[]) => number[], calcJacbiFunc: (params: number[]) => number[][], initParams: number[], lengthEps?: number, angleEps?: number, validFunc?: (params: number[], distEps: number) => boolean): number[];
+}

package/types/solve_equations/plurality.d.ts

@@ -0,0 +1,9 @@
+export declare class Plurality {
+    a: number;
+    b: number;
+    constructor(a: number, b: number);
+    added(another: Plurality): Plurality;
+    subed(another: Plurality): Plurality;
+    scaled(s: number): Plurality;
+    multiplied(another: Plurality): Plurality;
+}

package/types/solve_equations/polynomial_equation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 多项式求根: a0 + a1 * x + a2 * x^2 + ... + an * x^n = 0
+ */
+export declare class PolynomialEquation {
+    static solve(a: number, b: number, c: number): number[];
+}

package/types/solve_equations/quadratic_equation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 二次方程求根: a * x^2 + b * x + c = 0
+ */
+export declare class QuadraticEquation {
+    static solve(a: number, b: number, c: number, eps?: number): number[];
+}

package/types/solve_equations/quartic_equation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 四次方程求根: a * x^4 + b * x^3 + c * x^2 + d * x + e = 0 (a != 0) // 求解存在问题，很多测试用例不通过
+ */
+export declare class QuarticEquation {
+    static solve(a: number, b: number, c: number, d: number, e: number): number[] | undefined;
+}

package/types/solve_equations/solve_equation_util.d.ts

@@ -0,0 +1,50 @@
+export declare class SolveEquationUtil {
+    /**
+     * 二次方程求根（只求实数根）: a * x^2 + b * x + c = 0
+     */
+    static solveQuadraticEquation(a: number, b: number, c: number): number[];
+    /**
+     * 三次方程求根（只求实数根）: a * x^3 + b * x^2 + c * x + d = 0
+     */
+    static solveCubicEquation(a: number, b: number, c: number, d: number): number[];
+    /**
+     * 方程求根
+     * @param func 方程函数
+     * @param xMin 所求参数区间的下限
+     * @param xMax 所求参数区间的上限
+     * @param paramEps 容差精度
+     */
+    static execute(func: (param: number) => number, xMin: number, xMax: number, paramEps?: number): number | undefined;
+    /**
+     * 牛顿迭代法，可能不收敛
+     * 备注：迭代收敛较快，但是对于多重根，迭代非常慢，需要改进；并且容易陷入局部极值点位置
+     * @param func 目标函数
+     * @param dvtFunc 计算目标函数一阶微分的函数
+     * @param x0 初值
+     * @param tol
+     */
+    static iterationNewton(func: (param: number) => number, dtFunc: (param: number) => number, x0: number, tol?: number, validEps?: number, maxIterNum?: number): number | undefined;
+    /**
+     * 改进的正割法（近似牛顿迭代法，可能不收敛）
+     * 备注：迭代收敛较快，但是对于多重根，迭代非常慢，需要改进；并且容易陷入局部极值点位置
+     * @param x0 初值
+     * @param tol
+     */
+    static linearInterpolation(func: (param: number) => number, x0: number, tol?: number): number | undefined;
+    /**
+     * 二次插值法（米勒法）: 求方程的根
+     * 备注：稳定性不错，但是给的初值不好，容易陷入局部极值点附近无意义循环
+     * @param x0 初值
+     * @param h 初始步长
+     * @param tol
+     */
+    static quadraticInterpolation(func: (param: number) => number, xMin: number, xMax: number, tol?: number): number | undefined;
+    /**
+     * 逆二次插值法: 求方程的根
+     * 备注：能保证能计算一个根，即使初值在局部极值点附近也能迭代最后到一个根（如果存在根），但是对于多重根的情况，（y值相等）会使用割线法，计算效率较低，并且达到的精度不够
+     * @param x0 初值
+     * @param h 初始步长
+     * @param tol
+     */
+    static inverseQuadraticInterpolation(func: (param: number) => number, x0: number | undefined, h: number, tol?: number): number | undefined;
+}

package/types/test_util/loop_generator.d.ts

@@ -0,0 +1,21 @@
+import { Curve2 } from '../geometry/curve2';
+export type LoopGenerateFunction = (a?: number, b?: number) => Curve2[];
+export declare class LoopGenerator {
+    /**
+     * 可以通过 AlgTestSweep.showLoops() 查看
+     */
+    static getLoopFuncs(): (typeof LoopGenerator.square)[];
+    static byPoints(points: number[][]): Curve2[];
+    static square(a?: number, b?: number): Curve2[];
+    static diamond(a?: number, b?: number): Curve2[];
+    static arcs(a?: number, b?: number): Curve2[];
+    static arcsRev(a?: number, b?: number): Curve2[];
+    static lineArc(a?: number, b?: number): Curve2[];
+    static lineArcTan(a?: number, b?: number): Curve2[];
+    static arcsTan(a?: number, b?: number): Curve2[];
+    static circle(a?: number, b?: number): Curve2[];
+    static offsetCurves(a?: number, b?: number): Curve2[];
+    static offsetCurvesTan(a?: number, b?: number): Curve2[];
+    static offsetCurveWithSingularity(a?: number, _b?: number): Curve2[];
+    static offsetCurveReverse(a?: number, _b?: number): Curve2[];
+}