@cornerstonejs/core 0.45.1 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "0.45.1",
+  "version": "0.46.0",
   "description": "",
   "main": "dist/umd/index.js",
   "types": "dist/esm/index.d.ts",
@@ -43,5 +43,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "2a678fa8a71841b0a241357999d737a7b7f98126"
+  "gitHead": "5856c935d5879c1efa3a50930044d6526ed5c2c2"
 }

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -1,7 +1,13 @@
 import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 
 import cache from '../cache';
-import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
+import {
+  MPR_CAMERA_VALUES,
+  RENDERING_DEFAULTS,
+  VIEWPORT_PRESETS,
+} from '../constants';
 import {
   BlendModes,
   Events,
@@ -14,6 +20,7 @@ import { getShouldUseCPURendering } from '../init';
 import { loadVolume } from '../loaders/volumeLoader';
 import type {
   ActorEntry,
+  ColormapPublic,
   FlipDirection,
   IImageData,
   IVolumeInput,
@@ -28,10 +35,13 @@ import type { ViewportInput } from '../types/IViewport';
 import type IVolumeViewport from '../types/IVolumeViewport';
 import {
   actorIsA,
+  applyPreset,
   createSigmoidRGBTransferFunction,
   getVoiFromSigmoidRGBTransferFunction,
   imageIdToURI,
+  invertRgbTransferFunction,
   triggerEvent,
+  colormap as colormapUtils,
 } from '../utilities';
 import { createVolumeActor } from './helpers';
 import volumeNewImageEventDispatcher, {
@@ -40,6 +50,7 @@ import volumeNewImageEventDispatcher, {
 import Viewport from './Viewport';
 import type { vtkSlabCamera as vtkSlabCameraType } from './vtkClasses/vtkSlabCamera';
 import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 
 /**
  * Abstract base class for volume viewports. VolumeViewports are used to render
@@ -54,6 +65,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
   useCPURendering = false;
   use16BitTexture = false;
   private _FrameOfReferenceUID: string;
+  private inverted = false;
 
   // Viewport Properties
   // TODO: similar to setVoi, this is only applicable to first volume
@@ -206,6 +218,135 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     this.setVOI(voiRange, volumeId, suppressEvents);
   }
 
+  /**
+   * Sets the colormap for the volume with the given ID and optionally suppresses events.
+   *
+   * @param colormap - The colormap to apply (e.g., "hsv").
+   * @param volumeId - The ID of the volume to set the colormap for.
+   * @param suppressEvents - If `true`, events will not be emitted during the colormap a
+   *
+   * @returns void
+   */
+  private setColormap(
+    colormap: ColormapPublic,
+    volumeId: string,
+    suppressEvents?: boolean
+  ) {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const { volumeActor } = applicableVolumeActorInfo;
+
+    const mapper = volumeActor.getMapper();
+    mapper.setSampleDistance(1.0);
+
+    const cfun = vtkColorTransferFunction.newInstance();
+    let colormapObj = colormapUtils.getColormap(colormap);
+
+    const { name, opacityMapping } = colormap;
+
+    if (!colormapObj) {
+      colormapObj = vtkColorMaps.getPresetByName(name);
+    }
+
+    if (!colormapObj) {
+      throw new Error(`Colormap ${colormap} not found`);
+    }
+
+    const range = volumeActor
+      .getProperty()
+      .getRGBTransferFunction(0)
+      .getRange();
+
+    cfun.applyColorMap(colormapObj);
+    cfun.setMappingRange(range[0], range[1]);
+    volumeActor.getProperty().setRGBTransferFunction(0, cfun);
+
+    const ofun = vtkPiecewiseFunction.newInstance();
+    ofun.addPoint(range[0], 0.0);
+    ofun.addPoint(range[1], 1.0);
+    volumeActor.getProperty().setScalarOpacity(0, ofun);
+
+    if (!opacityMapping) {
+      return;
+    }
+
+    // add custom opacity points
+    opacityMapping.forEach(({ opacity, value }) => {
+      ofun.addPoint(value, opacity);
+    });
+  }
+
+  /**
+   * Sets the inversion for the volume transfer function
+   *
+   * @param invert - Should the transfer function be inverted?
+   * @param volumeId - volumeId
+   * @param suppressEvents - If `true`, events will not be published
+   *
+   * @returns void
+   */
+  private setInvert(
+    invert: boolean,
+    volumeId?: string,
+    suppressEvents?: boolean
+  ) {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const volumeIdToUse = applicableVolumeActorInfo.volumeId;
+
+    const cfun = this._getOrCreateColorTransferFunction(volumeIdToUse);
+    invertRgbTransferFunction(cfun);
+
+    this.inverted = invert;
+
+    const { voiRange } = this.getProperties();
+
+    if (!suppressEvents) {
+      const eventDetail: VoiModifiedEventDetail = {
+        viewportId: this.id,
+        range: voiRange,
+        volumeId: volumeIdToUse,
+        VOILUTFunction: this.VOILUTFunction,
+        invert: this.inverted,
+      };
+
+      triggerEvent(this.element, Events.VOI_MODIFIED, eventDetail);
+    }
+  }
+
+  private _getOrCreateColorTransferFunction(
+    volumeId: string
+  ): vtkColorTransferFunction {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return null;
+    }
+
+    const { volumeActor } = applicableVolumeActorInfo;
+
+    const rgbTransferFunction = volumeActor
+      .getProperty()
+      .getRGBTransferFunction(0);
+
+    if (rgbTransferFunction) {
+      return rgbTransferFunction;
+    }
+
+    const newRGBTransferFunction = vtkColorTransferFunction.newInstance();
+    volumeActor.getProperty().setRGBTransferFunction(0, newRGBTransferFunction);
+
+    return newRGBTransferFunction;
+  }
+
   /**
    * Sets the properties for the volume viewport on the volume
    * (if fusion, it sets it for the first volume in the fusion)
@@ -219,27 +360,14 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     volumeId?: string,
     suppressEvents = false
   ): void {
-    if (volumeId !== undefined && !this.getActor(volumeId)) {
-      return;
-    }
-
-    const actorEntries = this.getActors();
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
 
-    if (!actorEntries.length) {
+    if (!applicableVolumeActorInfo) {
       return;
     }
 
-    let volumeActor;
-
-    if (volumeId) {
-      volumeActor = this.getActor(volumeId)?.actor as vtkVolume;
-    }
-
-    // // set it for the first volume (if there are more than one - fusion)
-    if (!volumeActor) {
-      volumeActor = actorEntries[0].actor as vtkVolume;
-      volumeId = actorEntries[0].uid;
-    }
+    const { volumeActor } = applicableVolumeActorInfo;
+    const volumeIdToUse = applicableVolumeActorInfo.volumeId;
 
     let voiRangeToUse = voiRange;
     if (typeof voiRangeToUse === 'undefined') {
@@ -273,7 +401,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       const eventDetail: VoiModifiedEventDetail = {
         viewportId: this.id,
         range: voiRange,
-        volumeId: volumeId,
+        volumeId: volumeIdToUse,
         VOILUTFunction: this.VOILUTFunction,
       };
 
@@ -285,23 +413,76 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    * Sets the properties for the volume viewport on the volume
    * (if fusion, it sets it for the first volume in the fusion)
    *
-   * @param voiRange - Sets the lower and upper voi
-   * @param VOILUTFunction - Sets the voi mode (LINEAR, or SAMPLED_SIGMOID)
+   * @param VolumeViewportProperties - The properties to set
+   * @param [VolumeViewportProperties.voiRange] - Sets the lower and upper voi
+   * @param [VolumeViewportProperties.VOILUTFunction] - Sets the voi mode (LINEAR, or SAMPLED_SIGMOID)
+   * @param [VolumeViewportProperties.invert] - Inverts the color transfer function
+   * @param [VolumeViewportProperties.colormap] - Sets the colormap
+   * @param [VolumeViewportProperties.preset] - Sets the colormap
    * @param volumeId - The volume id to set the properties for (if undefined, the first volume)
    * @param suppressEvents - If true, the viewport will not emit events
    */
   public setProperties(
-    { voiRange, VOILUTFunction }: VolumeViewportProperties = {},
+    {
+      voiRange,
+      VOILUTFunction,
+      invert,
+      colormap,
+      preset,
+    }: VolumeViewportProperties = {},
     volumeId?: string,
     suppressEvents = false
   ): void {
-    if (voiRange) {
+    // Note: colormap should always be done first, since we can then
+    // modify the voiRange
+    if (colormap !== undefined) {
+      this.setColormap(colormap, volumeId, suppressEvents);
+    }
+
+    if (voiRange !== undefined) {
       this.setVOI(voiRange, volumeId, suppressEvents);
     }
 
-    if (VOILUTFunction) {
+    if (VOILUTFunction !== undefined) {
       this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
     }
+
+    if (invert !== undefined && this.inverted !== invert) {
+      this.setInvert(invert, volumeId, suppressEvents);
+    }
+
+    if (preset !== undefined) {
+      this.setPreset(preset, volumeId, suppressEvents);
+    }
+  }
+
+  /**
+   * Sets the specified preset for the volume with the given ID
+   *
+   * @param presetName - The name of the preset to apply (e.g., "CT-Bone").
+   * @param volumeId - The ID of the volume to set the preset for.
+   * @param suppressEvents - If `true`, events will not be emitted during the preset application.
+   *
+   * @returns void
+   */
+  private setPreset(presetName, volumeId, suppressEvents) {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const { volumeActor } = applicableVolumeActorInfo;
+
+    const preset = VIEWPORT_PRESETS.find((preset) => {
+      return preset.name === presetName;
+    });
+
+    if (!preset) {
+      return;
+    }
+
+    applyPreset(volumeActor, preset);
   }
 
   /**
@@ -328,7 +509,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     const voiRange = voiRanges.length ? voiRanges[0].voiRange : null;
     const VOILUTFunction = this.VOILUTFunction;
 
-    return { voiRange, VOILUTFunction };
+    return { voiRange, VOILUTFunction, invert: this.inverted };
   };
 
   /**
@@ -500,6 +681,32 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     console.warn('Method "setOrientation" needs implementation');
   }
 
+  private _getApplicableVolumeActor(volumeId?: string) {
+    if (volumeId !== undefined && !this.getActor(volumeId)) {
+      return;
+    }
+
+    const actorEntries = this.getActors();
+
+    if (!actorEntries.length) {
+      return;
+    }
+
+    let volumeActor;
+
+    if (volumeId) {
+      volumeActor = this.getActor(volumeId)?.actor as vtkVolume;
+    }
+
+    // // set it for the first volume (if there are more than one - fusion)
+    if (!volumeActor) {
+      volumeActor = actorEntries[0].actor as vtkVolume;
+      volumeId = actorEntries[0].uid;
+    }
+
+    return { volumeActor, volumeId };
+  }
+
   private async _isValidVolumeInputArray(
     volumeInputArray: Array<IVolumeInput>,
     FrameOfReferenceUID: string

package/src/RenderingEngine/helpers/createVolumeActor.ts

@@ -85,7 +85,6 @@ function triggerVOIModified(
   const voiRange = volumeActor
     .getProperty()
     .getRGBTransferFunction(0)
-    // @ts-ignore: vtk d ts problem
     .getRange();
 
   const voiModifiedEventDetail: VoiModifiedEventDetail = {

package/src/RenderingEngine/helpers/setDefaultVolumeVOI.ts

@@ -61,7 +61,7 @@ function handlePreScaledVolume(imageVolume: IImageVolume, voi: VOIRange) {
    * Therefore, we follow the majority of other viewers and we set the min/max
    * for the scaled PT to be 0, 5
    */
-  if (generalSeriesModule.modality === 'PT' && imageVolume.isPrescaled) {
+  if (_isCurrentImagePTPrescaled(generalSeriesModule.modality, imageVolume)) {
     return {
       lower: 0,
       upper: 5,
@@ -224,4 +224,16 @@ function _getImageScalarDataFromImageVolume(
   return imageScalarData;
 }
 
+function _isCurrentImagePTPrescaled(modality, imageVolume) {
+  if (modality !== 'PT' || !imageVolume.isPreScaled) {
+    return false;
+  }
+
+  if (!imageVolume.scaling?.PT.suvbw) {
+    return false;
+  }
+
+  return true;
+}
+
 export default setDefaultVolumeVOI;

package/src/types/Colormap.ts

@@ -0,0 +1,31 @@
+import RGB from './RGB';
+
+type ColormapRegistration = {
+  ColorSpace: string;
+  Name: string;
+  RGBPoints: RGB[];
+};
+
+type OpacityMapping = {
+  /** value to map to opacity */
+  value: number;
+  /** opacity value */
+  opacity: number;
+};
+
+type ColormapPublic = {
+  /** name of the colormap */
+  name: string;
+  /** midpoint mapping between values to opacity if the colormap
+   * is getting used for fusion, this is an array of arrays which
+   * each array containing 2 values, the first value is the value
+   * to map to opacity and the second value is the opacity value.
+   * By default, the minimum value is mapped to 0 opacity and the
+   * maximum value is mapped to 1 opacity, but you can configure
+   * the points in the middle to be mapped to different opacities
+   * instead of a linear mapping from 0 to 1.
+   */
+  opacityMapping?: OpacityMapping[];
+};
+
+export type { ColormapRegistration, ColormapPublic };

package/src/types/EventTypes.ts

@@ -40,6 +40,8 @@ type VoiModifiedEventDetail = {
   volumeId?: string;
   /** VOILUTFunction */
   VOILUTFunction?: VOILUTFunctionType;
+  /** inverted */
+  invert?: boolean;
 };
 
 /**

package/src/types/ScalingParameters.ts

@@ -18,6 +18,12 @@ type PTScaling = {
   suvbwToSuvlbm?: number;
   /** suv body weight to suv body surface area */
   suvbwToSuvbsa?: number;
+  /** SUV body weight */
+  suvbw?: number;
+  /** SUV lean body mass */
+  suvlbm?: number;
+  /** SUV body surface area */
+  suvbsa?: number;
 };
 
 type Scaling = {

package/src/types/StackViewportProperties.ts

@@ -1,17 +1,10 @@
 import InterpolationType from '../enums/InterpolationType';
-import VOILUTFunctionType from '../enums/VOILUTFunctionType';
-import { VOIRange } from './voi';
+import { ViewportProperties } from './ViewportProperties';
 
 /**
  * Stack Viewport Properties
  */
-type StackViewportProperties = {
-  /** voi range (upper, lower) for the viewport */
-  voiRange?: VOIRange;
-  /** VOILUTFunction type which is LINEAR or SAMPLED_SIGMOID */
-  VOILUTFunction?: VOILUTFunctionType;
-  /** invert flag - whether the image is inverted */
-  invert?: boolean;
+type StackViewportProperties = ViewportProperties & {
   /** interpolation type - linear or nearest neighbor */
   interpolationType?: InterpolationType;
   /** image rotation */

package/src/types/ViewportProperties.ts

@@ -0,0 +1,16 @@
+import { VOILUTFunctionType } from '../enums';
+import { VOIRange } from './voi';
+
+/**
+ * Shared Viewport Properties between Stack and Volume Viewports
+ */
+type ViewportProperties = {
+  /** voi range (upper, lower) for the viewport */
+  voiRange?: VOIRange;
+  /** VOILUTFunction type which is LINEAR or SAMPLED_SIGMOID */
+  VOILUTFunction?: VOILUTFunctionType;
+  /** invert flag - whether the image is inverted */
+  invert?: boolean;
+};
+
+export type { ViewportProperties };

package/src/types/VolumeViewportProperties.ts

@@ -1,14 +1,14 @@
-import { VOIRange } from './voi';
-import VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import { ColormapPublic } from './Colormap';
+import { ViewportProperties } from './ViewportProperties';
 
 /**
  * Stack Viewport Properties
  */
-type VolumeViewportProperties = {
-  /** voi range (upper, lower) for the viewport */
-  voiRange?: VOIRange;
-  /** VOILUTFunction type which is LINEAR or SAMPLED_SIGMOID */
-  VOILUTFunction?: VOILUTFunctionType;
+type VolumeViewportProperties = ViewportProperties & {
+  /** color maps  */
+  colormap?: ColormapPublic;
+  /** 3d preset */
+  preset?: string;
 };
 
 export default VolumeViewportProperties;

package/src/types/index.ts

@@ -75,6 +75,8 @@ import type ICachedGeometry from './ICachedGeometry';
 import type { IContourSet } from './IContourSet';
 import type { IContour } from './IContour';
 import type RGB from './RGB';
+import { ColormapPublic, ColormapRegistration } from './Colormap';
+import type { ViewportProperties } from './ViewportProperties';
 
 export type {
   // config
@@ -107,6 +109,7 @@ export type {
   IViewport,
   StackViewportProperties,
   VolumeViewportProperties,
+  ViewportProperties,
   PublicViewportInput,
   VolumeActor,
   Actor,
@@ -159,4 +162,6 @@ export type {
   IContour,
   // Color
   RGB,
+  ColormapPublic,
+  ColormapRegistration,
 };

package/src/utilities/applyPreset.ts

@@ -9,7 +9,10 @@ import { VolumeActor } from '../types/IActor';
  * @param actor - The volume actor to apply the preset to.
  * @param preset - The preset to apply.
  */
-export default function applyPreset(actor: VolumeActor, preset: ViewportPreset) {
+export default function applyPreset(
+  actor: VolumeActor,
+  preset: ViewportPreset
+) {
   // Create color transfer function
   const colorTransferArray = preset.colorTransfer
     .split(' ')

package/src/utilities/colormap.ts

@@ -0,0 +1,32 @@
+import { ColormapRegistration } from '../types';
+
+const _colormaps = new Map();
+
+/**
+ * Register a colormap
+ * @param name - name of the colormap
+ * @param colormap - colormap object
+ */
+function registerColormap(colormap: ColormapRegistration) {
+  _colormaps.set(colormap.Name, colormap);
+}
+
+/**
+ * Get a colormap by name
+ * @param name - name of the colormap
+ * @returns colormap object
+ */
+function getColormap(name) {
+  return _colormaps.get(name);
+}
+
+/**
+ * Get all registered colormap names
+ * @returns array of colormap names
+ *
+ */
+function getColormapNames() {
+  return Array.from(_colormaps.keys());
+}
+
+export { getColormap, getColormapNames, registerColormap };

package/src/utilities/index.ts

@@ -48,6 +48,7 @@ import getScalarDataType from './getScalarDataType';
 // name spaces
 import * as planar from './planar';
 import * as windowLevel from './windowLevel';
+import * as colormap from './colormap';
 
 export {
   csUtils as invertRgbTransferFunction,
@@ -79,7 +80,7 @@ export {
   transformWorldToIndex,
   loadImageToCanvas,
   renderToCanvasCPU,
-  renderToCanvasGPU,  
+  renderToCanvasGPU,
   worldToImageCoords,
   imageToWorldCoords,
   getVolumeSliceRangeInfo,
@@ -99,4 +100,5 @@ export {
   deepMerge,
   getScalingParameters,
   getScalarDataType,
+  colormap,
 };