@kitware/vtk.js 26.0.0-beta.2 → 26.0.0-beta.3

package/Imaging/Core/ImageReslice.js

@@ -1,7 +1,9 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4, vec4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import macro, { vtkWarningMacro } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
+import { g as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
@@ -15,14 +17,16 @@ 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 SlabMode = Constants.SlabMode;
-var capitalize = macro.capitalize,
-    vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // vtkImageReslice methods
 // ----------------------------------------------------------------------------
 
 function vtkImageReslice(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageReslice');
+
+  var superClass = _objectSpread({}, publicAPI);
+
   var indexMatrix = null;
   var optimizedTransform = null;
 
@@ -97,6 +101,16 @@ function vtkImageReslice(publicAPI, model) {
     getImageResliceSlabTrap(tmpPtr, inComponents, sampleCount, f);
   }
 
+  publicAPI.getMTime = function () {
+    var mTime = superClass.getMTime();
+
+    if (model.resliceTransform) {
+      mTime = Math.max(mTime, model.resliceTransform.getMTime());
+    }
+
+    return mTime;
+  };
+
   publicAPI.setResliceAxes = function (resliceAxes) {
     if (!model.resliceAxes) {
       model.resliceAxes = mat4.identity(new Float64Array(16));
@@ -131,12 +145,10 @@ function vtkImageReslice(publicAPI, model) {
     var outSpacing = [1, 1, 1];
     var outWholeExt = [0, 0, 0, 0, 0, 0];
     var outDims = [0, 0, 0];
-    var matrix = null;
+    var matrix = mat4.identity(new Float64Array(16));
 
     if (model.resliceAxes) {
-      matrix = model.resliceAxes;
-    } else {
-      matrix = mat4.identity(new Float64Array(16));
+      mat4.multiply(matrix, matrix, model.resliceAxes);
     }
 
     var imatrix = new Float64Array(16);
@@ -236,6 +248,11 @@ function vtkImageReslice(publicAPI, model) {
     output.setDimensions(outDims);
     output.setOrigin(outOrigin);
     output.setSpacing(outSpacing);
+
+    if (model.outputDirection) {
+      output.setDirection(model.outputDirection);
+    }
+
     output.getPointData().setScalars(outScalars);
     publicAPI.getIndexMatrix(input, output);
     var interpolationMode = model.interpolationMode;
@@ -340,7 +357,7 @@ function vtkImageReslice(publicAPI, model) {
     var floatPtr = null;
 
     if (!optimizeNearest) {
-      floatPtr = new Float64Array(inComponents * (outExt[1] - outExt[0]));
+      floatPtr = new Float64Array(inComponents * (outExt[1] - outExt[0] + nsamples));
     }
 
     var background = macro.newTypedArray(inputScalarType, model.backgroundColor); // set color for area outside of input volume extent
@@ -577,6 +594,20 @@ function vtkImageReslice(publicAPI, model) {
       }
     }
   };
+  /**
+   * The transform matrix supplied by the user converts output coordinates
+   * to input coordinates.
+   * To speed up the pixel lookup, the following function provides a
+   * matrix which converts output pixel indices to input pixel indices.
+   * This will also concatenate the ResliceAxes and the ResliceTransform
+   * if possible (if the ResliceTransform is a 4x4 matrix transform).
+   * If it does, this->OptimizedTransform will be set to nullptr, otherwise
+   * this->OptimizedTransform will be equal to this->ResliceTransform.
+   * @param {vtkPolyData} input
+   * @param {vtkPolyData} output
+   * @returns
+   */
+
 
   publicAPI.getIndexMatrix = function (input, output) {
     // first verify that we have to update the matrix
@@ -586,6 +617,7 @@ function vtkImageReslice(publicAPI, model) {
 
     var inOrigin = input.getOrigin();
     var inSpacing = input.getSpacing();
+    var inDirection = input.getDirection();
     var outOrigin = output.getOrigin();
     var outSpacing = output.getSpacing();
     var transform = mat4.identity(new Float64Array(16));
@@ -596,14 +628,29 @@ function vtkImageReslice(publicAPI, model) {
       mat4.copy(transform, model.resliceAxes);
     }
 
-    if (model.resliceTransform) ; // check to see if we have an identity matrix
+    if (model.resliceTransform) {
+      if (model.resliceTransform.isA('vtkHomogeneousTransform')) {
+        // transform->PostMultiply();
+        // transform->Concatenate(
+        // mat4.multiply(transform, transform, model.resliceTransform.getMatrix());
+        mat4.multiply(transform, model.resliceTransform.getMatrix(), transform);
+      } else {
+        // TODO
+        vtkWarningMacro('Non homogeneous transform have not yet been ported');
+      }
+    }
+
+    if (!vtkMath.isIdentity3x3(inDirection)) {
+      var imageTransform = vtkMatrixBuilder.buildFromRadian().translate(inOrigin[0], inOrigin[1], inOrigin[2]).multiply3x3(inDirection).translate(-inOrigin[0], -inOrigin[1], -inOrigin[2]);
+      mat4.multiply(transform, imageTransform.getMatrix(), transform);
+    } // check to see if we have an identity matrix
 
 
-    var isIdentity = publicAPI.isIdentityMatrix(transform); // the outMatrix takes OutputData indices to OutputData coordinates,
+    var isIdentity = vtkMath.isIdentity(transform); // the outMatrix takes OutputData indices to OutputData coordinates,
     // the inMatrix takes InputData coordinates to InputData indices
 
     for (var i = 0; i < 3; i++) {
-      if ((inSpacing[i] !== outSpacing[i] || inOrigin[i] !== outOrigin[i]) || optimizedTransform !== null ) {
+      if ((inSpacing[i] !== outSpacing[i] || inOrigin[i] !== outOrigin[i]) || optimizedTransform != null ) {
         isIdentity = false;
       }
 
@@ -633,6 +680,7 @@ function vtkImageReslice(publicAPI, model) {
   publicAPI.getAutoCroppedOutputBounds = function (input) {
     var inOrigin = input.getOrigin();
     var inSpacing = input.getSpacing();
+    var inDirection = input.getDirection();
     var dims = input.getDimensions();
     var inWholeExt = [0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1];
     var matrix = new Float64Array(16);
@@ -643,6 +691,18 @@ function vtkImageReslice(publicAPI, model) {
       mat4.identity(matrix);
     }
 
+    var transform = null;
+
+    if (model.resliceTransform) {
+      transform = model.resliceTransform.getInverse();
+    }
+
+    var imageTransform = null;
+
+    if (!vtkMath.isIdentity3x3(inDirection)) {
+      imageTransform = vtkMatrixBuilder.buildFromRadian().translate(inOrigin[0], inOrigin[1], inOrigin[2]).multiply3x3(inDirection).translate(-inOrigin[0], -inOrigin[1], -inOrigin[2]).invert().getMatrix();
+    }
+
     var bounds = [Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE];
     var point = [0, 0, 0, 0];
 
@@ -652,7 +712,13 @@ function vtkImageReslice(publicAPI, model) {
       point[2] = inOrigin[2] + inWholeExt[4 + Math.floor(i / 4) % 2] * inSpacing[2];
       point[3] = 1.0;
 
-      if (model.resliceTransform) ;
+      if (imageTransform) {
+        vec4.transformMat4(point, point, imageTransform);
+      }
+
+      if (model.resliceTransform) {
+        transform.transformPoint(point, point);
+      }
 
       vec4.transformMat4(point, point, matrix);
       var f = 1.0 / point[3];
@@ -931,27 +997,6 @@ function vtkImageReslice(publicAPI, model) {
 
     return 1;
   };
-}
-
-function setNullArray(publicAPI, model, fieldNames) {
-  fieldNames.forEach(function (field) {
-    var setterName = "set".concat(capitalize(field));
-    var superSet = publicAPI[setterName];
-
-    publicAPI[setterName] = function () {
-      if (arguments.length === 1 && (arguments.length <= 0 ? undefined : arguments[0]) == null || model[field] == null) {
-        if ((arguments.length <= 0 ? undefined : arguments[0]) !== model[field]) {
-          model[field] = arguments.length <= 0 ? undefined : arguments[0];
-          publicAPI.modified();
-          return true;
-        }
-
-        return null;
-      }
-
-      return superSet.apply(void 0, arguments);
-    };
-  });
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -965,6 +1010,8 @@ var DEFAULT_VALUES = {
   // automatically computed if null
   outputOrigin: null,
   // automatically computed if null
+  outputDirection: null,
+  // identity if null
   outputExtent: null,
   // automatically computed if null
   outputScalarType: null,
@@ -987,7 +1034,7 @@ var DEFAULT_VALUES = {
   scalarScale: 1,
   backgroundColor: [0, 0, 0, 0],
   resliceAxes: null,
-  resliceTransform: null,
+  // resliceTransform: null,
   interpolator: vtkImageInterpolator.newInstance(),
   usePermuteExecute: false // no supported yet
 
@@ -1000,10 +1047,11 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
 
   macro.algo(publicAPI, model, 1, 1);
-  macro.setGet(publicAPI, model, ['outputDimensionality', 'outputScalarType', 'scalarShift', 'scalarScale', 'transformInputSampling', 'autoCropOutput', 'wrap', 'mirror', 'border', 'backgroundColor', 'interpolationMode', 'slabMode', 'slabTrapezoidIntegration', 'slabNumberOfSlices', 'slabSliceSpacingFraction']);
+  macro.setGet(publicAPI, model, ['outputDimensionality', 'outputScalarType', 'scalarShift', 'scalarScale', 'transformInputSampling', 'autoCropOutput', 'wrap', 'mirror', 'border', 'interpolationMode', 'resliceTransform', 'slabMode', 'slabTrapezoidIntegration', 'slabNumberOfSlices', 'slabSliceSpacingFraction']);
   macro.setGetArray(publicAPI, model, ['outputOrigin', 'outputSpacing'], 3);
   macro.setGetArray(publicAPI, model, ['outputExtent'], 6);
-  setNullArray(publicAPI, model, ['outputOrigin', 'outputSpacing', 'outputExtent']);
+  macro.setGetArray(publicAPI, model, ['outputDirection'], 9);
+  macro.setGetArray(publicAPI, model, ['backgroundColor'], 4);
   macro.get(publicAPI, model, ['resliceAxes']); // Object specific methods
 
   macro.algo(publicAPI, model, 1, 1);

package/Rendering/Core/ColorTransferFunction.d.ts

@@ -1,3 +1,4 @@
+import vtkDataArray from './../../Common/Core/DataArray';
 import { vtkObject } from './../../interfaces';
 import { ColorSpace, Scale } from './ColorTransferFunction/Constants';
 
@@ -201,6 +202,25 @@ export interface vtkColorTransferFunction extends vtkObject {
     withAlpha: boolean
   ): Float32Array;
 
+  /**
+   * Construct a color transfer function from a vtkDataArray.
+   * The order of values depends on the number of components
+   * of the array.
+   * 3 -> RGB
+   * 4 -> XRGB
+   * 5 -> RGBMS
+   * 6 -> XRGBMS
+   * 
+   * X represents the input value to a function
+   * RGB represents the red, green, and blue value output
+   * M represents the midpoint
+   * S represents sharpness
+   * @param {vtkDataArray} array
+   */
+   buildFunctionFromArray(
+    array: vtkDataArray,
+  ): void;
+
   /**
    * Construct a color transfer function from a table.
    * @param {Number} xStart The index of the first point.

package/Rendering/Core/ColorTransferFunction.js

@@ -849,6 +849,69 @@ function vtkColorTransferFunction(publicAPI, model) {
 
     model.buildTime.modified();
     return model.table;
+  };
+
+  publicAPI.buildFunctionFromArray = function (array) {
+    publicAPI.removeAllPoints();
+    var numComponents = array.getNumberOfComponents();
+
+    for (var i = 0; i < array.getNumberOfTuples(); i++) {
+      switch (numComponents) {
+        case 3:
+          {
+            model.nodes.push({
+              x: i,
+              r: array.getComponent(i, 0),
+              g: array.getComponent(i, 1),
+              b: array.getComponent(i, 2),
+              midpoint: 0.5,
+              sharpness: 0.0
+            });
+            break;
+          }
+
+        case 4:
+          {
+            model.nodes.push({
+              x: array.getComponent(i, 0),
+              r: array.getComponent(i, 1),
+              g: array.getComponent(i, 2),
+              b: array.getComponent(i, 3),
+              midpoint: 0.5,
+              sharpness: 0.0
+            });
+            break;
+          }
+
+        case 5:
+          {
+            model.nodes.push({
+              x: i,
+              r: array.getComponent(i, 0),
+              g: array.getComponent(i, 1),
+              b: array.getComponent(i, 2),
+              midpoint: array.getComponent(i, 4),
+              sharpness: array.getComponent(i, 5)
+            });
+            break;
+          }
+
+        case 6:
+          {
+            model.nodes.push({
+              x: array.getComponent(i, 0),
+              r: array.getComponent(i, 1),
+              g: array.getComponent(i, 2),
+              b: array.getComponent(i, 3),
+              midpoint: array.getComponent(i, 4),
+              sharpness: array.getComponent(i, 5)
+            });
+            break;
+          }
+      }
+    }
+
+    publicAPI.sortAndUpdateRange();
   }; //----------------------------------------------------------------------------
 
 
@@ -1125,6 +1188,8 @@ function vtkColorTransferFunction(publicAPI, model) {
 
 
   publicAPI.applyColorMap = function (colorMap) {
+    var oldColorSpace = JSON.stringify(model.colorSpace);
+
     if (colorMap.ColorSpace) {
       model.colorSpace = ColorSpace[colorMap.ColorSpace.toUpperCase()];
 
@@ -1134,6 +1199,9 @@ function vtkColorTransferFunction(publicAPI, model) {
       }
     }
 
+    var isModified = oldColorSpace !== JSON.stringify(model.colorSpace);
+    var oldNanColor = isModified || JSON.stringify(model.nanColor);
+
     if (colorMap.NanColor) {
       model.nanColor = [].concat(colorMap.NanColor);
 
@@ -1142,6 +1210,9 @@ function vtkColorTransferFunction(publicAPI, model) {
       }
     }
 
+    isModified = isModified || oldNanColor !== JSON.stringify(model.nanColor);
+    var oldNodes = isModified || JSON.stringify(model.nodes);
+
     if (colorMap.RGBPoints) {
       var size = colorMap.RGBPoints.length;
       model.nodes = [];
@@ -1158,14 +1229,12 @@ function vtkColorTransferFunction(publicAPI, model) {
           sharpness: sharpness
         });
       }
-    } // FIXME: not supported ?
-    // if (colorMap.IndexedColors) {
-    // }
-    // if (colorMap.Annotations) {
-    // }
-
+    }
 
-    publicAPI.sortAndUpdateRange();
+    var modifiedInvoked = publicAPI.sortAndUpdateRange();
+    var callModified = !modifiedInvoked && (isModified || oldNodes !== JSON.stringify(model.nodes));
+    if (callModified) publicAPI.modified();
+    return modifiedInvoked || callModified;
   };
 } // ----------------------------------------------------------------------------
 // Object factory

package/Rendering/Core/Prop3D.js

@@ -1,7 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { B as degreesFromRadians, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { B as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
 // vtkProp3D methods
@@ -83,8 +83,13 @@ function vtkProp3D(publicAPI, model) {
   };
 
   publicAPI.setUserMatrix = function (matrix) {
+    if (areMatricesEqual(model.userMatrix, matrix)) {
+      return false;
+    }
+
     mat4.copy(model.userMatrix, matrix);
     publicAPI.modified();
+    return true;
   };
 
   publicAPI.getMatrix = function () {

package/Rendering/Core/VolumeProperty.js

@@ -243,7 +243,8 @@ var DEFAULT_VALUES = {
   specular: 0.2,
   specularPower: 10.0,
   useLabelOutline: false,
-  labelOutlineThickness: 1
+  labelOutlineThickness: 1,
+  labelOutlineOpacity: 1.0
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -273,7 +274,7 @@ function extend(publicAPI, model) {
     }
   }
 
-  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineThickness']); // Object methods
+  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineThickness', 'labelOutlineOpacity']); // Object methods
 
   vtkVolumeProperty(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat3, mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, setGet, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
@@ -16,6 +17,9 @@ import { registerOverride } from './ViewNodeFactory.js';
 import { PassTypes } from './HardwareSelector/Constants.js';
 import vtkDataSet from '../../Common/DataModel/DataSet.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 FieldAssociations = vtkDataSet.FieldAssociations;
 /* eslint-disable no-lonely-if */
 
@@ -1284,15 +1288,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         } else {
           // if we have edge visibility build the edge VBOs
           if (drawSurfaceWithEdges) {
-            model.primitives[i].getCABO().createVBO(primitives[i].cells, primitives[i].inRep, Representation.WIREFRAME, {
-              points: points,
-              normals: n,
+            options.cellOffset += model.primitives[i].getCABO().createVBO(primitives[i].cells, primitives[i].inRep, Representation.WIREFRAME, _objectSpread(_objectSpread({}, options), {}, {
               tcoords: null,
               colors: null,
-              cellOffset: 0,
               haveCellScalars: false,
               haveCellNormals: false
-            });
+            }), model.selectionWebGLIdsToVTKIds);
+            options.vertexOffset += model.primitives[i].getCABO().getElementCount();
           } else {
             // otherwise free them
             model.primitives[i].releaseGraphicsResources();

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -327,7 +327,18 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	setViewStream(stream: vtkViewStream): boolean;
 
 	/**
-	 *
+	 * Sets the pixel width and height of the rendered image.  
+	 * 
+	 * WebGL and WebGPU render windows apply these values to 
+	 * the width and height attribute of the canvas element.
+	 * 
+	 * To match the device resolution in browser environments, 
+	 * multiply the container size by `window.devicePixelRatio`
+	 * `apiSpecificRenderWindow.setSize(Math.floor(containerWidth * devicePixelRatio), Math.floor(containerHeight * devicePixelRatio));
+	 * See the VTK.js FullscreenRenderWindow class for an example.
+	 * 
+	 * @see getComputedDevicePixelRatio()
+	 * 
 	 * @param {Vector2} size 
 	 */
 	setSize(size: Vector2): void;
@@ -361,6 +372,19 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 *
 	 */
 	getVrResolution(): Vector2;
+
+	/**
+	 * Scales the size of a browser CSS pixel to a rendered canvas pixel.  
+	 * `const renderedPixelWidth = cssPixelWidth * apiRenderWindow.getComputedDevicePixelRatio()`
+	 * Use to scale rendered objects to a consistent perceived size or DOM pixel position.
+	 * 
+	 * Rather than using window.devicePixelRatio directly, the device pixel ratio is inferred
+	 * from the container CSS pixel size and rendered image pixel size. The user directly sets the rendered pixel size.
+	 * 
+	 * @see setSize()
+	 * @see getContainerSize()
+	 */
+	getComputedDevicePixelRatio(): number;
 }
 
 /**

package/Rendering/OpenGL/Texture.js

@@ -298,7 +298,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.getInternalFormat = function (vtktype, numComps) {
-    if (!model.internalFormat) {
+    if (!model._forceInternalFormat) {
       model.internalFormat = publicAPI.getDefaultInternalFormat(vtktype, numComps);
     }
 
@@ -332,6 +332,8 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.setInternalFormat = function (iFormat) {
+    model._forceInternalFormat = true;
+
     if (iFormat !== model.internalFormat) {
       model.internalFormat = iFormat;
       publicAPI.modified();
@@ -388,6 +390,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.resetFormatAndType = function () {
     model.format = 0;
     model.internalFormat = 0;
+    model._forceInternalFormat = false;
     model.openGLDataType = 0;
   }; //----------------------------------------------------------------------------
 
@@ -591,8 +594,14 @@ function vtkOpenGLTexture(publicAPI, model) {
     // then the data array must be u16
 
 
-    var halfFloatExt = model.context.getExtension('OES_texture_half_float');
-    var halfFloat = model._openGLRenderWindow.getWebgl2() ? model.openGLDataType === model.context.HALF_FLOAT : halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
+    var halfFloat = false;
+
+    if (model._openGLRenderWindow.getWebgl2()) {
+      halfFloat = model.openGLDataType === model.context.HALF_FLOAT;
+    } else {
+      var halfFloatExt = model.context.getExtension('OES_texture_half_float');
+      halfFloat = halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
+    }
 
     if (halfFloat) {
       for (var _idx2 = 0; _idx2 < data.length; _idx2++) {
@@ -993,8 +1002,14 @@ function vtkOpenGLTexture(publicAPI, model) {
   function checkUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
     var useHalfFloatType = true;
     publicAPI.getOpenGLDataType(dataType, useHalfFloatType);
-    var halfFloatExt = model.context.getExtension('OES_texture_half_float');
-    var useHalfFloat = model._openGLRenderWindow.getWebgl2() ? model.openGLDataType === model.context.HALF_FLOAT : halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
+    var useHalfFloat = false;
+
+    if (model._openGLRenderWindow.getWebgl2()) {
+      useHalfFloat = model.openGLDataType === model.context.HALF_FLOAT;
+    } else {
+      var halfFloatExt = model.context.getExtension('OES_texture_half_float');
+      useHalfFloat = halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
+    }
 
     if (!useHalfFloat) {
       return false;
@@ -1287,7 +1302,8 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  // _openGLRenderWindow: null,
+  _openGLRenderWindow: null,
+  _forceInternalFormat: false,
   context: null,
   handle: 0,
   sendParametersTime: null,

package/Rendering/OpenGL/VolumeMapper.js

@@ -461,7 +461,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     var i2wmat4 = model.currentInput.getIndexToWorld();
     mat4.multiply(model.idxToView, model.modelToView, i2wmat4);
     mat3.multiply(model.idxNormalMatrix, keyMats.normalMatrix, actMats.normalMatrix);
-    mat3.multiply(model.idxNormalMatrix, model.idxNormalMatrix, model.currentInput.getDirection());
+    mat3.multiply(model.idxNormalMatrix, model.idxNormalMatrix, model.currentInput.getDirectionByReference());
     var maxSamples = vec3.length(vsize) / model.renderable.getSampleDistance();
 
     if (maxSamples > model.renderable.getMaximumSamplesPerRay()) {
@@ -717,7 +717,9 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
     if (vtkImageLabelOutline === true) {
       var labelOutlineThickness = actor.getProperty().getLabelOutlineThickness();
+      var labelOutlineOpacity = actor.getProperty().getLabelOutlineOpacity();
       program.setUniformi('outlineThickness', labelOutlineThickness);
+      program.setUniformf('outlineOpacity', labelOutlineOpacity);
     }
 
     if (model.lastLightComplexity > 0) {