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

package/IO/Geometry/IFCImporter.js

@@ -0,0 +1,270 @@
+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';
+import { mat3 } from 'gl-matrix';
+
+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);
+      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);
+        normalMatrix.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);
+      const oapd = vtkAppendPolyData.newInstance();
+      opaqueMeshes.forEach(mesh => {
+        const pd = createColoredPolyDataFromIFCMesh(mesh);
+        oapd.addInputData(pd);
+      });
+      let mapper = vtkMapper.newInstance();
+      mapper.setColorModeToDirectScalars();
+      mapper.setInputConnection(oapd.getOutputPort());
+      let actor = vtkActor.newInstance();
+      actor.setMapper(mapper);
+      renderer.addActor(actor);
+      const transparentMeshes = meshes.filter(mesh => mesh.color.w < 1);
+      const tapd = vtkAppendPolyData.newInstance();
+      transparentMeshes.forEach(mesh => {
+        const pd = createColoredPolyDataFromIFCMesh(mesh);
+        tapd.addInputData(pd);
+      });
+      mapper = vtkMapper.newInstance();
+      mapper.setColorModeToDirectScalars();
+      mapper.setInputConnection(tapd.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/STLReader.d.ts

@@ -46,6 +46,11 @@ export interface vtkSTLReader extends vtkSTLReaderBase {
    */
   getUrl(): string;
 
+  /**
+   * Get tolerance when removeDuplicateVertices is set
+   */
+  getRemoveDuplicateVertices(): number;
+
   /**
    * Load the object data.
    * @param {ISTLReaderOptions} [options]
@@ -94,6 +99,15 @@ export interface vtkSTLReader extends vtkSTLReaderBase {
    * @param {ISTLReaderOptions} [option] The STL reader options.
    */
   setUrl(url: string, option?: ISTLReaderOptions): Promise<string | any>;
+
+  /**
+   * Turn on/off automatic removeDuplicateVertices
+   * After reading the STL file, if `tolerance` is >= 0, then points with the same coordinates at 10 power tolerance are merged.
+   * For a smooth rendering, you might want to compute normals with vtkPolyDataNormals.
+   *
+   *  @param {Number} tolerance
+   */
+  setRemoveDuplicateVertices(tolerance: number): boolean;
 }
 
 /**

package/IO/Geometry/STLReader.js

@@ -103,6 +103,55 @@ function vtkSTLReader(publicAPI, model) {
       progressCallback
     });
   }
+  function removeDuplicateVertices(tolerance) {
+    const polydata = model.output[0];
+    const points = polydata.getPoints().getData();
+    const faces = polydata.getPolys().getData();
+    if (!points || !faces) {
+      console.warn('No valid polydata.');
+      return;
+    }
+    const vMap = new Map();
+    const vIndexMap = new Map();
+    let vInc = 0;
+    let pointsChanged = false;
+    for (let i = 0; i < points.length; i += 3) {
+      const k1 = (points[i] * 10 ** tolerance).toFixed(0);
+      const k2 = (points[i + 1] * 10 ** tolerance).toFixed(0);
+      const k3 = (points[i + 2] * 10 ** tolerance).toFixed(0);
+      const key = `${k1},${k2},${k3}`;
+      if (vMap.get(key) !== undefined) {
+        vIndexMap.set(i / 3, vMap.get(key));
+        pointsChanged = true;
+      } else {
+        vIndexMap.set(i / 3, vInc);
+        vMap.set(key, vInc);
+        vInc++;
+      }
+    }
+    const outVerts = new Float32Array(vMap.size * 3);
+    const keys = Array.from(vMap.keys());
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      const j = vMap.get(k) * 3;
+      const coords = k.split(',').map(e => +e * 10 ** -tolerance);
+      outVerts[j] = coords[0];
+      outVerts[j + 1] = coords[1];
+      outVerts[j + 2] = coords[2];
+    }
+    const outFaces = new Int32Array(faces);
+    for (let i = 0; i < faces.length; i += 4) {
+      outFaces[i] = 3;
+      outFaces[i + 1] = vIndexMap.get(faces[i + 1]);
+      outFaces[i + 2] = vIndexMap.get(faces[i + 2]);
+      outFaces[i + 3] = vIndexMap.get(faces[i + 3]);
+    }
+    polydata.getPoints().setData(outVerts);
+    polydata.getPolys().setData(outFaces);
+    if (pointsChanged) {
+      publicAPI.modified();
+    }
+  }
 
   // Set DataSet url
   publicAPI.setUrl = function (url) {
@@ -251,6 +300,9 @@ function vtkSTLReader(publicAPI, model) {
 
     // Add new output
     model.output[0] = polydata;
+    if (model.removeDuplicateVertices >= 0) {
+      removeDuplicateVertices(model.removeDuplicateVertices);
+    }
   };
   publicAPI.parseAsText = content => {
     if (!content) {
@@ -281,6 +333,9 @@ function vtkSTLReader(publicAPI, model) {
 
     // Add new output
     model.output[0] = polydata;
+    if (model.removeDuplicateVertices >= 0) {
+      removeDuplicateVertices(model.removeDuplicateVertices);
+    }
   };
   publicAPI.requestData = (inData, outData) => {
     publicAPI.parse(model.parseData);
@@ -295,6 +350,7 @@ const DEFAULT_VALUES = {
   // baseURL: null,
   // dataAccessHelper: null,
   // url: null,
+  removeDuplicateVertices: -1
 };
 
 // ----------------------------------------------------------------------------
@@ -306,7 +362,7 @@ function extend(publicAPI, model) {
   // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url', 'baseURL']);
-  macro.setGet(publicAPI, model, ['dataAccessHelper']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper', 'removeDuplicateVertices']);
   macro.algo(publicAPI, model, 0, 1);
 
   // vtkSTLReader methods

package/IO/Geometry.js

@@ -3,13 +3,17 @@ import vtkPLYReader from './Geometry/PLYReader.js';
 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,
   vtkPLYReader,
   vtkDracoReader,
   vtkSTLWriter,
-  vtkPLYWriter
+  vtkPLYWriter,
+  vtkGLTFImporter,
+  vtkIFCImporter
 };
 
 export { Geometry as default };

package/IO/Image/HDRReader/Utils.js

@@ -1,4 +1,4 @@
-import { A as ldexp } from '../../../Common/Core/Math/index.js';
+import { B as ldexp } from '../../../Common/Core/Math/index.js';
 
 /**
  * Read a line from a Uint8Array

package/IO/Image/HDRReader.js

@@ -1,7 +1,7 @@
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 import { m as macro } from '../../macros2.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
-import { B as xyz2rgb } from '../../Common/Core/Math/index.js';
+import { C as xyz2rgb } from '../../Common/Core/Math/index.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { readLine, rgbe2float } from './HDRReader/Utils.js';

package/IO/Image/TGAReader/Constants.js

@@ -0,0 +1,28 @@
+const TYPE_INDEXED = 1;
+const TYPE_RGB = 2;
+const TYPE_GREY = 3;
+const TYPE_RLE_INDEXED = 9;
+const TYPE_RLE_RGB = 10;
+const TYPE_RLE_GREY = 11;
+const ORIGIN_MASK = 0x30;
+const ORIGIN_SHIFT = 0x04;
+const ORIGIN_BL = 0x00;
+const ORIGIN_BR = 0x01;
+const ORIGIN_UL = 0x02;
+const ORIGIN_UR = 0x03;
+var Constants = {
+  TYPE_INDEXED,
+  TYPE_RGB,
+  TYPE_GREY,
+  TYPE_RLE_INDEXED,
+  TYPE_RLE_RGB,
+  TYPE_RLE_GREY,
+  ORIGIN_MASK,
+  ORIGIN_SHIFT,
+  ORIGIN_BL,
+  ORIGIN_BR,
+  ORIGIN_UL,
+  ORIGIN_UR
+};
+
+export { Constants as default };

package/IO/Image/TGAReader.d.ts

@@ -0,0 +1,121 @@
+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 ITGAReaderOptions {
+  compression?: string;
+  progressCallback?: any;
+}
+
+/**
+ *
+ */
+export interface ITGAReaderInitialValues {}
+
+type vtkTGAReaderBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkTGAReader extends vtkTGAReaderBase {
+  /**
+   * Get the base url.
+   */
+  getBaseURL(): string;
+
+  /**
+   * Get the dataAccess helper.
+   */
+  getDataAccessHelper():
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Get the url of the object to load.
+   */
+  getUrl(): string;
+
+  /**
+   * Load the object data.
+   * @param {ITGAReaderOptions} [options]
+   */
+  loadData(options?: ITGAReaderOptions): 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;
+
+  /**
+   *
+   * @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 {ITGAReaderOptions} [option] The PLY reader options.
+   */
+  setUrl(url: string, option?: ITGAReaderOptions): Promise<string | any>;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkTGAReader characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITGAReaderInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITGAReaderInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkTGAReader
+ * @param {ITGAReaderInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ITGAReaderInitialValues
+): vtkTGAReader;
+
+/**
+ * vtkTGAReader is a source object that reads Truevision Targa(TGA) files.
+ */
+export declare const vtkTGAReader: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkTGAReader;