@kitware/vtk.js 28.6.0 → 28.7.0

package/Common/Core/DataArray.js

@@ -490,8 +490,19 @@ function vtkDataArray(publicAPI, model) {
   };
 
   publicAPI.deepCopy = function (other) {
-    publicAPI.shallowCopy(other);
-    publicAPI.setData(other.getData().slice());
+    // Retain current dataType and array reference before shallowCopy call.
+    var currentType = publicAPI.getDataType();
+    var currentArray = model.values;
+    publicAPI.shallowCopy(other); // Avoid array reallocation if size already sufficient
+    // and dataTypes match.
+
+    if ((currentArray === null || currentArray === void 0 ? void 0 : currentArray.length) >= other.getNumberOfValues() && currentType === other.getDataType()) {
+      currentArray.set(other.getData());
+      model.values = currentArray;
+      publicAPI.dataChange();
+    } else {
+      publicAPI.setData(other.getData().slice());
+    }
   };
 
   publicAPI.interpolateTuple = function (idx, source1, source1Idx, source2, source2Idx, t) {

package/Filters/General/ImageDataOutlineFilter.d.ts

@@ -0,0 +1,77 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+
+export const LINE_ARRAY: number[];
+
+export interface IImageDataOutlineFilterInitialValues {
+}
+
+type vtkImageDataOutlineFilterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkImageDataOutlineFilter extends vtkImageDataOutlineFilterBase {
+    /**
+     *
+     * @param inData 
+     * @param outData 
+     */
+    requestData(inData: vtkImageData, outData: vtkPolyData): void;
+
+    /**
+     * Flag that indicates whether the output will generate faces of the outline.
+     * @returns {boolean}
+     */
+    getGenerateFaces(): boolean;
+
+    /**
+     * Flag that indicates whether the output will generate wireframe lines of the outline.
+     * @returns {boolean}
+     */
+    getGenerateLines(): boolean;
+
+    /**
+     * Flag to indicate that the output should generate wireframe of the outline.
+     * @param {boolean} generateLines
+     */
+    setGenerateLines(generateLines: boolean): boolean;
+
+    /**
+     * Flag to indicate that the output should generate triangulated faces of the outline.
+     * @param {boolean} generateFaces
+     */
+    setGenerateFaces(generateFaces: boolean): boolean;
+
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with
+ * vtkImageDataOutlineFilter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageDataOutlineFilterInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageDataOutlineFilterInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkImageDataOutlineFilter
+ * @param {IImageDataOutlineFilterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageDataOutlineFilterInitialValues): vtkImageDataOutlineFilter;
+
+
+/**
+ * vtkImageDataOutlineFilter - A filter that generates oriented outline for
+ * vtkImageData.
+ *
+ * vtkImageDataOutlineFilter is a filter that generates a wireframe or
+ * triangulated rectangular-cuboid as an outline of an input vtkImageData.
+ * It takes into account the orientation / DirectionMatrix of the image, so the
+ * output outline may not be axes aligned.
+ * 
+ */
+export declare const vtkImageDataOutlineFilter: {
+    newInstance: typeof newInstance;
+    extend: typeof extend;
+}
+export default vtkImageDataOutlineFilter;

package/Filters/General/ImageDataOutlineFilter.js

@@ -0,0 +1,82 @@
+import macro from '../../macros.js';
+import vtkCubeSource from '../Sources/CubeSource.js';
+
+var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// vtkImageDataOutlineFilter methods
+// ----------------------------------------------------------------------------
+
+function vtkImageDataOutlineFilter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageDataOutlineFilter');
+
+  publicAPI.requestData = function (inData, outData) {
+    // implement requestData
+    var input = inData[0];
+
+    if (!input || !input.isA('vtkImageData')) {
+      vtkErrorMacro('Invalid or missing input');
+      return;
+    } // First create a cube polydata in the index-space of the image.
+    // The benefit of using `getSpatialExtent` call is that it automatically
+    // takes care of 0.5 voxel padding as required by an vtkImageData representation.
+
+
+    var spatialExt = input.getSpatialExtent();
+
+    if (!spatialExt) {
+      vtkErrorMacro('Unable to fetch spatial extents of input image.');
+      return;
+    }
+
+    model._cubeSource.setBounds(spatialExt); // Then apply index-to-world transform to the cube to create the outline.
+
+
+    model._cubeSource.setMatrix(input.getIndexToWorld());
+
+    outData[0] = model._cubeSource.getOutputData();
+  }; // Forward calls for [set/get]Generate[Faces/Lines] functions to cubeSource:
+
+
+  publicAPI.setGenerateFaces = function (generateFaces) {
+    if (model._cubeSource.setGenerateFaces(generateFaces)) {
+      publicAPI.modified();
+    }
+  };
+
+  publicAPI.setGenerateLines = function (generateLines) {
+    if (model._cubeSource.setGenerateLines(generateLines)) {
+      publicAPI.modified();
+    }
+  };
+
+  publicAPI.getGenerateFaces = model._cubeSource.getGenerateFaces;
+  publicAPI.getGenerateLines = model._cubeSource.getGenerateLines;
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var 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, 1, 1); // Internal persistent objects
+
+  model._cubeSource = vtkCubeSource.newInstance();
+  macro.moveToProtected(publicAPI, model, ['cubeSource', 'tmpOut']); // Object specific methods
+
+  vtkImageDataOutlineFilter(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageDataOutlineFilter'); // ----------------------------------------------------------------------------
+
+var vtkImageDataOutlineFilter$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkImageDataOutlineFilter$1 as default, extend, newInstance };

package/Filters/Sources/CubeSource.d.ts

@@ -1,3 +1,4 @@
+import { mat4 } from 'gl-matrix';
 import { vtkAlgorithm, vtkObject } from './../../interfaces';
 import { Bounds, Vector3 } from './../../types';
 
@@ -41,6 +42,24 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 	 */
 	getGenerate3DTextureCoordinates(): boolean;
 
+    /**
+     * Flag that indicates whether the output will generate faces of the outline.
+     * @returns {boolean}
+     */
+    getGenerateFaces(): boolean;
+
+    /**
+     * Flag that indicates whether the output will generate wireframe lines of the outline.
+     * @returns {boolean}
+     */
+    getGenerateLines(): boolean;
+
+    /**
+     * Get the 4x4 transformation set to apply as a final trasformation to the output.
+     * @param matrix
+     */
+    getMatrix(): mat4;
+
 	/**
 	 *
 	 * @default [0.0, 0.0, 0.0]
@@ -117,6 +136,24 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 	 */
 	setGenerate3DTextureCoordinates(generate3DTextureCoordinates: boolean): boolean;
 
+    /**
+     * Flag to indicate that the output should generate wireframe of the outline.
+     * @param {boolean} generateLines
+     */
+    setGenerateLines(generateLines: boolean): boolean;
+
+    /**
+     * Flag to indicate that the output should generate triangulated faces of the outline.
+     * @param {boolean} generateFaces
+     */
+    setGenerateFaces(generateFaces: boolean): boolean;
+
+    /**
+     * Set a 4x4 transformation that will be applied as a final trasformation to the output.
+     * @param matrix
+     */
+    setMatrix(matrix: mat4): boolean;
+
 	/**
 	 * Float array of size 3 representing the angles, in degrees, of rotation for the cube.
 	 * @param xAngle

package/Filters/Sources/CubeSource.js

@@ -1,9 +1,14 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
+import { IDENTITY } from '../../Common/Core/Math/Constants.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
+var LINE_ARRAY = [2, 0, 1, 2, 2, 3, 2, 4, 5, 2, 6, 7, 2, 0, 2, 2, 1, 3, 2, 4, 6, 2, 5, 7, 2, 0, 4, 2, 1, 5, 2, 2, 6, 2, 3, 7]; // prettier-ignore
+
+var POLY_ARRAY = [4, 0, 1, 3, 2, 4, 4, 6, 7, 5, 4, 8, 10, 11, 9, 4, 12, 13, 15, 14, 4, 16, 18, 19, 17, 4, 20, 21, 23, 22]; // ----------------------------------------------------------------------------
 // vtkCubeSource methods
 // ----------------------------------------------------------------------------
 
@@ -20,7 +25,6 @@ function vtkCubeSource(publicAPI, model) {
 
     var polyData = vtkPolyData.newInstance();
     outData[0] = polyData;
-    var numberOfPolys = 6;
     var numberOfPoints = 24; // Define points
 
     var points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
@@ -175,42 +179,29 @@ function vtkCubeSource(publicAPI, model) {
 
     vtkMatrixBuilder.buildFromDegree().rotateX(model.rotations[0]).rotateY(model.rotations[1]).rotateZ(model.rotations[2]).apply(points).apply(normals); // Apply transformation to the points coordinates
 
-    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).apply(points); // Define quads
-
-
-    var polys = new Uint16Array(numberOfPolys * 5);
-    polyData.getPolys().setData(polys, 1);
-    var polyIndex = 0;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 0;
-    polys[polyIndex++] = 1;
-    polys[polyIndex++] = 3;
-    polys[polyIndex++] = 2;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 6;
-    polys[polyIndex++] = 7;
-    polys[polyIndex++] = 5;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 8;
-    polys[polyIndex++] = 10;
-    polys[polyIndex++] = 11;
-    polys[polyIndex++] = 9;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 12;
-    polys[polyIndex++] = 13;
-    polys[polyIndex++] = 15;
-    polys[polyIndex++] = 14;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 16;
-    polys[polyIndex++] = 18;
-    polys[polyIndex++] = 19;
-    polys[polyIndex++] = 17;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 20;
-    polys[polyIndex++] = 21;
-    polys[polyIndex++] = 23;
-    polys[polyIndex] = 22;
+    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).apply(points); // Apply optional additionally specified matrix transformation
+
+
+    vtkMatrixBuilder.buildFromRadian().setMatrix(model.matrix).apply(points); // prettier-ignore
+
+    var rotMatrix = [model.matrix[0], model.matrix[1], model.matrix[2], 0, model.matrix[4], model.matrix[5], model.matrix[6], 0, model.matrix[8], model.matrix[9], model.matrix[10], 0, 0, 0, 0, 1];
+    vtkMatrixBuilder.buildFromRadian().setMatrix(rotMatrix).apply(normals); // Lastly, generate the necessary cell arrays.
+
+    if (model.generateFaces) {
+      polyData.getPolys().deepCopy(model._polys);
+    } else {
+      polyData.getPolys().initialize();
+    }
+
+    if (model.generateLines) {
+      polyData.getLines().deepCopy(model._lineCells); // only set normals for faces, not for lines.
+
+      polyData.getPointData().setNormals(null);
+    } else {
+      polyData.getLines().initialize();
+    }
+
+    polyData.modified();
   }
 
   publicAPI.setBounds = function () {
@@ -228,10 +219,10 @@ function vtkCubeSource(publicAPI, model) {
       return;
     }
 
-    model.xLength = boundsArray[1] - boundsArray[0];
-    model.yLength = boundsArray[3] - boundsArray[2];
-    model.zLength = boundsArray[5] - boundsArray[4];
-    model.center = [(boundsArray[0] + boundsArray[1]) / 2.0, (boundsArray[2] + boundsArray[3]) / 2.0, (boundsArray[4] + boundsArray[5]) / 2.0];
+    publicAPI.setXLength(boundsArray[1] - boundsArray[0]);
+    publicAPI.setYLength(boundsArray[3] - boundsArray[2]);
+    publicAPI.setZLength(boundsArray[5] - boundsArray[4]);
+    publicAPI.setCenter([(boundsArray[0] + boundsArray[1]) / 2.0, (boundsArray[2] + boundsArray[3]) / 2.0, (boundsArray[4] + boundsArray[5]) / 2.0]);
   }; // Expose methods
 
 
@@ -247,8 +238,11 @@ var DEFAULT_VALUES = {
   zLength: 1.0,
   center: [0.0, 0.0, 0.0],
   rotations: [0.0, 0.0, 0.0],
+  matrix: _toConsumableArray(IDENTITY),
   pointType: 'Float64Array',
-  generate3DTextureCoordinates: false
+  generate3DTextureCoordinates: false,
+  generateFaces: true,
+  generateLines: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -256,8 +250,17 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['xLength', 'yLength', 'zLength', 'generate3DTextureCoordinates']);
+  macro.setGet(publicAPI, model, ['xLength', 'yLength', 'zLength', 'generate3DTextureCoordinates', 'generateFaces', 'generateLines']);
   macro.setGetArray(publicAPI, model, ['center', 'rotations'], 3);
+  macro.setGetArray(publicAPI, model, ['matrix'], 16); // Internal persistent/static objects
+
+  model._polys = vtkCellArray.newInstance({
+    values: Uint16Array.from(POLY_ARRAY)
+  });
+  model._lineCells = vtkCellArray.newInstance({
+    values: Uint16Array.from(LINE_ARRAY)
+  });
+  macro.moveToProtected(publicAPI, model, ['polys', 'lineCells']);
   macro.algo(publicAPI, model, 0, 1);
   vtkCubeSource(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -3,16 +3,17 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { newInstance as newInstance$1, obj, get, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import { mat4, mat3, vec3 } from 'gl-matrix';
 import vtkClosedPolyLineToSurfaceFilter from '../../Filters/General/ClosedPolyLineToSurfaceFilter.js';
-import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../Filters/Core/Cutter.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
+import vtkImageDataOutlineFilter from '../../Filters/General/ImageDataOutlineFilter.js';
 import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
+import vtkTransform from '../../Common/Transform/Transform.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { v as vtkImageResliceMapperVS } from './glsl/vtkImageResliceMapperVS.glsl.js';
 import { v as vtkImageResliceMapperFS } from './glsl/vtkImageResliceMapperFS.glsl.js';
@@ -789,49 +790,6 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     return [false, 2];
   }
 
-  function transformPoints(points, transform) {
-    var tmp = [0, 0, 0];
-
-    for (var i = 0; i < points.length; i += 3) {
-      var p = points.subarray(i, i + 3);
-
-      if (transform.length === 9) {
-        vec3.transformMat3(tmp, p, transform);
-      } else {
-        vec3.transformMat4(tmp, p, transform);
-      }
-
-      p[0] = tmp[0];
-      p[1] = tmp[1];
-      p[2] = tmp[2];
-    }
-  }
-
-  function imageToCubePolyData(image, outPD) {
-    // First create a cube polydata in the index-space of the image.
-    var sext = image === null || image === void 0 ? void 0 : image.getSpatialExtent();
-
-    if (sext) {
-      model.cubeSource.setXLength(sext[1] - sext[0]);
-      model.cubeSource.setYLength(sext[3] - sext[2]);
-      model.cubeSource.setZLength(sext[5] - sext[4]);
-    } else {
-      model.cubeSource.setXLength(1);
-      model.cubeSource.setYLength(1);
-      model.cubeSource.setZLength(1);
-    }
-
-    model.cubeSource.setCenter(model.cubeSource.getXLength() / 2.0, model.cubeSource.getYLength() / 2.0, model.cubeSource.getZLength() / 2.0);
-    model.cubeSource.update();
-    var out = model.cubeSource.getOutputData();
-    outPD.getPoints().setData(Float32Array.from(out.getPoints().getData()), 3);
-    outPD.getPolys().setData(Uint32Array.from(out.getPolys().getData()), 1); // Now, transform the cube polydata points in-place
-    // using the image's indexToWorld transformation.
-
-    var points = outPD.getPoints().getData();
-    transformPoints(points, image.getIndexToWorld());
-  }
-
   publicAPI.updateResliceGeometry = function () {
     var resGeomString = '';
     var image = model.currentInput;
@@ -900,8 +858,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         model.resliceGeom.getPointData().setNormals(slicePD.getPointData().getNormals());
       } else if (slicePlane) {
         if (!orthoSlicing) {
-          imageToCubePolyData(image, model.cubePolyData);
-          model.cutter.setInputData(model.cubePolyData);
+          model.outlineFilter.setInputData(image);
+          model.cutter.setInputConnection(model.outlineFilter.getOutputPort());
           model.cutter.setCutFunction(slicePlane);
           model.lineToSurfaceFilter.setInputConnection(model.cutter.getOutputPort());
           model.lineToSurfaceFilter.update();
@@ -952,7 +910,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
             }
           }
 
-          transformPoints(ptsArray, image.getIndexToWorld());
+          model.transform.setMatrix(image.getIndexToWorld());
+          model.transform.transformPoints(ptsArray, ptsArray);
           var cellArray = new Uint16Array(8);
           cellArray[0] = 3;
           cellArray[1] = 0;
@@ -1047,10 +1006,13 @@ function extend(publicAPI, model) {
   obj(model.VBOBuildTime);
   model.tmpMat4 = mat4.identity(new Float64Array(16)); // Implicit plane to polydata related cache:
 
-  model.cubeSource = vtkCubeSource.newInstance();
+  model.outlineFilter = vtkImageDataOutlineFilter.newInstance();
+  model.outlineFilter.setGenerateFaces(true);
+  model.outlineFilter.setGenerateLines(false);
   model.cubePolyData = vtkPolyData.newInstance();
   model.cutter = vtkCutter.newInstance();
   model.lineToSurfaceFilter = vtkClosedPolyLineToSurfaceFilter.newInstance();
+  model.transform = vtkTransform.newInstance();
   get(publicAPI, model, ['openGLTexture']); // Object methods
 
   vtkOpenGLImageResliceMapper(publicAPI, model);

package/index.d.ts

@@ -57,6 +57,7 @@
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
 /// <reference path="./Filters/General/ContourTriangulator.d.ts" />
 /// <reference path="./Filters/General/ImageCropFilter.d.ts" />
+/// <reference path="./Filters/General/ImageDataOutlineFilter.d.ts" />
 /// <reference path="./Filters/General/ImageOutlineFilter.d.ts" />
 /// <reference path="./Filters/General/ImageSliceFilter.d.ts" />
 /// <reference path="./Filters/General/ImageStreamline.d.ts" />

package/package.json

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