@kitware/vtk.js 33.0.0-beta.4 → 33.0.0

package/Rendering/Core/VolumeProperty.js

@@ -1,14 +1,11 @@
 import { m as macro } from '../../macros2.js';
-import { E as clampValue, K as floor } from '../../Common/Core/Math/index.js';
 import vtkColorTransferFunction from './ColorTransferFunction.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
 import Constants from './VolumeProperty/Constants.js';
 
 const {
   InterpolationType,
-  OpacityMode,
-  FilterMode,
-  ColorMixPreset
+  OpacityMode
 } = Constants;
 const {
   vtkErrorMacro
@@ -22,9 +19,6 @@ const VTK_MAX_VRCOMP = 4;
 function vtkVolumeProperty(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolumeProperty');
-  const superClass = {
-    ...publicAPI
-  };
   publicAPI.getMTime = () => {
     let mTime = model.mtime;
     let time;
@@ -203,33 +197,14 @@ function vtkVolumeProperty(publicAPI, model) {
     const cap = macro.capitalize(val);
     publicAPI[`get${cap}`] = index => model.componentData[index][`${val}`];
   });
-  publicAPI.setAverageIPScalarRange = (min, max) => {
-    console.warn('setAverageIPScalarRange is deprecated use setIpScalarRange');
-    publicAPI.setIpScalarRange(min, max);
-  };
-  publicAPI.getFilterModeAsString = () => macro.enumToString(FilterMode, model.filterMode);
-  publicAPI.setFilterModeToOff = () => {
-    publicAPI.setFilterMode(FilterMode.OFF);
-  };
-  publicAPI.setFilterModeToNormalized = () => {
-    publicAPI.setFilterMode(FilterMode.NORMALIZED);
-  };
-  publicAPI.setFilterModeToRaw = () => {
-    publicAPI.setFilterMode(FilterMode.RAW);
-  };
-  publicAPI.setGlobalIlluminationReach = gl => superClass.setGlobalIlluminationReach(clampValue(gl, 0.0, 1.0));
-  publicAPI.setVolumetricScatteringBlending = vsb => superClass.setVolumetricScatteringBlending(clampValue(vsb, 0.0, 1.0));
-  publicAPI.setAnisotropy = at => superClass.setAnisotropy(clampValue(at, -0.99, 0.99));
-  publicAPI.setLAOKernelSize = ks => superClass.setLAOKernelSize(floor(clampValue(ks, 1, 32)));
-  publicAPI.setLAOKernelRadius = kr => superClass.setLAOKernelRadius(kr >= 1 ? kr : 1);
 }
 
 // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-const defaultValues = initialValues => ({
-  colorMixPreset: ColorMixPreset.DEFAULT,
+const DEFAULT_VALUES = {
+  colorMixPreset: null,
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
   shade: false,
@@ -239,31 +214,14 @@ const defaultValues = initialValues => ({
   specularPower: 10.0,
   useLabelOutline: false,
   labelOutlineThickness: [1],
-  labelOutlineOpacity: 1.0,
-  // Properties moved from volume mapper
-  ipScalarRange: [-1000000.0, 1000000.0],
-  filterMode: FilterMode.OFF,
-  // ignored by WebGL so no behavior change
-  preferSizeOverAccuracy: false,
-  // Whether to use halfFloat representation of float, when it is inaccurate
-  computeNormalFromOpacity: false,
-  // volume shadow parameters
-  volumetricScatteringBlending: 0.0,
-  globalIlluminationReach: 0.0,
-  anisotropy: 0.0,
-  // local ambient occlusion
-  localAmbientOcclusion: false,
-  LAOKernelSize: 15,
-  LAOKernelRadius: 7,
-  updatedExtents: [],
-  ...initialValues
-});
+  labelOutlineOpacity: 1.0
+};
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues));
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Build VTK API
   macro.obj(publicAPI, model);
@@ -287,12 +245,7 @@ function extend(publicAPI, model) {
       });
     }
   }
-  macro.setGet(publicAPI, model, ['colorMixPreset', 'independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineOpacity',
-  // Properties moved from volume mapper
-  'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius', 'updatedExtents']);
-
-  // Property moved from volume mapper
-  macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
+  macro.setGet(publicAPI, model, ['colorMixPreset', 'independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineOpacity']);
   macro.setGetArray(publicAPI, model, ['labelOutlineThickness']);
 
   // Object methods

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -11,7 +11,7 @@ import vtkOpenGLTexture from './Texture.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
-import { getImageDataHash, getTransferFunctionsHash } from './RenderWindow/resourceSharingHelper.js';
+import { getImageDataHash, getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -147,7 +147,6 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.buildBufferObjects = (ren, actor) => {
     const image = model.currentImageDataInput;
     const centerline = model.currentCenterlineInput;
-    const property = actor.getProperty();
 
     // Rebuild the volumeTexture if the data has changed
     const scalars = image?.getPointData()?.getScalars();
@@ -157,7 +156,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const cachedScalarsEntry = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     const volumeTextureHash = getImageDataHash(image, scalars);
     const reBuildTex = !cachedScalarsEntry?.oglObject?.getHandle() || cachedScalarsEntry?.hash !== volumeTextureHash;
-    const updatedExtents = property.getUpdatedExtents();
+    const updatedExtents = model.renderable.getUpdatedExtents();
     const hasUpdatedExtents = !!updatedExtents.length;
     if (reBuildTex) {
       model.volumeTexture = vtkOpenGLTexture.newInstance();
@@ -180,7 +179,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (hasUpdatedExtents) {
       // If hasUpdatedExtents, then the texture is partially updated.
       // clear the array to acknowledge the update.
-      property.setUpdatedExtents([]);
+      model.renderable.setUpdatedExtents([]);
       const dims = image.getDimensions();
       model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
     }
@@ -191,13 +190,9 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const iComps = ppty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const colorTransferFunctions = [];
-    for (let component = 0; component < numIComps; ++component) {
-      colorTransferFunctions.push(ppty.getRGBTransferFunction(component));
-    }
-    const colorTextureHash = getTransferFunctionsHash(colorTransferFunctions, iComps, numIComps);
-    const firstColorTransferFunc = ppty.getRGBTransferFunction();
-    const cachedColorEntry = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
+    const colorTransferFunc = ppty.getRGBTransferFunction();
+    const colorTextureHash = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
+    const cachedColorEntry = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
     const reBuildColorTexture = !cachedColorEntry?.oglObject?.getHandle() || cachedColorEntry?.hash !== colorTextureHash;
     if (reBuildColorTexture) {
       let cWidth = model.renderable.getColorTextureWidth();
@@ -208,7 +203,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       const cTable = new Uint8ClampedArray(cSize);
       model.colorTexture = vtkOpenGLTexture.newInstance();
       model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (firstColorTransferFunc) {
+      if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
           const cfun = ppty.getRGBTransferFunction(c);
@@ -236,13 +231,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      if (firstColorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, colorTextureHash);
-        if (firstColorTransferFunc !== model._colorTransferFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(firstColorTransferFunc, publicAPI);
+      if (colorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, colorTextureHash);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
         }
-        model._colorTransferFunc = firstColorTransferFunc;
+        model._colorTransferFunc = colorTransferFunc;
       }
     } else {
       model.colorTexture = cachedColorEntry.oglObject;
@@ -251,13 +246,9 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     // Build piecewise function buffer.  This buffer is used either
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
-    const opacityFunctions = [];
-    for (let component = 0; component < numIComps; ++component) {
-      opacityFunctions.push(ppty.getPiecewiseFunction(component));
-    }
-    const pwfTextureHash = getTransferFunctionsHash(opacityFunctions, iComps, numIComps);
-    const firstPwFunc = ppty.getPiecewiseFunction();
-    const cachedPwfEntry = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
+    const pwFunc = ppty.getPiecewiseFunction();
+    const pwfTextureHash = getTransferFunctionHash(pwFunc, iComps, numIComps);
+    const cachedPwfEntry = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
     const reBuildPwf = !cachedPwfEntry?.oglObject?.getHandle() || cachedPwfEntry?.hash !== pwfTextureHash;
     if (reBuildPwf) {
       let pwfWidth = model.renderable.getOpacityTextureWidth();
@@ -268,7 +259,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       const pwfTable = new Uint8ClampedArray(pwfSize);
       model.pwfTexture = vtkOpenGLTexture.newInstance();
       model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (firstPwFunc) {
+      if (pwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
@@ -300,13 +291,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      if (firstPwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfTextureHash);
-        if (firstPwFunc !== model._pwFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(firstPwFunc, publicAPI);
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, pwfTextureHash);
+        if (pwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
         }
-        model._pwFunc = firstPwFunc;
+        model._pwFunc = pwFunc;
       }
     } else {
       model.pwfTexture = cachedPwfEntry.oglObject;

package/Rendering/OpenGL/ImageMapper.js

@@ -4,13 +4,14 @@ import { n as newInstance$1, e as setGet, o as obj, r as vtkErrorMacro$1, h as c
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import vtkHelper from './Helper.js';
+import { u as uninitializeBounds } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { Representation } from '../Core/Property/Constants.js';
 import { Filter, Wrap } from './Texture/Constants.js';
 import { InterpolationType } from '../Core/ImageProperty/Constants.js';
-import { getTransferFunctionsHash } from './RenderWindow/resourceSharingHelper.js';
+import { getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
@@ -554,6 +555,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
   };
+  publicAPI.computeBounds = (ren, actor) => {
+    if (!publicAPI.getInput()) {
+      uninitializeBounds(model.bounds);
+      return;
+    }
+    model.bounds = publicAPI.getInput().getBounds();
+  };
   publicAPI.updateBufferObjects = (ren, actor) => {
     // Rebuild buffers if needed
     if (publicAPI.getNeedToRebuildBufferObjects(ren, actor)) {
@@ -577,13 +585,9 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const iComps = actorProperty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const colorTransferFunctions = [];
-    for (let component = 0; component < numIComps; ++component) {
-      colorTransferFunctions.push(actorProperty.getRGBTransferFunction(component));
-    }
-    const cfunToString = getTransferFunctionsHash(colorTransferFunctions, iComps, numIComps);
-    const firstColorTransferFunc = actorProperty.getRGBTransferFunction();
-    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
+    const colorTransferFunc = actorProperty.getRGBTransferFunction();
+    const cfunToString = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
     const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== cfunToString;
     if (reBuildC) {
       model.colorTexture = vtkOpenGLTexture.newInstance({
@@ -604,7 +608,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.colorTexture.setMinificationFilter(Filter.LINEAR);
         model.colorTexture.setMagnificationFilter(Filter.LINEAR);
       }
-      if (firstColorTransferFunc) {
+      if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
           const cfun = actorProperty.getRGBTransferFunction(c);
@@ -631,13 +635,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         }
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      if (firstColorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, cfunToString);
-        if (firstColorTransferFunc !== model._colorTransferFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(firstColorTransferFunc, publicAPI);
+      if (colorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, cfunToString);
+        if (colorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
         }
-        model._colorTransferFunc = firstColorTransferFunc;
+        model._colorTransferFunc = colorTransferFunc;
       }
     } else {
       model.colorTexture = cTex.oglObject;
@@ -646,13 +650,9 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // Build piecewise function buffer.  This buffer is used either
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
-    const opacityFunctions = [];
-    for (let component = 0; component < numIComps; ++component) {
-      opacityFunctions.push(actorProperty.getPiecewiseFunction(component));
-    }
-    const pwfunToString = getTransferFunctionsHash(opacityFunctions, iComps, numIComps);
-    const firstPwFunc = actorProperty.getPiecewiseFunction();
-    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
+    const pwFunc = actorProperty.getPiecewiseFunction();
+    const pwfunToString = getTransferFunctionHash(pwFunc, iComps, numIComps);
+    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
     // rebuild opacity tfun?
     const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== pwfunToString;
     if (reBuildPwf) {
@@ -674,7 +674,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.pwfTexture.setMinificationFilter(Filter.LINEAR);
         model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
       }
-      if (firstPwFunc) {
+      if (pwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
@@ -705,13 +705,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         pwfTable.fill(255.0);
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      if (firstPwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfunToString);
-        if (firstPwFunc !== model._pwFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(firstPwFunc, publicAPI);
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, pwfunToString);
+        if (pwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
         }
-        model._pwFunc = firstPwFunc;
+        model._pwFunc = pwFunc;
       }
     } else {
       model.pwfTexture = pwfTex.oglObject;