@cornerstonejs/core 1.21.2 → 1.22.0

package/src/RenderingEngine/StackViewport.ts

@@ -1,6 +1,7 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { vtkImageData as vtkImageDataType } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import _cloneDeep from 'lodash.clonedeep';
 import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
 import { vec2, vec3, mat4 } from 'gl-matrix';
@@ -19,6 +20,7 @@ import {
   imageIdToURI,
   isImageActor,
   actorIsA,
+  colormap as colormapUtils,
 } from '../utilities';
 import {
   Point2,
@@ -39,7 +41,7 @@ import {
   IStackViewport,
   VolumeActor,
   Mat3,
-  ColormapRegistration,
+  ColormapPublic,
   IImageCalibration,
 } from '../types';
 import { ViewportInput } from '../types/IViewport';
@@ -52,7 +54,6 @@ import {
   InterpolationType,
   RequestType,
   Events,
-  CalibrationTypes,
   VOILUTFunctionType,
 } from '../enums';
 import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
@@ -79,6 +80,10 @@ import {
   ImagePlaneModule,
 } from '../types';
 import ViewportStatus from '../enums/ViewportStatus';
+import {
+  getTransferFunctionNodes,
+  setTransferFunctionNodes,
+} from '../utilities/transferFunctionUtils';
 
 const EPSILON = 1; // Slice Thickness
 
@@ -125,6 +130,13 @@ class StackViewport extends Viewport implements IStackViewport {
   private debouncedTimeout: number;
 
   // Viewport Properties
+  private globalDefaultProperties: StackViewportProperties;
+  private perImageIdDefaultProperties = new Map<
+    string,
+    StackViewportProperties
+  >();
+
+  private colormap: ColormapPublic | CPUFallbackColormapData;
   private voiRange: VOIRange;
   private voiUpdatedWithSetProperties = false;
   private VOILUTFunction: VOILUTFunctionType;
@@ -132,6 +144,7 @@ class StackViewport extends Viewport implements IStackViewport {
   private invert = false;
   // The initial invert of the image loaded as opposed to the invert status of the viewport itself (see above).
   private initialInvert = false;
+  private initialTransferFunctionNodes = null;
   private interpolationType: InterpolationType;
 
   // Helpers
@@ -250,14 +263,6 @@ class StackViewport extends Viewport implements IStackViewport {
    */
   public getImageData: () => IImageData | CPUIImageData;
 
-  /**
-   * Sets the colormap for the current viewport.
-   * @param colormap - The colormap data to use.
-   */
-  public setColormap: (
-    colormap: CPUFallbackColormapData | ColormapRegistration
-  ) => void;
-
   /**
    * If the user has selected CPU rendering, return the CPU camera, otherwise
    * return the default camera
@@ -365,6 +370,14 @@ class StackViewport extends Viewport implements IStackViewport {
 
   private setInvertColor: (invert: boolean) => void;
 
+  /**
+   * Sets the colormap for the current viewport.
+   * @param colormap - The colormap data to use.
+   */
+  private setColormap: (
+    colormap: CPUFallbackColormapData | ColormapPublic
+  ) => void;
+
   private initializeElementDisabledHandler() {
     eventTarget.addEventListener(
       Events.ELEMENT_DISABLED,
@@ -623,15 +636,60 @@ class StackViewport extends Viewport implements IStackViewport {
   }
 
   /**
-   * Sets the properties for the viewport on the default actor. Properties include
-   * setting the VOI, inverting the colors and setting the interpolation type, rotation
-   * @param voiRange - Sets the lower and upper voi
-   * @param invert - Inverts the colors
-   * @param interpolationType - Changes the interpolation type (1:linear, 0: nearest)
-   * @param rotation - image rotation in degrees
+   * Update the default properties of the viewport and add properties by imageId if specified
+   * @param ViewportProperties - The properties to set
+   * @param imageId If given, we set the default properties only for this image index, if not
+   * the default properties will be set for all imageIds
+   */
+  public setDefaultProperties(
+    ViewportProperties: StackViewportProperties,
+    imageId?: string
+  ): void {
+    if (imageId == null) {
+      this.globalDefaultProperties = ViewportProperties;
+    } else {
+      this.perImageIdDefaultProperties.set(imageId, ViewportProperties);
+
+      //If the viewport is the same imageIdI, we need to update the viewport
+      if (this.getCurrentImageId() === imageId) {
+        this.setProperties(ViewportProperties);
+      }
+    }
+  }
+
+  /**
+   * Remove the global default properties of the viewport or remove default properties for an imageId if specified
+   * @param imageId If given, we remove the default properties only for this imageID, if not
+   * the global default properties will be removed
+   */
+  public clearDefaultProperties(imageId?: string): void {
+    if (imageId == null) {
+      this.globalDefaultProperties = {};
+      this.resetProperties();
+    } else {
+      this.perImageIdDefaultProperties.delete(imageId);
+      this.resetToDefaultProperties();
+    }
+  }
+
+  /**
+   Configures the properties of the viewport.
+   This method allows customization of the viewport by setting attributes like
+   VOI (Value of Interest), color inversion, interpolation type, and image rotation.
+   If setProperties is called for the first time, the provided properties will
+   become the default settings for all images in the stack in case the resetPropertiese need to be called
+   @param properties - An object containing the properties to be set.
+   @param properties.colormap - Specifies the colormap for the viewport.
+   @param properties.voiRange - Defines the lower and upper Value of Interest (VOI) to be applied.
+   @param properties.VOILUTFunction - Function to handle the application of a lookup table (LUT) to the VOI.
+   @param properties.invert - A boolean value to toggle color inversion (true: inverted, false: not inverted).
+   @param properties.interpolationType - Determines the interpolation method to be used (1: linear, 0: nearest-neighbor).
+   @param properties.rotation - Specifies the image rotation angle in degrees.
+   @param suppressEvents - A boolean value to control event suppression. If true, the related events will not be triggered. Default is false.
    */
   public setProperties(
     {
+      colormap,
       voiRange,
       VOILUTFunction,
       invert,
@@ -643,6 +701,21 @@ class StackViewport extends Viewport implements IStackViewport {
     this.viewportStatus = this.csImage
       ? ViewportStatus.PRE_RENDER
       : ViewportStatus.LOADING;
+
+    if (this.globalDefaultProperties == null) {
+      this.setDefaultProperties({
+        colormap,
+        voiRange,
+        VOILUTFunction,
+        invert,
+        interpolationType,
+        rotation,
+      });
+    }
+
+    if (typeof colormap !== 'undefined') {
+      this.setColormap(colormap);
+    }
     // if voi is not applied for the first time, run the setVOI function
     // which will apply the default voi based on the range
     if (typeof voiRange !== 'undefined') {
@@ -670,12 +743,35 @@ class StackViewport extends Viewport implements IStackViewport {
     }
   }
 
+  /**
+   * Retrieve the viewport default properties
+   * @param imageId If given, we retrieve the default properties of an image index if it exists
+   * If not given,we return the global properties of the viewport
+   * @returns viewport properties including voi, invert, interpolation type, rotation, flip
+   */
+  public getDefaultProperties = (imageId?: string): StackViewportProperties => {
+    let imageProperties;
+    if (imageId !== undefined) {
+      imageProperties = this.perImageIdDefaultProperties.get(imageId);
+    }
+
+    if (imageProperties !== undefined) {
+      return imageProperties;
+    }
+
+    return {
+      ...this.globalDefaultProperties,
+      rotation: this.getRotation(),
+    };
+  };
+
   /**
    * Retrieve the viewport properties
    * @returns viewport properties including voi, invert, interpolation type, rotation, flip
    */
   public getProperties = (): StackViewportProperties => {
     const {
+      colormap,
       voiRange,
       VOILUTFunction,
       interpolationType,
@@ -685,6 +781,7 @@ class StackViewport extends Viewport implements IStackViewport {
     const rotation = this.getRotation();
 
     return {
+      colormap,
       voiRange,
       VOILUTFunction,
       interpolationType,
@@ -733,6 +830,52 @@ class StackViewport extends Viewport implements IStackViewport {
     }
     this.setInterpolationType(InterpolationType.LINEAR);
     this.setInvertColor(this.initialInvert);
+
+    const transferFunction = this.getTransferFunction();
+    setTransferFunctionNodes(
+      transferFunction,
+      this.initialTransferFunctionNodes
+    );
+  }
+
+  public resetToDefaultProperties(): void {
+    this.cpuRenderingInvalidated = true;
+    this.viewportStatus = ViewportStatus.PRE_RENDER;
+
+    this.fillWithBackgroundColor();
+
+    if (this.useCPURendering) {
+      this._cpuFallbackEnabledElement.renderingTools = {};
+    }
+
+    const currentImageId = this.getCurrentImageId();
+    const properties =
+      this.perImageIdDefaultProperties.get(currentImageId) ||
+      this.globalDefaultProperties;
+
+    if (properties.colormap?.name) {
+      this.setColormap(properties.colormap);
+    }
+
+    let voiRange;
+    if (properties.voiRange == undefined) {
+      // if not set via setProperties; if it is not a PT image or is not prescaled,
+      // use the voiRange for the current image from its metadata if found
+      // otherwise, use the cached voiRange
+      voiRange = this._getVOIRangeForCurrentImage();
+    } else {
+      voiRange = properties.voiRange;
+    }
+
+    this.setVOI(voiRange);
+
+    if (this.getRotation() !== 0) {
+      this.setRotation(0);
+    }
+    this.setInterpolationType(InterpolationType.LINEAR);
+    this.setInvertColor(false);
+
+    this.render();
   }
 
   private _setPropertiesFromCache(): void {
@@ -1040,6 +1183,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
     // @ts-ignore
     volumeProperty.setInterpolationType(interpolationType);
+
     this.interpolationType = interpolationType;
   }
 
@@ -1091,6 +1235,7 @@ class StackViewport extends Viewport implements IStackViewport {
       if ((!this.invert && invert) || (this.invert && !invert)) {
         invertRgbTransferFunction(tfunc);
       }
+
       this.invert = invert;
     }
   }
@@ -1145,6 +1290,21 @@ class StackViewport extends Viewport implements IStackViewport {
     }
   }
 
+  private getTransferFunction() {
+    const defaultActor = this.getDefaultActor();
+
+    if (!defaultActor) {
+      return;
+    }
+
+    if (!isImageActor(defaultActor)) {
+      return;
+    }
+    const imageActor = defaultActor.actor as ImageActor;
+
+    return imageActor.getProperty().getRGBTransferFunction(0);
+  }
+
   private setVOIGPU(voiRange: VOIRange, options: SetVOIOptions = {}): void {
     const {
       suppressEvents = false,
@@ -1204,6 +1364,8 @@ class StackViewport extends Viewport implements IStackViewport {
       }
 
       imageActor.getProperty().setRGBTransferFunction(0, transferFunction);
+      this.initialTransferFunctionNodes =
+        getTransferFunctionNodes(transferFunction);
     }
 
     if (!isSigmoidTFun) {
@@ -2084,7 +2246,7 @@ class StackViewport extends Viewport implements IStackViewport {
 
   private _getInitialVOIRange(image: IImage) {
     if (this.voiRange && this.voiUpdatedWithSetProperties) {
-      return this.voiRange;
+      return this.globalDefaultProperties.voiRange;
     }
     const { windowCenter, windowWidth } = image;
 
@@ -2164,6 +2326,17 @@ class StackViewport extends Viewport implements IStackViewport {
       imageIdIndex
     );
 
+    //Check if there is any existing specific options for images if not we don't
+    //want to re-render the viewport to its default properties
+    if (this.perImageIdDefaultProperties.size >= 1) {
+      const defaultProperties = this.perImageIdDefaultProperties.get(imageId);
+      if (defaultProperties !== undefined) {
+        this.setProperties(defaultProperties);
+      } else if (this.globalDefaultProperties !== undefined) {
+        this.setProperties(this.globalDefaultProperties);
+      }
+    }
+
     return imageId;
   }
 
@@ -2642,6 +2815,7 @@ class StackViewport extends Viewport implements IStackViewport {
   }
 
   private setColormapCPU(colormapData: CPUFallbackColormapData) {
+    this.colormap = colormapData;
     const colormap = getColormap(colormapData.name, colormapData);
 
     this._cpuFallbackEnabledElement.viewport.colormap = colormap;
@@ -2653,23 +2827,31 @@ class StackViewport extends Viewport implements IStackViewport {
     this.render();
   }
 
-  private setColormapGPU(colormap: ColormapRegistration) {
+  private setColormapGPU(colormap: ColormapPublic) {
     const ActorEntry = this.getDefaultActor();
     const actor = ActorEntry.actor as ImageActor;
     const actorProp = actor.getProperty();
     const rgbTransferFunction = actorProp.getRGBTransferFunction();
 
+    const colormapObj =
+      colormapUtils.getColormap(colormap.name) ||
+      vtkColorMaps.getPresetByName(colormap.name);
+
     if (!rgbTransferFunction) {
       const cfun = vtkColorTransferFunction.newInstance();
-      const voiRange = this._getVOIRangeForCurrentImage();
-      cfun.applyColorMap(colormap);
-      cfun.setMappingRange(voiRange.lower, voiRange.upper);
+      cfun.applyColorMap(colormapObj);
+      cfun.setMappingRange(this.voiRange.lower, this.voiRange.upper);
       actorProp.setRGBTransferFunction(0, cfun);
     } else {
-      rgbTransferFunction.applyColorMap(colormap);
+      rgbTransferFunction.applyColorMap(colormapObj);
+      rgbTransferFunction.setMappingRange(
+        this.voiRange.lower,
+        this.voiRange.upper
+      );
       actorProp.setRGBTransferFunction(0, rgbTransferFunction);
     }
 
+    this.colormap = colormap;
     this.render();
   }
 

package/src/RenderingEngine/VolumeViewport.ts

@@ -14,9 +14,16 @@ import type {
   Point3,
 } from '../types';
 import type { ViewportInput } from '../types/IViewport';
-import { actorIsA, getClosestImageId, triggerEvent } from '../utilities';
+import {
+  actorIsA,
+  getClosestImageId,
+  isImageActor,
+  triggerEvent,
+} from '../utilities';
 import BaseVolumeViewport from './BaseVolumeViewport';
 import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
+import { setTransferFunctionNodes } from '../utilities/transferFunctionUtils';
+import { ImageActor } from '../types/IActor';
 
 /**
  * An object representing a VolumeViewport. VolumeViewports are used to render
@@ -272,6 +279,11 @@ class VolumeViewport extends BaseVolumeViewport {
    * the slab thickness to (if not provided, all actors will be affected).
    */
   public setSlabThickness(slabThickness: number, filterActorUIDs = []): void {
+    if (slabThickness < 0.1) {
+      // Cannot render zero thickness
+      slabThickness = 0.1;
+    }
+
     let actorEntries = this.getActors();
 
     if (filterActorUIDs && filterActorUIDs.length > 0) {
@@ -385,6 +397,15 @@ class VolumeViewport extends BaseVolumeViewport {
     }
     setDefaultVolumeVOI(volumeActor.actor as vtkVolume, imageVolume, false);
 
+    if (isImageActor(volumeActor)) {
+      setTransferFunctionNodes(
+        (volumeActor.actor as ImageActor)
+          .getProperty()
+          .getRGBTransferFunction(0),
+        this.initialTransferFunctionNodes
+      );
+    }
+
     const range = (volumeActor.actor as vtkVolume)
       .getProperty()
       .getRGBTransferFunction(0)

package/src/types/IStackViewport.ts

@@ -7,7 +7,7 @@ import Point2 from './Point2';
 import Point3 from './Point3';
 import { Scaling } from './ScalingParameters';
 import StackViewportProperties from './StackViewportProperties';
-import { ColormapRegistration } from './Colormap';
+import { ColormapPublic } from './Colormap';
 import IImage from './IImage';
 
 /**
@@ -27,14 +27,38 @@ export default interface IStackViewport extends IViewport {
    * metadata, it returns undefined, otherwise, frameOfReferenceUID is returned.
    */
   getFrameOfReferenceUID: () => string;
+
+  /**
+   * Update the default properties of the viewport and add properties by imageId if specified
+   * setting the VOI, inverting the colors and setting the interpolation type, rotation
+   */
+  setDefaultProperties(
+    ViewportProperties: StackViewportProperties,
+    imageId?: string
+  ): void;
+
+  /**
+   * Remove the global default properties of the viewport or remove default properties for an imageId if specified
+   */
+  clearDefaultProperties(imageId?: string): void;
   /**
    * Sets the properties for the viewport on the default actor. Properties include
    * setting the VOI, inverting the colors and setting the interpolation type, rotation
    */
   setProperties(
-    { voiRange, invert, interpolationType, rotation }: StackViewportProperties,
+    {
+      voiRange,
+      invert,
+      interpolationType,
+      rotation,
+      colormap,
+    }: StackViewportProperties,
     suppressEvents?: boolean
   ): void;
+  /**
+   * Retrieve the viewport default properties
+   */
+  getDefaultProperties: (imageId?: string) => StackViewportProperties;
   /**
    * Retrieve the viewport properties
    */
@@ -90,7 +114,11 @@ export default interface IStackViewport extends IViewport {
    */
   getCornerstoneImage: () => IImage;
   /**
-   * Reset the viewport properties to the default values
+   * Reset the viewport properties to the his default values if possible
+   */
+  resetToDefaultProperties(): void;
+  /**
+   * Reset the viewport properties to the default metadata values
    */
   resetProperties(): void;
   /**
@@ -132,11 +160,6 @@ export default interface IStackViewport extends IViewport {
    * If the renderer is CPU based, throw an error. Otherwise, returns the `vtkRenderer` responsible for rendering the `Viewport`.
    */
   getRenderer(): any;
-  /**
-   * Sets the colormap for the current viewport.
-   * @param colormap - The colormap data to use.
-   */
-  setColormap(colormap: CPUFallbackColormapData | ColormapRegistration): void;
   /**
    * It sets the colormap to the default colormap.
    */

package/src/types/IVolumeViewport.ts

@@ -13,10 +13,18 @@ import { VolumeViewportProperties } from '.';
 export default interface IVolumeViewport extends IViewport {
   useCPURendering: boolean;
   getFrameOfReferenceUID: () => string;
+
+  /**
+   * Retrieve the viewport default properties
+   * If volumeId is given, we retrieve the default properties of a volumeId if it exists
+   * If not given,we return the global properties of the viewport
+   * default viewport properties including voi, invert, interpolation type, colormap
+   */
+  getDefaultProperties: (volumeId?: string) => VolumeViewportProperties;
   /**
    * Retrieve the viewport properties
    */
-  getProperties: () => VolumeViewportProperties;
+  getProperties: (volumeId?: string) => VolumeViewportProperties;
   /**
    * canvasToWorld Returns the world coordinates of the given `canvasPos`
    * projected onto the plane defined by the `Viewport`'s `vtkCamera`'s focal point
@@ -57,6 +65,20 @@ export default interface IVolumeViewport extends IViewport {
    * currently being viewed.
    */
   getCurrentImageId: () => string;
+  /**
+   * Sets the default properties for the viewport. If no volumeId is provided
+   * it applies the properties to the default volume actor (first volume)
+   */
+  setDefaultProperties(
+    ViewportProperties: VolumeViewportProperties,
+    volumeId?: string
+  ): void;
+  /**
+   * Remove the global default properties of the viewport or remove default properties for a volumeId if specified
+   * If volumeId is given, we remove the default properties only for this volumeId, if not
+   * the global default properties will be removed
+   */
+  clearDefaultProperties(volumeId?: string): void;
   /**
    * Sets the properties for the viewport. If no volumeId is provided
    * it applies the properties to the default volume actor (first volume)
@@ -66,6 +88,10 @@ export default interface IVolumeViewport extends IViewport {
     volumeId?: string,
     suppressEvents?: boolean
   ): void;
+  /**
+   * Reset the viewport properties to the default values
+   */
+  resetProperties(volumeId: string): void;
   /**
    * Creates volume actors for all volumes defined in the `volumeInputArray`.
    * For each entry, if a `callback` is supplied, it will be called with the new volume actor as input.
@@ -142,8 +168,4 @@ export default interface IVolumeViewport extends IViewport {
   getImageData(volumeId?: string): IImageData | undefined;
 
   setOrientation(orientation: OrientationAxis): void;
-  /**
-   * Reset the viewport properties to the default values
-   */
-  resetProperties(volumeId?: string): void;
 }

package/src/types/ViewportProperties.ts

@@ -1,5 +1,6 @@
 import { InterpolationType, VOILUTFunctionType } from '../enums';
 import { VOIRange } from './voi';
+import { ColormapPublic } from './Colormap';
 
 /**
  * Shared Viewport Properties between Stack and Volume Viewports
@@ -11,6 +12,8 @@ type ViewportProperties = {
   VOILUTFunction?: VOILUTFunctionType;
   /** invert flag - whether the image is inverted */
   invert?: boolean;
+  /** Colormap applied to the viewport*/
+  colormap?: ColormapPublic;
   /** interpolation type */
   interpolationType?: InterpolationType;
 };

package/src/types/VolumeViewportProperties.ts

@@ -1,14 +1,13 @@
-import { ColormapPublic } from './Colormap';
 import { ViewportProperties } from './ViewportProperties';
 
 /**
  * Stack Viewport Properties
  */
 type VolumeViewportProperties = ViewportProperties & {
-  /** color maps  */
-  colormap?: ColormapPublic;
   /** 3d preset */
   preset?: string;
+
+  slabThickness?: number;
 };
 
 export default VolumeViewportProperties;

package/src/utilities/index.ts

@@ -51,6 +51,7 @@ import getImageLegacy from './getImageLegacy';
 import * as planar from './planar';
 import * as windowLevel from './windowLevel';
 import * as colormap from './colormap';
+import * as transferFunctionUtils from './transferFunctionUtils';
 
 export {
   csUtils as invertRgbTransferFunction,
@@ -105,4 +106,5 @@ export {
   getScalarDataType,
   colormap,
   getImageLegacy,
+  transferFunctionUtils,
 };

package/src/utilities/transferFunctionUtils.ts

@@ -0,0 +1,23 @@
+function getTransferFunctionNodes(transferFunction) {
+  const size = transferFunction.getSize();
+  const values = [];
+  for (let index = 0; index < size; index++) {
+    const nodeValue1 = [];
+
+    transferFunction.getNodeValue(index, nodeValue1);
+
+    values.push(nodeValue1);
+  }
+
+  return values;
+}
+
+function setTransferFunctionNodes(transferFunction, nodes) {
+  transferFunction.removeAllPoints();
+
+  nodes.forEach((node) => {
+    transferFunction.addRGBPoint(...node);
+  });
+}
+
+export { getTransferFunctionNodes, setTransferFunctionNodes };