@cornerstonejs/core 1.70.12 → 1.70.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "1.70.12",
+  "version": "1.70.14",
   "description": "",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -30,7 +30,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@kitware/vtk.js": "30.3.3",
+    "@kitware/vtk.js": "30.4.1",
     "comlink": "^4.4.1",
     "detect-gpu": "^5.0.22",
     "gl-matrix": "^3.4.3",
@@ -47,5 +47,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "bc9005d6ce0c473de4fc4189c7aa2813658421a3"
+  "gitHead": "e511c3f4b11596cfedb30b071b42c9c68d71d018"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -51,7 +51,6 @@ import {
   invertRgbTransferFunction,
   triggerEvent,
   colormap as colormapUtils,
-  isEqual,
 } from '../utilities';
 import { createVolumeActor } from './helpers';
 import volumeNewImageEventDispatcher, {
@@ -61,8 +60,8 @@ import Viewport from './Viewport';
 import type { vtkSlabCamera as vtkSlabCameraType } from './vtkClasses/vtkSlabCamera';
 import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
 import transformWorldToIndex from '../utilities/transformWorldToIndex';
+import { findMatchingColormap } from '../utilities/colormap';
 import { getTransferFunctionNodes } from '../utilities/transferFunctionUtils';
-import { getColormap, getColormapNames } from '../utilities/colormap';
 /**
  * Abstract base class for volume viewports. VolumeViewports are used to render
  * 3D volumes from which various orientations can be viewed. Since VolumeViewports
@@ -357,17 +356,11 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     const cfun = this._getOrCreateColorTransferFunction(volumeIdToUse);
     invertRgbTransferFunction(cfun);
 
-    const { voiRange, VOILUTFunction } = this.getProperties(volumeIdToUse);
-
     this.viewportProperties.invert = inverted;
 
     if (!suppressEvents) {
       const eventDetail: VoiModifiedEventDetail = {
-        viewportId: this.id,
-        range: voiRange,
-        volumeId: volumeIdToUse,
-        VOILUTFunction: VOILUTFunction,
-        invert: inverted,
+        ...this.getVOIModifiedEventDetail(volumeIdToUse),
         invertStateChanged: true,
       };
 
@@ -375,6 +368,39 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     }
   }
 
+  protected getVOIModifiedEventDetail(
+    volumeId: string
+  ): VoiModifiedEventDetail {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      throw new Error(`No actor found for the given volumeId: ${volumeId}`);
+    }
+
+    const volumeActor = applicableVolumeActorInfo.volumeActor;
+
+    const transferFunction = volumeActor
+      .getProperty()
+      .getRGBTransferFunction(0);
+
+    const range = transferFunction.getMappingRange();
+
+    const matchedColormap = this.getColormap(volumeId);
+    const { VOILUTFunction, invert } = this.getProperties(volumeId);
+
+    return {
+      viewportId: this.id,
+      range: {
+        lower: range[0],
+        upper: range[1],
+      },
+      volumeId: applicableVolumeActorInfo.volumeId,
+      VOILUTFunction: VOILUTFunction,
+      colormap: matchedColormap,
+      invert,
+    };
+  }
+
   private _getOrCreateColorTransferFunction(
     volumeId: string
   ): vtkColorTransferFunction {
@@ -468,22 +494,11 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         .getProperty()
         .getRGBTransferFunction(0)
         .setRange(lower, upper);
-
-      if (!this.initialTransferFunctionNodes) {
-        const transferFunction = volumeActor
-          .getProperty()
-          .getRGBTransferFunction(0);
-        this.initialTransferFunctionNodes =
-          getTransferFunctionNodes(transferFunction);
-      }
     }
 
     if (!suppressEvents) {
       const eventDetail: VoiModifiedEventDetail = {
-        viewportId: this.id,
-        range: voiRange,
-        volumeId: volumeIdToUse,
-        VOILUTFunction: VOILUTFunction,
+        ...this.getVOIModifiedEventDetail(volumeIdToUse),
       };
 
       triggerEvent(this.element, Events.VOI_MODIFIED, eventDetail);
@@ -850,7 +865,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       ? voiRanges.find((range) => range.volumeId === volumeId)?.voiRange
       : voiRanges[0]?.voiRange;
 
-    const volumeColormap = this.getColormap(applicableVolumeActorInfo);
+    const volumeColormap = this.getColormap(volumeId);
 
     const colormap =
       volumeId && volumeColormap ? volumeColormap : latestColormap;
@@ -880,7 +895,13 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    * @param applicableVolumeActorInfo  - The volume actor information for the volume
    * @returns colormap information for the volume if identified
    */
-  private getColormap = (applicableVolumeActorInfo) => {
+  private getColormap = (volumeId) => {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
     const { volumeActor } = applicableVolumeActorInfo;
     const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
     const { nodes } = cfun.getState();
@@ -888,53 +909,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       acc.push(node.x, node.r, node.g, node.b);
       return acc;
     }, []);
-    const colormapsVTK = vtkColorMaps.rgbPresetNames.map((presetName) =>
-      vtkColorMaps.getPresetByName(presetName)
-    );
-    const colormapsCS3D = getColormapNames().map((colormapName) =>
-      getColormap(colormapName)
-    );
-    const colormaps = colormapsVTK.concat(colormapsCS3D);
-    const matchedColormap = colormaps.find((colormap) => {
-      const { RGBPoints: presetRGBPoints } = colormap;
-      if (presetRGBPoints.length !== RGBPoints.length) {
-        return false;
-      }
-
-      for (let i = 0; i < presetRGBPoints.length; i += 4) {
-        if (
-          !isEqual(
-            presetRGBPoints.slice(i + 1, i + 4),
-            RGBPoints.slice(i + 1, i + 4)
-          )
-        ) {
-          return false;
-        }
-      }
-
-      return true;
-    });
-
-    if (!matchedColormap) {
-      return null;
-    }
 
-    const opacityPoints = volumeActor
-      .getProperty()
-      .getScalarOpacity(0)
-      .getDataPointer();
-
-    const opacity = [];
-    for (let i = 0; i < opacityPoints.length; i += 2) {
-      opacity.push({ value: opacityPoints[i], opacity: opacityPoints[i + 1] });
-    }
-
-    const colormap = {
-      name: matchedColormap.Name,
-      opacity: opacity,
-    };
+    const matchedColormap = findMatchingColormap(RGBPoints, volumeActor);
 
-    return colormap;
+    return matchedColormap;
   };
 
   /**
@@ -996,6 +974,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     this._setVolumeActors(volumeActors);
     this.viewportStatus = ViewportStatus.PRE_RENDER;
 
+    this.initializeColorTransferFunction(volumeInputArray);
+
     triggerEvent(this.element, Events.VOLUME_VIEWPORT_NEW_VOLUME, {
       viewportId: this.id,
       volumeActors,
@@ -1070,6 +1050,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
 
     this.addActors(volumeActors);
 
+    this.initializeColorTransferFunction(volumeInputArray);
+
     if (immediate) {
       // render
       this.render();
@@ -1106,6 +1088,25 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     console.warn('Method "setOrientation" needs implementation');
   }
 
+  /**
+   * Initializes the color transfer function nodes for a given volume.
+   *
+   * @param volumeInputArray - Array of volume inputs.
+   * @param getTransferFunctionNodes - Function to get the transfer function nodes.
+   * @returns void
+   */
+  private initializeColorTransferFunction(volumeInputArray) {
+    const selectedVolumeId = volumeInputArray[0].volumeId;
+    const colorTransferFunction =
+      this._getOrCreateColorTransferFunction(selectedVolumeId);
+
+    if (!this.initialTransferFunctionNodes) {
+      this.initialTransferFunctionNodes = getTransferFunctionNodes(
+        colorTransferFunction
+      );
+    }
+  }
+
   private _getApplicableVolumeActor(volumeId?: string) {
     if (volumeId !== undefined && !this.getActor(volumeId)) {
       return;

package/src/RenderingEngine/StackViewport.ts

@@ -97,6 +97,7 @@ import {
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
+import { findMatchingColormap } from '../utilities/colormap';
 
 const EPSILON = 1; // Slice Thickness
 
@@ -867,6 +868,18 @@ class StackViewport extends Viewport implements IStackViewport, IImagesLoader {
       transferFunction,
       this.initialTransferFunctionNodes
     );
+
+    const nodes = getTransferFunctionNodes(transferFunction);
+
+    const RGBPoints = nodes.reduce((acc, node) => {
+      acc.push(node[0], node[1], node[2], node[3]);
+      return acc;
+    }, []);
+
+    const defaultActor = this.getDefaultActor();
+    const matchedColormap = findMatchingColormap(RGBPoints, defaultActor.actor);
+
+    this.setColormap(matchedColormap);
   }
 
   public resetToDefaultProperties(): void {

package/src/RenderingEngine/VolumeViewport.ts

@@ -238,7 +238,7 @@ class VolumeViewport extends BaseVolumeViewport {
 
       const mapper = actor.getMapper();
       // @ts-ignore vtk incorrect typing
-      mapper.setBlendMode(blendMode);
+      mapper.setBlendMode?.(blendMode);
     });
 
     if (immediate) {
@@ -443,26 +443,18 @@ class VolumeViewport extends BaseVolumeViewport {
     setDefaultVolumeVOI(volumeActor.actor as vtkVolume, imageVolume, false);
 
     if (isImageActor(volumeActor)) {
+      const transferFunction = (volumeActor.actor as ImageActor)
+        .getProperty()
+        .getRGBTransferFunction(0);
+
       setTransferFunctionNodes(
-        (volumeActor.actor as ImageActor)
-          .getProperty()
-          .getRGBTransferFunction(0),
+        transferFunction,
         this.initialTransferFunctionNodes
       );
     }
 
-    const range = (volumeActor.actor as vtkVolume)
-      .getProperty()
-      .getRGBTransferFunction(0)
-      .getMappingRange();
-
     const eventDetails = {
-      viewportId: volumeActor.uid,
-      range: {
-        lower: range[0],
-        upper: range[1],
-      },
-      volumeId: volumeActor.uid,
+      ...super.getVOIModifiedEventDetail(volumeId),
     };
 
     const resetPan = true;

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow.js

@@ -1,9 +1,11 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
-import vtkStreamingOpenGLViewNodeFactory from './vtkStreamingOpenGLViewNodeFactory';
+import vtkStreamingOpenGLViewNodeFactory, {
+  registerOverride,
+} from './vtkStreamingOpenGLViewNodeFactory';
 
 /**
- * vtkStreamingOpenGLRenderWindow - A dervied class of the core vtkOpenGLRenderWindow class.
+ * vtkStreamingOpenGLRenderWindow - A derived class of the core vtkOpenGLRenderWindow class.
  * The main purpose for this class extension is to add in our own node factory, so we can use
  * our extended "streaming" classes for progressive texture loading.
  *
@@ -27,9 +29,8 @@ export function extend(publicAPI, model, initialValues = {}) {
   vtkOpenGLRenderWindow.extend(publicAPI, model, initialValues);
 
   model.myFactory = vtkStreamingOpenGLViewNodeFactory.newInstance();
-  /* eslint-disable no-use-before-define */
-  model.myFactory.registerOverride('vtkRenderWindow', newInstance);
-  /* eslint-enable no-use-before-define */
+
+  registerOverride('vtkRenderWindow', newInstance);
 
   // Object methods
   vtkStreamingOpenGLRenderWindow(publicAPI, model);

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLViewNodeFactory.js

@@ -18,6 +18,12 @@ import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper
 import vtkViewNodeFactory from '@kitware/vtk.js/Rendering/SceneGraph/ViewNodeFactory';
 import vtkStreamingOpenGLVolumeMapper from './vtkStreamingOpenGLVolumeMapper';
 
+const CLASS_MAPPING = Object.create(null);
+
+export function registerOverride(className, fn) {
+  CLASS_MAPPING[className] = fn;
+}
+
 /**
  * vtkStreamingOpenGLViewNodeFactory - A fork of the vtkOpenGLViewNodeFactory,
  * so that we can inject our custom derived "Streaming" classes.
@@ -63,6 +69,8 @@ function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
     return vn;
   };
 
+  model.overrides = CLASS_MAPPING;
+
   /**
    * getModelInitialValues - This function allows us to pass textures down from our
    * vtkSharedVolumeMapper to new instances of vtkStreamingOpenGLVolumeMapper.
@@ -104,44 +112,29 @@ export function extend(publicAPI, model, initialValues = {}) {
   vtkStreamingOpenGLViewNodeFactory(publicAPI, model);
 
   // Initialization
-  publicAPI.registerOverride('vtkActor', vtkOpenGLActor.newInstance);
-  publicAPI.registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
-  publicAPI.registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
-  publicAPI.registerOverride(
-    'vtkGlyph3DMapper',
-    vtkOpenGLGlyph3DMapper.newInstance
-  );
-  publicAPI.registerOverride(
-    'vtkImageMapper',
-    vtkOpenGLImageMapper.newInstance
-  );
-  publicAPI.registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
-  publicAPI.registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
-  publicAPI.registerOverride(
+  registerOverride('vtkActor', vtkOpenGLActor.newInstance);
+  registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
+  registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
+  registerOverride('vtkGlyph3DMapper', vtkOpenGLGlyph3DMapper.newInstance);
+  registerOverride('vtkImageMapper', vtkOpenGLImageMapper.newInstance);
+  registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
+  registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
+  registerOverride(
     'vtkPixelSpaceCallbackMapper',
     vtkOpenGLPixelSpaceCallbackMapper.newInstance
   );
-  publicAPI.registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
-  publicAPI.registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
-  publicAPI.registerOverride(
-    'vtkSphereMapper',
-    vtkOpenGLSphereMapper.newInstance
-  );
-  publicAPI.registerOverride(
-    'vtkStickMapper',
-    vtkOpenGLStickMapper.newInstance
-  );
-  publicAPI.registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
-  publicAPI.registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
-  publicAPI.registerOverride(
-    'vtkVolumeMapper',
-    vtkOpenGLVolumeMapper.newInstance
-  );
-  publicAPI.registerOverride(
+  registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
+  registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
+  registerOverride('vtkSphereMapper', vtkOpenGLSphereMapper.newInstance);
+  registerOverride('vtkStickMapper', vtkOpenGLStickMapper.newInstance);
+  registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
+  registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
+  registerOverride('vtkVolumeMapper', vtkOpenGLVolumeMapper.newInstance);
+  registerOverride(
     'vtkSharedVolumeMapper',
     vtkStreamingOpenGLVolumeMapper.newInstance
   );
-  // publicAPI.registerOverride(
+  // registerOverride(
   //   'vtkWidgetRepresentation',
   //   vtkGenericWidgetRepresentation.newInstance
   // )

package/src/types/Colormap.ts

@@ -3,7 +3,7 @@ import RGB from './RGB';
 type ColormapRegistration = {
   ColorSpace: string;
   Name: string;
-  RGBPoints: RGB[];
+  RGBPoints: RGB[] | number[];
 };
 
 type OpacityMapping = {

package/src/types/EventTypes.ts

@@ -47,6 +47,8 @@ type VoiModifiedEventDetail = {
   invert?: boolean;
   /** Indicates if the 'invert' state has changed from the previous state */
   invertStateChanged?: boolean;
+  /** color map */
+  colormap?: ColormapPublic;
 };
 
 type ColormapModifiedEventDetail = {

package/src/utilities/actorCheck.ts

@@ -15,10 +15,10 @@ export function isImageActor(actorEntry: Types.ActorEntry): boolean {
 }
 
 export function actorIsA(
-  actorEntry: Types.ActorEntry,
+  actorEntry: Types.ActorEntry | Types.Actor,
   actorType: actorTypes
 ): boolean {
-  const actor = actorEntry.actor;
+  const actorToCheck = 'isA' in actorEntry ? actorEntry : actorEntry.actor;
 
-  return !!actor.isA(actorType);
+  return !!actorToCheck.isA(actorType);
 }

package/src/utilities/colormap.ts

@@ -1,4 +1,8 @@
-import { ColormapRegistration } from '../types';
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+
+import { ColormapPublic, ColormapRegistration } from '../types';
+import isEqual from './isEqual';
+import { actorIsA } from './actorCheck';
 
 const _colormaps = new Map();
 
@@ -29,4 +33,78 @@ function getColormapNames() {
   return Array.from(_colormaps.keys());
 }
 
-export { getColormap, getColormapNames, registerColormap };
+/**
+ * Finds a colormap that matches the given RGB points.
+ *
+ * @param rgbPoints - The RGB points to match against the colormaps.
+ * @returns  The matched colormap object or null if no match is found.
+ */
+function findMatchingColormap(rgbPoints, actor): ColormapPublic | null {
+  const colormapsVTK = vtkColorMaps.rgbPresetNames.map((presetName) =>
+    vtkColorMaps.getPresetByName(presetName)
+  );
+
+  const colormapsCS3D = getColormapNames().map((colormapName) =>
+    getColormap(colormapName)
+  );
+
+  const colormaps = colormapsVTK.concat(colormapsCS3D);
+
+  // Find the colormap that matches the given RGB points
+  const matchedColormap = colormaps.find((colormap) => {
+    const { RGBPoints: presetRGBPoints } = colormap;
+
+    if (presetRGBPoints.length !== rgbPoints.length) {
+      return false;
+    }
+
+    for (let i = 0; i < presetRGBPoints.length; i += 4) {
+      if (
+        !isEqual(
+          presetRGBPoints.slice(i + 1, i + 4),
+          rgbPoints.slice(i + 1, i + 4)
+        )
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+
+  if (!matchedColormap) {
+    return null;
+  }
+
+  const opacity = [];
+  if (actorIsA(actor, 'vtkVolume')) {
+    const opacityPoints = actor
+      .getProperty()
+      .getScalarOpacity(0)
+      .getDataPointer();
+
+    if (!opacityPoints) {
+      return {
+        name: matchedColormap.Name,
+      };
+    }
+
+    for (let i = 0; i < opacityPoints.length; i += 2) {
+      opacity.push({
+        value: opacityPoints[i],
+        opacity: opacityPoints[i + 1],
+      });
+    }
+  }
+
+  return {
+    name: matchedColormap.Name,
+  };
+}
+
+export {
+  getColormap,
+  getColormapNames,
+  registerColormap,
+  findMatchingColormap,
+};