@kitware/vtk.js 32.6.2 → 32.7.1

package/IO/Geometry/GLTFImporter.d.ts

@@ -0,0 +1,266 @@
+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';
+
+import vtkActor from './../../Rendering/Core/Actor';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkCamera from './../../Rendering/Core/Camera';
+
+interface IGLTFImporterOptions {
+  binary?: boolean;
+  compression?: string;
+  progressCallback?: any;
+}
+
+export interface IGLTFAnimation {
+  id: string;
+  name: string;
+  channels: any[];
+  samplers: any[];
+}
+
+export interface IGLTFAnimationMixer {
+  addAnimation: (glTFAnimation: object) => void;
+  play: (name: string, weight?: number) => void;
+  stop: (name: string) => void;
+  stopAll: () => void;
+  update: (deltaTime: number) => void;
+}
+
+export interface IGLTFMaterialVariant {
+  material: number;
+  variants: number[];
+}
+
+/**
+ *
+ */
+export interface IGLTFImporterInitialValues {}
+
+type vtkGLTFImporterBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkGLTFImporter extends vtkGLTFImporterBase {
+  /**
+   * Get the actors.
+   */
+  getActors(): Map<string, vtkActor>;
+
+  /**
+   * Get the animation mixer.
+   */
+  getAnimationMixer(): IGLTFAnimationMixer;
+
+  /**
+   * Get the animations.
+   */
+  getAnimations(): IGLTFAnimation[];
+
+  /**
+   * Get the base url.
+   */
+  getBaseURL(): string;
+
+  /**
+   * Get the cameras.
+   */
+  getCameras(): Map<string, vtkCamera>;
+
+  /**
+   *
+   */
+  getDataAccessHelper():
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Get the url of the object to load.
+   */
+  getUrl(): string;
+
+  /**
+   * Get the variant array.
+   */
+  getVariants(): string[];
+
+  /**
+   * Get the variant mappings.
+   */
+  getVariantMappings(): Map<string, IGLTFMaterialVariant[]>;
+
+  /**
+   * Import the actors.
+   */
+  importActors(): void;
+
+  /**
+   * Import the animations.
+   */
+  importAnimations(): void;
+
+  /**
+   * Import the cameras.
+   */
+  importCameras(): void;
+
+  /**
+   * Import the lights.
+   */
+  importLights(): void;
+
+  /**
+   * Invoke the ready event.
+   */
+  invokeReady(): void;
+
+  /**
+   * Load the object data.
+   * @param {IGLTFImporterOptions} [options]
+   */
+  loadData(options?: IGLTFImporterOptions): Promise<any>;
+
+  /**
+   *
+   * @param callback
+   */
+  onReady(callback: () => void): void;
+
+  /**
+   * 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;
+
+  /**
+   * Parse data as text.
+   * @param {String} content The content to parse.
+   */
+  parseAsText(content: string): 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 {IGLTFImporterOptions} [option] The Draco reader options.
+   */
+  setUrl(url: string, option?: IGLTFImporterOptions): Promise<string | any>;
+
+  /**
+   * Set the camera id.
+   * @param cameraId
+   */
+  setCamera(cameraId: string): void;
+
+  /**
+   * Set the Draco decoder.
+   * @param mappings
+   */
+  setDracoDecoder(decoder: any): void;
+
+  /**
+   * Set the vtk Renderer.
+   * @param renderer
+   */
+  setRenderer(renderer: vtkRenderer): void;
+
+  /**
+   * Switch to a variant.
+   * @param variantIndex
+   */
+  switchToVariant(variantIndex: number): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkGLTFImporter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IGLTFImporterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IGLTFImporterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkGLTFImporter
+ * @param {IGLTFImporterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IGLTFImporterInitialValues
+): vtkGLTFImporter;
+
+/**
+ * Load the WASM decoder from url and set the decoderModule
+ * @param url
+ * @param binaryName
+ */
+export function setWasmBinary(
+  url: string,
+  binaryName: string
+): Promise<boolean>;
+
+/**
+ * vtkGLTFImporter can import glTF 2.0 files.
+ *
+ * The GL Transmission Format (glTF) is an API-neutral runtime asset delivery
+ * format. A glTF asset is represented by:
+ * * A JSON-formatted file (.gltf) containing a full scene description: node
+ *   hierarchy, materials, cameras, as well as descriptor information for
+ *   meshes, animations, and other constructs
+ * * Binary files (.bin) containing geometry and animation data, and other
+ *   buffer-based data
+ * * Image files (.jpg, .png) for textures
+ *
+ * Supported extensions:
+ * * KHR_draco_mesh_compression
+ * * KHR_lights_punctual
+ * * KHR_materials_unlit
+ * * KHR_materials_ior
+ * * KHR_materials_specular
+ * * KHR_materials_variants
+ * * EXT_texture_webp
+ * * EXT_texture_avif
+ */
+export declare const vtkGLTFImporter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkGLTFImporter;

package/IO/Geometry/GLTFImporter.js

@@ -0,0 +1,245 @@
+import { m as macro } from '../../macros2.js';
+import BinaryHelper from '../Core/BinaryHelper.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
+import vtkDracoReader from './DracoReader.js';
+import { parseGLTF, createVTKObjects, GLTFCameraToVTKCamera, applyTransformToCamera, createPropertyFromGLTFMaterial } from './GLTFImporter/Reader.js';
+import parseGLB from './GLTFImporter/Decoder.js';
+import { createAnimationMixer } from './GLTFImporter/Animations.js';
+import { BINARY_HEADER_MAGIC } from './GLTFImporter/Constants.js';
+
+const {
+  vtkDebugMacro,
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkGLTFImporter methods
+// ----------------------------------------------------------------------------
+
+function vtkGLTFImporter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkGLTFImporter');
+
+  // Create default dataAccessHelper if not available
+  if (!model.dataAccessHelper) {
+    model.dataAccessHelper = DataAccessHelper.get('http');
+  }
+
+  // Internal method to fetch Array
+  function fetchData(url) {
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      compression,
+      progressCallback
+    } = model;
+    if (option.binary) {
+      return model.dataAccessHelper.fetchBinary(url, {
+        compression,
+        progressCallback
+      });
+    }
+    return model.dataAccessHelper.fetchText(publicAPI, 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;
+    model.sceneId = option.sceneId ? option.sceneId : 0;
+
+    // Fetch metadata
+    return publicAPI.loadData({
+      progressCallback: option.progressCallback,
+      binary: !!option.binary
+    });
+  };
+
+  // Fetch the actual data arrays
+  publicAPI.loadData = function () {
+    let option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const promise = fetchData(model.url, option);
+    promise.then(publicAPI.parse);
+    return promise;
+  };
+  publicAPI.parse = content => {
+    if (typeof content === 'string') {
+      publicAPI.parseAsText(content);
+    } else {
+      publicAPI.parseAsBinary(content);
+    }
+  };
+  publicAPI.parseAsBinary = async content => {
+    if (!content) {
+      return;
+    }
+    if (content !== model.parseData) {
+      publicAPI.modified();
+    } else {
+      return;
+    }
+    const glTF = {};
+    const options = {
+      baseUri: model.baseURL
+    };
+    const magic = BinaryHelper.arrayBufferToString(new Uint8Array(content, 0, 4));
+    if (magic === BINARY_HEADER_MAGIC) {
+      const {
+        json,
+        buffers
+      } = parseGLB(content);
+      vtkDebugMacro('Loaded GLB', json, buffers);
+      glTF.glbBuffers = buffers;
+      glTF.json = json;
+    } else {
+      glTF.json = JSON.parse(BinaryHelper.arrayBufferToString(content));
+    }
+    if (glTF.json.asset === undefined || glTF.json.asset.version[0] < 2) {
+      vtkErrorMacro('Unsupported asset. glTF versions >=2.0 are supported.');
+      return;
+    }
+    model.glTFTree = await parseGLTF(glTF, options);
+    model.actors = new Map();
+    model.cameras = new Map();
+    model.lights = new Map();
+    model.animations = [];
+    model.variants = [];
+    model.variantMappings = new Map();
+    await createVTKObjects(model);
+    model.scenes = model.glTFTree.scenes;
+    publicAPI.invokeReady();
+  };
+  publicAPI.parseAsText = content => {
+    if (!content) {
+      return;
+    }
+    if (content !== model.parseData) {
+      publicAPI.modified();
+    } else {
+      return;
+    }
+    model.parseData = content;
+  };
+  publicAPI.requestData = (inData, outData) => {
+    publicAPI.parse(model.parseData);
+  };
+  publicAPI.setDracoDecoder = decoder => {
+    vtkDracoReader.setDracoDecoder(decoder);
+  };
+  publicAPI.importActors = () => {
+    // Add actors to renderer
+    model.actors.forEach(actor => model.renderer.addActor(actor));
+  };
+  publicAPI.importCameras = () => {
+    // Set up camera
+    model.glTFTree.cameras?.forEach(glTFcamera => {
+      const camera = GLTFCameraToVTKCamera(glTFcamera);
+      model.cameras.set(glTFcamera.id, camera);
+    });
+    model.scenes.forEach(scene => {
+      scene.nodes.forEach(node => {
+        const camera = model.cameras.get(node.camera?.id);
+        if (camera) {
+          applyTransformToCamera(camera, node.transform);
+        }
+      });
+    });
+  };
+  publicAPI.importAnimations = () => {
+    // Set up animations
+    if (model.glTFTree.animations?.length > 0) {
+      model.animationMixer = createAnimationMixer(model.actors, model.glTFTree.accessors);
+      model.glTFTree.animations.forEach(animation => {
+        model.animationMixer.addAnimation(animation);
+      });
+    }
+    model.animations = model.glTFTree.animations || [];
+  };
+  publicAPI.importLights = () => {
+    // Set up lights
+    model.lights?.forEach(light => {
+      vtkDebugMacro('Adding light', light);
+      model.renderer.addLight(light);
+    });
+  };
+  publicAPI.setCamera = cameraId => {
+    const camera = model.cameras.get(cameraId);
+    if (!camera) {
+      vtkErrorMacro(`Camera ${cameraId} not found`);
+      return;
+    }
+    vtkDebugMacro('Setting camera', camera);
+    model.renderer.setActiveCamera(camera);
+  };
+  publicAPI.switchToVariant = async variantIndex => {
+    const promises = Array.from(model.actors).map(async _ref => {
+      let [nodeId, actor] = _ref;
+      vtkDebugMacro('Switching to variant', variantIndex, 'for node', nodeId);
+      const variantMappings = model.variantMappings.get(nodeId);
+      if (variantMappings) {
+        const mapping = variantMappings.find(m => m.variants.includes(variantIndex));
+        if (mapping) {
+          const variantMaterial = model.glTFTree.materials[mapping.material];
+          await createPropertyFromGLTFMaterial(model, variantMaterial, actor);
+        }
+      }
+    });
+    await Promise.all(promises);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  // baseURL: null,
+  // dataAccessHelper: null,
+  // url: null,
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.get(publicAPI, model, ['url', 'baseURL', 'actors', 'scenes', 'cameras', 'animations', 'animationMixer', 'variants', 'variantMappings']);
+  macro.set(publicAPI, model, ['renderer', 'dracoDecoder']);
+  macro.event(publicAPI, model, 'ready');
+
+  // vtkGLTFImporter methods
+  vtkGLTFImporter(publicAPI, model);
+
+  // To support destructuring
+  if (!model.compression) {
+    model.compression = null;
+  }
+  if (!model.progressCallback) {
+    model.progressCallback = null;
+  }
+}
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkGLTFImporter');
+
+// ----------------------------------------------------------------------------
+
+var vtkGLTFImporter$1 = {
+  extend,
+  newInstance
+};
+
+export { vtkGLTFImporter$1 as default, extend, newInstance };

package/IO/Geometry.js

@@ -3,13 +3,15 @@ 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';
 
 var Geometry = {
   vtkSTLReader,
   vtkPLYReader,
   vtkDracoReader,
   vtkSTLWriter,
-  vtkPLYWriter
+  vtkPLYWriter,
+  vtkGLTFImporter
 };
 
 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/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRollManipulator methods

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
-import { C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 
 const {

package/Rendering/Core/Prop3D.js

@@ -1,7 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { C as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
 const VTK_EPSILON = 1e-6;

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import Constants from './RenderWindowInteractor/Constants.js';
 
 const {