@kitware/vtk.js 24.7.1 → 24.10.0

package/Common/DataModel/PolyLine.d.ts

@@ -0,0 +1,63 @@
+import { Vector2, Vector3 } from './../../types';
+import vtkCell, { ICellInitialValues } from './Cell';
+import { IIntersectWithLine } from './Line';
+
+export interface IPolyLineInitialValues extends ICellInitialValues { }
+
+export interface vtkPolyLine extends vtkCell {
+
+	/**
+	 * Get the topological dimensional of the cell (0, 1, 2 or 3).
+	 */
+	getCellDimension(): number;
+
+	/**
+	 * @param {number} t1
+	 * @param {number} t2
+	 * @param {Vector3} p1 The first point coordinate.
+	 * @param {Vector3} p2 The second point coordinate.
+	 * @param {Number} tol The tolerance to use.
+	 * @param {Vector3} x The point which intersect the line.
+	 * @param {Vector3} pcoords The parametric coordinates.
+	 */
+	intersectWithLine(t1: number, t2: number, p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): IIntersectWithLine;
+
+  /**
+   * Determine global coordinate (x[3]) from subId and parametric coordinates.
+   * Also returns interpolation weights. (The number of weights is equal to
+   * the number of points in the cell.)
+   * 
+   * @param {number} subId
+   * @param {Vector3} pcoords The parametric coordinates
+   * @param {Vector3} x The global coordinate
+   * @param {Vector2} weights The interpolation weights
+   */
+  evaluateLocation(subId: number, pcoords: Vector3, x: Vector3, weights: Vector2): void
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPolyLine characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPolyLineInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IPolyLineInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkPolyLine.
+ * @param {IPolyLineInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IPolyLineInitialValues): vtkPolyLine;
+
+/** 
+ * vtkPolyLine is a cell which representant a poly line.
+ * 
+ * @see vtkCell
+ */
+export declare const vtkPolyLine: {
+	newInstance: typeof newInstance,
+	extend: typeof extend;
+};
+
+export default vtkPolyLine;

package/Common/DataModel/PolyLine.js

@@ -0,0 +1,84 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkCell from './Cell.js';
+import vtkLine from './Line.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function vtkPolyLine(publicAPI, model) {
+  model.classHierarchy.push('vtkPolyLine');
+
+  var superClass = _objectSpread({}, publicAPI);
+
+  var line = vtkLine.newInstance();
+  line.getPoints().setNumberOfPoints(2);
+
+  publicAPI.getCellDimension = function () {
+    return 1;
+  };
+
+  publicAPI.intersectWithLine = function (t1, t2, p1, p2, tol, x, pcoords) {
+    var outObj = {
+      intersect: 0,
+      t: Number.MAX_VALUE,
+      subId: 0,
+      betweenPoints: null
+    };
+    var numLines = superClass.getPoints().getNumberOfPoints() - 1;
+    var pDistMin = Number.MAX_VALUE;
+    var minXYZ = [0, 0, 0];
+    var minPCoords = [0, 0, 0];
+
+    for (var subId = 0; subId < numLines; subId++) {
+      var pCoords = [0, 0, 0];
+      line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+      var lineIntersected = line.intersectWithLine(p1, p2, tol, x, pcoords);
+
+      if (lineIntersected.intersect === 1 && lineIntersected.t <= outObj.t + tol && lineIntersected.t >= t1 && lineIntersected.t <= t2) {
+        outObj.intersect = 1;
+        var pDist = line.getParametricDistance(pCoords);
+
+        if (pDist < pDistMin || pDist === pDistMin && lineIntersected.t < outObj.t) {
+          outObj.subId = subId;
+          outObj.t = lineIntersected.t;
+          pDistMin = pDist;
+
+          for (var k = 0; k < 3; k++) {
+            minXYZ[k] = x[k];
+            minPCoords[k] = pCoords[k];
+          }
+        }
+      }
+    }
+
+    return outObj;
+  };
+
+  publicAPI.evaluateLocation = function (subId, pcoords, x, weights) {
+    line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
+    return line.evaluateLocation(pcoords, x, weights);
+  };
+} // ----------------------------------------------------------------------------
+// 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);
+  vtkCell.extend(publicAPI, model, initialValues);
+  vtkPolyLine(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkPolyLine'); // ----------------------------------------------------------------------------
+
+var vtkPolyLine$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkPolyLine$1 as default, extend, newInstance };

package/Common/DataModel/Polygon.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { l as normalize, g as subtract, j as cross, k as add, d as dot, n as norm } from '../Core/Math/index.js';
+import { l as normalize, s as subtract, j as cross, k as add, d as dot, n as norm } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 import vtkPriorityQueue from '../Core/PriorityQueue.js';

package/Common/DataModel/Spline1D/Constants.js

@@ -0,0 +1,17 @@
+// Boundary conditions available to compute open splines
+// DEFAULT : desired slope at boundary point is derivative from two points (boundary and second interior)
+// DERIVATIVE : desired slope at boundary point is the boundary value given.
+// SECOND_DERIVATIVE : second derivative at boundary point is the boundary value given.
+// SECOND_DERIVATIVE_INTERIOR_POINT : desired second derivative at boundary point is the boundary value given times second derivative
+// at first interior point.
+var BoundaryCondition = {
+  DEFAULT: 0,
+  DERIVATIVE: 1,
+  SECOND_DERIVATIVE: 2,
+  SECOND_DERIVATIVE_INTERIOR_POINT: 3
+};
+var Constants = {
+  BoundaryCondition: BoundaryCondition
+};
+
+export { BoundaryCondition, Constants as default };

package/Common/DataModel/Spline1D.d.ts

@@ -3,6 +3,19 @@ import { vtkObject } from './../../interfaces' ;
 
 export interface ISpline1DInitialValues {}
 
+// Boundary conditions available to compute open splines
+// DEFAULT : desired slope at boundary point is derivative from two points (boundary and second interior)
+// DERIVATIVE : desired slope at boundary point is the boundary value given.
+// SECOND_DERIVATIVE : second derivative at boundary point is the boundary value given.
+// SECOND_DERIVATIVE_INTERIOR_POINT : desired second derivative at boundary point is the boundary value given times second derivative
+// at first interior point.
+export enum BoundaryCondition {
+	DEFAULT,
+	DERIVATIVE,
+	SECOND_DERIVATIVE,
+	SECOND_DERIVATIVE_INTERIOR_POINT,
+  }
+
 export interface vtkSpline1D extends vtkObject {
 
 	/**
@@ -19,9 +32,14 @@ export interface vtkSpline1D extends vtkObject {
 	 * @param {Number} size 
 	 * @param {Float32Array} work 
 	 * @param {Number[]} x 
-	 * @param {Number[]} y 
+	 * @param {Number[]} y
+	 * @param {Object} options
+	 * @param {BoundaryCondition} options.leftConstraint
+	 * @param {Number} options.leftValue
+	 * @param {BoundaryCondition} options.rightConstraint
+	 * @param {Number} options.rightValue
 	 */
-	computeOpenCoefficients(size: number, work: Float32Array, x: number[], y: number[]): void;
+	computeOpenCoefficients(size: number, work: Float32Array, x: number[], y: number[], options: { leftConstraint: BoundaryCondition, leftValue: number, rightConstraint: BoundaryCondition, rightValue: Number }): void;
 		
 	/**
 	 * 

package/Common/DataModel/Spline3D/Constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum splineKind {
+	CARDINAL_SPLINE = 'CARDINAL_SPLINE',
+	KOCHANEK_SPLINE = 'KOCHANEK_SPLINE',
+}
+
+declare const _default: {
+	splineKind: typeof splineKind;
+};
+export default _default;

package/Common/DataModel/Spline3D.d.ts

@@ -1,10 +1,5 @@
-import { vtkObject } from './../../interfaces' ;
-
-export enum splineKind {
-	CARDINAL_SPLINE,
-	KOCHANEK_SPLINE,
-}
-
+import { vtkObject } from './../../interfaces';
+import { splineKind } from './Spline3D/Constants';
 
 export interface ISpline3DInitialValues {
 	close?: boolean;
@@ -52,7 +47,7 @@ export function newInstance(initialValues?: ISpline3DInitialValues): vtkSpline3D
  * at any given point inside the spline intervals.
  */
 export declare const vtkSpline3D: {
-	newInstance: typeof newInstance,
-	extend: typeof extend
+	newInstance: typeof newInstance;
+	extend: typeof extend;
 };
 export default vtkSpline3D;

package/Common/DataModel/Spline3D.js

@@ -11,7 +11,7 @@ function vtkSpline3D(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkSpline3D'); // --------------------------------------------------------------------------
 
-  function computeCoefficients1D(spline, points) {
+  function computeCoefficients1D(spline, points, boundaryConditionValue) {
     if (points.length === 0) {
       vtkErrorMacro('Splines require at least one points');
     } // If we have only one point we create a spline
@@ -25,23 +25,27 @@ function vtkSpline3D(publicAPI, model) {
     var size = points.length;
     var work = null;
     var intervals = null;
+    work = new Float32Array(size);
 
-    if (model.close) {
-      work = new Float32Array(size);
-
-      if (model.intervals.length === 0) {
-        intervals = new Float32Array(size);
+    if (model.intervals.length === 0) {
+      intervals = new Float32Array(size);
 
-        for (var i = 0; i < intervals.length; i++) {
-          intervals[i] = i;
-        }
-      } else {
-        intervals = model.intervals;
+      for (var i = 0; i < intervals.length; i++) {
+        intervals[i] = i;
       }
+    } else {
+      intervals = model.intervals;
+    }
 
+    if (model.close) {
       spline.computeCloseCoefficients(size, work, intervals, points);
     } else {
-      vtkErrorMacro('Open splines are not supported yet!');
+      spline.computeOpenCoefficients(size, work, intervals, points, {
+        leftConstraint: model.boundaryCondition,
+        leftValue: boundaryConditionValue,
+        rightConstraint: model.boundaryCondition,
+        rightValue: boundaryConditionValue
+      });
     }
   } // --------------------------------------------------------------------------
 
@@ -56,9 +60,9 @@ function vtkSpline3D(publicAPI, model) {
     var z = points.map(function (pt) {
       return pt[2];
     });
-    computeCoefficients1D(model.splineX, x);
-    computeCoefficients1D(model.splineY, y);
-    computeCoefficients1D(model.splineZ, z);
+    computeCoefficients1D(model.splineX, x, model.boundaryConditionValues[0]);
+    computeCoefficients1D(model.splineY, y, model.boundaryConditionValues[1]);
+    computeCoefficients1D(model.splineZ, z, model.boundaryConditionValues[2]);
   }; // --------------------------------------------------------------------------
 
 
@@ -101,6 +105,7 @@ var DEFAULT_VALUES = {
   close: false,
   intervals: [],
   kind: splineKind.KOCHANEK_SPLINE,
+  boundaryConditionValues: [0, 0, 0],
   // Passed to the vtkKochanekSpline1D
   tension: 0,
   continuity: 0,

package/Filters/General/ImageCropFilter.d.ts

@@ -1,10 +1,12 @@
 import { vtkAlgorithm, vtkObject } from './../../interfaces';
 
+type CroppingPlanes = number[];
+
 /**
  *
  */
-interface IImageCropFilterInitialValues {
-	croppingPlanes?: any;
+export interface IImageCropFilterInitialValues {
+	croppingPlanes?: CroppingPlanes;
 }
 
 type vtkImageCropFilterBase = vtkObject & vtkAlgorithm;
@@ -15,18 +17,19 @@ export interface vtkImageCropFilter extends vtkImageCropFilterBase {
 	 * Get The cropping planes, in IJK space.
 	 * @default [0, 0, 0, 0, 0, 0].
 	 */
-	getCroppingPlanes(): number[];
+	getCroppingPlanes(): CroppingPlanes;
 
 	/**
 	 * Get The cropping planes, in IJK space.
 	 * @default [0, 0, 0, 0, 0, 0].
 	 */
-	getCroppingPlanesByReference(): number[];
+	getCroppingPlanesByReference(): CroppingPlanes;
 
 	/**
 	 *
 	 */
 	isResetAvailable(): boolean;
+
 	/**
 	 *
 	 */
@@ -43,13 +46,13 @@ export interface vtkImageCropFilter extends vtkImageCropFilterBase {
 	 *
 	 * @param croppingPlanes
 	 */
-	setCroppingPlanes(croppingPlanes: number[]): boolean;
+	setCroppingPlanes(croppingPlanes: CroppingPlanes): boolean;
 
 	/**
 	 *
 	 * @param croppingPlanes
 	 */
-	setCroppingPlanesFrom(croppingPlanes: number[]): boolean;
+	setCroppingPlanesFrom(croppingPlanes: CroppingPlanes): boolean;
 }
 
 /**

package/Filters/Sources/LineSource.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import { g as subtract, n as norm } from '../../Common/Core/Math/index.js';
+import { s as subtract, n as norm } from '../../Common/Core/Math/index.js';
 
 var vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
 // vtkLineSource methods

package/Filters/Sources/PlaneSource.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { g as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, d as dot, j as cross, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 

package/Interaction/Manipulators/MouseCameraUnicamManipulator.js

@@ -5,7 +5,7 @@ import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
 import vtkMouseCameraUnicamRotateManipulator from './MouseCameraUnicamRotateManipulator.js';
 import macro from '../../macros.js';
-import { g as subtract, x as multiplyScalar, l as normalize, d as dot, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { s as subtract, x as multiplyScalar, l as normalize, d as dot, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamManipulator methods

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -10,7 +10,7 @@ import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
-import { B as areEquals, l as normalize, d as dot, C as clampValue, g as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { B as areEquals, l as normalize, d as dot, C as clampValue, s as subtract, j as cross, x as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamRotateManipulator methods

package/Interaction/Manipulators/MouseRangeManipulator.js

@@ -18,9 +18,13 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
 
   function processDelta(listener, delta) {
-    var oldValue = listener.getValue(); // Apply scale and cached delta to current delta
+    var oldValue = listener.getValue(); // if exponential scroll is enabled, we raise our scale to the
+    //  exponent of the net delta of the interaction. The further away
+    // the user's cursor is from the start of the interaction, the more
+    // their movements will effect the value.
 
-    var newDelta = delta * listener.scale + incrementalDelta.get(listener);
+    var scalingFactor = listener.exponentialScroll ? Math.pow(listener.scale, Math.log2(Math.abs(model.interactionNetDelta) + 2)) : listener.scale;
+    var newDelta = delta * scalingFactor + incrementalDelta.get(listener);
     var value = oldValue + newDelta; // Compute new value based on step
 
     var difference = value - listener.min;
@@ -52,6 +56,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.setHorizontalListener = function (min, max, step, getValue, setValue) {
     var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     var getFn = Number.isFinite(getValue) ? function () {
       return getValue;
     } : getValue;
@@ -61,7 +66,8 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       step: step,
       getValue: getFn,
       setValue: setValue,
-      scale: scale
+      scale: scale,
+      exponentialScroll: exponentialScroll
     };
     incrementalDelta.set(model.horizontalListener, 0);
     publicAPI.modified();
@@ -70,6 +76,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.setVerticalListener = function (min, max, step, getValue, setValue) {
     var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     var getFn = Number.isFinite(getValue) ? function () {
       return getValue;
     } : getValue;
@@ -79,7 +86,8 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       step: step,
       getValue: getFn,
       setValue: setValue,
-      scale: scale
+      scale: scale,
+      exponentialScroll: exponentialScroll
     };
     incrementalDelta.set(model.verticalListener, 0);
     publicAPI.modified();
@@ -88,6 +96,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.setScrollListener = function (min, max, step, getValue, setValue) {
     var scale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+    var exponentialScroll = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     var getFn = Number.isFinite(getValue) ? function () {
       return getValue;
     } : getValue;
@@ -97,7 +106,8 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       step: step,
       getValue: getFn,
       setValue: setValue,
-      scale: scale
+      scale: scale,
+      exponentialScroll: exponentialScroll
     };
     incrementalDelta.set(model.scrollListener, 0);
     publicAPI.modified();
@@ -140,6 +150,7 @@ function vtkMouseRangeManipulator(publicAPI, model) {
 
   publicAPI.onButtonDown = function (interactor, renderer, position) {
     model.previousPosition = position;
+    model.interactionNetDelta = 0;
     var glRenderWindow = interactor.getView(); // Ratio is the dom size vs renderwindow size
 
     var ratio = glRenderWindow.getContainerSize()[0] / glRenderWindow.getSize()[0]; // Get proper pixel range used by viewport in rw size space
@@ -216,12 +227,14 @@ function vtkMouseRangeManipulator(publicAPI, model) {
     if (model.horizontalListener) {
       var dxNorm = (position.x - model.previousPosition.x) / model.containerSize[0];
       var dx = scaleDeltaToRange(model.horizontalListener, dxNorm);
+      model.interactionNetDelta += dx;
       processDelta(model.horizontalListener, dx);
     }
 
     if (model.verticalListener) {
       var dyNorm = (position.y - model.previousPosition.y) / model.containerSize[1];
       var dy = scaleDeltaToRange(model.verticalListener, dyNorm);
+      model.interactionNetDelta += dy;
       processDelta(model.verticalListener, dy);
     }
 
@@ -234,10 +247,14 @@ function vtkMouseRangeManipulator(publicAPI, model) {
       return;
     }
 
+    model.interactionNetDelta += delta * model.scrollListener.step;
     processDelta(model.scrollListener, delta * model.scrollListener.step);
   };
 
-  publicAPI.onStartScroll = publicAPI.onScroll;
+  publicAPI.onStartScroll = function (payload) {
+    model.interactionNetDelta = 0;
+    publicAPI.onScroll(payload);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Interaction/Widgets/OrientationMarkerWidget/Constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum Corners {
+	TOP_LEFT = 'TOP_LEFT',
+	TOP_RIGHT = 'TOP_RIGHT',
+	BOTTOM_LEFT = 'BOTTOM_LEFT',
+	BOTTOM_RIGHT = 'BOTTOM_RIGHT',
+}
+
+declare const _default: {
+	Corners: typeof Corners;
+};
+export default _default;

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -4,13 +4,8 @@ import vtkAxesActor from './../../Rendering/Core/AxesActor';
 import vtkRenderer from './../../Rendering/Core/Renderer';
 import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
 import { Nullable } from './../../types';
+import { Corners } from './OrientationMarkerWidget/Constants';
 
-export enum Corners {
-	TOP_LEFT,
-	TOP_RIGHT,
-	BOTTOM_LEFT,
-	BOTTOM_RIGHT,
-}
 
 /**
  * 
@@ -177,5 +172,6 @@ export function newInstance(initialValues?: IOrientationMarkerWidgetInitialValue
 export declare const vtkOrientationMarkerWidget: {
 	newInstance: typeof newInstance;
 	extend: typeof extend;
+	Corners: typeof Corners;
 }
 export default vtkOrientationMarkerWidget;