@kitware/vtk.js 25.2.3 → 25.4.0

package/README.md

@@ -48,8 +48,8 @@ In general VTK tries to be as portable as possible; the specific configurations
 
 vtk.js supports the following development environments:
 
-- Node 12+
-- NPM 6+
+- Node 14+
+- NPM 7+
 
 and we use [@babel/preset-env](https://www.npmjs.com/package/@babel/preset-env) with the [defaults](https://github.com/Kitware/vtk-js/blob/master/.browserslistrc) set of [browsers target](https://browserl.ist/?q=defaults).
 But when built from source this could be adjusted to support any browser as long they provide WebGL.

package/Rendering/Core/Renderer.d.ts

@@ -35,6 +35,10 @@ export interface IRendererInitialValues extends IViewportInitialValues {
 	occlusionRatio?: number;
 	maximumNumberOfPeels?: number;
 	texturedBackground?: boolean;
+	environmentTexture?: vtkTexture;
+	environmentTextureDiffuseStrength?: number;
+	environmentTextureSpecularStrength?: number;
+	useEnvironmentTextureAsBackground?: boolean;
 	pass?: number;
 }
 
@@ -115,7 +119,25 @@ export interface vtkRenderer extends vtkViewport {
 	 * 
 	 * @default null
 	 */
-	getBackgroundTexture(): vtkTexture;
+	getEnvironmentTexture(): vtkTexture;
+
+	/**
+	 * Returns the diffuse strength of the set environment texture.
+	 * @default 1
+	 */
+	getEnvironmentTextureDiffuseStrength(): number;
+
+	/**
+	 * Returns the specular strength of the set environment texture.
+	 * @default 1
+	 */
+	getEnvironmentTextureSpecularStrength(): number;
+
+	/**
+	  * Gets whether or not the environment texture is being used as the background for the view.
+	  * @default false
+	  */
+	getUseEnvironmentTextureAsBackground(): boolean;
 
 	/**
 	 * 
@@ -347,9 +369,27 @@ export interface vtkRenderer extends vtkViewport {
 
 	/**
 	 * 
-	 * @param {vtkTexture} backgroundTexture 
+	 * @param {vtkTexture} environmentTexture 
+	 */
+	setEnvironmentTexture(environmentTexture: vtkTexture): boolean;
+
+	/**
+	 * Sets the diffuse strength of the set environment texture.
+	 * @param {number} diffuseStrength the new diffuse strength.
 	 */
-	setBackgroundTexture(backgroundTexture: vtkTexture): boolean;
+	setEnvironmentTextureDiffuseStrength(diffuseStrength: number): boolean;
+
+	 /**
+	  * Sets the specular strength of the set environment texture.
+	  * @param {number} specularStrength the new specular strength.
+	  */
+	setEnvironmentTextureSpecularStrength(specularStrength: number): boolean;
+
+	/**
+	  * Sets whether or not to use the environment texture as the background for the view.
+	  * @param {number} textureAsBackground
+	  */
+	setUseEnvironmentTextureAsBackground(textureAsBackground: boolean): boolean;
 
 	/**
 	 * 

package/Rendering/Core/Renderer.js

@@ -593,6 +593,10 @@ var DEFAULT_VALUES = {
   delegate: null,
   texturedBackground: false,
   backgroundTexture: null,
+  environmentTexture: null,
+  environmentTextureDiffuseStrength: 1,
+  environmentTextureSpecularStrength: 1,
+  useEnvironmentTextureAsBackground: false,
   pass: 0
 }; // ----------------------------------------------------------------------------
 
@@ -611,7 +615,7 @@ function extend(publicAPI, model) {
   if (model.background.length === 3) model.background.push(1); // Build VTK API
 
   get(publicAPI, model, ['_renderWindow', 'allocatedRenderTime', 'timeFactor', 'lastRenderTimeInSeconds', 'numberOfPropsRendered', 'lastRenderingUsedDepthPeeling', 'selector']);
-  setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'useShadows', 'pass']);
+  setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'environmentTexture', 'environmentTextureDiffuseStrength', 'environmentTextureSpecularStrength', 'useEnvironmentTextureAsBackground', 'useShadows', 'pass']);
   getArray(publicAPI, model, ['actors', 'volumes', 'lights']);
   setGetArray(publicAPI, model, ['background'], 4, 1.0);
   moveToProtected(publicAPI, model, ['renderWindow']); // Object methods

package/Rendering/Core/Texture.d.ts

@@ -5,6 +5,7 @@ export interface ITextureInitialValues {
 	interpolate?: boolean;
 	edgeClamp?: boolean;
 	imageLoaded?: boolean;
+	mipLevel?: number;
 }
 
 export interface vtkTexture extends vtkAlgorithm {
@@ -34,6 +35,11 @@ export interface vtkTexture extends vtkAlgorithm {
 	 */
 	getImageLoaded(): boolean;
 
+	/**
+	 * 
+	 */
+	getMipLevel(): number;
+
 	/**
 	 * 
 	 * @param repeat 
@@ -62,6 +68,11 @@ export interface vtkTexture extends vtkAlgorithm {
 	 * @default null
 	 */
 	setImage(image: any): void;
+
+	/**
+	 * @param level
+	 */
+	setMipLevel(level: number): boolean;
 }
 
 /**
@@ -79,6 +90,17 @@ export function extend(publicAPI: object, model: object, initialValues?: ITextur
  */
 export function newInstance(initialValues?: ITextureInitialValues): vtkTexture;
 
+/**
+ * Method used to create mipmaps from given texture data. Works best with textures that have a 
+ * width and a height that are powers of two.
+ * 
+ * @param nativeArray the array of data to create mipmaps from.
+ * @param width the width of the data
+ * @param height the height of the data
+ * @param level the level to which additional mipmaps are generated.
+ */
+export function generateMipmaps(nativeArray: any, width: number, height: number, level: number): Array<Uint8ClampedArray>;
+
 /** 
  * vtkTexture is an image algorithm that handles loading and binding of texture maps.
  * It obtains its data from an input image data dataset type. 

package/Rendering/Core/Texture.js

@@ -1,5 +1,10 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+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; }
 // vtkTexture methods
 // ----------------------------------------------------------------------------
 
@@ -103,19 +108,160 @@ function vtkTexture(publicAPI, model) {
     var dimensionality = (width > 1) + (height > 1) + (depth > 1);
     return dimensionality;
   };
-} // ----------------------------------------------------------------------------
+
+  publicAPI.getInputAsJsImageData = function () {
+    if (!model.imageLoaded || publicAPI.getInputData()) return null;
+
+    if (model.jsImageData) {
+      return model.jsImageData();
+    }
+
+    if (model.canvas) {
+      var context = model.canvas.getContext('2d');
+      var imageData = context.getImageData(0, 0, model.canvas.width, model.canvas.height);
+      return imageData;
+    }
+
+    if (model.image) {
+      var canvas = document.createElement('canvas');
+      canvas.width = model.image.width;
+      canvas.height = model.image.height;
+
+      var _context = canvas.getContext('2d');
+
+      _context.translate(0, canvas.height);
+
+      _context.scale(1, -1);
+
+      _context.drawImage(model.image, 0, 0, model.image.width, model.image.height);
+
+      var _imageData = _context.getImageData(0, 0, canvas.width, canvas.height);
+
+      return _imageData;
+    }
+
+    return null;
+  };
+} // Use nativeArray instead of self
+
+
+var generateMipmaps = function generateMipmaps(nativeArray, width, height, level) {
+  // TODO: FIX UNEVEN TEXTURE MIP GENERATION:
+  // When textures don't have standard ratios, higher mip levels
+  // result in their color chanels getting messed up and shifting
+  // 3x3 gaussian kernel
+  var g3m = [1, 2, 1]; // eslint-disable-line
+
+  var g3w = 4; // eslint-disable-line
+
+  var kernel = g3m;
+  var kernelWeight = g3w;
+  var hs = nativeArray.length / (width * height); // TODO: support for textures with depth more than 1
+
+  var currentWidth = width;
+  var currentHeight = height;
+  var imageData = nativeArray;
+  var maps = [imageData];
+
+  for (var i = 0; i < level; i++) {
+    var oldData = _toConsumableArray(imageData);
+
+    currentWidth /= 2;
+    currentHeight /= 2;
+    imageData = new Uint8ClampedArray(currentWidth * currentHeight * hs);
+    var vs = hs * currentWidth; // Scale down
+
+    var shift = 0;
+
+    for (var p = 0; p < imageData.length; p += hs) {
+      if (p % vs === 0) {
+        shift += 2 * hs * currentWidth;
+      }
+
+      for (var c = 0; c < hs; c++) {
+        var sample = oldData[shift + c];
+        sample += oldData[shift + hs + c];
+        sample += oldData[shift - 2 * vs + c];
+        sample += oldData[shift - 2 * vs + hs + c];
+        sample /= 4;
+        imageData[p + c] = sample;
+      }
+
+      shift += 2 * hs;
+    } // Horizontal Pass
+
+
+    var dataCopy = _toConsumableArray(imageData);
+
+    for (var _p = 0; _p < imageData.length; _p += hs) {
+      for (var _c = 0; _c < hs; _c++) {
+        var x = -(kernel.length - 1) / 2;
+        var kw = kernelWeight;
+        var value = 0.0;
+
+        for (var k = 0; k < kernel.length; k++) {
+          var index = _p + _c + x * hs;
+          var lineShift = index % vs - (_p + _c) % vs;
+          if (lineShift > hs) index += vs;
+          if (lineShift < -hs) index -= vs;
+
+          if (dataCopy[index]) {
+            value += dataCopy[index] * kernel[k];
+          } else {
+            kw -= kernel[k];
+          }
+
+          x += 1;
+        }
+
+        imageData[_p + _c] = value / kw;
+      }
+    } // Vertical Pass
+
+
+    dataCopy = _toConsumableArray(imageData);
+
+    for (var _p2 = 0; _p2 < imageData.length; _p2 += hs) {
+      for (var _c2 = 0; _c2 < hs; _c2++) {
+        var _x = -(kernel.length - 1) / 2;
+
+        var _kw = kernelWeight;
+        var _value = 0.0;
+
+        for (var _k = 0; _k < kernel.length; _k++) {
+          var _index = _p2 + _c2 + _x * vs;
+
+          if (dataCopy[_index]) {
+            _value += dataCopy[_index] * kernel[_k];
+          } else {
+            _kw -= kernel[_k];
+          }
+
+          _x += 1;
+        }
+
+        imageData[_p2 + _c2] = _value / _kw;
+      }
+    }
+
+    maps.push(imageData);
+  }
+
+  return maps;
+}; // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
 var DEFAULT_VALUES = {
-  repeat: false,
-  interpolate: false,
-  edgeClamp: false,
   image: null,
   canvas: null,
+  jsImageData: null,
   imageLoaded: false,
-  jsImageData: null
+  repeat: false,
+  interpolate: false,
+  edgeClamp: false,
+  mipLevel: 0
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -125,15 +271,18 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model);
   macro.algo(publicAPI, model, 6, 0);
   macro.get(publicAPI, model, ['canvas', 'image', 'jsImageData', 'imageLoaded']);
-  macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate']);
+  macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate', 'mipLevel']);
   vtkTexture(publicAPI, model);
 } // ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkTexture'); // ----------------------------------------------------------------------------
+var newInstance = macro.newInstance(extend, 'vtkTexture');
+var STATIC = {
+  generateMipmaps: generateMipmaps
+}; // ----------------------------------------------------------------------------
 
-var vtkTexture$1 = {
+var vtkTexture$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
-};
+}, STATIC);
 
-export { vtkTexture$1 as default, extend, newInstance };
+export { STATIC, vtkTexture$1 as default, extend, newInstance };

package/Rendering/Core/VolumeMapper.d.ts

@@ -94,6 +94,24 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 */
 	getAnisotropy(): number;
 
+	/**
+	 * Get local ambient occlusion flag
+	 * @default false
+	 */
+	getLocalAmbientOcclusion(): boolean;
+
+	/**
+	 * Get kernel size for local ambient occlusion
+	 * @default 15
+	 */
+	getLAOKernelSize(): number;
+
+	/**
+	 * Get kernel radius for local ambient occlusion
+	 * @default 7
+	 */
+	getLAOKernelRadius(): number;
+
 	/**
 	 * 
 	 * @param x 
@@ -186,7 +204,28 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 * Value of -1.0 means light scatters backward, value of 1.0 means light scatters forward.
 	 * @param anisotropy
 	 */
-	setAnisotropy(anisotropy: number): number;
+	setAnisotropy(anisotropy: number): void;
+
+	/**
+	 * Set whether to turn on local ambient occlusion (LAO). LAO is only effective if shading is on and volumeScatterBlendCoef is set to 0.
+	 * LAO effect is added to ambient lighting, so the ambient component of the actor needs to be great than 0.
+	 * @param localAmbientOcclusion
+	 */
+	setLocalAmbientOcclusion(localAmbientOcclusion: boolean): void;
+
+	/**
+	 * Set kernel size for local ambient occlusion. It specifies the number of rays that are randomly sampled in the hemisphere.
+	 * Value is clipped between 1 and 32.
+	 * @param LAOKernelSize
+	 */
+	setLAOKernelSize(LAOKernelSize: number): void;
+
+	/**
+	 * Set kernel radius for local ambient occlusion. It specifies the number of samples that are considered on each random ray.
+	 * Value must be greater than or equal to 1.
+	 * @param LAOKernelRadius
+	 */
+	setLAOKernelRadius(LAOKernelRadius: number): void;
 
 	/**
 	 * 

package/Rendering/Core/VolumeMapper.js

@@ -1,8 +1,12 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { O as createUninitializedBounds, D as clampValue } from '../../Common/Core/Math/index.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';
 
+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; // ----------------------------------------------------------------------------
 // vtkVolumeMapper methods
@@ -12,6 +16,8 @@ function vtkVolumeMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolumeMapper');
 
+  var superClass = _objectSpread({}, publicAPI);
+
   publicAPI.getBounds = function () {
     var input = publicAPI.getInputData();
 
@@ -78,23 +84,27 @@ function vtkVolumeMapper(publicAPI, model) {
   };
 
   publicAPI.setGlobalIlluminationReach = function (gl) {
-    model.globalIlluminationReach = clampValue(gl, 0.0, 1.0);
-    publicAPI.modified();
+    return superClass.setGlobalIlluminationReach(clampValue(gl, 0.0, 1.0));
   };
 
   publicAPI.setVolumetricScatteringBlending = function (vsb) {
-    model.volumetricScatteringBlending = clampValue(vsb, 0.0, 1.0);
-    publicAPI.modified();
+    return superClass.setVolumetricScatteringBlending(clampValue(vsb, 0.0, 1.0));
   };
 
   publicAPI.setVolumeShadowSamplingDistFactor = function (vsdf) {
-    model.volumeShadowSamplingDistFactor = vsdf >= 1.0 ? vsdf : 1.0;
-    publicAPI.modified();
+    return superClass.setVolumeShadowSamplingDistFactor(vsdf >= 1.0 ? vsdf : 1.0);
   };
 
   publicAPI.setAnisotropy = function (at) {
-    model.anisotropy = clampValue(at, -0.99, 0.99);
-    publicAPI.modified();
+    return superClass.setAnisotropy(clampValue(at, -0.99, 0.99));
+  };
+
+  publicAPI.setLAOKernelSize = function (ks) {
+    return superClass.setLAOKernelSize(floor(clampValue(ks, 1, 32)));
+  };
+
+  publicAPI.setLAOKernelRadius = function (kr) {
+    return superClass.setLAOKernelRadius(kr >= 1 ? kr : 1);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -119,14 +129,18 @@ var DEFAULT_VALUES = {
   volumetricScatteringBlending: 0.0,
   globalIlluminationReach: 0.0,
   volumeShadowSamplingDistFactor: 5.0,
-  anisotropy: 0.0
+  anisotropy: 0.0,
+  // local ambient occlusion
+  localAmbientOcclusion: false,
+  LAOKernelSize: 15,
+  LAOKernelRadius: 7
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy']);
+  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.event(publicAPI, model, 'lightingActivated'); // Object methods
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -151,6 +151,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       if (model.renderable.getVolumetricScatteringBlending() < 1.0) {
         FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::SurfaceShadowOn', "#define SurfaceShadowOn").result;
       }
+
+      if (model.renderable.getVolumetricScatteringBlending() === 0.0 && model.renderable.getLocalAmbientOcclusion() && actor.getProperty().getAmbient() > 0.0) {
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::localAmbientOcclusionOn', "#define localAmbientOcclusionOn").result;
+      }
     } // if using gradient opacity define that
 
 
@@ -210,6 +214,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::VolumeShadow::Dec', ["uniform float volumetricScatteringBlending;", "uniform float giReach;", "uniform float volumeShadowSamplingDistFactor;", "uniform float anisotropy;", "uniform float anisotropy2;"], false).result;
     }
 
+    if (model.renderable.getVolumetricScatteringBlending() === 0.0 && model.renderable.getLocalAmbientOcclusion() && actor.getProperty().getAmbient() > 0.0) {
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LAO::Dec', ["uniform int kernelRadius;", "uniform vec2 kernelSample[".concat(model.renderable.getLAOKernelRadius(), "];"), "uniform int kernelSize;"], false).result;
+    }
+
     shaders.Fragment = FSSource;
   };
 
@@ -617,6 +625,20 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       program.setUniformf('anisotropy', model.renderable.getAnisotropy());
       program.setUniformf('anisotropy2', Math.pow(model.renderable.getAnisotropy(), 2.0));
     }
+
+    if (model.renderable.getVolumetricScatteringBlending() === 0.0 && model.renderable.getLocalAmbientOcclusion() && actor.getProperty().getAmbient() > 0.0) {
+      var ks = model.renderable.getLAOKernelSize();
+      program.setUniformi('kernelSize', ks);
+      var kernelSample = [];
+
+      for (var _i2 = 0; _i2 < ks; _i2++) {
+        kernelSample[_i2 * 2] = Math.random() * 0.5;
+        kernelSample[_i2 * 2 + 1] = Math.random() * 0.5;
+      }
+
+      program.setUniform2fv('kernelSample', kernelSample);
+      program.setUniformi('kernelRadius', model.renderable.getLAOKernelRadius());
+    }
   };
 
   publicAPI.setPropertyShaderParameters = function (cellBO, ren, actor) {
@@ -638,19 +660,19 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     // for performance in the fragment shader
 
 
-    for (var _i2 = 0; _i2 < numComp; _i2++) {
-      var target = iComps ? _i2 : 0;
-      var sscale = volInfo.scale[_i2];
+    for (var _i3 = 0; _i3 < numComp; _i3++) {
+      var target = iComps ? _i3 : 0;
+      var sscale = volInfo.scale[_i3];
       var ofun = vprop.getScalarOpacity(target);
       var oRange = ofun.getRange();
       var oscale = sscale / (oRange[1] - oRange[0]);
-      var oshift = (volInfo.offset[_i2] - oRange[0]) / (oRange[1] - oRange[0]);
-      program.setUniformf("oshift".concat(_i2), oshift);
-      program.setUniformf("oscale".concat(_i2), oscale);
+      var oshift = (volInfo.offset[_i3] - oRange[0]) / (oRange[1] - oRange[0]);
+      program.setUniformf("oshift".concat(_i3), oshift);
+      program.setUniformf("oscale".concat(_i3), oscale);
       var cfun = vprop.getRGBTransferFunction(target);
       var cRange = cfun.getRange();
-      program.setUniformf("cshift".concat(_i2), (volInfo.offset[_i2] - cRange[0]) / (cRange[1] - cRange[0]));
-      program.setUniformf("cscale".concat(_i2), sscale / (cRange[1] - cRange[0]));
+      program.setUniformf("cshift".concat(_i3), (volInfo.offset[_i3] - cRange[0]) / (cRange[1] - cRange[0]));
+      program.setUniformf("cscale".concat(_i3), sscale / (cRange[1] - cRange[0]));
     }
 
     if (model.gopacity) {
@@ -1009,9 +1031,9 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         var oRange = ofun.getRange();
         ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1); // adjust for sample distance etc
 
-        for (var _i3 = 0; _i3 < oWidth; ++_i3) {
-          ofTable[c * oWidth * 2 + _i3] = 1.0 - Math.pow(1.0 - tmpTable[_i3], opacityFactor);
-          ofTable[c * oWidth * 2 + _i3 + oWidth] = ofTable[c * oWidth * 2 + _i3];
+        for (var _i4 = 0; _i4 < oWidth; ++_i4) {
+          ofTable[c * oWidth * 2 + _i4] = 1.0 - Math.pow(1.0 - tmpTable[_i4], opacityFactor);
+          ofTable[c * oWidth * 2 + _i4 + oWidth] = ofTable[c * oWidth * 2 + _i4];
         }
       }
 
@@ -1027,8 +1049,8 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       } else {
         var _oTable = new Uint8Array(oSize);
 
-        for (var _i4 = 0; _i4 < oSize; ++_i4) {
-          _oTable[_i4] = 255.0 * ofTable[_i4];
+        for (var _i5 = 0; _i5 < oSize; ++_i5) {
+          _oTable[_i5] = 255.0 * ofTable[_i5];
         }
 
         model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.UNSIGNED_CHAR, _oTable);
@@ -1052,9 +1074,9 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         var cRange = cfun.getRange();
         cfun.getTable(cRange[0], cRange[1], cWidth, _tmpTable, 1);
 
-        for (var _i5 = 0; _i5 < cWidth * 3; ++_i5) {
-          cTable[_c * cWidth * 6 + _i5] = 255.0 * _tmpTable[_i5];
-          cTable[_c * cWidth * 6 + _i5 + cWidth * 3] = 255.0 * _tmpTable[_i5];
+        for (var _i6 = 0; _i6 < cWidth * 3; ++_i6) {
+          cTable[_c * cWidth * 6 + _i6] = 255.0 * _tmpTable[_i6];
+          cTable[_c * cWidth * 6 + _i6 + cWidth * 3] = 255.0 * _tmpTable[_i6];
         }
       }
 
@@ -1081,10 +1103,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       // build the CABO
       var ptsArray = new Float32Array(12);
 
-      for (var _i6 = 0; _i6 < 4; _i6++) {
-        ptsArray[_i6 * 3] = _i6 % 2 * 2 - 1.0;
-        ptsArray[_i6 * 3 + 1] = _i6 > 1 ? 1.0 : -1.0;
-        ptsArray[_i6 * 3 + 2] = -1.0;
+      for (var _i7 = 0; _i7 < 4; _i7++) {
+        ptsArray[_i7 * 3] = _i7 % 2 * 2 - 1.0;
+        ptsArray[_i7 * 3 + 1] = _i7 > 1 ? 1.0 : -1.0;
+        ptsArray[_i7 * 3 + 2] = -1.0;
       }
 
       var cellArray = new Uint16Array(8);