@kitware/vtk.js 25.7.2 → 25.8.0

package/Common/Core/CellArray.d.ts

@@ -25,9 +25,9 @@ export interface vtkCellArray extends vtkDataArray {
 
 	/**
 	 * Set the data of this array.
-	 * @param {TypedArray} typedArray The Array value.
+	 * @param {Number[]|TypedArray} typedArray The Array value.
 	 */
-	setData(typedArray: TypedArray): void;
+	setData(typedArray: number[]|TypedArray): void;
 
 	/**
 	 * Returns the point indices at the given location as a subarray.

package/Common/Core/DataArray.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject, vtkRange } from './../../interfaces';
-import { float, int, Nullable, TypedArray } from './../../types';
+import { float, int, Nullable, Range, TypedArray } from './../../types';
 
 
 /**
@@ -30,7 +30,7 @@ export interface IDataArrayInitialValues {
 	empty?: boolean;
 	name?: string;
 	numberOfComponents?: number;
-	rangeTuple?: [number, number];
+	rangeTuple?: Range;
 	size?: number;
 	values?: Array<number>|TypedArray;
 }
@@ -60,21 +60,21 @@ export interface vtkDataArray extends vtkObject {
 	/**
 	 *
 	 */
-	getData(): TypedArray;
+	getData(): number[]|TypedArray;
 
 	/**
 	 * Get the range of the given component.
 	 *
 	 * @param {Number} componentIndex (default: -1)
 	 */
-	getRange(componentIndex?: number): [number, number];
+	getRange(componentIndex?: number): Range;
 
 	/**
 	 *
 	 * @param {vtkRange} rangeValue
 	 * @param {Number} componentIndex
 	 */
-	setRange(rangeValue: vtkRange, componentIndex: number): [number, number];
+	setRange(rangeValue: vtkRange, componentIndex: number): Range;
 
 	/**
 	 * Set the given tuple at the given index.
@@ -93,17 +93,20 @@ export interface vtkDataArray extends vtkObject {
 	/**
 	 * Get the tuple at the given index.
 	 *
-	 * The recommended use is the following:
+	 * For performance reasons, it is advised to pass a 'tupleToFill':
 	 * `const x = [];`
-	 * `dataArray.getTuple(idx, x);`
+	 * `for (int i = 0; i < N; ++i) {
+	 * `  dataArray.getTuple(idx, x);`
+	 * `  ...`
 	 * instead of:
-	 * `const x = dataArray.getTuple(idx);`
-	 *
+	 * `for (int i = 0; i < N; ++i) {
+	 * `  const x = dataArray.getTuple(idx);`
+	 * `...`
 	 * @param {Number} idx
-	 * @param {Array<Number>} [tupleToFill] (default [])
-	 * @returns {Array<Number>}
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
 	 */
-	getTuple(idx: number, tupleToFill?: Array<number>): Array<number>;
+	getTuple(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
 	
 	/**
 	 * Get the tuples between fromId (inclusive) and toId (exclusive).
@@ -223,10 +226,10 @@ export interface vtkDataArray extends vtkObject {
 	 * If this dataArray's numberOfComponents doesn't divide the given array's
 	 * length, this dataArray's numberOfComponents is set to 1.
 	 *
-	 * @param {TypedArray} typedArray
-	 * @param {Number} [numberOfComponents]
+	 * @param {Number[]|TypedArray} typedArray The Array value.
+	 * @param {Number} [numberOfComponents] 
 	 */
-	setData(typedArray: TypedArray, numberOfComponents?: number): void;
+	setData(typedArray: number[]|TypedArray, numberOfComponents?: number): void;
 
 	/**
 	 * Get the state of this array.

package/Common/Core/DataArray.js

@@ -7,8 +7,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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; }
 var vtkErrorMacro = vtkErrorMacro$1;
-var DefaultDataType = Constants.DefaultDataType;
-var TUPLE_HOLDER = []; // ----------------------------------------------------------------------------
+var DefaultDataType = Constants.DefaultDataType; // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 // Original source from https://www.npmjs.com/package/compute-range
@@ -132,9 +131,11 @@ function getDataType(typedArray) {
 function getMaxNorm(normArray) {
   var numComps = normArray.getNumberOfComponents();
   var maxNorm = 0.0;
+  var tuple = new Array(numComps);
 
   for (var i = 0; i < normArray.getNumberOfTuples(); ++i) {
-    var norm$1 = norm(normArray.getTuple(i), numComps);
+    normArray.getTuple(i, tuple);
+    var norm$1 = norm(tuple, numComps);
 
     if (norm$1 > maxNorm) {
       maxNorm = norm$1;
@@ -335,13 +336,8 @@ function vtkDataArray(publicAPI, model) {
   };
 
   publicAPI.getTuple = function (idx) {
-    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
+    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var numberOfComponents = model.numberOfComponents || 1;
-
-    if (tupleToFill.length !== numberOfComponents) {
-      tupleToFill.length = numberOfComponents;
-    }
-
     var offset = idx * numberOfComponents; // Check most common component sizes first
     // to avoid doing a for loop if possible
 
@@ -363,7 +359,7 @@ function vtkDataArray(publicAPI, model) {
         break;
 
       default:
-        for (var i = 0; i < numberOfComponents; i++) {
+        for (var i = numberOfComponents - 1; i >= 0; --i) {
           tupleToFill[i] = model.values[offset + i];
         }
 
@@ -482,12 +478,10 @@ function vtkDataArray(publicAPI, model) {
       vtkErrorMacro('numberOfComponents must match');
     }
 
-    var tuple1 = [];
-    var tuple2 = [];
+    var tuple1 = source1.getTuple(source1Idx);
+    var tuple2 = source2.getTuple(source2Idx);
     var out = [];
-    out.length = numberOfComponents;
-    source1.getTuple(source1Idx, tuple1);
-    source2.getTuple(source2Idx, tuple2); // Check most common component sizes first
+    out.length = numberOfComponents; // Check most common component sizes first
     // to avoid doing a for loop if possible
 
     switch (numberOfComponents) {

package/Common/Core/MatrixBuilder.d.ts

@@ -78,11 +78,11 @@ declare interface Transform {
 	 * iterations (sets of 3) to loop through. Assumes the `typedArray` is an
 	 * array of multiples of 3, unless specifically handling with offset and
 	 * iterations. Returns the instance for chaining.
-	 * @param {TypedArray} typedArray 
+	 * @param {Number[]|TypedArray} typedArray The Array value.
 	 * @param {Number} [offset] 
 	 * @param {Number} [nbIterations] 
 	 */
-	apply(typedArray: TypedArray, offset?: number, nbIterations?: number): Transform
+	apply(typedArray: number[]|TypedArray, offset?: number, nbIterations?: number): Transform
 
 	/**
 	 * Returns the internal `mat4` matrix.

package/Common/Core/Points.d.ts

@@ -1,5 +1,5 @@
 import vtkDataArray from './DataArray';
-import { Bounds } from './../../types';
+import { Bounds, TypedArray } from './../../types';
 
 /**
  *
@@ -26,10 +26,10 @@ export interface vtkPoints extends vtkDataArray {
 	/**
 	 * Get the coordinate of a point.
 	 * @param {Number} idx The index of point.
-	 * @param {Number[]} [tupleToFill] 
-	 * @default []
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
 	 */
-	getPoint(idx: number, tupleToFill?: number[]): number[];
+	getPoint(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
 
 	/**
 	 * Get the number of points for this object can hold.

package/Common/Core/StringArray.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 
-var TUPLE_HOLDER = []; // ----------------------------------------------------------------------------
 // vtkStringArray methods
 // ----------------------------------------------------------------------------
 
@@ -34,7 +33,7 @@ function vtkStringArray(publicAPI, model) {
   };
 
   publicAPI.getTuple = function (idx) {
-    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
+    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var numberOfComponents = model.numberOfComponents || 1;
 
     if (tupleToFill.length) {

package/Common/Core/VariantArray.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 
-var TUPLE_HOLDER = []; // ----------------------------------------------------------------------------
 // vtkVariantArray methods
 // ----------------------------------------------------------------------------
 
@@ -34,7 +33,7 @@ function vtkVariantArray(publicAPI, model) {
   };
 
   publicAPI.getTuple = function (idx) {
-    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
+    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var numberOfComponents = model.numberOfComponents || 1;
 
     if (tupleToFill.length) {

package/Common/DataModel/BoundingBox.js

@@ -56,6 +56,24 @@ function _addPoint(bounds) {
   return bounds;
 }
 
+function _addPoints(bounds, points) {
+  if (points.length === 0) {
+    return bounds;
+  }
+
+  if (Array.isArray(points[0])) {
+    for (var i = 0; i < points.length; ++i) {
+      _addPoint(bounds, points[i]);
+    }
+  } else {
+    for (var _i = 0; _i < points.length; _i += 3) {
+      _addPoint(bounds, points.slice(_i, _i + 3));
+    }
+  }
+
+  return bounds;
+}
+
 function _addBounds(bounds, xMin, xMax, yMin, yMax, zMin, zMax) {
   var _bounds2 = _slicedToArray(bounds, 6),
       _xMin = _bounds2[0],
@@ -337,18 +355,18 @@ function _intersectBox(bounds, origin, dir, coord, tolerance) {
   } // Calculate parametric distance to plane
 
 
-  for (var _i = 0; _i < 3; _i++) {
-    if (quadrant[_i] !== MIDDLE && dir[_i] !== 0.0) {
-      maxT[_i] = (candidatePlane[_i] - origin[_i]) / dir[_i];
+  for (var _i2 = 0; _i2 < 3; _i2++) {
+    if (quadrant[_i2] !== MIDDLE && dir[_i2] !== 0.0) {
+      maxT[_i2] = (candidatePlane[_i2] - origin[_i2]) / dir[_i2];
     } else {
-      maxT[_i] = -1.0;
+      maxT[_i2] = -1.0;
     }
   } // Find the largest parametric value of intersection
 
 
-  for (var _i2 = 0; _i2 < 3; _i2++) {
-    if (maxT[whichPlane] < maxT[_i2]) {
-      whichPlane = _i2;
+  for (var _i3 = 0; _i3 < 3; _i3++) {
+    if (maxT[whichPlane] < maxT[_i3]) {
+      whichPlane = _i3;
     }
   } // Check for valie intersection along line
 
@@ -359,15 +377,15 @@ function _intersectBox(bounds, origin, dir, coord, tolerance) {
 
   tolerance[0] = maxT[whichPlane]; // Intersection point along line is okay. Check bbox.
 
-  for (var _i3 = 0; _i3 < 3; _i3++) {
-    if (whichPlane !== _i3) {
-      coord[_i3] = origin[_i3] + maxT[whichPlane] * dir[_i3];
+  for (var _i4 = 0; _i4 < 3; _i4++) {
+    if (whichPlane !== _i4) {
+      coord[_i4] = origin[_i4] + maxT[whichPlane] * dir[_i4];
 
-      if (coord[_i3] < bounds[2 * _i3] || coord[_i3] > bounds[2 * _i3 + 1]) {
+      if (coord[_i4] < bounds[2 * _i4] || coord[_i4] > bounds[2 * _i4 + 1]) {
         return 0;
       }
     } else {
-      coord[_i3] = candidatePlane[_i3];
+      coord[_i4] = candidatePlane[_i4];
     }
   }
 
@@ -623,6 +641,11 @@ var BoundingBox = /*#__PURE__*/function () {
 
       return _addPoint(this.bounds, xyz);
     }
+  }, {
+    key: "addPoints",
+    value: function addPoints(points) {
+      return _addPoints(this.bounds, points);
+    }
   }, {
     key: "addBounds",
     value: function addBounds(xMin, xMax, yMin, yMax, zMin, zMax) {
@@ -772,6 +795,7 @@ var STATIC = {
   setBounds: _setBounds,
   reset: _reset,
   addPoint: _addPoint,
+  addPoints: _addPoints,
   addBounds: _addBounds,
   setMinPoint: _setMinPoint,
   setMaxPoint: _setMaxPoint,
@@ -805,4 +829,4 @@ var vtkBoundingBox = _objectSpread({
   newInstance: newInstance
 }, STATIC);
 
-export { STATIC, _addBounds as addBounds, _addPoint as addPoint, _computeCornerPoints as computeCornerPoints, _computeLocalBounds as computeLocalBounds, _computeScale as computeScale3, contains, _containsPoint as containsPoint, _cutWithPlane as cutWithPlane, vtkBoundingBox as default, _equals as equals, _getCenter as getCenter, _getCorners as getCorners, _getDiagonalLength as getDiagonalLength, _getLength as getLength, _getLengths as getLengths, _getMaxLength as getMaxLength, _getMaxPoint as getMaxPoint, _getMinPoint as getMinPoint, _getXRange as getXRange, _getYRange as getYRange, _getZRange as getZRange, _inflate as inflate, _intersect as intersect, _intersectBox as intersectBox, _intersectPlane as intersectPlane, _intersects as intersects, _isValid as isValid, _reset as reset, _scale as scale, scaleAboutCenter, _setBounds as setBounds, _setMaxPoint as setMaxPoint, _setMinPoint as setMinPoint };
+export { STATIC, _addBounds as addBounds, _addPoint as addPoint, _addPoints as addPoints, _computeCornerPoints as computeCornerPoints, _computeLocalBounds as computeLocalBounds, _computeScale as computeScale3, contains, _containsPoint as containsPoint, _cutWithPlane as cutWithPlane, vtkBoundingBox as default, _equals as equals, _getCenter as getCenter, _getCorners as getCorners, _getDiagonalLength as getDiagonalLength, _getLength as getLength, _getLengths as getLengths, _getMaxLength as getMaxLength, _getMaxPoint as getMaxPoint, _getMinPoint as getMinPoint, _getXRange as getXRange, _getYRange as getYRange, _getZRange as getZRange, _inflate as inflate, _intersect as intersect, _intersectBox as intersectBox, _intersectPlane as intersectPlane, _intersects as intersects, _isValid as isValid, _reset as reset, _scale as scale, scaleAboutCenter, _setBounds as setBounds, _setMaxPoint as setMaxPoint, _setMinPoint as setMinPoint };

package/Common/DataModel/ImageData.js

@@ -1,11 +1,12 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import { c as computeBoundsFromPoints, b as roundVector, e as clampVector } from '../Core/Math/index.js';
 import vtkBoundingBox from './BoundingBox.js';
 import vtkDataSet from './DataSet.js';
 import vtkStructuredData from './StructuredData.js';
 import { StructuredType } from './StructuredData/Constants.js';
-import { mat3, vec3, mat4 } from 'gl-matrix';
+import { mat3, mat4, vec3 } from 'gl-matrix';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // vtkImageData methods
@@ -31,15 +32,8 @@ function vtkImageData(publicAPI, model) {
       return false;
     }
 
-    var changeDetected = false;
-    model.extent.forEach(function (item, index) {
-      if (item !== extentArray[index]) {
-        if (changeDetected) {
-          return;
-        }
-
-        changeDetected = true;
-      }
+    var changeDetected = model.extent.some(function (item, index) {
+      return item !== extentArray[index];
     });
 
     if (changeDetected) {
@@ -196,49 +190,22 @@ function vtkImageData(publicAPI, model) {
 
   publicAPI.extentToBounds = function (ex) {
     // prettier-ignore
-    var corners = [ex[0], ex[2], ex[4], ex[1], ex[2], ex[4], ex[0], ex[3], ex[4], ex[1], ex[3], ex[4], ex[0], ex[2], ex[5], ex[1], ex[2], ex[5], ex[0], ex[3], ex[5], ex[1], ex[3], ex[5]];
-    var idx = new Float64Array([corners[0], corners[1], corners[2]]);
-    var vout = new Float64Array(3);
-    publicAPI.indexToWorld(idx, vout);
-    var bounds = [vout[0], vout[0], vout[1], vout[1], vout[2], vout[2]];
-
-    for (var i = 3; i < 24; i += 3) {
-      vec3.set(idx, corners[i], corners[i + 1], corners[i + 2]);
-      publicAPI.indexToWorld(idx, vout);
-
-      if (vout[0] < bounds[0]) {
-        bounds[0] = vout[0];
-      }
+    var corners = [[ex[0], ex[2], ex[4]], [ex[1], ex[2], ex[4]], [ex[0], ex[3], ex[4]], [ex[1], ex[3], ex[4]], [ex[0], ex[2], ex[5]], [ex[1], ex[2], ex[5]], [ex[0], ex[3], ex[5]], [ex[1], ex[3], ex[5]]];
 
-      if (vout[1] < bounds[2]) {
-        bounds[2] = vout[1];
-      }
+    var bounds = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
 
-      if (vout[2] < bounds[4]) {
-        bounds[4] = vout[2];
-      }
+    var vout = [];
 
-      if (vout[0] > bounds[1]) {
-        bounds[1] = vout[0];
-      }
-
-      if (vout[1] > bounds[3]) {
-        bounds[3] = vout[1];
-      }
-
-      if (vout[2] > bounds[5]) {
-        bounds[5] = vout[2];
-      }
+    for (var i = 0; i < 8; ++i) {
+      publicAPI.indexToWorld(corners[i], vout);
+      vtkBoundingBox.addPoint.apply(vtkBoundingBox, [bounds].concat(vout));
     }
 
     return bounds;
   };
 
   publicAPI.getSpatialExtent = function () {
-    var boundingBox = vtkBoundingBox.newInstance();
-    boundingBox.setBounds(model.extent);
-    boundingBox.inflate(0.5);
-    return boundingBox.getBounds();
+    return vtkBoundingBox.inflate(_toConsumableArray(model.extent), 0.5);
   }; // Internal, shouldn't need to call this manually.
 
 
@@ -351,14 +318,7 @@ function vtkImageData(publicAPI, model) {
   publicAPI.computeTransforms();
 
   publicAPI.getCenter = function () {
-    var bounds = publicAPI.getBounds();
-    var center = [];
-
-    for (var i = 0; i < 3; i++) {
-      center[i] = (bounds[2 * i + 1] + bounds[2 * i]) / 2;
-    }
-
-    return center;
+    return vtkBoundingBox.getCenter(publicAPI.getBounds());
   };
 
   publicAPI.computeHistogram = function (worldBounds) {

package/Filters/General/ClipClosedSurface.js

@@ -91,10 +91,8 @@ function vtkClipClosedSurface(publicAPI, model) {
     } // Get the edge and interpolate the new point
 
 
-    var p0 = [];
-    var p1 = [];
-    points.getPoint(i0, p0);
-    points.getPoint(i1, p1);
+    var p0 = points.getPoint(i0);
+    var p1 = points.getPoint(i1);
     var f = v0 / (v0 - v1);
     var s = 1.0 - f;
     var t = 1.0 - s;

package/Filters/General/ImageStreamline.js

@@ -114,9 +114,10 @@ function vtkImageStreamline(publicAPI, model) {
     velAtArg[0] = 0.0;
     velAtArg[1] = 0.0;
     velAtArg[2] = 0.0;
+    var vel = new Array(3);
 
     for (var i = 0; i < 8; i++) {
-      var vel = velArray.getTuple(voxelIndices[i]);
+      velArray.getTuple(voxelIndices[i], vel);
 
       for (var j = 0; j < 3; j++) {
         velAtArg[j] += weights[i] * vel[j];
@@ -212,9 +213,11 @@ function vtkImageStreamline(publicAPI, model) {
     var offset = 0;
     var datas = [];
     var vectors = input.getPointData().getVectors();
+    var point = [];
 
     for (var i = 0; i < nSeeds; i++) {
-      var retVal = publicAPI.streamIntegrate(vectors, input, seedPts.getTuple(i), offset);
+      seedPts.getTuple(i, point);
+      var retVal = publicAPI.streamIntegrate(vectors, input, point, offset);
       offset += retVal[0].length / 3;
       datas.push(retVal);
     }

package/Filters/General/PaintFilter.js

@@ -89,10 +89,11 @@ function vtkPaintFilter(publicAPI, model) {
 
     if (model.voxelFunc) {
       var bgScalars = model.backgroundImage.getPointData().getScalars();
+      var voxel = [];
 
       for (var _i = 0; _i < maskLabelMap.length; _i++) {
         if (maskLabelMap[_i]) {
-          var voxel = bgScalars.getTuple(_i); // might not fill up snapshot
+          bgScalars.getTuple(_i, voxel); // might not fill up snapshot
 
           if (model.voxelFunc(voxel, _i, label)) {
             snapshot[diffIdx++] = [_i, data[_i]];

package/Filters/General/TubeFilter.js

@@ -236,6 +236,7 @@ function vtkTubeFilter(publicAPI, model) {
     var normal = [0.0, 0.0, 0.0];
     var sFactor = 1.0;
     var ptId = offset;
+    var vector = [];
 
     for (var j = 0; j < npts; ++j) {
       // First point
@@ -307,7 +308,7 @@ function vtkTubeFilter(publicAPI, model) {
       if (inScalars && model.varyRadius === VaryRadius.VARY_RADIUS_BY_SCALAR) {
         sFactor = 1.0 + (model.radiusFactor - 1.0) * (inScalars.getComponent(pts[j], 0) - range[0]) / (range[1] - range[0]);
       } else if (inVectors && model.varyRadius === VaryRadius.VARY_RADIUS_BY_VECTOR) {
-        sFactor = Math.sqrt(maxSpeed / norm(inVectors.getTuple(pts[j])));
+        sFactor = Math.sqrt(maxSpeed / norm(inVectors.getTuple(pts[j], vector)));
 
         if (sFactor > model.radiusFactor) {
           sFactor = model.radiusFactor;
@@ -667,16 +668,10 @@ function vtkTubeFilter(publicAPI, model) {
     var numStrips = 0;
     var inLinesData = inLines.getData();
     var npts = inLinesData[0];
-    var sidesShareVerticesMultiplier = model.sidesShareVertices ? 1 : 2;
 
     for (var i = 0; i < inLinesData.length; i += npts + 1) {
-      numNewPts += sidesShareVerticesMultiplier * npts * model.numberOfSides;
-
-      if (model.capping) {
-        numNewPts += 2 * model.numberOfSides;
-      }
-
       npts = inLinesData[i];
+      numNewPts = computeOffset(numNewPts, npts);
       numStrips += (2 * npts + 1) * Math.ceil(model.numberOfSides / model.onRatio);
 
       if (model.capping) {

package/Filters/General/WindowedSincPolyDataFilter.js

@@ -1,4 +1,3 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -177,13 +176,13 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
             if (model.featureEdgeSmoothing) {
               // TODO: support polygons
               // vtkPolygon::ComputeNormal(inPts,npts,pts,normal);
-              vtkTriangle.computeNormal(_toConsumableArray(inPts.getPoint(_pts2[0])), _toConsumableArray(inPts.getPoint(_pts2[1])), _toConsumableArray(inPts.getPoint(_pts2[2])), normal);
+              vtkTriangle.computeNormal(inPts.getPoint(_pts2[0]), inPts.getPoint(_pts2[1]), inPts.getPoint(_pts2[2]), normal);
 
               var _mesh$getCellPoints = mesh.getCellPoints(nei),
                   cellPointIds = _mesh$getCellPoints.cellPointIds; // vtkPolygon::ComputeNormal(inPts,numNeiPts,neiPts,neiNormal);
 
 
-              vtkTriangle.computeNormal(_toConsumableArray(inPts.getPoint(cellPointIds[0])), _toConsumableArray(inPts.getPoint(cellPointIds[1])), _toConsumableArray(inPts.getPoint(cellPointIds[2])), neiNormal);
+              vtkTriangle.computeNormal(inPts.getPoint(cellPointIds[0]), inPts.getPoint(cellPointIds[1]), inPts.getPoint(cellPointIds[2]), neiNormal);
 
               if (vtkMath.dot(normal, neiNormal) <= cosFeatureAngle) {
                 edge = VertexType.VTK_FEATURE_EDGE_VERTEX;
@@ -230,12 +229,11 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
           verts[_i4].type = VertexType.VTK_FIXED_VERTEX;
         } // check angle between edges
         else {
-          var _x = [0, 0, 0];
-          inPts.getPoint(verts[_i4].edges[0], _x);
-          var _x2 = [0, 0, 0];
-          inPts.getPoint(_i4, _x2);
-          var x3 = [0, 0, 0];
-          inPts.getPoint(verts[_i4].edges[1], x3);
+          var _x = inPts.getPoint(verts[_i4].edges[0]);
+
+          var _x2 = inPts.getPoint(_i4);
+
+          var x3 = inPts.getPoint(verts[_i4].edges[1]);
           var l1 = [0, 0, 0];
           var l2 = [0, 0, 0];
 

package/Filters/General.js

@@ -12,6 +12,7 @@ import vtkOBBTree from './General/OBBTree.js';
 import vtkOutlineFilter from './General/OutlineFilter.js';
 import vtkPaintFilter from './General/PaintFilter.js';
 import vtkScalarToRGBA from './General/ScalarToRGBA.js';
+import vtkTriangleFilter from './General/TriangleFilter.js';
 import vtkTubeFilter from './General/TubeFilter.js';
 import vtkWarpScalar from './General/WarpScalar.js';
 import vtkWindowedSincPolyDataFilter from './General/WindowedSincPolyDataFilter.js';
@@ -31,6 +32,7 @@ var General = {
   vtkOutlineFilter: vtkOutlineFilter,
   vtkPaintFilter: vtkPaintFilter,
   vtkScalarToRGBA: vtkScalarToRGBA,
+  vtkTriangleFilter: vtkTriangleFilter,
   vtkTubeFilter: vtkTubeFilter,
   vtkWarpScalar: vtkWarpScalar,
   vtkWindowedSincPolyDataFilter: vtkWindowedSincPolyDataFilter

package/Rendering/Core/VolumeMapper/Constants.d.ts

@@ -4,8 +4,9 @@ export declare enum BlendMode {
 	MINIMUM_INTENSITY_BLEND = 2,
 	AVERAGE_INTENSITY_BLEND = 3,
 	ADDITIVE_INTENSITY_BLEND = 4,
+	RADON_TRANSFORM_BLEND = 5,
 }
-	
+
 export declare enum FilterMode {
 	OFF = 0,
 	NORMALIZED = 1,

package/Rendering/Core/VolumeMapper/Constants.js

@@ -3,7 +3,8 @@ var BlendMode = {
   MAXIMUM_INTENSITY_BLEND: 1,
   MINIMUM_INTENSITY_BLEND: 2,
   AVERAGE_INTENSITY_BLEND: 3,
-  ADDITIVE_INTENSITY_BLEND: 4
+  ADDITIVE_INTENSITY_BLEND: 4,
+  RADON_TRANSFORM_BLEND: 5
 };
 var FilterMode = {
   OFF: 0,

package/Rendering/Core/VolumeMapper.d.ts

@@ -1,3 +1,4 @@
+import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { Bounds, Range } from './../../types';
 import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
 import { BlendMode, FilterMode } from './VolumeMapper/Constants';
@@ -151,6 +152,11 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 */
 	setBlendModeToAverageIntensity(): void;
 
+	/**
+	 * Set blend mode to RADON_TRANSFORM_BLEND
+	 */
+	 setBlendModeToRadonTransform(): void;
+
 	/**
 	 * Get the distance between samples used for rendering
 	 * @param sampleDistance 
@@ -233,6 +239,35 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	update(): void;
 }
 
+/**
+ * Create an absorption transfer function to set to the mapper when blend mode is RADON.
+ * The transfer function is a linear ramp between the lowest material with absorption and
+ * the material with maximum absorption. Voxel values lower than the lowest material with
+ * absorption will have no absorption associated. Voxel values higher than the maximum
+ * absorbent material will have the same absorption than the max absorbent material.
+ * The associated color transfer function is typically black to white between 0 and 1.
+ * An alternative is to create your own transfer function with HU/absorption pairs. e.g.
+ * const ofun = vtkPiecewiseFunction.newInstance();
+ * ofun.addPointLong(-1000,0, 1, 1); // air, "1, 1)" to flatten the function
+ * ofun.addPoint(-10, 0.01); // fat
+ * ofun.addPoint(-10, 0.015); // water
+ * ofun.addPointLong(1000, 0.03, 1, 1); // bone
+ * ofun.addPoint(3000, 1); // silver
+ * @static
+ * @param {number} firstAbsorbentMaterialHounsfieldValue: Define minimum voxel value (in hounsfield unit) with non zero absorption (e.g. water (0), fat(-10)...).
+ * Any voxel value lower than this parameter will have no absorption (absorption === 0)
+ * @param {number} firstAbsorbentMaterialAbsorption: Absorption attributed to voxels with firstAbsorbentMaterialHounsfieldValue (e.g. 0 or 0.01)
+ * @param {number} maxAbsorbentMaterialHounsfieldValue: Define maximum voxel value (in hounsfield unit) with increasing absorption (e.g. bone (1000))
+ * @param {number} maxAbsorbentMaterialAbsorption: Absorption attributed to voxels >= maxAbsorbentMaterialHounsfieldValue (e.g. 0.03)
+ * @param {vtkPiecewiseFunction} outputTransferFunction: To provide optionally to avoid instantiating a new transfer function each time.
+ * @return {vtkPiecewiseFunction} the created absorption transfer function to set on VolumeMapper scalarOpacity.
+ */
+export function createRadonTransferFunction(
+	firstAbsorbentMaterialHounsfieldValue: number,
+	firstAbsorbentMaterialAbsorption: number,
+	maxAbsorbentMaterialHounsfieldValue: number,
+	maxAbsorbentMaterialAbsorption: number,
+	outputTransferFunction?: vtkPiecewiseFunction): vtkPiecewiseFunction;
 
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkVolumeMapper characteristics.

package/Rendering/Core/VolumeMapper.js

@@ -3,12 +3,37 @@ import macro from '../../macros.js';
 import { O as createUninitializedBounds, D 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';
 
 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; }
 var BlendMode = Constants.BlendMode,
-    FilterMode = Constants.FilterMode; // ----------------------------------------------------------------------------
+    FilterMode = Constants.FilterMode;
+
+function createRadonTransferFunction(firstAbsorbentMaterialHounsfieldValue, firstAbsorbentMaterialAbsorption, maxAbsorbentMaterialHounsfieldValue, maxAbsorbentMaterialAbsorption, outputTransferFunction) {
+  var ofun = null;
+
+  if (outputTransferFunction) {
+    ofun = outputTransferFunction;
+    ofun.removeAllPoints();
+  } else {
+    ofun = vtkPiecewiseFunction.newInstance();
+  }
+
+  ofun.addPointLong(-1024, 0, 1, 1); // air (i.e. material with no absorption)
+
+  ofun.addPoint(firstAbsorbentMaterialHounsfieldValue, firstAbsorbentMaterialAbsorption);
+  ofun.addPoint(maxAbsorbentMaterialHounsfieldValue, maxAbsorbentMaterialAbsorption);
+  return ofun;
+} // ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+
+var STATIC = {
+  createRadonTransferFunction: createRadonTransferFunction
+}; // ----------------------------------------------------------------------------
 // vtkVolumeMapper methods
 // ----------------------------------------------------------------------------
 
@@ -58,6 +83,10 @@ function vtkVolumeMapper(publicAPI, model) {
     publicAPI.setBlendMode(BlendMode.ADDITIVE_INTENSITY_BLEND);
   };
 
+  publicAPI.setBlendModeToRadonTransform = function () {
+    publicAPI.setBlendMode(BlendMode.RADON_TRANSFORM_BLEND);
+  };
+
   publicAPI.getBlendModeAsString = function () {
     return macro.enumToString(BlendMode, model.blendMode);
   };
@@ -149,9 +178,9 @@ function extend(publicAPI, model) {
 
 var newInstance = macro.newInstance(extend, 'vtkVolumeMapper'); // ----------------------------------------------------------------------------
 
-var vtkVolumeMapper$1 = {
+var vtkVolumeMapper$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
-};
+}, STATIC);
 
-export { vtkVolumeMapper$1 as default, extend, newInstance };
+export { STATIC, vtkVolumeMapper$1 as default, extend, newInstance };

package/Rendering/Misc/RemoteView.d.ts

@@ -1,5 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import vtkCanvasView from './CanvasView';
+import vtkImageStream from './../../IO/Core/ImageStream';
 import vtkViewStream from './../../IO/Core/ImageStream/ViewStream';
 
 interface IRemoteViewInitialValues {
@@ -188,13 +189,18 @@ export function newInstance(
   initialValues?: IRemoteViewInitialValues
 ): vtkRemoteView;
 
-export function connectImageStream(session: any): any;
+export function connectImageStream(session: any): void;
+
+export function disconnectImageStream(): void;
+
 /**
  * vtkRemoteView provides a way to create a remote view.
  */
 export declare const vtkRemoteView: {
   newInstance: typeof newInstance;
   extend: typeof extend;
+  SHARED_IMAGE_STREAM: vtkImageStream;
   connectImageStream: typeof connectImageStream;
+  disconnectImageStream: typeof disconnectImageStream;
 };
 export default vtkRemoteView;

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -209,9 +209,11 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         var p = vtkPoints.newInstance();
         var numPts = points.getNumberOfPoints();
         p.setNumberOfPoints(numPts);
+        var point = [];
 
         for (var i = 0; i < numPts; ++i) {
-          transformCoordinate.setValue(points.getPoint(i));
+          points.getPoint(i, point);
+          transformCoordinate.setValue(point);
           var v = transformCoordinate.getComputedDoubleViewportValue(ren);
           p.setPoint(i, v[0], v[1], 0.0);
         }

package/Rendering/OpenGL/RenderWindow/ContextProxy.js

@@ -41,7 +41,7 @@ function createContextProxyHandler() {
 
   return {
     get: function get(gl, prop, receiver) {
-      var value = Reflect.get(gl, prop, receiver);
+      var value = Reflect.get(gl, prop, gl);
 
       if (value instanceof Function) {
         // prevents Illegal Invocation errors

package/Rendering/OpenGL/glsl/vtkVolumeFS.glsl.js

@@ -1,3 +1,3 @@
-var vtkVolumeFS = "//VTK::System::Dec\n\n/*=========================================================================\n\n  Program:   Visualization Toolkit\n  Module:    vtkVolumeFS.glsl\n\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n  All rights reserved.\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n     This software is distributed WITHOUT ANY WARRANTY; without even\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n     PURPOSE.  See the above copyright notice for more information.\n\n=========================================================================*/\n// Template for the volume mappers fragment shader\n\n// the output of this shader\n//VTK::Output::Dec\n\nvarying vec3 vertexVCVSOutput;\n\n// first declare the settings from the mapper\n// that impact the code paths in here\n\n// always set vtkNumComponents 1,2,3,4\n//VTK::NumComponents\n\n// possibly define vtkTrilinearOn\n//VTK::TrilinearOn\n\n// possibly define vtkIndependentComponents\n//VTK::IndependentComponentsOn\n\n// possibly define any \"proportional\" components\n//VTK::vtkProportionalComponents\n\n// Define the blend mode to use\n#define vtkBlendMode //VTK::BlendMode\n\n// Possibly define vtkImageLabelOutlineOn\n//VTK::ImageLabelOutlineOn\n\n#ifdef vtkImageLabelOutlineOn\nuniform int outlineThickness;\nuniform float vpWidth;\nuniform float vpHeight;\nuniform float vpOffsetX;\nuniform float vpOffsetY;\nuniform mat4 PCWCMatrix;\nuniform mat4 vWCtoIDX;\n#endif\n\n// define vtkLightComplexity\n//VTK::LightComplexity\n#if vtkLightComplexity > 0\nuniform float vSpecularPower;\nuniform float vAmbient;\nuniform float vDiffuse;\nuniform float vSpecular;\n//VTK::Light::Dec\n#endif\n\n//VTK::VolumeShadowOn\n//VTK::SurfaceShadowOn\n//VTK::localAmbientOcclusionOn\n//VTK::LAO::Dec\n//VTK::VolumeShadow::Dec\n\n// define vtkComputeNormalFromOpacity\n//VTK::vtkComputeNormalFromOpacity\n\n// possibly define vtkGradientOpacityOn\n//VTK::GradientOpacityOn\n#ifdef vtkGradientOpacityOn\nuniform float goscale0;\nuniform float goshift0;\nuniform float gomin0;\nuniform float gomax0;\n#if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\nuniform float goscale1;\nuniform float goshift1;\nuniform float gomin1;\nuniform float gomax1;\n#if vtkNumComponents >= 3\nuniform float goscale2;\nuniform float goshift2;\nuniform float gomin2;\nuniform float gomax2;\n#endif\n#if vtkNumComponents >= 4\nuniform float goscale3;\nuniform float goshift3;\nuniform float gomin3;\nuniform float gomax3;\n#endif\n#endif\n#endif\n\n// if you want to see the raw tiled\n// data in webgl1 uncomment the following line\n// #define debugtile\n\n// camera values\nuniform float camThick;\nuniform float camNear;\nuniform float camFar;\nuniform int cameraParallel;\n\n// values describing the volume geometry\nuniform vec3 vOriginVC;\nuniform vec3 vSpacing;\nuniform ivec3 volumeDimensions; // 3d texture dimensions\nuniform vec3 vPlaneNormal0;\nuniform float vPlaneDistance0;\nuniform vec3 vPlaneNormal1;\nuniform float vPlaneDistance1;\nuniform vec3 vPlaneNormal2;\nuniform float vPlaneDistance2;\nuniform vec3 vPlaneNormal3;\nuniform float vPlaneDistance3;\nuniform vec3 vPlaneNormal4;\nuniform float vPlaneDistance4;\nuniform vec3 vPlaneNormal5;\nuniform float vPlaneDistance5;\n\n//VTK::ClipPlane::Dec\n\n// opacity and color textures\nuniform sampler2D otexture;\nuniform float oshift0;\nuniform float oscale0;\nuniform sampler2D ctexture;\nuniform float cshift0;\nuniform float cscale0;\n\n// jitter texture\nuniform sampler2D jtexture;\n\n// some 3D texture values\nuniform float sampleDistance;\nuniform vec3 vVCToIJK;\n\n// the heights defined below are the locations\n// for the up to four components of the tfuns\n// the tfuns have a height of 2XnumComps pixels so the\n// values are computed to hit the middle of the two rows\n// for that component\n#ifdef vtkIndependentComponentsOn\n#if vtkNumComponents == 2\nuniform float mix0;\nuniform float mix1;\n#define height0 0.25\n#define height1 0.75\n#endif\n#if vtkNumComponents == 3\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\n#define height0 0.17\n#define height1 0.5\n#define height2 0.83\n#endif\n#if vtkNumComponents == 4\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\nuniform float mix3;\n#define height0 0.125\n#define height1 0.375\n#define height2 0.625\n#define height3 0.875\n#endif\n#endif\n\n#if vtkNumComponents >= 2\nuniform float oshift1;\nuniform float oscale1;\nuniform float cshift1;\nuniform float cscale1;\n#endif\n#if vtkNumComponents >= 3\nuniform float oshift2;\nuniform float oscale2;\nuniform float cshift2;\nuniform float cscale2;\n#endif\n#if vtkNumComponents >= 4\nuniform float oshift3;\nuniform float oscale3;\nuniform float cshift3;\nuniform float cscale3;\n#endif\n\nuniform vec4 ipScalarRangeMin;\nuniform vec4 ipScalarRangeMax;\n\n// declaration for intermixed geometry\n//VTK::ZBuffer::Dec\n\n//=======================================================================\n// global and custom variables (a temporary section before photorealistics rendering module is complete)\nvec3 rayDirVC;\nfloat sampleDistanceISVS;\nfloat sampleDistanceIS;\n\n#define SQRT3    1.7321\n#define INV4PI   0.0796\n#define EPSILON  0.001\n#define PI       3.1415\n#define PI2      9.8696\n\n//=======================================================================\n// Webgl2 specific version of functions\n#if __VERSION__ == 300\n\nuniform highp sampler3D texture1;\n\nvec4 getTextureValue(vec3 pos)\n{\n  vec4 tmp = texture(texture1, pos);\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.a = tmp.g;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n  return tmp;\n}\n\n//=======================================================================\n// WebGL1 specific version of functions\n#else\n\nuniform sampler2D texture1;\n\nuniform float texWidth;\nuniform float texHeight;\nuniform int xreps;\nuniform int xstride;\nuniform int ystride;\n\n// if computing trilinear values from multiple z slices\n#ifdef vtkTrilinearOn\nvec4 getTextureValue(vec3 ijk)\n{\n  float zoff = 1.0/float(volumeDimensions.z);\n  vec4 val1 = getOneTextureValue(ijk);\n  vec4 val2 = getOneTextureValue(vec3(ijk.xy, ijk.z + zoff));\n\n  float indexZ = float(volumeDimensions)*ijk.z;\n  float zmix =  indexZ - floor(indexZ);\n\n  return mix(val1, val2, zmix);\n}\n\nvec4 getOneTextureValue(vec3 ijk)\n#else // nearest or fast linear\nvec4 getTextureValue(vec3 ijk)\n#endif\n{\n  vec3 tdims = vec3(volumeDimensions);\n\n#ifdef debugtile\n  vec2 tpos = vec2(ijk.x, ijk.y);\n  vec4 tmp = texture2D(texture1, tpos);\n  tmp.a = 1.0;\n\n#else\n  int z = int(ijk.z * tdims.z);\n  int yz = z / xreps;\n  int xz = z - yz*xreps;\n\n  int tileWidth = volumeDimensions.x/xstride;\n  int tileHeight = volumeDimensions.y/ystride;\n\n  xz *= tileWidth;\n  yz *= tileHeight;\n\n  float ni = float(xz) + (ijk.x*float(tileWidth));\n  float nj = float(yz) + (ijk.y*float(tileHeight));\n\n  vec2 tpos = vec2(ni/texWidth, nj/texHeight);\n\n  vec4 tmp = texture2D(texture1, tpos);\n\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.g = tmp.a;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n#endif\n\n  return tmp;\n}\n\n// End of Webgl1 specific code\n//=======================================================================\n#endif\n\n//=======================================================================\n// transformation between VC and IS space\n\n// convert vector position from idx to vc\n#if vtkLightComplexity > 0\nvec3 IStoVC(vec3 posIS){\n  vec3 posVC = posIS / vVCToIJK;\n  return posVC.x * vPlaneNormal0 + \n         posVC.y * vPlaneNormal2 + \n         posVC.z * vPlaneNormal4 + \n         vOriginVC;\n}\n\n// convert vector position from vc to idx\nvec3 VCtoIS(vec3 posVC){\n  posVC = posVC - vOriginVC;\n  posVC = vec3(\n    dot(posVC, vPlaneNormal0),\n    dot(posVC, vPlaneNormal2),\n    dot(posVC, vPlaneNormal4));  \n  return posVC * vVCToIJK;\n}\n#endif\n\n//Rotate vector to view coordinate\n#if (vtkLightComplexity > 0) || (defined vtkGradientOpacityOn)\nvoid rotateToViewCoord(inout vec3 dirIS){\n  dirIS.xyz =\n    dirIS.x * vPlaneNormal0 +\n    dirIS.y * vPlaneNormal2 +\n    dirIS.z * vPlaneNormal4;\n}\n\n//Rotate vector to idx coordinate\nvec3 rotateToIDX(vec3 dirVC){\n  vec3 dirIS;\n  dirIS.xyz = vec3(\n    dot(dirVC, vPlaneNormal0),\n    dot(dirVC, vPlaneNormal2),\n    dot(dirVC, vPlaneNormal4));  \n  return dirIS;\n}\n#endif\n\n//=======================================================================\n// Given a normal compute the gradient opacity factors\nfloat computeGradientOpacityFactor(\n  float normalMag, float goscale, float goshift, float gomin, float gomax)\n{\n#if defined(vtkGradientOpacityOn)\n  return clamp(normalMag * goscale + goshift, gomin, gomax);\n#else\n  return 1.0;\n#endif\n}\n\n//=======================================================================\n// compute the normal and gradient magnitude for a position, uses forward difference\n#if (vtkLightComplexity > 0) || (defined vtkGradientOpacityOn)\n  #ifdef vtkComputeNormalFromOpacity\n    #ifdef vtkGradientOpacityOn\n      vec4 computeNormalForDensity(vec3 pos, float scalar, vec3 tstep, out mat3 scalarInterp, out vec3 secondaryGradientMag)\n      {\n        vec4 result;\n        scalarInterp[0][0] = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a;\n        scalarInterp[0][1] = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a;\n        scalarInterp[0][2] = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a;\n        // look up scalar values for computing secondary gradient\n        scalarInterp[1][0] = getTextureValue(pos + vec3(2.0*tstep.x, 0.0, 0.0)).a;\n        scalarInterp[1][1] = getTextureValue(pos + vec3(0.0, 2.0*tstep.y, 0.0)).a;\n        scalarInterp[1][2] = getTextureValue(pos + vec3(0.0, 0.0, 2.0*tstep.z)).a;\n        scalarInterp[2][0] = getTextureValue(pos + vec3(tstep.x, tstep.y, 0.0)).a;\n        scalarInterp[2][1] = getTextureValue(pos + vec3(tstep.x, 0.0, tstep.z)).a;\n        scalarInterp[2][2] = getTextureValue(pos + vec3(0.0, tstep.y, tstep.z)).a;\n        result.x = scalarInterp[0][0] - scalar;\n        result.y = scalarInterp[0][1] - scalar;\n        result.z = scalarInterp[0][2] - scalar;\n        // divide by spacing\n        result.xyz /= vSpacing;\n        result.w = length(result.xyz);\n        rotateToViewCoord(result.xyz);\n        secondaryGradientMag.x = length(vec3(scalarInterp[1][0] - scalarInterp[0][0],\n                                             scalarInterp[2][0] - scalarInterp[0][0],\n                                             scalarInterp[2][1] - scalarInterp[0][0]) / vSpacing);\n        secondaryGradientMag.y = length(vec3(scalarInterp[2][0] - scalarInterp[0][1],\n                                             scalarInterp[1][1] - scalarInterp[0][1],\n                                             scalarInterp[2][2] - scalarInterp[0][1]) / vSpacing);\n        secondaryGradientMag.z = length(vec3(scalarInterp[2][1] - scalarInterp[0][2],\n                                             scalarInterp[2][2] - scalarInterp[0][2],\n                                             scalarInterp[1][2] - scalarInterp[0][2]) / vSpacing);\n        if (length(result.xyz) > 0.0) {\n          return vec4(normalize(result.xyz),result.w);\n        } else {\n          return vec4(0.0);\n        }\n      }\n\n      vec4 computeDensityNormal(float scalar, float gradientMag, mat3 scalarInterp, vec3 secondaryGradientMag)\n      {\n        vec4 opacityG;\n        vec3 opacityInterp = vec3(0.0);\n        float opacity = texture2D(otexture, vec2(scalar * oscale0 + oshift0, 0.5)).r;\n        if (gradientMag >= 0.0){\n          opacity *= computeGradientOpacityFactor(gradientMag, goscale0, goshift0, gomin0, gomax0);\n        }\n        opacityInterp.x = texture2D(otexture, vec2(scalarInterp[0][0] * oscale0 + oshift0, 0.5)).r; \n        if (secondaryGradientMag.x >= 0.0){\n          opacityInterp.x *= computeGradientOpacityFactor(secondaryGradientMag.x, goscale0, goshift0, gomin0, gomax0);\n        }\n    \n        opacityInterp.y = texture2D(otexture, vec2(scalarInterp[0][1] * oscale0 + oshift0, 0.5)).r;\n        if (secondaryGradientMag.y >= 0.0){\n          opacityInterp.y *= computeGradientOpacityFactor(secondaryGradientMag.y, goscale0, goshift0, gomin0, gomax0);\n        }\n\n        opacityInterp.z = texture2D(otexture, vec2(scalarInterp[0][2] * oscale0 + oshift0, 0.5)).r;\n        if (secondaryGradientMag.z >= 0.0){\n          opacityInterp.z *= computeGradientOpacityFactor(secondaryGradientMag.z, goscale0, goshift0, gomin0, gomax0);\n        }\n\n        opacityG.xyz = opacityInterp - vec3(opacity,opacity,opacity);\n        // divide by spacing\n        opacityG.xyz /= vSpacing;\n        opacityG.w = length(opacityG.xyz);\n        rotateToViewCoord(opacityG.xyz);\n        if (length(opacityG.xyz) > 0.0) {  \n          return vec4(normalize(opacityG.xyz),opacityG.w);\n        } else {\n          return vec4(0.0);\n        }\n      } \n\n    #else\n    //if gradient opacity not on but using density gradient\n      vec4 computeDensityNormal(float scalar, vec3 scalarInterp) \n      { \n        vec4 opacityG; \n        float opacity = texture2D(otexture, vec2(scalar * oscale0 + oshift0, 0.5)).r; \n        opacityG.x = texture2D(otexture, vec2(scalarInterp.x * oscale0 + oshift0, 0.5)).r - opacity; \n        opacityG.y = texture2D(otexture, vec2(scalarInterp.y * oscale0 + oshift0, 0.5)).r - opacity; \n        opacityG.z = texture2D(otexture, vec2(scalarInterp.z * oscale0 + oshift0, 0.5)).r - opacity; \n        // divide by spacing \n        opacityG.xyz /= vSpacing; \n        opacityG.w = length(opacityG.xyz); \n        // rotate to View Coords \n        rotateToViewCoord(opacityG.xyz);\n        if (length(opacityG.xyz) > 0.0) {     \n          return vec4(normalize(opacityG.xyz),opacityG.w); \n        } else { \n          return vec4(0.0); \n        } \n      } \n      vec4 computeNormalForDensity(vec3 pos, float scalar, vec3 tstep, out vec3 scalarInterp) \n      { \n        vec4 result; \n        scalarInterp.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a; \n        scalarInterp.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a; \n        scalarInterp.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a; \n        result.x = scalarInterp.x - scalar; \n        result.y = scalarInterp.y - scalar; \n        result.z = scalarInterp.z - scalar;   \n        // divide by spacing\n        result.xyz /= vSpacing;\n        result.w = length(result.xyz); \n        // rotate to View Coords \n        rotateToViewCoord(result.xyz);      \n        if (length(result.xyz) > 0.0) {     \n          return vec4(normalize(result.xyz),result.w); \n        } else { \n          return vec4(0.0); \n        } \n      }           \n    #endif\n  #endif\n  // compute scalar density\n  vec4 computeNormal(vec3 pos, float scalar, vec3 tstep)  \n  {  \n    vec4 result;  \n    result.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a - scalar;  \n    result.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a - scalar;  \n    result.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a - scalar;  \n    // divide by spacing  \n    result.xyz /= vSpacing;  \n    result.w = length(result.xyz);\n    if (result.w > 0.0){\n      // rotate to View Coords  \n      rotateToViewCoord(result.xyz);\n      return vec4(normalize(result.xyz),result.w);  \n    } else {\n      return vec4(0.0);\n    }\n  }  \n#endif\n\n#ifdef vtkImageLabelOutlineOn\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\n  vec4 pcPos = vec4(\n    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\n    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\n    (fragCoord.z - 0.5) * 2.0,\n    1.0);\n\n  vec4 worldCoord = PCWCMatrix * pcPos;\n  vec4 vertex = (worldCoord/worldCoord.w);\n\n  vec3 index = (vWCtoIDX * vertex).xyz;\n\n  // half voxel fix for labelmapOutline \n  return (index + vec3(0.5)) / vec3(volumeDimensions);\n}\n#endif\n\n//=======================================================================\n// compute the normals and gradient magnitudes for a position\n// for independent components\nmat4 computeMat4Normal(vec3 pos, vec4 tValue, vec3 tstep)\n{\n  mat4 result;\n  vec4 distX = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)) - tValue;\n  vec4 distY = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)) - tValue;\n  vec4 distZ = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)) - tValue;\n\n  // divide by spacing\n  distX /= vSpacing.x;\n  distY /= vSpacing.y;\n  distZ /= vSpacing.z;\n\n  mat3 rot;\n  rot[0] = vPlaneNormal0;\n  rot[1] = vPlaneNormal2;\n  rot[2] = vPlaneNormal4;\n\n#if !defined(vtkComponent0Proportional)\n  result[0].xyz = vec3(distX.r, distY.r, distZ.r);\n  result[0].a = length(result[0].xyz);\n  result[0].xyz *= rot;\n  if (result[0].w > 0.0)\n  {\n    result[0].xyz /= result[0].w;\n  }\n#endif\n\n// optionally compute the 2nd component\n#if vtkNumComponents >= 2 && !defined(vtkComponent1Proportional)\n  result[1].xyz = vec3(distX.g, distY.g, distZ.g);\n  result[1].a = length(result[1].xyz);\n  result[1].xyz *= rot;\n  if (result[1].w > 0.0)\n  {\n    result[1].xyz /= result[1].w;\n  }\n#endif\n\n// optionally compute the 3rd component\n#if vtkNumComponents >= 3 && !defined(vtkComponent2Proportional)\n  result[2].xyz = vec3(distX.b, distY.b, distZ.b);\n  result[2].a = length(result[2].xyz);\n  result[2].xyz *= rot;\n  if (result[2].w > 0.0)\n  {\n    result[2].xyz /= result[2].w;\n  }\n#endif\n\n// optionally compute the 4th component\n#if vtkNumComponents >= 4 && !defined(vtkComponent3Proportional)\n  result[3].xyz = vec3(distX.a, distY.a, distZ.a);\n  result[3].a = length(result[3].xyz);\n  result[3].xyz *= rot;\n  if (result[3].w > 0.0)\n  {\n    result[3].xyz /= result[3].w;\n  }\n#endif\n\n  return result;\n}\n\n//=======================================================================\n// global shadow - secondary ray\n#if defined(VolumeShadowOn) || defined(localAmbientOcclusionOn)\nfloat random()\n{ \n  float rand = fract(sin(dot(gl_FragCoord.xy,vec2(12.9898,78.233)))*43758.5453123);\n  float jitter=texture2D(jtexture,gl_FragCoord.xy/32.).r;\n  uint pcg_state = floatBitsToUint(jitter);\n  uint state = pcg_state;\n  pcg_state = pcg_state * uint(747796405) + uint(2891336453);\n  uint word = ((state >> ((state >> uint(28)) + uint(4))) ^ state) * uint(277803737);\n  return (float((((word >> uint(22)) ^ word) >> 1 ))/float(2147483647) + rand)/2.0;\n}\n#endif\n\n#ifdef VolumeShadowOn\n// henyey greenstein phase function\nfloat phase_function(float cos_angle)\n{\n  // divide by 2.0 instead of 4pi to increase intensity\n  return ((1.0-anisotropy2)/pow(1.0+anisotropy2-2.0*anisotropy*cos_angle, 1.5))/2.0;\n}\n\n// Computes the intersection between a ray and a box\nstruct Hit\n{\n  float tmin;\n  float tmax;\n};\n\nstruct Ray\n{\n  vec3 origin;\n  vec3 dir;\n  vec3 invDir;\n};\n\nbool BBoxIntersect(vec3 boundMin, vec3 boundMax, const Ray r, out Hit hit)\n{\n  vec3 tbot = r.invDir * (boundMin - r.origin);\n  vec3 ttop = r.invDir * (boundMax - r.origin);\n  vec3 tmin = min(ttop, tbot);\n  vec3 tmax = max(ttop, tbot);\n  vec2 t = max(tmin.xx, tmin.yz);\n  float t0 = max(t.x, t.y);\n  t = min(tmax.xx, tmax.yz);\n  float t1 = min(t.x, t.y);\n  hit.tmin = t0;\n  hit.tmax = t1;\n  return t1 > max(t0,0.0);\n}\n\n// As BBoxIntersect requires the inverse of the ray coords,\n// this function is used to avoid numerical issues\nvoid safe_0_vector(inout Ray ray)\n{\n  if(abs(ray.dir.x) < EPSILON) ray.dir.x = sign(ray.dir.x) * EPSILON;\n  if(abs(ray.dir.y) < EPSILON) ray.dir.y = sign(ray.dir.y) * EPSILON;\n  if(abs(ray.dir.z) < EPSILON) ray.dir.z = sign(ray.dir.z) * EPSILON;\n}\n\nfloat volume_shadow(vec3 posIS, vec3 lightDirNormIS)\n{\n  float shadow = 1.0;\n  float opacity = 0.0;\n\n  // modify sample distance with a random number between 0.8 and 1.0\n  float sampleDistanceISVS_jitter = sampleDistanceISVS * mix(0.8, 1.0, random());\n  float opacityPrev = texture2D(otexture, vec2(getTextureValue(posIS).r * oscale0 + oshift0, 0.5)).r;\n  \n  // in case the first sample near surface has a very tiled light ray, we need to offset start position \n  posIS += sampleDistanceISVS_jitter * lightDirNormIS;  \n\n  // compute the start and end points for the ray\n  Ray ray;\n  Hit hit;  \n  ray.origin = posIS;\n  ray.dir = lightDirNormIS;\n  safe_0_vector(ray);\n  ray.invDir = 1.0/ray.dir;\n  \n  if(!BBoxIntersect(vec3(0.0),vec3(1.0), ray, hit))\n  {\n    return 1.0;\n  }\n  vec4 scalar = vec4(0.0);\n  float maxdist = hit.tmax;\n  if(maxdist < EPSILON) {\n    return 1.0;\n  }\n\n  // interpolate shadow ray length between: 1 unit of sample distance in IS to SQRT3, based on globalIlluminationReach\n  float maxgi = mix(sampleDistanceISVS_jitter,SQRT3,giReach);\n  maxdist = min(maxdist,maxgi);\n\n  // support gradient opacity\n  #ifdef vtkGradientOpacityOn\n    vec4 normal;\n  #endif\n\n  vec3 current_step = sampleDistanceISVS_jitter * lightDirNormIS;\n  float maxSteps = ceil(maxdist/sampleDistanceISVS_jitter);\n  float opacityDelta = 0.0;\n\n  for (float i = 0.0; i < maxSteps; i++)\n  {\n    scalar = getTextureValue(posIS);\n    opacity = texture2D(otexture, vec2(scalar.r * oscale0 + oshift0, 0.5)).r;\n    #ifdef vtkGradientOpacityOn \n      normal = computeNormal(posIS, scalar.a, vec3(1.0/vec3(volumeDimensions))); \n      opacity *= computeGradientOpacityFactor(normal.w, goscale0, goshift0, gomin0, gomax0);\n    #endif    \n    shadow *= 1.0 - opacity;\n\n    // optimization: early termination\n    if (shadow < EPSILON){\n      return 0.0;\n    }\n\n    // optimization: increase/decrease sample distance based on changed in opacity value\n    opacityDelta = opacityPrev - opacity;\n    opacityPrev = opacity;\n    if (opacityDelta > 0.0){\n      current_step *= 0.9;\n    } else if (opacityDelta < 0.0){\n      current_step *= 1.1;\n    }\n    posIS += current_step;\n  }\n\n  return shadow;  \n}\n\nvec3 applyShadowRay(vec3 tColor, vec3 posIS, vec3 viewDirectionVC)\n{\n  vec3 vertLight = vec3(0.0);\n  vec3 secondary_contrib = vec3(0.0);\n  // here we assume only positional light, no effect of cones\n  for (int i = 0; i < lightNum; i++)\n  {\n    #if(vtkLightComplexity==3)\n      if (lightPositional[i] == 1){\n        vertLight = lightPositionVC[i] - IStoVC(posIS);\n      }else{\n        vertLight = - lightDirectionVC[i];\n      }\n    #else\n      vertLight = - lightDirectionVC[i];\n    #endif\n    // here we assume achromatic light, only intensity\n    float dDotL = dot(viewDirectionVC, normalize(vertLight));\n    // isotropic scatter returns 0.5 instead of 1/4pi to increase intensity\n    float phase_attenuation = 0.5;\n    if (abs(anisotropy) > EPSILON){\n      phase_attenuation = phase_function(dDotL);\n    }\n    float vol_shadow = volume_shadow(posIS, normalize(rotateToIDX(vertLight)));\n    secondary_contrib += tColor * vDiffuse * lightColor[i] * vol_shadow * phase_attenuation;     \n    secondary_contrib += tColor * vAmbient;\n  } \n  return secondary_contrib;\n}\n#endif\n\n//=======================================================================\n// local ambient occlusion\n#ifdef localAmbientOcclusionOn\nvec3 sample_direction_uniform(int i)\n{\n  float rand = random() * 0.5;\n  float theta = PI2 * (kernelSample[i][0] + rand);\n  float phi = acos(2.0 * (kernelSample[i][1] + rand) -1.0) / 2.5;\n  return normalize(vec3(cos(theta)*sin(phi), sin(theta)*sin(phi), cos(phi)));\n}\n\n// return a matrix that transform startDir into z axis; startDir should be normalized\nmat3 zBaseRotationalMatrix(vec3 startDir){\n  vec3 axis = cross(startDir, vec3(0.0,0.0,1.0));\n  float cosA = startDir.z;\n  float k = 1.0 / (1.0 + cosA);\n  mat3 matrix = mat3((axis.x * axis.x * k) + cosA, (axis.y * axis.x * k) - axis.z, (axis.z * axis.x * k) + axis.y,\n              (axis.x * axis.y * k) + axis.z, (axis.y * axis.y * k) + cosA, (axis.z * axis.y * k) - axis.x,\n              (axis.x * axis.z * k) - axis.y, (axis.y * axis.z * k) + axis.x, (axis.z * axis.z * k) + cosA);\n  return matrix;\n}\n\nfloat computeLAO(vec3 posIS, float opacity, vec3 lightDir, vec4 normal){\n  // apply LAO only at selected locations, otherwise return full brightness\n  if (normal.w > 0.0 && opacity > 0.05){\n    float total_transmittance = 0.0;\n    mat3 inverseRotateBasis = inverse(zBaseRotationalMatrix(normalize(-normal.xyz)));\n    vec3 currPos, randomDirStep;\n    float weight, transmittance, opacity;\n    for (int i = 0; i < kernelSize; i++)\n    {\n      randomDirStep = inverseRotateBasis * sample_direction_uniform(i) * sampleDistanceIS;\n      weight = 1.0 - dot(normalize(lightDir), normalize(randomDirStep));\n      currPos = posIS;\n      transmittance = 1.0;\n      for (int j = 0; j < kernelRadius ; j++){\n        currPos += randomDirStep;\n        // check if it's at clipping plane, if so return full brightness\n        if (all(greaterThan(currPos, vec3(EPSILON))) && all(lessThan(currPos,vec3(1.0-EPSILON)))){\n          opacity = texture2D(otexture, vec2(getTextureValue(currPos).r * oscale0 + oshift0, 0.5)).r;\n          #ifdef vtkGradientOpacityOn\n             opacity *= computeGradientOpacityFactor(normal.w, goscale0, goshift0, gomin0, gomax0);\n          #endif\n          transmittance *= 1.0 - opacity;\n        }\n        else{\n          break;\n        }\n      }\n      total_transmittance += transmittance / float(kernelRadius) * weight;\n\n      // early termination if fully translucent\n      if (total_transmittance > 1.0 - EPSILON){\n        return 1.0;\n      }\n    }\n    // average transmittance and reduce variance\n    return clamp(total_transmittance / float(kernelSize), 0.3, 1.0); \n  } else {\n    return 1.0;\n  }\n}\n#endif\n\n//=======================================================================\n// surface light contribution\n#if vtkLightComplexity > 0\n  void applyLighting(inout vec3 tColor, vec4 normal)\n  {\n    vec3 diffuse = vec3(0.0, 0.0, 0.0);\n    vec3 specular = vec3(0.0, 0.0, 0.0);\n    float df, sf = 0.0;\n    for (int i = 0; i < lightNum; i++){\n        df = abs(dot(normal.rgb, -lightDirectionVC[i]));\n        diffuse += df * lightColor[i];\n        sf = pow( abs(dot(lightHalfAngleVC[i],normal.rgb)), vSpecularPower);\n        specular += sf * lightColor[i];\n    }\n    tColor.rgb = tColor.rgb*(diffuse*vDiffuse + vAmbient) + specular*vSpecular;\n  }\n  #ifdef SurfaceShadowOn\n  #if vtkLightComplexity < 3\n    vec3 applyLightingDirectional(vec3 posIS, vec4 tColor, vec4 normal)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      #ifdef localAmbientOcclusionOn\n        vec3 ambient = vec3(0.0);\n      #endif        \n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float ndotL,vdotR;\n        vertLightDirection = lightDirectionVC[i];\n        ndotL = dot(normal.xyz, vertLightDirection);\n        if (ndotL < 0.0 && twoSidedLighting)\n        {\n          ndotL = -ndotL;\n        }\n        if (ndotL > 0.0)\n        {\n          diffuse += ndotL * lightColor[i];\n          //specular\n          vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n          if (vdotR > 0.0)\n          {\n            specular += pow(vdotR, vSpecularPower) * lightColor[i];\n          }\n        }\n        #ifdef localAmbientOcclusionOn\n            ambient += computeLAO(posIS, tColor.a, vertLightDirection, normal);\n        #endif\n      }  \n      #ifdef localAmbientOcclusionOn\n        return tColor.rgb * (diffuse * vDiffuse + vAmbient * ambient) + specular*vSpecular;\n      #else \n        return tColor.rgb * (diffuse * vDiffuse + vAmbient) + specular*vSpecular;\n      #endif    \n    }\n  #else\n    vec3 applyLightingPositional(vec3 posIS, vec4 tColor, vec4 normal, vec3 posVC)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      #ifdef localAmbientOcclusionOn\n        vec3 ambient = vec3(0.0);\n      #endif      \n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float distance,attenuation,ndotL,vdotR;\n        vec3 lightDir;\n        if (lightPositional[i] == 1){\n          lightDir = lightDirectionVC[i];\n          vertLightDirection = posVC - lightPositionVC[i]; \n          distance = length(vertLightDirection);\n          vertLightDirection = normalize(vertLightDirection);\n          attenuation = 1.0 / (lightAttenuation[i].x\n                              + lightAttenuation[i].y * distance\n                              + lightAttenuation[i].z * distance * distance);\n          // per OpenGL standard cone angle is 90 or less for a spot light\n          if (lightConeAngle[i] <= 90.0){\n            float coneDot = dot(vertLightDirection, lightDir);\n            if (coneDot >= cos(radians(lightConeAngle[i]))){  // if inside cone\n              attenuation = attenuation * pow(coneDot, lightExponent[i]);\n            }\n            else {\n              attenuation = 0.0;\n            }\n          }\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * attenuation * lightColor[i];\n            //specular\n            vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n            if (vdotR > 0.0)\n            {\n              specular += pow(vdotR, vSpecularPower) * attenuation * lightColor[i];\n            }\n          }\n          #ifdef localAmbientOcclusionOn\n            ambient += computeLAO(posIS, tColor.a, vertLightDirection, normal);\n          #endif          \n        } else {\n          vertLightDirection = lightDirectionVC[i];\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * lightColor[i];\n            //specular\n            vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n            if (vdotR > 0.0)\n            {\n              specular += pow(vdotR, vSpecularPower) * lightColor[i];\n            }\n          }\n          #ifdef localAmbientOcclusionOn\n            ambient += computeLAO(posIS, tColor.a, vertLightDirection, normal);\n          #endif          \n        }\n      }\n      #ifdef localAmbientOcclusionOn\n        return tColor.rgb * (diffuse * vDiffuse + vAmbient * ambient) + specular*vSpecular;\n      #else \n        return tColor.rgb * (diffuse * vDiffuse + vAmbient) + specular*vSpecular;\n      #endif\n    }\n  #endif \n  #endif\n#endif\n\n//=======================================================================\n// Given a texture value compute the color and opacity\n//\nvec4 getColorForValue(vec4 tValue, vec3 posIS, vec3 tstep)\n{\n#ifdef vtkImageLabelOutlineOn\n  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\n  vec4 centerValue = getTextureValue(centerPosIS);\n  bool pixelOnBorder = false;\n  vec4 tColor = texture2D(ctexture, vec2(centerValue.r * cscale0 + cshift0, 0.5));\n\n  // Get alpha of segment from opacity function.\n  tColor.a = texture2D(otexture, vec2(centerValue.r * oscale0 + oshift0, 0.5)).r;\n\n  // Only perform outline check on fragments rendering voxels that aren't invisible.\n  // Saves a bunch of needless checks on the background.\n  // TODO define epsilon when building shader?\n  if (float(tColor.a) > 0.01) {\n    for (int i = -outlineThickness; i <= outlineThickness; i++) {\n      for (int j = -outlineThickness; j <= outlineThickness; j++) {\n        if (i == 0 || j == 0) {\n          continue;\n        }\n\n        vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\n          gl_FragCoord.y + float(j),\n          gl_FragCoord.z, gl_FragCoord.w);\n\n        vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\n        vec4 value = getTextureValue(neighborPosIS);\n\n        // If any of my neighbours are not the same value as I\n        // am, this means I am on the border of the segment.\n        // We can break the loops\n        if (any(notEqual(value, centerValue))) {\n          pixelOnBorder = true;\n          break;\n        }\n      }\n\n      if (pixelOnBorder == true) {\n        break;\n      }\n    }\n\n    // If I am on the border, I am displayed at full opacity\n    if (pixelOnBorder == true) {\n      tColor.a = 1.0;\n    }\n  }\n\n#else\n  // compute the normal and gradient magnitude if needed\n  // We compute it as a vec4 if possible otherwise a mat4\n  //\n  vec4 goFactor = vec4(1.0,1.0,1.0,1.0);\n\n  // compute the normal vectors as needed\n  #if (vtkLightComplexity > 0) || defined(vtkGradientOpacityOn)\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      mat4 normalMat = computeMat4Normal(posIS, tValue, tstep);\n      #if !defined(vtkComponent0Proportional)\n        vec4 normal0 = normalMat[0];\n      #endif\n      #if !defined(vtkComponent1Proportional)\n        vec4 normal1 = normalMat[1];\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          vec4 normal2 = normalMat[2];\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            vec4 normal3 = normalMat[3];\n          #endif\n        #endif\n      #endif\n    #else\n      vec4 normalLight;\n      #ifdef vtkComputeNormalFromOpacity\n        #ifdef vtkGradientOpacityOn\n          mat3 scalarInterp;  \n          vec3 secondaryGradientMag;  \n          vec4 normal0 = computeNormalForDensity(posIS, tValue.a, tstep, scalarInterp, secondaryGradientMag);  \n          normalLight = computeDensityNormal(tValue.a, normal0.w, scalarInterp,secondaryGradientMag);       \n          if (length(normalLight) == 0.0){  \n            normalLight = normal0;   \n          }                      \n        #else\n          vec3 scalarInterp;  \n          vec4 normal0 = computeNormalForDensity(posIS, tValue.a, tstep, scalarInterp);  \n          if (length(normal0)>0.0){  \n            normalLight = computeDensityNormal(tValue.a,scalarInterp);  \n            if (length(normalLight)==0.0){  \n              normalLight = normal0;  \n            }  \n          }                \n        #endif\n      #else \n        vec4 normal0 = computeNormal(posIS, tValue.a, tstep);  \n        normalLight = normal0;             \n      #endif\n    #endif\n  #endif\n\n  // compute gradient opacity factors as needed\n  #if defined(vtkGradientOpacityOn)\n    #if !defined(vtkComponent0Proportional)\n      goFactor.x =\n        computeGradientOpacityFactor(normal0.a, goscale0, goshift0, gomin0, gomax0);\n    #endif\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      #if !defined(vtkComponent1Proportional)\n        goFactor.y =\n          computeGradientOpacityFactor(normal1.a, goscale1, goshift1, gomin1, gomax1);\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          goFactor.z =\n            computeGradientOpacityFactor(normal2.a, goscale2, goshift2, gomin2, gomax2);\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            goFactor.w =\n              computeGradientOpacityFactor(normal3.a, goscale3, goshift3, gomin3, gomax3);\n          #endif\n        #endif\n      #endif\n    #endif\n  #endif\n\n  // single component is always independent\n  #if vtkNumComponents == 1\n    vec4 tColor = texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, 0.5));\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, 0.5)).r;\n    if (tColor.a < EPSILON){\n      return vec4(0.0);\n    }    \n  #endif\n\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n    vec4 tColor = mix0*texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, height0));\n    #if !defined(vtkComponent0Proportional)\n      tColor.a = goFactor.x*mix0*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n      tColor *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix0));\n    #endif\n\n    vec3 tColor1 = mix1*texture2D(ctexture, vec2(tValue.g * cscale1 + cshift1, height1)).rgb;\n    #if !defined(vtkComponent1Proportional)\n      tColor.a += goFactor.y*mix1*texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n      tColor1 *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix1));\n    #endif\n\n    #if vtkNumComponents >= 3\n      vec3 tColor2 = mix2*texture2D(ctexture, vec2(tValue.b * cscale2 + cshift2, height2)).rgb;\n      #if !defined(vtkComponent2Proportional)\n        tColor.a += goFactor.z*mix2*texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n      #else\n        float pwfValue = texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n        tColor2 *= pwfValue;\n        tColor.a *= mix(pwfValue, 1.0, (1.0 - mix2));\n      #endif\n\n      #if vtkNumComponents >= 4\n        vec3 tColor3 = mix3*texture2D(ctexture, vec2(tValue.a * cscale3 + cshift3, height3)).rgb;\n        #if !defined(vtkComponent3Proportional)\n          tColor.a += goFactor.w*mix3*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n        #else\n          float pwfValue = texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n          tColor3 *= pwfValue;\n          tColor.a *= mix(pwfValue, 1.0, (1.0 - mix3));\n        #endif\n      #endif\n    #endif\n  #else // then not independent\n\n  #if vtkNumComponents == 2\n    float lum = tValue.r * cscale0 + cshift0;\n    float alpha = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale1 + oshift1, 0.5)).r;\n    vec4 tColor = vec4(lum, lum, lum, alpha);\n  #endif\n  #if vtkNumComponents == 3\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale0 + oshift0, 0.5)).r;\n  #endif\n  #if vtkNumComponents == 4\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, 0.5)).r;\n  #endif\n  #endif // dependent\n\n  // apply lighting if requested as appropriate\n  #if vtkLightComplexity > 0\n    #if !defined(vtkComponent0Proportional) \n      #if vtkNumComponents == 1\n    \n        #ifdef SurfaceShadowOn\n            #if vtkLightComplexity < 3\n                vec3 tColorS = applyLightingDirectional(posIS, tColor, normalLight);\n            #else\n                vec3 tColorS = applyLightingPositional(posIS, tColor, normalLight, IStoVC(posIS));\n            #endif\n        #endif\n\n        #ifdef VolumeShadowOn\n          vec3 tColorVS = applyShadowRay(tColor.rgb, posIS, rayDirVC);\n          #ifdef SurfaceShadowOn\n            float vol_coef = volumetricScatteringBlending * (1.0 - tColor.a / 2.0) * (1.0 - atan(normalLight.w) * INV4PI);\n            tColor.rgb = (1.0-vol_coef) * tColorS + vol_coef * tColorVS;\n          #else\n            tColor.rgb = tColorVS;\n          #endif\n        #else\n            tColor.rgb = tColorS;\n        #endif\n        \n      #else\n        applyLighting(tColor.rgb, normal0);\n      #endif\n    #endif\n\n    #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n      #if !defined(vtkComponent1Proportional)\n        applyLighting(tColor1, normal1);\n      #endif\n    #if vtkNumComponents >= 3\n      #if !defined(vtkComponent2Proportional)\n        applyLighting(tColor2, normal2);\n      #endif\n    #if vtkNumComponents >= 4\n      #if !defined(vtkComponent3Proportional)\n        applyLighting(tColor3, normal3);\n      #endif\n    #endif\n    #endif\n    #endif\n  #endif\n\n// perform final independent blend as needed\n#if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n  tColor.rgb += tColor1;\n#if vtkNumComponents >= 3\n  tColor.rgb += tColor2;\n#if vtkNumComponents >= 4\n  tColor.rgb += tColor3;\n#endif\n#endif\n#endif\n\n#endif\n\n\n\n\n\n\n\nreturn tColor;\n}\n\nbool valueWithinScalarRange(vec4 val, vec4 min, vec4 max) {\n  bool withinRange = false;\n  #if vtkNumComponents == 1\n    if (val.r >= min.r && val.r <= max.r) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents == 2\n     if (val.r >= min.r && val.r <= max.r &&\n        val.g >= min.g && val.g <= max.g) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 3\n    if (all(greaterThanEqual(val, ipScalarRangeMin)) &&\n        all(lessThanEqual(val, ipScalarRangeMax))) {\n      withinRange = true;\n    }\n  #endif\n  return withinRange;\n}\n\n//=======================================================================\n// Apply the specified blend mode operation along the ray's path.\n//\nvoid applyBlend(vec3 posIS, vec3 endIS, vec3 tdims)\n{\n  vec3 tstep = 1.0/tdims;\n\n  // start slightly inside and apply some jitter\n  vec3 delta = endIS - posIS;\n  vec3 stepIS = normalize(delta)*sampleDistanceIS;\n  float raySteps = length(delta)/sampleDistanceIS;\n\n  // avoid 0.0 jitter\n  float jitter = 0.01 + 0.99*texture2D(jtexture, gl_FragCoord.xy/32.0).r;\n  float stepsTraveled = jitter;\n\n  // local vars for the loop\n  vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n  vec4 tValue;\n  vec4 tColor;\n\n  // if we have less than one step then pick the middle point\n  // as our value\n  // if (raySteps <= 1.0)\n  // {\n  //   posIS = (posIS + endIS)*0.5;\n  // }\n\n  // Perform initial step at the volume boundary\n  // compute the scalar\n  tValue = getTextureValue(posIS);\n\n  #if vtkBlendMode == 0 // COMPOSITE_BLEND\n    // now map through opacity and color\n    tColor = getColorForValue(tValue, posIS, tstep);\n\n    // handle very thin volumes\n    if (raySteps <= 1.0)\n    {\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps);\n      gl_FragData[0] = tColor;\n      return;\n    }\n\n    tColor.a = 1.0 - pow(1.0 - tColor.a, jitter);\n    color = vec4(tColor.rgb*tColor.a, tColor.a);\n    posIS += (jitter*stepIS);\n\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n\n      float mix = (1.0 - color.a);\n\n      // this line should not be needed but nvidia seems to not handle\n      // the break correctly on windows/chrome 58 angle\n      //mix = mix * sign(max(raySteps - stepsTraveled - 1.0, 0.0));\n\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n      stepsTraveled++;\n      posIS += stepIS;\n      if (color.a > 0.99) { color.a = 1.0; break; }\n    }\n\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0)\n    {\n      posIS = endIS;\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\n\n      float mix = (1.0 - color.a);\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n    }\n\n    gl_FragData[0] = vec4(color.rgb/color.a, color.a);\n  #endif\n  #if vtkBlendMode == 1 || vtkBlendMode == 2\n    // MAXIMUM_INTENSITY_BLEND || MINIMUM_INTENSITY_BLEND\n    // Find maximum/minimum intensity along the ray.\n\n    // Define the operation we will use (min or max)\n    #if vtkBlendMode == 1\n    #define OP max\n    #else\n    #define OP min\n    #endif\n\n    // If the clipping range is shorter than the sample distance\n    // we can skip the sampling loop along the ray.\n    if (raySteps <= 1.0)\n    {\n      gl_FragData[0] = getColorForValue(tValue, posIS, tstep);\n      return;\n    }\n\n    vec4 value = tValue;\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // Update the maximum value if necessary\n      value = OP(tValue, value);\n\n      // Otherwise, continue along the ray\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n    tValue = getTextureValue(posIS);\n    value = OP(tValue, value);\n\n    // Now map through opacity and color\n    gl_FragData[0] = getColorForValue(value, posIS, tstep);\n  #endif\n  #if vtkBlendMode == 3 || vtkBlendMode == 4 //AVERAGE_INTENSITY_BLEND || ADDITIVE_BLEND\n    vec4 sum = vec4(0.);\n\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n    }\n\n    if (raySteps <= 1.0) {\n      gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n      return;\n    }\n\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // One can control the scalar range by setting the AverageIPScalarRange to disregard scalar values, not in the range of interest, from the average computation.\n      // Notes:\n      // - We are comparing all values in the texture to see if any of them\n      //   are outside of the scalar range. In the future we might want to allow\n      //   scalar ranges for each component.\n      if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n        // Sum the values across each step in the path\n        sum += tValue;\n      }\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n\n    // compute the scalar\n    tValue = getTextureValue(posIS);\n\n    // One can control the scalar range by setting the IPScalarRange to disregard scalar values, not in the range of interest, from the average computation\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n\n      stepsTraveled++;\n    }\n\n    #if vtkBlendMode == 3 // Average\n      sum /= vec4(stepsTraveled, stepsTraveled, stepsTraveled, 1.0);\n    #endif\n\n    gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n  #endif\n}\n\n//=======================================================================\n// Compute a new start and end point for a given ray based\n// on the provided bounded clipping plane (aka a rectangle)\nvoid getRayPointIntersectionBounds(\n  vec3 rayPos, vec3 rayDir,\n  vec3 planeDir, float planeDist,\n  inout vec2 tbounds, vec3 vPlaneX, vec3 vPlaneY,\n  float vSize1, float vSize2)\n{\n  float result = dot(rayDir, planeDir);\n  if (abs(result) < 1e-6)\n  {\n    return;\n  }\n  result = -1.0 * (dot(rayPos, planeDir) + planeDist) / result;\n  vec3 xposVC = rayPos + rayDir*result;\n  vec3 vxpos = xposVC - vOriginVC;\n  vec2 vpos = vec2(\n    dot(vxpos, vPlaneX),\n    dot(vxpos, vPlaneY));\n\n  // on some apple nvidia systems this does not work\n  // if (vpos.x < 0.0 || vpos.x > vSize1 ||\n  //     vpos.y < 0.0 || vpos.y > vSize2)\n  // even just\n  // if (vpos.x < 0.0 || vpos.y < 0.0)\n  // fails\n  // so instead we compute a value that represents in and out\n  //and then compute the return using this value\n  float xcheck = max(0.0, vpos.x * (vpos.x - vSize1)); //  0 means in bounds\n  float check = sign(max(xcheck, vpos.y * (vpos.y - vSize2))); //  0 means in bounds, 1 = out\n\n  tbounds = mix(\n   vec2(min(tbounds.x, result), max(tbounds.y, result)), // in value\n   tbounds, // out value\n   check);  // 0 in 1 out\n}\n\n//=======================================================================\n// given a\n// - ray direction (rayDir)\n// - starting point (vertexVCVSOutput)\n// - bounding planes of the volume\n// - optionally depth buffer values\n// - far clipping plane\n// compute the start/end distances of the ray we need to cast\nvec2 computeRayDistances(vec3 rayDir, vec3 tdims)\n{\n  vec2 dists = vec2(100.0*camFar, -1.0);\n\n  vec3 vSize = vSpacing*tdims;\n\n  // all this is in View Coordinates\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal0, vPlaneDistance0, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal1, vPlaneDistance1, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal2, vPlaneDistance2, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal3, vPlaneDistance3, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal4, vPlaneDistance4, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal5, vPlaneDistance5, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n\n  //VTK::ClipPlane::Impl\n\n  // do not go behind front clipping plane\n  dists.x = max(0.0,dists.x);\n\n  // do not go PAST far clipping plane\n  float farDist = -camThick/rayDir.z;\n  dists.y = min(farDist,dists.y);\n\n  // Do not go past the zbuffer value if set\n  // This is used for intermixing opaque geometry\n  //VTK::ZBuffer::Impl\n\n  return dists;\n}\n\n//=======================================================================\n// Compute the index space starting position (pos) and end\n// position\n//\nvoid computeIndexSpaceValues(out vec3 pos, out vec3 endPos, vec3 rayDir, vec2 dists)\n{\n  // compute starting and ending values in volume space\n  pos = vertexVCVSOutput + dists.x*rayDir;\n  pos = pos - vOriginVC;\n  // convert to volume basis and origin\n  pos = vec3(\n    dot(pos, vPlaneNormal0),\n    dot(pos, vPlaneNormal2),\n    dot(pos, vPlaneNormal4));\n\n  endPos = vertexVCVSOutput + dists.y*rayDir;\n  endPos = endPos - vOriginVC;\n  endPos = vec3(\n    dot(endPos, vPlaneNormal0),\n    dot(endPos, vPlaneNormal2),\n    dot(endPos, vPlaneNormal4));\n\n  float delta = length(endPos - pos);\n\n  pos *= vVCToIJK;\n  endPos *= vVCToIJK;\n\n  float delta2 = length(endPos - pos);\n  sampleDistanceIS = sampleDistance*delta2/delta;\n  #ifdef VolumeShadowOn\n    sampleDistanceISVS = sampleDistanceIS * volumeShadowSamplingDistFactor;\n  #endif\n}\n\nvoid main()\n{\n\n  if (cameraParallel == 1)\n  {\n    // Camera is parallel, so the rayDir is just the direction of the camera.\n    rayDirVC = vec3(0.0, 0.0, -1.0);\n  } else {\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\n    rayDirVC = normalize(vertexVCVSOutput);\n  }\n\n  vec3 tdims = vec3(volumeDimensions);\n\n  // compute the start and end points for the ray\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayDirVC, tdims);\n\n  // do we need to composite? aka does the ray have any length\n  // If not, bail out early\n  if (rayStartEndDistancesVC.y <= rayStartEndDistancesVC.x)\n  {\n    discard;\n  }\n\n  // IS = Index Space\n  vec3 posIS;\n  vec3 endIS;\n  computeIndexSpaceValues(posIS, endIS, rayDirVC, rayStartEndDistancesVC);\n\n  // Perform the blending operation along the ray\n  applyBlend(posIS, endIS, tdims);\n}\n";
+var vtkVolumeFS = "//VTK::System::Dec\n\n/*=========================================================================\n\n  Program:   Visualization Toolkit\n  Module:    vtkVolumeFS.glsl\n\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n  All rights reserved.\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n     This software is distributed WITHOUT ANY WARRANTY; without even\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n     PURPOSE.  See the above copyright notice for more information.\n\n=========================================================================*/\n// Template for the volume mappers fragment shader\n\n// the output of this shader\n//VTK::Output::Dec\n\nvarying vec3 vertexVCVSOutput;\n\n// first declare the settings from the mapper\n// that impact the code paths in here\n\n// always set vtkNumComponents 1,2,3,4\n//VTK::NumComponents\n\n// possibly define vtkTrilinearOn\n//VTK::TrilinearOn\n\n// possibly define vtkIndependentComponents\n//VTK::IndependentComponentsOn\n\n// possibly define any \"proportional\" components\n//VTK::vtkProportionalComponents\n\n// Define the blend mode to use\n#define vtkBlendMode //VTK::BlendMode\n\n// Possibly define vtkImageLabelOutlineOn\n//VTK::ImageLabelOutlineOn\n\n#ifdef vtkImageLabelOutlineOn\nuniform int outlineThickness;\nuniform float vpWidth;\nuniform float vpHeight;\nuniform float vpOffsetX;\nuniform float vpOffsetY;\nuniform mat4 PCWCMatrix;\nuniform mat4 vWCtoIDX;\n#endif\n\n// define vtkLightComplexity\n//VTK::LightComplexity\n#if vtkLightComplexity > 0\nuniform float vSpecularPower;\nuniform float vAmbient;\nuniform float vDiffuse;\nuniform float vSpecular;\n//VTK::Light::Dec\n#endif\n\n//VTK::VolumeShadowOn\n//VTK::SurfaceShadowOn\n//VTK::localAmbientOcclusionOn\n//VTK::LAO::Dec\n//VTK::VolumeShadow::Dec\n\n// define vtkComputeNormalFromOpacity\n//VTK::vtkComputeNormalFromOpacity\n\n// possibly define vtkGradientOpacityOn\n//VTK::GradientOpacityOn\n#ifdef vtkGradientOpacityOn\nuniform float goscale0;\nuniform float goshift0;\nuniform float gomin0;\nuniform float gomax0;\n#if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\nuniform float goscale1;\nuniform float goshift1;\nuniform float gomin1;\nuniform float gomax1;\n#if vtkNumComponents >= 3\nuniform float goscale2;\nuniform float goshift2;\nuniform float gomin2;\nuniform float gomax2;\n#endif\n#if vtkNumComponents >= 4\nuniform float goscale3;\nuniform float goshift3;\nuniform float gomin3;\nuniform float gomax3;\n#endif\n#endif\n#endif\n\n// if you want to see the raw tiled\n// data in webgl1 uncomment the following line\n// #define debugtile\n\n// camera values\nuniform float camThick;\nuniform float camNear;\nuniform float camFar;\nuniform int cameraParallel;\n\n// values describing the volume geometry\nuniform vec3 vOriginVC;\nuniform vec3 vSpacing;\nuniform ivec3 volumeDimensions; // 3d texture dimensions\nuniform vec3 vPlaneNormal0;\nuniform float vPlaneDistance0;\nuniform vec3 vPlaneNormal1;\nuniform float vPlaneDistance1;\nuniform vec3 vPlaneNormal2;\nuniform float vPlaneDistance2;\nuniform vec3 vPlaneNormal3;\nuniform float vPlaneDistance3;\nuniform vec3 vPlaneNormal4;\nuniform float vPlaneDistance4;\nuniform vec3 vPlaneNormal5;\nuniform float vPlaneDistance5;\n\n//VTK::ClipPlane::Dec\n\n// opacity and color textures\nuniform sampler2D otexture;\nuniform float oshift0;\nuniform float oscale0;\nuniform sampler2D ctexture;\nuniform float cshift0;\nuniform float cscale0;\n\n// jitter texture\nuniform sampler2D jtexture;\n\n// some 3D texture values\nuniform float sampleDistance;\nuniform vec3 vVCToIJK;\n\n// the heights defined below are the locations\n// for the up to four components of the tfuns\n// the tfuns have a height of 2XnumComps pixels so the\n// values are computed to hit the middle of the two rows\n// for that component\n#ifdef vtkIndependentComponentsOn\n#if vtkNumComponents == 2\nuniform float mix0;\nuniform float mix1;\n#define height0 0.25\n#define height1 0.75\n#endif\n#if vtkNumComponents == 3\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\n#define height0 0.17\n#define height1 0.5\n#define height2 0.83\n#endif\n#if vtkNumComponents == 4\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\nuniform float mix3;\n#define height0 0.125\n#define height1 0.375\n#define height2 0.625\n#define height3 0.875\n#endif\n#endif\n\n#if vtkNumComponents >= 2\nuniform float oshift1;\nuniform float oscale1;\nuniform float cshift1;\nuniform float cscale1;\n#endif\n#if vtkNumComponents >= 3\nuniform float oshift2;\nuniform float oscale2;\nuniform float cshift2;\nuniform float cscale2;\n#endif\n#if vtkNumComponents >= 4\nuniform float oshift3;\nuniform float oscale3;\nuniform float cshift3;\nuniform float cscale3;\n#endif\n\nuniform vec4 ipScalarRangeMin;\nuniform vec4 ipScalarRangeMax;\n\n// declaration for intermixed geometry\n//VTK::ZBuffer::Dec\n\n//=======================================================================\n// global and custom variables (a temporary section before photorealistics rendering module is complete)\nvec3 rayDirVC;\nfloat sampleDistanceISVS;\nfloat sampleDistanceIS;\n\n#define SQRT3    1.7321\n#define INV4PI   0.0796\n#define EPSILON  0.001\n#define PI       3.1415\n#define PI2      9.8696\n\n//=======================================================================\n// Webgl2 specific version of functions\n#if __VERSION__ == 300\n\nuniform highp sampler3D texture1;\n\nvec4 getTextureValue(vec3 pos)\n{\n  vec4 tmp = texture(texture1, pos);\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.a = tmp.g;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n  return tmp;\n}\n\n//=======================================================================\n// WebGL1 specific version of functions\n#else\n\nuniform sampler2D texture1;\n\nuniform float texWidth;\nuniform float texHeight;\nuniform int xreps;\nuniform int xstride;\nuniform int ystride;\n\n// if computing trilinear values from multiple z slices\n#ifdef vtkTrilinearOn\nvec4 getTextureValue(vec3 ijk)\n{\n  float zoff = 1.0/float(volumeDimensions.z);\n  vec4 val1 = getOneTextureValue(ijk);\n  vec4 val2 = getOneTextureValue(vec3(ijk.xy, ijk.z + zoff));\n\n  float indexZ = float(volumeDimensions)*ijk.z;\n  float zmix =  indexZ - floor(indexZ);\n\n  return mix(val1, val2, zmix);\n}\n\nvec4 getOneTextureValue(vec3 ijk)\n#else // nearest or fast linear\nvec4 getTextureValue(vec3 ijk)\n#endif\n{\n  vec3 tdims = vec3(volumeDimensions);\n\n#ifdef debugtile\n  vec2 tpos = vec2(ijk.x, ijk.y);\n  vec4 tmp = texture2D(texture1, tpos);\n  tmp.a = 1.0;\n\n#else\n  int z = int(ijk.z * tdims.z);\n  int yz = z / xreps;\n  int xz = z - yz*xreps;\n\n  int tileWidth = volumeDimensions.x/xstride;\n  int tileHeight = volumeDimensions.y/ystride;\n\n  xz *= tileWidth;\n  yz *= tileHeight;\n\n  float ni = float(xz) + (ijk.x*float(tileWidth));\n  float nj = float(yz) + (ijk.y*float(tileHeight));\n\n  vec2 tpos = vec2(ni/texWidth, nj/texHeight);\n\n  vec4 tmp = texture2D(texture1, tpos);\n\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.g = tmp.a;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n#endif\n\n  return tmp;\n}\n\n// End of Webgl1 specific code\n//=======================================================================\n#endif\n\n//=======================================================================\n// transformation between VC and IS space\n\n// convert vector position from idx to vc\n#if vtkLightComplexity > 0\nvec3 IStoVC(vec3 posIS){\n  vec3 posVC = posIS / vVCToIJK;\n  return posVC.x * vPlaneNormal0 + \n         posVC.y * vPlaneNormal2 + \n         posVC.z * vPlaneNormal4 + \n         vOriginVC;\n}\n\n// convert vector position from vc to idx\nvec3 VCtoIS(vec3 posVC){\n  posVC = posVC - vOriginVC;\n  posVC = vec3(\n    dot(posVC, vPlaneNormal0),\n    dot(posVC, vPlaneNormal2),\n    dot(posVC, vPlaneNormal4));  \n  return posVC * vVCToIJK;\n}\n#endif\n\n//Rotate vector to view coordinate\n#if (vtkLightComplexity > 0) || (defined vtkGradientOpacityOn)\nvoid rotateToViewCoord(inout vec3 dirIS){\n  dirIS.xyz =\n    dirIS.x * vPlaneNormal0 +\n    dirIS.y * vPlaneNormal2 +\n    dirIS.z * vPlaneNormal4;\n}\n\n//Rotate vector to idx coordinate\nvec3 rotateToIDX(vec3 dirVC){\n  vec3 dirIS;\n  dirIS.xyz = vec3(\n    dot(dirVC, vPlaneNormal0),\n    dot(dirVC, vPlaneNormal2),\n    dot(dirVC, vPlaneNormal4));  \n  return dirIS;\n}\n#endif\n\n//=======================================================================\n// Given a normal compute the gradient opacity factors\nfloat computeGradientOpacityFactor(\n  float normalMag, float goscale, float goshift, float gomin, float gomax)\n{\n#if defined(vtkGradientOpacityOn)\n  return clamp(normalMag * goscale + goshift, gomin, gomax);\n#else\n  return 1.0;\n#endif\n}\n\n//=======================================================================\n// compute the normal and gradient magnitude for a position, uses forward difference\n#if (vtkLightComplexity > 0) || (defined vtkGradientOpacityOn)\n  #ifdef vtkComputeNormalFromOpacity\n    #ifdef vtkGradientOpacityOn\n      vec4 computeNormalForDensity(vec3 pos, float scalar, vec3 tstep, out mat3 scalarInterp, out vec3 secondaryGradientMag)\n      {\n        vec4 result;\n        scalarInterp[0][0] = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a;\n        scalarInterp[0][1] = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a;\n        scalarInterp[0][2] = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a;\n        // look up scalar values for computing secondary gradient\n        scalarInterp[1][0] = getTextureValue(pos + vec3(2.0*tstep.x, 0.0, 0.0)).a;\n        scalarInterp[1][1] = getTextureValue(pos + vec3(0.0, 2.0*tstep.y, 0.0)).a;\n        scalarInterp[1][2] = getTextureValue(pos + vec3(0.0, 0.0, 2.0*tstep.z)).a;\n        scalarInterp[2][0] = getTextureValue(pos + vec3(tstep.x, tstep.y, 0.0)).a;\n        scalarInterp[2][1] = getTextureValue(pos + vec3(tstep.x, 0.0, tstep.z)).a;\n        scalarInterp[2][2] = getTextureValue(pos + vec3(0.0, tstep.y, tstep.z)).a;\n        result.x = scalarInterp[0][0] - scalar;\n        result.y = scalarInterp[0][1] - scalar;\n        result.z = scalarInterp[0][2] - scalar;\n        // divide by spacing\n        result.xyz /= vSpacing;\n        result.w = length(result.xyz);\n        rotateToViewCoord(result.xyz);\n        secondaryGradientMag.x = length(vec3(scalarInterp[1][0] - scalarInterp[0][0],\n                                             scalarInterp[2][0] - scalarInterp[0][0],\n                                             scalarInterp[2][1] - scalarInterp[0][0]) / vSpacing);\n        secondaryGradientMag.y = length(vec3(scalarInterp[2][0] - scalarInterp[0][1],\n                                             scalarInterp[1][1] - scalarInterp[0][1],\n                                             scalarInterp[2][2] - scalarInterp[0][1]) / vSpacing);\n        secondaryGradientMag.z = length(vec3(scalarInterp[2][1] - scalarInterp[0][2],\n                                             scalarInterp[2][2] - scalarInterp[0][2],\n                                             scalarInterp[1][2] - scalarInterp[0][2]) / vSpacing);\n        if (length(result.xyz) > 0.0) {\n          return vec4(normalize(result.xyz),result.w);\n        } else {\n          return vec4(0.0);\n        }\n      }\n\n      vec4 computeDensityNormal(float scalar, float gradientMag, mat3 scalarInterp, vec3 secondaryGradientMag)\n      {\n        vec4 opacityG;\n        vec3 opacityInterp = vec3(0.0);\n        float opacity = texture2D(otexture, vec2(scalar * oscale0 + oshift0, 0.5)).r;\n        if (gradientMag >= 0.0){\n          opacity *= computeGradientOpacityFactor(gradientMag, goscale0, goshift0, gomin0, gomax0);\n        }\n        opacityInterp.x = texture2D(otexture, vec2(scalarInterp[0][0] * oscale0 + oshift0, 0.5)).r; \n        if (secondaryGradientMag.x >= 0.0){\n          opacityInterp.x *= computeGradientOpacityFactor(secondaryGradientMag.x, goscale0, goshift0, gomin0, gomax0);\n        }\n    \n        opacityInterp.y = texture2D(otexture, vec2(scalarInterp[0][1] * oscale0 + oshift0, 0.5)).r;\n        if (secondaryGradientMag.y >= 0.0){\n          opacityInterp.y *= computeGradientOpacityFactor(secondaryGradientMag.y, goscale0, goshift0, gomin0, gomax0);\n        }\n\n        opacityInterp.z = texture2D(otexture, vec2(scalarInterp[0][2] * oscale0 + oshift0, 0.5)).r;\n        if (secondaryGradientMag.z >= 0.0){\n          opacityInterp.z *= computeGradientOpacityFactor(secondaryGradientMag.z, goscale0, goshift0, gomin0, gomax0);\n        }\n\n        opacityG.xyz = opacityInterp - vec3(opacity,opacity,opacity);\n        // divide by spacing\n        opacityG.xyz /= vSpacing;\n        opacityG.w = length(opacityG.xyz);\n        rotateToViewCoord(opacityG.xyz);\n        if (length(opacityG.xyz) > 0.0) {  \n          return vec4(normalize(opacityG.xyz),opacityG.w);\n        } else {\n          return vec4(0.0);\n        }\n      } \n\n    #else\n    //if gradient opacity not on but using density gradient\n      vec4 computeDensityNormal(float scalar, vec3 scalarInterp) \n      { \n        vec4 opacityG; \n        float opacity = texture2D(otexture, vec2(scalar * oscale0 + oshift0, 0.5)).r; \n        opacityG.x = texture2D(otexture, vec2(scalarInterp.x * oscale0 + oshift0, 0.5)).r - opacity; \n        opacityG.y = texture2D(otexture, vec2(scalarInterp.y * oscale0 + oshift0, 0.5)).r - opacity; \n        opacityG.z = texture2D(otexture, vec2(scalarInterp.z * oscale0 + oshift0, 0.5)).r - opacity; \n        // divide by spacing \n        opacityG.xyz /= vSpacing; \n        opacityG.w = length(opacityG.xyz); \n        // rotate to View Coords \n        rotateToViewCoord(opacityG.xyz);\n        if (length(opacityG.xyz) > 0.0) {     \n          return vec4(normalize(opacityG.xyz),opacityG.w); \n        } else { \n          return vec4(0.0); \n        } \n      } \n      vec4 computeNormalForDensity(vec3 pos, float scalar, vec3 tstep, out vec3 scalarInterp) \n      { \n        vec4 result; \n        scalarInterp.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a; \n        scalarInterp.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a; \n        scalarInterp.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a; \n        result.x = scalarInterp.x - scalar; \n        result.y = scalarInterp.y - scalar; \n        result.z = scalarInterp.z - scalar;   \n        // divide by spacing\n        result.xyz /= vSpacing;\n        result.w = length(result.xyz); \n        // rotate to View Coords \n        rotateToViewCoord(result.xyz);      \n        if (length(result.xyz) > 0.0) {     \n          return vec4(normalize(result.xyz),result.w); \n        } else { \n          return vec4(0.0); \n        } \n      }           \n    #endif\n  #endif\n  // compute scalar density\n  vec4 computeNormal(vec3 pos, float scalar, vec3 tstep)  \n  {  \n    vec4 result;  \n    result.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a - scalar;  \n    result.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a - scalar;  \n    result.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a - scalar;  \n    // divide by spacing  \n    result.xyz /= vSpacing;  \n    result.w = length(result.xyz);\n    if (result.w > 0.0){\n      // rotate to View Coords  \n      rotateToViewCoord(result.xyz);\n      return vec4(normalize(result.xyz),result.w);  \n    } else {\n      return vec4(0.0);\n    }\n  }  \n#endif\n\n#ifdef vtkImageLabelOutlineOn\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\n  vec4 pcPos = vec4(\n    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\n    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\n    (fragCoord.z - 0.5) * 2.0,\n    1.0);\n\n  vec4 worldCoord = PCWCMatrix * pcPos;\n  vec4 vertex = (worldCoord/worldCoord.w);\n\n  vec3 index = (vWCtoIDX * vertex).xyz;\n\n  // half voxel fix for labelmapOutline \n  return (index + vec3(0.5)) / vec3(volumeDimensions);\n}\n#endif\n\n//=======================================================================\n// compute the normals and gradient magnitudes for a position\n// for independent components\nmat4 computeMat4Normal(vec3 pos, vec4 tValue, vec3 tstep)\n{\n  mat4 result;\n  vec4 distX = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)) - tValue;\n  vec4 distY = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)) - tValue;\n  vec4 distZ = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)) - tValue;\n\n  // divide by spacing\n  distX /= vSpacing.x;\n  distY /= vSpacing.y;\n  distZ /= vSpacing.z;\n\n  mat3 rot;\n  rot[0] = vPlaneNormal0;\n  rot[1] = vPlaneNormal2;\n  rot[2] = vPlaneNormal4;\n\n#if !defined(vtkComponent0Proportional)\n  result[0].xyz = vec3(distX.r, distY.r, distZ.r);\n  result[0].a = length(result[0].xyz);\n  result[0].xyz *= rot;\n  if (result[0].w > 0.0)\n  {\n    result[0].xyz /= result[0].w;\n  }\n#endif\n\n// optionally compute the 2nd component\n#if vtkNumComponents >= 2 && !defined(vtkComponent1Proportional)\n  result[1].xyz = vec3(distX.g, distY.g, distZ.g);\n  result[1].a = length(result[1].xyz);\n  result[1].xyz *= rot;\n  if (result[1].w > 0.0)\n  {\n    result[1].xyz /= result[1].w;\n  }\n#endif\n\n// optionally compute the 3rd component\n#if vtkNumComponents >= 3 && !defined(vtkComponent2Proportional)\n  result[2].xyz = vec3(distX.b, distY.b, distZ.b);\n  result[2].a = length(result[2].xyz);\n  result[2].xyz *= rot;\n  if (result[2].w > 0.0)\n  {\n    result[2].xyz /= result[2].w;\n  }\n#endif\n\n// optionally compute the 4th component\n#if vtkNumComponents >= 4 && !defined(vtkComponent3Proportional)\n  result[3].xyz = vec3(distX.a, distY.a, distZ.a);\n  result[3].a = length(result[3].xyz);\n  result[3].xyz *= rot;\n  if (result[3].w > 0.0)\n  {\n    result[3].xyz /= result[3].w;\n  }\n#endif\n\n  return result;\n}\n\n//=======================================================================\n// global shadow - secondary ray\n#if defined(VolumeShadowOn) || defined(localAmbientOcclusionOn)\nfloat random()\n{ \n  float rand = fract(sin(dot(gl_FragCoord.xy,vec2(12.9898,78.233)))*43758.5453123);\n  float jitter=texture2D(jtexture,gl_FragCoord.xy/32.).r;\n  uint pcg_state = floatBitsToUint(jitter);\n  uint state = pcg_state;\n  pcg_state = pcg_state * uint(747796405) + uint(2891336453);\n  uint word = ((state >> ((state >> uint(28)) + uint(4))) ^ state) * uint(277803737);\n  return (float((((word >> uint(22)) ^ word) >> 1 ))/float(2147483647) + rand)/2.0;\n}\n#endif\n\n#ifdef VolumeShadowOn\n// henyey greenstein phase function\nfloat phase_function(float cos_angle)\n{\n  // divide by 2.0 instead of 4pi to increase intensity\n  return ((1.0-anisotropy2)/pow(1.0+anisotropy2-2.0*anisotropy*cos_angle, 1.5))/2.0;\n}\n\n// Computes the intersection between a ray and a box\nstruct Hit\n{\n  float tmin;\n  float tmax;\n};\n\nstruct Ray\n{\n  vec3 origin;\n  vec3 dir;\n  vec3 invDir;\n};\n\nbool BBoxIntersect(vec3 boundMin, vec3 boundMax, const Ray r, out Hit hit)\n{\n  vec3 tbot = r.invDir * (boundMin - r.origin);\n  vec3 ttop = r.invDir * (boundMax - r.origin);\n  vec3 tmin = min(ttop, tbot);\n  vec3 tmax = max(ttop, tbot);\n  vec2 t = max(tmin.xx, tmin.yz);\n  float t0 = max(t.x, t.y);\n  t = min(tmax.xx, tmax.yz);\n  float t1 = min(t.x, t.y);\n  hit.tmin = t0;\n  hit.tmax = t1;\n  return t1 > max(t0,0.0);\n}\n\n// As BBoxIntersect requires the inverse of the ray coords,\n// this function is used to avoid numerical issues\nvoid safe_0_vector(inout Ray ray)\n{\n  if(abs(ray.dir.x) < EPSILON) ray.dir.x = sign(ray.dir.x) * EPSILON;\n  if(abs(ray.dir.y) < EPSILON) ray.dir.y = sign(ray.dir.y) * EPSILON;\n  if(abs(ray.dir.z) < EPSILON) ray.dir.z = sign(ray.dir.z) * EPSILON;\n}\n\nfloat volume_shadow(vec3 posIS, vec3 lightDirNormIS)\n{\n  float shadow = 1.0;\n  float opacity = 0.0;\n\n  // modify sample distance with a random number between 0.8 and 1.0\n  float sampleDistanceISVS_jitter = sampleDistanceISVS * mix(0.8, 1.0, random());\n  float opacityPrev = texture2D(otexture, vec2(getTextureValue(posIS).r * oscale0 + oshift0, 0.5)).r;\n  \n  // in case the first sample near surface has a very tiled light ray, we need to offset start position \n  posIS += sampleDistanceISVS_jitter * lightDirNormIS;  \n\n  // compute the start and end points for the ray\n  Ray ray;\n  Hit hit;  \n  ray.origin = posIS;\n  ray.dir = lightDirNormIS;\n  safe_0_vector(ray);\n  ray.invDir = 1.0/ray.dir;\n  \n  if(!BBoxIntersect(vec3(0.0),vec3(1.0), ray, hit))\n  {\n    return 1.0;\n  }\n  vec4 scalar = vec4(0.0);\n  float maxdist = hit.tmax;\n  if(maxdist < EPSILON) {\n    return 1.0;\n  }\n\n  // interpolate shadow ray length between: 1 unit of sample distance in IS to SQRT3, based on globalIlluminationReach\n  float maxgi = mix(sampleDistanceISVS_jitter,SQRT3,giReach);\n  maxdist = min(maxdist,maxgi);\n\n  // support gradient opacity\n  #ifdef vtkGradientOpacityOn\n    vec4 normal;\n  #endif\n\n  vec3 current_step = sampleDistanceISVS_jitter * lightDirNormIS;\n  float maxSteps = ceil(maxdist/sampleDistanceISVS_jitter);\n  float opacityDelta = 0.0;\n\n  for (float i = 0.0; i < maxSteps; i++)\n  {\n    scalar = getTextureValue(posIS);\n    opacity = texture2D(otexture, vec2(scalar.r * oscale0 + oshift0, 0.5)).r;\n    #ifdef vtkGradientOpacityOn \n      normal = computeNormal(posIS, scalar.a, vec3(1.0/vec3(volumeDimensions))); \n      opacity *= computeGradientOpacityFactor(normal.w, goscale0, goshift0, gomin0, gomax0);\n    #endif    \n    shadow *= 1.0 - opacity;\n\n    // optimization: early termination\n    if (shadow < EPSILON){\n      return 0.0;\n    }\n\n    // optimization: increase/decrease sample distance based on changed in opacity value\n    opacityDelta = opacityPrev - opacity;\n    opacityPrev = opacity;\n    if (opacityDelta > 0.0){\n      current_step *= 0.9;\n    } else if (opacityDelta < 0.0){\n      current_step *= 1.1;\n    }\n    posIS += current_step;\n  }\n\n  return shadow;  \n}\n\nvec3 applyShadowRay(vec3 tColor, vec3 posIS, vec3 viewDirectionVC)\n{\n  vec3 vertLight = vec3(0.0);\n  vec3 secondary_contrib = vec3(0.0);\n  // here we assume only positional light, no effect of cones\n  for (int i = 0; i < lightNum; i++)\n  {\n    #if(vtkLightComplexity==3)\n      if (lightPositional[i] == 1){\n        vertLight = lightPositionVC[i] - IStoVC(posIS);\n      }else{\n        vertLight = - lightDirectionVC[i];\n      }\n    #else\n      vertLight = - lightDirectionVC[i];\n    #endif\n    // here we assume achromatic light, only intensity\n    float dDotL = dot(viewDirectionVC, normalize(vertLight));\n    // isotropic scatter returns 0.5 instead of 1/4pi to increase intensity\n    float phase_attenuation = 0.5;\n    if (abs(anisotropy) > EPSILON){\n      phase_attenuation = phase_function(dDotL);\n    }\n    float vol_shadow = volume_shadow(posIS, normalize(rotateToIDX(vertLight)));\n    secondary_contrib += tColor * vDiffuse * lightColor[i] * vol_shadow * phase_attenuation;     \n    secondary_contrib += tColor * vAmbient;\n  } \n  return secondary_contrib;\n}\n#endif\n\n//=======================================================================\n// local ambient occlusion\n#ifdef localAmbientOcclusionOn\nvec3 sample_direction_uniform(int i)\n{\n  float rand = random() * 0.5;\n  float theta = PI2 * (kernelSample[i][0] + rand);\n  float phi = acos(2.0 * (kernelSample[i][1] + rand) -1.0) / 2.5;\n  return normalize(vec3(cos(theta)*sin(phi), sin(theta)*sin(phi), cos(phi)));\n}\n\n// return a matrix that transform startDir into z axis; startDir should be normalized\nmat3 zBaseRotationalMatrix(vec3 startDir){\n  vec3 axis = cross(startDir, vec3(0.0,0.0,1.0));\n  float cosA = startDir.z;\n  float k = 1.0 / (1.0 + cosA);\n  mat3 matrix = mat3((axis.x * axis.x * k) + cosA, (axis.y * axis.x * k) - axis.z, (axis.z * axis.x * k) + axis.y,\n              (axis.x * axis.y * k) + axis.z, (axis.y * axis.y * k) + cosA, (axis.z * axis.y * k) - axis.x,\n              (axis.x * axis.z * k) - axis.y, (axis.y * axis.z * k) + axis.x, (axis.z * axis.z * k) + cosA);\n  return matrix;\n}\n\nfloat computeLAO(vec3 posIS, float opacity, vec3 lightDir, vec4 normal){\n  // apply LAO only at selected locations, otherwise return full brightness\n  if (normal.w > 0.0 && opacity > 0.05){\n    float total_transmittance = 0.0;\n    mat3 inverseRotateBasis = inverse(zBaseRotationalMatrix(normalize(-normal.xyz)));\n    vec3 currPos, randomDirStep;\n    float weight, transmittance, opacity;\n    for (int i = 0; i < kernelSize; i++)\n    {\n      randomDirStep = inverseRotateBasis * sample_direction_uniform(i) * sampleDistanceIS;\n      weight = 1.0 - dot(normalize(lightDir), normalize(randomDirStep));\n      currPos = posIS;\n      transmittance = 1.0;\n      for (int j = 0; j < kernelRadius ; j++){\n        currPos += randomDirStep;\n        // check if it's at clipping plane, if so return full brightness\n        if (all(greaterThan(currPos, vec3(EPSILON))) && all(lessThan(currPos,vec3(1.0-EPSILON)))){\n          opacity = texture2D(otexture, vec2(getTextureValue(currPos).r * oscale0 + oshift0, 0.5)).r;\n          #ifdef vtkGradientOpacityOn\n             opacity *= computeGradientOpacityFactor(normal.w, goscale0, goshift0, gomin0, gomax0);\n          #endif\n          transmittance *= 1.0 - opacity;\n        }\n        else{\n          break;\n        }\n      }\n      total_transmittance += transmittance / float(kernelRadius) * weight;\n\n      // early termination if fully translucent\n      if (total_transmittance > 1.0 - EPSILON){\n        return 1.0;\n      }\n    }\n    // average transmittance and reduce variance\n    return clamp(total_transmittance / float(kernelSize), 0.3, 1.0); \n  } else {\n    return 1.0;\n  }\n}\n#endif\n\n//=======================================================================\n// surface light contribution\n#if vtkLightComplexity > 0\n  void applyLighting(inout vec3 tColor, vec4 normal)\n  {\n    vec3 diffuse = vec3(0.0, 0.0, 0.0);\n    vec3 specular = vec3(0.0, 0.0, 0.0);\n    float df, sf = 0.0;\n    for (int i = 0; i < lightNum; i++){\n        df = abs(dot(normal.rgb, -lightDirectionVC[i]));\n        diffuse += df * lightColor[i];\n        sf = pow( abs(dot(lightHalfAngleVC[i],normal.rgb)), vSpecularPower);\n        specular += sf * lightColor[i];\n    }\n    tColor.rgb = tColor.rgb*(diffuse*vDiffuse + vAmbient) + specular*vSpecular;\n  }\n  #ifdef SurfaceShadowOn\n  #if vtkLightComplexity < 3\n    vec3 applyLightingDirectional(vec3 posIS, vec4 tColor, vec4 normal)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      #ifdef localAmbientOcclusionOn\n        vec3 ambient = vec3(0.0);\n      #endif        \n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float ndotL,vdotR;\n        vertLightDirection = lightDirectionVC[i];\n        ndotL = dot(normal.xyz, vertLightDirection);\n        if (ndotL < 0.0 && twoSidedLighting)\n        {\n          ndotL = -ndotL;\n        }\n        if (ndotL > 0.0)\n        {\n          diffuse += ndotL * lightColor[i];\n          //specular\n          vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n          if (vdotR > 0.0)\n          {\n            specular += pow(vdotR, vSpecularPower) * lightColor[i];\n          }\n        }\n        #ifdef localAmbientOcclusionOn\n            ambient += computeLAO(posIS, tColor.a, vertLightDirection, normal);\n        #endif\n      }  \n      #ifdef localAmbientOcclusionOn\n        return tColor.rgb * (diffuse * vDiffuse + vAmbient * ambient) + specular*vSpecular;\n      #else \n        return tColor.rgb * (diffuse * vDiffuse + vAmbient) + specular*vSpecular;\n      #endif    \n    }\n  #else\n    vec3 applyLightingPositional(vec3 posIS, vec4 tColor, vec4 normal, vec3 posVC)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      #ifdef localAmbientOcclusionOn\n        vec3 ambient = vec3(0.0);\n      #endif      \n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float distance,attenuation,ndotL,vdotR;\n        vec3 lightDir;\n        if (lightPositional[i] == 1){\n          lightDir = lightDirectionVC[i];\n          vertLightDirection = posVC - lightPositionVC[i]; \n          distance = length(vertLightDirection);\n          vertLightDirection = normalize(vertLightDirection);\n          attenuation = 1.0 / (lightAttenuation[i].x\n                              + lightAttenuation[i].y * distance\n                              + lightAttenuation[i].z * distance * distance);\n          // per OpenGL standard cone angle is 90 or less for a spot light\n          if (lightConeAngle[i] <= 90.0){\n            float coneDot = dot(vertLightDirection, lightDir);\n            if (coneDot >= cos(radians(lightConeAngle[i]))){  // if inside cone\n              attenuation = attenuation * pow(coneDot, lightExponent[i]);\n            }\n            else {\n              attenuation = 0.0;\n            }\n          }\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * attenuation * lightColor[i];\n            //specular\n            vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n            if (vdotR > 0.0)\n            {\n              specular += pow(vdotR, vSpecularPower) * attenuation * lightColor[i];\n            }\n          }\n          #ifdef localAmbientOcclusionOn\n            ambient += computeLAO(posIS, tColor.a, vertLightDirection, normal);\n          #endif          \n        } else {\n          vertLightDirection = lightDirectionVC[i];\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * lightColor[i];\n            //specular\n            vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n            if (vdotR > 0.0)\n            {\n              specular += pow(vdotR, vSpecularPower) * lightColor[i];\n            }\n          }\n          #ifdef localAmbientOcclusionOn\n            ambient += computeLAO(posIS, tColor.a, vertLightDirection, normal);\n          #endif          \n        }\n      }\n      #ifdef localAmbientOcclusionOn\n        return tColor.rgb * (diffuse * vDiffuse + vAmbient * ambient) + specular*vSpecular;\n      #else \n        return tColor.rgb * (diffuse * vDiffuse + vAmbient) + specular*vSpecular;\n      #endif\n    }\n  #endif \n  #endif\n#endif\n\n//=======================================================================\n// Given a texture value compute the color and opacity\n//\nvec4 getColorForValue(vec4 tValue, vec3 posIS, vec3 tstep)\n{\n#ifdef vtkImageLabelOutlineOn\n  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\n  vec4 centerValue = getTextureValue(centerPosIS);\n  bool pixelOnBorder = false;\n  vec4 tColor = texture2D(ctexture, vec2(centerValue.r * cscale0 + cshift0, 0.5));\n\n  // Get alpha of segment from opacity function.\n  tColor.a = texture2D(otexture, vec2(centerValue.r * oscale0 + oshift0, 0.5)).r;\n\n  // Only perform outline check on fragments rendering voxels that aren't invisible.\n  // Saves a bunch of needless checks on the background.\n  // TODO define epsilon when building shader?\n  if (float(tColor.a) > 0.01) {\n    for (int i = -outlineThickness; i <= outlineThickness; i++) {\n      for (int j = -outlineThickness; j <= outlineThickness; j++) {\n        if (i == 0 || j == 0) {\n          continue;\n        }\n\n        vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\n          gl_FragCoord.y + float(j),\n          gl_FragCoord.z, gl_FragCoord.w);\n\n        vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\n        vec4 value = getTextureValue(neighborPosIS);\n\n        // If any of my neighbours are not the same value as I\n        // am, this means I am on the border of the segment.\n        // We can break the loops\n        if (any(notEqual(value, centerValue))) {\n          pixelOnBorder = true;\n          break;\n        }\n      }\n\n      if (pixelOnBorder == true) {\n        break;\n      }\n    }\n\n    // If I am on the border, I am displayed at full opacity\n    if (pixelOnBorder == true) {\n      tColor.a = 1.0;\n    }\n  }\n\n#else\n  // compute the normal and gradient magnitude if needed\n  // We compute it as a vec4 if possible otherwise a mat4\n  //\n  vec4 goFactor = vec4(1.0,1.0,1.0,1.0);\n\n  // compute the normal vectors as needed\n  #if (vtkLightComplexity > 0) || defined(vtkGradientOpacityOn)\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      mat4 normalMat = computeMat4Normal(posIS, tValue, tstep);\n      #if !defined(vtkComponent0Proportional)\n        vec4 normal0 = normalMat[0];\n      #endif\n      #if !defined(vtkComponent1Proportional)\n        vec4 normal1 = normalMat[1];\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          vec4 normal2 = normalMat[2];\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            vec4 normal3 = normalMat[3];\n          #endif\n        #endif\n      #endif\n    #else\n      vec4 normalLight;\n      #ifdef vtkComputeNormalFromOpacity\n        #ifdef vtkGradientOpacityOn\n          mat3 scalarInterp;  \n          vec3 secondaryGradientMag;  \n          vec4 normal0 = computeNormalForDensity(posIS, tValue.a, tstep, scalarInterp, secondaryGradientMag);  \n          normalLight = computeDensityNormal(tValue.a, normal0.w, scalarInterp,secondaryGradientMag);       \n          if (length(normalLight) == 0.0){  \n            normalLight = normal0;   \n          }                      \n        #else\n          vec3 scalarInterp;  \n          vec4 normal0 = computeNormalForDensity(posIS, tValue.a, tstep, scalarInterp);  \n          if (length(normal0)>0.0){  \n            normalLight = computeDensityNormal(tValue.a,scalarInterp);  \n            if (length(normalLight)==0.0){  \n              normalLight = normal0;  \n            }  \n          }                \n        #endif\n      #else \n        vec4 normal0 = computeNormal(posIS, tValue.a, tstep);  \n        normalLight = normal0;             \n      #endif\n    #endif\n  #endif\n\n  // compute gradient opacity factors as needed\n  #if defined(vtkGradientOpacityOn)\n    #if !defined(vtkComponent0Proportional)\n      goFactor.x =\n        computeGradientOpacityFactor(normal0.a, goscale0, goshift0, gomin0, gomax0);\n    #endif\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      #if !defined(vtkComponent1Proportional)\n        goFactor.y =\n          computeGradientOpacityFactor(normal1.a, goscale1, goshift1, gomin1, gomax1);\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          goFactor.z =\n            computeGradientOpacityFactor(normal2.a, goscale2, goshift2, gomin2, gomax2);\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            goFactor.w =\n              computeGradientOpacityFactor(normal3.a, goscale3, goshift3, gomin3, gomax3);\n          #endif\n        #endif\n      #endif\n    #endif\n  #endif\n\n  // single component is always independent\n  #if vtkNumComponents == 1\n    vec4 tColor = texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, 0.5));\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, 0.5)).r;\n    if (tColor.a < EPSILON){\n      return vec4(0.0);\n    }    \n  #endif\n\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n    vec4 tColor = mix0*texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, height0));\n    #if !defined(vtkComponent0Proportional)\n      tColor.a = goFactor.x*mix0*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n      tColor *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix0));\n    #endif\n\n    vec3 tColor1 = mix1*texture2D(ctexture, vec2(tValue.g * cscale1 + cshift1, height1)).rgb;\n    #if !defined(vtkComponent1Proportional)\n      tColor.a += goFactor.y*mix1*texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n      tColor1 *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix1));\n    #endif\n\n    #if vtkNumComponents >= 3\n      vec3 tColor2 = mix2*texture2D(ctexture, vec2(tValue.b * cscale2 + cshift2, height2)).rgb;\n      #if !defined(vtkComponent2Proportional)\n        tColor.a += goFactor.z*mix2*texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n      #else\n        float pwfValue = texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n        tColor2 *= pwfValue;\n        tColor.a *= mix(pwfValue, 1.0, (1.0 - mix2));\n      #endif\n\n      #if vtkNumComponents >= 4\n        vec3 tColor3 = mix3*texture2D(ctexture, vec2(tValue.a * cscale3 + cshift3, height3)).rgb;\n        #if !defined(vtkComponent3Proportional)\n          tColor.a += goFactor.w*mix3*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n        #else\n          float pwfValue = texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n          tColor3 *= pwfValue;\n          tColor.a *= mix(pwfValue, 1.0, (1.0 - mix3));\n        #endif\n      #endif\n    #endif\n  #else // then not independent\n\n  #if vtkNumComponents == 2\n    float lum = tValue.r * cscale0 + cshift0;\n    float alpha = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale1 + oshift1, 0.5)).r;\n    vec4 tColor = vec4(lum, lum, lum, alpha);\n  #endif\n  #if vtkNumComponents == 3\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale0 + oshift0, 0.5)).r;\n  #endif\n  #if vtkNumComponents == 4\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, 0.5)).r;\n  #endif\n  #endif // dependent\n\n  // apply lighting if requested as appropriate\n  #if vtkLightComplexity > 0\n    #if !defined(vtkComponent0Proportional) \n      #if vtkNumComponents == 1\n    \n        #ifdef SurfaceShadowOn\n            #if vtkLightComplexity < 3\n                vec3 tColorS = applyLightingDirectional(posIS, tColor, normalLight);\n            #else\n                vec3 tColorS = applyLightingPositional(posIS, tColor, normalLight, IStoVC(posIS));\n            #endif\n        #endif\n\n        #ifdef VolumeShadowOn\n          vec3 tColorVS = applyShadowRay(tColor.rgb, posIS, rayDirVC);\n          #ifdef SurfaceShadowOn\n            float vol_coef = volumetricScatteringBlending * (1.0 - tColor.a / 2.0) * (1.0 - atan(normalLight.w) * INV4PI);\n            tColor.rgb = (1.0-vol_coef) * tColorS + vol_coef * tColorVS;\n          #else\n            tColor.rgb = tColorVS;\n          #endif\n        #else\n            tColor.rgb = tColorS;\n        #endif\n        \n      #else\n        applyLighting(tColor.rgb, normal0);\n      #endif\n    #endif\n\n    #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n      #if !defined(vtkComponent1Proportional)\n        applyLighting(tColor1, normal1);\n      #endif\n    #if vtkNumComponents >= 3\n      #if !defined(vtkComponent2Proportional)\n        applyLighting(tColor2, normal2);\n      #endif\n    #if vtkNumComponents >= 4\n      #if !defined(vtkComponent3Proportional)\n        applyLighting(tColor3, normal3);\n      #endif\n    #endif\n    #endif\n    #endif\n  #endif\n\n// perform final independent blend as needed\n#if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n  tColor.rgb += tColor1;\n#if vtkNumComponents >= 3\n  tColor.rgb += tColor2;\n#if vtkNumComponents >= 4\n  tColor.rgb += tColor3;\n#endif\n#endif\n#endif\n\n#endif\n\n\n\n\n\n\n\nreturn tColor;\n}\n\nbool valueWithinScalarRange(vec4 val, vec4 min, vec4 max) {\n  bool withinRange = false;\n  #if vtkNumComponents == 1\n    if (val.r >= min.r && val.r <= max.r) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents == 2\n     if (val.r >= min.r && val.r <= max.r &&\n        val.g >= min.g && val.g <= max.g) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 3\n    if (all(greaterThanEqual(val, ipScalarRangeMin)) &&\n        all(lessThanEqual(val, ipScalarRangeMax))) {\n      withinRange = true;\n    }\n  #endif\n  return withinRange;\n}\n\n//=======================================================================\n// Apply the specified blend mode operation along the ray's path.\n//\nvoid applyBlend(vec3 posIS, vec3 endIS, vec3 tdims)\n{\n  vec3 tstep = 1.0/tdims;\n\n  // start slightly inside and apply some jitter\n  vec3 delta = endIS - posIS;\n  vec3 stepIS = normalize(delta)*sampleDistanceIS;\n  float raySteps = length(delta)/sampleDistanceIS;\n\n  // avoid 0.0 jitter\n  float jitter = 0.01 + 0.99*texture2D(jtexture, gl_FragCoord.xy/32.0).r;\n  float stepsTraveled = jitter;\n\n  // local vars for the loop\n  vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n  vec4 tValue;\n  vec4 tColor;\n\n  // if we have less than one step then pick the middle point\n  // as our value\n  // if (raySteps <= 1.0)\n  // {\n  //   posIS = (posIS + endIS)*0.5;\n  // }\n\n  // Perform initial step at the volume boundary\n  // compute the scalar\n  tValue = getTextureValue(posIS);\n\n  #if vtkBlendMode == 0 // COMPOSITE_BLEND\n    // now map through opacity and color\n    tColor = getColorForValue(tValue, posIS, tstep);\n\n    // handle very thin volumes\n    if (raySteps <= 1.0)\n    {\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps);\n      gl_FragData[0] = tColor;\n      return;\n    }\n\n    tColor.a = 1.0 - pow(1.0 - tColor.a, jitter);\n    color = vec4(tColor.rgb*tColor.a, tColor.a);\n    posIS += (jitter*stepIS);\n\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n\n      float mix = (1.0 - color.a);\n\n      // this line should not be needed but nvidia seems to not handle\n      // the break correctly on windows/chrome 58 angle\n      //mix = mix * sign(max(raySteps - stepsTraveled - 1.0, 0.0));\n\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n      stepsTraveled++;\n      posIS += stepIS;\n      if (color.a > 0.99) { color.a = 1.0; break; }\n    }\n\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0)\n    {\n      posIS = endIS;\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\n\n      float mix = (1.0 - color.a);\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n    }\n\n    gl_FragData[0] = vec4(color.rgb/color.a, color.a);\n  #endif\n  #if vtkBlendMode == 1 || vtkBlendMode == 2\n    // MAXIMUM_INTENSITY_BLEND || MINIMUM_INTENSITY_BLEND\n    // Find maximum/minimum intensity along the ray.\n\n    // Define the operation we will use (min or max)\n    #if vtkBlendMode == 1\n    #define OP max\n    #else\n    #define OP min\n    #endif\n\n    // If the clipping range is shorter than the sample distance\n    // we can skip the sampling loop along the ray.\n    if (raySteps <= 1.0)\n    {\n      gl_FragData[0] = getColorForValue(tValue, posIS, tstep);\n      return;\n    }\n\n    vec4 value = tValue;\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // Update the maximum value if necessary\n      value = OP(tValue, value);\n\n      // Otherwise, continue along the ray\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n    tValue = getTextureValue(posIS);\n    value = OP(tValue, value);\n\n    // Now map through opacity and color\n    gl_FragData[0] = getColorForValue(value, posIS, tstep);\n  #endif\n  #if vtkBlendMode == 3 || vtkBlendMode == 4 //AVERAGE_INTENSITY_BLEND || ADDITIVE_BLEND\n    vec4 sum = vec4(0.);\n\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n    }\n\n    if (raySteps <= 1.0) {\n      gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n      return;\n    }\n\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // One can control the scalar range by setting the AverageIPScalarRange to disregard scalar values, not in the range of interest, from the average computation.\n      // Notes:\n      // - We are comparing all values in the texture to see if any of them\n      //   are outside of the scalar range. In the future we might want to allow\n      //   scalar ranges for each component.\n      if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n        // Sum the values across each step in the path\n        sum += tValue;\n      }\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n\n    // compute the scalar\n    tValue = getTextureValue(posIS);\n\n    // One can control the scalar range by setting the IPScalarRange to disregard scalar values, not in the range of interest, from the average computation\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n\n      stepsTraveled++;\n    }\n\n    #if vtkBlendMode == 3 // Average\n      sum /= vec4(stepsTraveled, stepsTraveled, stepsTraveled, 1.0);\n    #endif\n\n    gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n  #endif\n  #if vtkBlendMode == 5 // RADON\n    float normalizedRayIntensity = 1.0;\n\n    // handle very thin volumes\n    if (raySteps <= 1.0)\n    {\n      tValue = getTextureValue(posIS);\n      normalizedRayIntensity = normalizedRayIntensity - sampleDistance*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, 0.5)).r;\n      gl_FragData[0] = texture2D(ctexture, vec2(normalizedRayIntensity * cscale0 + cshift0, 0.5));\n      return;\n    }\n\n    posIS += (jitter*stepIS);\n\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar value\n      tValue = getTextureValue(posIS);\n\n      // Convert scalar value to normalizedRayIntensity coefficient and accumulate normalizedRayIntensity\n      normalizedRayIntensity = normalizedRayIntensity - sampleDistance*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, 0.5)).r;\n\n      posIS += stepIS;\n      stepsTraveled++;\n    }\n\n    // map normalizedRayIntensity to color\n    gl_FragData[0] = texture2D(ctexture, vec2(normalizedRayIntensity * cscale0 + cshift0, 0.5));\n\n  #endif\n}\n\n//=======================================================================\n// Compute a new start and end point for a given ray based\n// on the provided bounded clipping plane (aka a rectangle)\nvoid getRayPointIntersectionBounds(\n  vec3 rayPos, vec3 rayDir,\n  vec3 planeDir, float planeDist,\n  inout vec2 tbounds, vec3 vPlaneX, vec3 vPlaneY,\n  float vSize1, float vSize2)\n{\n  float result = dot(rayDir, planeDir);\n  if (abs(result) < 1e-6)\n  {\n    return;\n  }\n  result = -1.0 * (dot(rayPos, planeDir) + planeDist) / result;\n  vec3 xposVC = rayPos + rayDir*result;\n  vec3 vxpos = xposVC - vOriginVC;\n  vec2 vpos = vec2(\n    dot(vxpos, vPlaneX),\n    dot(vxpos, vPlaneY));\n\n  // on some apple nvidia systems this does not work\n  // if (vpos.x < 0.0 || vpos.x > vSize1 ||\n  //     vpos.y < 0.0 || vpos.y > vSize2)\n  // even just\n  // if (vpos.x < 0.0 || vpos.y < 0.0)\n  // fails\n  // so instead we compute a value that represents in and out\n  //and then compute the return using this value\n  float xcheck = max(0.0, vpos.x * (vpos.x - vSize1)); //  0 means in bounds\n  float check = sign(max(xcheck, vpos.y * (vpos.y - vSize2))); //  0 means in bounds, 1 = out\n\n  tbounds = mix(\n   vec2(min(tbounds.x, result), max(tbounds.y, result)), // in value\n   tbounds, // out value\n   check);  // 0 in 1 out\n}\n\n//=======================================================================\n// given a\n// - ray direction (rayDir)\n// - starting point (vertexVCVSOutput)\n// - bounding planes of the volume\n// - optionally depth buffer values\n// - far clipping plane\n// compute the start/end distances of the ray we need to cast\nvec2 computeRayDistances(vec3 rayDir, vec3 tdims)\n{\n  vec2 dists = vec2(100.0*camFar, -1.0);\n\n  vec3 vSize = vSpacing*tdims;\n\n  // all this is in View Coordinates\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal0, vPlaneDistance0, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal1, vPlaneDistance1, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal2, vPlaneDistance2, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal3, vPlaneDistance3, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal4, vPlaneDistance4, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal5, vPlaneDistance5, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n\n  //VTK::ClipPlane::Impl\n\n  // do not go behind front clipping plane\n  dists.x = max(0.0,dists.x);\n\n  // do not go PAST far clipping plane\n  float farDist = -camThick/rayDir.z;\n  dists.y = min(farDist,dists.y);\n\n  // Do not go past the zbuffer value if set\n  // This is used for intermixing opaque geometry\n  //VTK::ZBuffer::Impl\n\n  return dists;\n}\n\n//=======================================================================\n// Compute the index space starting position (pos) and end\n// position\n//\nvoid computeIndexSpaceValues(out vec3 pos, out vec3 endPos, vec3 rayDir, vec2 dists)\n{\n  // compute starting and ending values in volume space\n  pos = vertexVCVSOutput + dists.x*rayDir;\n  pos = pos - vOriginVC;\n  // convert to volume basis and origin\n  pos = vec3(\n    dot(pos, vPlaneNormal0),\n    dot(pos, vPlaneNormal2),\n    dot(pos, vPlaneNormal4));\n\n  endPos = vertexVCVSOutput + dists.y*rayDir;\n  endPos = endPos - vOriginVC;\n  endPos = vec3(\n    dot(endPos, vPlaneNormal0),\n    dot(endPos, vPlaneNormal2),\n    dot(endPos, vPlaneNormal4));\n\n  float delta = length(endPos - pos);\n\n  pos *= vVCToIJK;\n  endPos *= vVCToIJK;\n\n  float delta2 = length(endPos - pos);\n  sampleDistanceIS = sampleDistance*delta2/delta;\n  #ifdef VolumeShadowOn\n    sampleDistanceISVS = sampleDistanceIS * volumeShadowSamplingDistFactor;\n  #endif\n}\n\nvoid main()\n{\n\n  if (cameraParallel == 1)\n  {\n    // Camera is parallel, so the rayDir is just the direction of the camera.\n    rayDirVC = vec3(0.0, 0.0, -1.0);\n  } else {\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\n    rayDirVC = normalize(vertexVCVSOutput);\n  }\n\n  vec3 tdims = vec3(volumeDimensions);\n\n  // compute the start and end points for the ray\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayDirVC, tdims);\n\n  // do we need to composite? aka does the ray have any length\n  // If not, bail out early\n  if (rayStartEndDistancesVC.y <= rayStartEndDistancesVC.x)\n  {\n    discard;\n  }\n\n  // IS = Index Space\n  vec3 posIS;\n  vec3 endIS;\n  computeIndexSpaceValues(posIS, endIS, rayDirVC, rayStartEndDistancesVC);\n\n  // Perform the blending operation along the ray\n  applyBlend(posIS, endIS, tdims);\n}\n";
 
 export { vtkVolumeFS as v };

package/package.json

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

package/types.d.ts

@@ -22,7 +22,6 @@ declare type double = number;
 declare type int = number;
 
 declare type TypedArray =
-  | number[]
   | Uint32Array
   | Uint16Array
   | Uint8Array