@kitware/vtk.js 27.5.0 → 28.0.0

package/BREAKING_CHANGES.md

@@ -1,3 +1,7 @@
+## From 26.x to 27
+
+- Change all `handleEvent` signatures of manipulators. Used to be `handleEvent(callData, glRenderWindow): vec3`, it is now `handleEvent(callData, glRenderWindow): { worldCoords: Nullable<vec3>, worldDirection?: mat3 }`.
+
 ## From 25.x to 26
 
 - **ResliceCursorWidget**: vtkResliceCursorContextRepresentation is deprecated and removed.

package/Common/DataModel/Line.d.ts

@@ -1,4 +1,5 @@
-import { Vector3, Vector2 } from './../../types';
+import { quat } from 'gl-matrix';
+import { Vector3, Vector2, Nullable } from './../../types';
 import vtkCell from './Cell';
 
 export enum IntersectionState {
@@ -7,7 +8,9 @@ export enum IntersectionState {
 	ON_LINE,
 }
 
-interface ILineInitialValues { }
+export interface ILineInitialValues {
+	orientations: Nullable<quat[]>;
+}
 
 export interface IIntersectWithLine {
 	intersect: number;
@@ -29,6 +32,18 @@ export interface vtkLine extends vtkCell {
 	 */
 	getCellDimension(): number;
 
+	/**
+	 * Get the list of orientations (a list of quat) for each point of the line.
+	 * Can be null if the line is not oriented
+	 */
+	getOrientations(): Nullable<quat[]>;
+
+	/**
+	 * @see getOrientations
+	 * @param orientations The list of orientation per point of the centerline
+	 */
+	setOrientations(orientations: Nullable<quat[]>): boolean;
+
 	/**
 	 * Compute the intersection point of the intersection between line and line
 	 * defined by p1 and p2. tol Tolerance use for the position evaluation x is
@@ -55,6 +70,13 @@ export interface vtkLine extends vtkCell {
 	 * Determine the global coordinates `x' and parametric coordinates `pcoords' in the cell.
 	 */
 	evaluateLocation(pcoords: Vector3, x: Vector3, weights: Vector2): void
+
+	/**
+	 * Determine the global orientation `q' and parametric coordinates `pcoords' in the cell.
+	 * Use slerp to interpolate orientation
+	 * Returns wether the orientation has been set in `q'
+	 */
+	evaluateOrientation(pcoords: Vector3, q: quat, weights: Vector2): boolean
 }
 
 /**

package/Common/DataModel/Line.js

@@ -3,6 +3,7 @@ import macro from '../../macros.js';
 import Constants from './Line/Constants.js';
 import vtkCell from './Cell.js';
 import { d as dot, e as distance2BetweenPoints, s as subtract, g as solveLinearSystem } from '../Core/Math/index.js';
+import { quat } from 'gl-matrix';
 
 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; }
 
@@ -242,17 +243,32 @@ function vtkLine(publicAPI, model) {
     weights[0] = 1.0 - pcoords[0];
     weights[1] = pcoords[0];
   };
+
+  publicAPI.evaluateOrientation = function (pcoords, q, weights) {
+    if (model.orientations) {
+      quat.slerp(q, model.orientations[0], model.orientations[1], pcoords[0]);
+      weights[0] = 1.0 - pcoords[0];
+      weights[1] = pcoords[0];
+      return true;
+    }
+
+    return false;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var DEFAULT_VALUES = {
+  orientations: null // an array of two quat or null
+
+}; // ----------------------------------------------------------------------------
 
 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);
+  macro.setGet(publicAPI, model, ['orientations']);
   vtkLine(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Common/DataModel/PolyLine.d.ts

@@ -1,3 +1,4 @@
+import { quat } from 'gl-matrix';
 import { Vector2, Vector3 } from './../../types';
 import vtkCell, { ICellInitialValues } from './Cell';
 import { IIntersectWithLine } from './Line';
@@ -24,8 +25,8 @@ export interface vtkPolyLine extends vtkCell {
 
   /**
    * 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.)
+   * Also set interpolation weights. (There are two weights for the two
+   * points of the line segment specified by subId)
    * 
    * @param {number} subId
    * @param {Vector3} pcoords The parametric coordinates
@@ -33,6 +34,39 @@ export interface vtkPolyLine extends vtkCell {
    * @param {Vector2} weights The interpolation weights
    */
   evaluateLocation(subId: number, pcoords: Vector3, x: Vector3, weights: Vector2): void
+
+  /**
+   * Determine global orientation (q[3]) from subId and parametric coordinates.
+   * This uses the same algorithm as vtkLine (interpolates using slerp).
+   * Also set interpolation weights. (There are two weights for the two
+   * points of the line segment specified by subId)
+   * 
+   * @param {number} subId
+   * @param {Vector3} pcoords The parametric coordinates
+   * @param {Vector3} q The global orientation
+   * @param {Vector2} weights The interpolation weights
+   * @returns {boolean} Wether the orientation has been set in `q'
+   */
+  evaluateOrientation(subId: number, pcoords: Vector3, q: quat, weights: Vector2): boolean
+
+  /**
+   * Returns an array containing for each pointIdx between 0 (included) and
+   * numberOfPoints (excluded) the distance from the first point of the
+   * polyline to the point at pointIdx
+   * In particular if tda = publicAPI.getDistancesToFirstPoint(), then tda[0] = 0
+   * and tda[tda.length - 1] is the total length of the polyline
+   */
+  getDistancesToFirstPoint(): number[]
+
+  /**
+   * Returns the subId of the segment at the given distance from the first
+   * point of the polyline
+   * If the distance is negative or greater than the total length of the
+   * polyline, returns -1
+   * 
+   * @param distance The distance from the first point of the polyline
+   */
+  findPointIdAtDistanceFromFirstPoint(distance: number): number;
 }
 
 /**

package/Common/DataModel/PolyLine.js

@@ -1,17 +1,10 @@
-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; }
+import { vec3 } from 'gl-matrix';
 
 function vtkPolyLine(publicAPI, model) {
   model.classHierarchy.push('vtkPolyLine');
-
-  var superClass = _objectSpread({}, publicAPI);
-
   var line = vtkLine.newInstance();
   line.getPoints().setNumberOfPoints(2);
 
@@ -26,7 +19,7 @@ function vtkPolyLine(publicAPI, model) {
       subId: 0,
       betweenPoints: null
     };
-    var numLines = superClass.getPoints().getNumberOfPoints() - 1;
+    var numLines = publicAPI.getNumberOfPoints() - 1;
     var pDistMin = Number.MAX_VALUE;
 
     for (var subId = 0; subId < numLines; subId++) {
@@ -53,17 +46,94 @@ function vtkPolyLine(publicAPI, model) {
     line.getPoints().getData().set(model.points.getData().subarray(3 * subId, 3 * (subId + 2)));
     return line.evaluateLocation(pcoords, x, weights);
   };
+
+  publicAPI.evaluateOrientation = function (subId, pcoords, q, weights) {
+    if (model.orientations) {
+      line.setOrientations([model.orientations[subId], model.orientations[subId + 1]]);
+    } else {
+      line.setOrientations(null);
+    }
+
+    return line.evaluateOrientation(pcoords, q, weights);
+  };
+
+  publicAPI.getDistancesToFirstPoint = function () {
+    if (model.distancesTime.getMTime() < model.points.getMTime()) {
+      var numPoints = publicAPI.getNumberOfPoints();
+
+      if (!model.distances) {
+        model.distances = new Array(numPoints);
+      } else {
+        model.distances.length = numPoints;
+      }
+
+      if (numPoints > 0) {
+        var previousPoint = new Array(3);
+        var currentPoint = new Array(3);
+        var totalDistance = 0;
+        model.distances[0] = totalDistance;
+        model.points.getPoint(0, previousPoint);
+
+        for (var i = 1; i < numPoints; ++i) {
+          model.points.getPoint(i, currentPoint);
+          totalDistance += vec3.dist(previousPoint, currentPoint);
+          model.distances[i] = totalDistance;
+          vec3.copy(previousPoint, currentPoint);
+        }
+      }
+
+      model.distancesTime.modified();
+    }
+
+    return model.distances;
+  };
+
+  publicAPI.findPointIdAtDistanceFromFirstPoint = function (distance) {
+    var distances = publicAPI.getDistancesToFirstPoint(); // At least two points to return an ID
+
+    if (distances.length < 2) {
+      return -1;
+    } // Binary search in the distance array
+
+
+    var minId = 0;
+    var maxId = distances.length - 1;
+
+    if (distance < distances[minId] || distance > distances[maxId] || distances[maxId] === 0) {
+      return -1;
+    }
+
+    while (maxId - minId > 1) {
+      var midId = Math.floor((minId + maxId) / 2);
+
+      if (distances[midId] <= distance) {
+        minId = midId;
+      } else {
+        maxId = midId;
+      }
+    }
+
+    return minId;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var DEFAULT_VALUES = {
+  orientations: null // an array of quat or null
+
+}; // ----------------------------------------------------------------------------
 
 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);
+  macro.setGet(publicAPI, model, ['orientations']);
+  model.distancesTime = {};
+  macro.obj(model.distancesTime, {
+    mtime: 0
+  });
   vtkPolyLine(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Common/Transform/Transform.d.ts

@@ -0,0 +1,177 @@
+import { mat4, vec3 } from 'gl-matrix';
+import { vtkObject } from './../../interfaces';
+import { TypedArray } from './../../types';
+
+export interface ITransformInitialValues { 
+	preMultiplyFlag?: boolean;
+	matrix?: number[];
+}
+
+type TSlicableArray = number[] | TypedArray;
+
+
+export interface vtkTransform extends vtkObject {
+
+	/**
+	 * Mat4 matrix, used by vtkTransform to transform points, vertices, matrices...
+	 * Default is identity.
+	 */
+	getMatrix(): mat4;
+
+	/**
+	 * @see getMatrix
+	 * @param {mat4} matrix
+	 */
+	setMatrix(matrix: mat4): boolean;
+
+	/**
+	 * @see getMatrix
+	 * Matrix is stored using gl-matrix conventions: column major
+	 * @param e00
+	 * @param e01
+	 * @param e02
+	 * @param e03
+	 * @param e10
+	 * @param e11
+	 * @param e12
+	 * @param e13
+	 * @param e20
+	 * @param e21
+	 * @param e22
+	 * @param e23
+	 * @param e30
+	 * @param e31
+	 * @param e32
+	 * @param e33
+	 */
+	setMatrix(e00: number, e01: number, e02: number, e03: number, e10: number, e11: number, e12: number, e13: number, e20: number, e21: number, e22: number, e23: number, e30: number, e31: number, e32: number, e33: number): boolean;
+
+	/**
+	 * The value of preMultiplyFlag indicates how matrix multiplications should occur.
+	 * 
+	 * When in premultiply mode:
+	 * All subsequent operations will occur before those already represented in the current transformation.
+	 * In homogeneous matrix notation, M = M*A where M is the current transformation matrix and A is the applied matrix.
+	 *
+	 * When in postmultiply mode:
+	 * All subsequent operations will occur after those already represented in the current transformation.
+	 * In homogeneous matrix notation, M = A*M where M is the current transformation matrix and A is the applied matrix.
+	 *
+	 * This flag is also used in @see transformMatrix and @see transformMatrices to indicate how transform is applied to matrices:
+	 * Premultiply: O_i = M * A_i
+	 * Postmultiply: O_i = A_i * M
+	 * where M is the current transformation matrix, A_i are the matrices in argument, O_i are the output matrices.
+	 *
+	 * The default is PreMultiply.
+	 */
+	getPreMultiplyFlag(): boolean;
+
+	/**
+	 * @see getPreMultiplyFlag
+	 * @param preMultiplyFlag
+	 */
+	setPreMultiplyFlag(preMultiplyFlag: boolean): boolean;
+
+	/**
+	 * Set preMultiplyFlag to true
+	 * @see getPreMultiplyFlag
+	 */
+	preMultiply(): void;
+
+	/**
+	 * Set preMultiplyFlag to false
+	 * @see getPreMultiplyFlag
+	 */
+	postMultiply(): void;
+
+	/**
+	 * Transform a single point using the internal transform matrix
+	 * The resulting point is: Pout = M * Pin where M is the internal matrix, Pin and Pout the in and out points
+	 * @param point The point to transform, is not modified (except if point === out)
+	 * @param out The receiving output point, is modified, can be the same as point
+	 * @returns The out parameter
+	 */
+	transformPoint(point: vec3, out: vec3): vec3;
+
+	/**
+	 * Transform multiple points using the internal transform matrix
+	 * See @see transformPoint for more info
+	 * Modify the out array only
+	 * @param points An array (typed or not) containing n*3 elements or of shape (n, 3)
+	 * @param out An array (typed or not) containing n*3 elements or of shape (n, 3)
+	 */
+	transformPoints(points: TSlicableArray, out: TSlicableArray): TSlicableArray;
+
+
+	/**
+	 * Transform a single matrix using the internal transform matrix
+	 * The resulting matrix is:
+	 * Mout = M * Min when in premultiply mode
+	 * Mout = Min * M when in postmultiply mode
+	 * @param matrix The matrix to transform, is not modified (except if matrix === out)
+	 * @param out The receiving output matrix, is modified, can be the same as matrix
+	 * @returns The out parameter
+	 */
+	transformMatrix(matrix: mat4, out: mat4): mat4;
+
+	/**
+	 * Transform multiple matrices using the internal transform matrix
+	 * See @see transformMatrix for more info
+	 * Modify the out array only
+	 * @param matrices An array (typed or not) containing n*16 elements or of shape (n, 16)
+	 * @param out An array (typed or not) containing n*16 elements or of shape (n, 16)
+	 */
+	transformMatrices(matrices: TSlicableArray, out: TSlicableArray): TSlicableArray;
+
+	/**
+	 * @returns A new transform with an inversed internal matrix. Also copy the premultiply flag @see getPreMultiplyFlag.
+	 */
+	getInverse(): vtkTransform;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkTransform characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITransformInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: ITransformInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkTransform.
+ * @param {ITransformInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: ITransformInitialValues): vtkTransform;
+
+
+/**
+ * vtkTransform describes linear transformations via a 4x4 matrix.
+ *
+ * A vtkTransform can be used to describe the full range of linear (also known as affine) coordinate transformations in three dimensions, which are internally represented as a 4x4 homogeneous transformation matrix. When you create a new vtkTransform, it is always initialized to the identity transformation.
+ *
+ * Most of the methods for manipulating this transformation (e.g. transformMatrices, transformMatrix) (TODO: Translate, Rotate, Concatenate...) can operate in either PreMultiply (the default) or PostMultiply mode. In PreMultiply mode, the translation, concatenation, etc. will occur before any transformations which are represented by the current matrix. In PostMultiply mode, the additional transformation will occur after any transformations represented by the current matrix.
+ *
+ * This class performs all of its operations in a right handed coordinate system with right handed rotations. Some other graphics libraries use left handed coordinate systems and rotations.
+ *
+ * @example
+ * ```js
+ * import vtkTransform from '@kitware/vtk.js/Common/Transform/Transform';
+ * import vtkMatrixBuilder from '@kitware/vtk.js/Common/Core/MatrixBuilder';
+ * 
+ * const transform = vtkTransform.newInstance();
+ * const matrix = vtkMatrixBuilder
+ *   .buildFromDegree()
+ *   .rotateZ(45)
+ *   .getMatrix();
+ * transform.setMatrix(matrix);
+ * const pointsIn = [[1, 2, 3], [4, 5, 6]];
+ * const pointsOut = new Float32Array(6);
+ * transform.transformPoints(pointsIn, pointsOut);
+ * ```
+ */
+export declare const vtkTransform: {
+	newInstance: typeof newInstance,
+	extend: typeof extend;
+};
+export default vtkTransform;

package/Common/Transform/Transform.js

@@ -1,8 +1,8 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import { vec3 } from 'gl-matrix';
+import { IDENTITY } from '../Core/Math/Constants.js';
+import { vec3, mat4 } from 'gl-matrix';
 import macro from '../../macros.js';
 import { f as vtkMath } from '../Core/Math/index.js';
-import { IDENTITY } from '../Core/Math/Constants.js';
 
 // vtkTransform methods
 // ----------------------------------------------------------------------------
@@ -19,9 +19,85 @@ function vtkTransform(publicAPI, model) {
     return out;
   };
 
+  publicAPI.transformPoints = function (points, out) {
+    var inPoint = new Float64Array(3);
+    var outPoint = new Float64Array(3);
+
+    for (var i = 0; i < points.length; i += 3) {
+      inPoint[0] = points[i];
+      inPoint[1] = points[i + 1];
+      inPoint[2] = points[i + 2];
+      vec3.transformMat4(outPoint, inPoint, model.matrix);
+      out[i] = outPoint[0];
+      out[i + 1] = outPoint[1];
+      out[i + 2] = outPoint[2];
+    }
+
+    return out;
+  };
+  /**
+   * Sets the internal state of the transform to PreMultiply.
+   * All subsequent operations will occur before those already represented in the current transformation.
+   * In homogeneous matrix notation, M = M*A where M is the current transformation matrix and A is the applied matrix.
+   * The default is PreMultiply.
+   */
+
+
+  publicAPI.preMultiply = function () {
+    publicAPI.setPreMultiplyFlag(true);
+  };
+  /**
+   * Sets the internal state of the transform to PostMultiply.
+   * All subsequent operations will occur after those already represented in the current transformation.
+   * In homogeneous matrix notation, M = A*M where M is the current transformation matrix and A is the applied matrix.
+   * The default is PreMultiply.
+   */
+
+
+  publicAPI.postMultiply = function () {
+    publicAPI.setPreMultiplyFlag(false);
+  };
+
+  publicAPI.transformMatrix = function (matrix, out) {
+    if (model.preMultiplyFlag) {
+      mat4.multiply(out, model.matrix, matrix);
+    } else {
+      mat4.multiply(out, matrix, model.matrix);
+    }
+
+    return out;
+  }; // Apply the transform to each matrix in the same way as transformMatrix
+  // `matrices` can be a contiguous array of float or an array of array
+
+
+  publicAPI.transformMatrices = function (matrices, out) {
+    var inMat = new Float64Array(16);
+    var outMat = new Float64Array(16);
+    var transform = model.preMultiplyFlag ? function () {
+      return mat4.multiply(outMat, model.matrix, inMat);
+    } : function () {
+      return mat4.multiply(outMat, inMat, model.matrix);
+    };
+
+    for (var i = 0; i < matrices.length; i += 16) {
+      for (var j = 0; j < 16; ++j) {
+        inMat[j] = matrices[i + j];
+      }
+
+      transform();
+
+      for (var _j = 0; _j < 16; ++_j) {
+        out[i + _j] = outMat[_j];
+      }
+    }
+
+    return out;
+  };
+
   publicAPI.getInverse = function () {
     return newInstance({
-      matrix: vtkMath.invertMatrix(Array.from(model.matrix), [], 4)
+      matrix: vtkMath.invertMatrix(Array.from(model.matrix), [], 4),
+      preMultiplyFlag: model.preMultiplyFlag
     });
   };
 } // ----------------------------------------------------------------------------
@@ -30,6 +106,7 @@ function vtkTransform(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
+  preMultiplyFlag: false,
   matrix: _toConsumableArray(IDENTITY)
 }; // ----------------------------------------------------------------------------
 
@@ -37,6 +114,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['preMultiplyFlag']);
   macro.setGetArray(publicAPI, model, ['matrix'], 16);
   vtkTransform(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Proxy/Core/View2DProxy.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkMouseRangeManipulator from '../../Interaction/Manipulators/MouseRangeManipulator.js';
 import vtkViewProxy from './ViewProxy.js';
-import { j as cross, E as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { j as cross, E as getMajorAxisIndex, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { mat4, vec3 } from 'gl-matrix';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 
@@ -68,6 +68,10 @@ function getPropCoarseHull(prop) {
   // It gives a more accurate hull than computing the corners of a transformed bounding box
 
 
+  if (!vtkBoundingBox.isValid(finestBounds)) {
+    return [];
+  }
+
   var corners = [];
   vtkBoundingBox.getCorners(finestBounds, corners);
 
@@ -192,6 +196,10 @@ function vtkView2DProxy(publicAPI, model) {
           return visiblePoints.push.apply(visiblePoints, _toConsumableArray(getPropCoarseHull(prop)));
         });
       });
+    }
+
+    if (!visiblePoints) {
+      return initialReset;
     } // Get the bounds in view coordinates
 
 
@@ -203,26 +211,28 @@ function vtkView2DProxy(publicAPI, model) {
       var point = visiblePoints[i];
       vec3.transformMat4(point, point, viewMatrix);
       vtkBoundingBox.addPoint.apply(vtkBoundingBox, [viewBounds].concat(_toConsumableArray(point)));
-    } // Compute focal point and position
+    } // Compute parallel scale
 
 
+    var view = model.renderer.getRenderWindow().getViews()[0];
+    var dims = view.getViewportSize(model.renderer);
+    var aspect = dims[1] && dims[0] ? dims[0] / dims[1] : 1;
+    var xLength = vtkBoundingBox.getLength(viewBounds, 0);
+    var yLength = vtkBoundingBox.getLength(viewBounds, 1);
+    var parallelScale = 0.5 * Math.max(yLength, xLength / aspect); // Compute focal point and position
+
     var viewFocalPoint = vtkBoundingBox.getCenter(viewBounds); // Camera position in view coordinates is the center of the bounds in XY
-    // and the maximum bound + 1 in Z
+    // and is (the maximum bound) + (the distance to see the bounds in perspective) in Z
 
-    var viewPosition = [viewFocalPoint[0], viewFocalPoint[1], viewBounds[5] + 1];
+    var perspectiveAngle = radiansFromDegrees(model.camera.getViewAngle());
+    var distance = parallelScale / Math.tan(perspectiveAngle * 0.5);
+    var viewPosition = [viewFocalPoint[0], viewFocalPoint[1], viewBounds[5] + distance];
     var inverseViewMatrix = new Float64Array(16);
     var worldFocalPoint = new Float64Array(3);
     var worldPosition = new Float64Array(3);
     mat4.invert(inverseViewMatrix, viewMatrix);
     vec3.transformMat4(worldFocalPoint, viewFocalPoint, inverseViewMatrix);
-    vec3.transformMat4(worldPosition, viewPosition, inverseViewMatrix); // Compute parallel scale
-
-    var view = model.renderer.getRenderWindow().getViews()[0];
-    var dims = view.getViewportSize(model.renderer);
-    var aspect = dims[0] / dims[1];
-    var xLength = vtkBoundingBox.getLength(viewBounds, 0);
-    var yLength = vtkBoundingBox.getLength(viewBounds, 1);
-    var parallelScale = 0.5 * Math.max(yLength, xLength / aspect);
+    vec3.transformMat4(worldPosition, viewPosition, inverseViewMatrix);
 
     if (parallelScale <= 0) {
       return initialReset;

package/Rendering/Core/AbstractMapper3D.d.ts

@@ -17,19 +17,17 @@ export interface vtkAbstractMapper3D extends vtkAbstractMapper {
 	 */
 	getBounds(): Bounds;
 
-		
 	/**
 	 * Get the center of this mapper’s data.
 	 * @return {Vector3} The center of the mapper's data.
 	 */
 	getCenter(): Vector3;
-		
+	
 	/**
 	 * Get the diagonal length of this mappers bounding box.
 	 * @return {Number} The diagonal length of mapper bounding box.
 	 */
 	getLength(): number;
-		
 }
 
 /**