@kitware/vtk.js 28.10.2 → 28.11.1

package/Filters/Texture/TextureMapToPlane.js

@@ -1,62 +1,63 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { l as normalize, d as dot, j as cross, e as distance2BetweenPoints, y as determinant3x3, z as rowsToMat3 } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkTextureMapToPlane methods
 // ----------------------------------------------------------------------------
 
 function vtkTextureMapToPlane(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkTextureMapToPlane');
-
   function computeNormal(output) {
-    var VTK_TOLERANCE = 0.001; //  First thing to do is to get an initial normal and point to define
+    const VTK_TOLERANCE = 0.001;
+    //  First thing to do is to get an initial normal and point to define
     //  the plane.  Then, use this information to construct better
     //  matrices.  If problem occurs, then the point and plane becomes the
     //  fallback value
 
-    var nbPoints = output.getPoints().getNumberOfPoints();
-    var dir = 0;
-    var m = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-    var x = [0, 0, 0];
-    var v = [0, 0, 0]; //  Get minimum width of bounding box.
-
-    var bounds = output.getBounds();
-    var minBounds = [bounds[0], bounds[2], bounds[4]];
-    var maxBounds = [bounds[1], bounds[3], bounds[5]];
-    var length = Math.sqrt(distance2BetweenPoints(minBounds, maxBounds));
-    var w = length;
-    var i = 0;
-
+    const nbPoints = output.getPoints().getNumberOfPoints();
+    let dir = 0;
+    let m = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const x = [0, 0, 0];
+    const v = [0, 0, 0];
+
+    //  Get minimum width of bounding box.
+    const bounds = output.getBounds();
+    const minBounds = [bounds[0], bounds[2], bounds[4]];
+    const maxBounds = [bounds[1], bounds[3], bounds[5]];
+    const length = Math.sqrt(distance2BetweenPoints(minBounds, maxBounds));
+    let w = length;
+    let i = 0;
     for (; i < 3; i++) {
       model.normal[i] = 0.0;
-
       if (bounds[2 * i + 1] - bounds[2 * i] < w) {
         dir = i;
         w = bounds[2 * i + 1] - bounds[2 * i];
       }
-    } //  If the bounds is perpendicular to one of the axes, then can
+    }
+
+    //  If the bounds is perpendicular to one of the axes, then can
     //  quickly compute normal.
     //
-
-
     model.normal[dir] = 1.0;
-
     if (w <= length * VTK_TOLERANCE) {
       return;
-    } //  Need to compute least squares approximation.  Depending on major
+    }
+
+    //  Need to compute least squares approximation.  Depending on major
     //  normal direction (dir), construct matrices appropriately.
     //
     //  Compute 3x3 least squares matrix
-
-
     v[0] = 0.0;
     v[1] = 0.0;
     v[2] = 0.0;
-
-    for (var ptId = 0; ptId < nbPoints; ptId++) {
+    for (let ptId = 0; ptId < nbPoints; ptId++) {
       output.getPoints().getPoint(ptId, x);
       v[0] += x[0] * x[2];
       v[1] += x[1] * x[2];
@@ -70,169 +71,159 @@ function vtkTextureMapToPlane(publicAPI, model) {
       m[6] += x[0];
       m[7] += x[1];
     }
+    m[8] = nbPoints;
 
-    m[8] = nbPoints; //  Solve linear system using Kramers rule
-
-    var c1 = [m[0], m[1], m[2]];
-    var c2 = [m[3], m[4], m[5]];
-    var c3 = [m[6], m[7], m[8]];
-    var det = determinant3x3(m);
+    //  Solve linear system using Kramers rule
 
+    const c1 = [m[0], m[1], m[2]];
+    const c2 = [m[3], m[4], m[5]];
+    const c3 = [m[6], m[7], m[8]];
+    const det = determinant3x3(m);
     if (det <= VTK_TOLERANCE) {
       return;
     }
-
     m = rowsToMat3(v, c2, c3, []);
     model.normal[0] = determinant3x3(m) / det;
     m = rowsToMat3(c1, v, c3, []);
-    model.normal[1] = determinant3x3(m) / det; // because of the formulation
-
+    model.normal[1] = determinant3x3(m) / det;
+    // because of the formulation
     model.normal[2] = -1.0;
   }
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var input = inData[0];
-    var nbPoints = input.getPoints().getNumberOfPoints();
-
+    const input = inData[0];
+    const nbPoints = input.getPoints().getNumberOfPoints();
     if (nbPoints < 3 && model.automaticPlaneGeneration) {
       vtkErrorMacro("Can't generate texture coordinates without points");
       return;
     }
-
-    var output = vtkPolyData.newInstance();
+    const output = vtkPolyData.newInstance();
     output.getPoints().setData(new Float32Array(input.getPoints().getData()), 3);
     output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
-    var tcoordsData = [];
-    var minProj = 0;
-    var i = 0;
-    var j = 0;
-    var proj = 0;
-    var axis = [0, 0, 0];
-    var dir = 0;
-    var tAxis = [0, 0, 0];
-    var sAxis = [0, 0, 0];
-    var s = 0;
-    var t = 0;
-    var sSf = 0;
-    var tSf = 0;
-    var p = [0, 0, 0]; //  Compute least squares plane if on automatic mode; otherwise use
+    const tcoordsData = [];
+    let minProj = 0;
+    let i = 0;
+    let j = 0;
+    let proj = 0;
+    const axis = [0, 0, 0];
+    let dir = 0;
+    const tAxis = [0, 0, 0];
+    const sAxis = [0, 0, 0];
+    let s = 0;
+    let t = 0;
+    let sSf = 0;
+    let tSf = 0;
+    const p = [0, 0, 0];
+
+    //  Compute least squares plane if on automatic mode; otherwise use
     //  normal specified or plane specified
-
     if (model.automaticPlaneGeneration && model.origin[0] === 0 && model.origin[1] === 0 && model.origin[2] === 0 && model.point1[0] === 0 && model.point1[1] === 0 && model.point2[0] === 0 && model.point2[1] === 0) {
       if (model.automaticPlaneGeneration) {
         computeNormal(output);
       }
+      normalize(model.normal);
 
-      normalize(model.normal); //  Now project each point onto plane generating s,t texture coordinates
+      //  Now project each point onto plane generating s,t texture coordinates
       //
       //  Create local s-t coordinate system.  Need to find the two axes on
       //  the plane and encompassing all the points.  Hence use the bounding
       //  box as a reference.
-
       minProj = 1.0;
       i = 0;
-
       for (; i < 3; i++) {
         axis[0] = 0.0;
         axis[1] = 0.0;
         axis[2] = 0.0;
         axis[i] = 1.0;
         proj = Math.abs(dot(model.normal, axis));
-
         if (proj < minProj) {
           minProj = proj;
           dir = i;
         }
       }
-
       axis[0] = 0.0;
       axis[1] = 0.0;
       axis[2] = 0.0;
       axis[dir] = 1.0;
       cross(model.normal, axis, tAxis);
       normalize(tAxis);
-      cross(tAxis, model.normal, sAxis); //  Construct projection matrices
+      cross(tAxis, model.normal, sAxis);
+
+      //  Construct projection matrices
       //
       //  Arrange s-t axes so that parametric location of points will fall
       //  between s_range and t_range.  Simplest to do by projecting maximum
       //  corner of bounding box unto plane and backing out scale factors.
       //
-
-      var bounds = output.getBounds();
-
+      const bounds = output.getBounds();
       for (i = 0; i < 3; i++) {
         axis[i] = bounds[2 * i + 1] - bounds[2 * i];
       }
-
       s = dot(sAxis, axis);
       t = dot(tAxis, axis);
       sSf = (model.sRange[1] - model.sRange[0]) / s;
-      tSf = (model.tRange[1] - model.tRange[0]) / t; //  Now can loop over all points, computing parametric coordinates.
-
+      tSf = (model.tRange[1] - model.tRange[0]) / t;
+      //  Now can loop over all points, computing parametric coordinates.
       for (i = 0; i < nbPoints; i++) {
         output.getPoints().getPoint(i, p);
-
         for (j = 0; j < 3; j++) {
           axis[j] = p[j] - bounds[2 * j];
         }
-
         tcoordsData.push(model.sRange[0] + dot(sAxis, axis) * sSf);
         tcoordsData.push(model.tRange[0] + dot(tAxis, axis) * tSf);
       }
     } else {
-      var num = 0; // compute axes
+      let num = 0;
 
+      // compute axes
       for (i = 0; i < 3; i++) {
         sAxis[i] = model.point1[i] - model.origin[i];
         tAxis[i] = model.point2[i] - model.origin[i];
       }
-
-      var sDenom = dot(sAxis, sAxis);
-      var tDenom = dot(tAxis, tAxis);
-
+      let sDenom = dot(sAxis, sAxis);
+      let tDenom = dot(tAxis, tAxis);
       if (sDenom === 0.0 || tDenom === 0.0) {
         vtkErrorMacro('Bad plane definition');
         sDenom = 1.0;
         tDenom = 1.0;
-      } // compute s-t coordinates
-
+      }
 
+      // compute s-t coordinates
       for (i = 0; i < nbPoints; i++) {
         output.getPoints().getPoint(i, p);
-
         for (j = 0; j < 3; j++) {
           axis[j] = p[j] - model.origin[j];
-        } // s-coordinate
-
+        }
 
+        // s-coordinate
         num = sAxis[0] * axis[0] + sAxis[1] * axis[1] + sAxis[2] * axis[2];
-        tcoordsData.push(num / sDenom); // t-coordinate
+        tcoordsData.push(num / sDenom);
 
+        // t-coordinate
         num = tAxis[0] * axis[0] + tAxis[1] * axis[1] + tAxis[2] * axis[2];
         tcoordsData.push(num / tDenom);
       }
     }
-
-    var tCoords = vtkDataArray.newInstance({
+    const tCoords = vtkDataArray.newInstance({
       name: 'Texture Coordinates',
       numberOfComponents: 2,
       size: nbPoints,
       values: tcoordsData
     });
-    output.getPointData().setTCoords(tCoords); // Update output
+    output.getPointData().setTCoords(tCoords);
 
+    // Update output
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   origin: [0, 0, 0],
   point1: [0, 0, 0],
   point2: [0, 0, 0],
@@ -240,25 +231,32 @@ var DEFAULT_VALUES = {
   sRange: [0, 1],
   tRange: [0, 1],
   automaticPlaneGeneration: 1
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.setGetArray(publicAPI, model, ['origin', 'point1', 'point2', 'normal'], 3);
   macro.setGetArray(publicAPI, model, ['sRange', 'tRange'], 2);
   macro.setGet(publicAPI, model, ['automaticPlaneGeneration']);
   macro.algo(publicAPI, model, 1, 1);
   vtkTextureMapToPlane(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTextureMapToPlane');
 
-var newInstance = macro.newInstance(extend, 'vtkTextureMapToPlane'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkTextureMapToPlane$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkTextureMapToPlane$1 as default, extend, newInstance };

package/Filters/Texture/TextureMapToSphere.js

@@ -1,67 +1,59 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkTextureMapToSphere methods
 // ----------------------------------------------------------------------------
 
 function vtkTextureMapToSphere(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkTextureMapToSphere');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var input = inData[0];
-    var nbPoints = input.getPoints().getNumberOfPoints();
-
+    const input = inData[0];
+    const nbPoints = input.getPoints().getNumberOfPoints();
     if (nbPoints <= 1) {
       vtkErrorMacro("Can't generate texture coordinates without points");
       return;
     }
-
-    var piOverTwo = Math.PI / 2;
-    var x = [];
-    var points = input.getPoints();
-
+    const piOverTwo = Math.PI / 2;
+    const x = [];
+    const points = input.getPoints();
     if (model.automaticSphereGeneration) {
       model.center = [0, 0, 0];
-
-      for (var i = 0; i < nbPoints; i++) {
+      for (let i = 0; i < nbPoints; i++) {
         points.getPoint(i, x);
         model.center[0] += x[0];
         model.center[1] += x[1];
         model.center[2] += x[2];
       }
-
       model.center[0] /= nbPoints;
       model.center[1] /= nbPoints;
       model.center[2] /= nbPoints;
     }
-
-    var rho = 0;
-    var diff = 0;
-    var phi = 0;
-    var tc = [0, 0];
-    var r = 0;
-    var thetaX = 0;
-    var thetaY = 0;
-    var tcoordsData = [];
-
-    for (var _i = 0; _i < nbPoints; _i++) {
-      points.getPoint(_i, x);
+    let rho = 0;
+    let diff = 0;
+    let phi = 0;
+    const tc = [0, 0];
+    let r = 0;
+    let thetaX = 0;
+    let thetaY = 0;
+    const tcoordsData = [];
+    for (let i = 0; i < nbPoints; i++) {
+      points.getPoint(i, x);
       rho = Math.sqrt(distance2BetweenPoints(x, model.center));
-
       if (rho !== 0) {
         diff = x[2] - model.center[2];
-
         if (Math.abs(diff) > rho) {
           phi = 0;
-
           if (diff > 0) {
             tc[1] = 0;
           } else {
@@ -74,12 +66,9 @@ function vtkTextureMapToSphere(publicAPI, model) {
       } else {
         tc[1] = 0;
       }
-
       r = rho * Math.sin(phi);
-
       if (r !== 0) {
         diff = x[0] - model.center[0];
-
         if (Math.abs(diff) > r) {
           if (diff > 0) {
             thetaX = 0;
@@ -89,9 +78,7 @@ function vtkTextureMapToSphere(publicAPI, model) {
         } else {
           thetaX = Math.acos(diff / r);
         }
-
         diff = x[1] - model.center[1];
-
         if (Math.abs(diff) > r) {
           if (diff > 0) {
             thetaY = piOverTwo;
@@ -105,60 +92,65 @@ function vtkTextureMapToSphere(publicAPI, model) {
         thetaX = 0;
         thetaY = 0;
       }
-
       if (model.preventSeam) {
         tc[0] = thetaX / Math.PI;
       } else {
         tc[0] = thetaX / (2 * Math.PI);
-
         if (thetaY < 0) {
           tc[0] = 1 - tc[0];
         }
       }
-
-      tcoordsData.push.apply(tcoordsData, tc);
+      tcoordsData.push(...tc);
     }
-
-    var tCoords = vtkDataArray.newInstance({
+    const tCoords = vtkDataArray.newInstance({
       name: 'Texture Coordinates',
       numberOfComponents: 2,
       size: nbPoints,
       values: tcoordsData
     });
-    var output = vtkPolyData.newInstance();
+    const output = vtkPolyData.newInstance();
     output.getPoints().setData(new Float32Array(input.getPoints().getData()), 3);
     output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
-    output.getPointData().setTCoords(tCoords); // Update output
+    output.getPointData().setTCoords(tCoords);
 
+    // Update output
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   center: [0, 0, 0],
   automaticSphereGeneration: 1,
   preventSeam: 1
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.setGetArray(publicAPI, model, ['center'], 3);
   macro.setGet(publicAPI, model, ['automaticSphereGeneration', 'preventSeam']);
   macro.algo(publicAPI, model, 1, 1);
   vtkTextureMapToSphere(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkTextureMapToSphere'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTextureMapToSphere');
+
+// ----------------------------------------------------------------------------
 
 var vtkTextureMapToSphere$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkTextureMapToSphere$1 as default, extend, newInstance };

package/Filters/Texture.js

@@ -2,8 +2,8 @@ import vtkTextureMapToSphere from './Texture/TextureMapToSphere.js';
 import vtkTextureMapToPlane from './Texture/TextureMapToPlane.js';
 
 var Texture = {
-  vtkTextureMapToPlane: vtkTextureMapToPlane,
-  vtkTextureMapToSphere: vtkTextureMapToSphere
+  vtkTextureMapToPlane,
+  vtkTextureMapToSphere
 };
 
 export { Texture as default };

package/Filters/index.js

@@ -5,11 +5,11 @@ import Sources from './Sources.js';
 import Texture from './Texture.js';
 
 var Filters = {
-  Cornerstone: Cornerstone,
-  Core: Core,
-  General: General,
-  Sources: Sources,
-  Texture: Texture
+  Cornerstone,
+  Core,
+  General,
+  Sources,
+  Texture
 };
 
 export { Filters as default };

package/IO/Core/BinaryHelper.js

@@ -5,32 +5,28 @@
  * expect proper Unicode or any other encoding.
  */
 function arrayBufferToString(arrayBuffer) {
-  var decoder = new TextDecoder('latin1');
+  const decoder = new TextDecoder('latin1');
   return decoder.decode(arrayBuffer);
 }
+
 /**
  * Extracts binary data out of a file ArrayBuffer given a prefix/suffix.
  */
-
-
 function extractBinary(arrayBuffer, prefixRegex) {
-  var suffixRegex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-  var str = arrayBufferToString(arrayBuffer);
-  var prefixMatch = prefixRegex.exec(str);
-
+  let suffixRegex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  const str = arrayBufferToString(arrayBuffer);
+  const prefixMatch = prefixRegex.exec(str);
   if (!prefixMatch) {
     return {
       text: str
     };
   }
-
-  var dataStartIndex = prefixMatch.index + prefixMatch[0].length;
-  var strFirstHalf = str.substring(0, dataStartIndex);
-  var retVal = null;
-  var suffixMatch = suffixRegex ? suffixRegex.exec(str) : null;
-
+  const dataStartIndex = prefixMatch.index + prefixMatch[0].length;
+  const strFirstHalf = str.substring(0, dataStartIndex);
+  let retVal = null;
+  const suffixMatch = suffixRegex ? suffixRegex.exec(str) : null;
   if (suffixMatch) {
-    var strSecondHalf = str.substr(suffixMatch.index);
+    const strSecondHalf = str.substr(suffixMatch.index);
     retVal = {
       text: strFirstHalf + strSecondHalf,
       binaryBuffer: arrayBuffer.slice(dataStartIndex, suffixMatch.index)
@@ -42,13 +38,11 @@ function extractBinary(arrayBuffer, prefixRegex) {
       binaryBuffer: arrayBuffer.slice(dataStartIndex)
     };
   }
-
   return retVal;
 }
-
 var BinaryHelper = {
-  arrayBufferToString: arrayBufferToString,
-  extractBinary: extractBinary
+  arrayBufferToString,
+  extractBinary
 };
 
 export { BinaryHelper as default };