@kitware/vtk.js 28.10.2 → 28.11.1

package/IO/Geometry/STLReader.js

@@ -1,6 +1,6 @@
 import BinaryHelper from '../Core/BinaryHelper.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
@@ -10,189 +10,172 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-
+const {
+  vtkErrorMacro
+} = macro;
 function parseHeader(headerString) {
-  var headerSubStr = headerString.split(' ');
-  var fieldValues = headerSubStr.filter(function (e) {
-    return e.indexOf('=') > -1;
-  });
-  var header = {};
-
-  for (var i = 0; i < fieldValues.length; ++i) {
-    var fieldValueStr = fieldValues[i];
-    var fieldValueSubStr = fieldValueStr.split('=');
-
+  const headerSubStr = headerString.split(' ');
+  const fieldValues = headerSubStr.filter(e => e.indexOf('=') > -1);
+  const header = {};
+  for (let i = 0; i < fieldValues.length; ++i) {
+    const fieldValueStr = fieldValues[i];
+    const fieldValueSubStr = fieldValueStr.split('=');
     if (fieldValueSubStr.length === 2) {
       header[fieldValueSubStr[0]] = fieldValueSubStr[1];
     }
   }
-
   return header;
 }
-
 function addValuesToArray(src, dst) {
-  for (var i = 0; i < src.length; i++) {
+  for (let i = 0; i < src.length; i++) {
     dst.push(src[i]);
   }
-} // facet normal ni nj nk
+}
+
+// facet normal ni nj nk
 //     outer loop
 //         vertex v1x v1y v1z
 //         vertex v2x v2y v2z
 //         vertex v3x v3y v3z
 //     endloop
 // endfacet
-
-
 function readTriangle(lines, offset, points, cellArray, cellNormals) {
-  var normalLine = lines[offset];
-
+  const normalLine = lines[offset];
   if (normalLine === undefined) {
     return -1;
   }
-
   if (normalLine.indexOf('endfacet') !== -1) {
     return offset + 1;
   }
-
   if (normalLine.indexOf('facet') === -1) {
     return offset + 1; // Move to next line
   }
 
-  var nbVertex = 0;
-  var nbConsumedLines = 2;
-  var firstVertexIndex = points.length / 3;
-  var normal = normalLine.split(/[ \t]+/).filter(function (i) {
-    return i;
-  }).slice(-3).map(Number);
+  let nbVertex = 0;
+  let nbConsumedLines = 2;
+  const firstVertexIndex = points.length / 3;
+  const normal = normalLine.split(/[ \t]+/).filter(i => i).slice(-3).map(Number);
   addValuesToArray(normal, cellNormals);
-
   while (lines[offset + nbConsumedLines].indexOf('vertex') !== -1) {
-    var line = lines[offset + nbConsumedLines];
-    var coords = line.split(/[ \t]+/).filter(function (i) {
-      return i;
-    }).slice(-3).map(Number);
+    const line = lines[offset + nbConsumedLines];
+    const coords = line.split(/[ \t]+/).filter(i => i).slice(-3).map(Number);
     addValuesToArray(coords, points);
     nbVertex++;
     nbConsumedLines++;
   }
-
   cellArray.push(nbVertex);
-
-  for (var i = 0; i < nbVertex; i++) {
+  for (let i = 0; i < nbVertex; i++) {
     cellArray.push(firstVertexIndex + i);
   }
-
   while (lines[offset + nbConsumedLines] && lines[offset + nbConsumedLines].indexOf('endfacet') !== -1) {
     nbConsumedLines++;
-  } // +1 (endfacet) +1 (next facet)
-
-
+  }
+  // +1 (endfacet) +1 (next facet)
   return offset + nbConsumedLines + 2;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkSTLReader methods
 // ----------------------------------------------------------------------------
 
-
 function vtkSTLReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSTLReader'); // Create default dataAccessHelper if not available
+  model.classHierarchy.push('vtkSTLReader');
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = DataAccessHelper.get('http');
-  } // Internal method to fetch Array
-
+  }
 
+  // Internal method to fetch Array
   function fetchData(url) {
-    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var compression = option.compression !== undefined ? option.compression : model.compression;
-    var progressCallback = option.progressCallback !== undefined ? option.progressCallback : model.progressCallback;
-
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const compression = option.compression !== undefined ? option.compression : model.compression;
+    const progressCallback = option.progressCallback !== undefined ? option.progressCallback : model.progressCallback;
     if (option.binary) {
       return model.dataAccessHelper.fetchBinary(url, {
-        compression: compression,
-        progressCallback: progressCallback
+        compression,
+        progressCallback
       });
     }
-
     return model.dataAccessHelper.fetchText(publicAPI, url, {
-      compression: compression,
-      progressCallback: progressCallback
+      compression,
+      progressCallback
     });
-  } // Set DataSet url
-
+  }
 
+  // Set DataSet url
   publicAPI.setUrl = function (url) {
-    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
       binary: true
     };
-    model.url = url; // Remove the file in the URL
+    model.url = url;
 
-    var path = url.split('/');
+    // Remove the file in the URL
+    const path = url.split('/');
     path.pop();
-    model.baseURL = path.join('/'); // Fetch metadata
+    model.baseURL = path.join('/');
 
+    // Fetch metadata
     return publicAPI.loadData(option);
-  }; // Fetch the actual data arrays
-
+  };
 
+  // Fetch the actual data arrays
   publicAPI.loadData = function () {
-    var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var promise = fetchData(model.url, option);
+    let option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const promise = fetchData(model.url, option);
     promise.then(publicAPI.parse);
     return promise;
   };
-
-  publicAPI.parse = function (content) {
+  publicAPI.parse = content => {
     if (typeof content === 'string') {
       publicAPI.parseAsText(content);
     } else {
       publicAPI.parseAsArrayBuffer(content);
     }
   };
-
-  publicAPI.parseAsArrayBuffer = function (content) {
+  publicAPI.parseAsArrayBuffer = content => {
     if (!content) {
       return;
     }
-
     if (content !== model.parseData) {
       publicAPI.modified();
     } else {
       return;
     }
+    model.parseData = content;
 
-    model.parseData = content; // ascii/binary detection
-
-    var isBinary = false; // 80=STL header, 4=uint32 of num of triangles (le)
-
-    var dview = new DataView(content, 0, 80 + 4);
-    var numTriangles = dview.getUint32(80, true); // 50 bytes per triangle
-
-    isBinary = 84 + numTriangles * 50 === content.byteLength; // Check if ascii format
+    // ascii/binary detection
+    let isBinary = false;
+    // 80=STL header, 4=uint32 of num of triangles (le)
+    const dview = new DataView(content, 0, 80 + 4);
+    const numTriangles = dview.getUint32(80, true);
+    // 50 bytes per triangle
+    isBinary = 84 + numTriangles * 50 === content.byteLength;
 
+    // Check if ascii format
     if (!isBinary) {
       publicAPI.parseAsText(BinaryHelper.arrayBufferToString(content));
       return;
-    } // Binary parsing
-    // Header
-
-
-    var headerData = content.slice(0, 80);
-    var headerStr = BinaryHelper.arrayBufferToString(headerData);
-    var header = parseHeader(headerStr); // Data
-
-    var dataView = new DataView(content, 84); // global.dataview = dataView;
-
-    var nbFaces = (content.byteLength - 84) / 50;
-    var pointValues = new Float32Array(nbFaces * 9);
-    var normalValues = new Float32Array(nbFaces * 3);
-    var cellValues = new Uint32Array(nbFaces * 4);
-    var cellDataValues = new Uint16Array(nbFaces);
-    var cellOffset = 0;
+    }
 
-    for (var faceIdx = 0; faceIdx < nbFaces; faceIdx++) {
-      var offset = faceIdx * 50;
+    // Binary parsing
+    // Header
+    const headerData = content.slice(0, 80);
+    const headerStr = BinaryHelper.arrayBufferToString(headerData);
+    const header = parseHeader(headerStr);
+
+    // Data
+    const dataView = new DataView(content, 84);
+    // global.dataview = dataView;
+    const nbFaces = (content.byteLength - 84) / 50;
+    const pointValues = new Float32Array(nbFaces * 9);
+    const normalValues = new Float32Array(nbFaces * 3);
+    const cellValues = new Uint32Array(nbFaces * 4);
+    const cellDataValues = new Uint16Array(nbFaces);
+    let cellOffset = 0;
+    for (let faceIdx = 0; faceIdx < nbFaces; faceIdx++) {
+      const offset = faceIdx * 50;
       normalValues[faceIdx * 3 + 0] = dataView.getFloat32(offset + 0, true);
       normalValues[faceIdx * 3 + 1] = dataView.getFloat32(offset + 4, true);
       normalValues[faceIdx * 3 + 2] = dataView.getFloat32(offset + 8, true);
@@ -210,62 +193,50 @@ function vtkSTLReader(publicAPI, model) {
       cellValues[cellOffset++] = faceIdx * 3 + 1;
       cellValues[cellOffset++] = faceIdx * 3 + 2;
       cellDataValues[faceIdx] = dataView.getUint16(offset + 48, true);
-    } // Rotate points
-
-
-    var orientationField = 'SPACE';
+    }
 
+    // Rotate points
+    const orientationField = 'SPACE';
     if (orientationField in header && header[orientationField] !== 'LPS') {
-      var XYZ = header[orientationField];
-      var mat4 = new Float32Array(16);
+      const XYZ = header[orientationField];
+      const mat4 = new Float32Array(16);
       mat4[15] = 1;
-
       switch (XYZ[0]) {
         case 'L':
           mat4[0] = 1;
           break;
-
         case 'R':
           mat4[0] = -1;
           break;
-
         default:
-          vtkErrorMacro("Can not convert STL file from ".concat(XYZ, " to LPS space: ") + "permutations not supported. Use itk.js STL reader instead.");
+          vtkErrorMacro(`Can not convert STL file from ${XYZ} to LPS space: ` + `permutations not supported. Use itk.js STL reader instead.`);
           return;
       }
-
       switch (XYZ[1]) {
         case 'P':
           mat4[5] = 1;
           break;
-
         case 'A':
           mat4[5] = -1;
           break;
-
         default:
-          vtkErrorMacro("Can not convert STL file from ".concat(XYZ, " to LPS space: ") + "permutations not supported. Use itk.js STL reader instead.");
+          vtkErrorMacro(`Can not convert STL file from ${XYZ} to LPS space: ` + `permutations not supported. Use itk.js STL reader instead.`);
           return;
       }
-
       switch (XYZ[2]) {
         case 'S':
           mat4[10] = 1;
           break;
-
         case 'I':
           mat4[10] = -1;
           break;
-
         default:
-          vtkErrorMacro("Can not convert STL file from ".concat(XYZ, " to LPS space: ") + "permutations not supported. Use itk.js STL reader instead.");
+          vtkErrorMacro(`Can not convert STL file from ${XYZ} to LPS space: ` + `permutations not supported. Use itk.js STL reader instead.`);
           return;
       }
-
       vtkMatrixBuilder.buildFromDegree().setMatrix(mat4).apply(pointValues).apply(normalValues);
     }
-
-    var polydata = vtkPolyData.newInstance();
+    const polydata = vtkPolyData.newInstance();
     polydata.getPoints().setData(pointValues, 3);
     polydata.getPolys().setData(cellValues);
     polydata.getCellData().setScalars(vtkDataArray.newInstance({
@@ -276,83 +247,89 @@ function vtkSTLReader(publicAPI, model) {
       name: 'Normals',
       values: normalValues,
       numberOfComponents: 3
-    })); // Add new output
+    }));
 
+    // Add new output
     model.output[0] = polydata;
   };
-
-  publicAPI.parseAsText = function (content) {
+  publicAPI.parseAsText = content => {
     if (!content) {
       return;
     }
-
     if (content !== model.parseData) {
       publicAPI.modified();
     } else {
       return;
     }
-
     model.parseData = content;
-    var lines = content.split('\n');
-    var offset = 1;
-    var points = [];
-    var cellArray = [];
-    var cellNormals = [];
-
+    const lines = content.split('\n');
+    let offset = 1;
+    const points = [];
+    const cellArray = [];
+    const cellNormals = [];
     while (offset !== -1) {
       offset = readTriangle(lines, offset, points, cellArray, cellNormals);
     }
-
-    var polydata = vtkPolyData.newInstance();
+    const polydata = vtkPolyData.newInstance();
     polydata.getPoints().setData(Float32Array.from(points), 3);
     polydata.getPolys().setData(Uint32Array.from(cellArray));
     polydata.getCellData().setNormals(vtkDataArray.newInstance({
       name: 'Normals',
       values: Float32Array.from(cellNormals),
       numberOfComponents: 3
-    })); // Add new output
+    }));
 
+    // Add new output
     model.output[0] = polydata;
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     publicAPI.parse(model.parseData);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {// baseURL: null,
+const DEFAULT_VALUES = {
+  // baseURL: null,
   // dataAccessHelper: null,
   // url: null,
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url', 'baseURL']);
   macro.setGet(publicAPI, model, ['dataAccessHelper']);
-  macro.algo(publicAPI, model, 0, 1); // vtkSTLReader methods
+  macro.algo(publicAPI, model, 0, 1);
 
-  vtkSTLReader(publicAPI, model); // To support destructuring
+  // vtkSTLReader methods
+  vtkSTLReader(publicAPI, model);
 
+  // To support destructuring
   if (!model.compression) {
     model.compression = null;
   }
-
   if (!model.progressCallback) {
     model.progressCallback = null;
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkSTLReader'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkSTLReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkSTLReader$1 = {
-  extend: extend,
-  newInstance: newInstance
+  extend,
+  newInstance
 };
 
 export { vtkSTLReader$1 as default, extend, newInstance };

package/IO/Geometry/STLWriter/Constants.js

@@ -1,9 +1,9 @@
-var FormatTypes = {
+const FormatTypes = {
   ASCII: 'ascii',
   BINARY: 'binary'
 };
 var Constants = {
-  FormatTypes: FormatTypes
+  FormatTypes
 };
 
 export { FormatTypes, Constants as default };