@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.21

package/src/RenderingEngine/VolumeViewport.ts

@@ -1,389 +0,0 @@
-import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
-import { vec3 } from 'gl-matrix';
-
-import cache from '../cache';
-import { 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, getClosestImageId } from '../utilities';
-import BaseVolumeViewport from './BaseVolumeViewport';
-import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
-import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
-
-/**
- * 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();
-  }
-
-  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 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);
-  }
-
-  /**
-   * 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 => {
-    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 { origin, spacing } = this.getImageData();
-
-    // 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);
-  };
-
-  /**
-   * 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 => {
-    if (this.getActors().length > 1) {
-      console.warn(
-        `Using the first/default actor of ${
-          this.getActors().length
-        } actors for getCurrentImageId.`
-      );
-    }
-
-    const actorEntry = this.getDefaultActor();
-
-    if (!actorEntry || !actorIsA(actorEntry, 'vtkVolume')) {
-      return;
-    }
-
-    const { uid } = actorEntry;
-    const volume = cache.getVolume(uid);
-
-    if (!volume) {
-      return;
-    }
-
-    const { viewPlaneNormal, focalPoint } = this.getCamera();
-
-    return getClosestImageId(volume, focalPoint, viewPlaneNormal);
-  };
-
-  getRotation = (): number => 0;
-
-  /**
-   * Reset the viewport properties to the default values
-   *
-
-   * @param volumeId - Optional volume ID to specify which volume properties to reset.
-   * If not provided, it will reset the properties of the default actor.
-   *
-   * @returns void
-   */
-  public resetProperties(volumeId?: string): void {
-    this._resetProperties(volumeId);
-  }
-
-  private _resetProperties(volumeId?: string) {
-    // Get the actor based on the volumeId if provided, otherwise use the default actor.
-    const volumeActor = volumeId
-      ? this.getActor(volumeId)
-      : this.getDefaultActor();
-
-    if (!volumeActor) {
-      throw new Error(`No actor found for the given volumeId: ${volumeId}`);
-    }
-
-    const imageVolume = cache.getVolume(volumeActor.uid);
-    if (!imageVolume) {
-      throw new Error(
-        `imageVolume with id: ${volumeActor.uid} does not exist in cache`
-      );
-    }
-    setDefaultVolumeVOI(volumeActor.actor as vtkVolume, imageVolume, false);
-  }
-}
-
-export default VolumeViewport;

package/src/RenderingEngine/VolumeViewport3D.ts

@@ -1,69 +0,0 @@
-import { BlendModes, 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;
-
-  getCurrentImageIdIndex = (): number | undefined => {
-    return undefined;
-  };
-
-  getCurrentImageId = (): string => {
-    return null;
-  };
-
-  setSlabThickness(
-    slabThickness: number,
-    filterActorUIDs?: Array<string>
-  ): void {
-    return null;
-  }
-
-  setBlendMode(
-    blendMode: BlendModes,
-    filterActorUIDs?: string[],
-    immediate?: boolean
-  ): void {
-    return null;
-  }
-
-  resetProperties(volumeId?: string): void {
-    return null;
-  }
-}
-
-export default VolumeViewport3D;

package/src/RenderingEngine/getRenderingEngine.ts

@@ -1,34 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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;