@kitware/vtk.js 28.7.0 → 28.8.1

package/Common/Core/Math/index.js

@@ -2370,4 +2370,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { factorial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, isInf as F, rgb2hsv as G, rgb2lab as H, lab2rgb as I, floor as J, round as K, normalize2D as L, nearestPowerOfTwo as M, createUninitializedBounds as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, createArray as T, Pi as U, ceil as V, min as W, max as X, arrayMin as Y, arrayMax as Z, ceilLog2 as _, areMatricesEqual as a, binomial as a0, beginCombination as a1, nextCombination as a2, randomSeed as a3, getSeed as a4, gaussian as a5, multiplyScalar2D as a6, multiplyAccumulate2D as a7, outer as a8, projectVector as a9, singularValueDecomposition3x3 as aA, luFactorLinearSystem as aB, luSolveLinearSystem as aC, invertMatrix as aD, estimateMatrixCondition as aE, solveHomogeneousLeastSquares as aF, solveLeastSquares as aG, hex2float as aH, lab2xyz as aI, xyz2lab as aJ, xyz2rgb as aK, rgb2xyz as aL, computeBoundsFromPoints as aM, clampAndNormalizeValue as aN, getScalarTypeFittingRange as aO, getAdjustedScalarRange as aP, extentIsWithinOtherExtent as aQ, boundsIsWithinOtherBounds as aR, pointIsWithinBounds as aS, solve3PointCircle as aT, inf as aU, negInf as aV, isFinite as aW, isNaN as aX, floatToHex2 as aY, floatRGB2HexCode as aZ, float2CssRGBA as a_, dot2D as aa, projectVector2D as ab, gaussianAmplitude as ac, gaussianWeight as ad, outer2D as ae, norm2D as af, rowsToMat4 as ag, columnsToMat4 as ah, columnsToMat3 as ai, LUFactor3x3 as aj, LUSolve3x3 as ak, linearSolve3x3 as al, multiply3x3_mat3 as am, multiplyMatrix as an, transpose3x3 as ao, invert3x3 as ap, identity3x3 as aq, identity as ar, isIdentity as as, isIdentity3x3 as at, quaternionToMatrix3x3 as au, roundNumber as av, matrix3x3ToQuaternion as aw, multiplyQuaternion as ax, orthogonalize3x3 as ay, diagonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { factorial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor as K, round as L, normalize2D as M, nearestPowerOfTwo as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, createArray as T, Pi as U, ceil as V, min as W, max as X, arrayMin as Y, arrayMax as Z, ceilLog2 as _, areMatricesEqual as a, binomial as a0, beginCombination as a1, nextCombination as a2, randomSeed as a3, getSeed as a4, gaussian as a5, multiplyScalar2D as a6, multiplyAccumulate2D as a7, outer as a8, projectVector as a9, singularValueDecomposition3x3 as aA, luFactorLinearSystem as aB, luSolveLinearSystem as aC, invertMatrix as aD, estimateMatrixCondition as aE, solveHomogeneousLeastSquares as aF, solveLeastSquares as aG, hex2float as aH, lab2xyz as aI, xyz2lab as aJ, xyz2rgb as aK, rgb2xyz as aL, computeBoundsFromPoints as aM, clampAndNormalizeValue as aN, getScalarTypeFittingRange as aO, getAdjustedScalarRange as aP, extentIsWithinOtherExtent as aQ, boundsIsWithinOtherBounds as aR, pointIsWithinBounds as aS, solve3PointCircle as aT, inf as aU, negInf as aV, isFinite as aW, isNaN as aX, floatToHex2 as aY, floatRGB2HexCode as aZ, float2CssRGBA as a_, dot2D as aa, projectVector2D as ab, gaussianAmplitude as ac, gaussianWeight as ad, outer2D as ae, norm2D as af, rowsToMat4 as ag, columnsToMat4 as ah, columnsToMat3 as ai, LUFactor3x3 as aj, LUSolve3x3 as ak, linearSolve3x3 as al, multiply3x3_mat3 as am, multiplyMatrix as an, transpose3x3 as ao, invert3x3 as ap, identity3x3 as aq, identity as ar, isIdentity as as, isIdentity3x3 as at, quaternionToMatrix3x3 as au, roundNumber as av, matrix3x3ToQuaternion as aw, multiplyQuaternion as ax, orthogonalize3x3 as ay, diagonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.js

@@ -3,4 +3,4 @@ import '@babel/runtime/helpers/toConsumableArray';
 import 'seedrandom';
 import '../../macros.js';
 import './Math/Constants.js';
-export { aj as LUFactor3x3, ak as LUSolve3x3, U as Pi, k as add, R as angleBetweenVectors, P as areBoundsInitialized, B as areEquals, a as areMatricesEqual, Z as arrayMax, Y as arrayMin, D as arrayRange, a1 as beginCombination, a0 as binomial, aR as boundsIsWithinOtherBounds, V as ceil, _ as ceilLog2, aN as clampAndNormalizeValue, C as clampValue, c as clampVector, ai as columnsToMat3, ah as columnsToMat4, aM as computeBoundsFromPoints, T as createArray, N as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, az as diagonalize3x3, e as distance2BetweenPoints, d as dot, aa as dot2D, aE as estimateMatrixCondition, aQ as extentIsWithinOtherExtent, $ as factorial, a_ as float2CssRGBA, aZ as floatRGB2HexCode, aY as floatToHex2, J as floor, a5 as gaussian, ac as gaussianAmplitude, ad as gaussianWeight, aP as getAdjustedScalarRange, E as getMajorAxisIndex, aO as getScalarTypeFittingRange, a4 as getSeed, aH as hex2float, h as hsv2rgb, ar as identity, aq as identity3x3, aU as inf, ap as invert3x3, aD as invertMatrix, aW as isFinite, as as isIdentity, at as isIdentity3x3, F as isInf, aX as isNaN, i as isNan, Q as isPowerOfTwo, t as jacobi, p as jacobiN, I as lab2rgb, aI as lab2xyz, al as linearSolve3x3, aB as luFactorLinearSystem, aC as luSolveLinearSystem, aw as matrix3x3ToQuaternion, X as max, W as min, am as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a7 as multiplyAccumulate2D, an as multiplyMatrix, ax as multiplyQuaternion, w as multiplyScalar, a6 as multiplyScalar2D, M as nearestPowerOfTwo, aV as negInf, a2 as nextCombination, n as norm, af as norm2D, l as normalize, L as normalize2D, ay as orthogonalize3x3, a8 as outer, ae as outer2D, q as perpendiculars, aS as pointIsWithinBounds, a9 as projectVector, ab as projectVector2D, au as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a3 as randomSeed, G as rgb2hsv, H as rgb2lab, aL as rgb2xyz, K as round, av as roundNumber, b as roundVector, z as rowsToMat3, ag as rowsToMat4, S as signedAngleBetweenVectors, aA as singularValueDecomposition3x3, aT as solve3PointCircle, aF as solveHomogeneousLeastSquares, aG as solveLeastSquares, g as solveLinearSystem, s as subtract, ao as transpose3x3, u as uninitializeBounds, aJ as xyz2lab, aK as xyz2rgb } from './Math/index.js';
+export { aj as LUFactor3x3, ak as LUSolve3x3, U as Pi, k as add, R as angleBetweenVectors, P as areBoundsInitialized, B as areEquals, a as areMatricesEqual, Z as arrayMax, Y as arrayMin, D as arrayRange, a1 as beginCombination, a0 as binomial, aR as boundsIsWithinOtherBounds, V as ceil, _ as ceilLog2, aN as clampAndNormalizeValue, C as clampValue, c as clampVector, ai as columnsToMat3, ah as columnsToMat4, aM as computeBoundsFromPoints, T as createArray, F as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, az as diagonalize3x3, e as distance2BetweenPoints, d as dot, aa as dot2D, aE as estimateMatrixCondition, aQ as extentIsWithinOtherExtent, $ as factorial, a_ as float2CssRGBA, aZ as floatRGB2HexCode, aY as floatToHex2, K as floor, a5 as gaussian, ac as gaussianAmplitude, ad as gaussianWeight, aP as getAdjustedScalarRange, E as getMajorAxisIndex, aO as getScalarTypeFittingRange, a4 as getSeed, aH as hex2float, h as hsv2rgb, ar as identity, aq as identity3x3, aU as inf, ap as invert3x3, aD as invertMatrix, aW as isFinite, as as isIdentity, at as isIdentity3x3, G as isInf, aX as isNaN, i as isNan, Q as isPowerOfTwo, t as jacobi, p as jacobiN, J as lab2rgb, aI as lab2xyz, al as linearSolve3x3, aB as luFactorLinearSystem, aC as luSolveLinearSystem, aw as matrix3x3ToQuaternion, X as max, W as min, am as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a7 as multiplyAccumulate2D, an as multiplyMatrix, ax as multiplyQuaternion, w as multiplyScalar, a6 as multiplyScalar2D, N as nearestPowerOfTwo, aV as negInf, a2 as nextCombination, n as norm, af as norm2D, l as normalize, M as normalize2D, ay as orthogonalize3x3, a8 as outer, ae as outer2D, q as perpendiculars, aS as pointIsWithinBounds, a9 as projectVector, ab as projectVector2D, au as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a3 as randomSeed, H as rgb2hsv, I as rgb2lab, aL as rgb2xyz, L as round, av as roundNumber, b as roundVector, z as rowsToMat3, ag as rowsToMat4, S as signedAngleBetweenVectors, aA as singularValueDecomposition3x3, aT as solve3PointCircle, aF as solveHomogeneousLeastSquares, aG as solveLeastSquares, g as solveLinearSystem, s as subtract, ao as transpose3x3, u as uninitializeBounds, aJ as xyz2lab, aK as xyz2rgb } from './Math/index.js';

package/Common/DataModel/PolyLine.d.ts

@@ -1,5 +1,5 @@
-import { quat } from 'gl-matrix';
-import { Vector2, Vector3 } from './../../types';
+import { quat, vec3 } from 'gl-matrix';
+import { Nullable, Vector2, Vector3 } from './../../types';
 import vtkCell, { ICellInitialValues } from './Cell';
 import { IIntersectWithLine } from './Line';
 
@@ -67,6 +67,31 @@ export interface vtkPolyLine extends vtkCell {
    * @param distance The distance from the first point of the polyline
    */
   findPointIdAtDistanceFromFirstPoint(distance: number): number;
+
+  /**
+   * An array of quaternions used to orient the polyline at each of its point
+   * The length of the array has to be the same size as the number of points
+   * Defaults to null.
+   */
+  getOrientations(): Nullable<quat[]>;
+
+  /**
+   * @see getOrientations
+   * @param orientations
+   */
+  setOrientations(orientations: Nullable<quat[]>): boolean;
+
+  /**
+   * The function used in getDistancesToFirstPoint and in findPointIdAtDistanceFromFirstPoint
+   * Defaults to vec3.dist of gl-matrix
+   */
+  getDistanceFunction(): (a: vec3, b: vec3) => number;
+
+  /**
+   * @see getDistanceFunction
+   * @param f
+   */
+  setDistanceFunction(f: (a: vec3, b: vec3) => number): boolean;
 }
 
 /**

package/Common/DataModel/PolyLine.js

@@ -58,7 +58,9 @@ function vtkPolyLine(publicAPI, model) {
   };
 
   publicAPI.getDistancesToFirstPoint = function () {
-    if (model.distancesTime.getMTime() < model.points.getMTime()) {
+    var dTime = model.distancesTime.getMTime();
+
+    if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
       var numPoints = publicAPI.getNumberOfPoints();
 
       if (!model.distances) {
@@ -76,7 +78,7 @@ function vtkPolyLine(publicAPI, model) {
 
         for (var i = 1; i < numPoints; ++i) {
           model.points.getPoint(i, currentPoint);
-          totalDistance += vec3.dist(previousPoint, currentPoint);
+          totalDistance += model.distanceFunction(previousPoint, currentPoint);
           model.distances[i] = totalDistance;
           vec3.copy(previousPoint, currentPoint);
         }
@@ -121,15 +123,16 @@ function vtkPolyLine(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  orientations: null // an array of quat or null
-
+  orientations: null,
+  // an array of quat or null
+  distanceFunction: vec3.dist
 }; // ----------------------------------------------------------------------------
 
 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']);
+  macro.setGet(publicAPI, model, ['orientations', 'distanceFunction']);
   model.distancesTime = {};
   macro.obj(model.distancesTime, {
     mtime: 0

package/Rendering/Core/AbstractImageMapper.d.ts

@@ -1,6 +1,6 @@
 import vtkAbstractMapper3D, { IAbstractMapper3DInitialValues } from './AbstractMapper3D';
 import vtkImageData from './../../Common/DataModel/ImageData';
-import { Nullable } from './../../types';
+import { Bounds, Extent, Nullable, RGBAColor } from './../../types';
 
 
 export interface IAbstractImageMapperInitialValues extends IAbstractMapper3DInitialValues {
@@ -32,6 +32,45 @@ export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {
 	 */
 	setSlice(slice: number): boolean;
 
+	/**
+	 * Get bounds for a specified slice.
+	 * To be implemented by derived classes.
+	 * @param {Number} slice The slice index. If undefined, the current slice is considered.
+	 * @param {Number} thickness The slice thickness. If undefined, 0 is considered.
+	 */
+	getBoundsForSlice(slice?: number, thickness?: number): Bounds;
+
+	/**
+	 * Return the currently set background color.
+	 */
+	getBackgroundColor(): RGBAColor;
+
+	/**
+	 * Return the currently set background color.
+	 */
+	getBackgroundColorByReference(): RGBAColor;
+
+	/**
+	 * @param r red component of background color
+	 * @param g green component of background color
+	 * @param b blue component of background color
+	 * @param a opacity component of background color
+	 */
+	setBackgroundColor(r: number, g: number, b: number, a: number): boolean;
+
+	/**
+	 *
+	 * @param color specify background color as an array of 4 values.
+	 */
+	setBackgroundColor(color: RGBAColor): boolean;
+
+	/**
+	 *
+	 * @param {RGBAColor} color specify the background color to use
+	 * in RGBA format as an array of 4 values. Values are copied.
+	 */
+	setBackgroundColorFrom(color: RGBAColor): boolean;
+
 	/**
 	 *
 	 */
@@ -43,6 +82,16 @@ export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {
 	 */
 	setUseCustomExtents(useCustomExtents: boolean): boolean;
 
+	/**
+	 *
+	 */
+	getCustomDisplayExtent(): Extent;
+
+	/**
+	 *
+	 */
+	getCustomDisplayExtentByReference(): Extent;
+
 	/**
 	 *
 	 * @param {Number} x1 The x coordinate of the first point.
@@ -54,6 +103,12 @@ export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {
 	 */
 	setCustomDisplayExtent(x1: number, x2: number, y1: number, y2: number, z1: number, z2: number): boolean;
 
+	/**
+	 *
+	 * @param extents specify extents as an array of 6 values [minx, maxx, ...]
+	 */
+	setCustomDisplayExtent(customDisplayExtent: Extent): boolean;
+
 	/**
 	 *
 	 * @param customDisplayExtent

package/Rendering/Core/AbstractImageMapper.js

@@ -1,5 +1,6 @@
 import macro from '../../macros.js';
 import vtkAbstractMapper3D from './AbstractMapper3D.js';
+import { F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 
 // vtkAbstractImageMapper methods
 // ----------------------------------------------------------------------------
@@ -14,6 +15,11 @@ function vtkAbstractImageMapper(publicAPI, model) {
   publicAPI.getCurrentImage = function () {
     return null;
   };
+
+  publicAPI.getBoundsForSlice = function () {
+    macro.vtkErrorMacro('vtkAbstractImageMapper.getBoundsForSlice - NOT IMPLEMENTED');
+    return createUninitializedBounds();
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/Core/AbstractMapper3D.js

@@ -3,6 +3,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
+import { F as createUninitializedBounds } from '../../Common/Core/Math/index.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; }
 
@@ -13,6 +14,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function vtkAbstractMapper3D(publicAPI, model) {
   publicAPI.getBounds = function () {
     macro.vtkErrorMacro("vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED");
+    return createUninitializedBounds();
   };
 
   publicAPI.getCenter = function () {

package/Rendering/Core/ColorTransferFunction.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { h as hsv2rgb, i as isNan, F as isInf, G as rgb2hsv, H as rgb2lab, I as lab2rgb, J as floor } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, G as isInf, H as rgb2hsv, I as rgb2lab, J as lab2rgb, K as floor } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import Constants from './Coordinate/Constants.js';
-import { K as round, J as floor } from '../../Common/Core/Math/index.js';
+import { L as round, K as floor } from '../../Common/Core/Math/index.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; }
 

package/Rendering/Core/CubeAxesActor.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { L as normalize2D, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { M as normalize2D, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/Glyph3DMapper.js

@@ -4,7 +4,7 @@ import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
-import { N as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.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; }

package/Rendering/Core/ImageArrayMapper.d.ts

@@ -52,9 +52,9 @@ export interface vtkImageArrayMapper extends vtkAbstractImageMapper {
 	 * @param {Number} [slice] The slice index. If undefined, the current slice is considered.
 	 * @param {Number} [halfThickness] Half the slice thickness in index space (unit voxel
 	 * spacing). If undefined, 0 is considered.
-	 * @return {Number[]} The bounds for a given slice.
+	 * @return {Bounds} The bounds for a given slice.
 	 */
-	getBoundsForSlice(slice?: number, halfThickness?: number): number[];
+	getBoundsForSlice(slice?: number, halfThickness?: number): Bounds;
 
 	/**
 	 * Get the closest IJK axis

package/Rendering/Core/ImageArrayMapper.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import vtkImageMapper from './ImageMapper.js';
-import { N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -62,6 +62,21 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	setUseUniformOrientation(useUniformOrientation: boolean): boolean;
 
+	/**
+	 * A point used to offset each line of pixel in the rendering
+	 * The line of pixel is offseted such as the center of the line is as close as possible to the center point
+	 * This can be used in combination with @see getUseUniformOrientation and a custom distance function for @see getOrientedCenterline to visualize a CPR in projected mode or stretched mode
+	 * Defaults to null.
+	 * @returns the center point
+	 */
+	getCenterPoint(): Nullable<vec3>;
+	
+	/**
+	 * @see getCenterPoint
+	 * @param point
+	 */
+	setCenterPoint(point: Nullable<vec3>): boolean;
+
 	/**
 	 * This flag indicates wether the GPU should use half float or not
 	 * When true, will use half float
@@ -191,6 +206,17 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	preRenderCheck(): boolean;
 
+	/**
+	 * Configure the mapper and the centerline to be in straightened CPR mode
+	 */
+	useStraightenedMode(): void;
+
+	/**
+	 * Configure the mapper and the centerline to be in strectched CPR mode
+	 * @param centerPoint The center point, optional, default to the first point of the centerline or [0, 0, 0]
+	 */
+	useStretchedMode(centerPoint?: Nullable<vec3>): void;
+
 	/**
 	 * Set the polydata used as a centerline
 	 * You can also use `publicAPI.setInputData(centerlineData, 1);`
@@ -346,7 +372,10 @@ export function newInstance(initialValues?: IImageCPRMapperInitialValues): vtkIm
 
 /**
  * CPR in vtkImageCPRMapper stands for Curved Planar Reformation. This mapper
- * can be used to visualize tubular structures such as blood vessels.
+ * can be used to visualize tubular structures such as blood vessels. It can be
+ * used in projected mode, stretched mode or straightened mode depending on the
+ * settings @see getUseUniformOrientation , @see getCenterPoint and the distance
+ * function of @see getOrientedCenterline .
  * 
  * This specialised mapper takes as input a vtkImageData representing a volume
  * ( @see setImageData ) and a vtkPolyData representing a centerline

package/Rendering/Core/ImageCPRMapper.js

@@ -293,6 +293,36 @@ function vtkImageCPRMapper(publicAPI, model) {
     return true;
   };
 
+  publicAPI.useStraightenedMode = function () {
+    publicAPI.setCenterPoint(null);
+    publicAPI.setUseUniformOrientation(false);
+    publicAPI.getOrientedCenterline().setDistanceFunction(vec3.dist);
+  };
+
+  publicAPI.useStretchedMode = function (centerPoint) {
+    var centerline = publicAPI.getOrientedCenterline(); // Set center point
+
+    if (!centerPoint) {
+      // Get the first point of the centerline if there is one
+      var centerlinePoints = centerline.getPoints();
+      var newCenterPoint = centerlinePoints.getNumberOfTuples() > 0 ? centerlinePoints.getPoint(0) : [0, 0, 0];
+      publicAPI.setCenterPoint(newCenterPoint);
+    } else {
+      publicAPI.setCenterPoint(centerPoint);
+    } // Enable uniform orientation
+
+
+    publicAPI.setUseUniformOrientation(true); // Change distance function
+
+    centerline.setDistanceFunction(function (a, b) {
+      var direction = publicAPI.getUniformDirection();
+      var vec = vec3.subtract([], a, b);
+      var d2 = vec3.squaredLength(vec);
+      var x = vec3.dot(direction, vec);
+      return Math.sqrt(d2 - x * x);
+    });
+  };
+
   publicAPI.setCenterlineData = function (centerlineData) {
     return publicAPI.setInputData(centerlineData, 1);
   };
@@ -326,6 +356,7 @@ var DEFAULT_VALUES = {
   width: 10,
   uniformOrientation: [0, 0, 0, 1],
   useUniformOrientation: false,
+  centerPoint: null,
   preferSizeOverAccuracy: false,
   orientationArrayName: null,
   tangentDirection: [1, 0, 0],
@@ -345,7 +376,7 @@ function extend(publicAPI, model) {
     mtime: 0
   }); // Setters and getters
 
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkImageCPRMapper(publicAPI, model);

package/Rendering/Core/ImageMapper.d.ts

@@ -46,9 +46,9 @@ export interface vtkImageMapper extends vtkAbstractImageMapper {
 	 * @param {Number} [slice] The slice index. If undefined, the current slice is considered.
 	 * @param {Number} [halfThickness] Half the slice thickness in index space (unit voxel
 	 * spacing). If undefined, 0 is considered.
-	 * @return {Number[]} The bounds for a given slice.
+	 * @return {Bounds} The bounds for a given slice.
 	 */
-	getBoundsForSlice(slice?: number, halfThickness?: number): number[];
+	getBoundsForSlice(slice?: number, halfThickness?: number): Bounds;
 
 	/**
 	 *

package/Rendering/Core/ImageMapper.js

@@ -3,7 +3,7 @@ import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
-import { C as clampValue, O as multiply3x3_vect3, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { C as clampValue, O as multiply3x3_vect3, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.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; }

package/Rendering/Core/ImageSlice.d.ts

@@ -1,10 +1,10 @@
 import { Bounds } from './../../types';
 import vtkImageProperty, { IImagePropertyInitialValues } from './ImageProperty';
-import vtkImageMapper from './ImageMapper';
+import vtkAbstractImageMapper from './AbstractImageMapper';
 import vtkProp3D, { IProp3DInitialValues } from './Prop3D';
 
 export interface IImageSliceInitialValues extends IProp3DInitialValues{
-	mapper?: vtkImageMapper;
+	mapper?: vtkAbstractImageMapper;
 	property?: vtkImageProperty;
 	bounds?: Bounds;
 }
@@ -55,7 +55,7 @@ export interface vtkImageSlice extends vtkProp3D {
 	/**
 	 * 
 	 */
-	getMapper(): vtkImageMapper;
+	getMapper(): vtkAbstractImageMapper;
 	
 	/**
 	 * Get the minimum X bound
@@ -126,9 +126,9 @@ export interface vtkImageSlice extends vtkProp3D {
 
 	/**
 	 * 
-	 * @param {vtkImageMapper} mapper The vtkImageMapper instance.
+	 * @param {vtkAbstractImageMapper} mapper An instance that derives from vtkAbstractImageMapper.
 	 */
-	setMapper(mapper: vtkImageMapper): boolean;
+	setMapper(mapper: vtkAbstractImageMapper): boolean;
 
 	/**
 	 * 

package/Rendering/Core/Mapper.js

@@ -4,7 +4,7 @@ import vtkAbstractMapper3D from './AbstractMapper3D.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkLookupTable from '../../Common/Core/LookupTable.js';
-import { N as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, moveToProtected, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { P as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { P as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import * as d3 from 'd3-scale';
-import { M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Core/VolumeMapper.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { N as createUninitializedBounds, C as clampValue, J as floor } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds, C as clampValue, K as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -449,14 +449,20 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.getNeedToRebuildShaders = function (cellBO, ren, actor) {
     // has something changed that would require us to recreate the shader?
     // candidates are
+    // presence of centerPoint
+    // value of useUniformOrientation
     // property modified (representation interpolation and lighting)
     // input modified
     // light complexity changed
     // render pass shader replacement changed
     var tNumComp = model.volumeTexture.getComponents();
     var iComp = actor.getProperty().getIndependentComponents();
+    var useCenterPoint = !!model.renderable.getCenterPoint();
+    var useUniformOrientation = model.renderable.getUseUniformOrientation();
 
-    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (cellBO.getProgram() === 0 || model.lastUseCenterPoint !== useCenterPoint || model.lastUseUniformOrientation !== useUniformOrientation || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+      model.lastUseCenterPoint = useCenterPoint;
+      model.lastUseUniformOrientation = useUniformOrientation;
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -521,6 +527,12 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       tcoordFSDec.push('in vec3 centerlineTopDirVSOutput;', 'in vec3 centerlineBotDirVSOutput;', 'in float centerlineAngleVSOutput;');
     }
 
+    var centerPoint = model.renderable.getCenterPoint();
+
+    if (centerPoint) {
+      tcoordFSDec.push('uniform vec3 globalCenterPoint;');
+    }
+
     if (iComps) {
       for (var comp = 1; comp < tNumComp; comp++) {
         tcoordFSDec = tcoordFSDec.concat([// color shift and scale
@@ -566,7 +578,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       tcoordFSImpl.push('vec3 interpolatedCenterlineDir;', 'if (centerlineAngleVSOutput < 0.0) {', '  // Lerp', '  interpolatedCenterlineDir = quadOffsetVSOutput.y * centerlineTopDirVSOutput + (1.0 - quadOffsetVSOutput.y) * centerlineBotDirVSOutput;', '} else {', '  // Slerp', '  float topInterpolationAngle = quadOffsetVSOutput.y * centerlineAngleVSOutput;', '  float botInterpolationAngle = centerlineAngleVSOutput - topInterpolationAngle;', '  interpolatedCenterlineDir = sin(topInterpolationAngle) * centerlineTopDirVSOutput + sin(botInterpolationAngle) * centerlineBotDirVSOutput;', '}', '// Slerp should give a normalized vector but when sin(angle) is small, rounding error occurs', '// Normalize for both lerp and slerp', 'interpolatedCenterlineDir = normalize(interpolatedCenterlineDir);');
     }
 
-    tcoordFSImpl.push('vec3 volumePosMC = centerlinePosVSOutput + quadOffsetVSOutput.x * interpolatedCenterlineDir;', 'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;', 'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(volumeTexture, volumePosTC);');
+    if (centerPoint) {
+      tcoordFSImpl.push('float baseOffset = dot(interpolatedCenterlineDir, globalCenterPoint - centerlinePosVSOutput);', 'float horizontalOffset = quadOffsetVSOutput.x + baseOffset;');
+    } else {
+      tcoordFSImpl.push('float horizontalOffset = quadOffsetVSOutput.x;');
+    }
+
+    tcoordFSImpl.push('vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * interpolatedCenterlineDir;', 'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;', 'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(volumeTexture, volumePosTC);');
 
     if (iComps) {
       var rgba = ['r', 'g', 'b', 'a'];
@@ -685,6 +703,11 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (cellBO.getProgram().isUniformUsed('centerlineDirection')) {
       var uniformDirection = model.renderable.getUniformDirection();
       cellBO.getProgram().setUniform3fArray('centerlineDirection', uniformDirection);
+    }
+
+    if (cellBO.getProgram().isUniformUsed('globalCenterPoint')) {
+      var centerPoint = model.renderable.getCenterPoint();
+      cellBO.getProgram().setUniform3fArray('globalCenterPoint', centerPoint);
     } // Model coordinates to image space
     // getWorldToIndex is badly named and is in fact modelToIndex
     // MCIC -> Model coordinates to index coordinates

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -8,7 +8,7 @@ import { v as vtkPolyData2DVS } from './glsl/vtkPolyData2DVS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
-import { K as round } from '../../Common/Core/Math/index.js';
+import { L as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/Texture.js

@@ -4,7 +4,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { newInstance as newInstance$1, obj, set, setGet, get, moveToProtected, newTypedArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { Q as isPowerOfTwo, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { Q as isPowerOfTwo, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -365,6 +365,10 @@ function widgetBehavior(publicAPI, model) {
     var _manipulator$handleEv3 = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
         worldCoords = _manipulator$handleEv3.worldCoords;
 
+    if (!worldCoords || !worldCoords.length) {
+      return;
+    }
+
     var center = model.widgetState.getCenter();
     var currentVectorToOrigin = [0, 0, 0];
     subtract(worldCoords, center, currentVectorToOrigin);

package/package.json

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