@kitware/vtk.js 34.9.1 → 34.11.0

package/Common/DataModel.js

@@ -12,6 +12,7 @@ import vtkLine from './DataModel/Line.js';
 import vtkMolecule from './DataModel/Molecule.js';
 import vtkPiecewiseFunction from './DataModel/PiecewiseFunction.js';
 import vtkPlane from './DataModel/Plane.js';
+import vtkPlanes from './DataModel/Planes.js';
 import vtkPointSet from './DataModel/PointSet.js';
 import vtkPolyData from './DataModel/PolyData.js';
 import vtkSelectionNode from './DataModel/SelectionNode.js';
@@ -35,6 +36,7 @@ var DataModel = {
   vtkMolecule,
   vtkPiecewiseFunction,
   vtkPlane,
+  vtkPlanes,
   vtkPointSet,
   vtkPolyData,
   vtkSelectionNode,

package/Filters/Sources/FrustumSource.d.ts

@@ -0,0 +1,111 @@
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkPlanes from './../../Common/DataModel/Planes';
+
+/**
+ *
+ */
+export interface IFrustumSourceInitialValues {
+  planes?: vtkPlanes;
+  showLines?: boolean;
+  outputPointsPrecision?: DesiredOutputPrecision;
+}
+
+type vtkFrustumSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkFrustumSource extends vtkFrustumSourceBase {
+  /**
+   * Get the output points precision.
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   * Get the planes defining the frustum.
+   */
+  getPlanes(): vtkPlanes;
+
+  /**
+   * Get whether to show lines.
+   */
+  getShowLines(): boolean;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the output points precision.
+   * @param {DesiredOutputPrecision} precision
+   */
+  setOutputPointsPrecision(precision: DesiredOutputPrecision): boolean;
+
+  /**
+   * Set the planes defining the frustum.
+   * @param {vtkPlanes} planes
+   */
+  setPlanes(planes: vtkPlanes): boolean;
+
+  /**
+   * Set whether to show lines.
+   * @param {Boolean} showLines
+   */
+  setShowLines(showLines: boolean): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkFrustumSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IFrustumSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IFrustumSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkFrustumSource.
+ * @param {IFrustumSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IFrustumSourceInitialValues
+): vtkFrustumSource;
+
+/**
+ * vtkFrustumSource creates a frustum defines by a set of planes. The frustum is
+ * represented with four-sided polygons. It is possible to specify extra lines
+ * to better visualize the field of view.
+ *
+ * @example
+ * ```js
+ * import vtkFrustumSource from '@kitware/vtk.js/Filters/Sources/FrustumSource';
+ *
+ * const frustum = vtkFrustumSource.newInstance();
+ * const camera = vtkCamera.newInstance();
+ * camera.setClippingRange(0.1, 0.4);
+ * const planesArray = camera.getFrustumPlanes(1.0);
+ * const planes = vtkPlanes.newInstance();
+ * planes.setFrustumPlanes(planesArray);
+ * frustum.setPlanes(planes);
+ * frustum.setShowLines(false);
+ * ```
+ */
+export declare const vtkFrustumSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkFrustumSource;

package/Filters/Sources/FrustumSource.js

@@ -0,0 +1,248 @@
+import { m as macro } from '../../macros2.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkFrustumSource methods
+// ----------------------------------------------------------------------------
+
+function vtkFrustumSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkFrustumSource');
+  function computePoint(planeIndices, pt) {
+    // Get planes and their normals/origins
+    const plane0 = model.planes.getPlane(planeIndices[0]);
+    const n0 = plane0.getNormal();
+    const p0 = plane0.getOrigin();
+    const plane1 = model.planes.getPlane(planeIndices[1]);
+    const n1 = plane1.getNormal();
+    const p1 = plane1.getOrigin();
+    const plane2 = model.planes.getPlane(planeIndices[2]);
+    const n2 = plane2.getNormal();
+    const p2 = plane2.getOrigin();
+
+    // Dot products
+    const d0 = vtkMath.dot(p0, n0);
+    const d1 = vtkMath.dot(p1, n1);
+    const d2 = vtkMath.dot(p2, n2);
+
+    // Cross products
+    const c12 = [0, 0, 0];
+    vtkMath.cross(n1, n2, c12);
+    const c20 = [0, 0, 0];
+    vtkMath.cross(n2, n0, c20);
+    const c01 = [0, 0, 0];
+    vtkMath.cross(n0, n1, c01);
+
+    // Determinant
+    const d = vtkMath.determinant3x3([...n0, ...n1, ...n2]);
+
+    // Intersection point
+    for (let i = 0; i < 3; ++i) {
+      pt[i] = (d0 * c12[i] + d1 * c20[i] + d2 * c01[i]) / d;
+    }
+  }
+  publicAPI.requestData = (inData, outData) => {
+    const output = outData[0] || vtkPolyData.newInstance();
+    if (!model.planes || model.planes.getNumberOfPlanes() !== 6) {
+      vtkErrorMacro('vtkFrustum requires 6 planes.');
+      return;
+    }
+    let nbPts = 8;
+    let leftRightNull = false;
+    let bottomTopNull = false;
+    let parallelFrustum = false;
+
+    // angle between left and right planes
+    const n0 = model.planes.getPlane(0).getNormal().slice();
+    const n1 = model.planes.getPlane(1).getNormal().slice();
+    const c = [0, 0, 0];
+    vtkMath.normalize(n0);
+    vtkMath.normalize(n1);
+    vtkMath.dot(n0, n1);
+    vtkMath.cross(n0, n1, c);
+    vtkMath.norm(c);
+
+    // angle between bottom and top planes
+    n0.splice(0, 3, ...model.planes.getPlane(2).getNormal());
+    n1.splice(0, 3, ...model.planes.getPlane(3).getNormal());
+    vtkMath.normalize(n0);
+    vtkMath.normalize(n1);
+    vtkMath.dot(n0, n1);
+    vtkMath.cross(n0, n1, c);
+    vtkMath.norm(c);
+    if (model.showLines) {
+      const left = model.planes.getPlane(0).getNormal();
+      const right = model.planes.getPlane(1).getNormal();
+      const bottom = model.planes.getPlane(2).getNormal();
+      const top = model.planes.getPlane(3).getNormal();
+      const leftRight = [0, 0, 0];
+      vtkMath.cross(left, right, leftRight);
+      leftRightNull = leftRight[0] === 0.0 && leftRight[1] === 0.0 && leftRight[2] === 0.0;
+      const bottomTop = [0, 0, 0];
+      vtkMath.cross(bottom, top, bottomTop);
+      bottomTopNull = bottomTop[0] === 0.0 && bottomTop[1] === 0.0 && bottomTop[2] === 0.0;
+      parallelFrustum = leftRightNull && bottomTopNull;
+      if (parallelFrustum) {
+        // start at near points, just add the 4 extra far points.
+        nbPts += 4;
+      } else if (leftRightNull || bottomTopNull) {
+        // two extra starting points, and 4 extra far points.
+        nbPts += 6;
+      } else {
+        // there is an apex, and 4 extra far points
+        nbPts += 5;
+      }
+    }
+    let pointType = 0;
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+    const newPoints = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    newPoints.setNumberOfPoints(nbPts);
+    const pt = [0.0, 0.0, 0.0];
+    const planes = [0, 0, 0];
+    planes[0] = 0; // left
+    planes[1] = 2; // bottom
+    planes[2] = 5; // near
+    computePoint(planes, pt);
+    newPoints.setPoint(0, ...pt);
+    planes[0] = 1;
+    computePoint(planes, pt);
+    newPoints.setPoint(1, ...pt);
+    planes[1] = 3;
+    computePoint(planes, pt);
+    newPoints.setPoint(2, ...pt);
+    planes[0] = 0;
+    computePoint(planes, pt);
+    newPoints.setPoint(3, ...pt);
+    planes[1] = 2;
+    planes[2] = 4; // far
+    computePoint(planes, pt);
+    newPoints.setPoint(4, ...pt);
+    planes[0] = 1;
+    computePoint(planes, pt);
+    newPoints.setPoint(5, ...pt);
+    planes[1] = 3;
+    computePoint(planes, pt);
+    newPoints.setPoint(6, ...pt);
+    planes[0] = 0;
+    computePoint(planes, pt);
+    newPoints.setPoint(7, ...pt);
+    const numPolys = 6;
+    const newPolys = vtkCellArray.newInstance();
+    newPolys.allocate(numPolys * 5);
+
+    // left
+    newPolys.insertNextCell([4, 0, 3, 7]);
+
+    // right
+    newPolys.insertNextCell([1, 5, 6, 2]);
+
+    // bottom
+    newPolys.insertNextCell([0, 4, 5, 1]);
+
+    // top
+    newPolys.insertNextCell([3, 2, 6, 7]);
+
+    // near
+    newPolys.insertNextCell([0, 1, 2, 3]);
+
+    // far
+    newPolys.insertNextCell([4, 7, 6, 5]);
+    let newLines = null;
+    if (model.showLines) {
+      const numLines = 4;
+      newLines = vtkCellArray.newInstance();
+      newLines.allocate(numLines * 3);
+      const pts = [12, 8]; // apex, or first of the two extra near points.
+
+      // line from lower-left corner
+      if (parallelFrustum) {
+        pts[0] = 0;
+      }
+      newLines.insertNextCell(pts);
+
+      // line from lower-right corner
+      if (parallelFrustum) {
+        pts[0]++;
+      } else if (leftRightNull) {
+        pts[0] = 13;
+      }
+      pts[1]++;
+      newLines.insertNextCell(pts);
+
+      // line from upper-right corner
+      if (parallelFrustum) {
+        pts[0]++;
+      } else if (bottomTopNull) {
+        pts[0] = 13;
+      }
+      pts[1]++;
+      newLines.insertNextCell(pts);
+
+      // line from upper-left corner
+      if (parallelFrustum) {
+        pts[0]++;
+      } else if (leftRightNull) {
+        pts[0] = 12;
+      }
+      pts[1]++;
+      newLines.insertNextCell(pts);
+      output.setLines(newLines);
+    }
+    output.setPoints(newPoints);
+    output.setPolys(newPolys);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  planes: null,
+  showLines: true,
+  outputPointsPrecision: DesiredOutputPrecision.DEFAULT
+};
+
+// ----------------------------------------------------------------------------
+
+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);
+
+  // Also make it an algorithm with no input and one output
+  macro.algo(publicAPI, model, 0, 1);
+  macro.setGet(publicAPI, model, ['showLines', 'outputPointsPrecision', 'planes']);
+  vtkFrustumSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkFrustumSource');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };

package/Rendering/Core/Camera.d.ts

@@ -301,10 +301,17 @@ export interface vtkCamera extends vtkObject {
   getViewAngle(): number;
 
   /**
-   *
+   * Get the view transform
    */
   getViewMatrix(): mat4;
 
+  /**
+   * Get the model transform matrix for the camera.
+   * This matrix could be used for model related transformations such as scale, shear, rotations and translations.
+   * @returns {mat4} mat The value of the model transform matrix.
+   */
+  getModelTransformMatrix(): mat4;
+
   /**
    * Get the ViewPlaneNormal.
    * This vector will point opposite to the direction of projection,
@@ -674,7 +681,14 @@ export interface vtkCamera extends vtkObject {
    * Set the view matrix for the camera.
    * @param {mat4} mat The value of the view matrix.
    */
-  setViewMatrix(mat: mat4): boolean;
+  setViewMatrix(mat: mat4): void;
+
+  /**
+   * Set the model transform matrix for the camera.
+   * This matrix could be used for model related transformations such as scale, shear, rotations and translations.
+   * @param {mat4} mat The value of the model transform matrix.
+   */
+  setModelTransformMatrixMatrix(mat: mat4): void;
 
   /**
    * Set the view up direction for the camera.

package/Rendering/Core/Camera.js

@@ -402,6 +402,10 @@ function vtkCamera(publicAPI, model) {
     mat4.multiply(tmpMatrix, mat, tmpMatrix);
     publicAPI.computeViewParametersFromViewMatrix(tmpMatrix);
   };
+  publicAPI.setModelTransformMatrix = mat => {
+    model.modelTransformMatrix = mat;
+  };
+  publicAPI.getModelTransformMatrix = () => model.modelTransformMatrix;
   publicAPI.setViewMatrix = mat => {
     model.viewMatrix = mat;
     if (model.viewMatrix) {
@@ -412,6 +416,10 @@ function vtkCamera(publicAPI, model) {
   };
   publicAPI.getViewMatrix = () => {
     if (model.viewMatrix) {
+      if (model.modelTransformMatrix) {
+        mat4.multiply(tmpMatrix, model.viewMatrix, model.modelTransformMatrix);
+        return tmpMatrix;
+      }
       return model.viewMatrix;
     }
     mat4.lookAt(tmpMatrix, model.position,
@@ -423,7 +431,11 @@ function vtkCamera(publicAPI, model) {
 
     mat4.transpose(tmpMatrix, tmpMatrix);
     const result = new Float64Array(16);
-    mat4.copy(result, tmpMatrix);
+    if (model.modelTransformMatrix) {
+      mat4.multiply(result, tmpMatrix, model.modelTransformMatrix);
+    } else {
+      mat4.copy(result, tmpMatrix);
+    }
     return result;
   };
   publicAPI.setProjectionMatrix = mat => {
@@ -613,6 +625,7 @@ const DEFAULT_VALUES = {
   freezeFocalPoint: false,
   projectionMatrix: null,
   viewMatrix: null,
+  modelTransformMatrix: null,
   cameraLightTransform: mat4.create(),
   // used for world to physical transformations
   physicalTranslation: [0, 0, 0],

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -162,6 +162,22 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     }
     superClass.replaceShaderNormal(shaders, ren, actor);
   };
+  publicAPI.replaceShaderClip = (shaders, ren, actor) => {
+    if (model.hardwareSupport) {
+      let VSSource = shaders.Vertex;
+      let FSSource = shaders.Fragment;
+      if (model.renderable.getNumberOfClippingPlanes()) {
+        const numClipPlanes = model.renderable.getNumberOfClippingPlanes();
+        VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Clip::Dec', ['uniform int numClipPlanes;', `uniform vec4 clipPlanes[${numClipPlanes}];`, `varying float clipDistancesVSOutput[${numClipPlanes}];`]).result;
+        VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Clip::Impl', [`for (int planeNum = 0; planeNum < ${numClipPlanes}; planeNum++)`, '    {', '    if (planeNum >= numClipPlanes)', '        {', '        break;', '        }', '    vec4 gVertex = gMatrix * vertexMC;', '    clipDistancesVSOutput[planeNum] = dot(clipPlanes[planeNum], gVertex);', '    }']).result;
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Clip::Dec', ['uniform int numClipPlanes;', `varying float clipDistancesVSOutput[${numClipPlanes}];`]).result;
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Clip::Impl', [`for (int planeNum = 0; planeNum < ${numClipPlanes}; planeNum++)`, '    {', '    if (planeNum >= numClipPlanes)', '        {', '        break;', '        }', '    if (clipDistancesVSOutput[planeNum] < 0.0) discard;', '    }']).result;
+      }
+      shaders.Vertex = VSSource;
+      shaders.Fragment = FSSource;
+    }
+    superClass.replaceShaderClip(shaders, ren, actor);
+  };
   publicAPI.replaceShaderColor = (shaders, ren, actor) => {
     if (model.hardwareSupport && model.renderable.getColorArray()) {
       let VSSource = shaders.Vertex;

package/Rendering/OpenGL/glsl/vtkVolumeVS.glsl.js

@@ -1,3 +1,3 @@
-var vtkVolumeVS = "//VTK::System::Dec\n\n/*=========================================================================\n\n  Program:   Visualization Toolkit\n  Module:    vtkPolyDataVS.glsl\n\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n  All rights reserved.\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n     This software is distributed WITHOUT ANY WARRANTY; without even\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n     PURPOSE.  See the above copyright notice for more information.\n\n=========================================================================*/\n\nattribute vec4 vertexDC;\n\nvarying vec3 vertexVCVSOutput;\nuniform mat4 PCVCMatrix;\n\nuniform float dcxmin;\nuniform float dcxmax;\nuniform float dcymin;\nuniform float dcymax;\n\nvoid main()\n{\n  // dcsmall is the device coords reduced to the\n  // x y area covered by the volume\n  vec4 dcsmall = vec4(\n    dcxmin + 0.5 * (vertexDC.x + 1.0) * (dcxmax - dcxmin),\n    dcymin + 0.5 * (vertexDC.y + 1.0) * (dcymax - dcymin),\n    vertexDC.z,\n    vertexDC.w);\n  vec4 vcpos = PCVCMatrix * dcsmall;\n  vertexVCVSOutput = vcpos.xyz/vcpos.w;\n  gl_Position = dcsmall;\n}\n";
+var vtkVolumeVS = "//VTK::System::Dec\n\n/*=========================================================================\n\n  Program:   Visualization Toolkit\n  Module:    vtkVolumeVS.glsl\n\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n  All rights reserved.\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n     This software is distributed WITHOUT ANY WARRANTY; without even\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n     PURPOSE.  See the above copyright notice for more information.\n\n=========================================================================*/\n\nattribute vec4 vertexDC;\n\nvarying vec3 vertexVCVSOutput;\nuniform mat4 PCVCMatrix;\n\nuniform float dcxmin;\nuniform float dcxmax;\nuniform float dcymin;\nuniform float dcymax;\n\nvoid main()\n{\n  // dcsmall is the device coords reduced to the\n  // x y area covered by the volume\n  vec4 dcsmall = vec4(\n    dcxmin + 0.5 * (vertexDC.x + 1.0) * (dcxmax - dcxmin),\n    dcymin + 0.5 * (vertexDC.y + 1.0) * (dcymax - dcymin),\n    vertexDC.z,\n    vertexDC.w);\n  vec4 vcpos = PCVCMatrix * dcsmall;\n  vertexVCVSOutput = vcpos.xyz/vcpos.w;\n  gl_Position = dcsmall;\n}\n";
 
 export { vtkVolumeVS as v };

package/index.d.ts

@@ -37,8 +37,11 @@
 /// <reference path="./Common/DataModel/KochanekSpline1D.d.ts" />
 /// <reference path="./Common/DataModel/Line.d.ts" />
 /// <reference path="./Common/DataModel/Locator.d.ts" />
+/// <reference path="./Common/DataModel/MergePoints.d.ts" />
 /// <reference path="./Common/DataModel/PiecewiseFunction.d.ts" />
 /// <reference path="./Common/DataModel/Plane.d.ts" />
+/// <reference path="./Common/DataModel/Planes.d.ts" />
+/// <reference path="./Common/DataModel/PointLocator.d.ts" />
 /// <reference path="./Common/DataModel/PointSet.d.ts" />
 /// <reference path="./Common/DataModel/PolyData/Constants.d.ts" />
 /// <reference path="./Common/DataModel/PolyData.d.ts" />
@@ -81,6 +84,7 @@
 /// <reference path="./Filters/Sources/CylinderSource.d.ts" />
 /// <reference path="./Filters/Sources/DiskSource.d.ts" />
 /// <reference path="./Filters/Sources/EllipseArcSource.d.ts" />
+/// <reference path="./Filters/Sources/FrustumSource.d.ts" />
 /// <reference path="./Filters/Sources/LineSource.d.ts" />
 /// <reference path="./Filters/Sources/PlaneSource.d.ts" />
 /// <reference path="./Filters/Sources/PlatonicSolidSource/Constants.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.9.1",
+  "version": "34.11.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",