@kitware/vtk.js 32.7.1 → 32.8.0

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/IO/Geometry/GLTFImporter/Animations.js

@@ -133,7 +133,7 @@ function createAnimationSampler(glTFSampler) {
         result = cubicSplineInterpolate(path, t0, t1, i0, i1, time);
         break;
       default:
-        throw new Error(`Unknown interpolation method: ${glTFSampler.interpolation}`);
+        vtkWarningMacro(`Unknown interpolation method: ${glTFSampler.interpolation}`);
     }
     return result;
   }

package/IO/Geometry/GLTFImporter/Parser.js

@@ -101,7 +101,7 @@ class GLTFParser {
     if (mesh.primitives) {
       mesh.primitives = mesh.primitives.map((primitive, idx) => {
         const attributes = primitive.attributes;
-        primitive.name = `submesh-${idx}`;
+        primitive.name = `primitive-${idx}`;
         primitive.attributes = {};
         for (const attribute in attributes) {
           const attr = SEMANTIC_ATTRIBUTE_MAP[attribute];

package/IO/Geometry/GLTFImporter/Reader.js

@@ -30,18 +30,15 @@ async function parseGLTF(gltf, options) {
 }
 
 /**
- * Creates VTK polydata from a GLTF mesh
- * @param {GLTFMesh} mesh - The GLTF mesh
+ * Creates VTK polydata from a GLTF mesh primitive
+ * @param {GLTFPrimitive} primitive - The GLTF mesh primitive
  * @returns {vtkPolyData} The created VTK polydata
  */
-async function createPolyDataFromGLTFMesh(mesh) {
-  const primitive = mesh.primitives[0]; // For simplicity, we'll just use the first primitive
-
+async function createPolyDataFromGLTFMesh(primitive) {
   if (!primitive || !primitive.attributes) {
-    vtkWarningMacro('Mesh has no position data, skipping');
+    vtkWarningMacro('Primitive has no position data, skipping');
     return null;
   }
-  const mode = primitive.mode;
   if (primitive.extensions?.KHR_draco_mesh_compression) {
     return handleKHRDracoMeshCompression(primitive.extensions.KHR_draco_mesh_compression);
   }
@@ -118,10 +115,10 @@ async function createPolyDataFromGLTFMesh(mesh) {
   });
 
   // Handle indices if available
-  if (primitive.indices !== undefined) {
+  if (primitive.indices != null) {
     const indices = primitive.indices.value;
     const nCells = indices.length - 2;
-    switch (mode) {
+    switch (primitive.mode) {
       case MODES.GL_LINE_STRIP:
       case MODES.GL_TRIANGLE_STRIP:
       case MODES.GL_LINE_LOOP:
@@ -135,7 +132,7 @@ async function createPolyDataFromGLTFMesh(mesh) {
         }
     }
   }
-  switch (mode) {
+  switch (primitive.mode) {
     case MODES.GL_TRIANGLES:
     case MODES.GL_TRIANGLE_FAN:
       polyData.setPolys(cells);
@@ -159,7 +156,7 @@ async function createPolyDataFromGLTFMesh(mesh) {
 
 /**
  * Creates a VTK property from a GLTF material
- * @param {*} model - The vtk model object
+ * @param {object} model - The vtk model object
  * @param {GLTFMaterial} material - The GLTF material
  * @param {vtkActor} actor - The VTK actor
  */
@@ -169,15 +166,15 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
   const emissiveFactor = material.emissiveFactor;
   const property = actor.getProperty();
   const pbr = material.pbrMetallicRoughness;
-  if (pbr !== undefined) {
+  if (pbr != null) {
     if (!pbr?.metallicFactor || pbr?.metallicFactor <= 0 || pbr?.metallicFactor >= 1) {
-      vtkWarningMacro('Invalid material.pbrMetallicRoughness.metallicFactor value. Using default value instead.');
+      vtkDebugMacro('Invalid material.pbrMetallicRoughness.metallicFactor value. Using default value instead.');
     } else metallicFactor = pbr.metallicFactor;
     if (!pbr?.roughnessFactor || pbr?.roughnessFactor <= 0 || pbr?.roughnessFactor >= 1) {
-      vtkWarningMacro('Invalid material.pbrMetallicRoughness.roughnessFactor value. Using default value instead.');
+      vtkDebugMacro('Invalid material.pbrMetallicRoughness.roughnessFactor value. Using default value instead.');
     } else roughnessFactor = pbr.roughnessFactor;
     const color = pbr.baseColorFactor;
-    if (color !== undefined) {
+    if (color != null) {
       property.setDiffuseColor(color[0], color[1], color[2]);
       property.setOpacity(color[3]);
     }
@@ -187,7 +184,7 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
     if (pbr.baseColorTexture) {
       pbr.baseColorTexture.extensions;
       const tex = pbr.baseColorTexture.texture;
-      if (tex.extensions !== undefined) {
+      if (tex.extensions != null) {
         const extensionsNames = Object.keys(tex.extensions);
         extensionsNames.forEach(extensionName => {
           // TODO: Handle KHR_texture_basisu extension
@@ -243,7 +240,7 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
       property.setEmissionTexture(emissiveTex);
 
       // Handle mutiple Uvs
-      if (material.emissiveTexture.texCoord !== undefined) {
+      if (material.emissiveTexture.texCoord != null) {
         const pd = actor.getMapper().getInputData().getPointData();
         pd.setActiveTCoords(`TEXCOORD_${material.emissiveTexture.texCoord}`);
       }
@@ -257,14 +254,14 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
       const normalImage = await loadImage(tex.source);
       const normalTex = createVTKTextureFromGLTFTexture(normalImage, sampler);
       property.setNormalTexture(normalTex);
-      if (material.normalTexture.scale !== undefined) {
+      if (material.normalTexture.scale != null) {
         property.setNormalStrength(material.normalTexture.scale);
       }
     }
   }
 
   // Material extensions
-  if (material.extensions !== undefined) {
+  if (material.extensions != null) {
     const extensionsNames = Object.keys(material.extensions);
     extensionsNames.forEach(extensionName => {
       const extension = material.extensions[extensionName];
@@ -291,17 +288,17 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
 
 /**
  * Handles primitive extensions
+ * @param {string} nodeId The GLTF node id
  * @param {*} extensions The extensions object
  * @param {*} model The vtk model object
- * @param {GLTFNode} node The GLTF node
  */
-function handlePrimitiveExtensions(extensions, model, node) {
+function handlePrimitiveExtensions(nodeId, extensions, model) {
   const extensionsNames = Object.keys(extensions);
   extensionsNames.forEach(extensionName => {
     const extension = extensions[extensionName];
     switch (extensionName) {
       case 'KHR_materials_variants':
-        model.variantMappings.set(node.id, extension.mappings);
+        model.variantMappings.set(nodeId, extension.mappings);
         break;
       default:
         vtkWarningMacro(`Unhandled extension: ${extensionName}`);
@@ -314,33 +311,43 @@ function handlePrimitiveExtensions(extensions, model, node) {
  * @param {GLTFMesh} mesh - The GLTF mesh
  * @returns {vtkActor} The created VTK actor
  */
-async function createActorFromGTLFNode(model, node, worldMatrix) {
+async function createActorFromGTLFNode(worldMatrix) {
   const actor = vtkActor.newInstance();
   const mapper = vtkMapper.newInstance();
   mapper.setColorModeToDirectScalars();
   actor.setMapper(mapper);
   actor.setUserMatrix(worldMatrix);
-  if (node.mesh !== undefined) {
-    const polyData = await createPolyDataFromGLTFMesh(node.mesh);
-    mapper.setInputData(polyData);
-    const primitive = node.mesh.primitives[0]; // the first one for now
+  const polydata = vtkPolyData.newInstance();
+  mapper.setInputData(polydata);
+  return actor;
+}
 
-    // Support for materials
-    if (primitive.material !== undefined) {
-      await createPropertyFromGLTFMaterial(model, primitive.material, actor);
-    }
-    if (primitive.extensions !== undefined) {
-      handlePrimitiveExtensions(primitive.extensions, model, node);
-    }
-  } else {
-    const polyData = vtkPolyData.newInstance();
-    mapper.setInputData(polyData);
+/**
+ * Creates a VTK actor from a GLTF mesh
+ * @param {GLTFMesh} mesh - The GLTF mesh
+ * @returns {vtkActor} The created VTK actor
+ */
+async function createActorFromGTLFPrimitive(model, primitive, worldMatrix) {
+  const actor = vtkActor.newInstance();
+  const mapper = vtkMapper.newInstance();
+  mapper.setColorModeToDirectScalars();
+  actor.setMapper(mapper);
+  actor.setUserMatrix(worldMatrix);
+  const polydata = await createPolyDataFromGLTFMesh(primitive);
+  mapper.setInputData(polydata);
+
+  // Support for materials
+  if (primitive.material != null) {
+    await createPropertyFromGLTFMaterial(model, primitive.material, actor);
+  }
+  if (primitive.extensions != null) {
+    handlePrimitiveExtensions(`${primitive.name}`, primitive.extensions, model);
   }
   return actor;
 }
 
 /**
- *
+ * Creates a GLTF animation object
  * @param {GLTFAnimation} animation
  * @returns
  */
@@ -366,7 +373,7 @@ function getTransformationMatrix(node) {
   const translation = node.translation ?? vec3.create();
   const rotation = node.rotation ?? quat.create();
   const scale = node.scale ?? vec3.fromValues(1.0, 1.0, 1.0);
-  const matrix = node.matrix !== undefined ? mat4.clone(node.matrix) : mat4.fromRotationTranslationScale(mat4.create(), rotation, translation, scale);
+  const matrix = node.matrix != null ? mat4.clone(node.matrix) : mat4.fromRotationTranslationScale(mat4.create(), rotation, translation, scale);
   return matrix;
 }
 
@@ -384,13 +391,17 @@ async function processNode(node, model) {
   const worldMatrix = mat4.multiply(mat4.create(), parentMatrix, node.transform);
 
   // Create actor for the current node
-  const actor = await createActorFromGTLFNode(model, node, worldMatrix);
-  if (actor) {
-    actor.setUserMatrix(worldMatrix);
+  if (node.mesh != null) {
+    const nodeActor = await createActorFromGTLFNode(worldMatrix);
     if (parentActor) {
-      actor.setParentProp(parentActor);
+      nodeActor.setParentProp(parentActor);
     }
-    model.actors.set(node.id, actor);
+    model.actors.set(`${node.id}`, nodeActor);
+    await Promise.all(node.mesh.primitives.map(async (primitive, i) => {
+      const actor = await createActorFromGTLFPrimitive(model, primitive, worldMatrix);
+      actor.setParentProp(nodeActor);
+      model.actors.set(`${node.id}_${primitive.name}`, actor);
+    }));
   }
 
   // Handle KHRLightsPunctual extension

package/IO/Geometry/GLTFImporter/Utils.js

@@ -153,7 +153,7 @@ function createVTKTextureFromGLTFTexture(image, sampler, extensions) {
         texture.setInterpolate(true);
       }
     } else {
-      texture.MipmapOn();
+      texture.setMipLevel(8);
       texture.setInterpolate(true);
       texture.setEdgeClamp(true);
     }

package/IO/Geometry/IFCImporter.d.ts

@@ -0,0 +1,163 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import HtmlDataAccessHelper from './../Core/DataAccessHelper/HtmlDataAccessHelper';
+import HttpDataAccessHelper from './../Core/DataAccessHelper/HttpDataAccessHelper';
+import JSZipDataAccessHelper from './../Core/DataAccessHelper/JSZipDataAccessHelper';
+import LiteHttpDataAccessHelper from './../Core/DataAccessHelper/LiteHttpDataAccessHelper';
+
+interface IIFCImporterOptions {
+  compression?: string;
+  progressCallback?: any;
+}
+
+/**
+ *
+ */
+export interface IIFCImporterInitialValues {
+  mergeGeometries?: boolean;
+}
+
+type vtkIFCImporterBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkIFCImporter extends vtkIFCImporterBase {
+  /**
+   *
+   */
+  getBaseURL(): string;
+
+  /**
+   *
+   */
+  getDataAccessHelper():
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Get the url of the object to load.
+   */
+  getUrl(): string;
+
+  /**
+   * Import actors into the renderer.
+   * @param {vtkRenderer} renderer The vtkRenderer to import the actors into.
+   */
+  importActors(renderer: vtkRenderer): void;
+
+  /**
+   * Load the object data.
+   * @param {IIFCImporterOptions} [options]
+   */
+  loadData(options?: IIFCImporterOptions): Promise<any>;
+
+  /**
+   * Parse data.
+   * @param {String | ArrayBuffer} content The content to parse.
+   */
+  parse(content: string | ArrayBuffer): void;
+
+  /**
+   * Parse data as ArrayBuffer.
+   * @param {ArrayBuffer} content The content to parse.
+   */
+  parseAsArrayBuffer(content: ArrayBuffer): void;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   *
+   * @param dataAccessHelper
+   */
+  setDataAccessHelper(
+    dataAccessHelper:
+      | HtmlDataAccessHelper
+      | HttpDataAccessHelper
+      | JSZipDataAccessHelper
+      | LiteHttpDataAccessHelper
+  ): boolean;
+
+  /**
+   * Set the url of the object to load.
+   * @param {String} url the url of the object to load.
+   * @param {IIFCImporterOptions} [option] The PLY reader options.
+   */
+  setUrl(url: string, option?: IIFCImporterOptions): Promise<string | any>;
+}
+
+/**
+ * Set WebIFC api to be used by vtkIFCImporter
+ * @param {object} ifcApi
+ */
+export function setIFCAPI(ifcApi: any): void;
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkIFCImporter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IIFCImporterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IIFCImporterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkIFCImporter
+ * @param {IIFCImporterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IIFCImporterInitialValues
+): vtkIFCImporter;
+
+/**
+ * vtkIFCImporter is a source object that reads Industry Foundation Class(IFC) files.
+ *
+ * The vtkIFCImporter is using web-ifc library to parse the IFC file.
+ *
+ * @example
+ * ```js
+ * import vtkResourceLoader from '@kitware/vtk.js/IO/Core/ResourceLoader';
+ * import vtkIFCImporter from '@kitware/vtk.js/IO/Geometry/IFCImporter';
+ *
+ * function update() {
+ *   importer.onReady(() => {
+ *     importer.importActors(renderer);
+ *     renderer.resetCamera();
+ *     renderWindow.render();
+ *   });
+ * }
+ *
+ * vtkResourceLoader
+ * .loadScript('https://cdn.jsdelivr.net/npm/web-ifc@0.0.55/web-ifc-api-iife.js')
+ * .then(() => {
+ *   // Pass WebIFC api to vtkIFCImporter
+ *   vtkIFCImporter.setIFCAPI(window.WebIFC);
+ *
+ *   // Trigger data download
+ *   importer.setUrl(`${__BASE_PATH__}/data/ifc/house.ifc`).then(update);
+ * });
+ * ```
+ */
+export declare const vtkIFCImporter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  setIFCAPI: typeof setIFCAPI;
+};
+export default vtkIFCImporter;

package/IO/Geometry/IFCImporter.js

@@ -0,0 +1,267 @@
+import { m as macro } from '../../macros2.js';
+import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
+import vtkActor from '../../Rendering/Core/Actor.js';
+import vtkMapper from '../../Rendering/Core/Mapper.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+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';
+
+const {
+  vtkErrorMacro
+} = macro;
+let WebIFC;
+
+/**
+ * Set WebIFC api to be used by vtkIFCImporter
+ * @param {object} ifcApi
+ */
+function setIFCAPI(ifcApi) {
+  WebIFC = ifcApi;
+}
+function vtkIFCImporter(publicAPI, model) {
+  model.classHierarchy.push('vtkIFCImporter');
+  const meshes = [];
+
+  /**
+   * Create a vtkPolyData from an IFC mesh object
+   * @param {object} mesh the IFC web mesh object
+   * @returns vtkPolyData
+   */
+  function createPolyDataFromIFCMesh(mesh) {
+    const {
+      vertices,
+      indices
+    } = mesh;
+    const pd = vtkPolyData.newInstance();
+    const cells = vtkCellArray.newInstance();
+    const pointValues = new Float32Array(vertices.length / 2);
+    const normalsArray = new Float32Array(vertices.length / 2);
+    for (let i = 0; i < vertices.length; i += 6) {
+      pointValues[i / 2] = vertices[i];
+      pointValues[i / 2 + 1] = vertices[i + 1];
+      pointValues[i / 2 + 2] = vertices[i + 2];
+      normalsArray[i / 2] = vertices[i + 3];
+      normalsArray[i / 2 + 1] = vertices[i + 4];
+      normalsArray[i / 2 + 2] = vertices[i + 5];
+    }
+    const nCells = indices.length;
+    cells.resize(3 * nCells / 3);
+    for (let cellId = 0; cellId < nCells; cellId += 3) {
+      const cell = indices.slice(cellId, cellId + 3);
+      cells.insertNextCell(cell);
+    }
+    pd.getPoints().setData(pointValues, 3);
+    pd.setStrips(cells);
+    pd.getPointData().setNormals(vtkDataArray.newInstance({
+      name: 'Normals',
+      values: normalsArray,
+      numberOfComponents: 3
+    }));
+    return pd;
+  }
+
+  /**
+   * Create a colored vtkPolyData from an IFC mesh object
+   * @param {object} mesh the IFC mesh object
+   * @returns vtkPolyData
+   */
+  function createColoredPolyDataFromIFCMesh(mesh) {
+    const {
+      vertices,
+      indices,
+      color,
+      userMatrix
+    } = mesh;
+    const pd = vtkPolyData.newInstance();
+    const cells = vtkCellArray.newInstance();
+    const pointValues = new Float32Array(vertices.length / 2);
+    const normalsArray = new Float32Array(vertices.length / 2);
+    const colorArray = new Float32Array(vertices.length / 2);
+    if (userMatrix) {
+      const transformMatrix = vtkMatrixBuilder.buildFromRadian().setMatrix(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);
+        pointValues[i / 2] = point[0];
+        pointValues[i / 2 + 1] = point[1];
+        pointValues[i / 2 + 2] = point[2];
+        normalsArray[i / 2] = normal[0];
+        normalsArray[i / 2 + 1] = normal[1];
+        normalsArray[i / 2 + 2] = normal[2];
+        const colorIndex = i / 2;
+        colorArray[colorIndex] = color.x;
+        colorArray[colorIndex + 1] = color.y;
+        colorArray[colorIndex + 2] = color.z;
+      }
+    } else {
+      for (let i = 0; i < vertices.length; i += 6) {
+        pointValues[i / 2] = vertices[i];
+        pointValues[i / 2 + 1] = vertices[i + 1];
+        pointValues[i / 2 + 2] = vertices[i + 2];
+        normalsArray[i / 2] = vertices[i + 3];
+        normalsArray[i / 2 + 1] = vertices[i + 4];
+        normalsArray[i / 2 + 2] = vertices[i + 5];
+        const colorIndex = i / 2;
+        colorArray[colorIndex] = color.x;
+        colorArray[colorIndex + 1] = color.y;
+        colorArray[colorIndex + 2] = color.z;
+      }
+    }
+    const nCells = indices.length;
+    cells.resize(3 * nCells / 3);
+    for (let cellId = 0; cellId < nCells; cellId += 3) {
+      const cell = indices.slice(cellId, cellId + 3);
+      cells.insertNextCell(cell);
+    }
+    pd.getPoints().setData(pointValues, 3);
+    pd.setPolys(cells);
+    pd.getPointData().setNormals(vtkDataArray.newInstance({
+      name: 'Normals',
+      values: normalsArray,
+      numberOfComponents: 3
+    }));
+    pd.getPointData().setScalars(vtkDataArray.newInstance({
+      name: 'Colors',
+      values: colorArray,
+      numberOfComponents: 3
+    }));
+    return pd;
+  }
+  function parseIfc(content) {
+    const modelID = model._ifcApi.OpenModel(new Uint8Array(content), {
+      COORDINATE_TO_ORIGIN: true,
+      USE_FAST_BOOLS: true
+    });
+    model._ifcApi.StreamAllMeshes(modelID, mesh => {
+      const placedGeometries = mesh.geometries;
+      for (let i = 0; i < placedGeometries.size(); i++) {
+        const placedGeometry = placedGeometries.get(i);
+        const ifcGeometryData = model._ifcApi.GetGeometry(modelID, placedGeometry.geometryExpressID);
+        const ifcVertices = model._ifcApi.GetVertexArray(ifcGeometryData.GetVertexData(), ifcGeometryData.GetVertexDataSize());
+        const ifcIndices = model._ifcApi.GetIndexArray(ifcGeometryData.GetIndexData(), ifcGeometryData.GetIndexDataSize());
+        meshes.push({
+          vertices: ifcVertices,
+          indices: ifcIndices,
+          color: placedGeometry.color,
+          userMatrix: placedGeometry.flatTransformation
+        });
+      }
+    });
+    model._ifcApi.CloseModel(modelID);
+  }
+  if (!model.dataAccessHelper) {
+    model.dataAccessHelper = DataAccessHelper.get('http');
+  }
+  function fetchData(url) {
+    const {
+      compression,
+      progressCallback
+    } = model;
+    return model.dataAccessHelper.fetchBinary(url, {
+      compression,
+      progressCallback
+    });
+  }
+  publicAPI.setUrl = function (url) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      binary: true
+    };
+    model.url = url;
+    model.baseURL = url.split('/').slice(0, -1).join('/');
+    model.compression = options.compression;
+    return publicAPI.loadData(options);
+  };
+  publicAPI.loadData = function () {
+    return fetchData(model.url).then(publicAPI.parse);
+  };
+  publicAPI.parse = content => {
+    publicAPI.parseAsArrayBuffer(content);
+  };
+  publicAPI.parseAsArrayBuffer = content => {
+    if (!content) {
+      vtkErrorMacro('No content to parse.');
+      return;
+    }
+    if (!WebIFC) {
+      vtkErrorMacro('vtkIFCImporter requires WebIFC API to be set.');
+      return;
+    }
+    model._ifcApi = new WebIFC.IfcAPI();
+    model._ifcApi.Init().then(() => {
+      parseIfc(content);
+      publicAPI.invokeReady();
+    });
+  };
+  publicAPI.importActors = renderer => {
+    if (model.mergeGeometries) {
+      const opaqueMeshes = meshes.filter(mesh => mesh.color.w === 1);
+      let apd = vtkAppendPolyData.newInstance();
+      opaqueMeshes.forEach(mesh => {
+        const pd = createColoredPolyDataFromIFCMesh(mesh);
+        apd.addInputData(pd);
+      });
+      let mapper = vtkMapper.newInstance();
+      mapper.setColorModeToDirectScalars();
+      mapper.setInputConnection(apd.getOutputPort());
+      let actor = vtkActor.newInstance();
+      actor.setMapper(mapper);
+      renderer.addActor(actor);
+      const transparentMeshes = meshes.filter(mesh => mesh.color.w < 1);
+      apd = vtkAppendPolyData.newInstance();
+      transparentMeshes.forEach(mesh => {
+        const pd = createColoredPolyDataFromIFCMesh(mesh);
+        apd.addInputData(pd);
+      });
+      mapper = vtkMapper.newInstance();
+      mapper.setColorModeToDirectScalars();
+      mapper.setInputConnection(apd.getOutputPort());
+      actor = vtkActor.newInstance();
+      actor.setMapper(mapper);
+      actor.getProperty().setOpacity(0.5);
+      renderer.addActor(actor);
+    } else {
+      meshes.forEach(mesh => {
+        const pd = createPolyDataFromIFCMesh(mesh);
+        const mapper = vtkMapper.newInstance();
+        mapper.setInputData(pd);
+        const actor = vtkActor.newInstance();
+        actor.setMapper(mapper);
+        const {
+          x,
+          y,
+          z,
+          w
+        } = mesh.color;
+        actor.getProperty().setColor(x, y, z);
+        actor.getProperty().setOpacity(w);
+        actor.setUserMatrix(mesh.userMatrix);
+        renderer.addActor(actor);
+      });
+    }
+  };
+}
+const DEFAULT_VALUES = {
+  mergeGeometries: false
+};
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.obj(publicAPI, model);
+  macro.get(publicAPI, model, ['url', 'baseURL']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper', 'mergeGeometries']);
+  macro.event(publicAPI, model, 'ready');
+  macro.algo(publicAPI, model, 0, 1);
+  vtkIFCImporter(publicAPI, model);
+}
+const newInstance = macro.newInstance(extend, 'vtkIFCImporter');
+var vtkIFCImporter$1 = {
+  newInstance,
+  extend,
+  setIFCAPI
+};
+
+export { vtkIFCImporter$1 as default, extend, newInstance };

package/IO/Geometry.js

@@ -4,6 +4,7 @@ import vtkDracoReader from './Geometry/DracoReader.js';
 import vtkSTLWriter from './Geometry/STLWriter.js';
 import vtkPLYWriter from './Geometry/PLYWriter.js';
 import vtkGLTFImporter from './Geometry/GLTFImporter.js';
+import vtkIFCImporter from './Geometry/IFCImporter.js';
 
 var Geometry = {
   vtkSTLReader,
@@ -11,7 +12,8 @@ var Geometry = {
   vtkDracoReader,
   vtkSTLWriter,
   vtkPLYWriter,
-  vtkGLTFImporter
+  vtkGLTFImporter,
+  vtkIFCImporter
 };
 
 export { Geometry as default };

package/IO/Image/TIFFReader.d.ts

@@ -0,0 +1,133 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import HtmlDataAccessHelper from './../Core/DataAccessHelper/HtmlDataAccessHelper';
+import HttpDataAccessHelper from './../Core/DataAccessHelper/HttpDataAccessHelper';
+import JSZipDataAccessHelper from './../Core/DataAccessHelper/JSZipDataAccessHelper';
+import LiteHttpDataAccessHelper from './../Core/DataAccessHelper/LiteHttpDataAccessHelper';
+
+interface ITIFFReaderOptions {
+  compression?: string;
+  progressCallback?: any;
+  flipY?: boolean;
+}
+
+/**
+ *
+ */
+export interface ITIFFReaderInitialValues {}
+
+type vtkTIFFReaderBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkTIFFReader extends vtkTIFFReaderBase {
+  /**
+   * Get the base url.
+   */
+  getBaseURL(): string;
+
+  /**
+   * Get if the image is flipped vertically.
+   */
+  getFlipY(): boolean;
+
+  /**
+   * Get the dataAccess helper.
+   */
+  getDataAccessHelper():
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Get the url of the object to load.
+   */
+  getUrl(): string;
+
+  /**
+   * Load the object data.
+   * @param {ITIFFReaderOptions} [options]
+   */
+  loadData(options?: ITIFFReaderOptions): Promise<any>;
+
+  /**
+   * Parse data.
+   * @param {ArrayBuffer} content The content to parse.
+   */
+  parse(content: ArrayBuffer): void;
+
+  /**
+   * Parse data as ArrayBuffer.
+   * @param {ArrayBuffer} content The content to parse.
+   */
+  parseAsArrayBuffer(content: ArrayBuffer): void;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Flip the image vertically.
+   * @param {String} flipY If true, flip the image vertically.
+   */
+  setFlipY(flipY: boolean): boolean;
+
+  /**
+   *
+   * @param dataAccessHelper
+   */
+  setDataAccessHelper(
+    dataAccessHelper:
+      | HtmlDataAccessHelper
+      | HttpDataAccessHelper
+      | JSZipDataAccessHelper
+      | LiteHttpDataAccessHelper
+  ): boolean;
+
+  /**
+   * Set the url of the object to load.
+   * @param {String} url the url of the object to load.
+   * @param {ITIFFReaderOptions} [option] The PLY reader options.
+   */
+  setUrl(url: string, option?: ITIFFReaderOptions): Promise<string | any>;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkTIFFReader characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITIFFReaderInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITIFFReaderInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkTIFFReader
+ * @param {ITIFFReaderInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ITIFFReaderInitialValues
+): vtkTIFFReader;
+
+/**
+ * vtkTIFFReader is a source object that reads TIFF files.
+ */
+export declare const vtkTIFFReader: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkTIFFReader;

package/IO/Image/TIFFReader.js

@@ -0,0 +1,144 @@
+import { m as macro } from '../../macros2.js';
+import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
+import vtkImageData from '../../Common/DataModel/ImageData.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import UTIF from 'utif';
+
+// ----------------------------------------------------------------------------
+// vtkTIFFReader methods
+// ----------------------------------------------------------------------------
+
+function vtkTIFFReader(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTIFFReader');
+
+  // Create default dataAccessHelper if not available
+  if (!model.dataAccessHelper) {
+    model.dataAccessHelper = DataAccessHelper.get('http');
+  }
+
+  // Internal method to fetch Array
+  function fetchData(url) {
+    const {
+      compression,
+      progressCallback
+    } = model;
+    return model.dataAccessHelper.fetchBinary(url, {
+      compression,
+      progressCallback
+    });
+  }
+
+  // Set DataSet url
+  publicAPI.setUrl = function (url) {
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      binary: true
+    };
+    model.url = url;
+
+    // Remove the file in the URL
+    const path = url.split('/');
+    path.pop();
+    model.baseURL = path.join('/');
+    model.compression = option.compression;
+
+    // Fetch metadata
+    return publicAPI.loadData({
+      progressCallback: option.progressCallback
+    });
+  };
+
+  // Fetch the actual data arrays
+  publicAPI.loadData = function () {
+    const promise = fetchData(model.url);
+    promise.then(publicAPI.parse);
+    return promise;
+  };
+  publicAPI.parse = content => {
+    publicAPI.parseAsArrayBuffer(content);
+  };
+  publicAPI.parseAsArrayBuffer = content => {
+    if (!content) {
+      return;
+    }
+
+    // Read Header
+    const ifds = UTIF.decode(content);
+    UTIF.decodeImage(content, ifds[0]);
+    const data = UTIF.toRGBA8(ifds[0]);
+    const width = ifds[0].width;
+    const height = ifds[0].height;
+    const output = new Uint8Array(data.length);
+    if (model.flipY) {
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const srcIndex = (y * width + x) * 4;
+          const destIndex = ((height - y - 1) * width + x) * 4;
+          output[destIndex] = data[srcIndex]; // R
+          output[destIndex + 1] = data[srcIndex + 1]; // G
+          output[destIndex + 2] = data[srcIndex + 2]; // B
+          output[destIndex + 3] = data[srcIndex + 3]; // A
+        }
+      }
+    }
+
+    const dataExtent = [0, width - 1, 0, height - 1];
+    const dataSpacing = [1, 1, 1];
+    const imageData = vtkImageData.newInstance();
+    imageData.setDimensions(width, height, 1);
+    imageData.setExtent(dataExtent);
+    imageData.setSpacing(dataSpacing);
+    const dataArray = vtkDataArray.newInstance({
+      name: 'TIFFImage',
+      numberOfComponents: 4,
+      values: output
+    });
+    imageData.getPointData().setScalars(dataArray);
+    model.output[0] = imageData;
+  };
+  publicAPI.requestData = (inData, outData) => {
+    publicAPI.parse(model.parseData);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  flipY: true,
+  compression: null,
+  progressCallback: null
+};
+
+// ----------------------------------------------------------------------------
+
+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, 0, 1);
+  macro.get(publicAPI, model, ['url', 'baseURL']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper', 'flipY']);
+
+  // Object specific methods
+  vtkTIFFReader(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTIFFReader');
+
+// ----------------------------------------------------------------------------
+
+var vtkTIFFReader$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTIFFReader$1 as default, extend, newInstance };

package/IO/Image.js

@@ -1,9 +1,11 @@
 import vtkHDRReader from './Image/HDRReader.js';
 import vtkTGAReader from './Image/TGAReader.js';
+import vtkTIFFReader from './Image/TIFFReader.js';
 
 var index = {
   vtkHDRReader,
-  vtkTGAReader
+  vtkTGAReader,
+  vtkTIFFReader
 };
 
 export { index as default };

package/Widgets/Widgets3D/AngleWidget/behavior.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../../macros2.js';
 import { k as add } from '../../../Common/Core/Math/index.js';
+import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkPointPicker from '../../../Rendering/Core/PointPicker.js';
 
 const MAX_POINTS = 3;
@@ -8,6 +9,7 @@ function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
   const picker = vtkPointPicker.newInstance();
   picker.setPickFromList(1);
+  publicAPI.getBounds = () => model.widgetState.getHandleList().reduce((bounds, handle) => vtkBoundingBox.inflate(vtkBoundingBox.addPoint(bounds, ...handle.getOrigin()), publicAPI.getScaleInPixels() ? 0 : handle.getScale1() / 2), [...vtkBoundingBox.INIT_BOUNDS]);
 
   // --------------------------------------------------------------------------
   // Display 2D

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -342,6 +342,23 @@ function widgetBehavior(publicAPI, model) {
     };
   };
 
+  /**
+   * Rotate a line by a specified angle
+   * @param {string} lineName The line name to rotate (e.g. YinX, ZinX, XinY, ZinY, XinZ, YinZ)
+   * @param {Number} radianAngle Applied angle in radian
+   */
+  publicAPI.setViewPlane = (viewType, normal, viewUp) => {
+    let newViewUp = viewUp;
+    if (newViewUp == null) {
+      newViewUp = model.widgetState.getPlanes()[viewType].viewUp;
+    }
+    model.widgetState.getPlanes()[viewType] = {
+      normal,
+      viewUp: newViewUp
+    };
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
+  };
+
   // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -113,6 +113,7 @@ function rotateVector(vectorToBeRotated, axis, angle) {
 }
 
 /**
+ * Return ['X'] if there are only 1 plane defined in the widget state.
  * Return ['X', 'Y'] if there are only 2 planes defined in the widget state.
  * Return ['X', 'Y', 'Z'] if there are 3 planes defined in the widget state.
  * @param {object} widgetState the state of the widget

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -290,6 +290,9 @@ function widgetBehavior(publicAPI, model) {
       const up = model._camera.getViewUp();
       const right = [];
       vec3.cross(right, up, normal);
+      vtkMath.normalize(right);
+      vec3.cross(up, normal, right);
+      vtkMath.normalize(up);
       model.shapeHandle.setUp(up);
       model.shapeHandle.setRight(right);
       model.shapeHandle.setDirection(normal);

package/index.d.ts

@@ -93,12 +93,14 @@
 /// <reference path="./IO/Core/WSLinkClient.d.ts" />
 /// <reference path="./IO/Geometry/DracoReader.d.ts" />
 /// <reference path="./IO/Geometry/GLTFImporter.d.ts" />
+/// <reference path="./IO/Geometry/IFCImporter.d.ts" />
 /// <reference path="./IO/Geometry/PLYReader.d.ts" />
 /// <reference path="./IO/Geometry/PLYWriter.d.ts" />
 /// <reference path="./IO/Geometry/STLReader.d.ts" />
 /// <reference path="./IO/Geometry/STLWriter.d.ts" />
 /// <reference path="./IO/Image/HDRReader.d.ts" />
 /// <reference path="./IO/Image/TGAReader.d.ts" />
+/// <reference path="./IO/Image/TIFFReader.d.ts" />
 /// <reference path="./IO/Misc/ElevationReader.d.ts" />
 /// <reference path="./IO/Misc/GCodeReader.d.ts" />
 /// <reference path="./IO/Misc/ITKImageReader.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "32.7.1",
+  "version": "32.8.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -43,6 +43,7 @@
     "shelljs": "0.8.5",
     "spark-md5": "3.0.2",
     "stream-browserify": "3.0.0",
+    "utif": "3.1.0",
     "webworker-promise": "0.5.0",
     "worker-loader": "3.0.8",
     "xmlbuilder2": "3.0.2"