xl-public-utils 1.0.11 → 1.0.12

package/index.d.ts

@@ -979,4 +979,56 @@ declare module "xl-public-utils" {
       ): void;
     }
   }
+  export interface FontParameters {
+    font: Record<string, any>; // 字体数据由 FontLoader 加载，结构可进一步细化
+    size: number;
+    height: number;
+    curveSegments: number;
+    bevelThickness: number;
+    bevelSize: number;
+    bevelEnabled: boolean;
+  }
+
+  export class FontManager {
+    private constructor(); // 使用单例模式
+    static Mgr(): FontManager;
+
+    private cacheFontMap: Record<string, vtkPolyData>;
+    private cacheFontPointMap: Record<string, IndexData>;
+    private fontJsonMap: Record<string, any>;
+    private parameters: FontParameters & { font: Record<string, any> };
+
+    /**
+     * 加载字体文件
+     * @param url JSON 字体文件地址
+     * @param fontName 字体名称
+     * @param bevelEnabled 是否启用 bevel
+     */
+    loadFontFile(url: string, fontName?: string, bevelEnabled?: boolean): Promise<void>;
+
+    /**
+     * 生成文字的 PolyData 以及前后顶点索引映射数据
+     * @param text 要生成的文字
+     * @param fontName 字体名
+     * @param scale 缩放向量
+     */
+    generateShapes(
+      text: string,
+      fontName?: string,
+      scale?: vec3
+    ): {
+      polyData: vtkPolyData;
+      indexData: IndexData;
+    };
+
+    /**
+     * 获取顶点索引映射
+     */
+    getPointsMapData(polydata: vtkPolyData): IndexData;
+
+    /**
+     * 创建 vtkPolyData 对象
+     */
+    createPolyData(verts: any, faces: any): vtkPolyData;
+  }
 }

package/index.js

@@ -3,4 +3,5 @@ import * as utils from './src/utils.js'
 import * as qrcode from './src/qrcode.js'
 import * as BwipJs from './src/bwip-js.js';
 import * as drcUtils from './src/drcUtils.js';
-export { vtkUtils, utils, qrcode, BwipJs, drcUtils };
+import FontManager  from './src/threeFont/index.js';
+export { vtkUtils, utils, qrcode, BwipJs, drcUtils, FontManager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xl-public-utils",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "",
   "main": "index.js",
   "module": "index.js",
@@ -30,7 +30,9 @@
     "./qrcode": "./src/qrcode.js",
     "./vtkUtils": "./src/vtkUtils.js",
     "./utils": "./src/utils.js",
-    "./bwipJs": "./src/bwip-js.js"
+    "./bwipJs": "./src/bwip-js.js",
+    "./drcUtils": "./src/drcUtils.js",
+    "./threeFont": "./src/threeFont/index.js"
   },
   "scripts": {
     "test": "karma start",

package/src/threeFont/Curve/Curve.js

@@ -0,0 +1,349 @@
+import { Vector2 } from '../Math/Vector2.js';
+import { Vector3 } from '../Math/Vector3.js';
+import { Matrix4 } from '../Math/Matrix4.js';
+
+/**
+ * Extensible curve object.
+ *
+ * Some common of curve methods:
+ * .getPoint( t, optionalTarget ), .getTangent( t, optionalTarget )
+ * .getPointAt( u, optionalTarget ), .getTangentAt( u, optionalTarget )
+ * .getPoints(), .getSpacedPoints()
+ * .getLength()
+ * .updateArcLengths()
+ *
+ * This following curves inherit from THREE.Curve:
+ *
+ * -- 2D curves --
+ * THREE.ArcCurve
+ * THREE.CubicBezierCurve
+ * THREE.EllipseCurve
+ * THREE.LineCurve
+ * THREE.QuadraticBezierCurve
+ * THREE.SplineCurve
+ *
+ * -- 3D curves --
+ * THREE.CatmullRomCurve3
+ * THREE.CubicBezierCurve3
+ * THREE.LineCurve3
+ * THREE.QuadraticBezierCurve3
+ *
+ * A series of curves can be represented as a THREE.CurvePath.
+ *
+ **/
+
+class Curve {
+    constructor() {
+        this.type = 'Curve';
+        this.arcLengthDivisions = 200;
+        this.cacheArcLengths = [];
+    }
+
+    // Virtual base class method to overwrite and implement in subclasses
+    //	- t [0 .. 1]
+
+    getPoint(/* t, optionalTarget */) {
+        console.warn('THREE.Curve: .getPoint() not implemented.');
+        return null;
+    }
+
+    // Get point at relative position in curve according to arc length
+    // - u [0 .. 1]
+
+    getPointAt(u, optionalTarget) {
+        const t = this.getUtoTmapping(u);
+        return this.getPoint(t, optionalTarget);
+    }
+
+    // Get sequence of points using getPoint( t )
+
+    getPoints(divisions = 5) {
+        const points = [];
+
+        for (let d = 0; d <= divisions; d++) {
+            points.push(this.getPoint(d / divisions));
+        }
+
+        return points;
+    }
+
+    // Get sequence of points using getPointAt( u )
+
+    getSpacedPoints(divisions = 5) {
+        const points = [];
+
+        for (let d = 0; d <= divisions; d++) {
+            points.push(this.getPointAt(d / divisions));
+        }
+
+        return points;
+    }
+
+    // Get total curve arc length
+
+    getLength() {
+        const lengths = this.getLengths();
+        return lengths[lengths.length - 1];
+    }
+
+    // Get list of cumulative segment lengths
+
+    getLengths(divisions = this.arcLengthDivisions) {
+        if (this.cacheArcLengths && this.cacheArcLengths.length === divisions + 1 && !this.needsUpdate) {
+            return this.cacheArcLengths;
+        }
+
+        this.needsUpdate = false;
+
+        const cache = [];
+        let current,
+            last = this.getPoint(0);
+        let sum = 0;
+
+        cache.push(0);
+
+        for (let p = 1; p <= divisions; p++) {
+            current = this.getPoint(p / divisions);
+            sum += current.distanceTo(last);
+            cache.push(sum);
+            last = current;
+        }
+
+        this.cacheArcLengths = cache;
+
+        return cache; // { sums: cache, sum: sum }; Sum is in the last element.
+    }
+
+    updateArcLengths() {
+        this.needsUpdate = true;
+        this.getLengths();
+    }
+
+    // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
+
+    getUtoTmapping(u, distance = null) {
+        const arcLengths = this.getLengths();
+
+        let i = 0;
+        const il = arcLengths.length;
+
+        let targetArcLength; // The targeted u distance value to get
+
+        if (distance) {
+            targetArcLength = distance;
+        } else {
+            targetArcLength = u * arcLengths[il - 1];
+        }
+
+        // binary search for the index with largest value smaller than target u distance
+
+        let low = 0,
+            high = il - 1,
+            comparison;
+
+        while (low <= high) {
+            i = Math.floor(low + (high - low) / 2); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
+
+            comparison = arcLengths[i] - targetArcLength;
+
+            if (comparison < 0) {
+                low = i + 1;
+            } else if (comparison > 0) {
+                high = i - 1;
+            } else {
+                high = i;
+                break;
+
+                // DONE
+            }
+        }
+
+        i = high;
+
+        if (arcLengths[i] === targetArcLength) {
+            return i / (il - 1);
+        }
+
+        // we could get finer grain at lengths, or use simple interpolation between two points
+
+        const lengthBefore = arcLengths[i];
+        const lengthAfter = arcLengths[i + 1];
+
+        const segmentLength = lengthAfter - lengthBefore;
+
+        // determine where we are between the 'before' and 'after' points
+
+        const segmentFraction = (targetArcLength - lengthBefore) / segmentLength;
+
+        // add that fractional amount to t
+
+        const t = (i + segmentFraction) / (il - 1);
+
+        return t;
+    }
+
+    // Returns a unit vector tangent at t
+    // In case any sub curve does not implement its tangent derivation,
+    // 2 points a small delta apart will be used to find its gradient
+    // which seems to give a reasonable approximation
+
+    getTangent(t, optionalTarget) {
+        const delta = 0.0001;
+        let t1 = t - delta;
+        let t2 = t + delta;
+
+        // Capping in case of danger
+
+        if (t1 < 0) t1 = 0;
+        if (t2 > 1) t2 = 1;
+
+        const pt1 = this.getPoint(t1);
+        const pt2 = this.getPoint(t2);
+
+        const tangent = optionalTarget || (pt1.isVector2 ? new Vector2() : new Vector3());
+
+        tangent.copy(pt2).sub(pt1).normalize();
+
+        return tangent;
+    }
+
+    getTangentAt(u, optionalTarget) {
+        const t = this.getUtoTmapping(u);
+        return this.getTangent(t, optionalTarget);
+    }
+
+    computeFrenetFrames(segments, closed) {
+        // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
+        /**
+         * 将数值限制在范围 [min, max] 之间
+         * @param {number} number 要限制的数值
+         * @param {number} min 最小值
+         * @param {number} max 最大值
+         * @returns {number}
+         */
+        function clamp(number, min, max) {
+          return Math.min(Math.max(number, min), max);
+        }
+        const normal = new Vector3();
+
+        const tangents = [];
+        const normals = [];
+        const binormals = [];
+
+        const vec = new Vector3();
+        const mat = new Matrix4();
+
+        // compute the tangent vectors for each segment on the curve
+
+        for (let i = 0; i <= segments; i++) {
+            const u = i / segments;
+
+            tangents[i] = this.getTangentAt(u, new Vector3());
+        }
+
+        // select an initial normal vector perpendicular to the first tangent vector,
+        // and in the direction of the minimum tangent xyz component
+
+        normals[0] = new Vector3();
+        binormals[0] = new Vector3();
+        let min = Number.MAX_VALUE;
+        const tx = Math.abs(tangents[0].x);
+        const ty = Math.abs(tangents[0].y);
+        const tz = Math.abs(tangents[0].z);
+
+        if (tx <= min) {
+            min = tx;
+            normal.set(1, 0, 0);
+        }
+
+        if (ty <= min) {
+            min = ty;
+            normal.set(0, 1, 0);
+        }
+
+        if (tz <= min) {
+            normal.set(0, 0, 1);
+        }
+
+        vec.crossVectors(tangents[0], normal).normalize();
+
+        normals[0].crossVectors(tangents[0], vec);
+        binormals[0].crossVectors(tangents[0], normals[0]);
+
+        // compute the slowly-varying normal and binormal vectors for each segment on the curve
+
+        for (let i = 1; i <= segments; i++) {
+            normals[i] = normals[i - 1].clone();
+
+            binormals[i] = binormals[i - 1].clone();
+
+            vec.crossVectors(tangents[i - 1], tangents[i]);
+
+            if (vec.length() > Number.EPSILON) {
+                vec.normalize();
+
+                const theta = Math.acos(clamp(tangents[i - 1].dot(tangents[i]), -1, 1)); // clamp for floating pt errors
+
+                normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta));
+            }
+
+            binormals[i].crossVectors(tangents[i], normals[i]);
+        }
+
+        // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
+
+        if (closed === true) {
+            let theta = Math.acos(clamp(normals[0].dot(normals[segments]), -1, 1));
+            theta /= segments;
+
+            if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
+                theta = -theta;
+            }
+
+            for (let i = 1; i <= segments; i++) {
+                // twist a little...
+                normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i));
+                binormals[i].crossVectors(tangents[i], normals[i]);
+            }
+        }
+
+        return {
+            tangents: tangents,
+            normals: normals,
+            binormals: binormals,
+        };
+    }
+
+    clone() {
+        return new this.constructor().copy(this);
+    }
+
+    copy(source) {
+        this.arcLengthDivisions = source.arcLengthDivisions;
+
+        return this;
+    }
+
+    toJSON() {
+        const data = {
+            metadata: {
+                version: 4.5,
+                type: 'Curve',
+                generator: 'Curve.toJSON',
+            },
+        };
+
+        data.arcLengthDivisions = this.arcLengthDivisions;
+        data.type = this.type;
+
+        return data;
+    }
+
+    fromJSON(json) {
+        this.arcLengthDivisions = json.arcLengthDivisions;
+
+        return this;
+    }
+}
+
+export { Curve };

package/src/threeFont/Curve/CurvePath.js

@@ -0,0 +1,202 @@
+import { Curve } from './Curve.js';
+import * as Curves from '../curves/Curves.js';
+
+/**************************************************************
+ *	Curved Path - a curve path is simply a array of connected
+ *  curves, but retains the api of a curve
+ **************************************************************/
+
+class CurvePath extends Curve {
+    constructor() {
+        super();
+
+        this.type = 'CurvePath';
+
+        this.curves = [];
+        this.autoClose = false; // Automatically closes the path
+    }
+
+    add(curve) {
+        this.curves.push(curve);
+    }
+
+    closePath() {
+        // Add a line curve if start and end of lines are not connected
+        const startPoint = this.curves[0].getPoint(0);
+        const endPoint = this.curves[this.curves.length - 1].getPoint(1);
+
+        if (!startPoint.equals(endPoint)) {
+            this.curves.push(new Curves['LineCurve'](endPoint, startPoint));
+        }
+    }
+
+    // To get accurate point with reference to
+    // entire path distance at time t,
+    // following has to be done:
+
+    // 1. Length of each sub path have to be known
+    // 2. Locate and identify type of curve
+    // 3. Get t for the curve
+    // 4. Return curve.getPointAt(t')
+
+    getPoint(t, optionalTarget) {
+        const d = t * this.getLength();
+        const curveLengths = this.getCurveLengths();
+        let i = 0;
+
+        // To think about boundaries points.
+
+        while (i < curveLengths.length) {
+            if (curveLengths[i] >= d) {
+                const diff = curveLengths[i] - d;
+                const curve = this.curves[i];
+
+                const segmentLength = curve.getLength();
+                const u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;
+
+                return curve.getPointAt(u, optionalTarget);
+            }
+
+            i++;
+        }
+
+        return null;
+
+        // loop where sum != 0, sum > d , sum+1 <d
+    }
+
+    // We cannot use the default THREE.Curve getPoint() with getLength() because in
+    // THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
+    // getPoint() depends on getLength
+
+    getLength() {
+        const lens = this.getCurveLengths();
+        return lens[lens.length - 1];
+    }
+
+    // cacheLengths must be recalculated.
+    updateArcLengths() {
+        this.needsUpdate = true;
+        this.cacheLengths = null;
+        this.getCurveLengths();
+    }
+
+    // Compute lengths and cache them
+    // We cannot overwrite getLengths() because UtoT mapping uses it.
+
+    getCurveLengths() {
+        // We use cache values if curves and cache array are same length
+
+        if (this.cacheLengths && this.cacheLengths.length === this.curves.length) {
+            return this.cacheLengths;
+        }
+
+        // Get length of sub-curve
+        // Push sums into cached array
+
+        const lengths = [];
+        let sums = 0;
+
+        for (let i = 0, l = this.curves.length; i < l; i++) {
+            sums += this.curves[i].getLength();
+            lengths.push(sums);
+        }
+
+        this.cacheLengths = lengths;
+
+        return lengths;
+    }
+
+    getSpacedPoints(divisions = 40) {
+        const points = [];
+
+        for (let i = 0; i <= divisions; i++) {
+            points.push(this.getPoint(i / divisions));
+        }
+
+        if (this.autoClose) {
+            points.push(points[0]);
+        }
+
+        return points;
+    }
+
+    getPoints(divisions = 12) {
+        const points = [];
+        let last;
+
+        for (let i = 0, curves = this.curves; i < curves.length; i++) {
+            const curve = curves[i];
+            const resolution = curve.isEllipseCurve
+                ? divisions * 2
+                : curve.isLineCurve || curve.isLineCurve3
+                ? 1
+                : curve.isSplineCurve
+                ? divisions * curve.points.length
+                : divisions;
+
+            const pts = curve.getPoints(resolution);
+
+            for (let j = 0; j < pts.length; j++) {
+                const point = pts[j];
+
+                if (last && last.equals(point)) continue; // ensures no consecutive points are duplicates
+
+                points.push(point);
+                last = point;
+            }
+        }
+
+        if (this.autoClose && points.length > 1 && !points[points.length - 1].equals(points[0])) {
+            points.push(points[0]);
+        }
+
+        return points;
+    }
+
+    copy(source) {
+        super.copy(source);
+
+        this.curves = [];
+
+        for (let i = 0, l = source.curves.length; i < l; i++) {
+            const curve = source.curves[i];
+
+            this.curves.push(curve.clone());
+        }
+
+        this.autoClose = source.autoClose;
+
+        return this;
+    }
+
+    toJSON() {
+        const data = super.toJSON();
+
+        data.autoClose = this.autoClose;
+        data.curves = [];
+
+        for (let i = 0, l = this.curves.length; i < l; i++) {
+            const curve = this.curves[i];
+            data.curves.push(curve.toJSON());
+        }
+
+        return data;
+    }
+
+    fromJSON(json) {
+        super.fromJSON(json);
+
+        this.autoClose = json.autoClose;
+        this.curves = [];
+
+        for (let i = 0, l = json.curves.length; i < l; i++) {
+            const curve = json.curves[i];
+            this.curves.push(new Curves[curve.type]().fromJSON(curve));
+        }
+
+        return this;
+    }
+}
+
+export { CurvePath };

package/src/threeFont/Curve/Interpolations.js

@@ -0,0 +1,57 @@
+/**
+ * Bezier Curves formulas obtained from
+ * https://en.wikipedia.org/wiki/B%C3%A9zier_curve
+ */
+
+function CatmullRom(t, p0, p1, p2, p3) {
+    const v0 = (p2 - p0) * 0.5;
+    const v1 = (p3 - p1) * 0.5;
+    const t2 = t * t;
+    const t3 = t * t2;
+    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+}
+
+//
+
+function QuadraticBezierP0(t, p) {
+    const k = 1 - t;
+    return k * k * p;
+}
+
+function QuadraticBezierP1(t, p) {
+    return 2 * (1 - t) * t * p;
+}
+
+function QuadraticBezierP2(t, p) {
+    return t * t * p;
+}
+
+function QuadraticBezier(t, p0, p1, p2) {
+    return QuadraticBezierP0(t, p0) + QuadraticBezierP1(t, p1) + QuadraticBezierP2(t, p2);
+}
+
+//
+
+function CubicBezierP0(t, p) {
+    const k = 1 - t;
+    return k * k * k * p;
+}
+
+function CubicBezierP1(t, p) {
+    const k = 1 - t;
+    return 3 * k * k * t * p;
+}
+
+function CubicBezierP2(t, p) {
+    return 3 * (1 - t) * t * t * p;
+}
+
+function CubicBezierP3(t, p) {
+    return t * t * t * p;
+}
+
+function CubicBezier(t, p0, p1, p2, p3) {
+    return CubicBezierP0(t, p0) + CubicBezierP1(t, p1) + CubicBezierP2(t, p2) + CubicBezierP3(t, p3);
+}
+
+export { CatmullRom, QuadraticBezier, CubicBezier };