@kitware/vtk.js 27.1.2 → 27.2.0

package/Rendering/Core/ImageMapper.js

@@ -356,7 +356,9 @@ var DEFAULT_VALUES = {
     flip: false
   },
   renderToRectangle: false,
-  sliceAtFocalPoint: false
+  sliceAtFocalPoint: false,
+  preferSizeOverAccuracy: false // Whether to use halfFloat representation of float, when it is inaccurate
+
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -365,7 +367,7 @@ function extend(publicAPI, model) {
 
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['slicingMode']);
-  macro.setGet(publicAPI, model, ['closestIJKAxis', 'renderToRectangle', 'sliceAtFocalPoint']);
+  macro.setGet(publicAPI, model, ['closestIJKAxis', 'renderToRectangle', 'sliceAtFocalPoint', 'preferSizeOverAccuracy']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkImageMapper(publicAPI, model);

package/Rendering/OpenGL/ImageMapper.js

@@ -688,9 +688,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     } // rebuild the VBO if the data has changed
 
 
-    var toString = "".concat(slice, "A").concat(image.getMTime(), "A").concat(imgScalars.getMTime(), "B").concat(publicAPI.getMTime(), "C").concat(model.renderable.getSlicingMode(), "D").concat(actor.getProperty().getMTime());
+    var toString = "".concat(slice, "A").concat(image.getMTime(), "A").concat(imgScalars.getMTime(), "B").concat(publicAPI.getMTime(), "C").concat(model.renderable.getSlicingMode(), "D").concat(actor.getProperty().getInterpolationType());
 
     if (model.VBOBuildString !== toString) {
+      var _model$renderable$get2, _model$renderable;
+
       // Build the VBOs
       var dims = image.getDimensions();
 
@@ -803,7 +805,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         vtkErrorMacro('Reformat slicing not yet supported.');
       }
 
-      model.openGLTexture.create2DFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars);
+      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, (_model$renderable$get2 = (_model$renderable = model.renderable).getPreferSizeOverAccuracy) === null || _model$renderable$get2 === void 0 ? void 0 : _model$renderable$get2.call(_model$renderable));
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();

package/Rendering/OpenGL/Texture.js

@@ -1040,7 +1040,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     return true;
   }
 
-  function checkUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
+  function setUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
     publicAPI.getOpenGLDataType(dataType);
     var useHalfFloat = false;
 
@@ -1049,20 +1049,70 @@ function vtkOpenGLTexture(publicAPI, model) {
     } else {
       var halfFloatExt = model.context.getExtension('OES_texture_half_float');
       useHalfFloat = halfFloatExt && model.openGLDataType === halfFloatExt.HALF_FLOAT_OES;
-    }
-
-    if (!useHalfFloat) {
-      return false;
     } // Don't consider halfFloat and convert back to Float when the range of data does not generate an accurate halfFloat
     // AND it is not preferable to have a smaller texture than an exact texture.
 
 
-    if (!hasExactHalfFloat(offset, scale) && !preferSizeOverAccuracy) {
-      return false;
+    var isHalfFloat = useHalfFloat && (hasExactHalfFloat(offset, scale) || preferSizeOverAccuracy);
+    model.useHalfFloat = isHalfFloat;
+  }
+
+  function processDataArray(dataArray, preferSizeOverAccuracy) {
+    var numComps = dataArray.getNumberOfComponents();
+    var dataType = dataArray.getDataType();
+    var data = dataArray.getData(); // Compute min max from array
+    // Using the vtkDataArray.getRange() enables caching
+
+    var minArray = new Array(numComps);
+    var maxArray = new Array(numComps);
+
+    for (var c = 0; c < numComps; ++c) {
+      var _dataArray$getRange = dataArray.getRange(c),
+          _dataArray$getRange2 = _slicedToArray(_dataArray$getRange, 2),
+          min = _dataArray$getRange2[0],
+          max = _dataArray$getRange2[1];
+
+      minArray[c] = min;
+      maxArray[c] = max;
     }
 
-    return true;
-  } //----------------------------------------------------------------------------
+    var scaleOffsets = computeScaleOffsets(minArray, maxArray, numComps); // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
+
+    setUseHalfFloat(dataType, scaleOffsets.offset, scaleOffsets.scale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
+    // we need to use another type
+
+    if (!model.useHalfFloat) {
+      publicAPI.getOpenGLDataType(dataType, true);
+    }
+
+    return {
+      numComps: numComps,
+      dataType: dataType,
+      data: data,
+      scaleOffsets: scaleOffsets
+    };
+  }
+
+  publicAPI.create2DFilterableFromRaw = function (width, height, numberOfComponents, dataType, values) {
+    var preferSizeOverAccuracy = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+    return publicAPI.create2DFilterableFromDataArray(width, height, vtkDataArray.newInstance({
+      numberOfComponents: numberOfComponents,
+      dataType: dataType,
+      values: values
+    }), preferSizeOverAccuracy);
+  };
+
+  publicAPI.create2DFilterableFromDataArray = function (width, height, dataArray) {
+    var preferSizeOverAccuracy = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+    var _processDataArray = processDataArray(dataArray, preferSizeOverAccuracy),
+        numComps = _processDataArray.numComps,
+        dataType = _processDataArray.dataType,
+        data = _processDataArray.data;
+
+    publicAPI.create2DFromRaw(width, height, numComps, dataType, data);
+  }; //----------------------------------------------------------------------------
 
 
   publicAPI.create3DFromRaw = function (width, height, depth, numComps, dataType, data) {
@@ -1131,37 +1181,20 @@ function vtkOpenGLTexture(publicAPI, model) {
 
   publicAPI.create3DFilterableFromDataArray = function (width, height, depth, dataArray) {
     var preferSizeOverAccuracy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-    var numComps = dataArray.getNumberOfComponents();
-    var dataType = dataArray.getDataType();
-    var data = dataArray.getData();
-    var numPixelsIn = width * height * depth; // Compute min max from array
-    // Using the vtkDataArray.getRange() enables caching
-
-    var minArray = new Array(numComps);
-    var maxArray = new Array(numComps);
-
-    for (var c = 0; c < numComps; ++c) {
-      var _dataArray$getRange = dataArray.getRange(c),
-          _dataArray$getRange2 = _slicedToArray(_dataArray$getRange, 2),
-          min = _dataArray$getRange2[0],
-          max = _dataArray$getRange2[1];
-
-      minArray[c] = min;
-      maxArray[c] = max;
-    }
-
-    var scaleOffsets = computeScaleOffsets(minArray, maxArray, numComps); // Create a copy of scale and offset to avoid aliasing issues
-    // Original is read only, copy is read/write
-    // Use the copy as volumeInfo.scale and volumeInfo.offset
 
-    var scaleOffsetsCopy = structuredClone(scaleOffsets); // initialize offset/scale
+    var _processDataArray2 = processDataArray(dataArray, preferSizeOverAccuracy),
+        numComps = _processDataArray2.numComps,
+        dataType = _processDataArray2.dataType,
+        data = _processDataArray2.data,
+        scaleOffsets = _processDataArray2.scaleOffsets;
 
+    var numPixelsIn = width * height * depth;
     var offset = [];
     var scale = [];
 
-    for (var _c = 0; _c < numComps; ++_c) {
-      offset[_c] = 0.0;
-      scale[_c] = 1.0;
+    for (var c = 0; c < numComps; ++c) {
+      offset[c] = 0.0;
+      scale[c] = 1.0;
     } // store the information, we will need it later
     // offset and scale are the offset and scale required to get
     // the texture value back to data values ala
@@ -1177,29 +1210,24 @@ function vtkOpenGLTexture(publicAPI, model) {
       width: width,
       height: height,
       depth: depth
-    }; // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
-    // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
-
-    model.useHalfFloat = checkUseHalfFloat(dataType, scaleOffsets.offset, scaleOffsets.scale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
-    // we need to use another type
-
-    if (!model.useHalfFloat) {
-      publicAPI.getOpenGLDataType(dataType, true);
-    } // WebGL2 path, we have 3d textures etc
+    }; // Create a copy of scale and offset to avoid aliasing issues
+    // Original is read only, copy is read/write
+    // Use the copy as volumeInfo.scale and volumeInfo.offset
 
+    var scaleOffsetsCopy = structuredClone(scaleOffsets); // WebGL2 path, we have 3d textures etc
 
     if (model._openGLRenderWindow.getWebgl2()) {
       if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.SHORT) {
-        for (var _c2 = 0; _c2 < numComps; ++_c2) {
-          model.volumeInfo.scale[_c2] = 32767.0;
+        for (var _c = 0; _c < numComps; ++_c) {
+          model.volumeInfo.scale[_c] = 32767.0;
         }
 
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
       }
 
       if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
-        for (var _c3 = 0; _c3 < numComps; ++_c3) {
-          model.volumeInfo.scale[_c3] = 65535.0;
+        for (var _c2 = 0; _c2 < numComps; ++_c2) {
+          model.volumeInfo.scale[_c2] = 65535.0;
         }
 
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
@@ -1210,8 +1238,8 @@ function vtkOpenGLTexture(publicAPI, model) {
       }
 
       if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
-        for (var _c4 = 0; _c4 < numComps; ++_c4) {
-          model.volumeInfo.scale[_c4] = 255.0;
+        for (var _c3 = 0; _c3 < numComps; ++_c3) {
+          model.volumeInfo.scale[_c3] = 255.0;
         }
 
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
@@ -1247,9 +1275,9 @@ function vtkOpenGLTexture(publicAPI, model) {
     var dataTypeToUse = VtkDataTypes.UNSIGNED_CHAR; // unsigned char gets used as is
 
     if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
-      for (var _c5 = 0; _c5 < numComps; ++_c5) {
-        scaleOffsetsCopy.offset[_c5] = 0.0;
-        scaleOffsetsCopy.scale[_c5] = 255.0;
+      for (var _c4 = 0; _c4 < numComps; ++_c4) {
+        scaleOffsetsCopy.offset[_c4] = 0.0;
+        scaleOffsetsCopy.scale[_c4] = 255.0;
       }
     } else if (model.context.getExtension('OES_texture_float') && model.context.getExtension('OES_texture_float_linear')) {
       // use float textures scaled to 0.0 to 1.0

package/package.json

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