@kitware/vtk.js 24.7.1 → 24.10.0

package/Common/Core/Math/index.js

@@ -2329,4 +2329,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { binomial 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, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, projectVector as a8, dot2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, projectVector2D as aa, gaussianAmplitude as ab, gaussianWeight as ac, outer2D as ad, norm2D as ae, LUFactor3x3 as af, LUSolve3x3 as ag, linearSolve3x3 as ah, multiply3x3_mat3 as ai, multiplyMatrix as aj, transpose3x3 as ak, invert3x3 as al, identity3x3 as am, quaternionToMatrix3x3 as an, roundNumber as ao, matrix3x3ToQuaternion as ap, multiplyQuaternion as aq, orthogonalize3x3 as ar, diagonalize3x3 as as, singularValueDecomposition3x3 as at, luFactorLinearSystem as au, luSolveLinearSystem as av, invertMatrix as aw, estimateMatrixCondition as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract 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, solveLinearSystem as s, vtkMath as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { binomial 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, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, projectVector as a8, dot2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, projectVector2D as aa, gaussianAmplitude as ab, gaussianWeight as ac, outer2D as ad, norm2D as ae, LUFactor3x3 as af, LUSolve3x3 as ag, linearSolve3x3 as ah, multiply3x3_mat3 as ai, multiplyMatrix as aj, transpose3x3 as ak, invert3x3 as al, identity3x3 as am, quaternionToMatrix3x3 as an, roundNumber as ao, matrix3x3ToQuaternion as ap, multiplyQuaternion as aq, orthogonalize3x3 as ar, diagonalize3x3 as as, singularValueDecomposition3x3 as at, luFactorLinearSystem as au, luSolveLinearSystem as av, invertMatrix as aw, estimateMatrixCondition as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints 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, vtkMath as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.js

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

package/Common/Core/ScalarsToColors/Constants.d.ts

@@ -0,0 +1,18 @@
+export declare enum VectorMode {
+	MAGNITUDE = 0,
+	COMPONENT = 1,
+	RGBCOLORS = 2,
+}
+
+export declare enum ScalarMappingTarget {
+	LUMINANCE = 1,
+	LUMINANCE_ALPHA = 2,
+	RGB = 3,
+	RGBA = 4,
+}
+
+declare const _default: {
+	VectorMode: typeof VectorMode;
+	ScalarMappingTarget: typeof ScalarMappingTarget;
+};
+export default _default;

package/Common/Core/ScalarsToColors.d.ts

@@ -1,19 +1,7 @@
-import { vtkObject } from './../../interfaces' ;
-import { ColorMode } from './../../Rendering/Core/Mapper';
-import { Range } from './../../types' ;
-
-export enum VectorMode {
-	MAGNITUDE,
-	COMPONENT,
-	RGBCOLORS
-}
-
-export enum ScalarMappingTarget {
-	LUMINANCE,
-	LUMINANCE_ALPHA,
-	RGB,
-	RGBA
-}
+import { vtkObject } from './../../interfaces';
+import { ColorMode } from './../../Rendering/Core/Mapper/Constants';
+import { Range } from './../../types';
+import { ScalarMappingTarget, VectorMode } from './ScalarsToColors/Constants';
 
 /**
  *
@@ -370,5 +358,7 @@ export function newInstance(initialValues?: IScalarsToColorsInitialValues): vtkS
 export declare const vtkScalarsToColors: {
 	newInstance: typeof newInstance;
 	extend: typeof extend;
+	VectorMode: typeof VectorMode;
+	ScalarMappingTarget: typeof VectorMode;
 }
 export default vtkScalarsToColors;

package/Common/DataModel/Box.d.ts

@@ -1,5 +1,5 @@
-import { vtkObject } from './../../interfaces' ;
-import { Bounds, Point } from './../../types';
+import { vtkObject } from './../../interfaces';
+import { Bounds, Vector3 } from './../../types';
 
 
 export interface IBoxInitialValues {
@@ -22,9 +22,9 @@ export interface vtkBox extends vtkObject {
 
     /**
      * 
-     * @param {Point} x The point coordinate.
+     * @param {Vector3} x The point coordinate.
      */
-    evaluateFunction(x: Point): number;
+    evaluateFunction(x: Vector3): number;
 
     /**
      * 

package/Common/DataModel/CardinalSpline1D.d.ts

@@ -1,6 +1,5 @@
 import { Vector3 } from './../../types';
-import vtkSpline1D, { ISpline1DInitialValues } from './Spline1D';
-
+import vtkSpline1D, { ISpline1DInitialValues, BoundaryCondition } from './Spline1D';
 
 export interface ICardinalSpline1DInitialValues extends ISpline1DInitialValues {}
 
@@ -20,9 +19,14 @@ export interface vtkCardinalSpline1D extends vtkSpline1D {
 	 * @param {Number} size 
 	 * @param {Float32Array} work 
 	 * @param {Vector3} x 
-	 * @param {Vector3} y 
+	 * @param {Vector3} 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: Vector3, y: Vector3): void;
+	computeOpenCoefficients(size: number, work: Float32Array, x: Vector3, y: Vector3, options: { leftConstraint: BoundaryCondition, leftValue: number, rightConstraint: BoundaryCondition, rightValue: Number }): void;
 
 	/**
 	 * 

package/Common/DataModel/CardinalSpline1D.js

@@ -1,7 +1,8 @@
 import macro from '../../macros.js';
 import vtkSpline1D from './Spline1D.js';
+import { BoundaryCondition } from './Spline1D/Constants.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+var VTK_EPSILON = 0.0001; // ----------------------------------------------------------------------------
 // vtkCardinalSpline1D methods
 // ----------------------------------------------------------------------------
 
@@ -38,9 +39,9 @@ function vtkCardinalSpline1D(publicAPI, model) {
     var cN = model.coefficients[4 * N + 2];
     var dN = work[N]; // solve resulting set of equations.
 
-    model.coefficients[0 * 4 + 2] = 0;
+    model.coefficients[4 * 0 + 2] = 0;
     work[0] = 0;
-    model.coefficients[0 * 4 + 3] = 1;
+    model.coefficients[4 * 0 + 3] = 1;
 
     for (var _k = 1; _k <= N; _k++) {
       model.coefficients[4 * _k + 1] -= model.coefficients[4 * _k + 0] * model.coefficients[4 * (_k - 1) + 2];
@@ -86,7 +87,135 @@ function vtkCardinalSpline1D(publicAPI, model) {
 
 
   publicAPI.computeOpenCoefficients = function (size, work, x, y) {
-    vtkErrorMacro('Open splines are not implemented yet!');
+    var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+
+    if (!model.coefficients || model.coefficients.length !== 4 * size) {
+      model.coefficients = new Float32Array(4 * size);
+    }
+
+    var N = size - 1; // develop constraint at leftmost point.
+
+    switch (options.leftConstraint) {
+      case BoundaryCondition.DERIVATIVE:
+        // desired slope at leftmost point is leftValue.
+        model.coefficients[4 * 0 + 1] = 1.0;
+        model.coefficients[4 * 0 + 2] = 0.0;
+        work[0] = options.leftValue;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE:
+        // desired second derivative at leftmost point is leftValue.
+        model.coefficients[4 * 0 + 1] = 2.0;
+        model.coefficients[4 * 0 + 2] = 1.0;
+        work[0] = 3.0 * ((y[1] - y[0]) / (x[1] - x[0])) - 0.5 * (x[1] - x[0]) * options.leftValue;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE_INTERIOR_POINT:
+        // desired second derivative at leftmost point is
+        // leftValue times second derivative at first interior point.
+        model.coefficients[4 * 0 + 1] = 2.0;
+
+        if (Math.abs(options.leftValue + 2) > VTK_EPSILON) {
+          model.coefficients[4 * 0 + 2] = 4.0 * ((0.5 + options.leftValue) / (2.0 + options.leftValue));
+          work[0] = 6.0 * ((1.0 + options.leftValue) / (2.0 + options.leftValue)) * ((y[1] - y[0]) / (x[1] - x[0]));
+        } else {
+          model.coefficients[4 * 0 + 2] = 0;
+          work[0] = 0;
+        }
+
+        break;
+
+      case BoundaryCondition.DEFAULT:
+      default:
+        // desired slope at leftmost point is derivative from two points
+        model.coefficients[4 * 0 + 1] = 1.0;
+        model.coefficients[4 * 0 + 2] = 0.0;
+        work[0] = y[2] - y[0];
+        break;
+    }
+
+    for (var k = 1; k < N; k++) {
+      var xlk = x[k] - x[k - 1];
+      var xlkp = x[k + 1] - x[k];
+      model.coefficients[4 * k + 0] = xlkp;
+      model.coefficients[4 * k + 1] = 2 * (xlkp + xlk);
+      model.coefficients[4 * k + 2] = xlk;
+      work[k] = 3.0 * (xlkp * (y[k] - y[k - 1]) / xlk + xlk * (y[k + 1] - y[k]) / xlkp);
+    } // develop constraint at rightmost point.
+
+
+    switch (options.rightConstraint) {
+      case BoundaryCondition.DERIVATIVE:
+        // desired slope at rightmost point is rightValue
+        model.coefficients[4 * N + 0] = 0.0;
+        model.coefficients[4 * N + 1] = 1.0;
+        work[N] = options.rightValue;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE:
+        // desired second derivative at rightmost point is rightValue.
+        model.coefficients[4 * N + 0] = 1.0;
+        model.coefficients[4 * N + 1] = 2.0;
+        work[N] = 3.0 * ((y[N] - y[N - 1]) / (x[N] - x[N - 1])) + 0.5 * (x[N] - x[N - 1]) * options.rightValue;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE_INTERIOR_POINT:
+        // desired second derivative at rightmost point is
+        // rightValue times second derivative at last interior point.
+        model.coefficients[4 * N + 1] = 2.0;
+
+        if (Math.abs(options.rightValue + 2) > VTK_EPSILON) {
+          model.coefficients[4 * N + 0] = 4.0 * ((0.5 + options.rightValue) / (2.0 + options.rightValue));
+          work[N] = 6.0 * ((1.0 + options.rightValue) / (2.0 + options.rightValue)) * ((y[N] - y[size - 2]) / (x[N] - x[size - 2]));
+        } else {
+          model.coefficients[4 * N + 0] = 0;
+          work[N] = 0;
+        }
+
+        break;
+
+      case BoundaryCondition.DEFAULT:
+      default:
+        // desired slope at rightmost point is derivative from two points
+        model.coefficients[4 * N + 0] = 0.0;
+        model.coefficients[4 * N + 1] = 1.0;
+        work[N] = y[N] - y[N - 2];
+        break;
+    } // solve resulting set of equations.
+
+
+    model.coefficients[4 * 0 + 2] /= model.coefficients[4 * 0 + 1];
+    work[0] /= model.coefficients[4 * N + 1];
+    model.coefficients[4 * N + 3] = 1;
+
+    for (var _k5 = 1; _k5 <= N; _k5++) {
+      model.coefficients[4 * _k5 + 1] -= model.coefficients[4 * _k5 + 0] * model.coefficients[4 * (_k5 - 1) + 2];
+      model.coefficients[4 * _k5 + 2] /= model.coefficients[4 * _k5 + 1];
+      work[_k5] = (work[_k5] - model.coefficients[4 * _k5 + 0] * work[_k5 - 1]) / model.coefficients[4 * _k5 + 1];
+    }
+
+    for (var _k6 = N - 1; _k6 >= 0; _k6--) {
+      work[_k6] -= model.coefficients[4 * _k6 + 2] * work[_k6 + 1];
+    } // the column vector work now contains the first
+    // derivative of the spline function at each joint.
+    // compute the coefficients of the cubic between
+    // each pair of joints.
+
+
+    for (var _k7 = 0; _k7 < N; _k7++) {
+      var b = x[_k7 + 1] - x[_k7];
+      model.coefficients[4 * _k7 + 0] = y[_k7];
+      model.coefficients[4 * _k7 + 1] = work[_k7];
+      model.coefficients[4 * _k7 + 2] = 3 * (y[_k7 + 1] - y[_k7]) / (b * b) - (work[_k7 + 1] + 2 * work[_k7]) / b;
+      model.coefficients[4 * _k7 + 3] = 2 * (y[_k7] - y[_k7 + 1]) / (b * b * b) + (work[_k7 + 1] + work[_k7]) / (b * b);
+    } // the coefficients of a fictitious nth cubic
+    // are the same as the coefficients in the first interval
+
+
+    model.coefficients[4 * N + 0] = y[N];
+    model.coefficients[4 * N + 1] = work[N];
+    model.coefficients[4 * N + 2] = model.coefficients[4 * 0 + 2];
+    model.coefficients[4 * N + 3] = model.coefficients[4 * 0 + 3];
   }; // --------------------------------------------------------------------------
 
 

package/Common/DataModel/Cell.js

@@ -119,7 +119,9 @@ function vtkCell(publicAPI, model) {
   publicAPI.intersectWithLine = function (p1, p2, tol, t, x, pcoords, subId) {}; // virtual
 
 
-  publicAPI.evaluatePosition = function (x, closestPoint, subId, pcoords, dist2, weights) {}; // virtual
+  publicAPI.evaluatePosition = function (x, closestPoint, subId, pcoords, dist2, weights) {
+    macro.vtkErrorMacro('vtkCell.evaluatePosition is not implemented.');
+  }; // virtual
 
 } // ----------------------------------------------------------------------------
 // Object factory

package/Common/DataModel/CellTypes.js

@@ -35,6 +35,10 @@ function getTypeIdFromClassName(cellTypeString) {
 
 function isLinear(type) {
   return type < CellType.VTK_QUADRATIC_EDGE || type === CellType.VTK_CONVEX_POINT_SET || type === CellType.VTK_POLYHEDRON;
+}
+
+function hasSubCells(cellType) {
+  return cellType === CellType.VTK_TRIANGLE_STRIP || cellType === CellType.VTK_POLY_LINE || cellType === CellType.VTK_POLY_VERTEX;
 } // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
@@ -43,7 +47,8 @@ function isLinear(type) {
 var STATIC = {
   getClassNameFromTypeId: getClassNameFromTypeId,
   getTypeIdFromClassName: getTypeIdFromClassName,
-  isLinear: isLinear
+  isLinear: isLinear,
+  hasSubCells: hasSubCells
 }; // ----------------------------------------------------------------------------
 // vtkCellTypes methods
 // ----------------------------------------------------------------------------

package/Common/DataModel/ITKHelper.d.ts

@@ -0,0 +1,54 @@
+import vtkPolyData from './PolyData';
+import vtkImageData from './ImageData';
+
+export interface IOptions {
+	pointDataName?: string;
+	scalarArrayName?: string;
+	cellDataName?: string;
+}
+
+/**
+ * Converts an itk-wasm Image to a vtk.js vtkImageData.
+ * Requires an itk-wasm Image as input.
+ * @param itkImage 
+ * @param {IOptions} [options] 
+ */
+export function convertItkToVtkImage(itkImage: any, options?: IOptions): vtkImageData;
+
+/**
+ * Converts a vtk.js vtkImageData to an itk-wasm Image.
+ * Requires a vtk.js vtkImageData as input.
+ * @param {vtkImageData} vtkImage 
+ * @param {IOptions} [options] 
+ */
+export function convertVtkToItkImage(vtkImage: vtkImageData, options?: IOptions): any;
+
+/**
+ * Converts an itk-wasm PolyData to a vtk.js vtkPolyData.
+ * Requires an itk-wasm PolyData as input.
+ * @param itkPolyData 
+ * @param {IOptions} [options] 
+ */
+export function convertItkToVtkPolyData(itkPolyData: any, options?: IOptions): vtkPolyData;
+
+/**
+ * Converts a vtk.js vtkPolyData to an itk-wasm PolyData.
+ * Requires a vtk.js vtkPolyData as input.
+ * 
+ * @param {vtkPolyData} polyData 
+ * @param {IOptions} [options] 
+ */
+export function convertVtkToItkPolyData(polyData: vtkPolyData, options?: IOptions): any;
+
+
+/** 
+ * vtkITKHelper is a helper which provides a set of functions to work with
+ * itk-wasm module.
+ */
+export declare const vtkITKHelper: {
+	convertItkToVtkImage: typeof convertItkToVtkImage,
+	convertVtkToItkImage: typeof convertVtkToItkImage,
+	convertItkToVtkPolyData: typeof convertItkToVtkPolyData,
+	convertVtkToItkPolyData: typeof convertVtkToItkPolyData,
+};
+export default vtkITKHelper;

package/Common/DataModel/KochanekSpline1D.d.ts

@@ -1,5 +1,4 @@
-import vtkSpline1D, { ISpline1DInitialValues } from './Spline1D';
-
+import vtkSpline1D, { ISpline1DInitialValues, BoundaryCondition } from './Spline1D';
 
 export interface IKochanekSpline1DInitialValues extends ISpline1DInitialValues {
 	tension?: number;
@@ -23,9 +22,14 @@ export interface vtkKochanekSpline1D extends vtkSpline1D {
 	 * @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/KochanekSpline1D.js

@@ -1,7 +1,8 @@
 import macro from '../../macros.js';
 import vtkSpline1D from './Spline1D.js';
+import { BoundaryCondition } from './Spline1D/Constants.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+var VTK_EPSILON = 0.0001; // ----------------------------------------------------------------------------
 // vtkKochanekSpline1D methods
 // ----------------------------------------------------------------------------
 
@@ -79,7 +80,107 @@ function vtkKochanekSpline1D(publicAPI, model) {
 
 
   publicAPI.computeOpenCoefficients = function (size, work, x, y) {
-    vtkErrorMacro('Open splines are not implemented yet!');
+    var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+
+    if (!model.coefficients || model.coefficients.length !== 4 * size) {
+      model.coefficients = new Float32Array(4 * size);
+    }
+
+    var N = size - 1;
+
+    for (var i = 1; i < N; i++) {
+      var cs = y[i] - y[i - 1];
+      var cd = y[i + 1] - y[i];
+      var ds = cs * ((1 - model.tension) * (1 - model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 + model.continuity) * (1 - model.bias));
+      var dd = cs * ((1 - model.tension) * (1 + model.continuity) * (1 + model.bias)) + cd * ((1 - model.tension) * (1 - model.continuity) * (1 - model.bias)); // adjust deriviatives for non uniform spacing between nodes
+
+      var n1 = x[i + 1] - x[i];
+      var n0 = x[i] - x[i - 1];
+      ds *= n0 / (n0 + n1);
+      dd *= n1 / (n0 + n1);
+      model.coefficients[4 * i + 0] = y[i];
+      model.coefficients[4 * i + 1] = dd;
+      model.coefficients[4 * i + 2] = ds;
+    }
+
+    model.coefficients[4 * 0 + 0] = y[0];
+    model.coefficients[4 * N + 0] = y[N]; // Calculate the deriviatives at the end points
+
+    switch (options.leftConstraint) {
+      // desired slope at leftmost point is leftValue
+      case BoundaryCondition.DERIVATIVE:
+        model.coefficients[4 * 0 + 1] = options.leftValue;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE:
+        // desired second derivative at leftmost point is leftValue
+        model.coefficients[4 * 0 + 1] = (6 * (y[1] - y[0]) - 2 * model.coefficients[4 * 1 + 2] - options.leftValue) / 4;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE_INTERIOR_POINT:
+        // desired second derivative at leftmost point is leftValue
+        // times second derivative at first interior point
+        if (Math.abs(options.leftValue + 2) > VTK_EPSILON) {
+          model.coefficients[4 * 0 + 1] = (3 * (1 + options.leftValue) * (y[1] - y[0]) - (1 + 2 * options.leftValue) * model.coefficients[4 * 1 + 2]) / (2 + options.leftValue);
+        } else {
+          model.coefficients[4 * 0 + 1] = 0.0;
+        }
+
+        break;
+
+      case BoundaryCondition.DEFAULT:
+      default:
+        // desired slope at leftmost point is derivative from two points
+        model.coefficients[4 * 0 + 1] = y[2] - y[0];
+        break;
+    }
+
+    switch (options.rightConstraint) {
+      case BoundaryCondition.DERIVATIVE:
+        // desired slope at rightmost point is leftValue
+        model.coefficients[4 * N + 2] = options.leftValue;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE:
+        // desired second derivative at rightmost point is leftValue
+        model.coefficients[4 * N + 2] = (6 * (y[N] - y[N - 1]) - 2 * model.coefficients[4 * (N - 1) + 1] + options.leftValue) / 4.0;
+        break;
+
+      case BoundaryCondition.SECOND_DERIVATIVE_INTERIOR_POINT:
+        // desired second derivative at rightmost point is leftValue
+        // times second derivative at last interior point
+        if (Math.abs(options.leftValue + 2) > VTK_EPSILON) {
+          model.coefficients[4 * N + 2] = (3 * (1 + options.leftValue) * (y[N] - y[N - 1]) - (1 + 2 * options.leftValue) * model.coefficients[4 * (N - 1) + 1]) / (2 + options.leftValue);
+        } else {
+          model.coefficients[4 * N + 2] = 0.0;
+        }
+
+        break;
+
+      case BoundaryCondition.DEFAULT:
+      default:
+        // desired slope at rightmost point is rightValue
+        model.coefficients[4 * N + 2] = y[N] - y[N - 2];
+        break;
+    }
+
+    for (var _i2 = 0; _i2 < N; _i2++) {
+      //
+      // c0    = P ;    c1    = DD ;
+      //   i      i       i       i
+      //
+      // c1    = P   ;  c2    = DS   ;
+      //   i+1    i+1     i+1     i+1
+      //
+      // c2  = -3P  + 3P    - 2DD  - DS   ;
+      //   i      i     i+1      i     i+1
+      //
+      // c3  =  2P  - 2P    +  DD  + DS   ;
+      //   i      i     i+1      i     i+1
+      //
+      model.coefficients[4 * _i2 + 2] = -3 * y[_i2] + 3 * y[_i2 + 1] + -2 * model.coefficients[4 * _i2 + 1] + -1 * model.coefficients[4 * (_i2 + 1) + 2];
+      model.coefficients[4 * _i2 + 3] = 2 * y[_i2] + -2 * y[_i2 + 1] + 1 * model.coefficients[4 * _i2 + 1] + 1 * model.coefficients[4 * (_i2 + 1) + 2];
+    }
   }; // --------------------------------------------------------------------------
 
 

package/Common/DataModel/Line.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './../../types';
+import { Vector3, Vector2 } from './../../types';
 import vtkCell from './Cell';
 
 export enum IntersectionState {
@@ -9,7 +9,7 @@ export enum IntersectionState {
 
 interface ILineInitialValues { }
 
-interface IIntersectWithLine {
+export interface IIntersectWithLine {
 	intersect: number;
 	t: number;
 	subId: number;
@@ -50,6 +50,11 @@ export interface vtkLine extends vtkCell {
 	 * @param {Vector3} pcoords The parametric coordinates.
 	 */
 	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): IIntersectWithLine;
+
+	/**
+	 * Determine the global coordinates `x' and parametric coordinates `pcoords' in the cell.
+	 */
+	evaluateLocation(pcoords: Vector3, x: Vector3, weights: Vector2): void
 }
 
 /**
@@ -77,7 +82,7 @@ export function newInstance(initialValues?: ILineInitialValues): vtkLine;
  *   t: tolerance of the distance
  *   distance: quared distance between closest point and x
  * }
- * 
+ * ```
  * @static
  * @param {Vector3} x 
  * @param {Vector3} p1 

package/Common/DataModel/Line.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import Constants from './Line/Constants.js';
 import vtkCell from './Cell.js';
-import { d as dot, f as distance2BetweenPoints, s as solveLinearSystem } from '../Core/Math/index.js';
+import { d as dot, f as distance2BetweenPoints, s as subtract, g as solveLinearSystem } from '../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; }
 
@@ -69,15 +69,9 @@ function intersection(a1, a2, b1, b2, u, v) {
   u[0] = 0.0;
   v[0] = 0.0; // Determine line vectors.
 
-  a21[0] = a2[0] - a1[0];
-  a21[1] = a2[1] - a1[1];
-  a21[2] = a2[2] - a1[2];
-  b21[0] = b2[0] - b1[0];
-  b21[1] = b2[1] - b1[1];
-  b21[2] = b2[2] - b1[2];
-  b1a1[0] = b1[0] - a1[0];
-  b1a1[1] = b1[1] - a1[1];
-  b1a1[2] = b1[2] - a1[2]; // Compute the system (least squares) matrix.
+  subtract(a2, a1, a21);
+  subtract(b2, b1, b21);
+  subtract(b1, a1, b1a1); // Compute the system (least squares) matrix.
 
   var A = [];
   A[0] = [dot(a21, a21), -dot(a21, b21)];
@@ -237,8 +231,19 @@ function vtkLine(publicAPI, model) {
     return outObj;
   };
 
-  publicAPI.evaluatePosition = function (x, closestPoint, subId, pcoords, dist2, weights) {}; // virtual
+  publicAPI.evaluateLocation = function (pcoords, x, weights) {
+    var a1 = [];
+    var a2 = [];
+    model.points.getPoint(0, a1);
+    model.points.getPoint(1, a2);
 
+    for (var i = 0; i < 3; i++) {
+      x[i] = a1[i] + pcoords[0] * (a2[i] - a1[i]);
+    }
+
+    weights[0] = 1.0 - pcoords[0];
+    weights[1] = pcoords[0];
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Common/DataModel/Plane.js

@@ -1,5 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { g as subtract, d as dot, j as cross, k as add } from '../Core/Math/index.js';
+import { s as subtract, d as dot, j as cross, k as add } from '../Core/Math/index.js';
 import macro from '../../macros.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/Common/DataModel/PolyData/Constants.d.ts

@@ -0,0 +1,6 @@
+export declare const POLYDATA_FIELDS : string[];
+
+declare const _default: {
+	POLYDATA_FIELDS: typeof POLYDATA_FIELDS;
+};
+export default _default;