@kitware/vtk.js 34.11.3 → 34.13.0

package/Filters/Core/CleanPolyData.js

@@ -0,0 +1,399 @@
+import { m as macro } from '../../macros2.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkMergePoints from '../../Common/DataModel/MergePoints.js';
+import vtkPointLocator from '../../Common/DataModel/PointLocator.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+
+// ----------------------------------------------------------------------------
+// vtkCleanPolyData methods
+// ----------------------------------------------------------------------------
+
+function vtkCleanPolyData(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkCleanPolyData');
+  const tempX = [];
+
+  // Point processing
+  function processPoint(ptId, inPts, newPts, inputPD, outputPD, pointMap, numUsedPts) {
+    const newX = [0, 0, 0];
+    inPts.getPoint(ptId, tempX);
+    publicAPI.operateOnPoint(tempX, newX);
+    if (!model.pointMerging) {
+      if (pointMap[ptId] === -1) {
+        pointMap[ptId] = numUsedPts.value++;
+        newPts.setPoint(pointMap[ptId], newX);
+        outputPD.passData(inputPD, ptId, pointMap[ptId]);
+      }
+      return pointMap[ptId];
+    }
+    const newPtId = model._locator.insertUniquePoint(newX).id;
+    if (!model.copiedPoints.has(newPtId)) {
+      model.copiedPoints.add(newPtId);
+      outputPD.passData(inputPD, ptId, newPtId);
+    }
+    return newPtId;
+  }
+  publicAPI.operateOnPoint = (inPt, outPt) => {
+    outPt[0] = inPt[0];
+    outPt[1] = inPt[1];
+    outPt[2] = inPt[2];
+  };
+  publicAPI.operateOnBounds = (inBounds, outBounds) => {
+    vtkBoundingBox.setBounds(outBounds, inBounds);
+  };
+  publicAPI.createDefaultLocator = input => {
+    let tol;
+    if (model.toleranceIsAbsolute) {
+      tol = model.absoluteTolerance;
+    } else if (input) {
+      tol = model.tolerance * input.getLength();
+    } else {
+      tol = model.tolerance;
+    }
+    if (!model._locator) {
+      model._locator = tol === 0.0 ? vtkMergePoints.newInstance() : vtkPointLocator.newInstance();
+      return;
+    }
+    if (tol === 0.0 && model._locator?.getTolerance() !== 0.0) {
+      model._locator = vtkMergePoints.newInstance();
+    } else if (tol > 0.0 && !(model._locator?.getTolerance() > 0.0)) {
+      model._locator = vtkPointLocator.newInstance();
+    }
+  };
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
+    outData[0] = output;
+    const inPts = input.getPoints();
+    const numPts = input.getNumberOfPoints();
+    if (!inPts || numPts < 1) {
+      return;
+    }
+    const updatedPts = new Array(input.getMaxCellSize());
+    const numUsedPts = {
+      value: 0
+    };
+    const precision = model.outputPointsPrecision;
+    let pointType = inPts.getDataType();
+    if (precision) {
+      pointType = precision === DesiredOutputPrecision.DOUBLE ? VtkDataTypes.DOUBLE : VtkDataTypes.FLOAT;
+    }
+    const newPts = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    const inVerts = input.getVerts();
+    const inLines = input.getLines();
+    const inPolys = input.getPolys();
+    const inStrips = input.getStrips();
+    let newVerts = null;
+    let newLines = null;
+    let newPolys = null;
+    let newStrips = null;
+    const inputPD = input.getPointData();
+    const inputCD = input.getCellData();
+    const outputPD = output.getPointData();
+    const outputCD = output.getCellData();
+    let pointMap = null;
+    if (model.pointMerging) {
+      publicAPI.createDefaultLocator(input);
+      if (model.toleranceIsAbsolute) {
+        model._locator.setTolerance(model.absoluteTolerance);
+      } else {
+        model._locator.setTolerance(model.tolerance * input.getLength());
+      }
+      const originalBounds = input.getBounds();
+      const mappedBounds = [];
+      publicAPI.operateOnBounds(originalBounds, mappedBounds);
+      model._locator.initPointInsertion(newPts, mappedBounds);
+    } else {
+      pointMap = new Array(numPts).fill(-1);
+    }
+
+    // Copy data attributes setup
+    outputPD.copyStructure(inputPD);
+    outputCD.copyStructure(inputCD);
+    model.copiedPoints.clear();
+    let outLineData = null;
+    let outPolyData = null;
+    let outStrpData = null;
+    let vertIDcounter = 0;
+    let lineIDcounter = 0;
+    let polyIDcounter = 0;
+    let strpIDcounter = 0;
+
+    // Process vertices
+    let inCellID = 0;
+    if (inVerts && inVerts.getNumberOfCells() > 0) {
+      newVerts = vtkCellArray.newInstance();
+      let currentIdx = 0;
+      const cellData = inVerts.getData();
+      while (currentIdx < cellData.length) {
+        const npts = cellData[currentIdx++];
+        const inputPointIds = cellData.slice(currentIdx, currentIdx + npts);
+        currentIdx += npts;
+        let numNewPts = 0;
+        for (let i = 0; i < inputPointIds.length; i++) {
+          const ptId = inputPointIds[i];
+          const newPtId = processPoint(ptId, inPts, newPts, inputPD, outputPD, pointMap, numUsedPts);
+          updatedPts[numNewPts++] = newPtId;
+        }
+        if (numNewPts > 0) {
+          newVerts.insertNextCell(updatedPts.slice(0, numNewPts));
+          outputCD.passData(inputCD, inCellID, vertIDcounter);
+          vertIDcounter++;
+        }
+        inCellID++;
+      }
+    }
+
+    // Process lines
+    if (inLines && inLines.getNumberOfCells() > 0) {
+      newLines = vtkCellArray.newInstance();
+      let currentIdx = 0;
+      const cellData = inLines.getData();
+      while (currentIdx < cellData.length) {
+        const npts = cellData[currentIdx++];
+        const inputPointIds = cellData.slice(currentIdx, currentIdx + npts);
+        currentIdx += npts;
+        let numNewPts = 0;
+        for (let i = 0; i < inputPointIds.length; i++) {
+          const ptId = inputPointIds[i];
+          const newPtId = processPoint(ptId, inPts, newPts, inputPD, outputPD, pointMap, numUsedPts);
+          if (i === 0 || newPtId !== updatedPts[numNewPts - 1]) {
+            updatedPts[numNewPts++] = newPtId;
+          }
+        }
+        if (numNewPts >= 2) {
+          newLines.insertNextCell(updatedPts.slice(0, numNewPts));
+          if (!outLineData) {
+            outLineData = [];
+          }
+          outLineData.push({
+            inputId: inCellID,
+            outputId: lineIDcounter
+          });
+          lineIDcounter++;
+        } else if (numNewPts === 1 && (inputPointIds.length === numNewPts || model.convertLinesToPoints)) {
+          if (!newVerts) {
+            newVerts = vtkCellArray.newInstance();
+          }
+          newVerts.insertNextCell(updatedPts.slice(0, numNewPts));
+          outputCD.passData(inputCD, inCellID, vertIDcounter);
+          vertIDcounter++;
+        }
+        inCellID++;
+      }
+    }
+
+    // Process polygons
+    if (inPolys && inPolys.getNumberOfCells() > 0) {
+      newPolys = vtkCellArray.newInstance();
+      let currentIdx = 0;
+      const cellData = inPolys.getData();
+      while (currentIdx < cellData.length) {
+        const npts = cellData[currentIdx++];
+        const inputPointIds = cellData.slice(currentIdx, currentIdx + npts);
+        currentIdx += npts;
+        let numNewPts = 0;
+        for (let i = 0; i < inputPointIds.length; i++) {
+          const ptId = inputPointIds[i];
+          const newPtId = processPoint(ptId, inPts, newPts, inputPD, outputPD, pointMap, numUsedPts);
+          if (i === 0 || newPtId !== updatedPts[numNewPts - 1]) {
+            updatedPts[numNewPts++] = newPtId;
+          }
+        }
+
+        // Remove duplicate last point if it matches first
+        if (numNewPts > 2 && updatedPts[0] === updatedPts[numNewPts - 1]) {
+          numNewPts--;
+        }
+        if (numNewPts > 2) {
+          newPolys.insertNextCell(updatedPts.slice(0, numNewPts));
+          if (!outPolyData) {
+            outPolyData = [];
+          }
+          outPolyData.push({
+            inputId: inCellID,
+            outputId: polyIDcounter
+          });
+          polyIDcounter++;
+        } else if (numNewPts === 2 && (inputPointIds.length === numNewPts || model.convertPolysToLines)) {
+          if (!newLines) {
+            newLines = vtkCellArray.newInstance();
+            outLineData = [];
+          }
+          newLines.insertNextCell(updatedPts.slice(0, numNewPts));
+          outLineData.push({
+            inputId: inCellID,
+            outputId: lineIDcounter
+          });
+          lineIDcounter++;
+        } else if (numNewPts === 1 && (inputPointIds.length === numNewPts || model.convertLinesToPoints)) {
+          if (!newVerts) {
+            newVerts = vtkCellArray.newInstance();
+          }
+          newVerts.insertNextCell(updatedPts.slice(0, numNewPts));
+          outputCD.passData(inputCD, inCellID, vertIDcounter);
+          vertIDcounter++;
+        }
+        inCellID++;
+      }
+    }
+
+    // Process triangle strips
+    if (inStrips && inStrips.getNumberOfCells() > 0) {
+      newStrips = vtkCellArray.newInstance();
+      let currentIdx = 0;
+      const cellData = inStrips.getData();
+      while (currentIdx < cellData.length) {
+        const npts = cellData[currentIdx++];
+        const inputPointIds = cellData.slice(currentIdx, currentIdx + npts);
+        currentIdx += npts;
+        let numNewPts = 0;
+        for (let i = 0; i < inputPointIds.length; i++) {
+          const ptId = inputPointIds[i];
+          const newPtId = processPoint(ptId, inPts, newPts, inputPD, outputPD, pointMap, numUsedPts);
+          if (i === 0 || newPtId !== updatedPts[numNewPts - 1]) {
+            updatedPts[numNewPts++] = newPtId;
+          }
+        }
+
+        // Remove duplicate last point if it matches first
+        if (numNewPts > 1 && updatedPts[0] === updatedPts[numNewPts - 1]) {
+          numNewPts--;
+        }
+        if (numNewPts > 3) {
+          newStrips.insertNextCell(updatedPts.slice(0, numNewPts));
+          if (!outStrpData) {
+            outStrpData = [];
+          }
+          outStrpData.push({
+            inputId: inCellID,
+            outputId: strpIDcounter
+          });
+          strpIDcounter++;
+        } else if (numNewPts === 3 && (inputPointIds.length === numNewPts || model.convertStripsToPolys)) {
+          if (!newPolys) {
+            newPolys = vtkCellArray.newInstance();
+            outPolyData = [];
+          }
+          newPolys.insertNextCell(updatedPts.slice(0, numNewPts));
+          outPolyData.push({
+            inputId: inCellID,
+            outputId: polyIDcounter
+          });
+          polyIDcounter++;
+        } else if (numNewPts === 2 && (inputPointIds.length === numNewPts || model.convertPolysToLines)) {
+          if (!newLines) {
+            newLines = vtkCellArray.newInstance();
+            outLineData = [];
+          }
+          newLines.insertNextCell(updatedPts.slice(0, numNewPts));
+          outLineData.push({
+            inputId: inCellID,
+            outputId: lineIDcounter
+          });
+          lineIDcounter++;
+        } else if (numNewPts === 1 && (inputPointIds.length === numNewPts || model.convertLinesToPoints)) {
+          if (!newVerts) {
+            newVerts = vtkCellArray.newInstance();
+          }
+          newVerts.insertNextCell(updatedPts.slice(0, numNewPts));
+          outputCD.passData(inputCD, inCellID, vertIDcounter);
+          vertIDcounter++;
+        }
+        inCellID++;
+      }
+    }
+
+    // Clean up
+    if (model.pointMerging) {
+      model._locator.initialize();
+    } else {
+      newPts.setNumberOfPoints(numUsedPts.value);
+    }
+
+    // Copy cell data in correct order
+    let combinedCellID = vertIDcounter;
+    if (outLineData) {
+      outLineData.forEach(item => {
+        outputCD.passData(inputCD, item.inputId, combinedCellID);
+        combinedCellID++;
+      });
+    }
+    if (outPolyData) {
+      outPolyData.forEach(item => {
+        outputCD.passData(inputCD, item.inputId, combinedCellID);
+        combinedCellID++;
+      });
+    }
+    if (outStrpData) {
+      outStrpData.forEach(item => {
+        outputCD.passData(inputCD, item.inputId, combinedCellID);
+        combinedCellID++;
+      });
+    }
+
+    // Set output
+    output.setPoints(newPts);
+    if (newVerts) output.setVerts(newVerts);
+    if (newLines) output.setLines(newLines);
+    if (newPolys) output.setPolys(newPolys);
+    if (newStrips) output.setStrips(newStrips);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  pointMerging: true,
+  toleranceIsAbsolute: false,
+  tolerance: 0.0,
+  absoluteTolerance: 1.0,
+  convertLinesToPoints: true,
+  convertPolysToLines: true,
+  convertStripsToPolys: true,
+  locator: null,
+  outputPointsPrecision: DesiredOutputPrecision.DEFAULT
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // 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);
+
+  // Generate macros for properties
+  macro.setGet(publicAPI, model, ['pointMerging', 'toleranceIsAbsolute', 'tolerance', 'absoluteTolerance', 'convertPolysToLines', 'convertLinesToPoints', 'convertStripsToPolys', 'outputPointsPrecision']);
+
+  // Internal state
+  model.copiedPoints = new Set();
+
+  // Object methods
+  vtkCleanPolyData(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCleanPolyData');
+
+// ----------------------------------------------------------------------------
+
+var vtkCleanPolyData$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkCleanPolyData$1 as default, extend, newInstance };

package/Filters/Core/PolyDataNormals.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 

package/Filters/Core/ThresholdPoints.js

@@ -209,10 +209,10 @@ const newInstance = macro.newInstance(extend, 'vtkThresholdPoints');
 
 // ----------------------------------------------------------------------------
 
-var index = {
+var vtkThresholdPoints$1 = {
   newInstance,
   extend,
   OperationType
 };
 
-export { index as default, extend, newInstance };
+export { vtkThresholdPoints$1 as default, extend, newInstance };

package/Filters/Core.js

@@ -1,9 +1,13 @@
+import vtkCleanPolyData from './Core/CleanPolyData.js';
 import vtkCutter from './Core/Cutter.js';
 import vtkPolyDataNormals from './Core/PolyDataNormals.js';
+import vtkThresholdPoints from './Core/ThresholdPoints.js';
 
 var Core = {
+  vtkCleanPolyData,
   vtkCutter,
-  vtkPolyDataNormals
+  vtkPolyDataNormals,
+  vtkThresholdPoints
 };
 
 export { Core as default };

package/Filters/General/ClipClosedSurface.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { d as dot, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { d as dot, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';

package/Filters/General/ContourTriangulator/helper.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../../macros2.js';
 import vtkPoints from '../../../Common/Core/Points.js';
-import { s as subtract, j as cross, d as dot, n as norm, e as distance2BetweenPoints, k as add, l as normalize } from '../../../Common/Core/Math/index.js';
+import { s as subtract, j as cross, d as dot, n as norm, f as distance2BetweenPoints, k as add, l as normalize } from '../../../Common/Core/Math/index.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
 import vtkPolygon from '../../../Common/DataModel/Polygon.js';
 import vtkIncrementalOctreePointLocator from '../../../Common/DataModel/IncrementalOctreePointLocator.js';

package/Filters/General/TubeFilter.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, j as cross, n as norm, d as dot, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { l as normalize, j as cross, n as norm, d as dot, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';

package/Filters/General/WindowedSincPolyDataFilter.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import { AttributeTypes } from '../../Common/DataModel/DataSetAttributes/Constants.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';

package/Filters/Sources/ArcSource.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';

package/Filters/Sources/EllipseArcSource.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';

package/Filters/Sources/FrustumSource.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';

package/Filters/Sources/TorusSource.js

@@ -0,0 +1,107 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+
+// ----------------------------------------------------------------------------
+// vtkTorusSource methods
+// Adapted from three.js TorusGeometry
+// ----------------------------------------------------------------------------
+
+const TAU = Math.PI * 2;
+function vtkTorusSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTorusSource');
+  function requestData(inData, outData) {
+    let dataset = outData[0];
+
+    // Points
+    const points = macro.newTypedArray(model.pointType, 3 * (model.resolution + 1) * (model.tubeResolution + 1));
+    let pointIdx = 0;
+    for (let ti = 0; ti <= model.tubeResolution; ti++) {
+      const v = ti / model.tubeResolution * TAU;
+      const cosV = Math.cos(v);
+      const sinV = Math.sin(v);
+      for (let ri = 0; ri <= model.resolution; ri++) {
+        const u = ri / model.resolution * model.arcLength;
+        points[pointIdx++] = (model.radius + model.tubeRadius * cosV) * Math.cos(u);
+        points[pointIdx++] = (model.radius + model.tubeRadius * cosV) * Math.sin(u);
+        points[pointIdx++] = model.tubeRadius * sinV;
+      }
+    }
+
+    // Cells
+    const cellArraySize = 4 * 2 * (model.resolution * model.tubeResolution);
+    let cellLocation = 0;
+    const polys = new Uint32Array(cellArraySize);
+    for (let ti = 1; ti <= model.tubeResolution; ti++) {
+      for (let ri = 1; ri <= model.resolution; ri++) {
+        const a = (model.resolution + 1) * ti + ri - 1;
+        const b = (model.resolution + 1) * (ti - 1) + ri - 1;
+        const c = (model.resolution + 1) * (ti - 1) + ri;
+        const d = (model.resolution + 1) * ti + ri;
+        polys[cellLocation++] = 3;
+        polys[cellLocation++] = a;
+        polys[cellLocation++] = b;
+        polys[cellLocation++] = d;
+        polys[cellLocation++] = 3;
+        polys[cellLocation++] = b;
+        polys[cellLocation++] = c;
+        polys[cellLocation++] = d;
+      }
+    }
+
+    // Apply transformation to the points coordinates
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).apply(points);
+    dataset = vtkPolyData.newInstance();
+    dataset.getPoints().setData(points, 3);
+    dataset.getPolys().setData(polys, 1);
+
+    // Update output
+    outData[0] = dataset;
+  }
+
+  // Expose methods
+  publicAPI.requestData = requestData;
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  radius: 0.5,
+  tubeRadius: 0.01,
+  resolution: 64,
+  tubeResolution: 64,
+  arcLength: TAU,
+  center: [0, 0, 0],
+  direction: [1.0, 0.0, 0.0],
+  pointType: 'Float64Array'
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['radius', 'tubeRadius', 'resolution', 'tubeResolution', 'arcLength']);
+  macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
+  macro.algo(publicAPI, model, 0, 1);
+  vtkTorusSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTorusSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkTorusSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTorusSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -16,6 +16,7 @@ import vtkPointSource from './Sources/PointSource.js';
 import vtkRTAnalyticSource from './Sources/RTAnalyticSource.js';
 import vtkSLICSource from './Sources/SLICSource.js';
 import vtkSphereSource from './Sources/SphereSource.js';
+import vtkTorusSource from './Sources/TorusSource.js';
 
 var Sources = {
   vtkArcSource,
@@ -35,7 +36,8 @@ var Sources = {
   vtkPointSource,
   vtkRTAnalyticSource,
   vtkSLICSource,
-  vtkSphereSource
+  vtkSphereSource,
+  vtkTorusSource
 };
 
 export { Sources as default };

package/Filters/Texture/TextureMapToPlane.js

@@ -1,6 +1,6 @@
 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, z as determinant3x3, A as rowsToMat3 } from '../../Common/Core/Math/index.js';
+import { l as normalize, d as dot, j as cross, f as distance2BetweenPoints, z as determinant3x3, A as rowsToMat3 } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 const {

package/Filters/Texture/TextureMapToSphere.js

@@ -1,6 +1,6 @@
 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 { f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 const {

package/Imaging/Core/ImageReslice.d.ts

@@ -666,7 +666,8 @@ export function newInstance(
  * slice rather than a volume. You can use both the resliceAxes and the
  * resliceTransform at the same time, in order to extract slices from a
  * volume that you have applied a transformation to.
- * */
+ * **Note**: vtkImageReslice uses column-major format.
+ */
 export declare const vtkImageReslice: {
   newInstance: typeof newInstance;
   extend: typeof extend;

package/Imaging/Core/ImageReslice.js

@@ -1,7 +1,7 @@
 import { mat4, vec4 } from 'gl-matrix';
 import { m as macro, v as vtkWarningMacro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';