xl-public-utils 1.0.11 → 1.0.13

package/src/threeFont/curves/EllipseCurve.js

@@ -0,0 +1,130 @@
+import { Curve } from '../Curve/Curve.js';
+import { Vector2 } from '../Math/Vector2.js';
+
+class EllipseCurve extends Curve {
+    constructor(aX = 0, aY = 0, xRadius = 1, yRadius = 1, aStartAngle = 0, aEndAngle = Math.PI * 2, aClockwise = false, aRotation = 0) {
+        super();
+
+        this.isEllipseCurve = true;
+
+        this.type = 'EllipseCurve';
+
+        this.aX = aX;
+        this.aY = aY;
+
+        this.xRadius = xRadius;
+        this.yRadius = yRadius;
+
+        this.aStartAngle = aStartAngle;
+        this.aEndAngle = aEndAngle;
+
+        this.aClockwise = aClockwise;
+
+        this.aRotation = aRotation;
+    }
+
+    getPoint(t, optionalTarget) {
+        const point = optionalTarget || new Vector2();
+
+        const twoPi = Math.PI * 2;
+        let deltaAngle = this.aEndAngle - this.aStartAngle;
+        const samePoints = Math.abs(deltaAngle) < Number.EPSILON;
+
+        // ensures that deltaAngle is 0 .. 2 PI
+        while (deltaAngle < 0) deltaAngle += twoPi;
+        while (deltaAngle > twoPi) deltaAngle -= twoPi;
+
+        if (deltaAngle < Number.EPSILON) {
+            if (samePoints) {
+                deltaAngle = 0;
+            } else {
+                deltaAngle = twoPi;
+            }
+        }
+
+        if (this.aClockwise === true && !samePoints) {
+            if (deltaAngle === twoPi) {
+                deltaAngle = -twoPi;
+            } else {
+                deltaAngle = deltaAngle - twoPi;
+            }
+        }
+
+        const angle = this.aStartAngle + t * deltaAngle;
+        let x = this.aX + this.xRadius * Math.cos(angle);
+        let y = this.aY + this.yRadius * Math.sin(angle);
+
+        if (this.aRotation !== 0) {
+            const cos = Math.cos(this.aRotation);
+            const sin = Math.sin(this.aRotation);
+
+            const tx = x - this.aX;
+            const ty = y - this.aY;
+
+            // Rotate the point about the center of the ellipse.
+            x = tx * cos - ty * sin + this.aX;
+            y = tx * sin + ty * cos + this.aY;
+        }
+
+        return point.set(x, y);
+    }
+
+    copy(source) {
+        super.copy(source);
+
+        this.aX = source.aX;
+        this.aY = source.aY;
+
+        this.xRadius = source.xRadius;
+        this.yRadius = source.yRadius;
+
+        this.aStartAngle = source.aStartAngle;
+        this.aEndAngle = source.aEndAngle;
+
+        this.aClockwise = source.aClockwise;
+
+        this.aRotation = source.aRotation;
+
+        return this;
+    }
+
+    toJSON() {
+        const data = super.toJSON();
+
+        data.aX = this.aX;
+        data.aY = this.aY;
+
+        data.xRadius = this.xRadius;
+        data.yRadius = this.yRadius;
+
+        data.aStartAngle = this.aStartAngle;
+        data.aEndAngle = this.aEndAngle;
+
+        data.aClockwise = this.aClockwise;
+
+        data.aRotation = this.aRotation;
+
+        return data;
+    }
+
+    fromJSON(json) {
+        super.fromJSON(json);
+
+        this.aX = json.aX;
+        this.aY = json.aY;
+
+        this.xRadius = json.xRadius;
+        this.yRadius = json.yRadius;
+
+        this.aStartAngle = json.aStartAngle;
+        this.aEndAngle = json.aEndAngle;
+
+        this.aClockwise = json.aClockwise;
+
+        this.aRotation = json.aRotation;
+
+        return this;
+    }
+}
+
+export { EllipseCurve };

package/src/threeFont/curves/LineCurve.js

@@ -0,0 +1,70 @@
+import { Curve } from '../Curve/Curve.js';
+import { Vector2 } from '../Math/Vector2.js';
+
+class LineCurve extends Curve {
+    constructor(v1 = new Vector2(), v2 = new Vector2()) {
+        super();
+
+        this.isLineCurve = true;
+
+        this.type = 'LineCurve';
+
+        this.v1 = v1;
+        this.v2 = v2;
+    }
+
+    getPoint(t, optionalTarget = new Vector2()) {
+        const point = optionalTarget;
+
+        if (t === 1) {
+            point.copy(this.v2);
+        } else {
+            point.copy(this.v2).sub(this.v1);
+            point.multiplyScalar(t).add(this.v1);
+        }
+
+        return point;
+    }
+
+    // Line curve is linear, so we can overwrite default getPointAt
+    getPointAt(u, optionalTarget) {
+        return this.getPoint(u, optionalTarget);
+    }
+
+    getTangent(t, optionalTarget) {
+        const tangent = optionalTarget || new Vector2();
+
+        tangent.copy(this.v2).sub(this.v1).normalize();
+
+        return tangent;
+    }
+
+    copy(source) {
+        super.copy(source);
+
+        this.v1.copy(source.v1);
+        this.v2.copy(source.v2);
+
+        return this;
+    }
+
+    toJSON() {
+        const data = super.toJSON();
+
+        data.v1 = this.v1.toArray();
+        data.v2 = this.v2.toArray();
+
+        return data;
+    }
+
+    fromJSON(json) {
+        super.fromJSON(json);
+
+        this.v1.fromArray(json.v1);
+        this.v2.fromArray(json.v2);
+
+        return this;
+    }
+}
+
+export { LineCurve };

package/src/threeFont/curves/QuadraticBezierCurve.js

@@ -0,0 +1,61 @@
+import { Curve } from '../Curve/Curve.js';
+import { Vector2 } from '../Math/Vector2.js';
+import { QuadraticBezier } from '../Curve/Interpolations.js';
+
+class QuadraticBezierCurve extends Curve {
+    constructor(v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2()) {
+        super();
+
+        this.isQuadraticBezierCurve = true;
+
+        this.type = 'QuadraticBezierCurve';
+
+        this.v0 = v0;
+        this.v1 = v1;
+        this.v2 = v2;
+    }
+
+    getPoint(t, optionalTarget = new Vector2()) {
+        const point = optionalTarget;
+
+        const v0 = this.v0,
+            v1 = this.v1,
+            v2 = this.v2;
+
+        point.set(QuadraticBezier(t, v0.x, v1.x, v2.x), QuadraticBezier(t, v0.y, v1.y, v2.y));
+
+        return point;
+    }
+
+    copy(source) {
+        super.copy(source);
+
+        this.v0.copy(source.v0);
+        this.v1.copy(source.v1);
+        this.v2.copy(source.v2);
+
+        return this;
+    }
+
+    toJSON() {
+        const data = super.toJSON();
+
+        data.v0 = this.v0.toArray();
+        data.v1 = this.v1.toArray();
+        data.v2 = this.v2.toArray();
+
+        return data;
+    }
+
+    fromJSON(json) {
+        super.fromJSON(json);
+
+        this.v0.fromArray(json.v0);
+        this.v1.fromArray(json.v1);
+        this.v2.fromArray(json.v2);
+
+        return this;
+    }
+}
+
+export { QuadraticBezierCurve };

package/src/threeFont/curves/SplineCurve.js

@@ -0,0 +1,76 @@
+import { Curve } from '../Curve/Curve.js';
+import { Vector2 } from '../Math/Vector2.js';
+import { CatmullRom } from '../Curve/Interpolations.js';
+
+class SplineCurve extends Curve {
+    constructor(points = []) {
+        super();
+
+        this.isSplineCurve = true;
+
+        this.type = 'SplineCurve';
+
+        this.points = points;
+    }
+
+    getPoint(t, optionalTarget = new Vector2()) {
+        const point = optionalTarget;
+
+        const points = this.points;
+        const p = (points.length - 1) * t;
+
+        const intPoint = Math.floor(p);
+        const weight = p - intPoint;
+
+        const p0 = points[intPoint === 0 ? intPoint : intPoint - 1];
+        const p1 = points[intPoint];
+        const p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1];
+        const p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2];
+
+        point.set(CatmullRom(weight, p0.x, p1.x, p2.x, p3.x), CatmullRom(weight, p0.y, p1.y, p2.y, p3.y));
+
+        return point;
+    }
+
+    copy(source) {
+        super.copy(source);
+
+        this.points = [];
+
+        for (let i = 0, l = source.points.length; i < l; i++) {
+            const point = source.points[i];
+
+            this.points.push(point.clone());
+        }
+
+        return this;
+    }
+
+    toJSON() {
+        const data = super.toJSON();
+
+        data.points = [];
+
+        for (let i = 0, l = this.points.length; i < l; i++) {
+            const point = this.points[i];
+            data.points.push(point.toArray());
+        }
+
+        return data;
+    }
+
+    fromJSON(json) {
+        super.fromJSON(json);
+
+        this.points = [];
+
+        for (let i = 0, l = json.points.length; i < l; i++) {
+            const point = json.points[i];
+            this.points.push(new Vector2().fromArray(point));
+        }
+
+        return this;
+    }
+}
+
+export { SplineCurve };

package/src/threeFont/index.js

@@ -0,0 +1,166 @@
+import { Font } from './TextGeometry/FontLoader.js';
+import { ExtrudeGeometry } from './TextGeometry/ExtrudeGeometry.js';
+import { mat4, vec3 } from 'gl-matrix';
+
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData.js';
+import vtkPoints from '@kitware/vtk.js/Common/Core/Points.js';
+import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray.js';
+
+import {
+  clonePolyData,
+  deduplicatePolyData,
+  pointsApplyMat4
+} from '../vtkUtils.js';
+
+/**
+ * 文字网格管理
+ */
+class FontManager {
+  static instance;
+
+  constructor() {
+    if (FontManager.instance) return FontManager.instance;
+
+    /** @type {Object.<string, vtkPolyData>} */
+    this.cacheFontMap = {};
+    /** @type {Object.<string, { zeroIndexs: number[], oneIndexs: number[] }>} */
+    this.cacheFontPointMap = {};
+
+    this.fontJsonMap = {};
+
+    /** @type {{ font: Object, size: number, height: number, curveSegments: number, bevelThickness: number, bevelSize: number, bevelEnabled: boolean, font: Record<string, Font> }} */
+    this.parameters = {
+      font: null,
+      size: 100,
+      height: 20,
+      curveSegments: 4,
+      bevelThickness: 2,
+      bevelSize: 3,
+      bevelEnabled: true,
+      font: {}
+    };
+
+    FontManager.instance = this;
+  }
+
+  static Mgr() {
+    return new FontManager();
+  }
+
+  /**
+   * 加载字体文件
+   * @param {string} url 文件json地址
+   * @param {string} fontName 字体名称
+   * @param {boolean} bevelEnabled 
+   */
+  async loadFontFile(url, fontName = 'defaultFont', bevelEnabled = false) {
+    if(this.fontJsonMap[fontName]) {
+      return;
+    }
+    const fontMap = await (await fetch(url)).json();
+    this.fontJsonMap[fontName] = fontMap;
+    this.parameters.font[fontName] = new Font(this.fontJsonMap[fontName]);
+    this.parameters.bevelEnabled = bevelEnabled;
+  }
+
+  /**
+   * 生成文字的 PolyData
+   * @param {string} text 
+   * @param {string} fontName 
+   * @param {vec3} scale 
+   * @returns {{ polyData: import('@kitware/vtk.js/Common/DataModel/PolyData').default, indexData: { zeroIndexs: number[], oneIndexs: number[] } }}
+   */
+  generateShapes(text, fontName = 'defaultFont', scale = [0.018, 0.018, 0.018]) {
+    const scaleM4 = mat4.scale(mat4.create(), mat4.create(), scale);
+
+    if (this.cacheFontMap[text]) {
+      const newPolyData = clonePolyData(this.cacheFontMap[text]);
+      pointsApplyMat4(scaleM4, newPolyData);
+      return {
+        polyData: newPolyData,
+        indexData: this.cacheFontPointMap[text]
+      };
+    }
+
+    const shapes = this.parameters.font[fontName].generateShapes(text, this.parameters.size);
+    const extrude = new ExtrudeGeometry(shapes, this.parameters);
+
+    let polyData = this.createPolyData(extrude.vertices, extrude.faces);
+    polyData = deduplicatePolyData(polyData);
+    const indexData = this.getPointsMapData(polyData);
+
+    const _polyData = clonePolyData(polyData);
+    pointsApplyMat4(scaleM4, _polyData);
+
+    this.cacheFontMap[text] = polyData;
+    this.cacheFontPointMap[text] = indexData;
+
+    return {
+      polyData: _polyData,
+      indexData
+    };
+  }
+
+  /**
+   * 获取前后层顶点索引映射数据
+   * @param {import('@kitware/vtk.js/Common/DataModel/PolyData').default} polydata 
+   * @returns {{ zeroIndexs: number[], oneIndexs: number[] }}
+   */
+  getPointsMapData(polydata) {
+    const points = polydata.getPoints().getData();
+    const zeroIndexs = [];
+    const oneIndexs = [];
+    const pointIndexMap = {};
+
+    for (let i = 0; i < points.length / 3; i++) {
+      const point = [points[i * 3], points[i * 3 + 1], points[i * 3 + 2]];
+      if (point[2] === 0) {
+        zeroIndexs.push(i);
+      }
+      const key = point.join('_');
+      pointIndexMap[key] = i;
+    }
+
+    for (let i = 0; i < zeroIndexs.length; i++) {
+      const index = zeroIndexs[i];
+      const point = [points[index * 3], points[index * 3 + 1], 1];
+      const key = point.join('_');
+      const oneIndex = pointIndexMap[key];
+      oneIndexs.push(oneIndex);
+    }
+
+    return {
+      zeroIndexs,
+      oneIndexs
+    };
+  }
+
+  /**
+   * 创建 vtkPolyData 对象
+   * @param {any} verts 
+   * @param {any} faces 
+   * @returns {vtkPolyData}
+   */
+  createPolyData(verts, faces) {
+    const values_v = Object.values(verts);
+    const values_f = Object.values(faces);
+
+    const _verts = values_v.map(v => parseFloat(v));
+    const _faces = values_f.map(f => parseInt(f));
+
+    const vpoints = vtkPoints.newInstance();
+    const cellArray = vtkCellArray.newInstance();
+
+    vpoints.setData(_verts, 3);
+    cellArray.setNumberOfComponents(4);
+    cellArray.setData(_faces);
+
+    const polyData = vtkPolyData.newInstance();
+    polyData.setPoints(vpoints);
+    polyData.setPolys(cellArray);
+
+    return polyData;
+  }
+}
+
+export default FontManager;

package/src/vtkUtils.js

@@ -256,29 +256,22 @@ export function projectVecToPlane(vec, norm) {
  * @returns {vec3} 投影后的点
  */
 export function projectPointOnPoints(point, begin, end) {
-  const dx = begin[0] - end[0];
-  const dy = begin[1] - end[1];
-  const dz = begin[2] - end[2];
-  const EPS = 0.00000001;
+  const EPS = 1e-8;
 
-  //  确保两个点不是同一个点
-  if (Math.abs(dx) < EPS && Math.abs(dy) < EPS && Math.abs(dz) < EPS) {
-    return begin;
-  }
+  let dir = vec3.sub(vec3.create(), end, begin);
+  let lenSq = vec3.squaredLength(dir);
 
-  //计算斜率
-  let u =
-    (point[0] - begin[0]) * (begin[0] - end[0]) +
-    (point[1] - begin[1]) * (begin[1] - end[1]) +
-    (point[2] - begin[2]) * (begin[2] - end[2]);
-  u = u / (Math.pow(dx, 2) + Math.pow(dy, 2) + Math.pow(dz, 2));
+  if (lenSq < EPS) {
+    // begin 和 end 太近了，视为同一点
+    return vec3.clone(begin);
+  }
+  vec3.normalize(dir, dir);
+  lenSq = vec3.squaredLength(dir);
+  const v = vec3.sub(vec3.create(), point, begin);
+  const u = vec3.dot(v, dir) / lenSq;
 
-  return vec3.set(
-    vec3.create(),
-    begin[0] + u * dx,
-    begin[1] + u * dy,
-    begin[2] + u * dz
-  );
+  const projected = vec3.scaleAndAdd(vec3.create(), begin, dir, u);
+  return projected;
 }
 
 /**
@@ -330,14 +323,23 @@ export function getPointToPointsMinIndex(point, points) {
  * @returns {number} 返回点到曲线的最近距离
  */
 export function getPointToPointsMinDist(point, points) {
-  let dist = vec3.dist(point, points[0]);
-  for (let i = 1; i < points.length; i++) {
-    const iDist = vec3.dist(point, points[i]);
-    if (iDist < dist) {
-      dist = iDist;
+  if (!Array.isArray(points) || points.length === 0) {
+    return Infinity; // 或者可以抛错 throw new Error('Points array is empty');
+  }
+
+  let minDistSq = Infinity;
+  for (let i = 0; i < points.length; i++) {
+    const dx = point[0] - points[i][0];
+    const dy = point[1] - points[i][1];
+    const dz = point[2] - points[i][2];
+    const distSq = dx * dx + dy * dy + dz * dz;
+
+    if (distSq < minDistSq) {
+      minDistSq = distSq;
     }
   }
-  return dist;
+
+  return Math.sqrt(minDistSq);
 }
 
 
@@ -374,8 +376,13 @@ export function getPointToLineDist(point, begin, end) {
  * @param {vec3} normal 平面法向量，要求单位化
  * @returns {number}
  */
-export function getPointToPlaneDist(point, origin, normal) {
-  return vec3.dot(vec3.sub(vec3.create(), point, origin), normal);
+export function getPointToPlaneDist(point, origin, normal) {  // 如果法向量没有单位化，先进行归一化
+  if(vec3.squaredLength(normal) < 1e-8) {
+    throw('Normal vector is too small');
+  }
+  const normalizedNormal = vec3.create();
+  vec3.normalize(normalizedNormal, normal);
+  return vec3.dot(vec3.sub(vec3.create(), point, origin), normalizedNormal);
 }
 
 
@@ -545,6 +552,9 @@ export function deduplicatePolyData(data) {
  */
 
 export function getPointsCenter(points) {
+  if(!points.length) {
+    throw('no points input')
+  }
   let sumPoints = vec3.create();
   for (let i = 0; i < points.length; i++) {
     vec3.add(sumPoints, sumPoints, points[i]);
@@ -1016,4 +1026,21 @@ export function getCurvePointIndexByLength(points, dist, absDist = true) {
   const minSub = Math.min(...targetDistanceSubs);
   const targetIndex = targetDistanceSubs.findIndex(i => i === minSub)
   return targetIndex;
+}
+
+/**
+ * 复制一个polydata，只复制点和面的数据
+ * @param {vtkPolyData} originalPolyData 原始的polydata
+ * @returns {vtkPolyData} 新的polydata
+ */
+export function clonePolyData(originalPolyData) {
+  // 创建深拷贝的 PolyData 对象
+  const clonedPolyData = vtkPolyData.newInstance();
+  // 复制顶点数据
+  const originalPoints = originalPolyData.getPoints().getData();
+  clonedPolyData.getPoints().setData([...originalPoints]);
+  // 复制单元数据
+  const originalCells = originalPolyData.getPolys().getData();
+  clonedPolyData.getPolys().setData([...originalCells]);
+  return clonedPolyData;
 }

package/tsconfig.json

@@ -5,5 +5,5 @@
     "emitDeclarationOnly": true,
     "outDir": "types" // 可选，定义.d.ts文件输出目录
   },
-  "include": ["src/*.js", "src/vtkUtils.js",] // 指定包含的 JavaScript 文件路径
+  "include": ["src/*.js", "src/vtkUtils.js", "src/threeFont/font.js",] // 指定包含的 JavaScript 文件路径
 }