@kitware/vtk.js 28.10.1 → 28.11.0

package/IO/Geometry/PLYWriter/Constants.js

@@ -1,19 +1,19 @@
-var FormatTypes = {
+const FormatTypes = {
   ASCII: 'ascii',
   BINARY: 'binary'
 };
+
 /**
  * Choose the name used for the texture coordinates.
  * (u, v) or (texture_u, texture_v)
  */
-
-var TextureCoordinatesName = {
+const TextureCoordinatesName = {
   UV: ['u', 'v'],
   TEXTURE_UV: ['texture_u', 'texture_v']
 };
 var Constants = {
-  FormatTypes: FormatTypes,
-  TextureCoordinatesName: TextureCoordinatesName
+  FormatTypes,
+  TextureCoordinatesName
 };
 
 export { FormatTypes, TextureCoordinatesName, Constants as default };

package/IO/Geometry/PLYWriter.js

@@ -1,94 +1,85 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { FormatTypes, TextureCoordinatesName } from './PLYWriter/Constants.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  vtkErrorMacro,
+  vtkWarningMacro
+} = macro;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkPLYWriter methods
 // ----------------------------------------------------------------------------
-
-var _writeHeader = function writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, vertexCount, faceListLength, withNormals, withUVs, withColors, withIndices) {
-  var isBinary = fileFormat !== FormatTypes.ASCII;
-  var format;
-
+const writeHeader = (polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, vertexCount, faceListLength, withNormals, withUVs, withColors, withIndices) => {
+  const isBinary = fileFormat !== FormatTypes.ASCII;
+  let 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));
+    headerComments.push(`TextureFile ${textureFileName}`);
   }
+  const commentElements = headerComments.map(comment => `comment ${comment}`).join('\n');
+  const header = ['ply', `format ${format} 1.0`, `${commentElements}`, `element vertex ${vertexCount}`, 'property float x', 'property float y', 'property float z'];
 
-  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
-
+  // normals
   if (withNormals) {
     header.push('property float nx', 'property float ny', 'property float nz');
-  } // uvs
-
+  }
 
+  // uvs
   if (withUVs) {
-    header.push("property float ".concat(textureCoordinatesName[0]), "property float ".concat(textureCoordinatesName[1]));
-  } // colors
-
+    header.push(`property float ${textureCoordinatesName[0]}`, `property float ${textureCoordinatesName[1]}`);
+  }
 
+  // colors
   if (withColors) {
     header.push('property uchar red', 'property uchar green', 'property uchar blue');
-  } // faces
-
+  }
 
+  // faces
   if (withIndices) {
-    header.push("element face ".concat(faceListLength), 'property list uchar int vertex_indices');
+    header.push(`element face ${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;
+const binaryWriter = () => {
+  let output;
+  let vOffset;
+  let fOffset;
+  const indexByteCount = 4;
+  let 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
+    init: polyData => {},
+    writeHeader: (polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, numPts, numPolys, withNormals, withUVs, withColors, withIndices) => {
+      const vertexCount = polyData.getPoints().getNumberOfPoints();
+      ft = fileType;
+      // 1 byte shape descriptor
       // 3 vertex indices at ${indexByteCount} bytes
+      const faceListLength = withIndices ? numPolys * (indexByteCount * 3 + 1) : 0;
 
-      var faceListLength = withIndices ? numPolys * (indexByteCount * 3 + 1) : 0; // 3 position values at 4 bytes
+      // 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);
+      const vertexListLength = vertexCount * (4 * 3 + (withNormals ? 4 * 3 : 0) + (withUVs ? 4 * 2 : 0) + (withColors ? 3 : 0));
+      const header = writeHeader(polyData, fileFormat, fileType, headerComments, textureFileName, textureCoordinatesName, numPts, numPolys, withNormals, withUVs, withColors, withIndices);
+      const 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) {
+    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
-
+      vOffset += 4;
+      // nxnynz
       if (nx !== null && ny !== null && nz !== null) {
         output.setFloat32(vOffset, nx, ft);
         vOffset += 4;
@@ -96,17 +87,15 @@ var binaryWriter = function binaryWriter() {
         vOffset += 4;
         output.setFloat32(vOffset, nz, ft);
         vOffset += 4;
-      } // uv
-
-
+      }
+      // uv
       if (u !== null && v !== null) {
         output.setFloat32(vOffset, u, ft);
         vOffset += 4;
         output.setFloat32(vOffset, v, ft);
         vOffset += 4;
-      } // rgb
-
-
+      }
+      // rgb
       if (r !== null && g !== null && b !== null) {
         output.setUint8(vOffset, r);
         vOffset += 1;
@@ -116,7 +105,7 @@ var binaryWriter = function binaryWriter() {
         vOffset += 1;
       }
     },
-    writeFace: function writeFace(n, x, y, z) {
+    writeFace: (n, x, y, z) => {
       output.setUint8(fOffset, n);
       fOffset += 1;
       output.setUint32(fOffset, x, ft);
@@ -126,57 +115,44 @@ var binaryWriter = function binaryWriter() {
       output.setUint32(fOffset, z, ft);
       fOffset += indexByteCount;
     },
-    writeFooter: function writeFooter(polyData) {},
-    getOutputData: function getOutputData() {
-      return output;
-    }
+    writeFooter: polyData => {},
+    getOutputData: () => output
   };
 };
-
-var asciiWriter = function asciiWriter() {
-  var fileContent = '';
+const asciiWriter = () => {
+  let 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);
+    init: polyData => {},
+    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);
-
+    writeVertice: (x, y, z, nx, ny, nz, u, v, r, g, b) => {
+      fileContent += `${x} ${y} ${z}`;
       if (nx !== null && ny !== null && nz !== null) {
-        fileContent += " ".concat(nx, " ").concat(ny, " ").concat(nz);
+        fileContent += ` ${nx} ${ny} ${nz}`;
       }
-
       if (u !== null && v !== null) {
-        fileContent += " ".concat(u, " ").concat(v);
+        fileContent += ` ${u} ${v}`;
       }
-
       if (r !== null && g !== null && b !== null) {
-        fileContent += " ".concat(r, " ").concat(g, " ").concat(b);
+        fileContent += ` ${r} ${g} ${b}`;
       }
-
       fileContent += '\n';
     },
-    writeFace: function writeFace(n, x, y, z) {
-      fileContent += "".concat(n, " ").concat(x, " ").concat(y, " ").concat(z, "\n");
+    writeFace: (n, x, y, z) => {
+      fileContent += `${n} ${x} ${y} ${z}\n`;
     },
-    writeFooter: function writeFooter(polyData) {},
-    getOutputData: function getOutputData() {
-      return fileContent;
-    }
+    writeFooter: polyData => {},
+    getOutputData: () => fileContent
   };
 };
-
 function writePLY(polyData, format, dataByteOrder, headerComments, textureFileName, textureCoordinatesName, transform, withNormals, withUVs, withColors, withIndices) {
-  var inPts = polyData.getPoints();
-  var polys = polyData.getPolys();
-
+  const inPts = polyData.getPoints();
+  const polys = polyData.getPolys();
   if (inPts === null || polys === null) {
     vtkErrorMacro('No data to write!');
   }
-
-  var writer = null;
-
+  let writer = null;
   if (format === FormatTypes.BINARY) {
     writer = binaryWriter();
   } else if (format === FormatTypes.ASCII) {
@@ -184,110 +160,108 @@ function writePLY(polyData, format, dataByteOrder, headerComments, textureFileNa
   } else {
     vtkErrorMacro('Invalid type format');
   }
-
-  var tCoordsName = textureCoordinatesName;
-
+  let tCoordsName = textureCoordinatesName;
   if (typeof textureCoordinatesName === 'undefined') {
     vtkWarningMacro('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
+  const numPts = inPts.getNumberOfPoints();
+  const numPolys = polys.getNumberOfCells();
 
-  withUVs = !(textureCoords === null); // scalars / colors
-
-  var scalars = polyData.getPointData().getScalars(); // eslint-disable-next-line no-param-reassign
+  // textureCoords / uvs
+  const textureCoords = polyData.getPointData().getTCoords();
+  // eslint-disable-next-line no-param-reassign
+  withUVs = !(textureCoords === null);
 
+  // scalars / colors
+  const scalars = polyData.getPointData().getScalars();
+  // eslint-disable-next-line no-param-reassign
   withColors = !(scalars === null);
-  var fileType = dataByteOrder ? 0 : 1;
+  const 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
+  const normals = polyData.getPointData().getNormals();
 
-  for (var i = 0; i < numPts; i++) {
+  // points / vertices
+  for (let i = 0; i < numPts; i++) {
     // eslint-disable-next-line prefer-const
-    var p = inPts.getPoint(i); // TODO: apply transform matrix
-    // divide by 1 to remove trailing zeros
-
-
-    var x = p[0].toPrecision(6) / 1;
-    var y = p[1].toPrecision(6) / 1;
-    var z = p[2].toPrecision(6) / 1; // 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;
+    let p = inPts.getPoint(i);
 
+    // coords
+    // divide by 1 to remove trailing zeros
+    const x = p[0].toPrecision(6) / 1;
+    const y = p[1].toPrecision(6) / 1;
+    const z = p[2].toPrecision(6) / 1;
+
+    // normals
+    let nx = null;
+    let ny = null;
+    let nz = null;
+
+    // uvs
+    let u = null;
+    let v = null;
+
+    // colors
+    let r = null;
+    let g = null;
+    let 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]);
   }
 
+  // polys / indices
+  const pd = polys.getData();
+  for (let 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();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  writePLY
+};
 
-var STATIC = {
-  writePLY: writePLY
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkPLYWriter methods
 // ----------------------------------------------------------------------------
 
 function vtkPLYWriter(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPLYWriter');
-
-  publicAPI.requestData = function (inData, outData) {
-    var input = inData[0];
-
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
     if (!input || input.getClassName() !== 'vtkPolyData') {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
     outData[0] = writePLY(input, model.format, model.dataByteOrder, model.headerComments, model.textureFileName, model.textureCoordinatesName, model.transform, model.withNormals, model.withUVs, model.withColors, model.withIndices);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   format: FormatTypes.ASCII,
   dataByteOrder: 0,
   headerComments: [],
@@ -298,26 +272,37 @@ var DEFAULT_VALUES = {
   withUVs: true,
   withColors: true,
   withIndices: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
+  // Also make it an algorithm with one input and one output
   macro.algo(publicAPI, model, 1, 1);
-  macro.setGet(publicAPI, model, ['format', 'dataByteOrder', // binary_little_endian 0 binary_big_endian 1
-  'headerComments', 'textureFileName', 'textureCoordinatesName', 'transform', 'withNormals', 'withUVs', 'withColors', 'withIndices']); // Object specific methods
+  macro.setGet(publicAPI, model, ['format', 'dataByteOrder',
+  // binary_little_endian 0 binary_big_endian 1
+  'headerComments', 'textureFileName', 'textureCoordinatesName', 'transform', 'withNormals', 'withUVs', 'withColors', 'withIndices']);
 
+  // Object specific methods
   vtkPLYWriter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkPLYWriter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkPLYWriter$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+const newInstance = macro.newInstance(extend, 'vtkPLYWriter');
+
+// ----------------------------------------------------------------------------
+
+var vtkPLYWriter$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkPLYWriter$1 as default, extend, newInstance };