@kitware/vtk.js 32.8.1 → 32.9.1

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

package/IO/Geometry/DracoReader.js

@@ -1,8 +1,9 @@
-import DataAccessHelper from '../Core/DataAccessHelper.js';
 import { m as macro } from '../../macros2.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPolyDataNormals from '../../Filters/Core/PolyDataNormals.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip
@@ -12,8 +13,7 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 const {
   vtkErrorMacro
 } = macro;
-let decoderModule = {};
-
+let decoderModule = null;
 // ----------------------------------------------------------------------------
 // static methods
 // ----------------------------------------------------------------------------
@@ -46,8 +46,13 @@ function setWasmBinary(url, binaryName) {
     xhr.send(null);
   });
 }
-function setDracoDecoder(createDracoModule) {
-  decoderModule = createDracoModule({});
+
+/**
+ * Set the Draco decoder module
+ * @param {*} dracoDecoder
+ */
+async function setDracoDecoder(dracoDecoder) {
+  decoderModule = await dracoDecoder({});
 }
 function getDracoDecoder() {
   return decoderModule;
@@ -56,115 +61,141 @@ function getDracoDecoder() {
 // ----------------------------------------------------------------------------
 // vtkDracoReader methods
 // ----------------------------------------------------------------------------
-
-function decodeBuffer(buffer) {
-  const byteArray = new Int8Array(buffer);
-  const decoder = new decoderModule.Decoder();
-  const decoderBuffer = new decoderModule.DecoderBuffer();
-  decoderBuffer.Init(byteArray, byteArray.length);
-  const geometryType = decoder.GetEncodedGeometryType(decoderBuffer);
-  let dracoGeometry;
-  if (geometryType === decoderModule.TRIANGULAR_MESH) {
-    dracoGeometry = new decoderModule.Mesh();
-    const status = decoder.DecodeBufferToMesh(decoderBuffer, dracoGeometry);
-    if (!status.ok()) {
-      vtkErrorMacro(`Could not decode Draco file: ${status.error_msg()}`);
-    }
-  } else {
-    vtkErrorMacro('Wrong geometry type, expected mesh, got point cloud.');
+function getDracoDataType(attributeType) {
+  switch (attributeType) {
+    case Float32Array:
+      return decoderModule.DT_FLOAT32;
+    case Int8Array:
+      return decoderModule.DT_INT8;
+    case Int16Array:
+      return decoderModule.DT_INT16;
+    case Int32Array:
+      return decoderModule.DT_INT32;
+    case Uint8Array:
+      return decoderModule.DT_UINT8;
+    case Uint16Array:
+      return decoderModule.DT_UINT16;
+    case Uint32Array:
+      return decoderModule.DT_UINT32;
+    default:
+      return decoderModule.DT_FLOAT32;
   }
-  decoderModule.destroy(decoderBuffer);
-  decoderModule.destroy(decoder);
-  return dracoGeometry;
 }
-function getDracoAttributeAsFloat32Array(dracoGeometry, attributeId) {
-  const decoder = new decoderModule.Decoder();
-  const attribute = decoder.GetAttribute(dracoGeometry, attributeId);
-  const numberOfComponents = attribute.num_components();
-  const numberOfPoints = dracoGeometry.num_points();
-  const attributeData = new decoderModule.DracoFloat32Array();
-  decoder.GetAttributeFloatForAllPoints(dracoGeometry, attribute, attributeData);
-  let i = numberOfPoints * numberOfComponents;
-  const attributeArray = new Float32Array(i);
-  while (i--) {
-    attributeArray[i] = attributeData.GetValue(i);
-  }
-  return attributeArray;
+
+/**
+ * Decode a single attribute
+ * @param {*} decoder The Draco decoder
+ * @param {*} dracoGeometry The geometry to decode
+ * @param {*} attributeName The name of the attribute
+ * @param {*} attributeType The type of the attribute
+ * @param {*} attribute The attribute to decode
+ * @returns object with name, array, itemSize
+ */
+function decodeAttribute(decoder, dracoGeometry, attributeName, attributeType, attribute) {
+  const numComponents = attribute.num_components();
+  const numPoints = dracoGeometry.num_points();
+  const numValues = numPoints * numComponents;
+  const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
+  const dataType = getDracoDataType(attributeType);
+  const ptr = decoderModule._malloc(byteLength);
+  decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr);
+
+  // eslint-disable-next-line new-cap
+  const array = new attributeType(decoderModule.HEAPF32.buffer, ptr, numValues).slice();
+  decoderModule._free(ptr);
+  return {
+    name: attributeName,
+    array,
+    itemSize: numComponents
+  };
 }
-function getPolyDataFromDracoGeometry(dracoGeometry) {
-  const decoder = new decoderModule.Decoder();
 
-  // Get position attribute ID
-  const positionAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.POSITION);
-  if (positionAttributeId === -1) {
-    console.error('No position attribute found in the decoded model.');
-    decoderModule.destroy(decoder);
-    decoderModule.destroy(dracoGeometry);
-    return null;
-  }
-  const positionArray = getDracoAttributeAsFloat32Array(dracoGeometry, positionAttributeId);
+/**
+ * Decode the indices of the geometry
+ * @param {*} decoder The Draco decoder
+ * @param {*} dracoGeometry The geometry to decode
+ * @returns The indices array of the geometry
+ */
+function decodeIndices(decoder, dracoGeometry) {
+  const numFaces = dracoGeometry.num_faces();
+  const numIndices = numFaces * 3;
+  const byteLength = numIndices * 4;
+  const ptr = decoderModule._malloc(byteLength);
+  decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+  const indices = new Uint32Array(decoderModule.HEAPF32.buffer, ptr, numIndices).slice();
+  decoderModule._free(ptr);
+  return indices;
+}
 
-  // Read indices
-  let i = dracoGeometry.num_faces();
-  const indices = new Uint32Array(i * 4);
-  const indicesArray = new decoderModule.DracoInt32Array();
-  while (i--) {
-    decoder.GetFaceFromMesh(dracoGeometry, i, indicesArray);
-    const index = i * 4;
-    indices[index] = 3;
-    indices[index + 1] = indicesArray.GetValue(0);
-    indices[index + 2] = indicesArray.GetValue(1);
-    indices[index + 3] = indicesArray.GetValue(2);
+/**
+ * Get the polyData from the Draco geometry
+ * @param {*} decoder The Draco decoder
+ * @param {*} dracoGeometry The geometry to decode
+ * @returns {vtkPolyData} The polyData of the geometry
+ */
+function getPolyDataFromDracoGeometry(decoder, dracoGeometry) {
+  const indices = decodeIndices(decoder, dracoGeometry);
+  const nCells = indices.length - 2;
+  const cells = vtkCellArray.newInstance();
+  cells.resize(4 * indices.length / 3);
+  for (let cellId = 0; cellId < nCells; cellId += 3) {
+    const cell = indices.slice(cellId, cellId + 3);
+    cells.insertNextCell(cell);
   }
-
-  // Create polyData and add positions and indinces
-  const cellArray = vtkCellArray.newInstance({
-    values: indices
-  });
   const polyData = vtkPolyData.newInstance({
-    polys: cellArray
+    polys: cells
   });
-  polyData.getPoints().setData(positionArray);
-
-  // Look for other attributes
-  const pointData = polyData.getPointData();
 
-  // Normals
-  const normalAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.NORMAL);
-  if (normalAttributeId !== -1) {
-    const normalArray = getDracoAttributeAsFloat32Array(dracoGeometry, decoderModule.NORMAL);
-    const normals = vtkDataArray.newInstance({
-      numberOfComponents: 3,
-      values: normalArray,
-      name: 'Normals'
-    });
-    pointData.setNormals(normals);
-  }
-
-  // Texture coordinates
-  const texCoordAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.TEX_COORD);
-  if (texCoordAttributeId !== -1) {
-    const texCoordArray = getDracoAttributeAsFloat32Array(dracoGeometry, texCoordAttributeId);
-    const texCoords = vtkDataArray.newInstance({
-      numberOfComponents: 2,
-      values: texCoordArray,
-      name: 'TCoords'
-    });
-    pointData.setTCoords(texCoords);
-  }
+  // Look for attributes
+  const attributeIDs = {
+    points: 'POSITION',
+    normals: 'NORMAL',
+    scalars: 'COLOR',
+    tcoords: 'TEX_COORD'
+  };
+  Object.keys(attributeIDs).forEach(attributeName => {
+    const attributeType = Float32Array;
+    const attributeID = decoder.GetAttributeId(dracoGeometry, decoderModule[attributeIDs[attributeName]]);
+    if (attributeID === -1) return;
+    const attribute = decoder.GetAttribute(dracoGeometry, attributeID);
+    const attributeResult = decodeAttribute(decoder, dracoGeometry, attributeName, attributeType, attribute);
+    const pointData = polyData.getPointData();
+    switch (attributeName) {
+      case 'points':
+        polyData.getPoints().setData(attributeResult.array, attributeResult.itemSize);
+        break;
+      case 'normals':
+        pointData.setNormals(vtkDataArray.newInstance({
+          numberOfComponents: attributeResult.itemSize,
+          values: attributeResult.array,
+          name: 'Normals'
+        }));
+        break;
+      case 'scalars':
+        pointData.setScalars(vtkDataArray.newInstance({
+          numberOfComponents: attributeResult.itemSize,
+          values: attributeResult.array,
+          name: 'Scalars'
+        }));
+        break;
+      case 'tcoords':
+        pointData.setTCoords(vtkDataArray.newInstance({
+          numberOfComponents: attributeResult.itemSize,
+          values: attributeResult.array,
+          name: 'TCoords'
+        }));
+        break;
+    }
+  });
 
-  // Scalars
-  const colorAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.COLOR);
-  if (colorAttributeId !== -1) {
-    const colorArray = getDracoAttributeAsFloat32Array(dracoGeometry, colorAttributeId);
-    const scalars = vtkDataArray.newInstance({
-      numberOfComponents: 3,
-      values: colorArray,
-      name: 'Scalars'
-    });
-    pointData.setScalars(scalars);
+  // we will generate normals if they're missing
+  const hasNormals = polyData.getPointData().getNormals();
+  if (!hasNormals) {
+    const pdn = vtkPolyDataNormals.newInstance();
+    pdn.setInputData(polyData);
+    pdn.setComputePointNormals(true);
+    return pdn.getOutputData();
   }
-  decoderModule.destroy(decoder);
   return polyData;
 }
 function vtkDracoReader(publicAPI, model) {
@@ -235,9 +266,27 @@ function vtkDracoReader(publicAPI, model) {
       return;
     }
     model.parseData = content;
-    const dracoGeometry = decodeBuffer(content);
-    const polyData = getPolyDataFromDracoGeometry(dracoGeometry);
+    const byteArray = new Int8Array(content);
+    const decoder = new decoderModule.Decoder();
+    const buffer = new decoderModule.DecoderBuffer();
+    buffer.Init(byteArray, byteArray.length);
+    const geometryType = decoder.GetEncodedGeometryType(buffer);
+    let dracoGeometry;
+    if (geometryType === decoderModule.TRIANGULAR_MESH) {
+      dracoGeometry = new decoderModule.Mesh();
+      const status = decoder.DecodeBufferToMesh(buffer, dracoGeometry);
+      if (!status.ok()) {
+        vtkErrorMacro(`Could not decode Draco file: ${status.error_msg()}`);
+        return;
+      }
+    } else {
+      vtkErrorMacro('Wrong geometry type, expected mesh, got point cloud.');
+      return;
+    }
+    const polyData = getPolyDataFromDracoGeometry(decoder, dracoGeometry);
     decoderModule.destroy(dracoGeometry);
+    decoderModule.destroy(buffer);
+    decoderModule.destroy(decoder);
     model.output[0] = polyData;
   };
   publicAPI.requestData = () => {

package/IO/Geometry/GLTFImporter/Extensions.js

@@ -91,7 +91,7 @@ function handleKHRLightsPunctual(extension, transformMatrix, model) {
  *
  * @param {object} extension - The KHR_draco_mesh_compression extension object.
  */
-async function handleKHRDracoMeshCompression(extension) {
+function handleKHRDracoMeshCompression(extension) {
   const reader = vtkDracoReader.newInstance();
   reader.parse(extension.bufferView);
   return reader.getOutputData();

package/IO/Geometry/GLTFImporter.d.ts

@@ -183,25 +183,25 @@ export interface vtkGLTFImporter extends vtkGLTFImporterBase {
 
   /**
    * Set the camera id.
-   * @param cameraId
+   * @param cameraId The camera id.
    */
   setCamera(cameraId: string): void;
 
   /**
    * Set the Draco decoder.
-   * @param mappings
+   * @param dracoDecoder
    */
-  setDracoDecoder(decoder: any): void;
+  setDracoDecoder(dracoDecoder: any): void;
 
   /**
    * Set the vtk Renderer.
-   * @param renderer
+   * @param renderer The vtk Renderer.
    */
   setRenderer(renderer: vtkRenderer): void;
 
   /**
    * Switch to a variant.
-   * @param variantIndex
+   * @param variantIndex The index of the variant to switch to.
    */
   switchToVariant(variantIndex: number): void;
 }

package/IO/Geometry/GLTFImporter.js

@@ -133,8 +133,8 @@ function vtkGLTFImporter(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
     publicAPI.parse(model.parseData);
   };
-  publicAPI.setDracoDecoder = decoder => {
-    vtkDracoReader.setDracoDecoder(decoder);
+  publicAPI.setDracoDecoder = async dracoDecoder => {
+    await vtkDracoReader.setDracoDecoder(dracoDecoder);
   };
   publicAPI.importActors = () => {
     // Add actors to renderer

package/IO/Geometry/IFCImporter.js

@@ -8,6 +8,7 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkAppendPolyData from '../../Filters/General/AppendPolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+import { mat3 } from 'gl-matrix';
 
 const {
   vtkErrorMacro
@@ -82,10 +83,12 @@ function vtkIFCImporter(publicAPI, model) {
     const colorArray = new Float32Array(vertices.length / 2);
     if (userMatrix) {
       const transformMatrix = vtkMatrixBuilder.buildFromRadian().setMatrix(userMatrix);
+      const normalMatrix = vtkMatrixBuilder.buildFromRadian().multiply3x3(mat3.fromMat4(mat3.create(), userMatrix));
       for (let i = 0; i < vertices.length; i += 6) {
         const point = [vertices[i], vertices[i + 1], vertices[i + 2]];
         const normal = [vertices[i + 3], vertices[i + 4], vertices[i + 5]];
-        transformMatrix.apply(point).apply(normal);
+        transformMatrix.apply(point);
+        normalMatrix.apply(normal);
         pointValues[i / 2] = point[0];
         pointValues[i / 2 + 1] = point[1];
         pointValues[i / 2 + 2] = point[2];
@@ -199,26 +202,26 @@ function vtkIFCImporter(publicAPI, model) {
   publicAPI.importActors = renderer => {
     if (model.mergeGeometries) {
       const opaqueMeshes = meshes.filter(mesh => mesh.color.w === 1);
-      let apd = vtkAppendPolyData.newInstance();
+      const oapd = vtkAppendPolyData.newInstance();
       opaqueMeshes.forEach(mesh => {
         const pd = createColoredPolyDataFromIFCMesh(mesh);
-        apd.addInputData(pd);
+        oapd.addInputData(pd);
       });
       let mapper = vtkMapper.newInstance();
       mapper.setColorModeToDirectScalars();
-      mapper.setInputConnection(apd.getOutputPort());
+      mapper.setInputConnection(oapd.getOutputPort());
       let actor = vtkActor.newInstance();
       actor.setMapper(mapper);
       renderer.addActor(actor);
       const transparentMeshes = meshes.filter(mesh => mesh.color.w < 1);
-      apd = vtkAppendPolyData.newInstance();
+      const tapd = vtkAppendPolyData.newInstance();
       transparentMeshes.forEach(mesh => {
         const pd = createColoredPolyDataFromIFCMesh(mesh);
-        apd.addInputData(pd);
+        tapd.addInputData(pd);
       });
       mapper = vtkMapper.newInstance();
       mapper.setColorModeToDirectScalars();
-      mapper.setInputConnection(apd.getOutputPort());
+      mapper.setInputConnection(tapd.getOutputPort());
       actor = vtkActor.newInstance();
       actor.setMapper(mapper);
       actor.getProperty().setOpacity(0.5);

package/Rendering/Misc/CanvasView.js

@@ -134,8 +134,10 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Create internal instances
-  model.canvas = document.createElement('canvas');
-  model.canvas.style.width = '100%';
+  if (!model.canvas) {
+    model.canvas = document.createElement('canvas');
+    model.canvas.style.width = '100%';
+  }
 
   // Create internal bgImage
   model.bgImage = new Image();

package/Rendering/Misc/RemoteView.d.ts

@@ -13,21 +13,27 @@ interface IRemoteViewInitialValues {
   rpcGestureEvent?: any;
   rpcWheelEvent?: any;
   viewStream?: vtkViewStream;
+  canvasElement?: HTMLCanvasElement;
 }
 
 export interface vtkRemoteView extends vtkObject {
   /**
-   * Get container element
+   * Get container HTML element
    */
   getContainer(): HTMLElement;
 
   /**
-   *
+   * Get vtkViewStream object
    */
   getViewStream(): vtkViewStream;
 
   /**
-   *
+   * Get the canvas HTML element
+   */
+  getCanvasElement(): HTMLCanvasElement;
+
+  /**
+   * Get the vtkCanvasView object
    */
   getCanvasView(): vtkCanvasView;
 

package/Rendering/Misc/RemoteView.js

@@ -17,7 +17,9 @@ function vtkRemoteView(publicAPI, model) {
   model.classHierarchy.push('vtkRemoteView');
 
   // Constructor
-  model.canvasView = vtkCanvasView.newInstance();
+  model.canvasView = vtkCanvasView.newInstance({
+    canvas: model.canvasElement
+  });
   model.interactorStyle = vtkInteractorStyleRemoteMouse.newInstance();
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setView(model.canvasView);
@@ -60,6 +62,7 @@ function vtkRemoteView(publicAPI, model) {
       model.viewStream.delete();
     }
   }, publicAPI.delete);
+  publicAPI.getCanvasElement = () => model.canvasView.getCanvas();
 
   // --------------------------------------------------------------------------
   // remote handing
@@ -194,7 +197,8 @@ const DEFAULT_VALUES = {
   stillRatio: 1,
   rpcMouseEvent: 'viewport.mouse.interaction',
   rpcGestureEvent: null,
-  rpcWheelEvent: null
+  rpcWheelEvent: null,
+  canvasElement: null
 };
 
 // ----------------------------------------------------------------------------
@@ -203,7 +207,7 @@ function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio']);
+  macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio', 'canvasElement']);
   macro.setGet(publicAPI, model, ['session', 'rpcMouseEvent', 'rpcGestureEvent', 'rpcWheelEvent']);
 
   // Object methods

package/Rendering/OpenGL/Texture/supportsNorm16Linear.js

@@ -0,0 +1,97 @@
+/**
+ * Even when the EXT_texture_norm16 extension is present, linear filtering
+ * might not be supported for normalized fixed point textures.
+ *
+ * This is a driver bug. See https://github.com/KhronosGroup/WebGL/issues/3706
+ * @return {boolean}
+ */
+function supportsNorm16Linear() {
+  try {
+    const canvasSize = 4;
+    const texWidth = 2;
+    const texHeight = 1;
+    const texData = new Int16Array([0, 2 ** 15 - 1]);
+    const pixelToCheck = [1, 1];
+    const canvas = document.createElement('canvas');
+    canvas.width = canvasSize;
+    canvas.height = canvasSize;
+    const gl = canvas.getContext('webgl2');
+    if (!gl) {
+      return false;
+    }
+    const ext = gl.getExtension('EXT_texture_norm16');
+    if (!ext) {
+      return false;
+    }
+    const vs = `#version 300 es
+    void main() {
+      gl_PointSize = ${canvasSize.toFixed(1)};
+      gl_Position = vec4(0, 0, 0, 1);
+    }
+  `;
+    const fs = `#version 300 es
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+
+    uniform sampler2D u_image;
+
+    out vec4 color;
+
+    void main() {
+        vec4 intColor = texture(u_image, gl_PointCoord.xy);
+        color = vec4(vec3(intColor.rrr), 1);
+    }
+    `;
+    const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vertexShader, vs);
+    gl.compileShader(vertexShader);
+    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+      return false;
+    }
+    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fragmentShader, fs);
+    gl.compileShader(fragmentShader);
+    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+      return false;
+    }
+    const program = gl.createProgram();
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      return false;
+    }
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, ext.R16_SNORM_EXT, texWidth, texHeight, 0, gl.RED, gl.SHORT, texData);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.useProgram(program);
+    gl.drawArrays(gl.POINTS, 0, 1);
+    const pixel = new Uint8Array(4);
+    gl.readPixels(pixelToCheck[0], pixelToCheck[1], 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+    const [r, g, b] = pixel;
+    const webglLoseContext = gl.getExtension('WEBGL_lose_context');
+    if (webglLoseContext) {
+      webglLoseContext.loseContext();
+    }
+    return r === g && g === b && r !== 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * @type {boolean | undefined}
+ */
+let supportsNorm16LinearCache;
+function supportsNorm16LinearCached() {
+  // Only create a canvas+texture+shaders the first time
+  if (supportsNorm16LinearCache === undefined) {
+    supportsNorm16LinearCache = supportsNorm16Linear();
+  }
+  return supportsNorm16LinearCache;
+}
+
+export { supportsNorm16LinearCached as default };

package/Rendering/OpenGL/Texture.js

@@ -5,6 +5,7 @@ import vtkDataArray from '../../Common/Core/DataArray.js';
 import { V as isPowerOfTwo, R as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import supportsNorm16LinearCached from './Texture/supportsNorm16Linear.js';
 
 const {
   Wrap,
@@ -133,6 +134,12 @@ function vtkOpenGLTexture(publicAPI, model) {
       publicAPI.activate();
     }
   };
+  const getNorm16Ext = () => {
+    if ((model.minificationFilter === Filter.LINEAR || model.magnificationFilter === Filter.LINEAR) && !supportsNorm16LinearCached()) {
+      return undefined;
+    }
+    return model.oglNorm16Ext;
+  };
 
   //----------------------------------------------------------------------------
   publicAPI.destroyTexture = () => {
@@ -285,7 +292,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.getDefaultInternalFormat = (vtktype, numComps) => {
     let result = 0;
     // try default next
-    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, getNorm16Ext(), publicAPI.useHalfFloat());
     if (result) {
       return result;
     }
@@ -364,9 +371,9 @@ function vtkOpenGLTexture(publicAPI, model) {
           return model.context.UNSIGNED_BYTE;
         // prefer norm16 since that is accurate compared to
         // half float which is not
-        case model.oglNorm16Ext && !useHalfFloat && VtkDataTypes.SHORT:
+        case getNorm16Ext() && !useHalfFloat && VtkDataTypes.SHORT:
           return model.context.SHORT;
-        case model.oglNorm16Ext && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
+        case getNorm16Ext() && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.UNSIGNED_SHORT;
         // use half float type
         case useHalfFloat && VtkDataTypes.SHORT:
@@ -659,7 +666,7 @@ function vtkOpenGLTexture(publicAPI, model) {
       }
       if (model._openGLRenderWindow.getWebgl2()) {
         const webGLInfo = model._openGLRenderWindow.getGLInformations();
-        if (webGLInfo.RENDERER.value.match(/WebKit/gi) && navigator.platform.match(/Mac/gi) && model.oglNorm16Ext && (dataType === VtkDataTypes.UNSIGNED_SHORT || dataType === VtkDataTypes.SHORT)) {
+        if (webGLInfo.RENDERER.value.match(/WebKit/gi) && navigator.platform.match(/Mac/gi) && getNorm16Ext() && (dataType === VtkDataTypes.UNSIGNED_SHORT || dataType === VtkDataTypes.SHORT)) {
           // Cannot use texStorage with EXT_texture_norm16 textures on Mac M1 GPU.
           // No errors reported but the texture is unusable.
           return false;
@@ -717,7 +724,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (flip) {
       model.context.pixelStorei(model.context.UNPACK_FLIP_Y_WEBGL, false);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -795,7 +802,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         h /= 2;
       }
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, getNorm16Ext(), publicAPI.useHalfFloat());
     // generateMipmap must not be called here because we manually upload all levels
     // if it is called, all levels will be overwritten
 
@@ -845,7 +852,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -895,7 +902,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(VtkDataTypes.UNSIGNED_CHAR, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(VtkDataTypes.UNSIGNED_CHAR, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -1013,7 +1020,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
 
     // Handle SHORT data type with EXT_texture_norm16 extension
-    if (model.oglNorm16Ext && !useHalfFloat && dataType === VtkDataTypes.SHORT) {
+    if (getNorm16Ext() && !useHalfFloat && dataType === VtkDataTypes.SHORT) {
       for (let c = 0; c < numComps; ++c) {
         model.volumeInfo.scale[c] = 32767.0; // Scale to [-1, 1] range
       }
@@ -1022,7 +1029,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
 
     // Handle UNSIGNED_SHORT data type with EXT_texture_norm16 extension
-    if (model.oglNorm16Ext && !useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
+    if (getNorm16Ext() && !useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
       for (let c = 0; c < numComps; ++c) {
         model.volumeInfo.scale[c] = 65535.0; // Scale to [0, 1] range
       }
@@ -1112,7 +1119,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataTypeToUse, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataTypeToUse, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };

package/index.d.ts

@@ -54,6 +54,7 @@
 /// <reference path="./Common/DataModel/Triangle.d.ts" />
 /// <reference path="./Common/Transform/LandmarkTransform.d.ts" />
 /// <reference path="./Common/Transform/Transform.d.ts" />
+/// <reference path="./Filters/Core/ThresholdPoints.d.ts" />
 /// <reference path="./Filters/General/AppendPolyData.d.ts" />
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
 /// <reference path="./Filters/General/ContourLoopExtraction.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "32.8.1",
+  "version": "32.9.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",