@kitware/vtk.js 32.0.0 → 32.1.0

package/Common/DataModel/Box.d.ts

@@ -1,5 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Bounds, Vector3 } from './../../types';
+import vtkImplicitFunction from './ImplicitFunction';
 
 export interface IBoxInitialValues {
   bbox?: Bounds;
@@ -12,7 +13,7 @@ export interface IBoxIntersections {
   x2: Vector3;
 }
 
-export interface vtkBox extends vtkObject {
+export interface vtkBox extends vtkImplicitFunction {
   /**
    * Add the bounds for the box.
    * @param {Bounds} bounds

package/Common/DataModel/Box.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from './BoundingBox.js';
+import vtkImplicitFunction from './ImplicitFunction.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -202,7 +203,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods
-  macro.obj(publicAPI, model);
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
   vtkBox(publicAPI, model);
 }
 

package/Common/DataModel/Cone.d.ts

@@ -13,7 +13,7 @@ export interface vtkCone extends vtkObject {
    * Given the point x evaluate the cone equation.
    * @param {Vector3} x The point coordinate.
    */
-  evaluateFunction(x: Vector3): number[];
+  evaluateFunction(x: Vector3): number;
 
   /**
    * Given the point x evaluate the equation for the cone gradient.
@@ -54,11 +54,7 @@ export function newInstance(initialValues?: IConeInitialValues): vtkCone;
 
 /**
  * vtkCone computes the implicit function and/or gradient for a cone. vtkCone is
- * a concrete implementation of vtkImplicitFunction. TODO: Currently the cone's
- * axis of rotation is along the x-axis with the apex at the origin. To
- * transform this to a different location requires the application of a
- * transformation matrix. This can be performed by supporting transforms at the
- * implicit function level, and should be added.
+ * a concrete implementation of vtkImplicitFunction.
  */
 export declare const vtkCone: {
   newInstance: typeof newInstance;

package/Common/DataModel/Cone.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import { r as radiansFromDegrees } from '../Core/Math/index.js';
+import vtkImplicitFunction from './ImplicitFunction.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -42,7 +43,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods
-  macro.obj(publicAPI, model);
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['angle']);
   vtkCone(publicAPI, model);
 }

package/Common/DataModel/Cylinder.d.ts

@@ -1,5 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Vector3 } from './../../types';
+import vtkImplicitFunction from './ImplicitFunction';
 
 /**
  *
@@ -10,13 +11,13 @@ export interface ICylinderInitialValues {
   axis?: number[];
 }
 
-export interface vtkCylinder extends vtkObject {
+export interface vtkCylinder extends vtkImplicitFunction {
   /**
    * Given the point xyz (three floating value) evaluate the cylinder
    * equation.
    * @param {Vector3} xyz The point coordinate.
    */
-  evaluateFunction(xyz: Vector3): number[];
+  evaluateFunction(xyz: Vector3): number;
 
   /**
    * Given the point xyz (three floating values) evaluate the equation for the

package/Common/DataModel/Cylinder.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import { d as dot } from '../Core/Math/index.js';
+import vtkImplicitFunction from './ImplicitFunction.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -60,7 +61,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods
-  macro.obj(publicAPI, model);
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['radius']);
   macro.setGetArray(publicAPI, model, ['center', 'axis'], 3);
   vtkCylinder(publicAPI, model);

package/Common/DataModel/ImageData.d.ts

@@ -27,7 +27,6 @@ export interface vtkImageData extends vtkDataSet {
    * `voxelFunc(index, bounds)` is an optional function that is called with
    * the `[i,j,k]` index and index `bounds`, expected to return truthy if the
    * data point should be counted in the histogram, and falsey if not.
-   * @param {Bounds} worldBounds The bounds of the world.
    * @param [voxelFunc]
    */
   computeHistogram(worldBounds: Bounds, voxelFunc?: any): IComputeHistogram;

package/Common/DataModel/ImageData.js

@@ -197,7 +197,7 @@ function vtkImageData(publicAPI, model) {
   publicAPI.computeTransforms();
   publicAPI.getCenter = () => vtkBoundingBox.getCenter(publicAPI.getBounds());
   publicAPI.computeHistogram = function (worldBounds) {
-    let voxelFunc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let voxelFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     const bounds = [0, 0, 0, 0, 0, 0];
     publicAPI.worldToIndexBounds(worldBounds, bounds);
     const point1 = [0, 0, 0];
@@ -220,7 +220,7 @@ function vtkImageData(publicAPI, model) {
       for (let y = point1[1]; y <= point2[1]; y++) {
         let index = point1[0] + y * yStride + z * zStride;
         for (let x = point1[0]; x <= point2[0]; x++) {
-          if (!voxelFunc || voxelFunc([x, y, z], bounds)) {
+          if (!voxelFunction || voxelFunction([x, y, z], bounds)) {
             const pixel = pixels[index];
             if (pixel > maximum) maximum = pixel;
             if (pixel < minimum) minimum = pixel;

package/Common/DataModel/ImplicitBoolean.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import Constants from './ImplicitBoolean/Constants.js';
+import vtkImplicitFunction from './ImplicitFunction.js';
 
 const {
   Operation
@@ -64,7 +65,7 @@ function vtkImplicitBoolean(publicAPI, model) {
       value = Number.MAX_VALUE;
       for (let i = 0; i < model.functions.length; ++i) {
         const f = model.functions[i];
-        const v = f.evaluateFunction(xyz);
+        const v = f.functionValue(xyz);
         if (v < value) {
           value = v;
         }
@@ -73,14 +74,14 @@ function vtkImplicitBoolean(publicAPI, model) {
       value = -Number.MAX_VALUE;
       for (let i = 0; i < model.functions.length; ++i) {
         const f = model.functions[i];
-        const v = f.evaluateFunction(xyz);
+        const v = f.functionValue(xyz);
         if (v > value) {
           value = v;
         }
       }
     } else {
       const firstF = model.functions[0];
-      value = firstF.evaluateFunction(xyz);
+      value = firstF.functionValue(xyz);
       for (let i = 1; i < model.functions.length; ++i) {
         const f = model.functions[i];
         const v = -1.0 * f.evaluateFunction(xyz);
@@ -117,7 +118,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods
-  macro.obj(publicAPI, model);
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['operation']);
   vtkImplicitBoolean(publicAPI, model);
 }

package/Common/DataModel/ImplicitFunction.d.ts

@@ -0,0 +1,68 @@
+import { vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+import { vtkTransform } from './../Transform/Transform';
+
+/**
+ *
+ */
+export interface IImplicitFunctionInitialValues {
+  transform?: vtkTransform;
+}
+
+export interface vtkImplicitFunction extends vtkObject {
+  /**
+   * Given the point x evaluate the function.
+   * @see functionValue
+   * @param {Vector3} x The point coordinate.
+   */
+  evaluateFunction(x: Vector3): number;
+
+  /**
+   * Evaluate function at position x-y-z and return value. Point x[3] is
+   * transformed through transform (if provided).
+   * @see evaluateFunction
+   * @param {Vector3} x The point coordinate.
+   */
+  functionValue(x: Vector3): number;
+
+  /**
+   * Get the transform. undefined by default
+   */
+  getTransform(): vtkTransform;
+
+  /**
+   * Set the transform to apply on all points.
+   * @param {vtkTransform} transform The transform to apply
+   */
+  setTransform(transform: vtkTransform): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkImplicitFunction characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImplicitFunctionInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IImplicitFunctionInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkImplicitFunction.
+ * @param {IImplicitFunctionInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IImplicitFunctionInitialValues
+): vtkImplicitFunction;
+
+/**
+ * vtkImplicitFunction computes the implicit function and/or gradient for a function.
+ */
+export declare const vtkImplicitFunction: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkImplicitFunction;

package/Common/DataModel/ImplicitFunction.js

@@ -0,0 +1,60 @@
+import { m as macro } from '../../macros2.js';
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// vtkImplicitFunction methods
+// ----------------------------------------------------------------------------
+
+function vtkImplicitFunction(publicAPI, model) {
+  model.classHierarchy.push('vtkImplicitFunction');
+  publicAPI.functionValue = xyz => {
+    if (!model.transform) {
+      return publicAPI.evaluateFunction(xyz);
+    }
+    const transformedXYZ = [];
+    model.transform.transformPoint(xyz, transformedXYZ);
+    return publicAPI.evaluateFunction(transformedXYZ);
+  };
+  publicAPI.evaluateFunction = _xyz => {
+    macro.vtkErrorMacro('not implemented');
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+const DEFAULT_VALUES = {
+  // transform : null
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Object methods
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['transform']);
+  vtkImplicitFunction(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImplicitFunction');
+
+// ----------------------------------------------------------------------------
+
+var vtkImplicitFunction$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkImplicitFunction$1 as default, extend, newInstance };

package/Common/DataModel/Plane.d.ts

@@ -1,5 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Vector3 } from './../../types';
+import vtkImplicitFunction from './ImplicitFunction';
 
 /**
  *
@@ -16,7 +17,7 @@ interface IIntersectWithLine {
   x: Vector3;
 }
 
-export interface vtkPlane extends vtkObject {
+export interface vtkPlane extends vtkImplicitFunction {
   /**
    * Get the distance of a point x to a plane defined by n (x-p0) = 0.
    * The normal n must be magnitude = 1.

package/Common/DataModel/Plane.js

@@ -1,5 +1,6 @@
 import { s as subtract, d as dot, j as cross, k as add } from '../Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
+import vtkImplicitFunction from './ImplicitFunction.js';
 
 const PLANE_TOLERANCE = 1.0e-6;
 const COINCIDE = 'coincide';
@@ -235,7 +236,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods
-  macro.obj(publicAPI, model);
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['normal', 'origin'], 3);
   vtkPlane(publicAPI, model);
 }

package/Common/DataModel/Sphere.d.ts

@@ -1,18 +1,18 @@
-import { vtkObject } from './../../interfaces';
-import { Bounds, Vector3 } from './../../types';
+import { Vector3 } from './../../types';
+import vtkImplicitFunction from './ImplicitFunction';
 
 export interface ISphereInitialValues {
-  radius?: number;
+  radius?: number | Vector3;
   center?: Vector3;
 }
 
-export interface vtkSphere extends vtkObject {
+export interface vtkSphere extends vtkImplicitFunction {
   /**
    * Given the point xyz (three floating value) evaluate the sphere
    * equation.
    * @param {Vector3} xyz The point coordinate.
    */
-  evaluateFunction(xyz: Vector3): number[];
+  evaluateFunction(xyz: Vector3): number;
 
   /**
    * Given the point xyz (three floating values) evaluate the equation for the
@@ -34,7 +34,7 @@ export interface vtkSphere extends vtkObject {
   /**
    * Get the radius of the sphere.
    */
-  getRadius(): number;
+  getRadius(): number | Vector3;
 
   /**
    * Set the center of the sphere.
@@ -57,10 +57,11 @@ export interface vtkSphere extends vtkObject {
   setCenterFrom(center: Vector3): boolean;
 
   /**
-   * Set the radius of the sphere.
-   * @param {Number} radius The radius of the sphere.
+   * Set the radius of the sphere. Radius must be > 0.
+   * It can also be an array of 3 positive values for ellipsoids
+   * @param {Number|Vector3} radius The radius of the sphere.
    */
-  setRadius(radius: number): boolean;
+  setRadius(radius: number | Vector3): boolean;
 }
 
 /**
@@ -89,13 +90,6 @@ export function newInstance(initialValues?: ISphereInitialValues): vtkSphere;
  */
 declare function evaluate(radius: number, center: Vector3, x: Vector3): number;
 
-/**
- *
- * @param {Vector3} point
- * @param {Bounds} bounds
- */
-declare function isPointIn3DEllipse(point: Vector3, bounds: Bounds): boolean;
-
 /**
  * vtkSphere provides methods for creating a 1D cubic spline object from given
  * parameters, and allows for the calculation of the spline value and derivative
@@ -105,6 +99,5 @@ export declare const vtkSphere: {
   newInstance: typeof newInstance;
   extend: typeof extend;
   evaluate: typeof evaluate;
-  isPointIn3DEllipse: typeof isPointIn3DEllipse;
 };
 export default vtkSphere;

package/Common/DataModel/Sphere.js

@@ -1,21 +1,17 @@
 import { m as macro } from '../../macros2.js';
-import vtkBoundingBox from './BoundingBox.js';
-
-const VTK_SMALL_NUMBER = 1e-12;
+import vtkImplicitFunction from './ImplicitFunction.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
-function evaluate(radius, center, x) {
-  return (x[0] - center[0]) * (x[0] - center[0]) + (x[1] - center[1]) * (x[1] - center[1]) + (x[2] - center[2]) * (x[2] - center[2]) - radius * radius;
-}
-function isPointIn3DEllipse(point, bounds) {
-  const center = vtkBoundingBox.getCenter(bounds);
-  let scale3 = vtkBoundingBox.computeScale3(bounds);
-  scale3 = scale3.map(x => Math.max(Math.abs(x), VTK_SMALL_NUMBER));
-  const radius = [(point[0] - center[0]) / scale3[0], (point[1] - center[1]) / scale3[1], (point[2] - center[2]) / scale3[2]];
-  return radius[0] * radius[0] + radius[1] * radius[1] + radius[2] * radius[2] <= 1;
+function evaluate(radius, center, xyz) {
+  if (!Array.isArray(radius)) {
+    const retVal = (xyz[0] - center[0]) * (xyz[0] - center[0]) + (xyz[1] - center[1]) * (xyz[1] - center[1]) + (xyz[2] - center[2]) * (xyz[2] - center[2]) - radius * radius;
+    return retVal;
+  }
+  const r = [(xyz[0] - center[0]) / radius[0], (xyz[1] - center[1]) / radius[1], (xyz[2] - center[2]) / radius[2]];
+  return r[0] * r[0] + r[1] * r[1] + r[2] * r[2] - 1;
 }
 
 // ----------------------------------------------------------------------------
@@ -23,8 +19,7 @@ function isPointIn3DEllipse(point, bounds) {
 // ----------------------------------------------------------------------------
 
 const STATIC = {
-  evaluate,
-  isPointIn3DEllipse
+  evaluate
 };
 
 // ----------------------------------------------------------------------------
@@ -34,10 +29,7 @@ const STATIC = {
 function vtkSphere(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSphere');
-  publicAPI.evaluateFunction = xyz => {
-    const retVal = (xyz[0] - model.center[0]) * (xyz[0] - model.center[0]) + (xyz[1] - model.center[1]) * (xyz[1] - model.center[1]) + (xyz[2] - model.center[2]) * (xyz[2] - model.center[2]) - model.radius * model.radius;
-    return retVal;
-  };
+  publicAPI.evaluateFunction = xyz => evaluate(model.radius, model.center, xyz);
   publicAPI.evaluateGradient = xyz => {
     const retVal = [2.0 - (xyz[0] - model.center[0]), 2.0 - (xyz[1] - model.center[1]), 2.0 - (xyz[2] - model.center[2])];
     return retVal;
@@ -60,7 +52,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods
-  macro.obj(publicAPI, model);
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['radius']);
   macro.setGetArray(publicAPI, model, ['center'], 3);
   vtkSphere(publicAPI, model);

package/Rendering/Core/Mapper.js

@@ -595,11 +595,11 @@ function vtkMapper(publicAPI, model) {
         let inValue = 0;
         inValue += rawHighData[pos];
         inValue *= 256;
-        inValue += rawLowData[pos];
+        inValue += rawLowData[pos + 2];
         inValue *= 256;
         inValue += rawLowData[pos + 1];
         inValue *= 256;
-        inValue += rawLowData[pos + 2];
+        inValue += rawLowData[pos];
         const outValue = idMap[inValue];
         const highData = selector.getPixelBuffer(PassTypes.ID_HIGH24);
         highData[pos] = (outValue & 0xff000000) >> 24;

package/Rendering/OpenGL/HardwareSelector.d.ts

@@ -331,6 +331,23 @@ export function extend(
   initialValues?: IOpenGLHardwareSelectorInitialValues
 ): void;
 
+/**
+ * The WebGL implementation of the hardware selector renders the id of the VBO
+ * vertices (gl_VertexID) with an offset to a RGBA texture.
+ * Only the RGB channels of the RGBA texture are used. This means that a single
+ * render can only draw 24 bits of information. To reach 32 bits, the hardware
+ * selector renders a second pass which only writes in the R channel of the
+ * texture.
+ *
+ * Note:
+ * - With Webgl 2, it is now possible to render directly to a R32 texture and
+ * even render to multiple render targets.
+ * - The raw pixel buffers fetched from WebGL are processed in the core mapper
+ * (see `processSelectorPixelBuffers`) instead of the PolydataMapper.
+ * - The processing of the raw pixel buffers does not output an UInt32Array as
+ * we could expect, but one or two textures with the same layout as the RGBA
+ * textures as input.
+ */
 export const vtkOpenGLHardwareSelector: {
   newInstance: typeof newInstance;
   extend: typeof extend;

package/Rendering/OpenGL/HardwareSelector.js

@@ -358,6 +358,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     model._renderer.setBackground(0.0, 0.0, 0.0, 0.0);
     const rpasses = model._openGLRenderWindow.getRenderPasses();
     publicAPI.beginSelection();
+    const pixelBufferSavedPasses = [];
     for (model.currentPass = PassTypes.MIN_KNOWN_PASS; model.currentPass <= PassTypes.MAX_KNOWN_PASS; model.currentPass++) {
       if (publicAPI.passRequired(model.currentPass)) {
         publicAPI.preCapturePass(model.currentPass);
@@ -369,9 +370,16 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
         }
         publicAPI.postCapturePass(model.currentPass);
         publicAPI.savePixelBuffer(model.currentPass);
-        publicAPI.processPixelBuffers();
+        pixelBufferSavedPasses.push(model.currentPass);
       }
     }
+
+    // Process pixel buffers
+    pixelBufferSavedPasses.forEach(pass => {
+      model.currentPass = pass;
+      publicAPI.processPixelBuffers();
+    });
+    model.currentPass = PassTypes.MAX_KNOWN_PASS;
     publicAPI.endSelection();
 
     // restore original background
@@ -631,9 +639,9 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
   //----------------------------------------------------------------------------
 
-  publicAPI.attach = (w, r) => {
-    model._openGLRenderWindow = w;
-    model._renderer = r;
+  publicAPI.attach = (openGLRenderWindow, renderer) => {
+    model._openGLRenderWindow = openGLRenderWindow;
+    model._renderer = renderer;
   };
 
   // override