@kitware/vtk.js 27.1.0 → 27.1.1

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -222,7 +222,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         model.openGLTexture.getOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
         model.openGLTexture.releaseGraphicsResources(model._openGLRenderWindow);
         model.openGLTexture.resetFormatAndType();
-        model.openGLTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], numComp, scalars.getDataType(), scalars.getData());
+        model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
         model.openGLTextureString = _toString;
       }
     }

package/Rendering/OpenGL/Texture.js

@@ -1,8 +1,9 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { newInstance as newInstance$1, obj, set, setGet, get, moveToProtected, newTypedArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
-import vtkDataArray, { STATIC } from '../../Common/Core/DataArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
 import { Q as isPowerOfTwo, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -1005,29 +1006,16 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     publicAPI.deactivate();
     return true;
-  };
+  }; // Compute scale and offset per component from min and max per component
 
-  function computeScaleOffsets(numComps, numPixelsIn, data) {
-    // compute min and max values per component
-    var min = [];
-    var max = [];
 
-    for (var c = 0; c < numComps; ++c) {
-      var range = STATIC.fastComputeRange(data, c, numComps);
-      min[c] = range.min;
-      max[c] = range.max;
-    }
+  function computeScaleOffsets(min, max, numComps) {
+    var offset = new Array(numComps);
+    var scale = new Array(numComps);
 
-    var offset = [];
-    var scale = [];
-
-    for (var _c = 0; _c < numComps; ++_c) {
-      if (min[_c] === max[_c]) {
-        max[_c] = min[_c] + 1.0;
-      }
-
-      offset[_c] = min[_c];
-      scale[_c] = max[_c] - min[_c];
+    for (var c = 0; c < numComps; ++c) {
+      offset[c] = min[c];
+      scale[c] = max[c] - min[c] || 1.0;
     }
 
     return {
@@ -1127,18 +1115,53 @@ function vtkOpenGLTexture(publicAPI, model) {
     return true;
   }; //----------------------------------------------------------------------------
   // This method simulates a 3D texture using 2D
+  // Prefer create3DFilterableFromDataArray to enable caching of min and max values
 
 
-  publicAPI.create3DFilterableFromRaw = function (width, height, depth, numComps, dataType, data) {
+  publicAPI.create3DFilterableFromRaw = function (width, height, depth, numberOfComponents, dataType, values) {
     var preferSizeOverAccuracy = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-    var numPixelsIn = width * height * depth; // initialize offset/scale
+    return publicAPI.create3DFilterableFromDataArray(width, height, depth, vtkDataArray.newInstance({
+      numberOfComponents: numberOfComponents,
+      dataType: dataType,
+      values: values
+    }), preferSizeOverAccuracy);
+  }; //----------------------------------------------------------------------------
+  // This method create a 3D texture from dimensions and a DataArray
+
+
+  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 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
@@ -1149,21 +1172,15 @@ function vtkOpenGLTexture(publicAPI, model) {
     model.volumeInfo = {
       scale: scale,
       offset: offset,
+      dataComputedScale: scaleOffsets.scale,
+      dataComputedOffset: scaleOffsets.offset,
       width: width,
       height: height,
       depth: depth
-    }; // Check if we can accurately use halfFloat or whether it is preferred to have a smaller size texture
-    // compute min and max values
-
-    var _computeScaleOffsets = computeScaleOffsets(numComps, numPixelsIn, data),
-        computedOffset = _computeScaleOffsets.offset,
-        computedScale = _computeScaleOffsets.scale;
-
-    model.volumeInfo.dataComputedScale = computedScale;
-    model.volumeInfo.dataComputedOffset = computedOffset; // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
+    }; // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
     // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
 
-    model.useHalfFloat = checkUseHalfFloat(dataType, computedOffset, computedScale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
+    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) {
@@ -1201,19 +1218,19 @@ function vtkOpenGLTexture(publicAPI, model) {
       } // otherwise convert to float
 
 
-      var _newArray = new Float32Array(numPixelsIn * numComps); // compute min and max values
+      var _newArray = new Float32Array(numPixelsIn * numComps); // use computed scale and offset
 
 
-      model.volumeInfo.offset = computedOffset;
-      model.volumeInfo.scale = computedScale;
+      model.volumeInfo.offset = scaleOffsetsCopy.offset;
+      model.volumeInfo.scale = scaleOffsetsCopy.scale;
       var count = 0;
-      var scaleInverse = computedScale.map(function (s) {
+      var scaleInverse = scaleOffsetsCopy.scale.map(function (s) {
         return 1 / s;
       });
 
       for (var i = 0; i < numPixelsIn; i++) {
         for (var nc = 0; nc < numComps; nc++) {
-          _newArray[count] = (data[count] - computedOffset[nc]) * scaleInverse[nc];
+          _newArray[count] = (data[count] - scaleOffsetsCopy.offset[nc]) * scaleInverse[nc];
           count++;
         }
       }
@@ -1221,10 +1238,7 @@ function vtkOpenGLTexture(publicAPI, model) {
       return publicAPI.create3DFromRaw(width, height, depth, numComps, VtkDataTypes.FLOAT, _newArray);
     } // not webgl2, deal with webgl1, no 3d textures
     // and maybe no float textures
-    // compute min and max values
-
 
-    var res = computeScaleOffsets(numComps, numPixelsIn, data);
 
     var volCopyData = function volCopyData(outArray, outIdx, inValue, smin, smax) {
       outArray[outIdx] = inValue;
@@ -1234,8 +1248,8 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
       for (var _c5 = 0; _c5 < numComps; ++_c5) {
-        res.offset[_c5] = 0.0;
-        res.scale[_c5] = 255.0;
+        scaleOffsetsCopy.offset[_c5] = 0.0;
+        scaleOffsetsCopy.scale[_c5] = 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
@@ -1310,8 +1324,8 @@ function vtkOpenGLTexture(publicAPI, model) {
     model.volumeInfo.yreps = yreps;
     model.volumeInfo.xstride = xstride;
     model.volumeInfo.ystride = ystride;
-    model.volumeInfo.offset = res.offset;
-    model.volumeInfo.scale = res.scale; // OK stuff the data into the 2d TEXTURE
+    model.volumeInfo.offset = scaleOffsetsCopy.offset;
+    model.volumeInfo.scale = scaleOffsetsCopy.scale; // OK stuff the data into the 2d TEXTURE
     // first allocate the new texture
 
     var newArray;
@@ -1340,7 +1354,7 @@ function vtkOpenGLTexture(publicAPI, model) {
           for (var tileX = 0; tileX < tileWidth; tileX++) {
             // copy value
             for (var _nc = 0; _nc < numComps; _nc++) {
-              volCopyData(newArray, outIdx, data[inOffset + xstride * tileX * numComps + _nc], res.offset[_nc], res.scale[_nc]);
+              volCopyData(newArray, outIdx, data[inOffset + xstride * tileX * numComps + _nc], scaleOffsetsCopy.offset[_nc], scaleOffsetsCopy.scale[_nc]);
               outIdx++;
             }
           }

package/Rendering/OpenGL/VolumeMapper.js

@@ -1127,7 +1127,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       model.scalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
       model.scalarTexture.resetFormatAndType();
-      model.scalarTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], numComp, scalars.getDataType(), scalars.getData(), model.renderable.getPreferSizeOverAccuracy());
+      model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
       model.scalarTextureString = toString;
     }
 

package/package.json

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