@kitware/vtk.js 19.3.0 → 19.4.0

package/Common/Core/HalfFloat.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Helper class to convert to/from half float
+ */
+
+/**
+ * Convert a number to half float representation
+ * @param {number} input
+ * @return encoded half float number (16 bits)
+ */
+export function toHalf(input: number): number;
+
+/**
+ * Convert a half float representation to a number
+ * @param {number} input
+ * @return decoded half float number
+ */
+export function fromHalf(input: number): number;
+
+export declare const HalfFloat: {
+	toHalf: typeof toHalf;
+	fromHalf: typeof fromHalf;
+}
+
+export default HalfFloat;

package/Common/Core/HalfFloat.js

@@ -0,0 +1,80 @@
+/* eslint-disable no-bitwise */
+var floatView = new Float32Array(1);
+var int32View = new Int32Array(floatView.buffer);
+/* eslint-disable no-bitwise */
+
+/* This method is faster than the OpenEXR implementation (very often
+ * used, eg. in Ogre), with the additional benefit of rounding, inspired
+ * by James Tursa?s half-precision code. */
+
+function toHalf(val) {
+  floatView[0] = val;
+  var x = int32View[0];
+  var bits = x >> 16 & 0x8000;
+  /* Get the sign */
+
+  var m = x >> 12 & 0x07ff;
+  /* Keep one extra bit for rounding */
+
+  var e = x >> 23 & 0xff;
+  /* Using int is faster here */
+
+  /* If zero, or denormal, or exponent underflows too much for a denormal
+   * half, return signed zero. */
+
+  if (e < 103) {
+    return bits;
+  }
+  /* If NaN, return NaN. If Inf or exponent overflow, return Inf. */
+
+
+  if (e > 142) {
+    bits |= 0x7c00;
+    /* If exponent was 0xff and one mantissa bit was set, it means NaN,
+     * not Inf, so make sure we set one mantissa bit too. */
+
+    bits |= (e === 255 ? 0 : 1) && x & 0x007fffff;
+    return bits;
+  }
+  /* If exponent underflows but not too much, return a denormal */
+
+
+  if (e < 113) {
+    m |= 0x0800;
+    /* Extra rounding may overflow and set mantissa to 0 and exponent
+     * to 1, which is OK. */
+
+    bits |= (m >> 114 - e) + (m >> 113 - e & 1);
+    return bits;
+  }
+
+  bits |= e - 112 << 10 | m >> 1;
+  /* Extra rounding. An overflow will set mantissa to 0 and increment
+   * the exponent, which is OK. */
+
+  bits += m & 1;
+  return bits;
+}
+
+function fromHalf(h) {
+  var s = (h & 0x8000) >> 15;
+  var e = (h & 0x7c00) >> 10;
+  var f = h & 0x03ff;
+
+  if (e === 0) {
+    return (s ? -1 : 1) * Math.pow(2, -14) * (f / Math.pow(2, 10));
+  }
+
+  if (e === 0x1f) {
+    return f ? NaN : (s ? -1 : 1) * Infinity;
+  }
+
+  return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / Math.pow(2, 10));
+}
+
+var HalfFloat = {
+  fromHalf: fromHalf,
+  toHalf: toHalf
+};
+
+export { HalfFloat as default };

package/Common/Core.js

@@ -2,6 +2,7 @@ import Base64 from './Core/Base64.js';
 import vtkCellArray from './Core/CellArray.js';
 import vtkDataArray from './Core/DataArray.js';
 import Endian from './Core/Endian.js';
+import HalfFloat from './Core/HalfFloat.js';
 import ImageHelper from './Core/ImageHelper.js';
 import vtkLookupTable from './Core/LookupTable.js';
 import { v as vtkMath } from './Core/Math/index.js';
@@ -18,6 +19,7 @@ var Core = {
   vtkCellArray: vtkCellArray,
   vtkDataArray: vtkDataArray,
   vtkEndian: Endian,
+  vtkHalfFloat: HalfFloat,
   vtkImageHelper: ImageHelper,
   vtkLookupTable: vtkLookupTable,
   vtkMath: vtkMath,

package/README.md

@@ -48,7 +48,7 @@ In general VTK tries to be as portable as possible; the specific configurations
 
 vtk.js supports the following development environments:
 
-- Node 10+
+- Node 12+
 - NPM 6+
 
 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).

package/Rendering/WebGPU/Texture.js

@@ -1,4 +1,5 @@
 import macro from '../../macros.js';
+import HalfFloat from '../../Common/Core/HalfFloat.js';
 import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUTextureView from './TextureView.js';
 import vtkWebGPUTypes from './Types.js';
@@ -79,20 +80,28 @@ function vtkWebGPUTexture(publicAPI, model) {
       // the data here before passing to the buffer. e.g. if it is unorm8x4 then
       // we need to have width be a multiple of 64
 
-      var currWidthInBytes = model.width * tDetails.stride;
+      var currWidthInBytes = model.width * tDetails.stride; // is this a half float texture?
 
-      if (currWidthInBytes % 256) {
-        var oArray = req.nativeArray;
+      var halfFloat = tDetails.elementSize === 2 && tDetails.sampleType === 'float'; // if we need to copy the data
+
+      if (halfFloat || currWidthInBytes % 256) {
+        var inArray = req.nativeArray;
         var bufferWidthInBytes = 256 * Math.floor((currWidthInBytes + 255) / 256);
-        var bufferWidth = bufferWidthInBytes / oArray.BYTES_PER_ELEMENT;
-        var oWidth = currWidthInBytes / oArray.BYTES_PER_ELEMENT;
-        var nArray = macro.newTypedArray(oArray.name, bufferWidth * model.height * model.depth);
+        var bufferWidth = bufferWidthInBytes / tDetails.elementSize;
+        var inWidth = currWidthInBytes / inArray.BYTES_PER_ELEMENT;
+        var outArray = macro.newTypedArray(halfFloat ? 'Uint16Array' : inArray.name, bufferWidth * model.height * model.depth);
 
         for (var v = 0; v < model.height * model.depth; v++) {
-          nArray.set(oArray.subarray(v * oWidth, (v + 1) * oWidth), v * bufferWidth);
+          if (halfFloat) {
+            for (var i = 0; i < inWidth; i++) {
+              outArray[v * bufferWidth + i] = HalfFloat.toHalf(inArray[v * inWidth + i]);
+            }
+          } else {
+            outArray.set(inArray.subarray(v * inWidth, (v + 1) * inWidth), v * bufferWidth);
+          }
         }
 
-        buffRequest.nativeArray = nArray;
+        buffRequest.nativeArray = outArray;
         bufferBytesPerRow = bufferWidthInBytes;
       }
 

package/Rendering/WebGPU/TextureManager.js

@@ -58,6 +58,8 @@ function vtkWebGPUTextureManager(publicAPI, model) {
         case VtkDataTypes.UNSIGNED_CHAR:
           req.format += '8unorm';
           break;
+        // todo extend to other types that are not filterable
+        // as they can be useful
 
         case VtkDataTypes.FLOAT:
         case VtkDataTypes.UNSIGNED_INT:
@@ -66,7 +68,8 @@ function vtkWebGPUTextureManager(publicAPI, model) {
         case VtkDataTypes.UNSIGNED_SHORT:
         case VtkDataTypes.SHORT:
         default:
-          console.log('unsupported data type in texture');
+          req.format += '16float';
+          break;
       }
     } // fill in values based on image if the request has it
 

package/Rendering/WebGPU/VolumePassFSQ.js

@@ -5,6 +5,7 @@ import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUStorageBuffer from './StorageBuffer.js';
 import vtkWebGPUSampler from './Sampler.js';
+import vtkWebGPUTypes from './Types.js';
 import { BlendMode } from '../Core/VolumeMapper/Constants.js';
 import { i as identity, t as translate, j as transpose, g as invert, m as multiply, s as scale } from '../../vendor/gl-matrix/esm/mat4.js';
 
@@ -240,8 +241,7 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
 
       var modelToIndex = _image3.getWorldToIndex();
 
-      transpose(tmp2Mat4, modelToIndex);
-      multiply(tmpMat4, tmp2Mat4, tmpMat4); // tmpMat4 is now SC -> Index
+      multiply(tmpMat4, modelToIndex, tmpMat4); // tmpMat4 is now SC -> Index
 
       var dims = _image3.getDimensions();
 
@@ -301,13 +301,23 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
 
       var numComp = scalars.getNumberOfComponents();
       var iComps = vprop.getIndependentComponents(); // const numIComps = iComps ? numComp : 1;
+      // half float
 
+      var tformat = model.textureViews[_vidx2 + 4].getTexture().getFormat();
+
+      var tDetails = vtkWebGPUTypes.getDetailsFromTextureFormat(tformat);
+      var halfFloat = tDetails.elementSize === 2 && tDetails.sampleType === 'float';
       var volInfo = {
         scale: [255.0],
         offset: [0.0]
-      }; // three levels of shift scale combined into one
+      };
+
+      if (halfFloat) {
+        volInfo.scale[0] = 1.0;
+      } // three levels of shift scale combined into one
       // for performance in the fragment shader
 
+
       for (var compIdx = 0; compIdx < numComp; compIdx++) {
         var target = iComps ? compIdx : 0;
         var sscale = volInfo.scale[compIdx];
@@ -381,10 +391,8 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
       model.sampleDist = sampleDist;
       model.UBO.setValue('SampleDistance', sampleDist);
       model.UBO.sendIfNeeded(device);
-    }
+    } // add in 3d volume textures
 
-    publicAPI.updateLUTImage(device);
-    publicAPI.updateSSBO(device); // add in 3d volume textures
 
     for (var vidx = 0; vidx < model.volumes.length; vidx++) {
       var webgpuvol = model.volumes[vidx];
@@ -406,6 +414,9 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
         model.textureViews[vidx + 4] = tview;
       }
     }
+
+    publicAPI.updateLUTImage(device);
+    publicAPI.updateSSBO(device);
   };
 
   publicAPI.computePipelineHash = function () {