@kitware/vtk.js 25.14.2 → 25.15.1

package/Rendering/OpenGL/ImageMapper.js

@@ -560,6 +560,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
     }
 
+    var dataType = imgScalars.getDataType();
     var numComp = imgScalars.getNumberOfComponents();
     var iComps = actorProperty.getIndependentComponents();
     var numIComps = iComps ? numComp : 1;
@@ -694,7 +695,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       var dims = image.getDimensions();
 
       if (iType === InterpolationType.NEAREST) {
-        if (numComp === 4) {
+        if (new Set([1, 3, 4]).has(numComp) && dataType === VtkDataTypes.UNSIGNED_CHAR && !iComps) {
           model.openGLTexture.setGenerateMipmap(true);
           model.openGLTexture.setMinificationFilter(Filter.NEAREST);
         } else {
@@ -703,7 +704,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
 
         model.openGLTexture.setMagnificationFilter(Filter.NEAREST);
       } else {
-        if (numComp === 4) {
+        if (numComp === 4 && dataType === VtkDataTypes.UNSIGNED_CHAR && !iComps) {
           model.openGLTexture.setGenerateMipmap(true);
           model.openGLTexture.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         } else {

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -270,7 +270,7 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @param {Number} numComps 
 	 * @param {Boolean} useFloat 
 	 */
-	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, useFloat: boolean): void;
+	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, oglNorm16Ext?: unknown): void;
 
 	/**
 	 * 

package/Rendering/OpenGL/RenderWindow.js

@@ -536,7 +536,9 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     return -1;
   };
 
-  publicAPI.getDefaultTextureInternalFormat = function (vtktype, numComps, useFloat) {
+  publicAPI.getDefaultTextureInternalFormat = function (vtktype, numComps) {
+    var oglNorm16Ext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
     if (model.webgl2) {
       switch (vtktype) {
         case VtkDataTypes.UNSIGNED_CHAR:
@@ -555,6 +557,40 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
               return model.context.RGBA8;
           }
 
+        case oglNorm16Ext && VtkDataTypes.UNSIGNED_SHORT:
+          switch (numComps) {
+            case 1:
+              return oglNorm16Ext.R16_EXT;
+
+            case 2:
+              return oglNorm16Ext.RG16_EXT;
+
+            case 3:
+              return oglNorm16Ext.RGB16_EXT;
+
+            case 4:
+            default:
+              return oglNorm16Ext.RGBA16_EXT;
+          }
+
+        // prioritize norm16 over float
+
+        case oglNorm16Ext && VtkDataTypes.SHORT:
+          switch (numComps) {
+            case 1:
+              return oglNorm16Ext.R16_SNORM_EXT;
+
+            case 2:
+              return oglNorm16Ext.RG16_SNORM_EXT;
+
+            case 3:
+              return oglNorm16Ext.RGB16_SNORM_EXT;
+
+            case 4:
+            default:
+              return oglNorm16Ext.RGBA16_SNORM_EXT;
+          }
+
         case VtkDataTypes.FLOAT:
         default:
           switch (numComps) {

package/Rendering/OpenGL/Texture.js

@@ -20,8 +20,6 @@ var vtkDebugMacro = vtkDebugMacro$1,
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLTexture(publicAPI, model) {
-  var _this = this;
-
   // Set our className
   model.classHierarchy.push('vtkOpenGLTexture'); // Renders myself
 
@@ -313,14 +311,11 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.getDefaultInternalFormat = function (vtktype, numComps) {
     var result = 0; // try default next
 
-    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, false);
+    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext);
 
     if (result) {
       return result;
-    } // try floating point
-
-
-    result = _this._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, true);
+    }
 
     if (!result) {
       vtkDebugMacro('Unsupported internal texture type!');
@@ -396,8 +391,6 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.getDefaultDataType = function (vtkScalarType) {
-    var useHalfFloatType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
     // DON'T DEAL with VTK_CHAR as this is platform dependent.
     if (model._openGLRenderWindow.getWebgl2()) {
       switch (vtkScalarType) {
@@ -405,11 +398,20 @@ function vtkOpenGLTexture(publicAPI, model) {
         //   return model.context.BYTE;
         case VtkDataTypes.UNSIGNED_CHAR:
           return model.context.UNSIGNED_BYTE;
+        // prefer norm16 since that is accurate compared to
+        // half float which is not
+
+        case model.oglNorm16Ext && VtkDataTypes.SHORT:
+          return model.context.SHORT;
 
-        case useHalfFloatType && VtkDataTypes.SHORT:
+        case model.oglNorm16Ext && VtkDataTypes.UNSIGNED_SHORT:
+          return model.context.UNSIGNED_SHORT;
+        // use half float type
+
+        case model.useHalfFloat && VtkDataTypes.SHORT:
           return model.context.HALF_FLOAT;
 
-        case useHalfFloatType && VtkDataTypes.UNSIGNED_SHORT:
+        case model.useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.HALF_FLOAT;
         // case VtkDataTypes.INT:
         //   return model.context.INT;
@@ -459,10 +461,10 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.getOpenGLDataType = function (vtkScalarType) {
-    var useHalfFloatType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var forceUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
-    if (!model.openGLDataType) {
-      model.openGLDataType = publicAPI.getDefaultDataType(vtkScalarType, useHalfFloatType);
+    if (!model.openGLDataType || forceUpdate) {
+      model.openGLDataType = publicAPI.getDefaultDataType(vtkScalarType);
     }
 
     return model.openGLDataType;
@@ -1000,8 +1002,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   }
 
   function checkUseHalfFloat(dataType, offset, scale, preferSizeOverAccuracy) {
-    var useHalfFloatType = true;
-    publicAPI.getOpenGLDataType(dataType, useHalfFloatType);
+    publicAPI.getOpenGLDataType(dataType);
     var useHalfFloat = false;
 
     if (model._openGLRenderWindow.getWebgl2()) {
@@ -1027,8 +1028,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
   publicAPI.create3DFromRaw = function (width, height, depth, numComps, dataType, data) {
     // Permit OpenGLDataType to be half float, if applicable, for 3D
-    var useHalfFloatType = true;
-    publicAPI.getOpenGLDataType(dataType, useHalfFloatType); // Now determine the texture parameters using the arguments.
+    publicAPI.getOpenGLDataType(dataType); // Now determine the texture parameters using the arguments.
 
     publicAPI.getInternalFormat(dataType, numComps);
     publicAPI.getFormat(dataType, numComps);
@@ -1056,6 +1056,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     var scaledData = scaleTextureToHighestPowerOfTwo(pixData); // Source texture data from the PBO.
     // model.context.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
     // model.context.pixelStorei(model.context.UNPACK_ALIGNMENT, 1);
+    // openGLDataType
 
     model.context.texImage3D(model.target, 0, model.internalFormat, model.width, model.height, model.depth, 0, model.format, model.openGLDataType, scaledData[0]);
 
@@ -1100,17 +1101,40 @@ function vtkOpenGLTexture(publicAPI, model) {
         computedScale = _computeScaleOffsets.scale;
 
     model.volumeInfo.dataComputedScale = computedScale;
-    model.volumeInfo.dataComputedOffset = computedOffset;
-    var useHalfFloat = checkUseHalfFloat(dataType, computedOffset, computedScale, preferSizeOverAccuracy); // WebGL2 path, we have 3d textures etc
+    model.volumeInfo.dataComputedOffset = computedOffset; // if we can use norm16, there is no need to use halfFloat then
+
+    model.useHalfFloat = model.oglNorm16Ext ? false : checkUseHalfFloat(dataType, computedOffset, computedScale, 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
+
 
     if (model._openGLRenderWindow.getWebgl2()) {
-      if (dataType === VtkDataTypes.FLOAT || useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
+      if (dataType === VtkDataTypes.FLOAT || model.useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
       }
 
-      if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
+      if (model.oglNorm16Ext && dataType === VtkDataTypes.SHORT) {
         for (var _c3 = 0; _c3 < numComps; ++_c3) {
-          model.volumeInfo.scale[_c3] = 255.0;
+          model.volumeInfo.scale[_c3] = 32767.0;
+        }
+
+        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
+      }
+
+      if (model.oglNorm16Ext && dataType === VtkDataTypes.UNSIGNED_SHORT) {
+        for (var _c4 = 0; _c4 < numComps; ++_c4) {
+          model.volumeInfo.scale[_c4] = 65535.0;
+        }
+
+        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
+      }
+
+      if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
+        for (var _c5 = 0; _c5 < numComps; ++_c5) {
+          model.volumeInfo.scale[_c5] = 255.0;
         }
 
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
@@ -1149,9 +1173,9 @@ function vtkOpenGLTexture(publicAPI, model) {
     var dataTypeToUse = VtkDataTypes.UNSIGNED_CHAR; // unsigned char gets used as is
 
     if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
-      for (var _c4 = 0; _c4 < numComps; ++_c4) {
-        res.offset[_c4] = 0.0;
-        res.scale[_c4] = 255.0;
+      for (var _c6 = 0; _c6 < numComps; ++_c6) {
+        res.offset[_c6] = 0.0;
+        res.scale[_c6] = 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
@@ -1326,7 +1350,13 @@ var DEFAULT_VALUES = {
   maxLOD: 1000.0,
   baseLevel: 0,
   maxLevel: 1000,
-  generateMipmap: false
+  generateMipmap: false,
+  // use half float by default, but it will get set
+  // to false if the context does not support it or
+  // the voxel intensity range is out of the accurate
+  // range of half float
+  useHalfFloat: true,
+  oglNorm16Ext: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -1344,7 +1374,7 @@ function extend(publicAPI, model) {
   }); // Build VTK API
 
   set(publicAPI, model, ['format', 'openGLDataType']);
-  setGet(publicAPI, model, ['keyMatrixTime', 'minificationFilter', 'magnificationFilter', 'wrapS', 'wrapT', 'wrapR', 'generateMipmap']);
+  setGet(publicAPI, model, ['keyMatrixTime', 'minificationFilter', 'magnificationFilter', 'wrapS', 'wrapT', 'wrapR', 'generateMipmap', 'oglNorm16Ext']);
   get(publicAPI, model, ['width', 'height', 'volumeInfo', 'components', 'handle', 'target']); // Object methods
 
   vtkOpenGLTexture(publicAPI, model);

package/Rendering/OpenGL/VolumeMapper.js

@@ -671,8 +671,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       program.setUniformf("oscale".concat(_i3), oscale);
       var cfun = vprop.getRGBTransferFunction(target);
       var cRange = cfun.getRange();
-      program.setUniformf("cshift".concat(_i3), (volInfo.offset[_i3] - cRange[0]) / (cRange[1] - cRange[0]));
-      program.setUniformf("cscale".concat(_i3), sscale / (cRange[1] - cRange[0]));
+      var cshift = (volInfo.offset[_i3] - cRange[0]) / (cRange[1] - cRange[0]);
+      var cScale = sscale / (cRange[1] - cRange[0]);
+      program.setUniformf("cshift".concat(_i3), cshift);
+      program.setUniformf("cscale".concat(_i3), cScale);
     }
 
     if (model.gopacity) {
@@ -1094,7 +1096,9 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
     if (model.scalarTextureString !== toString) {
       // Build the textures
-      var dims = image.getDimensions();
+      var dims = image.getDimensions(); // Use norm16 for scalar texture if the extension is available
+
+      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());

package/package.json

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