@cornerstonejs/tools 0.56.1 → 0.56.3

package/src/utilities/segmentation/triggerSegmentationRender.ts

@@ -0,0 +1,206 @@
+import {
+  triggerEvent,
+  eventTarget,
+  getRenderingEngine,
+  Enums,
+  Types,
+} from '@cornerstonejs/core';
+import { Events as csToolsEvents } from '../../enums';
+import {
+  getToolGroup,
+  getToolGroupForViewport,
+} from '../../store/ToolGroupManager';
+
+import SegmentationDisplayTool from '../../tools/displayTools/SegmentationDisplayTool';
+import { SegmentationRenderedEventDetail } from '../../types/EventTypes';
+
+/**
+ * SegmentationRenderingEngine is a class that is responsible for rendering
+ * segmentations for a toolGroup. It will call SegmentationDisplayTool to render the segmentation
+ * based on the segmentation data and their configurations. Note: This is a Singleton class
+ * and should not be instantiated directly. To trigger a render for all the
+ * segmentations of a tool group you can use.
+ *
+ * ```
+ * triggerSegmentationRender(toolGroupId)
+ * ```
+ */
+class SegmentationRenderingEngine {
+  private _needsRender: Set<string> = new Set();
+  private _animationFrameSet = false;
+  private _animationFrameHandle: number | null = null;
+  public hasBeenDestroyed: boolean;
+
+  public removeToolGroup(toolGroupId) {
+    this._needsRender.delete(toolGroupId);
+
+    if (this._needsRender.size === 0) {
+      this._reset();
+    }
+  }
+
+  public renderToolGroupSegmentations(toolGroupId): void {
+    this._setToolGroupSegmentationToBeRenderedNextFrame([toolGroupId]);
+  }
+
+  /**
+   *  _throwIfDestroyed Throws an error if trying to interact with the `RenderingEngine`
+   * instance after its `destroy` method has been called.
+   */
+  private _throwIfDestroyed() {
+    if (this.hasBeenDestroyed) {
+      throw new Error(
+        'this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.'
+      );
+    }
+  }
+
+  private _setToolGroupSegmentationToBeRenderedNextFrame(
+    toolGroupIds: string[]
+  ) {
+    // Add the viewports to the set of flagged viewports
+    toolGroupIds.forEach((toolGroupId) => {
+      this._needsRender.add(toolGroupId);
+    });
+
+    // Render any flagged viewports
+    this._render();
+  }
+
+  /**
+   *  _render Sets up animation frame if necessary
+   */
+  private _render() {
+    // If we have viewports that need rendering and we have not already
+    // set the RAF callback to run on the next frame.
+    if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+      this._animationFrameHandle = window.requestAnimationFrame(
+        this._renderFlaggedToolGroups
+      );
+
+      // Set the flag that we have already set up the next RAF call.
+      this._animationFrameSet = true;
+    }
+  }
+
+  private _renderFlaggedToolGroups = () => {
+    this._throwIfDestroyed();
+
+    // for each toolGroupId insides the _needsRender set, render the segmentation
+    const toolGroupIds = Array.from(this._needsRender.values());
+
+    for (const toolGroupId of toolGroupIds) {
+      this._triggerRender(toolGroupId);
+
+      // This viewport has been rendered, we can remove it from the set
+      this._needsRender.delete(toolGroupId);
+
+      // If there is nothing left that is flagged for rendering, stop here
+      // and allow RAF to be called again
+      if (this._needsRender.size === 0) {
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        return;
+      }
+    }
+  };
+  _triggerRender(toolGroupId) {
+    const toolGroup = getToolGroup(toolGroupId);
+
+    if (!toolGroup) {
+      console.warn(`No tool group found with toolGroupId: ${toolGroupId}`);
+      return;
+    }
+
+    const { viewportsInfo } = toolGroup;
+    const viewports = [];
+
+    viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+      const renderingEngine = getRenderingEngine(renderingEngineId);
+
+      if (!renderingEngine) {
+        console.warn('rendering Engine has been destroyed');
+        return;
+      }
+
+      viewports.push(renderingEngine.getViewport(viewportId));
+    });
+
+    const segmentationDisplayToolInstance = toolGroup.getToolInstance(
+      SegmentationDisplayTool.toolName
+    ) as SegmentationDisplayTool;
+    if (!segmentationDisplayToolInstance) {
+      console.warn('No segmentation tool found inside', toolGroupId);
+      return;
+    }
+
+    function onSegmentationRender(evt: Types.EventTypes.ImageRenderedEvent) {
+      const { element, viewportId, renderingEngineId } = evt.detail;
+
+      element.removeEventListener(
+        Enums.Events.IMAGE_RENDERED,
+        onSegmentationRender as EventListener
+      );
+
+      const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+
+      if (!toolGroup) {
+        console.warn('toolGroup has been destroyed');
+        return;
+      }
+
+      const eventDetail: SegmentationRenderedEventDetail = {
+        toolGroupId: toolGroup.id,
+        viewportId,
+      };
+
+      triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
+        ...eventDetail,
+      });
+    }
+
+    // Todo: for other representations we probably need the drawSVG, but right now we are not using it
+    // drawSvg(element, (svgDrawingHelper) => {
+    //   const handleDrawSvg = (tool) => {
+    //     if (tool instanceof SegmentationDisplayTool && tool.renderAnnotation) {
+    //       tool.renderAnnotation({ detail: eventDetail })
+    //       triggerEvent(element, csToolsEvents.SEGMENTATION_RENDERED, { ...eventDetail })
+    //     }
+    //   }
+    //   enabledTools.forEach(handleDrawSvg)
+    // })
+
+    viewports.forEach(({ element }) => {
+      element.addEventListener(
+        Enums.Events.IMAGE_RENDERED,
+        onSegmentationRender
+      );
+    });
+
+    segmentationDisplayToolInstance.renderSegmentation(toolGroupId);
+  }
+
+  /**
+   *  _reset Resets the `RenderingEngine`
+   */
+  private _reset() {
+    window.cancelAnimationFrame(this._animationFrameHandle);
+
+    this._needsRender.clear();
+    this._animationFrameSet = false;
+    this._animationFrameHandle = null;
+  }
+}
+
+const segmentationRenderingEngine = new SegmentationRenderingEngine();
+
+/**
+ * It triggers a render for all the segmentations of the tool group with the given Id.
+ * @param toolGroupId - The Id of the tool group to render.
+ */
+function triggerSegmentationRender(toolGroupId: string): void {
+  segmentationRenderingEngine.renderToolGroupSegmentations(toolGroupId);
+}
+
+export { segmentationRenderingEngine, triggerSegmentationRender };
+export default triggerSegmentationRender;

package/src/utilities/segmentation/utilities.ts

@@ -0,0 +1,116 @@
+import { Types } from '@cornerstonejs/core';
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { getToolGroup } from '../../store/ToolGroupManager';
+import BrushTool from '../../tools/segmentation/BrushTool';
+import getBoundingBoxAroundShape from '../boundingBox/getBoundingBoxAroundShape';
+
+export type ThresholdInformation = {
+  volume: Types.IImageVolume;
+  lower: number;
+  upper: number;
+};
+
+export default function getBrushToolInstances(toolGroupId) {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    return;
+  }
+
+  const toolInstances = toolGroup._toolInstances;
+
+  if (!Object.keys(toolInstances).length) {
+    return;
+  }
+
+  // For each tool that has BrushTool as base class, set the brush size.
+  const brushBasedToolInstances = Object.values(toolInstances).filter(
+    (toolInstance) => toolInstance instanceof BrushTool
+  ) as BrushTool[];
+
+  return brushBasedToolInstances;
+}
+
+const equalsCheck = (a, b) => {
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+
+/**
+ * Given the center of a voxel in world coordinates, calculate the voxel
+ * corners in world coords to calculate the voxel overlap in another volume
+ */
+export function getVoxelOverlap(
+  imageData,
+  dimensions,
+  voxelSpacing,
+  voxelCenter
+) {
+  const voxelCornersWorld = [];
+  for (let i = 0; i < 2; i++) {
+    for (let j = 0; j < 2; j++) {
+      for (let k = 0; k < 2; k++) {
+        const point = voxelCenter;
+        point[0] = point[0] + ((i * 2 - 1) * voxelSpacing[0]) / 2;
+        point[1] = point[1] + ((j * 2 - 1) * voxelSpacing[1]) / 2;
+        point[2] = point[2] + ((k * 2 - 1) * voxelSpacing[2]) / 2;
+        voxelCornersWorld.push(point);
+      }
+    }
+  }
+  const voxelCornersIJK = voxelCornersWorld.map(
+    (world) => csUtils.transformWorldToIndex(imageData, world) as Types.Point3
+  );
+  const overlapBounds = getBoundingBoxAroundShape(voxelCornersIJK, dimensions);
+
+  return overlapBounds;
+}
+
+/**
+ * Prepare a list of volume information objects for callback functions
+ */
+export function processVolumes(
+  segmentationVolume: Types.IImageVolume,
+  thresholdVolumeInformation: ThresholdInformation[]
+) {
+  const { spacing: segmentationSpacing, imageData: segmentationImageData } =
+    segmentationVolume;
+  const scalarData = segmentationVolume.getScalarData();
+
+  // prepare a list of volume information objects for callback functions
+  const volumeInfoList = [];
+  let baseVolumeIdx = 0;
+  for (let i = 0; i < thresholdVolumeInformation.length; i++) {
+    const { imageData, spacing, dimensions } =
+      thresholdVolumeInformation[i].volume;
+
+    const volumeSize =
+      thresholdVolumeInformation[i].volume.getScalarData().length;
+    // discover the index of the volume the segmentation data is based on
+    if (
+      volumeSize === scalarData.length &&
+      equalsCheck(spacing, segmentationSpacing)
+    ) {
+      baseVolumeIdx = i;
+    }
+
+    // prepare information used in callback functions
+    const referenceValues = imageData.getPointData().getScalars().getData();
+    const lower = thresholdVolumeInformation[i].lower;
+    const upper = thresholdVolumeInformation[i].upper;
+
+    volumeInfoList.push({
+      imageData,
+      referenceValues,
+      lower,
+      upper,
+      spacing,
+      dimensions,
+      volumeSize,
+    });
+  }
+
+  return {
+    volumeInfoList,
+    baseVolumeIdx,
+  };
+}

package/src/utilities/stackPrefetch/index.ts

@@ -0,0 +1,8 @@
+import {
+  enable,
+  disable,
+  setConfiguration,
+  getConfiguration,
+} from './stackPrefetch';
+
+export { enable, disable, setConfiguration, getConfiguration };