xl-public-utils 1.0.4 → 1.0.5

package/src/vtkUtils.mjs

@@ -1,5 +1,16 @@
 import vtkRenderer from "@kitware/vtk.js/Rendering/Core/Renderer";
-
+import vtkInteractorStyleManipulator from "@kitware/vtk.js/Interaction/Style/InteractorStyleManipulator"
+import vtkMouseCameraTrackballPanManipulator from "@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballPanManipulator";
+import vtkMouseCameraTrackballRotateManipulator from "@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballRotateManipulator";
+import vtkMouseCameraTrackballZoomManipulator from "@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballZoomManipulator";
+import vtkRenderWindowInteractor from "@kitware/vtk.js/Rendering/Core/RenderWindowInteractor";
+import vtkMatrixBuilder from "@kitware/vtk.js/Common/Core/MatrixBuilder";
+import { vec3, mat4, mat3 } from 'gl-matrix';
+import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData";
+import { exportBinarySTL } from './exportSTL.mjs';
+import { writePLY } from "./exportPLY.mjs";
+import { enCodeMesh } from './drcUtils.mjs';
+import { int8ArrayToBase64 } from "./utils.mjs";
 
 /**
  * 计算屏幕坐标到三维坐标
@@ -25,4 +36,772 @@ export function computeDisplayToWorld(renderer, x, y, z) {
 export function computeWorldToDisplay(renderer, x, y, z) {
   const view = renderer.getRenderWindow().getViews()[0];
   return view.worldToDisplay(x, y, z, renderer);
+}
+
+/**
+ * 计算 w2l(word 2 local, word to local) 的变换矩阵
+ * @param {vec3} center 中心点
+ * @param {vec3} xaxis x轴
+ * @param {vec3} yaxis y轴
+ * @param {vec3} zaxis z轴
+ * @returns { mat4 } 变换矩阵
+ */
+
+export function getW2LMatrix(
+  center,
+  xaxis,
+  yaxis,
+  zaxis
+) {
+  let rmat = mat4.create();
+  rmat[0] = xaxis[0];
+  rmat[4] = xaxis[1];
+  rmat[8] = xaxis[2];
+  rmat[12] = 0;
+
+  rmat[1] = yaxis[0];
+  rmat[5] = yaxis[1];
+  rmat[9] = yaxis[2];
+  rmat[13] = 0;
+
+  rmat[2] = zaxis[0];
+  rmat[6] = zaxis[1];
+  rmat[10] = zaxis[2];
+  rmat[14] = 0;
+
+  rmat[3] = 0;
+  rmat[7] = 0;
+  rmat[11] = 0;
+  rmat[15] = 1;
+
+  mat4.invert(rmat, rmat);
+
+  let tmat = mat4.create();
+  mat4.identity(tmat);
+  tmat[3] = -center[0];
+  tmat[7] = -center[1];
+  tmat[11] = -center[2];
+  mat4.multiply(rmat, tmat, rmat);
+
+  return mat4.transpose(rmat, rmat);
+}
+
+
+/**
+ * Alias for {@link getW2LMatrix}
+ * @function
+ */
+export const getmatw2l = getW2LMatrix;
+
+/**
+ * 计算 l2w(local 2 word, local to word) 的变换矩阵
+ * @param {vec3} center 中心点
+ * @param {vec3} xaxis x轴
+ * @param {vec3} yaxis y轴
+ * @param {vec3} zaxis z轴
+ * @returns { mat4 } 变换矩阵
+ */
+
+export function getL2WMatrix(
+  center,
+  xaxis,
+  yaxis,
+  zaxis
+) {
+  let rmat = mat4.create();
+  rmat[0] = xaxis[0];
+  rmat[4] = xaxis[1];
+  rmat[8] = xaxis[2];
+  rmat[12] = 0;
+
+  rmat[1] = yaxis[0];
+  rmat[5] = yaxis[1];
+  rmat[9] = yaxis[2];
+  rmat[13] = 0;
+
+  rmat[2] = zaxis[0];
+  rmat[6] = zaxis[1];
+  rmat[10] = zaxis[2];
+  rmat[14] = 0;
+
+  rmat[3] = 0;
+  rmat[7] = 0;
+  rmat[11] = 0;
+  rmat[15] = 1;
+
+  let tmat = mat4.create();
+  mat4.identity(tmat);
+  tmat[3] = center[0];
+  tmat[7] = center[1];
+  tmat[11] = center[2];
+
+  mat4.multiply(rmat, rmat, tmat);
+  return mat4.transpose(rmat, rmat);
+}
+
+
+/**
+ * Alias for {@link getL2WMatrix}
+ * @function
+ */
+export const getmatofl2w = getL2WMatrix;
+
+/**
+ * 返回交互的interactorStyle
+ * @returns {vtkInteractorStyleManipulator} 交互的interactorStyle
+ */
+export function make3DInteractorStyle() {
+  const interactorStyle = vtkInteractorStyleManipulator.newInstance();
+  const cameraRotate = vtkMouseCameraTrackballRotateManipulator.newInstance({
+    button: 1,
+  });
+  const cameraPan = vtkMouseCameraTrackballPanManipulator.newInstance({
+    button: 3,
+  });
+  // const cameraPanControl = vtkMouseCameraTrackballPanManipulator.newInstance({
+  //   button: 1,
+  //   shift: true,
+  // });
+  // const cameraRoll = vtkMouseCameraTrackballRollManipulator.newInstance({
+  //   button: 3,
+  //   control: true,
+  // });
+  const cameraZoom = vtkMouseCameraTrackballZoomManipulator.newInstance({
+    button: 2,
+  });
+  const cameraZoomDrag = vtkMouseCameraTrackballZoomManipulator.newInstance({
+    scrollEnabled: true,
+    dragEnabled: false,
+  });
+
+  interactorStyle.addMouseManipulator(cameraRotate);
+  interactorStyle.addMouseManipulator(cameraPan);
+  // interactorStyle.addMouseManipulator(cameraPanControl);
+  // interactorStyle.addMouseManipulator(cameraRoll);
+  // interactorStyle.addMouseManipulator(cameraZoom);
+  interactorStyle.addMouseManipulator(cameraZoomDrag);
+  return interactorStyle;
+}
+
+/**
+ * 移除并返回当前renderWindow的所有鼠标交互设定
+ * @param {vtkRenderWindowInteractor} interactor vtkRenderWindowInteractor
+ * @returns {any[]} 当前鼠标的所有交互Manipulators
+ */
+
+export function removeMouseInteraction(interactor) {
+  const interactorStyle = interactor.getInteractorStyle();
+  const mm = interactorStyle.getMouseManipulators();
+  interactorStyle.removeAllMouseManipulators();
+  return mm;
+}
+
+/**
+ * 给当前窗口设置交互Maintainers
+ * @param {vtkRenderWindowInteractor} interactor vtkRenderWindowInteractor
+ * @param {any[]} mm 所有的交互Maintainers
+ * @returns {void}
+ */
+export function resetAllMouseMaintainers(interactor, mm) {
+  const interactorStyle = interactor.getInteractorStyle();
+  mm.forEach(element => {
+    interactorStyle.addMouseManipulator(element);
+  });
+}
+
+/**
+ * 将点投影到平面上
+ * @param {vec3} point 需要投影的点
+ * @param {vec3} origin 平面中心点
+ * @param {vec3} normal 平面法向量
+ * @returns {vec3} 投影到平面之后的点
+ */
+export function projectPointToPlane(point, origin, normal) {
+  const xo = vec3.sub(vec3.create(), point, origin);
+  let t = vec3.dot(normal, xo);
+  let xproj = vec3.sub(vec3.create(), point, vec3.scale(vec3.create(), normal, t));
+  return xproj;
+}
+
+/**
+ * 将向量投影到面上
+ * 
+ * @param {vec3} vec - The vector to project.
+ * @param {vec3} norm - The normal vector of the plane (assumed to be normalized).
+ * @returns {vec3} - The projected vector on the plane.
+ */
+export function projectVecToPlane(vec, norm) {
+  // Calculate the dot product of the vector and the normal
+  const dotProduct = vec3.dot(vec, norm);
+
+  // Calculate the projection vector along the normal direction
+  const projectionOnNormal = vec3.scale(vec3.create(), norm, dotProduct);
+
+  // Subtract the projection on the normal from the original vector
+  const projectedVec = vec3.subtract(vec3.create(), vec, projectionOnNormal);
+
+  return projectedVec;
+}
+
+
+/**
+ * 将直线外一点投影到直线(两个点)上
+ * @param {vec3} point 直线外一点
+ * @param {vec3} begin 直线开始点
+ * @param {vec3} end 直线结束点
+ * @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;
+
+  //  确保两个点不是同一个点
+  if (Math.abs(dx) < EPS && Math.abs(dy) < EPS && Math.abs(dz) < EPS) {
+    return begin;
+  }
+
+  //计算斜率
+  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));
+
+  return vec3.set(
+    vec3.create(),
+    begin[0] + u * dx,
+    begin[1] + u * dy,
+    begin[2] + u * dz
+  );
+}
+
+/**
+ * 将点投影到直线(point+dir)上
+ * @param {vec3} point 直线外的点
+ * @param {vec3} linePoint 直线任意一点
+ * @param {vec3} lineDir 直线方向
+ * @returns {vec3} 投影到直线上后的点
+ */
+
+export function projectPointToLine(
+  point,
+  linePoint,
+  lineDir,
+) {
+  const t =
+    vec3.dot(vec3.sub(vec3.create(), point, linePoint), lineDir) /
+    vec3.squaredLength(lineDir);
+  return vec3.add(
+    vec3.create(),
+    linePoint,
+    vec3.scale(vec3.create(), lineDir, t)
+  );
+}
+
+/**
+ * 获取曲线外一点到曲线最近点的索引
+ * @param {vec3} point 曲线外一点
+ * @param {vec3[]} points 曲线
+ * @returns {number} 返回离点最近的曲线点索引
+ */
+export function getPointToPointsMinIndex(point, points) {
+  let index = 0;
+  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;
+      index = i;
+    }
+  }
+  return index;
+}
+
+/**
+ * 获取点到曲线的最近距离
+ * @param {vec3} point 曲线外一点
+ * @param {vec3[]} 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;
+    }
+  }
+  return dist;
+}
+
+
+/**
+ * 获取点到曲线的最近点
+ * @param {vec3} point 曲线外一点
+ * @param {vec3[]} points 曲线
+ * @returns {vec3} 返回点到曲线的最近点
+ */
+
+export function getPointToPointsMinPoint(point, points) {
+  const index = getPointToPointsMinIndex(point, points);
+  return points[index];
+}
+
+
+/**
+ * 获取直线外一点到直线的距离
+ * @param {vec3} point 直线外一点
+ * @param {vec3} begin 直线开始点
+ * @param {vec3} end 直线结束点
+ * @returns {number} 点到直线的距离
+ */
+
+export function getPointToLineDist(point, begin, end) {
+  const linePoint = projectPointOnPoints(point, begin, end);
+  return vec3.dist(linePoint, point);
+}
+
+/**
+ * 计算点到平面的距离 
+ * @param {vec3} point 任意一点
+ * @param {vec3} origin 平面上一点
+ * @param {vec3} normal 平面法向量，要求单位化
+ * @returns {number}
+ */
+export function getPointToPlaneDist(point, origin, normal) {
+  return vec3.dot(vec3.sub(vec3.create(), point, origin), normal);
+}
+
+
+/**
+ * 对一个polydata应用矩阵变化，直接改变点位置
+ * @param {mat4} mt4 变换矩阵
+ * @param {vtkPolyData} data 需要应用变换的polydata
+ */
+
+export function pointsApplyMat4(mt4, data) {
+  vtkMatrixBuilder
+    .buildFromDegree()
+    .multiply(mt4)
+    .apply(data.getPoints().getData());
+}
+
+/**
+ * 将点应用矩阵变换
+ * @param {vec3} point 三维点
+ * @param {mat4} matrix 变换矩阵
+ * @returns {vec3} 应用矩阵变换之后的点
+ */
+export function pointTransformByMat4(point, matrix) {
+  return vec3.transformMat4(vec3.create(), point, matrix);
+}
+/**
+ * 将向量应用矩阵变换
+ * @param {vec3} vec 向量
+ * @param {mat4} matrix 变换矩阵
+ * @returns {vec3} 应用矩阵变换之后的向量
+ */
+export function vecTransfromByMat4(vec, matrix) {
+  const newMatrix = mat4.clone(matrix);
+  newMatrix[12] = 0;
+  newMatrix[13] = 0;
+  newMatrix[14] = 0;
+  return vec3.transformMat4(vec3.create(), vec, newMatrix);
+}
+
+/**
+ * 获取mesh的ply文件Blob
+ * @param {vtkPolyData} mesh 网格polydata
+ * @param {'ascii' | 'binary'} [format='ascii'] format 导出文件格式
+ * @returns {Blob} 网格的ply文件Blob
+ */
+export function createPlyBlob(mesh, format = 'ascii') {
+  // const data = deduplicatePolyData(mesh)
+  // const deduplicateData = deduplicatePolyData(mesh);
+  const fileContents = writePLY(mesh, format);
+  const blob = new Blob([fileContents], { type: "application/octet-steam" });
+  return blob;
+}
+
+/**
+ * 获取mesh的stl文件Blob，由于STL文件过大，只使用Binary格式
+ * @param {vtkPolyData} mesh 网格polydata
+ * @returns {Blob} 网格的BinarySTL文件Blob
+ */
+export function createStlBlob(mesh) {
+  const blob = exportBinarySTL(mesh);
+  return blob;
+}
+
+/**
+ * 将网格压缩为drc文件，导出drc需要先加载draco_encode.js，并调用initDrcCoder初始化
+ * @param {vtkPolyData} mesh 网格文件
+ * @returns {Blob} drc文件
+ */
+export function createDrcBlob(mesh) {
+  const blob = new Blob([enCodeMesh(mesh)]);
+  return blob;
+}
+
+
+/**
+ * 将网格输出为对应类型的Blob,均采用默认参数，导出drc需要先加载draco_encode.js，并调用initDrcCoder初始化
+ * @param {vtkPolyData} mesh 网格文件
+ * @param {'ply' | 'stl' | 'drc' } type 输出类型 
+ * @returns {Blob} 对应类型的Blob
+ */
+
+export function createMeshTypeBlob(
+  mesh,
+  type
+) {
+  if (type !== "ply" && type !== "stl" && type !== "drc") {
+    return null;
+  }
+  switch (type) {
+    case "ply":
+      return createPlyBlob(mesh);
+    case "stl":
+      return createStlBlob(mesh);
+    case "drc":
+      return createDrcBlob(mesh);
+  }
+}
+
+
+/**
+ * vtkPolyData的顶点去重
+ * 用于3倍顶点的stl和老版本的vtkMarchingCube
+ * @param {vtkPolyData} data 网格的vtkPolyData
+ * @returns {vtkPolyData} 去重之后的vtkPolyData
+ */
+export const deduplicatePolyData = (data) => {
+  const OFFSET_BOUNDS = 10;
+  const vMap = new Map();
+  const vIndexMap = new Map();
+  const cMap = new Map();
+  const vertices = data.getPoints().getData();
+  const hasColorInfo = !!data.getPointData().getScalars();
+  const colors = hasColorInfo
+    ? data.getPointData().getScalars().getData()
+    : new Uint8Array(vertices.length);
+  let vInc = 0; // 顶点新索引
+  // 更新顶点map:vMap和顶点映射map:vIndexMap
+  for (let i = 0; i < vertices.length; i += 3) {
+    // const key: string = `${vertices[i]},${vertices[i + 1]},${vertices[i + 2]}`
+    const key = `${(vertices[i] * Math.pow(10, OFFSET_BOUNDS)).toFixed(
+      0
+    )},${(vertices[i + 1] * Math.pow(10, OFFSET_BOUNDS)).toFixed(0)},${(
+      vertices[i + 2] * Math.pow(10, OFFSET_BOUNDS)
+    ).toFixed(0)}`;
+    if (vMap.get(key) !== undefined) {
+      vIndexMap.set(i / 3, vMap.get(key));
+    } else {
+      vIndexMap.set(i / 3, vInc);
+      hasColorInfo && cMap.set(vInc, [colors[i], colors[i + 1], colors[i + 2]]);
+      vMap.set(key, vInc);
+      vInc++;
+    }
+  }
+  const tVertices = new Float32Array(vMap.size * 3);
+  const tColors = new Uint8Array(vMap.size * 3).fill(255);
+
+  for (let k of vMap.keys()) {
+    const j = vMap.get(k) * 3;
+    [tVertices[j], tVertices[j + 1], tVertices[j + 2]] = k
+      .split(",")
+      .map((e) => +e * Math.pow(10, -OFFSET_BOUNDS));
+    const t = cMap.get(vMap.get(k));
+    hasColorInfo && ([tColors[j], tColors[j + 1], tColors[j + 2]] = t);
+  }
+  const faces = data.getPolys().getData();
+  const tFaces = new Int32Array(faces);
+  for (let i = 0; i < faces.length; i += 4) {
+    tFaces[i] = 3;
+    tFaces[i + 1] = vIndexMap.get(faces[i + 1]);
+    tFaces[i + 2] = vIndexMap.get(faces[i + 2]);
+    tFaces[i + 3] = vIndexMap.get(faces[i + 3]);
+  }
+  const p = vtkPolyData.newInstance();
+  p.getPoints().setData(tVertices);
+  p.getPolys().setData(tFaces);
+  return p;
+};
+
+/**
+ * 计算一组三维点的中心点
+ * @param {vec3[]} points 三维点数组
+ * @returns {vec3} 中心点
+ */
+
+export function getPointsCenter(points) {
+  let sumPoints = vec3.create();
+  for (let i = 0; i < points.length; i++) {
+    vec3.add(sumPoints, sumPoints, points[i]);
+  }
+  return vec3.scale(vec3.create(), sumPoints, 1 / points.length);
+}
+
+/**
+ * @typedef Position
+ * @property {number} x 对应vtk坐标系的x值
+ * @property {number} y 对应vtk坐标系的y值
+ * @property {number} z 0
+ */
+
+/**
+ * 计算js事件对应vtk事件的position
+ * @param {HTMLElement} el vtkViewDom
+ * @param {MouseEvent} event 二维鼠标事件
+ * @returns {Position} 对应vtk坐标系的xyz值
+ */
+export function getScreenEventPositionFor(el, event) {
+  var canvas = el.getElementsByTagName("canvas")[0];
+
+  var bounds = canvas.getBoundingClientRect();
+  var scaleX = canvas.width / bounds.width;
+  var scaleY = canvas.height / bounds.height;
+  var position = {
+    x: scaleX * (event.clientX - bounds.left),
+    y: scaleY * (bounds.height - event.clientY + bounds.top),
+    z: 0,
+  };
+  return position;
+}
+
+/**
+ * 将数值数组转换为vec3数组
+ * @param {number[] | Float32Array} dataList 
+ * @returns {vec3[]} 格式化之后的数组
+ */
+
+export function formatNumberArrayToVec3Array(dataList) {
+  const vec3Data = [];
+  for (let i = 0; i < dataList.length / 3; i++) {
+    const data = [
+      dataList[i * 3],
+      dataList[i * 3 + 1],
+      dataList[i * 3 + 2],
+    ];
+    vec3Data.push(data);
+  }
+  return vec3Data;
+}
+
+
+/**
+ * 简单的数值平均插值
+ * @param {number} from 开始数值
+ * @param {number} to 结束数值
+ * @param {number} step 步长
+ * @returns {number[]} 插值的数值
+ */
+export function calculateSimpleLerp(from, to, step) {
+  let lerps = [];
+  let temp = from;
+  const a = (to - from) / (step + 1);
+  for (let i = 0; i < step; i++) {
+    lerps.push((temp += a));
+  }
+  return lerps;
+}
+
+/**
+ * 将 mat3 解析为 3 个自由度的 欧拉角(Eular)(弧度)
+ * @param {mat3} rmat 3 * 3的矩阵
+ * @param {[number, number, number]} eular 输出的欧拉角度数(弧度)
+ * @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;
+  }
+  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);
+  }
+  return eular;
+}
+
+
+/**
+ * 将欧拉角(Eular)转换为mat3
+ * @param {mat3} rmat 变换矩阵
+ * @param {number} xangle 对应欧拉角x 弧度
+ * @param {number} yangle 对应欧拉角y 弧度
+ * @param {number} zangle 对应欧拉加z 弧度
+ * @returns {mat3} 对应变换矩阵
+ * @example
+ * const rotateX = 0.5;
+ * const rotateY = 0.5;
+ * const rotateZ = 0.5;
+ * const mt3 = mat3.create();
+ * convEular2matrixZYX(mt3, [rotateX, rotateY, rotateZ])
+ */
+export function convEular2matrixZYX(rmat, xangle, yangle, zangle) {
+  let UnitZ = vec3.create();
+  vec3.set(UnitZ, 0, 0, 1);
+  // let UnitZ = getLocalAxis(0, 0, 1);
+  let qz = quat.create();
+  quat.setAxisAngle(qz, UnitZ, zangle);
+  quat.normalize(qz, qz);
+
+  let UnitY = vec3.create();
+  vec3.set(UnitY, 0, 1, 0);
+  // let UnitY = getLocalAxis(0, 1, 0);
+  vec3.transformQuat(UnitY, UnitY, qz);
+  vec3.normalize(UnitY, UnitY);
+
+  let qy = quat.create();
+  quat.setAxisAngle(qy, UnitY, yangle);
+  quat.normalize(qy, qy);
+
+  let UnitX = vec3.create();
+  vec3.set(UnitX, 1, 0, 0);
+  // let UnitX = getLocalAxis(1, 0, 0);
+  vec3.transformQuat(UnitX, UnitX, qz);
+  vec3.transformQuat(UnitX, UnitX, qy);
+  vec3.normalize(UnitX, UnitX);
+
+  let qx = quat.create();
+  quat.setAxisAngle(qx, UnitX, xangle);
+  quat.normalize(qx, qx);
+
+  //instrinsic qx*qy*qz
+  quat.multiply(qx, qx, qy);
+  quat.multiply(qx, qx, qz);
+
+  let qx2 = quat.create();
+  quat.multiply(qx2, qy, qx);
+  quat.multiply(qx2, qz, qx2);
+
+  mat3.fromQuat(rmat, qx);
+  // mat3.transpose(rmat, rmat);
+  // console.log('🚀 ~  mat3', rmat)
+  return rmat;
+}
+
+/**
+ * 将drc
+ * @param {vtkPolyData} mesh 网格polyData
+ * @param {mat4} [matrix] 变换矩阵
+ * @returns {string} drc压缩之后的网格base64
+ */
+export function enCodeMeshToBase64(mesh, matrix = undefined) {
+  const encodePolydata = vtkPolyData.newInstance();
+  encodePolydata.getPoints().setData([...mesh.getPoints().getData()]);
+  encodePolydata.getPolys().setData([...mesh.getPolys().getData()]);
+  if(matrix) {
+    pointsApplyMat4(matrix, encodePolydata);
+  }
+  return int8ArrayToBase64(enCodeMesh(encodePolydata))
+}
+
+/**
+ * 将一圈有序点按指定size进行平滑
+ * @param {vce3[]} points 一圈有序点
+ * @param {number} smaSize=3 平滑点的数量通常值为奇数
+ * @returns {vec3[]} 平滑之后的点
+ */
+
+export function smaPoint(points, smaSize = 3) {
+  const newPoints = [];
+  for (let i = 0; i < points.length; i++) {
+    const step = Math.floor(smaSize / 2);
+    const sumPoint = vec3.clone(points[i]);
+    for (let j = 1; j <= step; j++) {
+      let lastIndex = i - j;
+      let nextIndex = i + j;
+      if (lastIndex < 0) lastIndex = points.length + lastIndex;
+      if (nextIndex > points.length - 1) nextIndex = nextIndex - points.length;
+      vec3.add(sumPoint, sumPoint, points[lastIndex]);
+      vec3.add(sumPoint, sumPoint, points[nextIndex]);
+    }
+    const centerPoint = vec3.scale(vec3.create(), sumPoint, 1 / smaSize);
+    newPoints.push(centerPoint);
+  }
+  return newPoints;
+}
+/**
+ * 将一段有序点按指定size进行平滑
+ * @param {vce3[]} points 一段有序点
+ * @param {number} smaSize=3 平滑点的数量通常值为奇数
+ * @returns {vec3[]} 平滑之后的点
+ */
+export function smaPointNotRound(points, smaSize = 3) {
+  const newPoints= [];
+  for (let i = 0; i < points.length; i++) {
+    const step = Math.floor(smaSize / 2);
+    let sumPoint = vec3.clone(points[i]);
+    for (let j = 1; j <= step; j++) {
+      let lastIndex = i - j;
+      let nextIndex = i + j;
+      if (lastIndex < 0) {
+        sumPoint = points[i];
+        break;
+      }
+      if (nextIndex > points.length - 1) {
+        sumPoint = points[i];
+        break;
+      }
+      vec3.add(sumPoint, sumPoint, points[lastIndex]);
+      vec3.add(sumPoint, sumPoint, points[nextIndex]);
+    }
+    let centerPoint;
+    if (vec3.equals(sumPoint, points[i])) {
+      centerPoint = sumPoint;
+    } else {
+      centerPoint = vec3.scale(vec3.create(), sumPoint, 1 / smaSize);
+    }
+    newPoints.push(centerPoint);
+  }
+  return newPoints;
+}
+
+/**
+ * 表示一个包含三个轴向的对象
+ * @typedef {Object} AxisObject
+ * @property {vec3} x - x轴
+ * @property {vec3} y - y轴
+ * @property {vec3} z - z轴
+ */
+
+/**
+ * 获取一个矩阵的三个轴向
+ * @param {mat4} matrix 4 * 4 的矩阵
+ * @returns {AxisObject} 三个轴向
+ */
+
+export function getAxisFormMat4(matrix) {
+  let axis_x = vec3.fromValues(matrix[0], matrix[1], matrix[2]);
+  let axis_y = vec3.fromValues(matrix[4], matrix[5], matrix[6]);
+  let axis_z = vec3.fromValues(matrix[8], matrix[9], matrix[10]);
+  vec3.normalize(axis_x, axis_x);
+  vec3.normalize(axis_y, axis_y);
+  vec3.normalize(axis_z, axis_z);
+  return { x: axis_x, y: axis_y, z: axis_z };
 }