@cornerstonejs/core 0.36.3 → 0.36.4

package/src/RenderingEngine/VolumeViewport.ts

@@ -0,0 +1,420 @@
+import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+import { vec3 } from 'gl-matrix';
+
+import cache from '../cache';
+import { EPSILON, MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
+import { BlendModes, OrientationAxis } from '../enums';
+import type {
+  ActorEntry,
+  IImageVolume,
+  IVolumeInput,
+  OrientationVectors,
+  Point3,
+} from '../types';
+import type { ViewportInput } from '../types/IViewport';
+import { actorIsA } from '../utilities';
+import transformWorldToIndex from '../utilities/transformWorldToIndex';
+import BaseVolumeViewport from './BaseVolumeViewport';
+
+/**
+ * An object representing a VolumeViewport. VolumeViewports are used to render
+ * 3D volumes from which various orientations can be viewed. Since VolumeViewports
+ * use SharedVolumeMappers behind the scene, memory footprint of visualizations
+ * of the same volume in different orientations is very small.
+ *
+ * For setting volumes on viewports you need to use {@link addVolumesToViewports}
+ * which will add volumes to the specified viewports.
+ */
+class VolumeViewport extends BaseVolumeViewport {
+  private _useAcquisitionPlaneForViewPlane = false;
+  constructor(props: ViewportInput) {
+    super(props);
+
+    const { orientation } = this.options;
+
+    // if the camera is set to be acquisition axis then we need to skip
+    // it for now until the volume is set
+    if (orientation && orientation !== OrientationAxis.ACQUISITION) {
+      this.applyViewOrientation(orientation);
+      return;
+    }
+
+    this._useAcquisitionPlaneForViewPlane = true;
+  }
+
+  /**
+   * 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.
+   * For each entry, if a `blendMode` and/or `slabThickness` is defined, this will be set on the actor's
+   * `VolumeMapper`.
+   *
+   * @param volumeInputArray - The array of `VolumeInput`s which define the volumes to add.
+   * @param immediate - Whether the `Viewport` should be rendered as soon as volumes are added.
+   */
+  public async setVolumes(
+    volumeInputArray: Array<IVolumeInput>,
+    immediate = false,
+    suppressEvents = false
+  ): Promise<void> {
+    const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
+
+    if (!firstImageVolume) {
+      throw new Error(
+        `imageVolume with id: ${firstImageVolume.volumeId} does not exist`
+      );
+    }
+
+    if (this._useAcquisitionPlaneForViewPlane) {
+      this._setViewPlaneToAcquisitionPlane(firstImageVolume);
+      this._useAcquisitionPlaneForViewPlane = false;
+    }
+
+    return super.setVolumes(volumeInputArray, immediate, suppressEvents);
+  }
+
+  /**
+   * Creates and adds 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.
+   *
+   * @param volumeInputArray - The array of `VolumeInput`s which define the volumes to add.
+   * @param immediate - Whether the `Viewport` should be rendered as soon as volumes are added.
+   */
+  public async addVolumes(
+    volumeInputArray: Array<IVolumeInput>,
+    immediate = false,
+    suppressEvents = false
+  ): Promise<void> {
+    const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
+
+    if (!firstImageVolume) {
+      throw new Error(
+        `imageVolume with id: ${firstImageVolume.volumeId} does not exist`
+      );
+    }
+
+    if (this._useAcquisitionPlaneForViewPlane) {
+      this._setViewPlaneToAcquisitionPlane(firstImageVolume);
+      this._useAcquisitionPlaneForViewPlane = false;
+    }
+
+    return super.addVolumes(volumeInputArray, immediate, suppressEvents);
+  }
+
+  /**
+   * It sets the orientation for the camera, the orientation can be one of the
+   * following: axial, sagittal, coronal, default. Use the Enums.OrientationAxis
+   * to set the orientation. The "default" orientation is the orientation that
+   * the volume was acquired in (scan axis)
+   *
+   * @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 {
+    let viewPlaneNormal, viewUp;
+
+    if (MPR_CAMERA_VALUES[orientation]) {
+      ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
+    } else if (orientation === 'acquisition') {
+      ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+    } else {
+      throw new Error(
+        `Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`
+      );
+    }
+
+    this.setCamera({
+      viewPlaneNormal,
+      viewUp,
+    });
+
+    this.resetCamera();
+
+    if (immediate) {
+      this.render();
+    }
+  }
+
+  private _getAcquisitionPlaneOrientation(): OrientationVectors {
+    const actorEntry = this.getDefaultActor();
+
+    if (!actorEntry) {
+      return;
+    }
+
+    // Todo: fix this after we add the volumeId reference to actorEntry later
+    // in the segmentation refactor
+    const volumeId = actorEntry.uid;
+
+    const imageVolume = cache.getVolume(volumeId);
+
+    if (!imageVolume) {
+      throw new Error(
+        `imageVolume with id: ${volumeId} does not exist in cache`
+      );
+    }
+
+    const { direction } = imageVolume;
+    const viewPlaneNormal = direction.slice(6, 9).map((x) => -x) as Point3;
+    const viewUp = (direction.slice(3, 6) as Point3).map((x) => -x) as Point3;
+
+    return {
+      viewPlaneNormal,
+      viewUp,
+    };
+  }
+
+  private _setViewPlaneToAcquisitionPlane(imageVolume: IImageVolume): void {
+    let viewPlaneNormal, viewUp;
+
+    if (imageVolume) {
+      const { direction } = imageVolume;
+      viewPlaneNormal = direction.slice(6, 9).map((x) => -x) as Point3;
+      viewUp = (direction.slice(3, 6) as Point3).map((x) => -x) as Point3;
+    } else {
+      ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+    }
+
+    this.setCamera({
+      viewPlaneNormal,
+      viewUp,
+    });
+
+    this.resetCamera();
+  }
+
+  /**
+   * Given a point in world coordinates, return the intensity at that point
+   * @param point - The point in world coordinates to get the intensity
+   * from.
+   * @returns The intensity value of the voxel at the given point.
+   */
+  public getIntensityFromWorld(point: Point3): number {
+    const actorEntry = this.getDefaultActor();
+    if (!actorIsA(actorEntry, 'vtkVolume')) {
+      return;
+    }
+
+    const { actor, uid } = actorEntry;
+    const imageData = actor.getMapper().getInputData();
+
+    const volume = cache.getVolume(uid);
+    const { dimensions } = volume;
+
+    const index = transformWorldToIndex(imageData, point);
+
+    const voxelIndex =
+      index[2] * dimensions[0] * dimensions[1] +
+      index[1] * dimensions[0] +
+      index[0];
+
+    return volume.getScalarData()[voxelIndex];
+  }
+
+  public setBlendMode(
+    blendMode: BlendModes,
+    filterActorUIDs = [],
+    immediate = false
+  ): void {
+    let actorEntries = this.getActors();
+
+    if (filterActorUIDs && filterActorUIDs.length > 0) {
+      actorEntries = actorEntries.filter((actorEntry: ActorEntry) => {
+        return filterActorUIDs.includes(actorEntry.uid);
+      });
+    }
+
+    actorEntries.forEach((actorEntry) => {
+      const { actor } = actorEntry;
+
+      const mapper = actor.getMapper();
+      // @ts-ignore vtk incorrect typing
+      mapper.setBlendMode(blendMode);
+    });
+
+    if (immediate) {
+      this.render();
+    }
+  }
+
+  /**
+   * Reset the camera for the volume viewport
+   */
+  public resetCamera(
+    resetPan = true,
+    resetZoom = true,
+    resetToCenter = true
+  ): boolean {
+    super.resetCamera(resetPan, resetZoom, resetToCenter);
+
+    this.resetVolumeViewportClippingRange();
+
+    const activeCamera = this.getVtkActiveCamera();
+    const viewPlaneNormal = <Point3>activeCamera.getViewPlaneNormal();
+    const focalPoint = <Point3>activeCamera.getFocalPoint();
+
+    // always add clipping planes for the volume viewport. If a use case
+    // arises where we don't want clipping planes, you should use the volume_3d
+    // viewport instead.
+    const actorEntries = this.getActors();
+    actorEntries.forEach((actorEntry) => {
+      if (!actorEntry.actor) {
+        return;
+      }
+      const mapper = actorEntry.actor.getMapper();
+      const vtkPlanes = mapper.getClippingPlanes();
+
+      if (vtkPlanes.length === 0) {
+        const clipPlane1 = vtkPlane.newInstance();
+        const clipPlane2 = vtkPlane.newInstance();
+        const newVtkPlanes = [clipPlane1, clipPlane2];
+
+        let slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+        if (actorEntry.slabThickness) {
+          slabThickness = actorEntry.slabThickness;
+        }
+
+        this.setOrientationOfClippingPlanes(
+          newVtkPlanes,
+          slabThickness,
+          viewPlaneNormal,
+          focalPoint
+        );
+
+        mapper.addClippingPlane(clipPlane1);
+        mapper.addClippingPlane(clipPlane2);
+      }
+    });
+
+    return true;
+  }
+
+  /**
+   * It sets the slabThickness of the actors of the viewport. If filterActorUIDs are
+   * provided, only the actors with the given UIDs will be affected. If no
+   * filterActorUIDs are provided, all actors will be affected.
+   *
+   * @param slabThickness - The slab thickness to set.
+   * @param blendMode - The blend mode to use when rendering the actors.
+   * @param filterActorUIDs - Optional argument to filter the actors to apply
+   * the slab thickness to (if not provided, all actors will be affected).
+   */
+  public setSlabThickness(slabThickness: number, filterActorUIDs = []): void {
+    let actorEntries = this.getActors();
+
+    if (filterActorUIDs && filterActorUIDs.length > 0) {
+      actorEntries = actorEntries.filter((actorEntry) => {
+        return filterActorUIDs.includes(actorEntry.uid);
+      });
+    }
+
+    actorEntries.forEach((actorEntry) => {
+      if (actorIsA(actorEntry, 'vtkVolume')) {
+        actorEntry.slabThickness = slabThickness;
+      }
+    });
+
+    const currentCamera = this.getCamera();
+    this.updateClippingPlanesForActors(currentCamera);
+    this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
+  }
+
+  /**
+   * Gets the largest slab thickness from all actors in the viewport.
+   *
+   * @returns slabThickness - The slab thickness.
+   */
+  public getSlabThickness(): number {
+    const actors = this.getActors();
+    let slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+    actors.forEach((actor) => {
+      if (actor.slabThickness > slabThickness) {
+        slabThickness = actor.slabThickness;
+      }
+    });
+
+    return slabThickness;
+  }
+
+  /**
+   * Uses viewport camera and volume actor to decide if the viewport
+   * is looking at the volume in the direction of acquisition (imageIds).
+   * If so, it uses the origin and focalPoint to calculate the slice index.
+   * Todo: This only works if the imageIds are properly sorted
+   *
+   * @returns The slice index
+   */
+  public getCurrentImageIdIndex = (): number | undefined => {
+    return this._getImageIdIndex();
+  };
+
+  /**
+   * Uses viewport camera and volume actor to decide if the viewport
+   * is looking at the volume in the direction of acquisition (imageIds).
+   * If so, it uses the origin and focalPoint to find which imageId is
+   * currently being viewed.
+   *
+   * @returns ImageId
+   */
+  public getCurrentImageId = (): string | undefined => {
+    const index = this._getImageIdIndex();
+
+    if (isNaN(index)) {
+      return;
+    }
+
+    const actorEntry = this.getDefaultActor();
+    if (!actorIsA(actorEntry, 'vtkVolume')) {
+      return;
+    }
+
+    const { uid } = actorEntry;
+    const volume = cache.getVolume(uid);
+
+    if (!volume) {
+      return;
+    }
+
+    const imageIds = volume.imageIds;
+
+    return imageIds[index];
+  };
+
+  private _getImageIdIndex = () => {
+    const { viewPlaneNormal, focalPoint } = this.getCamera();
+
+    // Todo: handle scenario of fusion of multiple volumes
+    // we cannot only check number of actors, because we might have
+    // segmentations ...
+    const { direction, origin, spacing } = this.getImageData();
+
+    // get the last 3 components of the direction - axis normal
+    const dir = direction.slice(direction.length - 3);
+
+    const dot = Math.abs(
+      dir[0] * viewPlaneNormal[0] +
+        dir[1] * viewPlaneNormal[1] +
+        dir[2] * viewPlaneNormal[2]
+    );
+
+    // if dot is not 1 or -1 return null since it means
+    // viewport is not looking at the image acquisition plane
+    if (dot - 1 > EPSILON) {
+      return;
+    }
+
+    // how many steps are from the origin to the focal point in the
+    // normal direction
+    const spacingInNormal = spacing[2];
+    const sub = vec3.create();
+    vec3.sub(sub, focalPoint, origin);
+    const distance = vec3.dot(sub, viewPlaneNormal);
+
+    // divide by the spacing in the normal direction to get the
+    // number of steps, and subtract 1 to get the index
+    return Math.round(Math.abs(distance) / spacingInNormal);
+  };
+
+  getRotation = (): number => 0;
+}
+
+export default VolumeViewport;

package/src/RenderingEngine/VolumeViewport3D.ts

@@ -0,0 +1,42 @@
+import { OrientationAxis } from '../enums';
+import type { ViewportInput } from '../types/IViewport';
+import BaseVolumeViewport from './BaseVolumeViewport';
+
+/**
+ * An object representing a 3-dimensional volume viewport. VolumeViewport3Ds are used to render
+ * 3D volumes in their entirety, and not just load a single slice at a time.
+ *
+ * For setting volumes on viewports you need to use {@link addVolumesToViewports}
+ * which will add volumes to the specified viewports.
+ */
+class VolumeViewport3D extends BaseVolumeViewport {
+  constructor(props: ViewportInput) {
+    super(props);
+
+    const { parallelProjection, orientation } = this.options;
+
+    const activeCamera = this.getVtkActiveCamera();
+
+    if (parallelProjection != null) {
+      activeCamera.setParallelProjection(parallelProjection);
+    }
+
+    if (orientation && orientation !== OrientationAxis.ACQUISITION) {
+      this.applyViewOrientation(orientation);
+    }
+  }
+
+  public resetCamera(
+    resetPan = true,
+    resetZoom = true,
+    resetToCenter = true
+  ): boolean {
+    super.resetCamera(resetPan, resetZoom, resetToCenter);
+    this.resetVolumeViewportClippingRange();
+    return;
+  }
+
+  getRotation = (): number => 0;
+}
+
+export default VolumeViewport3D;

package/src/RenderingEngine/getRenderingEngine.ts

@@ -0,0 +1,34 @@
+import renderingEngineCache from './renderingEngineCache';
+import type { IRenderingEngine } from '../types';
+
+/**
+ * Method to retrieve a RenderingEngine by its unique identifier.
+ *
+ * @example
+ * How to get a RenderingEngine that was created earlier:
+ * ```javascript
+ * import { RenderingEngine, getRenderingEngine } from 'vtkjs-viewport';
+ *
+ * const renderingEngine = new RenderingEngine('my-engine');
+ *
+ * // getting reference to rendering engine later...
+ * const renderingEngine = getRenderingEngine('my-engine');
+ * ```
+ *
+ * @param id - The identifier that was used to create the RenderingEngine
+ * @returns the matching RenderingEngine, or `undefined` if there is no match
+ * @public
+ */
+export function getRenderingEngine(id: string): IRenderingEngine | undefined {
+  return renderingEngineCache.get(id);
+}
+
+/**
+ * Get all the rendering engines that are currently registered
+ * @returns An array of rendering engines.
+ */
+export function getRenderingEngines(): IRenderingEngine[] | undefined {
+  return renderingEngineCache.getAll();
+}
+
+export default getRenderingEngine;

package/src/RenderingEngine/helpers/addVolumesToViewports.ts

@@ -0,0 +1,52 @@
+import { VolumeViewport } from '../';
+import BaseVolumeViewport from '../BaseVolumeViewport';
+import type { IVolumeInput, IRenderingEngine } from '../../types';
+
+/**
+ * For each provided viewport it adds a volume to the viewport using the
+ * provided renderingEngine
+ *
+ *
+ * @param renderingEngine - The rendering engine to use to get viewports from
+ * @param volumeInputs - Array of volume inputs including volumeId. Other properties
+ * such as visibility, callback, blendMode, slabThickness are optional
+ * @param viewportIds - Array of viewport IDs to add the volume to
+ * @param immediateRender - If true, the volumes will be rendered immediately
+ * @returns A promise that resolves when all volumes have been added
+ */
+async function addVolumesToViewports(
+  renderingEngine: IRenderingEngine,
+  volumeInputs: Array<IVolumeInput>,
+  viewportIds: Array<string>,
+  immediateRender = false,
+  suppressEvents = false
+): Promise<void> {
+  // Check if all viewports are volumeViewports
+  for (const viewportId of viewportIds) {
+    const viewport = renderingEngine.getViewport(viewportId);
+
+    if (!viewport) {
+      throw new Error(`Viewport with Id ${viewportId} does not exist`);
+    }
+
+    // if not instance of BaseVolumeViewport, throw
+    if (!(viewport instanceof BaseVolumeViewport)) {
+      console.warn(
+        `Viewport with Id ${viewportId} is not a BaseVolumeViewport. Cannot add volume to this viewport.`
+      );
+
+      return;
+    }
+  }
+
+  const addVolumePromises = viewportIds.map(async (viewportId) => {
+    const viewport = renderingEngine.getViewport(viewportId) as VolumeViewport;
+
+    await viewport.addVolumes(volumeInputs, immediateRender, suppressEvents);
+  });
+
+  await Promise.all(addVolumePromises);
+  return;
+}
+
+export default addVolumesToViewports;