@cornerstonejs/core 2.0.0-beta.6 → 2.0.0-beta.8

package/src/RenderingEngine/BaseVolumeViewport.ts

@@ -3,6 +3,8 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 
+import { vec2, vec3 } from 'gl-matrix';
+
 import cache from '../cache';
 import {
   MPR_CAMERA_VALUES,
@@ -31,11 +33,16 @@ import type {
   Point2,
   Point3,
   VOIRange,
+  EventTypes,
   VolumeViewportProperties,
+  ViewReferenceSpecifier,
+  ReferenceCompatibleOptions,
+  ViewPresentation,
+  ViewReference,
+  IVolumeViewport,
 } from '../types';
 import { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
-import type IVolumeViewport from '../types/IVolumeViewport';
 import {
   actorIsA,
   applyPreset,
@@ -45,6 +52,10 @@ import {
   invertRgbTransferFunction,
   triggerEvent,
   colormap as colormapUtils,
+  isEqualNegative,
+  getVolumeViewportScrollInfo,
+  snapFocalPointToSlice,
+  isEqual,
 } from '../utilities';
 import { createVolumeActor } from './helpers';
 import volumeNewImageEventDispatcher, {
@@ -54,7 +65,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';
 /**
  * Abstract base class for volume viewports. VolumeViewports are used to render
  * 3D volumes from which various orientations can be viewed. Since VolumeViewports
@@ -66,19 +78,25 @@ import transformWorldToIndex from '../utilities/transformWorldToIndex';
  */
 abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
   useCPURendering = false;
-  use16BitTexture = false;
+  useNativeDataType = false;
   private _FrameOfReferenceUID: string;
-  private inverted = false;
 
+  protected initialTransferFunctionNodes: any;
   // Viewport Properties
-  // TODO: similar to setVoi, this is only applicable to first volume
-  private VOILUTFunction: VOILUTFunctionType;
+  private globalDefaultProperties: VolumeViewportProperties;
+  private perVolumeIdDefaultProperties = new Map<
+    string,
+    VolumeViewportProperties
+  >();
+  // Camera properties
+  protected initialViewUp: Point3;
+  protected viewportProperties: VolumeViewportProperties = {};
 
   constructor(props: ViewportInput) {
     super(props);
 
     this.useCPURendering = getShouldUseCPURendering();
-    this.use16BitTexture = this._shouldUseNativeDataType();
+    this.useNativeDataType = this._shouldUseNativeDataType();
 
     if (this.useCPURendering) {
       throw new Error(
@@ -113,7 +131,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
   }
 
   protected applyViewOrientation(
-    orientation: OrientationAxis | OrientationVectors
+    orientation: OrientationAxis | OrientationVectors,
+    resetCamera = true
   ) {
     const { viewPlaneNormal, viewUp } =
       this._getOrientationVectors(orientation);
@@ -124,8 +143,11 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       -viewPlaneNormal[2]
     );
     camera.setViewUpFrom(viewUp);
+    this.initialViewUp = viewUp;
 
-    this.resetCamera();
+    if (resetCamera) {
+      this.resetCamera();
+    }
   }
 
   private initializeVolumeNewImageEventDispatcher(): void {
@@ -217,8 +239,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       voiLUTFunction = VOILUTFunctionType.LINEAR;
     }
     const { voiRange } = this.getProperties();
-    this.VOILUTFunction = voiLUTFunction;
     this.setVOI(voiRange, volumeId, suppressEvents);
+    this.viewportProperties.VOILUTFunction = voiLUTFunction;
   }
 
   /**
@@ -236,16 +258,12 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     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.name);
 
@@ -267,6 +285,20 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     cfun.applyColorMap(colormapObj);
     cfun.setMappingRange(range[0], range[1]);
     volumeActor.getProperty().setRGBTransferFunction(0, cfun);
+
+    // This configures the viewport to use the most recently applied colormap.
+    // However, this approach is not optimal when dealing with two volumes, as it prevents retrieval of the
+    // colormap for Volume A if Volume B's colormap was the last one applied.
+    this.viewportProperties.colormap = colormap;
+
+    if (!suppressEvents) {
+      const eventDetail = {
+        viewportId: this.id,
+        colormap,
+        volumeId,
+      };
+      triggerEvent(this.element, Events.COLORMAP_MODIFIED, eventDetail);
+    }
   }
 
   /**
@@ -283,6 +315,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       return;
     }
     const { volumeActor } = applicableVolumeActorInfo;
+
     const ofun = vtkPiecewiseFunction.newInstance();
     if (typeof colormap.opacity === 'number') {
       const range = volumeActor
@@ -298,19 +331,25 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       });
     }
     volumeActor.getProperty().setScalarOpacity(0, ofun);
+
+    if (!this.viewportProperties.colormap) {
+      this.viewportProperties.colormap = {};
+    }
+
+    this.viewportProperties.colormap.opacity = colormap.opacity;
   }
 
   /**
    * Sets the inversion for the volume transfer function
    *
-   * @param invert - Should the transfer function be inverted?
+   * @param inverted - Should the transfer function be inverted?
    * @param volumeId - volumeId
    * @param suppressEvents - If `true`, events will not be published
    *
    * @returns void
    */
   private setInvert(
-    invert: boolean,
+    inverted: boolean,
     volumeId?: string,
     suppressEvents?: boolean
   ) {
@@ -325,17 +364,11 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     const cfun = this._getOrCreateColorTransferFunction(volumeIdToUse);
     invertRgbTransferFunction(cfun);
 
-    this.inverted = invert;
-
-    const { voiRange } = this.getProperties();
+    this.viewportProperties.invert = inverted;
 
     if (!suppressEvents) {
       const eventDetail: VoiModifiedEventDetail = {
-        viewportId: this.id,
-        range: voiRange,
-        volumeId: volumeIdToUse,
-        VOILUTFunction: this.VOILUTFunction,
-        invert: this.inverted,
+        ...this.getVOIModifiedEventDetail(volumeIdToUse),
         invertStateChanged: true,
       };
 
@@ -343,6 +376,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 {
@@ -368,7 +434,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return newRGBTransferFunction;
   }
 
-  private setInterpolationType(
+  protected setInterpolationType(
     interpolationType: InterpolationType,
     volumeId?: string
   ) {
@@ -383,6 +449,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
 
     // @ts-ignore
     volumeProperty.setInterpolationType(interpolationType);
+    this.viewportProperties.interpolationType = interpolationType;
   }
 
   /**
@@ -415,9 +482,11 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       voiRangeToUse = maxVoiRange;
     }
 
+    const { VOILUTFunction } = this.getProperties(volumeIdToUse);
+
     // scaling logic here
     // https://github.com/Kitware/vtk-js/blob/c6f2e12cddfe5c0386a73f0793eb6d9ab20d573e/Sources/Rendering/OpenGL/VolumeMapper/index.js#L957-L972
-    if (this.VOILUTFunction === VOILUTFunctionType.SAMPLED_SIGMOID) {
+    if (VOILUTFunction === VOILUTFunctionType.SAMPLED_SIGMOID) {
       const cfun = createSigmoidRGBTransferFunction(voiRangeToUse);
       volumeActor.getProperty().setRGBTransferFunction(0, cfun);
     } else {
@@ -437,18 +506,281 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
 
     if (!suppressEvents) {
       const eventDetail: VoiModifiedEventDetail = {
-        viewportId: this.id,
-        range: voiRange,
-        volumeId: volumeIdToUse,
-        VOILUTFunction: this.VOILUTFunction,
+        ...this.getVOIModifiedEventDetail(volumeIdToUse),
       };
 
       triggerEvent(this.element, Events.VOI_MODIFIED, eventDetail);
     }
+
+    this.viewportProperties.voiRange = voiRangeToUse;
+  }
+
+  protected setRotation = (rotation: number) => {
+    const panFit = this.getPan(this.fitToCanvasCamera);
+    const pan = this.getPan();
+    const previousCamera = this.getCamera();
+    const panSub = vec2.sub([0, 0], panFit, pan) as Point2;
+    this.setPan(panSub, false);
+    const { flipVertical } = this.getCamera();
+
+    // Moving back to zero rotation, for new scrolled slice rotation is 0 after camera reset
+    const initialViewUp = flipVertical
+      ? vec3.negate([0, 0, 0], this.initialViewUp)
+      : this.initialViewUp;
+
+    this.setCameraNoEvent({
+      viewUp: initialViewUp as Point3,
+    });
+
+    // rotating camera to the new value
+    this.rotateCamera(rotation);
+    const afterPan = this.getPan();
+    const afterPanFit = this.getPan(this.fitToCanvasCamera);
+    const newCenter = vec2.sub([0, 0], afterPan, afterPanFit);
+    const newOffset = vec2.add([0, 0], panFit, newCenter) as Point2;
+    this.setPan(newOffset, false);
+
+    if (this._suppressCameraModifiedEvents) {
+      return;
+    }
+
+    // New camera after rotation
+    const camera = this.getCamera();
+
+    const eventDetail: EventTypes.CameraModifiedEventDetail = {
+      previousCamera,
+      camera,
+      element: this.element,
+      viewportId: this.id,
+      renderingEngineId: this.renderingEngineId,
+      rotation,
+    };
+
+    triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
+    this.viewportProperties.rotation = rotation;
+  };
+
+  private rotateCamera(rotation: number): void {
+    const rotationToApply = rotation - this.getRotation();
+    // rotating camera to the new value
+    this.getVtkActiveCamera().roll(-rotationToApply);
+  }
+
+  /**
+   * Update the default properties for the volume viewport on the volume
+   * @param ViewportProperties - The properties to set
+   * @param volumeId - The volume id to set the default properties for (if undefined, we set the global default viewport properties)
+   */
+  public setDefaultProperties(
+    ViewportProperties: VolumeViewportProperties,
+    volumeId?: string
+  ): void {
+    if (volumeId == null) {
+      this.globalDefaultProperties = ViewportProperties;
+    } else {
+      this.perVolumeIdDefaultProperties.set(volumeId, ViewportProperties);
+    }
+  }
+
+  /**
+   * Remove the global default properties of the viewport or remove default properties for a volumeId if specified
+   * @param volumeId If given, we remove the default properties only for this volumeId, if not
+   * the global default properties will be removed
+   */
+  public clearDefaultProperties(volumeId?: string): void {
+    if (volumeId == null) {
+      this.globalDefaultProperties = {};
+      this.resetProperties();
+    } else {
+      this.perVolumeIdDefaultProperties.delete(volumeId);
+      this.resetToDefaultProperties(volumeId);
+    }
+  }
+
+  /**
+   * Gets a view target, allowing comparison between view positions as well
+   * as restoring views later.
+   */
+  public getViewReference(
+    viewRefSpecifier: ViewReferenceSpecifier = {}
+  ): ViewReference {
+    const target = super.getViewReference(viewRefSpecifier);
+    const volumeId = this.getVolumeId(viewRefSpecifier);
+    if (viewRefSpecifier?.forFrameOfReference !== false) {
+      target.volumeId = volumeId;
+    }
+    if (typeof viewRefSpecifier?.sliceIndex !== 'number') {
+      return target;
+    }
+    const { viewPlaneNormal } = target;
+    const delta =
+      (viewRefSpecifier.sliceIndex as number) - this.getSliceIndex();
+    // Calculate a camera focal point and position
+    const { sliceRangeInfo } = getVolumeViewportScrollInfo(
+      this,
+      volumeId,
+      true
+    );
+
+    const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
+    const { focalPoint, position } = camera;
+    const { newFocalPoint } = snapFocalPointToSlice(
+      focalPoint,
+      position,
+      sliceRange,
+      viewPlaneNormal,
+      spacingInNormalDirection,
+      delta
+    );
+    target.cameraFocalPoint = newFocalPoint;
+
+    return target;
+  }
+
+  /**
+   * Find out if this viewport would show this view
+   *
+   * @param options - allows specifying whether the view COULD display this with
+   *                  some modification - either navigation or displaying as volume.
+   * @returns true if the target is compatible with this view
+   */
+  public isReferenceViewable(
+    viewRef: ViewReference,
+    options?: ReferenceCompatibleOptions
+  ): boolean {
+    if (!viewRef.FrameOfReferenceUID) {
+      return false;
+    }
+    if (!super.isReferenceViewable(viewRef, options)) {
+      return false;
+    }
+    if (options?.withNavigation) {
+      return true;
+    }
+    const currentSliceIndex = this.getSliceIndex();
+    const { sliceIndex } = viewRef;
+    if (Array.isArray(sliceIndex)) {
+      return (
+        sliceIndex[0] <= currentSliceIndex && currentSliceIndex <= sliceIndex[1]
+      );
+    }
+    return sliceIndex === undefined || sliceIndex === currentSliceIndex;
+  }
+
+  /**
+   * Scrolls the viewport in the given direction/amount
+   */
+  public scroll(delta = 1) {
+    const volumeId = this.getVolumeId();
+    const { sliceRangeInfo } = getVolumeViewportScrollInfo(
+      this,
+      volumeId,
+      true
+    );
+
+    if (!sliceRangeInfo) {
+      return;
+    }
+
+    const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
+    const { focalPoint, viewPlaneNormal, position } = camera;
+
+    const { newFocalPoint, newPosition } = snapFocalPointToSlice(
+      focalPoint,
+      position,
+      sliceRange,
+      viewPlaneNormal,
+      spacingInNormalDirection,
+      delta
+    );
+
+    this.setCamera({
+      focalPoint: newFocalPoint,
+      position: newPosition,
+    });
+  }
+
+  /**
+   * Navigates to the specified view reference.
+   */
+  public setViewReference(viewRef: ViewReference): void {
+    if (!viewRef) {
+      return;
+    }
+    const volumeId = this.getVolumeId();
+    const {
+      viewPlaneNormal: refViewPlaneNormal,
+      FrameOfReferenceUID: refFrameOfReference,
+      cameraFocalPoint,
+      viewUp,
+    } = viewRef;
+    let { sliceIndex } = viewRef;
+    const { focalPoint, viewPlaneNormal, position } = this.getCamera();
+    const isNegativeNormal = isEqualNegative(
+      viewPlaneNormal,
+      refViewPlaneNormal
+    );
+    const isSameNormal = isEqual(viewPlaneNormal, refViewPlaneNormal);
+
+    // Handle slices
+    if (
+      typeof sliceIndex === 'number' &&
+      viewRef.volumeId === volumeId &&
+      (isNegativeNormal || isSameNormal)
+    ) {
+      const { currentStepIndex, sliceRangeInfo, numScrollSteps } =
+        getVolumeViewportScrollInfo(this, volumeId, true);
+
+      const { sliceRange, spacingInNormalDirection } = sliceRangeInfo;
+      if (isNegativeNormal) {
+        // Convert opposite orientation view refs to normal orientation
+        sliceIndex = numScrollSteps - sliceIndex - 1;
+      }
+      const delta = sliceIndex - currentStepIndex;
+      const { newFocalPoint, newPosition } = snapFocalPointToSlice(
+        focalPoint,
+        position,
+        sliceRange,
+        viewPlaneNormal,
+        spacingInNormalDirection,
+        delta
+      );
+      this.setCamera({ focalPoint: newFocalPoint, position: newPosition });
+    } else if (refFrameOfReference === this.getFrameOfReferenceUID()) {
+      // Handle same frame of reference navigation
+
+      if (refViewPlaneNormal && !isNegativeNormal && !isSameNormal) {
+        // Need to update the orientation vectors correctly for this case
+        // this.setCameraNoEvent({ viewPlaneNormal: refViewPlaneNormal, viewUp });
+        this.setOrientation({ viewPlaneNormal: refViewPlaneNormal, viewUp });
+        return this.setViewReference(viewRef);
+      }
+      if (cameraFocalPoint) {
+        const focalDelta = vec3.subtract(
+          [0, 0, 0],
+          cameraFocalPoint,
+          focalPoint
+        );
+        const useNormal = refViewPlaneNormal ?? viewPlaneNormal;
+        const normalDot = vec3.dot(focalDelta, useNormal);
+        if (!isEqual(normalDot, 0)) {
+          // Gets the portion of the focal point in the normal direction
+          vec3.scale(focalDelta, useNormal, normalDot);
+        }
+        const newFocal = <Point3>vec3.add([0, 0, 0], focalPoint, focalDelta);
+        const newPosition = <Point3>vec3.add([0, 0, 0], position, focalDelta);
+        this.setCamera({ focalPoint: newFocal, position: newPosition });
+      }
+    } else {
+      throw new Error(
+        `Incompatible view refs: ${refFrameOfReference}!==${this.getFrameOfReferenceUID()}`
+      );
+    }
   }
 
   /**
    * Sets the properties for the volume viewport on the volume
+   * and if setProperties is called for the first time, the properties will also become the default one.
    * (if fusion, it sets it for the first volume in the fusion)
    *
    * @param VolumeViewportProperties - The properties to set
@@ -456,7 +788,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    * @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 [VolumeViewportProperties.preset] - Sets the colormap preset
    * @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
    */
@@ -468,10 +800,25 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       colormap,
       preset,
       interpolationType,
+      slabThickness,
+      rotation,
     }: VolumeViewportProperties = {},
     volumeId?: string,
     suppressEvents = false
   ): void {
+    //If the viewport hasn't been initialized, we need to set the default properties
+    if (this.globalDefaultProperties == null) {
+      this.setDefaultProperties({
+        voiRange,
+        VOILUTFunction,
+        invert,
+        colormap,
+        preset,
+        slabThickness,
+        rotation,
+      });
+    }
+
     // Note: colormap should always be done first, since we can then
     // modify the voiRange
 
@@ -494,13 +841,61 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
     }
 
-    if (invert !== undefined && this.inverted !== invert) {
+    if (invert !== undefined && this.viewportProperties.invert !== invert) {
       this.setInvert(invert, volumeId, suppressEvents);
     }
 
     if (preset !== undefined) {
       this.setPreset(preset, volumeId, suppressEvents);
     }
+
+    if (slabThickness !== undefined) {
+      this.setSlabThickness(slabThickness);
+      //We need to set the current slab thickness here since setSlabThickness is define in VolumeViewport
+      this.viewportProperties.slabThickness = slabThickness;
+    }
+
+    if (rotation !== undefined) {
+      this.setRotation(rotation);
+    }
+  }
+
+  /**
+   * Reset the viewport properties to the default values
+   */
+  public resetToDefaultProperties(volumeId: string): void {
+    const properties = this.globalDefaultProperties;
+
+    if (properties.colormap?.name) {
+      this.setColormap(properties.colormap, volumeId);
+    }
+    if (properties.colormap?.opacity != null) {
+      this.setOpacity(properties.colormap, volumeId);
+    }
+
+    if (properties.voiRange !== undefined) {
+      this.setVOI(properties.voiRange, volumeId);
+    }
+
+    if (properties.VOILUTFunction !== undefined) {
+      this.setVOILUTFunction(properties.VOILUTFunction, volumeId);
+    }
+
+    if (properties.invert !== undefined) {
+      this.setInvert(properties.invert, volumeId);
+    }
+
+    if (properties.slabThickness !== undefined) {
+      this.setSlabThickness(properties.slabThickness);
+      //We need to set the current slabThickness here since setSlabThickness is define in VolumeViewport
+      this.viewportProperties.slabThickness = properties.slabThickness;
+    }
+
+    if (properties.rotation !== undefined) {
+      this.setRotation(properties.rotation);
+    }
+
+    this.render();
   }
 
   /**
@@ -512,7 +907,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    *
    * @returns void
    */
-  private setPreset(presetName, volumeId, suppressEvents) {
+  private setPreset(presetNameOrObj, volumeId, suppressEvents) {
     const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
 
     if (!applicableVolumeActorInfo) {
@@ -521,22 +916,77 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
 
     const { volumeActor } = applicableVolumeActorInfo;
 
-    const preset = VIEWPORT_PRESETS.find((preset) => {
-      return preset.name === presetName;
-    });
+    let preset = presetNameOrObj;
+
+    if (typeof preset === 'string') {
+      preset = VIEWPORT_PRESETS.find((preset) => {
+        return preset.name === presetNameOrObj;
+      });
+    }
 
     if (!preset) {
       return;
     }
 
     applyPreset(volumeActor, preset);
+
+    this.viewportProperties.preset = preset;
+    this.render();
+
+    if (!suppressEvents) {
+      triggerEvent(this.element, Events.PRESET_MODIFIED, {
+        viewportId: this.id,
+        volumeId: applicableVolumeActorInfo.volumeId,
+        actor: volumeActor,
+        presetName: preset.name,
+      });
+    }
   }
 
+  /**
+   * Retrieve the viewport default properties
+   * @param volumeId If given, we retrieve the default properties of a volumeId if it exists
+   * If not given,we return the global properties of the viewport
+   * @returns default viewport properties including voi, invert, interpolation type, colormap
+   */
+  public getDefaultProperties = (
+    volumeId?: string
+  ): VolumeViewportProperties => {
+    let volumeProperties;
+    if (volumeId !== undefined) {
+      volumeProperties = this.perVolumeIdDefaultProperties.get(volumeId);
+    }
+
+    if (volumeProperties !== undefined) {
+      return volumeProperties;
+    }
+
+    return {
+      ...this.globalDefaultProperties,
+    };
+  };
+
   /**
    * Retrieve the viewport properties
+   * @param volumeId - The volume id to get the properties for (if undefined, the first volume)
    * @returns viewport properties including voi, interpolation type: TODO: slabThickness, invert, rotation, flip
    */
-  public getProperties = (): VolumeViewportProperties => {
+  public getProperties = (volumeId?: string): VolumeViewportProperties => {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const {
+      colormap: latestColormap,
+      VOILUTFunction,
+      interpolationType,
+      invert,
+      slabThickness,
+      rotation,
+      preset,
+    } = this.viewportProperties;
+
     const voiRanges = this.getActors()
       .map((actorEntry) => {
         const volumeActor = actorEntry.actor as vtkVolume;
@@ -547,17 +997,65 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         }
         const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
         const [lower, upper] =
-          this.VOILUTFunction === 'SIGMOID'
+          this.viewportProperties?.VOILUTFunction === 'SIGMOID'
             ? getVoiFromSigmoidRGBTransferFunction(cfun)
             : cfun.getRange();
         return { volumeId, voiRange: { lower, upper } };
       })
       .filter(Boolean);
 
-    const voiRange = voiRanges.length ? voiRanges[0].voiRange : null;
-    const VOILUTFunction = this.VOILUTFunction;
+    const voiRange = volumeId
+      ? voiRanges.find((range) => range.volumeId === volumeId)?.voiRange
+      : voiRanges[0]?.voiRange;
+
+    const volumeColormap = this.getColormap(volumeId);
+
+    const colormap =
+      volumeId && volumeColormap ? volumeColormap : latestColormap;
+
+    return {
+      colormap: colormap,
+      voiRange: voiRange,
+      VOILUTFunction: VOILUTFunction,
+      interpolationType: interpolationType,
+      invert: invert,
+      slabThickness: slabThickness,
+      rotation: rotation,
+      preset,
+    };
+  };
+
+  /**
+   * This function extracts the nodes from the RGB Transfer Function, transforming each node's x, r, g, b properties
+   * into a unified array "RGB Points." Then, it compares these RGB Points—specifically the r, g, b values—with
+   * those in the predefined vtk colormap presets. Upon finding a matching set of r, g, b values, the function identifies and selects the
+   * corresponding colormap.
+   *
+   * Next, the function extracts an array of opacity points, formatted as a sequence of [x,y] pairs, where 'x' represents a value and
+   * 'y' represents its opacity. It iterates through this array to construct an opacity object that maps each value to its opacity.
+   *
+   * The function returns an object that includes the name of the identified colormap and the constructed opacity object.
+   * @param applicableVolumeActorInfo  - The volume actor information for the volume
+   * @returns colormap information for the volume if identified
+   */
+  private getColormap = (volumeId) => {
+    const applicableVolumeActorInfo = this._getApplicableVolumeActor(volumeId);
+
+    if (!applicableVolumeActorInfo) {
+      return;
+    }
+
+    const { volumeActor } = applicableVolumeActorInfo;
+    const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
+    const { nodes } = cfun.getState();
+    const RGBPoints = nodes.reduce((acc, node) => {
+      acc.push(node.x, node.r, node.g, node.b);
+      return acc;
+    }, []);
+
+    const matchedColormap = findMatchingColormap(RGBPoints, volumeActor);
 
-    return { voiRange, VOILUTFunction, invert: this.inverted };
+    return matchedColormap;
   };
 
   /**
@@ -599,7 +1097,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         this.element,
         this.id,
         suppressEvents,
-        this.use16BitTexture
+        this.useNativeDataType
       );
 
       // We cannot use only volumeId since then we cannot have for instance more
@@ -619,6 +1117,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,
@@ -665,7 +1165,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
         this.element,
         this.id,
         suppressEvents,
-        this.use16BitTexture
+        this.useNativeDataType
       );
 
       if (visibility === false) {
@@ -693,6 +1193,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
 
     this.addActors(volumeActors);
 
+    this.initializeColorTransferFunction(volumeInputArray);
+
     if (immediate) {
       // render
       this.render();
@@ -725,10 +1227,32 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    * @param orientation - The orientation to set the camera to.
    * @param immediate - Whether the `Viewport` should be rendered as soon as the camera is set.
    */
-  public setOrientation(orientation: OrientationAxis, immediate = true): void {
+  public setOrientation(
+    _orientation: OrientationAxis | OrientationVectors,
+    _immediate = true
+  ): void {
     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;
@@ -783,6 +1307,56 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return true;
   }
 
+  /**
+   * Gets the rotation resulting from the value set in setRotation AND taking into
+   * account any flips that occurred subsequently from the camera provided or the viewport.
+   *
+   * @returns the rotation resulting from the value set in setRotation AND taking into
+   * account any flips that occurred subsequently.
+   */
+  public getRotation = (): number => {
+    const {
+      viewUp: currentViewUp,
+      viewPlaneNormal,
+      flipVertical,
+    } = this.getCamera();
+
+    // The initial view up vector without any rotation, but incorporating vertical flip.
+    const initialViewUp = flipVertical
+      ? vec3.negate([0, 0, 0], this.initialViewUp)
+      : this.initialViewUp;
+
+    if (!initialViewUp) {
+      return 0;
+    }
+
+    // The angle between the initial and current view up vectors.
+    // TODO: check with VTK about rounding errors here.
+    const initialToCurrentViewUpAngle =
+      (vec3.angle(initialViewUp, currentViewUp) * 180) / Math.PI;
+
+    // Now determine if initialToCurrentViewUpAngle is positive or negative by comparing
+    // the direction of the initial/current view up cross product with the current
+    // viewPlaneNormal.
+
+    const initialToCurrentViewUpCross = vec3.cross(
+      [0, 0, 0],
+      initialViewUp,
+      currentViewUp
+    );
+
+    // The sign of the dot product of the start/end view up cross product and
+    // the viewPlaneNormal indicates a positive or negative rotation respectively.
+    const normalDot = vec3.dot(initialToCurrentViewUpCross, viewPlaneNormal);
+
+    const value =
+      normalDot >= 0
+        ? initialToCurrentViewUpAngle
+        : (360 - initialToCurrentViewUpAngle) % 360;
+
+    return value;
+  };
+
   /**
    * gets the visible bounds of the viewport in the world coordinate system
    */
@@ -873,7 +1447,10 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
    */
   private _setVolumeActors(volumeActorEntries: Array<ActorEntry>): void {
     // New volume actors implies resetting the inverted flag (i.e. like starting from scratch).
-    this.inverted = false;
+
+    for (let i = 0; i < volumeActorEntries.length; i++) {
+      this.viewportProperties.invert = false;
+    }
     this.setActors(volumeActorEntries);
   }
 
@@ -1052,6 +1629,7 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
       typeof orientation === 'string' &&
       MPR_CAMERA_VALUES[orientation]
     ) {
+      this.viewportProperties.orientation = orientation;
       return MPR_CAMERA_VALUES[orientation];
     } else {
       throw new Error(
@@ -1130,10 +1708,64 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     return imageVolume.imageIds;
   };
 
-  abstract getCurrentImageIdIndex(): number;
-
   abstract getCurrentImageId(): string;
 
+  /**
+   * Gets the volumeId to use for references.
+   * Returns undefined if the specified volume is NOT in this viewport.
+   */
+  protected getVolumeId(specifier?: ViewReferenceSpecifier) {
+    const actorEntries = this.getActors();
+    if (!actorEntries) {
+      return;
+    }
+    if (!specifier?.volumeId) {
+      // find the first image actor of instance type vtkVolume
+      return actorEntries.find(
+        (actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume'
+      )?.uid;
+    }
+
+    // See if this volumeId can be found in one of the actors for this
+    // viewport.  This check will cause undefined to be returned when the
+    // volumeId isn't currently shown in this viewport.
+    return actorEntries.find(
+      (actorEntry) =>
+        actorEntry.actor.getClassName() === 'vtkVolume' &&
+        actorEntry.uid === specifier.volumeId
+    )?.uid;
+  }
+
+  /**
+   * For a volume viewport, the reference id will be a URN starting with
+   * `volumeId:<volumeId>`, followed by additional arguments to specify
+   * the view orientation.  This will end up being a unique string that
+   * identifies the view reference being shown.  It is different from the
+   * view reference in that the values are all incorporated into a string to
+   * allow using it as a parameter key.
+   */
+  public getReferenceId(specifier: ViewReferenceSpecifier = {}): string {
+    let { volumeId, sliceIndex: sliceIndex } = specifier;
+    if (!volumeId) {
+      const actorEntries = this.getActors();
+      if (!actorEntries) {
+        return;
+      }
+      // find the first image actor of instance type vtkVolume
+      volumeId = actorEntries.find(
+        (actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume'
+      )?.uid;
+    }
+
+    const currentIndex = this.getSliceIndex();
+    sliceIndex ??= currentIndex;
+    const { viewPlaneNormal, focalPoint } = this.getCamera();
+    const querySeparator = volumeId.indexOf('?') > -1 ? '&' : '?';
+    return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${viewPlaneNormal.join(
+      ','
+    )}&focalPoint=${focalPoint.join(',')}`;
+  }
+
   abstract setBlendMode(
     blendMode: BlendModes,
     filterActorUIDs?: Array<string>,
@@ -1145,6 +1777,8 @@ abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
     filterActorUIDs?: Array<string>
   ): void;
 
+  abstract resetSlabThickness(): void;
+
   abstract resetProperties(volumeId?: string): void;
 }