@kitware/vtk.js 32.7.2 → 32.8.1

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/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/IO/XML/XMLPolyDataWriter.js

@@ -36,6 +36,7 @@ function vtkXMLPolyDataWriter(publicAPI, model) {
     });
     publicAPI.processDataSetAttributes(piece, 'PointData', dataObject.getPointData());
     publicAPI.processDataSetAttributes(piece, 'CellData', dataObject.getCellData());
+    publicAPI.processDataSetAttributes(piece, 'FieldData', dataObject.getFieldData());
     publicAPI.processDataArray(piece.ele('Points'), dataObject.getPoints());
     POLYDATA_FIELDS.forEach(cellType => {
       const cellTypeName = camelize(cellType);

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.2",
+  "version": "32.8.1",
   "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"