xl-public-utils 1.0.8 → 1.0.10

package/index.d.ts

@@ -1,4 +1,16 @@
+import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData";
 declare module "xl-public-utils" {
+  
+  export type Mesh = {
+    /**
+     * 点信息
+     */
+    vertices: number[][] | vec3[];
+    /**
+     * 面信息
+     */
+    faces: number[][] | vec3[];
+  };
   export interface QrCodeOptions {
     /** 二维码类型，具体支持请查看文档 */
     bcid?: string; // 默认值 'qrcode'
@@ -262,12 +274,22 @@ declare module "xl-public-utils" {
     export function createStlBlob(mesh: vtkPolyData): Blob;
     /**
      * 将网格压缩为drc文件，导出drc需要先加载draco_encode.js，并调用initDrcCoder初始化
-     * @param {vtkPolyData | Mesh} mesh 网格文件
+     * @param {vtkPolyData} mesh 网格文件
+     * @param {number} byteLength=14  压缩率
+     * @returns {Blob} drc文件
+     */
+    export function createDrcBlob(
+      mesh: vtkPolyData,
+      byteLength?: number
+    ): Blob;
+    /**
+     * 将网格压缩为drc文件，导出drc需要先加载draco_encode.js，并调用initDrcCoder初始化
+     * @param {Mesh} mesh 网格文件
      * @param {number} byteLength=14  压缩率
      * @returns {Blob} drc文件
      */
     export function createDrcBlob(
-      mesh: vtkPolyData | Mesh,
+      mesh: Mesh,
       byteLength?: number
     ): Blob;
     /**
@@ -360,16 +382,20 @@ declare module "xl-public-utils" {
     ): mat3;
     /**
      * 将polyData转换为Base64string
-     * @param {vtkPolyData | Mesh} mesh 网格数据
+     * @param {vtkPolyData} mesh 网格数据
      * @param {mat4} [matrix] 变换矩阵
      * @param {number} byteLength=14  压缩率
      * @returns {string} drc压缩之后的网格base64
      */
-    export function enCodeMeshToBase64(
-      mesh: vtkPolyData | Mesh,
-      matrix?: mat4,
-      byteLength?: number
-    ): string;
+    export function enCodeMeshToBase64(mesh: vtkPolyData,matrix?: mat4,byteLength?: number): string;
+    /**
+     * 将polyData转换为Base64string
+     * @param {Mesh} mesh 网格数据
+     * @param {mat4} [matrix] 变换矩阵
+     * @param {number} byteLength=14  压缩率
+     * @returns {string} drc压缩之后的网格base64
+     */
+    export function enCodeMeshToBase64(mesh: Mesh,matrix?: mat4,byteLength?: number): string;
     /**
      * 将一圈有序点按指定size进行平滑
      * @param {vec3[]} points 一圈有序点
@@ -466,12 +492,6 @@ declare module "xl-public-utils" {
      * @returns {Plane| null} 拟合的平面
      */
     export function pcaFitPlane(points: vec3[]): Plane | null;
-    /**
-     * 计算一组 3D 点的最佳拟合平面（最小二乘法）。
-     * @param {Array<vec3>} points - 3D 点数组，每个点是一个 vec3 向量。
-     * @returns {Plane|null} - 返回平面的 origin（质心）和 normal（法向量），如果点数少于 3 个则返回 null。
-     */
-    export function leastSquaresFitPlane(points: Array<vec3>): Plane | null;
     export type Position = {
       /**
        * 对应vtk坐标系的x值
@@ -503,16 +523,6 @@ declare module "xl-public-utils" {
        */
       z: vec3;
     };
-    export type Mesh = {
-      /**
-       * 点信息
-       */
-      vertices: number[][] | vec3[];
-      /**
-       * 面信息
-       */
-      faces: number[][] | vec3[];
-    };
     export type Plane = {
       /**
        * 对应vtk坐标系的x值
@@ -562,16 +572,6 @@ declare module "xl-public-utils" {
       normals?: Float32Array;
     };
     export type Decoder = any;
-    export type Mesh = {
-      /**
-       * 点信息
-       */
-      vertices: number[][] | vec3[];
-      /**
-       * 面信息
-       */
-      faces: number[][] | vec3[];
-    };
     /**
      * @typedef {Object} AttrOption
      * @property {number[]} [colors] 颜色数组
@@ -650,13 +650,25 @@ declare module "xl-public-utils" {
      */
     /**
      * 使用drc压缩网格信息
-     * @param {Mesh | vtkPolyData} mesh
+     * @param {vtkPolyData} mesh
+     * @param {number} byteLength=14  压缩率
+     * @param {AttrOption} [attr] 其他需要压缩的属性
+     * @returns {Int8Array} 压缩之后的DRC数据
+     */
+    export function enCodeMesh(
+      mesh: vtkPolyData,
+      byteLength?: number,
+      attr?: AttrOption
+    ): Int8Array;
+    /**
+     * 使用drc压缩网格信息
+     * @param {Mesh} mesh
      * @param {number} byteLength=14  压缩率
      * @param {AttrOption} [attr] 其他需要压缩的属性
      * @returns {Int8Array} 压缩之后的DRC数据
      */
     export function enCodeMesh(
-      mesh: Mesh | vtkPolyData,
+      mesh: Mesh,
       byteLength?: number,
       attr?: AttrOption
     ): Int8Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xl-public-utils",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
   "main": "index.js",
   "module": "index.js",

package/src/drcUtils.js

@@ -301,7 +301,12 @@ export function enCodeMesh(mesh, byteLength = 14, attr = undefined) {
   let faces = [];
   let vertices = [];
   if(mesh.vertices && mesh.faces) {
-    vertices = mesh.vertices;
+    for(let i =0; i<mesh.vertices.length; i++) {
+      const vertice = mesh.vertices[i];
+      vertices.push(vertice[0]);
+      vertices.push(vertice[1]);
+      vertices.push(vertice[2]);
+    }
     for(let i = 0; i < mesh.faces.length; i++) {
       const face = mesh.faces[i];
       faces.push(face[0]);

package/src/vtkUtils.js

@@ -10,7 +10,7 @@ import vtkPLYReader from '@kitware/vtk.js/IO/Geometry/PLYReader';
 import vtkSTLReader from '@kitware/vtk.js/IO/Geometry/STLReader';
 import vtkDracoReader from '@kitware/vtk.js/IO/Geometry/DracoReader';
 import vtkTriangleFilter from "@kitware/vtk.js/Filters/General/TriangleFilter";
-import { vec3, mat4, mat3 } from 'gl-matrix';
+import { vec3, mat4, mat3, quat } from 'gl-matrix';
 import { exportBinarySTL } from './exportSTL.js';
 import { writePLY } from "./exportPLY.js";
 import { enCodeMesh } from './drcUtils.js';
@@ -619,40 +619,46 @@ export function calculateSimpleLerp(from, to, step) {
 /**
  * 将 mat3 解析为 3 个自由度的 欧拉角(Eular)(弧度)
  * @param {mat3} rmat 3 * 3的矩阵
- * @param {[number, number, number]} eular 输出的欧拉角度数(弧度)
+ * @param {[number, number, number]} euler 输出的欧拉角度数(弧度)
  * @returns {[number, number, number]} 3个自由度的欧拉角
  * @example
  * const mt4: mat4;
  * const mt3 = mat3.fromMat4(mt3, mt4);
  * mat3.transpose(mt3, mt3);
- * let eular = [0, 0, 0];
- * convMatrix2EularZYX(mt3, eular);
- */
-export function convMatrix2EularZYX(rmat, eular) {
-  function fclamp(v, min, max) {
-    if (v <= min) return min;
-    if (v >= max) return max;
-    return v;
+ * let euler = [0, 0, 0];
+ * convMatrix2EularZYX(mt3, euler);
+ */
+export function convMatrix2EularZYX(rmat, euler) {
+  const R = mat3.transpose(mat3.create(),rmat);
+  // 计算pitch(绕Y轴)
+  const pitch = Math.atan2(-R[6], Math.sqrt(R[7] * R[7] + R[8] * R[8]));
+    
+  // 处理万向节死锁(Gimbal Lock)
+  if (Math.abs(pitch - Math.PI/2) < 1e-3) {  // pitch接近90度
+      vec3.set(
+          euler,
+          0.0,                      // roll
+          Math.PI/2,               // pitch
+          Math.atan2(R[1], R[0]),  // yaw
+      );
+  } 
+  else if (Math.abs(pitch + Math.PI/2) < 1e-3) {  // pitch接近-90度
+      vec3.set(
+          euler,
+          0.0,                      // roll
+          -Math.PI/2,              // pitch
+          -Math.atan2(R[1], R[0]), // yaw
+      );
   }
-  const m11 = rmat[0],
-    m12 = rmat[1],
-    m13 = rmat[2];
-  const m21 = rmat[3],
-    m22 = rmat[4],
-    m23 = rmat[5];
-  const m31 = rmat[6],
-    m32 = rmat[7],
-    m33 = rmat[8];
-
-  eular[1] = Math.asin(-fclamp(m31, -1, 1));
-  if (Math.abs(m31) < 0.9999999) {
-    eular[0] = Math.atan2(m32, m33);
-    eular[2] = Math.atan2(m21, m11);
-  } else {
-    eular[0] = 0;
-    eular[2] = Math.atan2(-m12, m22);
+  else {
+      vec3.set(
+          euler,
+          Math.atan2(R[7], R[8]),   // roll
+          pitch,                    // pitch
+          Math.atan2(R[3], R[0]),  // yaw
+      );
   }
-  return eular;
+  return euler;
 }
 
 
@@ -668,7 +674,7 @@ export function convMatrix2EularZYX(rmat, eular) {
  * const rotateY = 0.5;
  * const rotateZ = 0.5;
  * const mt3 = mat3.create();
- * convEular2matrixZYX(mt3, [rotateX, rotateY, rotateZ])
+ * convEular2matrixZYX(mt3, rotateX, rotateY, rotateZ)
  */
 export function convEular2matrixZYX(rmat, xangle, yangle, zangle) {
   let UnitZ = vec3.create();
@@ -739,8 +745,11 @@ export function enCodeMeshToBase64(mesh, matrix = undefined, byteLength = 14) {
  * @returns {vec3[]} 平滑之后的点
  */
 
-export function smaPoint(points, smaSize = 3) {
+export function smoothLoop(points, smaSize = 3) {
   const newPoints = [];
+  if(points.length < smaSize) {
+    return points;
+  }
   for (let i = 0; i < points.length; i++) {
     const step = Math.floor(smaSize / 2);
     const sumPoint = vec3.clone(points[i]);
@@ -760,13 +769,16 @@ export function smaPoint(points, smaSize = 3) {
 /**
  * 将一段有序点按指定size进行平滑
  * @param {vec3[]} points 一段有序点
- * @param {number} smaSize=3 平滑点的数量通常值为奇数
+ * @param {number} smoothSize=3 平滑点的数量通常值为奇数
  * @returns {vec3[]} 平滑之后的点
  */
-export function smaPointNotRound(points, smaSize = 3) {
+export function smoothCurve(points, smoothSize = 3) {
   const newPoints= [];
+  if(points.length < smoothSize) {
+    return points;
+  }
   for (let i = 0; i < points.length; i++) {
-    const step = Math.floor(smaSize / 2);
+    const step = Math.floor(smoothSize / 2);
     let sumPoint = vec3.clone(points[i]);
     for (let j = 1; j <= step; j++) {
       let lastIndex = i - j;
@@ -786,7 +798,7 @@ export function smaPointNotRound(points, smaSize = 3) {
     if (vec3.equals(sumPoint, points[i])) {
       centerPoint = sumPoint;
     } else {
-      centerPoint = vec3.scale(vec3.create(), sumPoint, 1 / smaSize);
+      centerPoint = vec3.scale(vec3.create(), sumPoint, 1 / smoothSize);
     }
     newPoints.push(centerPoint);
   }
@@ -970,63 +982,38 @@ export function pcaFitPlane(points) {
   }
 }
 
-
 /**
- * 计算一组 3D 点的最佳拟合平面（最小二乘法）。
- * @param {Array<vec3>} points - 3D 点数组，每个点是一个 vec3 向量。
- * @returns {Plane|null} - 返回平面的 origin（质心）和 normal（法向量），如果点数少于 3 个则返回 null。
+ * 计算曲线长度
+ * @param {vec3[]} points 曲线
+ * @returns {number} 曲线长度
  */
-export function leastSquaresFitPlane(points) {
-  if (points.length < 3) {
-      return null;
-  }
 
-  // Step 1: 计算质心（origin）
-  let centroid = vec3.create();
-  for (let point of points) {
-      vec3.add(centroid, centroid, point);
+export function getCurveLength(points) {
+  let dist = 0;
+  for (let i = 1; i < points.length; i++) {
+    dist += vec3.dist(points[i - 1], points[i]);
   }
-  vec3.scale(centroid, centroid, 1 / points.length);
-
-  // Step 2: 构建协方差矩阵
-  let xx = 0, xy = 0, xz = 0;
-  let yy = 0, yz = 0, zz = 0;
+  return dist;
+}
 
-  for (let point of points) {
-      let r = vec3.sub(vec3.create(), point, centroid); // r = point - centroid
 
-      xx += r[0] * r[0];
-      xy += r[0] * r[1];
-      xz += r[0] * r[2];
-      yy += r[1] * r[1];
-      yz += r[1] * r[2];
-      zz += r[2] * r[2];
+/**
+ * 
+ * @param {vec3[]} points 曲线
+ * @param {number} dist 目标点距离，绝对距离或者相对距离
+ * @param {boolean} [absDist=true] 是否使用绝对距离
+ * @returns 
+ */
+export function getCurvePointIndexByLength(points, dist, absDist = true) {
+  let allDist = getCurvePointDist(points);
+  const targetDist = absDist ? dist :  dist * allDist;
+  let targetDistanceSubs = [targetDist];
+  let distance = 0;
+  for (let i = 1; i < points.length; i++) {
+      distance += vec3.dist(points[i], points[i - 1])
+      targetDistanceSubs.push(Math.abs(distance - targetDist))
   }
-
-  // 协方差矩阵
-  const covarianceMatrix = mat3.fromValues(
-      xx, xy, xz,
-      xy, yy, yz,
-      xz, yz, zz
-  );
-
-  // Step 3: 计算协方差矩阵的特征值和特征向量
-  const eigenVectors = mat3.create();
-  const eigenValues = vec3.create();
-  mat3.eigenDecomposition(eigenValues, eigenVectors, covarianceMatrix);
-
-  // Step 4: 选择最小特征值对应的特征向量作为法向量
-  const minEigenIndex = eigenValues.indexOf(Math.min(...eigenValues));
-  const normal = vec3.fromValues(
-      eigenVectors[3 * minEigenIndex + 0],
-      eigenVectors[3 * minEigenIndex + 1],
-      eigenVectors[3 * minEigenIndex + 2]
-  );
-
-  vec3.normalize(normal, normal); // 单位化法向量
-
-  return {
-      origin: centroid,
-      normal: normal
-  };
+  const minSub = Math.min(...targetDistanceSubs);
+  const targetIndex = targetDistanceSubs.findIndex(i => i === minSub)
+  return targetIndex;
 }

package/types/vtkUtils.d.ts

@@ -306,12 +306,6 @@ export function loadMeshData(file: string | File | Blob, type?: "drc" | "stl" |
  * @returns {Plane| null} 拟合的平面
  */
 export function pcaFitPlane(points: vec3[]): Plane | null;
-/**
- * 计算一组 3D 点的最佳拟合平面（最小二乘法）。
- * @param {Array<vec3>} points - 3D 点数组，每个点是一个 vec3 向量。
- * @returns {Plane|null} - 返回平面的 origin（质心）和 normal（法向量），如果点数少于 3 个则返回 null。
- */
-export function leastSquaresFitPlane(points: Array<vec3>): Plane | null;
 /**
  * 计算 w2l(word 2 local, word to local) 的变换矩阵
  * @param {vec3} center 中心点