xl-public-utils 1.0.4 → 1.0.6

package/index.js

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

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "xl-public-utils",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "",
+  "type": "module",
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
   "peerDependencies": {
-    "@kitware/vtk.js": ">=25.7.2"
+    "@kitware/vtk.js": ">=25.7.2",
+    "gl-matrix": ">=3.4.3"
   },
   "peerDependenciesMeta": {
     "@kitware/vtk.js": {
       "optional": true
+    },
+    "gl-matrix": {
+      "optional": true
     }
   },
   "exports": {
@@ -21,11 +26,14 @@
     "./bwipJs": "./src/bwip-js.mjs"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
   },
   "keywords": [
     "一些通用方法"
   ],
   "author": "xl",
-  "license": "ISC"
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  }
 }

package/src/drcUtils.mjs

@@ -0,0 +1,353 @@
+import { vec3 } from "gl-matrix";
+import { int8ArrayToBase64 } from './utils.mjs'
+import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData";
+/**
+ * @typedef {Object} AttrOption
+ * @property {number[]} [colors] 颜色数组
+ * @property {number[]} [generics] 属性数组
+ * @property {number[]} [normals] 法向量数组
+ */
+
+/**
+ * 将数据进行压缩
+ * @param {number[]} vertices 网格点
+ * @param {number[]} faces 网格面，必须是三角化之后的面，每连续的三个点索引标识一个面
+ * @param {number} byteLength=14 byteLength 压缩率
+ * @param {AttrOption} [attr] 其他需要压缩的属性
+ * @returns {Int8Array} 压缩之后的DRC数据
+ */
+export function enCodeMeshByVF(vertices, faces, byteLength = 14, attr =undefined)  {
+  const facesFlat = faces;
+  const pointFlat = vertices;
+  const encoderModule = window.encoderModule
+  const encoder = new encoderModule.Encoder();
+  const meshBuilder = new encoderModule.MeshBuilder();
+  const dracoMesh = new encoderModule.Mesh();
+  const numberFaces = faces.length / 3;
+  const numberPoints = vertices.length / 3;
+  meshBuilder.AddFacesToMesh(dracoMesh, numberFaces, facesFlat);
+  meshBuilder.AddFloatAttributeToMesh(dracoMesh, encoderModule.POSITION, numberPoints, 3, pointFlat);
+  if (attr) {
+    if (attr.colors && attr.colors.length) {
+      meshBuilder.AddFloatAttributeToMesh(dracoMesh, encoderModule.COLOR, numberPoints, 3, attr.colors);
+    }
+    if (attr.normals && attr.normals.length) {
+      meshBuilder.AddFloatAttributeToMesh(dracoMesh, encoderModule.NORMAL, numberPoints, 3, attr.normals);
+    }
+    if (attr.generics && attr.generics.length) {
+      meshBuilder.AddFloatAttributeToMesh(dracoMesh, encoderModule.GENERIC, numberPoints, 3, attr.generics);
+    }
+  }
+  
+  // encoder.SetSpeedOptions(5, 5);
+  encoder.SetAttributeQuantization(encoderModule.POSITION, byteLength);
+  encoder.SetEncodingMethod(encoderModule.MESH_EDGEBREAKER_ENCODING);
+  const encodedData = new encoderModule.DracoInt8Array();
+  const encodedLen = encoder.EncodeMeshToDracoBuffer(dracoMesh, encodedData);
+  const outputBuffer = new ArrayBuffer(encodedLen);
+  const outputData = new Int8Array(outputBuffer);
+  for (let i = 0; i < encodedLen; ++i) {
+    outputData[i] = encodedData.GetValue(i);
+  }
+  encoderModule.destroy(dracoMesh);
+  encoderModule.destroy(encoder);
+  encoderModule.destroy(meshBuilder);
+  return outputData
+}
+
+/**
+ * 使用drc压缩点
+ * @param {vec3[] | number[]} points 点数组
+ * @returns {Int8Array} 压缩之后的drc data
+ */
+export function enCodePointCloud(points) {
+  const encoderModule = window.encoderModule
+  const encoder = new encoderModule.Encoder();
+  const pointCloudBuilder = new encoderModule.PointCloudBuilder();
+  const dracoPointCloud = new encoderModule.PointCloud();
+  const pointsFlat = [];
+  for(let i= 0; i <points.length; i++) {
+    if(typeof points[i] === 'object') {
+      pointsFlat.push(points[i][0], points[i][1], points[i][2]);
+    } else {
+      pointsFlat.push(points[i])
+    }
+  }
+  const numberPoints = pointsFlat.length / 3;
+  pointCloudBuilder.AddFloatAttribute(dracoPointCloud, encoderModule.POSITION, numberPoints, 3, pointsFlat);
+  
+  encoder.SetAttributeQuantization(encoderModule.POSITION, 14);
+  
+  encoder.SetEncodingMethod(encoderModule.MESH_SEQUENTIAL_ENCODING);
+  const encodedData = new encoderModule.DracoInt8Array();
+  const encodedLen = encoder.EncodePointCloudToDracoBuffer(dracoPointCloud, false, encodedData);
+  const outputBuffer = new ArrayBuffer(encodedLen);
+  const outputData = new Int8Array(outputBuffer);
+  for (let i = 0; i < encodedLen; ++i) {
+    outputData[i] = encodedData.GetValue(i);
+  }
+  encoderModule.destroy(dracoPointCloud);
+  encoderModule.destroy(encoder);
+  encoderModule.destroy(pointCloudBuilder);
+  return outputData
+}
+/**
+ * 解压drc格式的点云数据
+ * @param {ArrayBuffer} byteArray drc点数据
+ * @returns {Float32Array} 点数组
+ */
+export function decodePointCloud(byteArray) {
+  const dracoPointCloud = decodeBuffer(byteArray);
+  return getPointCloudFromDracoGeometry(dracoPointCloud);
+}
+
+/**
+ * @typedef {Object} DrcMeshData
+ * @property {Uint32Array} faces 网格面数组
+ * @property {Float32Array} vertices 网格点数组
+ * @property {Float32Array} [colors] 颜色数组
+ * @property {Float32Array} [generics] 属性数组
+ * @property {Float32Array} [normals] 法向量数组
+ */
+
+/**
+ * 解压drc格式的网格数据
+ * @param {ArrayBuffer} byteArray drc网格数据
+ * @returns {DrcMeshData} 网格数据
+ */
+export function decodeDrcBufferArray(byteArray) {
+  var dracoGeometry = decodeBuffer(byteArray);
+  return getPolyDataFromDracoGeometry(dracoGeometry);
+}
+/**
+ * @typedef {Object} Decoder
+ */
+
+/**
+ * 输入一个Drc数据，反会对应的解压器
+ * @param {ArrayBuffer} arrayBuffer 输入的数据
+ * @returns {Decoder} drc解压类
+ */
+export function decodeBuffer(arrayBuffer) {
+  const decoderModule = window.decoderModule;
+  var byteArray = new Int8Array(arrayBuffer);
+  var decoder = new decoderModule.Decoder();
+  var decoderBuffer = new decoderModule.DecoderBuffer();
+  decoderBuffer.Init(byteArray, byteArray.length);
+  var geometryType = decoder.GetEncodedGeometryType(decoderBuffer);
+  var dracoGeometry;
+
+  if (geometryType === decoderModule.TRIANGULAR_MESH) {
+    dracoGeometry = new decoderModule.Mesh();
+    var status = decoder.DecodeBufferToMesh(decoderBuffer, dracoGeometry);
+
+    if (!status.ok()) {
+      console.error("Could not decode Draco file: ".concat(status.error_msg()));
+    }
+  } else if ( geometryType === decoderModule.POINT_CLOUD ) {
+    dracoGeometry = new decoderModule.PointCloud();
+    var status =
+            decoder.DecodeBufferToPointCloud(decoderBuffer, dracoGeometry);
+    if(!status.ok()) {
+      console.error('Wrong geometry type, expected mesh, got point cloud.');
+    }
+  }
+
+  decoderModule.destroy(decoderBuffer);
+  decoderModule.destroy(decoder);
+  return dracoGeometry;
+}
+
+/**
+ * 获取drcDecoder中的网格信息
+ * @param {Decoder} dracoGeometry DRC网格的decoder
+ * @returns {DrcMeshData} decoder中的网格信息
+ */
+function getPolyDataFromDracoGeometry(dracoGeometry) {
+  const decoderModule = window.decoderModule;
+  var decoder = new decoderModule.Decoder(); // Get position attribute ID
+
+  var positionAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.POSITION);
+
+  if (positionAttributeId === -1) {
+    console.error('No position attribute found in the decoded model.');
+    decoderModule.destroy(decoder);
+    decoderModule.destroy(dracoGeometry);
+    return null;
+  }
+  var positionArray = getDracoAttributeAsFloat32Array(dracoGeometry, positionAttributeId); // Read indices
+  var i = dracoGeometry.num_faces();
+  var indices = new Uint32Array(i * 4);
+  var indicesArray = new decoderModule.DracoInt32Array();
+  while (i--) {
+    decoder.GetFaceFromMesh(dracoGeometry, i, indicesArray);
+    var index = i * 4;
+    indices[index] = 3;
+    indices[index + 1] = indicesArray.GetValue(0);
+    indices[index + 2] = indicesArray.GetValue(1);
+    indices[index + 3] = indicesArray.GetValue(2);
+  } // Create polyData and add positions and indinces
+  var normalAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.NORMAL);
+  var normals;
+  if (normalAttributeId !== -1) {
+    normals = getDracoAttributeAsFloat32Array(dracoGeometry, decoderModule.NORMAL);
+  } // Texture coordinates
+  var genericattributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.GENERIC);
+  let generics;
+  if (genericattributeId !== -1) {
+    generics = getDracoAttributeAsFloat32Array(dracoGeometry, genericattributeId);
+  }
+
+  // var texCoordAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.TEX_COORD);
+
+  // if (texCoordAttributeId !== -1) {
+  //   var texCoordArray = getDracoAttributeAsFloat32Array(dracoGeometry, texCoordAttributeId);
+  //   var texCoords = vtkDataArray.newInstance({
+  //     numberOfComponents: 2,
+  //     values: texCoordArray,
+  //     name: 'TCoords'
+  //   });
+  // } // Scalars
+
+
+  var colorAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.COLOR);
+  let colors;
+  if (colorAttributeId !== -1) {
+    colors = getDracoAttributeAsFloat32Array(dracoGeometry, colorAttributeId);
+  }
+
+  decoderModule.destroy(decoder);
+  return {
+    faces: indices,
+    vertices: positionArray,
+    normals,
+    colors,
+    generics
+  };
+}
+
+/**
+ * 解压DRC点云数据
+ * @param {Decoder} dracoGeometry DRC点云的Decder
+ * @returns {Float32Array} 点
+ */
+function getPointCloudFromDracoGeometry(dracoGeometry) {
+  const decoderModule = window.decoderModule;
+  var decoder = new decoderModule.Decoder(); // Get position attribute ID
+
+  var positionAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.POSITION);
+
+  if (positionAttributeId === -1) {
+    console.error('No position attribute found in the decoded model.');
+    decoderModule.destroy(decoder);
+    decoderModule.destroy(dracoGeometry);
+    return new Float32Array();
+  } else  {
+    const points = getDracoAttributeAsFloat32Array(dracoGeometry, positionAttributeId); // Read indices
+    decoderModule.destroy(decoder);
+    return points;
+  }
+}
+/**
+ * 获取decoder中的属性
+ * @param {Decoder} dracoGeometry DRC Decoder
+ * @param {number} attributeId 需要获取的属性id
+ * @returns {Float32Array} 对应decoder中的属性
+ */
+export function getDracoAttributeAsFloat32Array(dracoGeometry, attributeId) {
+  const decoderModule = window.decoderModule;
+  var decoder = new decoderModule.Decoder();
+  var attribute = decoder.GetAttribute(dracoGeometry, attributeId);
+  var numberOfComponents = attribute.num_components();
+  var numberOfPoints = dracoGeometry.num_points();
+  var attributeData = new decoderModule.DracoFloat32Array();
+  decoder.GetAttributeFloatForAllPoints(dracoGeometry, attribute, attributeData);
+  var i = numberOfPoints * numberOfComponents;
+  var attributeArray = new Float32Array(i);
+  while (i--) {
+    attributeArray[i] = attributeData.GetValue(i);
+  }
+
+  return attributeArray;
+}
+
+
+/**
+ * 将点数据使用drc压缩处理为 base64 string
+ * @param {vec3[] | number[]} points 点数据
+ * @returns {string} drc压缩之后的base64数据
+ */
+
+export function enCloudPointTobase64(points) {
+  return int8ArrayToBase64(enCodePointCloud(points));
+}
+
+
+/**
+ * @typedef {Object} Mesh
+ * @property {number[][]} vertices 点信息
+ * @property {number[][]} faces 面信息
+ */
+
+/**
+ * 使用drc压缩网格信息
+ * @param {Mesh | vtkPolyData} mesh 
+ * @param {number} byteLength=14  压缩率
+ * @param {AttrOption} [attr] 其他需要压缩的属性
+ * @returns {Int8Array} 压缩之后的DRC数据
+ */
+
+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.faces.length; i++) {
+      const face = mesh.faces[i];
+      faces.push(face[0]);
+      faces.push(face[1]);
+      faces.push(face[2]);
+    }
+  } else if(mesh.getClassName && mesh.getClassName() === 'vtkPolyData') {
+    vertices = mesh.getPoints().getData();
+    const _vtkFaces = mesh.getPolys().getData();
+    const nbFaces = _vtkFaces.length / 4;
+    for(let i = 0; i < nbFaces; i++) {
+      faces.push(_vtkFaces[i * 4 + 1]);
+      faces.push(_vtkFaces[i * 4 + 2]);
+      faces.push(_vtkFaces[i * 4 + 3]);
+    }
+  }
+  return enCodeMeshByVF(vertices, faces, byteLength, attr)
+}
+
+/**
+ * 初始化Draco文件
+ */
+export function initDrcCoder() {
+  if (!window.encoderModule) {
+    const timerEncoder = setInterval(() => {
+      if (window.DracoEncoderModule) {
+        window.DracoEncoderModule().then((res) => {
+          window.encoderModule = res;
+        });
+        clearInterval(timerEncoder);
+      }
+    }, 50);
+  }
+  if (!window.decoderModule) {
+    const timerDecoder = setInterval(() => {
+      if (window.DracoDecoderModule) {
+        window.DracoDecoderModule().then((res) => {
+          window.decoderModule = res;
+          function a() {
+            return res;
+          }
+          // show.value = true;
+          vtkDracoReader.setDracoDecoder(a);
+        });
+        clearInterval(timerDecoder);
+      }
+    }, 50);
+  }
+}

package/src/exportPLY.mjs

@@ -0,0 +1,285 @@
+import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData";
+import { mat4 } from "gl-matrix";
+var FormatTypes = {
+  ASCII: 'ascii',
+  BINARY: 'binary'
+};
+var TextureCoordinatesName = {
+  UV: ['u', 'v'],
+  TEXTURE_UV: ['texture_u', 'texture_v']
+};
+
+var DEFAULT_VALUES = {
+  format: FormatTypes.ASCII,
+  dataByteOrder: 0,
+  headerComments: [],
+  textureFileName: '',
+  textureCoordinatesName: TextureCoordinatesName.UV,
+  withNormals: false,
+  withUVs: false,
+  withColors: false,
+  withIndices: true
+}
+
+var _writeHeader = function writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, vertexCount, faceListLength, withNormals, withUVs, withColors, withIndices) {
+  var isBinary = fileFormat !== FormatTypes.ASCII;
+  var format;
+
+  if (isBinary) {
+    format = fileType ? 'binary_little_endian' : 'binary_big_endian';
+  } else format = 'ascii';
+
+  headerComments.unshift('VTK.js generated PLY File');
+
+  if (textureFileName) {
+    headerComments.push("TextureFile ".concat(textureFileName));
+  }
+
+  var commentElements = headerComments.map(function (comment) {
+    return "comment ".concat(comment);
+  }).join('\n');
+  var header = ['ply', "format ".concat(format, " 1.0"), "".concat(commentElements), "element vertex ".concat(vertexCount), 'property float x', 'property float y', 'property float z']; // normals
+
+  if (withNormals) {
+    header.push('property float nx', 'property float ny', 'property float nz');
+  } // uvs
+
+
+  if (withUVs) {
+    header.push("property float ".concat(textureCoordinatesName[0]), "property float ".concat(textureCoordinatesName[1]));
+  } // colors
+
+
+  if (withColors) {
+    header.push('property uchar red', 'property uchar green', 'property uchar blue');
+  } // faces
+
+
+  if (withIndices) {
+    header.push("element face ".concat(faceListLength), 'property list uchar int vertex_indices');
+  }
+
+  header.push('end_header\n');
+  return header.join('\n');
+};
+
+var binaryWriter = function binaryWriter() {
+  var output;
+  var vOffset;
+  var fOffset;
+  var indexByteCount = 4;
+  var ft;
+  return {
+    init: function init(polyData) {},
+    writeHeader: function writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, numPts, numPolys, withNormals, withUVs, withColors, withIndices) {
+      var vertexCount = polyData.getPoints().getNumberOfPoints();
+      ft = fileType; // 1 byte shape descriptor
+      // 3 vertex indices at ${indexByteCount} bytes
+
+      var faceListLength = withIndices ? numPolys * (indexByteCount * 3 + 1) : 0; // 3 position values at 4 bytes
+      // 3 normal values at 4 bytes
+      // 3 color channels with 1 byte
+      // 2 uv values at 4 bytes
+
+      var vertexListLength = vertexCount * (4 * 3 + (withNormals ? 4 * 3 : 0) + (withUVs ? 4 * 2 : 0) + (withColors ? 3 : 0));
+
+      var header = _writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, numPts, numPolys, withNormals, withUVs, withColors, withIndices);
+
+      var headerBin = new TextEncoder().encode(header);
+      output = new DataView(new ArrayBuffer(headerBin.length + vertexListLength + faceListLength));
+      new Uint8Array(output.buffer).set(headerBin, 0);
+      vOffset = headerBin.length;
+      fOffset = vOffset + vertexListLength;
+    },
+    writeVertice: function writeVertice(x, y, z, nx, ny, nz, u, v, r, g, b) {
+      // xyz
+      output.setFloat32(vOffset, x, ft);
+      vOffset += 4;
+      output.setFloat32(vOffset, y, ft);
+      vOffset += 4;
+      output.setFloat32(vOffset, z, ft);
+      vOffset += 4; // nxnynz
+
+      if (nx !== null && ny !== null && nz !== null) {
+        output.setFloat32(vOffset, nx, ft);
+        vOffset += 4;
+        output.setFloat32(vOffset, ny, ft);
+        vOffset += 4;
+        output.setFloat32(vOffset, nz, ft);
+        vOffset += 4;
+      } // uv
+
+
+      if (u !== null && v !== null) {
+        output.setFloat32(vOffset, u, ft);
+        vOffset += 4;
+        output.setFloat32(vOffset, v, ft);
+        vOffset += 4;
+      } // rgb
+
+
+      if (r !== null && g !== null && b !== null) {
+        output.setUint8(vOffset, r);
+        vOffset += 1;
+        output.setUint8(vOffset, g);
+        vOffset += 1;
+        output.setUint8(vOffset, b);
+        vOffset += 1;
+      }
+    },
+    writeFace: function writeFace(n, x, y, z) {
+      output.setUint8(fOffset, n);
+      fOffset += 1;
+      output.setUint32(fOffset, x, ft);
+      fOffset += indexByteCount;
+      output.setUint32(fOffset, y, ft);
+      fOffset += indexByteCount;
+      output.setUint32(fOffset, z, ft);
+      fOffset += indexByteCount;
+    },
+    writeFooter: function writeFooter(polyData) {},
+    getOutputData: function getOutputData() {
+      return output;
+    }
+  };
+};
+
+var asciiWriter = function asciiWriter() {
+  var fileContent = '';
+  return {
+    init: function init(polyData) {},
+    writeHeader: function writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, numPts, numPolys, withNormals, withUVs, withColors, withIndices) {
+      fileContent += _writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, numPts, numPolys, withNormals, withUVs, withColors, withIndices);
+    },
+    writeVertice: function writeVertice(x, y, z, nx, ny, nz, u, v, r, g, b) {
+      fileContent += "".concat(x, " ").concat(y, " ").concat(z);
+
+      if (nx !== null && ny !== null && nz !== null) {
+        fileContent += " ".concat(nx, " ").concat(ny, " ").concat(nz);
+      }
+
+      if (u !== null && v !== null) {
+        fileContent += " ".concat(u, " ").concat(v);
+      }
+
+      if (r !== null && g !== null && b !== null) {
+        fileContent += " ".concat(r, " ").concat(g, " ").concat(b);
+      }
+
+      fileContent += '\n';
+    },
+    writeFace: function writeFace(n, x, y, z) {
+      fileContent += "".concat(n, " ").concat(x, " ").concat(y, " ").concat(z, "\n");
+    },
+    writeFooter: function writeFooter(polyData) {},
+    getOutputData: function getOutputData() {
+      return fileContent;
+    }
+  };
+};
+
+/**
+ * 将polyData转换为ply文件
+ * @param {vtkPolyData} polyData 需要导出的polydata
+ * @param {'ascii' | 'binary'} format 导出文件格式
+ * @param {0 | 1} dataByteOrder=0 字节序,默认为0, 0为大端模式， 1小端模式
+ * @param {string[]} headerComments=[] 文件头描述
+ * @param {string} textureFileName='' header描述文件名 
+ * @param {['u', 'v']} textureCoordinatesName=['u', 'v'] header添加u和v
+ * @param {boolean} withNormals=false 是否需要法向量
+ * @param {boolean} withUVs=false 是否需要UV
+ * @param {boolean} withColors=false 是否需要Colors
+ * @param {boolean} withColors=true 面使用点索引
+ * @returns {string | DataView} 返回文件内容
+ */
+export function writePLY(polyData, format, dataByteOrder = DEFAULT_VALUES.dataByteOrder, headerComments = DEFAULT_VALUES.headerComments, textureFileName = DEFAULT_VALUES.textureFileName, textureCoordinatesName = DEFAULT_VALUES.textureCoordinatesName, withNormals = DEFAULT_VALUES.withNormals, withUVs = DEFAULT_VALUES.withUVs, withColors = DEFAULT_VALUES.withColors, withIndices = DEFAULT_VALUES.withIndices) {
+  var inPts = polyData.getPoints();
+  var polys = polyData.getPolys();
+
+  if (inPts === null || polys === null) {
+    console.error('输入错误！')
+  }
+
+  var writer = null;
+
+  if (format === 'binary') {
+    writer = binaryWriter();
+  } else if (format === 'ascii') {
+    writer = asciiWriter();
+  } else {
+    console.error('Invalid type format');
+  }
+
+  var tCoordsName = textureCoordinatesName;
+
+  if (typeof textureCoordinatesName === 'undefined') {
+    console.log('Invalid TextureCoordinatesName value, fallback to default uv values');
+    tCoordsName = TextureCoordinatesName.UV;
+  }
+
+  writer.init(polyData);
+  var numPts = inPts.getNumberOfPoints();
+  var numPolys = polys.getNumberOfCells(); // textureCoords / uvs
+
+  var textureCoords = polyData.getPointData().getTCoords(); // eslint-disable-next-line no-param-reassign
+
+  // withUVs = !(textureCoords === null); // scalars / colors
+
+  var scalars = polyData.getPointData().getScalars(); // eslint-disable-next-line no-param-reassign
+
+  withColors = !(scalars === null);
+  var fileType = dataByteOrder ? 0 : 1;
+  writer.writeHeader(polyData, format, fileType, headerComments, textureFileName, tCoordsName, numPts, numPolys, withNormals, withUVs, withColors, withIndices);
+  var normals = polyData.getPointData().getNormals(); // points / vertices
+
+  for (var i = 0; i < numPts; i++) {
+    // eslint-disable-next-line prefer-const
+    var p = inPts.getPoint(i); 
+    // divide by 1 to remove trailing zeros
+
+
+    var x = p[0].toFixed(8);
+    var y = p[1].toFixed(8);
+    var z = p[2].toFixed(8); // normals
+
+    var nx = null;
+    var ny = null;
+    var nz = null; // uvs
+
+    var u = null;
+    var v = null; // colors
+
+    var r = null;
+    var g = null;
+    var b = null;
+
+    // if (textureCoords) {
+    //   u = textureCoords.getData()[i * 2];
+    //   v = textureCoords.getData()[i * 2 + 1];
+    // }
+
+    if (scalars) {
+      r = scalars.getData()[i * 3];
+      g = scalars.getData()[i * 3 + 1];
+      b = scalars.getData()[i * 3 + 2];
+    }
+
+    if (normals) {
+      nx = normals.getData()[i * 2];
+      ny = normals.getData()[i * 2 + 1];
+      nz = normals.getData()[i * 2 + 2];
+    }
+
+    writer.writeVertice(x, y, z, nx, ny, nz, u, v, r, g, b);
+  } // polys / indices
+
+
+  var pd = polys.getData();
+
+  for (var _i = 0, l = pd.length; _i < l; _i += 4) {
+    writer.writeFace(pd[_i + 0], pd[_i + 1], pd[_i + 2], pd[_i + 3]);
+  }
+
+  writer.writeFooter(polyData);
+  return writer.getOutputData();
+}