@kitware/vtk.js 34.12.0 → 34.13.1

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/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';

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -8,7 +8,7 @@ import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
-import { E as areEquals, l as normalize, d as dot, F as clampValue, s as subtract, j as cross, x as multiplyScalar, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { E as areEquals, l as normalize, d as dot, F as clampValue, s as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 
 const {
   States

package/Interaction/Style/InteractorStyleMPRSlice.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { l as normalize, E as areEquals, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { l as normalize, E as areEquals, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkInteractorStyleManipulator from './InteractorStyleManipulator.js';

package/Rendering/Core/CellPicker.js

@@ -5,7 +5,7 @@ import vtkPicker from './Picker.js';
 import vtkPolyLine from '../../Common/DataModel/PolyLine.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 import vtkQuad from '../../Common/DataModel/Quad.js';
-import { l as normalize, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { l as normalize, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import { CellType } from '../../Common/DataModel/CellTypes/Constants.js';
 import { vec3, vec4 } from 'gl-matrix';
 import vtkBox from '../../Common/DataModel/Box.js';

package/Rendering/Core/Mapper.js

@@ -193,12 +193,12 @@ function getOrCreateColorTextureCoordinates(input, component, range, useLogScale
     if (useMagnitude) {
       let sum = 0;
       for (let compIdx = 0; compIdx < numComps; ++compIdx) {
-        const compValue = inputV[inputIdx + compIdx];
+        const compValue = Number(inputV[inputIdx + compIdx]);
         sum += compValue * compValue;
       }
       scalarValue = Math.sqrt(sum);
     } else {
-      scalarValue = inputV[inputIdx + component];
+      scalarValue = Number(inputV[inputIdx + component]);
     }
     if (useLogScale) {
       scalarValue = Math.log10(scalarValue);

package/Rendering/Core/Mapper2D.js

@@ -176,12 +176,12 @@ function getOrCreateColorTextureCoordinates(input, component, range, useLogScale
     if (useMagnitude) {
       let sum = 0;
       for (let compIdx = 0; compIdx < numComps; ++compIdx) {
-        const compValue = inputV[inputIdx + compIdx];
+        const compValue = Number(inputV[inputIdx + compIdx]);
         sum += compValue * compValue;
       }
       scalarValue = Math.sqrt(sum);
     } else {
-      scalarValue = inputV[inputIdx + component];
+      scalarValue = Number(inputV[inputIdx + component]);
     }
     if (useLogScale) {
       scalarValue = Math.log10(scalarValue);

package/Rendering/Core/Picker.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { d as dot, l as normalize, s as subtract, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { d as dot, l as normalize, s as subtract, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import { vec3, mat4, vec4 } from 'gl-matrix';
 
 const {

package/Rendering/Core/Renderer.js

@@ -362,17 +362,19 @@ function vtkRenderer(publicAPI, model) {
 
     // default so that the bounding sphere fits within the view fustrum
 
-    // compute the distance from the intersection of the view frustum with the
-    // bounding sphere. Basically in 2D draw a circle representing the bounding
-    // sphere in 2D then draw a horizontal line going out from the center of
-    // the circle. That is the camera view. Then draw a line from the camera
-    // position to the point where it intersects the circle. (it will be tangent
-    // to the circle at this point, this is important, only go to the tangent
-    // point, do not draw all the way to the view plane). Then draw the radius
-    // from the tangent point to the center of the circle. You will note that
-    // this forms a right triangle with one side being the radius, another being
-    // the target distance for the camera, then just find the target dist using
-    // a sin.
+    // Viewing the scene from the side in 2D:
+    // Draw a circle representing the bounding sphere containing all pixels.
+    // Then, draw a horizontal line going out from the center of the circle.
+    // The camera is somewhere on this line.
+    // Picture the view frustrum, moving through the circle.
+    // Draw a line from the intersection of the view frustrum and the bounding sphere to line the camera is on, ensuring that the line is tangent to the circle.
+    // Draw the radius from the tangent point to the center of the circle.
+    // You will note that this forms a right triangle with sides:
+    // - radius
+    // - the line formed by the intersection of the view frustrum and the bounding sphere
+    // - the target distance for the camera.
+    // We can use trigonometry to solve for that distance.
+
     const angle = radiansFromDegrees(model.activeCamera.getViewAngle());
     const parallelScale = radius;
     const distance = radius / Math.sin(angle * 0.5);

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -5,7 +5,7 @@ import vtkCutter from '../../Filters/Core/Cutter.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
 import vtkImageDataOutlineFilter from '../../Filters/General/ImageDataOutlineFilter.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';