@kitware/vtk.js 33.0.0-beta.1 → 33.0.0-beta.3

package/Common/Core/DataArray.d.ts

@@ -408,6 +408,10 @@ export function extend(
 
 /**
  * Method use to create a new instance of vtkDataArray
+ *
+ * If the provided `values` is a plain Array and `dataType` is not explicitly provided,
+ * then the vtkDataArray data type will be a Float32Array.
+ *
  * @param {object} [initialValues] for pre-setting some of its content
  */
 export function newInstance(initialValues?: object): vtkDataArray;

package/Common/Core/DataArray.js

@@ -497,6 +497,9 @@ const DEFAULT_VALUES = {
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
+  if (Array.isArray(initialValues.values) && initialValues.dataType === undefined) {
+    console.warn('vtkDataArray.newInstance: no dataType provided, converting to Float32Array');
+  }
   if (!model.empty && !model.values && !model.size) {
     throw new TypeError('Cannot create vtkDataArray object without: size > 0, values');
   }

package/Common/Core/Math/index.js

@@ -2256,4 +2256,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { min as $, ldexp as A, xyz2rgb as B, degreesFromRadians as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, isPowerOfTwo as V, angleBetweenVectors as W, signedAngleBetweenVectors as X, createArray as Y, Pi as Z, ceil as _, areMatricesEqual as a, floatRGB2HexCode as a$, max as a0, arrayMin as a1, arrayMax as a2, ceilLog2 as a3, factorial as a4, binomial as a5, beginCombination as a6, nextCombination as a7, randomSeed as a8, getSeed as a9, multiplyQuaternion as aA, orthogonalize3x3 as aB, diagonalize3x3 as aC, singularValueDecomposition3x3 as aD, luFactorLinearSystem as aE, luSolveLinearSystem as aF, invertMatrix as aG, estimateMatrixCondition as aH, solveHomogeneousLeastSquares as aI, solveLeastSquares as aJ, hex2float as aK, lab2xyz as aL, xyz2lab as aM, rgb2xyz as aN, computeBoundsFromPoints as aO, clampAndNormalizeValue as aP, getScalarTypeFittingRange as aQ, getAdjustedScalarRange as aR, extentIsWithinOtherExtent as aS, boundsIsWithinOtherBounds as aT, pointIsWithinBounds as aU, solve3PointCircle as aV, inf as aW, negInf as aX, isFinite as aY, isNaN as aZ, floatToHex2 as a_, gaussian as aa, multiplyScalar2D as ab, multiplyAccumulate2D as ac, outer as ad, projectVector as ae, dot2D as af, projectVector2D as ag, gaussianAmplitude as ah, gaussianWeight as ai, outer2D as aj, norm2D as ak, rowsToMat4 as al, columnsToMat4 as am, columnsToMat3 as an, LUFactor3x3 as ao, LUSolve3x3 as ap, linearSolve3x3 as aq, multiply3x3_mat3 as ar, transpose3x3 as as, invert3x3 as at, identity3x3 as au, isIdentity as av, isIdentity3x3 as aw, quaternionToMatrix3x3 as ax, roundNumber as ay, matrix3x3ToQuaternion as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { min as $, degreesFromRadians as A, ldexp as B, xyz2rgb as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, isPowerOfTwo as V, angleBetweenVectors as W, signedAngleBetweenVectors as X, createArray as Y, Pi as Z, ceil as _, areMatricesEqual as a, floatRGB2HexCode as a$, max as a0, arrayMin as a1, arrayMax as a2, ceilLog2 as a3, factorial as a4, binomial as a5, beginCombination as a6, nextCombination as a7, randomSeed as a8, getSeed as a9, multiplyQuaternion as aA, orthogonalize3x3 as aB, diagonalize3x3 as aC, singularValueDecomposition3x3 as aD, luFactorLinearSystem as aE, luSolveLinearSystem as aF, invertMatrix as aG, estimateMatrixCondition as aH, solveHomogeneousLeastSquares as aI, solveLeastSquares as aJ, hex2float as aK, lab2xyz as aL, xyz2lab as aM, rgb2xyz as aN, computeBoundsFromPoints as aO, clampAndNormalizeValue as aP, getScalarTypeFittingRange as aQ, getAdjustedScalarRange as aR, extentIsWithinOtherExtent as aS, boundsIsWithinOtherBounds as aT, pointIsWithinBounds as aU, solve3PointCircle as aV, inf as aW, negInf as aX, isFinite as aY, isNaN as aZ, floatToHex2 as a_, gaussian as aa, multiplyScalar2D as ab, multiplyAccumulate2D as ac, outer as ad, projectVector as ae, dot2D as af, projectVector2D as ag, gaussianAmplitude as ah, gaussianWeight as ai, outer2D as aj, norm2D as ak, rowsToMat4 as al, columnsToMat4 as am, columnsToMat3 as an, LUFactor3x3 as ao, LUSolve3x3 as ap, linearSolve3x3 as aq, multiply3x3_mat3 as ar, transpose3x3 as as, invert3x3 as at, identity3x3 as au, isIdentity as av, isIdentity3x3 as aw, quaternionToMatrix3x3 as ax, roundNumber as ay, matrix3x3ToQuaternion as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { ao as LUFactor3x3, ap as LUSolve3x3, Z as Pi, k as add, W as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a2 as arrayMax, a1 as arrayMin, F as arrayRange, a6 as beginCombination, a5 as binomial, aT as boundsIsWithinOtherBounds, _ as ceil, a3 as ceilLog2, aP as clampAndNormalizeValue, E as clampValue, c as clampVector, an as columnsToMat3, am as columnsToMat4, aO as computeBoundsFromPoints, Y as createArray, H as createUninitializedBounds, j as cross, f as default, C as degreesFromRadians, o as determinant2x2, y as determinant3x3, aC as diagonalize3x3, e as distance2BetweenPoints, d as dot, af as dot2D, aH as estimateMatrixCondition, aS as extentIsWithinOtherExtent, a4 as factorial, b0 as float2CssRGBA, a$ as floatRGB2HexCode, a_ as floatToHex2, K as floor, aa as gaussian, ah as gaussianAmplitude, ai as gaussianWeight, aR as getAdjustedScalarRange, G as getMajorAxisIndex, aQ as getScalarTypeFittingRange, a9 as getSeed, T as getSparseOrthogonalMatrix, aK as hex2float, h as hsv2rgb, I as identity, au as identity3x3, aW as inf, at as invert3x3, aG as invertMatrix, aY as isFinite, av as isIdentity, aw as isIdentity3x3, L as isInf, aZ as isNaN, i as isNan, V as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aL as lab2xyz, A as ldexp, aq as linearSolve3x3, aE as luFactorLinearSystem, aF as luSolveLinearSystem, az as matrix3x3ToQuaternion, a0 as max, $ as min, ar as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ac as multiplyAccumulate2D, J as multiplyMatrix, aA as multiplyQuaternion, w as multiplyScalar, ab as multiplyScalar2D, R as nearestPowerOfTwo, aX as negInf, a7 as nextCombination, n as norm, ak as norm2D, l as normalize, Q as normalize2D, aB as orthogonalize3x3, ad as outer, aj as outer2D, q as perpendiculars, aU as pointIsWithinBounds, ae as projectVector, ag as projectVector2D, ax as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a8 as randomSeed, M as rgb2hsv, N as rgb2lab, aN as rgb2xyz, P as round, ay as roundNumber, b as roundVector, z as rowsToMat3, al as rowsToMat4, X as signedAngleBetweenVectors, aD as singularValueDecomposition3x3, aV as solve3PointCircle, aI as solveHomogeneousLeastSquares, aJ as solveLeastSquares, g as solveLinearSystem, s as subtract, as as transpose3x3, u as uninitializeBounds, aM as xyz2lab, B as xyz2rgb } from './Math/index.js';
+export { ao as LUFactor3x3, ap as LUSolve3x3, Z as Pi, k as add, W as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a2 as arrayMax, a1 as arrayMin, F as arrayRange, a6 as beginCombination, a5 as binomial, aT as boundsIsWithinOtherBounds, _ as ceil, a3 as ceilLog2, aP as clampAndNormalizeValue, E as clampValue, c as clampVector, an as columnsToMat3, am as columnsToMat4, aO as computeBoundsFromPoints, Y as createArray, H as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aC as diagonalize3x3, e as distance2BetweenPoints, d as dot, af as dot2D, aH as estimateMatrixCondition, aS as extentIsWithinOtherExtent, a4 as factorial, b0 as float2CssRGBA, a$ as floatRGB2HexCode, a_ as floatToHex2, K as floor, aa as gaussian, ah as gaussianAmplitude, ai as gaussianWeight, aR as getAdjustedScalarRange, G as getMajorAxisIndex, aQ as getScalarTypeFittingRange, a9 as getSeed, T as getSparseOrthogonalMatrix, aK as hex2float, h as hsv2rgb, I as identity, au as identity3x3, aW as inf, at as invert3x3, aG as invertMatrix, aY as isFinite, av as isIdentity, aw as isIdentity3x3, L as isInf, aZ as isNaN, i as isNan, V as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aL as lab2xyz, B as ldexp, aq as linearSolve3x3, aE as luFactorLinearSystem, aF as luSolveLinearSystem, az as matrix3x3ToQuaternion, a0 as max, $ as min, ar as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ac as multiplyAccumulate2D, J as multiplyMatrix, aA as multiplyQuaternion, w as multiplyScalar, ab as multiplyScalar2D, R as nearestPowerOfTwo, aX as negInf, a7 as nextCombination, n as norm, ak as norm2D, l as normalize, Q as normalize2D, aB as orthogonalize3x3, ad as outer, aj as outer2D, q as perpendiculars, aU as pointIsWithinBounds, ae as projectVector, ag as projectVector2D, ax as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a8 as randomSeed, M as rgb2hsv, N as rgb2lab, aN as rgb2xyz, P as round, ay as roundNumber, b as roundVector, z as rowsToMat3, al as rowsToMat4, X as signedAngleBetweenVectors, aD as singularValueDecomposition3x3, aV as solve3PointCircle, aI as solveHomogeneousLeastSquares, aJ as solveLeastSquares, g as solveLinearSystem, s as subtract, as as transpose3x3, u as uninitializeBounds, aM as xyz2lab, C as xyz2rgb } from './Math/index.js';

package/Common/Core/URLExtract.js

@@ -27,12 +27,8 @@ function extractURLParameters() {
   let query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window.location.search;
   const summary = {};
   const convert = castToNativeType ? toNativeType : identity;
-  const queryTokens = (query || '').replace(/#.*/, '') // remove hash query
-  .replace('?', '') // Remove ? from the head
-  .split('&'); // extract token pair
-
-  queryTokens.forEach(token => {
-    const [key, value] = token.split('=').map(s => decodeURIComponent(s));
+  const params = new URLSearchParams(query);
+  params.forEach((value, key) => {
     if (key) {
       summary[key] = value ? convert(value) : true;
     }

package/Common/DataModel/Line.js

@@ -92,6 +92,7 @@ function intersection(a1, a2, b1, b2, u, v) {
       obj = distanceToLine(p[i], l1[i], l2[i]);
       if (obj.distance < minDist) {
         minDist = obj.distance;
+        obj.t;
       }
     }
     return IntersectionState.ON_LINE;

package/Common/DataModel/PolyLine.js

@@ -28,6 +28,10 @@ function vtkPolyLine(publicAPI, model) {
           outObj.subId = subId;
           outObj.t = lineIntersected.t;
           pDistMin = pDist;
+          for (let k = 0; k < 3; k++) {
+            x[k];
+            pCoords[k];
+          }
         }
       }
     }

package/Filters/Core/ThresholdPoints.d.ts

@@ -0,0 +1,72 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+
+export interface ThresholdCriteria {
+  arrayName: string;
+  fieldAssociation: string;
+  operation: string;
+  value: number;
+}
+
+/**
+ *
+ */
+export interface IThresholdPointsInitialValues {
+  criterias?: ThresholdCriteria[];
+}
+
+type vtkThresholdPointsBase = vtkObject & vtkAlgorithm;
+
+export interface vtkThresholdPoints extends vtkThresholdPointsBase {
+  /**
+   * Get the desired precision for the output types.
+   */
+  getCriterias(): ThresholdCriteria[];
+
+  /**
+   * Set the desired precision for the output types.
+   * @param outputPointsPrecision
+   */
+  setCriterias(criterias: ThresholdCriteria[]): boolean;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkThresholdPoints characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IThresholdPointsInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IThresholdPointsInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkThresholdPoints
+ * @param {IThresholdPointsInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IThresholdPointsInitialValues
+): vtkThresholdPoints;
+
+/**
+ * vtkThresholdPoints - extracts points whose scalar value satisfies threshold criterion
+ *
+ * vtkThresholdPoints is a filter that extracts points from a dataset that
+ * satisfy a threshold criterion. The criterion can take three forms:
+ * 1) greater than a particular value; 2) less than a particular value; or
+ * 3) between a particular value. The output of the filter is polygonal data.
+ */
+export declare const vtkThresholdPoints: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkThresholdPoints;

package/Filters/Core/ThresholdPoints.js

@@ -0,0 +1,219 @@
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { POLYDATA_FIELDS } from '../../Common/DataModel/PolyData/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+const OperationType = {
+  Below: 'Below',
+  Above: 'Above'
+};
+
+// Function to perform binary search on a sorted array
+function binarySearch(items, value) {
+  let firstIndex = 0;
+  let lastIndex = items.length - 1;
+  let middleIndex = Math.floor((lastIndex + firstIndex) / 2);
+  while (items[middleIndex] !== value && firstIndex < lastIndex) {
+    if (value < items[middleIndex]) {
+      lastIndex = middleIndex - 1;
+    } else if (value > items[middleIndex]) {
+      firstIndex = middleIndex + 1;
+    }
+    middleIndex = Math.floor((lastIndex + firstIndex) / 2);
+  }
+  return {
+    found: items[middleIndex] === value,
+    index: Math.max(items[middleIndex] < value ? middleIndex + 1 : middleIndex, 0)
+  };
+}
+function camelize(str) {
+  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, letter => letter.toUpperCase()).replace(/\s+/g, '');
+}
+// ----------------------------------------------------------------------------
+// vtkThresholdPoints methods
+// ----------------------------------------------------------------------------
+
+function vtkThresholdPoints(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkThresholdPoints');
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    const output = vtkPolyData.newInstance();
+    outData[0] = output;
+    if (model.criterias.length === 0) {
+      output.shallowCopy(input);
+      return;
+    }
+    const oldPoints = input.getPoints();
+    const oldPointCount = oldPoints.getNumberOfPoints();
+    const oldPointData = input.getPointData();
+    const oldPointsData = oldPoints.getData();
+    const newPointsData = macro.newTypedArray(input.getPoints().getDataType(), 3 * oldPointCount);
+    const oldArrays = [];
+    const newArraysData = [];
+    const numArrays = oldPointData.getNumberOfArrays();
+    for (let i = 0; i < numArrays; ++i) {
+      const oldArray = oldPointData.getArrayByIndex(i);
+      oldArrays.push(oldArray);
+      newArraysData.push(macro.newTypedArray(oldArray.getDataType(), oldPointCount * oldArray.getNumberOfComponents()));
+    }
+    const pointAcceptanceFunctions = model.criterias.map(criteria => {
+      let inputArray = null;
+      let component = 0;
+      let numberOfComponents = 1;
+      if (criteria.fieldAssociation === 'PointData') {
+        inputArray = oldArrays.find(oldArray => oldArray.getName() === criteria.arrayName);
+        numberOfComponents = inputArray.getNumberOfComponents();
+      } else if (criteria.fieldAssociation === 'Points') {
+        inputArray = oldPoints;
+        if (criteria.arrayName === 'z') {
+          component = 2;
+        } else {
+          component = criteria.arrayName === 'y' ? 1 : 0;
+        }
+        numberOfComponents = 3;
+      } else {
+        vtkErrorMacro('No field association');
+      }
+      const inputArrayData = inputArray.getData();
+      const operation = criteria.operation === OperationType.Below ? (a, b) => a < b : (a, b) => a > b;
+      const pointAcceptanceFunction = pointId => operation(inputArrayData[numberOfComponents * pointId + component], criteria.value);
+      return pointAcceptanceFunction;
+    });
+    const thresholdedPointIds = []; // sorted list
+    let newI = 0;
+    for (let i = 0; i < oldPointCount; ++i) {
+      const keepPoint = pointAcceptanceFunctions.reduce((keep, pointAcceptanceFunction) => keep && pointAcceptanceFunction(i), true);
+      if (keepPoint) {
+        let ii = 3 * i;
+        let newII = 3 * newI;
+        for (let c = 0; c < 3; ++c) {
+          newPointsData[newII++] = oldPointsData[ii++];
+        }
+        for (let j = 0; j < numArrays; ++j) {
+          const oldArrayData = oldArrays[j].getData();
+          const newArrayData = newArraysData[j];
+          const cc = oldArrays[j].getNumberOfComponents();
+          ii = cc * i;
+          newII = cc * newI;
+          for (let c = 0; c < cc; ++c) {
+            newArrayData[newII++] = oldArrayData[ii++];
+          }
+        }
+        ++newI;
+      } else {
+        thresholdedPointIds.push(i);
+      }
+    }
+    if (thresholdedPointIds.length === 0) {
+      output.shallowCopy(input);
+      return;
+    }
+    output.setPoints(vtkPoints.newInstance({
+      values: newPointsData,
+      size: 3 * newI
+    }));
+    for (let i = 0; i < numArrays; ++i) {
+      const oldArray = oldArrays[i];
+      const newArray = vtkDataArray.newInstance({
+        name: oldArray.getName(),
+        values: newArraysData[i],
+        dataType: oldArray.getDataType(),
+        numberOfComponents: oldArray.getNumberOfComponents(),
+        size: newI * oldArray.getNumberOfComponents()
+      });
+      output.getPointData().addArray(newArray);
+      oldPointData.getAttributes(oldArray).forEach(attrType => {
+        output.getPointData().setAttribute(newArray, attrType);
+      });
+    }
+    POLYDATA_FIELDS.forEach(cellType => {
+      const oldPolysData = input[`get${camelize(cellType)}`]().getData();
+      const newCellData = macro.newTypedArray(input.getPolys().getDataType(), oldPolysData.length);
+      const newPointIds = []; // first point starts at [1]
+      const firstPointIndex = cellType === 'verts' ? 0 : 1;
+      let numberOfPoints = 1;
+      let newP = 0;
+      for (let c = 0; c < oldPolysData.length; c += numberOfPoints + firstPointIndex) {
+        if (firstPointIndex === 1) {
+          // not for verts
+          numberOfPoints = oldPolysData[c];
+        }
+        let keepCell = true;
+        for (let p = firstPointIndex; p <= numberOfPoints; ++p) {
+          const {
+            found,
+            index
+          } = binarySearch(thresholdedPointIds, oldPolysData[c + p]);
+          if (found) {
+            keepCell = false;
+            break;
+          }
+          newPointIds[p] = oldPolysData[c + p] - index;
+        }
+        if (keepCell) {
+          newCellData[newP++] = numberOfPoints;
+          for (let p = firstPointIndex; p <= numberOfPoints;) {
+            newCellData[newP++] = newPointIds[p++];
+          }
+        }
+      }
+      output[`set${camelize(cellType)}`](vtkCellArray.newInstance({
+        values: newCellData,
+        size: newP,
+        // it may shorter than original array if cells are not kept
+        dataType: input.getPolys().getDataType()
+      }));
+    });
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+function defaultValues(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return {
+    criterias: [],
+    // arrayName: string, fieldAssociation: string, operation: string, value: number
+    ...initialValues
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(publicAPI, model, initialValues));
+
+  // Build VTK API
+  macro.setGet(publicAPI, model, []);
+  macro.get(publicAPI, model, []);
+  macro.setGetArray(publicAPI, model, ['criterias']);
+
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 1, 1);
+
+  // Object specific methods
+  vtkThresholdPoints(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkThresholdPoints');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend,
+  OperationType
+};
+
+export { index as default, extend, newInstance };

package/Filters/General/ContourTriangulator/helper.js

@@ -1747,11 +1747,11 @@ function vtkCCSCutHoleyPolys(polys, points, polyGroups, polyEdges, normal) {
       // Do a quick search first, then do an exhaustive search.
       let madeCut = 0;
       let inner = 0;
+      const cuts = [[0, 0], [0, 0]];
       for (let exhaustive = 0; exhaustive < 2 && !madeCut; exhaustive++) {
         for (let j = 1; j < polyGroup.length; j++) {
           inner = innerBySize[j][1];
           innerPolyId = polyGroup[inner];
-          const cuts = [];
           if (vtkCCSFindCuts(polys, polyGroup, outerPolyId, innerPolyId, points, normal, cuts, exhaustive)) {
             vtkCCSMakeCuts(polys, polyEdges, outerPolyId, innerPolyId, points, cuts);
             madeCut = 1;

package/IO/Core/DataAccessHelper/JSZipDataAccessHelper.js

@@ -1,4 +1,4 @@
-import { strToU8, unzipSync, strFromU8, decompressSync } from 'fflate';
+import { unzipSync, strFromU8, decompressSync, strToU8 } from 'fflate';
 import { m as macro } from '../../../macros2.js';
 import Endian from '../../../Common/Core/Endian.js';
 import { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';

package/IO/Geometry/DracoReader.d.ts

@@ -118,15 +118,15 @@ export function newInstance(
 ): vtkDracoReader;
 
 /**
- *
+ * Get the draco decoder
  */
 export function getDracoDecoder(): any;
 
 /**
- *
- * @param createDracoModule
+ * Set the draco decoder
+ * @param dracoDecoder
  */
-export function setDracoDecoder(createDracoModule: any): void;
+export function setDracoDecoder(dracoDecoder: any): Promise<any>;
 
 /**
  * Load the WASM decoder from url and set the decoderModule