@kitware/vtk.js 34.10.0 → 34.11.1

package/Filters/Sources/CylinderSource.js

@@ -10,11 +10,7 @@ import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 function vtkCylinderSource(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkCylinderSource');
-  function requestData(inData, outData) {
-    if (model.deleted) {
-      return;
-    }
-    let dataset = outData[0];
+  publicAPI.requestData = (inData, outData) => {
     const angle = 2.0 * Math.PI / model.resolution;
     let numberOfPoints = 2 * model.resolution;
     let numberOfPolys = 5 * model.resolution;
@@ -147,7 +143,7 @@ function vtkCylinderSource(publicAPI, model) {
 
     // Apply transformation to the points coordinates
     vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([0, 1, 0], model.direction).translate(...model.center.map(c => c * -1)).apply(points);
-    dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(polys, 1);
     dataset.getPointData().setNormals(normals);
@@ -155,10 +151,7 @@ function vtkCylinderSource(publicAPI, model) {
 
     // Update output
     outData[0] = dataset;
-  }
-
-  // Expose methods
-  publicAPI.requestData = requestData;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Filters/Sources/DiskSource.js

@@ -25,10 +25,6 @@ function vtkDiskSource(publicAPI, model) {
       circumferentialResolution,
       pointType
     } = model;
-    if (model.deleted) {
-      return;
-    }
-    let dataset = outData[0];
 
     // Points
     const points = vtkPoints.newInstance({
@@ -83,7 +79,7 @@ function vtkDiskSource(publicAPI, model) {
       }
     }
     polys.setData(cellData, cellCount, 1);
-    dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     dataset.setPoints(points);
     dataset.setPolys(polys);
 

package/Filters/Sources/EllipseArcSource.js

@@ -26,7 +26,7 @@ function vtkEllipseArcSource(publicAPI, model) {
     const numLines = resolution;
     const numPts = resolution + 1;
     const tc = [0.0, 0.0];
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
 
     // Make sure the normal vector is normalized
     const normal = [...model.normal];

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/Filters/Sources/ImageGridSource.js

@@ -10,9 +10,6 @@ function vtkImageGridSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageGridSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const state = {};
     const dataset = {
       type: 'vtkImageData',

package/Filters/Sources/LineSource.js

@@ -14,14 +14,11 @@ function vtkLineSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLineSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataset = outData[0];
 
     // Check input
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    const pd = vtkPolyData.newInstance();
+    const pd = dataset?.initialize() || vtkPolyData.newInstance();
     const v21 = [];
     subtract(model.point2, model.point1, v21);
     if (norm(v21) <= 0.0) {

package/Filters/Sources/PlaneSource.js

@@ -18,14 +18,11 @@ function vtkPlaneSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPlaneSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataset = outData[0];
 
     // Check input
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    const pd = vtkPolyData.newInstance();
+    const pd = dataset?.initialize() || vtkPolyData.newInstance();
     const v10 = [];
     const v20 = [];
     subtract(model.point1, model.origin, v10);

package/Filters/Sources/PlatonicSolidSource.js

@@ -63,7 +63,7 @@ function vtkPlatonicSolidSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPlatonicSolidSource');
   publicAPI.requestData = (inData, outData) => {
-    const output = outData[0] || vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     let solidData;
     switch (model.solidType) {
       case SolidType.VTK_SOLID_TETRAHEDRON:

package/Filters/Sources/PointSource.js

@@ -10,14 +10,11 @@ function vtkPointSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataset = outData[0];
 
     // Check input
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    const pd = vtkPolyData.newInstance();
+    const pd = dataset?.initialize() || vtkPolyData.newInstance();
 
     // hand create a point cloud
     const numPts = model.numberOfPoints;

package/Filters/Sources/RTAnalyticSource.js

@@ -8,9 +8,6 @@ function vtkRTAnalyticSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRTAnalyticSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const state = {};
     const dataset = {
       type: 'vtkImageData',

package/Filters/Sources/SLICSource.js

@@ -60,11 +60,8 @@ function vtkSLICSource(publicAPI, model) {
   };
   publicAPI.getNumberOfClusters = () => model.clusters.length;
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const dataSize = model.dimensions[0] * model.dimensions[1] * model.dimensions[2];
-    const imageData = vtkImageData.newInstance();
+    const imageData = outData[0]?.initialize() || vtkImageData.newInstance();
     imageData.setSpacing(...model.spacing);
     imageData.setExtent(0, model.dimensions[0] - 1, 0, model.dimensions[1] - 1, 0, model.dimensions[2] - 1);
     imageData.setOrigin(...model.origin);

package/Filters/Sources/SphereSource.js

@@ -10,12 +10,9 @@ function vtkSphereSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSphereSource');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     let dataset = outData[0];
     const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    dataset = vtkPolyData.newInstance();
+    dataset = dataset?.initialize() || vtkPolyData.newInstance();
 
     // ----------------------------------------------------------------------
     let numPoles = 0;

package/Filters/Sources/ViewFinderSource.js

@@ -4,7 +4,7 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 function vtkViewFinderSource(publicAPI, model) {
   publicAPI.requestData = (inData, outData) => {
-    const dataset = vtkPolyData.newInstance();
+    const dataset = outData[0]?.initialize() || vtkPolyData.newInstance();
     const points = macro.newTypedArray(model.pointType, 3 * 16);
     points[0] = model.radius;
     points[1] = model.radius / model.width;

package/Filters/Texture/TextureMapToPlane.js

@@ -90,16 +90,13 @@ function vtkTextureMapToPlane(publicAPI, model) {
     model.normal[2] = -1.0;
   }
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const input = inData[0];
     const nbPoints = input.getPoints().getNumberOfPoints();
     if (nbPoints < 3 && model.automaticPlaneGeneration) {
       vtkErrorMacro("Can't generate texture coordinates without points");
       return;
     }
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.getPoints().setData(new Float32Array(input.getPoints().getData()), 3);
     output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
     const tcoordsData = [];

package/Filters/Texture/TextureMapToSphere.js

@@ -15,9 +15,6 @@ function vtkTextureMapToSphere(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkTextureMapToSphere');
   publicAPI.requestData = (inData, outData) => {
-    if (model.deleted) {
-      return;
-    }
     const input = inData[0];
     const nbPoints = input.getPoints().getNumberOfPoints();
     if (nbPoints <= 1) {
@@ -108,7 +105,7 @@ function vtkTextureMapToSphere(publicAPI, model) {
       size: nbPoints,
       values: tcoordsData
     });
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.getPoints().setData(new Float32Array(input.getPoints().getData()), 3);
     output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
     output.getPointData().setTCoords(tCoords);

package/Imaging/Core/ImageReslice.js

@@ -206,7 +206,7 @@ function vtkImageReslice(publicAPI, model) {
     });
 
     // Update output
-    const output = vtkImageData.newInstance();
+    const output = outData[0]?.initialize() || vtkImageData.newInstance();
     output.setDimensions(outDims);
     output.setOrigin(outOrigin);
     output.setSpacing(outSpacing);

package/Imaging/Hybrid/SampleFunction.js

@@ -39,7 +39,7 @@ function vtkSampleFunction(publicAPI, model) {
       vtkErrorMacro('Bad volume dimensions');
       return;
     }
-    const volume = vtkImageData.newInstance();
+    const volume = outData[0]?.initialize() || vtkImageData.newInstance();
     const origin = [model.modelBounds[0], model.modelBounds[2], model.modelBounds[4]];
     const spacing = [(model.modelBounds[1] - model.modelBounds[0]) / (dims[0] - 1), (model.modelBounds[3] - model.modelBounds[2]) / (dims[1] - 1), (model.modelBounds[5] - model.modelBounds[4]) / (dims[2] - 1)];
     const sliceSize = dims[0] * dims[1];

package/Rendering/Core/VectorText.js

@@ -241,11 +241,10 @@ function vtkVectorText(publicAPI, model) {
    * Creates a vtkPolyData from the processed shapes
    * @returns {Object} vtkPolyData instance
    */
-  function buildPolyData() {
+  function buildPolyData(polyData) {
     model.verticesArray = [];
     model.uvArray = [];
     model.colorArray = [];
-    const polyData = vtkPolyData.newInstance();
     const cells = vtkCellArray.newInstance();
     const pointData = polyData.getPointData();
 
@@ -328,7 +327,9 @@ function vtkVectorText(publicAPI, model) {
       return;
     }
     buildShape();
-    outData[0] = buildPolyData();
+    const polyData = outData[0]?.initialize() || vtkPolyData.newInstance();
+    buildPolyData(polyData);
+    outData[0] = polyData;
   };
 }
 

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/Widgets/Representations/ImplicitPlaneRepresentation.js

@@ -221,7 +221,7 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
     // --------------------------------
 
     vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
-    const output = vtkPolyData.newInstance();
+    const output = outData[0]?.initialize() || vtkPolyData.newInstance();
     output.shallowCopy(model._pipelines.plane.filter.getOutputData());
     outData[0] = output;
   };