@cornerstonejs/tools 0.56.2 → 0.56.3

package/src/utilities/pointInSurroundingSphereCallback.ts

@@ -0,0 +1,188 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { vec3 } from 'gl-matrix';
+import { pointInSphere } from './math/sphere';
+import pointInShapeCallback, {
+  PointInShapeCallback,
+} from './pointInShapeCallback';
+import { BoundsIJK } from '../types';
+import { getBoundingBoxAroundShape } from './boundingBox';
+
+const { transformWorldToIndex } = csUtils;
+
+/**
+ * Given an imageData, and the great circle top and bottom points of a sphere,
+ * this function will run the callback for each point of the imageData that is
+ * within the sphere defined by the great circle points. If the viewport
+ * is provided, region of interest will be an accurate approximation of the
+ * sphere (using viewport camera), and the resulting performance will be
+ * better.
+ *
+ * @privateRemarks great circle also known as orthodrome is the intersection of
+ * the sphere and the plane that passes through the center of the sphere
+ *
+ * @param imageData - The volume imageData
+ * @param circlePoints - bottom and top points of the great circle in world coordinates
+ * @param callback - A callback function that will be called for each point in the shape.
+ */
+export default function pointInSurroundingSphereCallback(
+  imageData: vtkImageData,
+  circlePoints: [Types.Point3, Types.Point3],
+  callback: PointInShapeCallback,
+  viewport?: Types.IVolumeViewport
+): void {
+  // We can run the sphere equation to determine if a point is inside
+  // the sphere; however, since the imageData dimensions can be quite large, we
+  // can narrow down the search by estimating the bounds of the sphere in index
+  // space.
+  const { boundsIJK, centerWorld, radiusWorld } = _getBounds(
+    circlePoints,
+    imageData,
+    viewport
+  );
+
+  const sphereObj = {
+    center: centerWorld,
+    radius: radiusWorld,
+  };
+
+  pointInShapeCallback(
+    imageData,
+    (pointLPS) => pointInSphere(sphereObj, pointLPS),
+    callback,
+    boundsIJK
+  );
+}
+
+function _getBounds(
+  circlePoints: [Types.Point3, Types.Point3],
+  imageData: vtkImageData,
+  viewport
+): {
+  boundsIJK: BoundsIJK;
+  centerWorld: Types.Point3;
+  radiusWorld: number;
+} {
+  const [bottom, top] = circlePoints;
+
+  // Sphere center in world
+  const centerWorld = vec3.fromValues(
+    (bottom[0] + top[0]) / 2,
+    (bottom[1] + top[1]) / 2,
+    (bottom[2] + top[2]) / 2
+  );
+
+  // sphere radius in world
+  const radiusWorld = vec3.distance(bottom, top) / 2;
+
+  let boundsIJK;
+
+  if (!viewport) {
+    // If no viewport is provide (no camera), we can estimate the bounding box
+    // of the sphere in index space.
+    // This is done by calculating the maximum value for radius in the index
+    // space (since the radius is in world space, we need to convert it to index, and
+    // each dimensions can have a different scale factor). Therefore, by finding
+    // the minimum spacing value in the imageData, we can calculate the maximum
+    // radius in index space and use that to calculate the bounds of the sphere
+    // This will not be accurate, but it is a good first approximation.
+    // sphere center in index
+    const centerIJK = transformWorldToIndex(
+      imageData,
+      centerWorld as Types.Point3
+    );
+
+    const spacings = imageData.getSpacing();
+    const minSpacing = Math.min(...spacings);
+
+    const maxRadiusIJK = Math.ceil(radiusWorld / minSpacing);
+
+    boundsIJK = [
+      [centerIJK[0] - maxRadiusIJK, centerIJK[0] + maxRadiusIJK],
+      [centerIJK[1] - maxRadiusIJK, centerIJK[1] + maxRadiusIJK],
+      [centerIJK[2] - maxRadiusIJK, centerIJK[2] + maxRadiusIJK],
+    ];
+
+    return {
+      boundsIJK,
+      centerWorld: centerWorld as Types.Point3,
+      radiusWorld,
+    };
+  }
+
+  boundsIJK = _computeBoundsIJKWithCamera(
+    imageData,
+    viewport,
+    circlePoints,
+    centerWorld,
+    radiusWorld
+  );
+
+  return {
+    boundsIJK,
+    centerWorld: centerWorld as Types.Point3,
+    radiusWorld,
+  };
+}
+
+function _computeBoundsIJKWithCamera(
+  imageData,
+  viewport,
+  circlePoints,
+  centerWorld,
+  radiusWorld
+) {
+  const [bottom, top] = circlePoints;
+
+  const dimensions = imageData.getDimensions() as Types.Point3;
+  const camera = viewport.getCamera();
+
+  // Calculate viewRight from the camera, this will get used in order to
+  // calculate circles topLeft and bottomRight on different planes of intersection
+  // between sphere and viewPlane
+  const viewUp = vec3.fromValues(
+    camera.viewUp[0],
+    camera.viewUp[1],
+    camera.viewUp[2]
+  );
+  const viewPlaneNormal = vec3.fromValues(
+    camera.viewPlaneNormal[0],
+    camera.viewPlaneNormal[1],
+    camera.viewPlaneNormal[2]
+  );
+  const viewRight = vec3.create();
+
+  vec3.cross(viewRight, viewUp, viewPlaneNormal);
+
+  // we need to find the bounding box of the sphere in the image, e.g., the
+  // topLeftWorld and bottomRightWorld points of the bounding box.
+  // We go from the sphereCenter in the normal direction of amount radius, and
+  // we go left to find the topLeftWorld point of the bounding box. Next we go
+  // in the opposite direction and go right to find the bottomRightWorld point
+  // of the bounding box.
+  const topLeftWorld = vec3.create();
+  const bottomRightWorld = vec3.create();
+
+  vec3.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
+  vec3.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
+
+  // go in the direction of viewRight with the value of radius
+  vec3.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
+  vec3.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
+
+  // convert the world coordinates to index coordinates
+
+  const sphereCornersIJK = [
+    <Types.Point3>transformWorldToIndex(imageData, <Types.Point3>topLeftWorld),
+    <Types.Point3>(
+      transformWorldToIndex(imageData, <Types.Point3>bottomRightWorld)
+    ),
+  ];
+
+  // get the bounding box of the sphere in the image
+  const boundsIJK = getBoundingBoxAroundShape(sphereCornersIJK, dimensions);
+
+  return boundsIJK;
+}

package/src/utilities/rectangleROITool/getBoundsIJKFromRectangleAnnotations.ts

@@ -0,0 +1,76 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import getBoundingBoxAroundShape from '../boundingBox/getBoundingBoxAroundShape';
+import extend2DBoundingBoxInViewAxis from '../boundingBox/extend2DBoundingBoxInViewAxis';
+
+type Options = {
+  numSlicesToProject?: number;
+};
+
+function getBoundsIJKFromRectangleAnnotations(
+  annotations,
+  referenceVolume,
+  options = {} as Options
+) {
+  const AllBoundsIJK = [];
+  annotations.forEach((annotation) => {
+    const { data } = annotation;
+    const { points } = data.handles;
+
+    const { imageData, dimensions } = referenceVolume;
+
+    let pointsToUse = points;
+    // If the tool is a 2D tool but has projection points, use them
+    if (data.cachedStats?.projectionPoints) {
+      const { projectionPoints } = data.cachedStats;
+      pointsToUse = [].concat(...projectionPoints); // cannot use flat() because of typescript compiler right now
+    }
+
+    const rectangleCornersIJK = pointsToUse.map(
+      (world) => csUtils.transformWorldToIndex(imageData, world) as Types.Point3
+    );
+    let boundsIJK = getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
+
+    // If the tool is 2D but it is configured to project to X amount of slices
+    // Don't project the slices if projectionPoints have been used to define the extents
+    if (options.numSlicesToProject && !data.cachedStats?.projectionPoints) {
+      boundsIJK = extend2DBoundingBoxInViewAxis(
+        boundsIJK,
+        options.numSlicesToProject
+      );
+    }
+
+    AllBoundsIJK.push(boundsIJK);
+  });
+
+  if (AllBoundsIJK.length === 1) {
+    return AllBoundsIJK[0];
+  }
+
+  // Get the intersection of all the bounding boxes
+  // This is the bounding box that contains all the ROIs
+  const boundsIJK = AllBoundsIJK.reduce(
+    (accumulator, currentValue) => {
+      return {
+        iMin: Math.min(accumulator.iMin, currentValue.iMin),
+        jMin: Math.min(accumulator.jMin, currentValue.jMin),
+        kMin: Math.min(accumulator.kMin, currentValue.kMin),
+        iMax: Math.max(accumulator.iMax, currentValue.iMax),
+        jMax: Math.max(accumulator.jMax, currentValue.jMax),
+        kMax: Math.max(accumulator.kMax, currentValue.kMax),
+      };
+    },
+    {
+      iMin: Infinity,
+      jMin: Infinity,
+      kMin: Infinity,
+      iMax: -Infinity,
+      jMax: -Infinity,
+      kMax: -Infinity,
+    }
+  );
+
+  return boundsIJK;
+}
+
+export default getBoundsIJKFromRectangleAnnotations;

package/src/utilities/rectangleROITool/index.ts

@@ -0,0 +1,3 @@
+import getBoundsIJKFromRectangleAnnotations from './getBoundsIJKFromRectangleAnnotations';
+
+export { getBoundsIJKFromRectangleAnnotations };

package/src/utilities/scroll.ts

@@ -0,0 +1,62 @@
+import {
+  StackViewport,
+  Types,
+  VolumeViewport,
+  utilities as csUtils,
+} from '@cornerstonejs/core';
+import { ScrollOptions } from '../types';
+
+/**
+ * It scrolls one slice in the Stack or Volume Viewport, it uses the options provided
+ * to determine the slice to scroll to. For Stack Viewport, it scrolls in the 1 or -1
+ * direction, for Volume Viewport, it uses the camera and focal point to determine the
+ * slice to scroll to based on the spacings.
+ * @param viewport - The viewport in which to scroll
+ * @param options - Options to use for scrolling, including direction, invert, and volumeId
+ * @returns
+ */
+export default function scroll(
+  viewport: Types.IStackViewport | Types.IVolumeViewport,
+  options: ScrollOptions
+): void {
+  const { type: viewportType } = viewport;
+  const { volumeId, delta } = options;
+
+  if (viewport instanceof StackViewport) {
+    viewport.scroll(delta, options.debounceLoading, options.loop);
+  } else if (viewport instanceof VolumeViewport) {
+    scrollVolume(viewport, volumeId, delta);
+  } else {
+    throw new Error(`Not implemented for Viewport Type: ${viewportType}`);
+  }
+}
+
+export function scrollVolume(
+  viewport: VolumeViewport,
+  volumeId: string,
+  delta: number
+) {
+  const sliceRangeInfo = csUtils.getVolumeSliceRangeInfo(viewport, volumeId);
+
+  if (!sliceRangeInfo) {
+    return;
+  }
+
+  const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
+  const { focalPoint, viewPlaneNormal, position } = camera;
+
+  const { newFocalPoint, newPosition } = csUtils.snapFocalPointToSlice(
+    focalPoint,
+    position,
+    sliceRange,
+    viewPlaneNormal,
+    spacingInNormalDirection,
+    delta
+  );
+
+  viewport.setCamera({
+    focalPoint: newFocalPoint,
+    position: newPosition,
+  });
+  viewport.render();
+}

package/src/utilities/segmentation/brushSizeForToolGroup.ts

@@ -0,0 +1,72 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import BrushTool from '../../tools/segmentation/BrushTool';
+import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
+import { getRenderingEngine } from '@cornerstonejs/core';
+import getBrushToolInstances from './utilities';
+
+export function setBrushSizeForToolGroup(
+  toolGroupId: string,
+  brushSize: number
+): void {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    return;
+  }
+
+  const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+
+  brushBasedToolInstances.forEach((tool: BrushTool) => {
+    tool.configuration.brushSize = brushSize;
+
+    // Invalidate the brush being rendered so it can update.
+    tool.invalidateBrushCursor();
+  });
+
+  // Trigger an annotation render for any viewports on the toolgroup
+  const viewportsInfo = toolGroup.getViewportsInfo();
+
+  const viewportsInfoArray = Object.keys(viewportsInfo).map(
+    (key) => viewportsInfo[key]
+  );
+
+  if (!viewportsInfoArray.length) {
+    return;
+  }
+
+  const { renderingEngineId } = viewportsInfoArray[0];
+
+  // Use helper to get array of viewportIds, or we just end up doing this mapping
+  // ourselves here.
+  const viewportIds = toolGroup.getViewportIds();
+
+  const renderingEngine = getRenderingEngine(renderingEngineId);
+
+  triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
+}
+
+export function getBrushSizeForToolGroup(toolGroupId: string): void {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    return;
+  }
+
+  const toolInstances = toolGroup._toolInstances;
+
+  if (!Object.keys(toolInstances).length) {
+    return;
+  }
+
+  const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+
+  // one is enough as they share the same brush size
+  const brushToolInstance = brushBasedToolInstances[0];
+
+  if (!brushToolInstance) {
+    return;
+  }
+
+  // TODO -> Assumes the brush sizes are the same and set via these helpers.
+  return brushToolInstance.configuration.brushSize;
+}

package/src/utilities/segmentation/brushThresholdForToolGroup.ts

@@ -0,0 +1,65 @@
+import type { Types } from '@cornerstonejs/core';
+import { getToolGroup } from '../../store/ToolGroupManager';
+import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
+import { getRenderingEngine } from '@cornerstonejs/core';
+import getBrushToolInstances from './utilities';
+
+export function setBrushThresholdForToolGroup(
+  toolGroupId: string,
+  threshold: Types.Point2
+) {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    return;
+  }
+
+  const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+
+  brushBasedToolInstances.forEach((tool) => {
+    tool.configuration.strategySpecificConfiguration.THRESHOLD_INSIDE_CIRCLE.threshold =
+      threshold;
+  });
+
+  // Trigger an annotation render for any viewports on the toolgroup
+  const viewportsInfo = toolGroup.getViewportsInfo();
+
+  if (!viewportsInfo.length) {
+    return;
+  }
+
+  const { renderingEngineId } = viewportsInfo[0];
+
+  // Use helper to get array of viewportIds, or we just end up doing this mapping
+  // ourselves here.
+  const viewportIds = toolGroup.getViewportIds();
+
+  const renderingEngine = getRenderingEngine(renderingEngineId);
+
+  triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
+}
+
+export function getBrushThresholdForToolGroup(toolGroupId: string) {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    return;
+  }
+
+  const toolInstances = toolGroup._toolInstances;
+
+  if (!Object.keys(toolInstances).length) {
+    return;
+  }
+
+  const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+  const brushToolInstance = brushBasedToolInstances[0];
+
+  if (!brushToolInstance) {
+    return;
+  }
+
+  // TODO -> Assumes the
+  return brushToolInstance.configuration.strategySpecificConfiguration
+    .THRESHOLD_INSIDE_CIRCLE.threshold;
+}

package/src/utilities/segmentation/createLabelmapVolumeForViewport.ts

@@ -0,0 +1,74 @@
+import { _cloneDeep } from 'lodash.clonedeep';
+import {
+  getEnabledElementByIds,
+  volumeLoader,
+  VolumeViewport,
+  utilities as csUtils,
+} from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+
+/**
+ * Create a new 3D segmentation volume from the default imageData presented in
+ * the first actor of the viewport. It looks at the metadata of the imageData
+ * to determine the volume dimensions and spacing if particular options are not provided.
+ *
+ * @param viewportId - The Id of the viewport from which to derive the volume from.
+ * @param renderingEngineId - The Id of the rendering engine the viewport belongs to.
+ * @param [segmentationId] - The Id to name the generated segmentation. Autogenerated if not given.
+ * @param [options] - LabelmapOptions
+ * @returns A promise that resolves to the Id of the new labelmap volume.
+ */
+export default async function createLabelmapVolumeForViewport(input: {
+  viewportId: string;
+  renderingEngineId: string;
+  segmentationId?: string;
+  options?: {
+    volumeId?: string;
+    scalarData?: Float32Array | Uint8Array | Uint16Array | Int16Array;
+    targetBuffer?: {
+      type: 'Float32Array' | 'Uint8Array' | 'Uint16Array' | 'Int8Array';
+    };
+    metadata?: any;
+    dimensions?: Types.Point3;
+    spacing?: Types.Point3;
+    origin?: Types.Point3;
+    direction?: Float32Array;
+  };
+}): Promise<string> {
+  const { viewportId, renderingEngineId, options } = input;
+  let { segmentationId } = input;
+  const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+
+  if (!enabledElement) {
+    throw new Error('element disabled');
+  }
+
+  const { viewport } = enabledElement;
+  if (!(viewport instanceof VolumeViewport)) {
+    throw new Error('Segmentation only supports VolumeViewport');
+  }
+
+  const { uid } = viewport.getDefaultActor();
+
+  if (segmentationId === undefined) {
+    // Name the segmentation volume with the viewport Id
+    segmentationId = `${uid}-based-segmentation-${
+      options?.volumeId ?? csUtils.uuidv4().slice(0, 8)
+    }`;
+  }
+
+  if (options) {
+    // create a new labelmap with its own properties
+    // This allows creation of a higher resolution labelmap vs reference volume
+    const properties = _cloneDeep(options);
+    await volumeLoader.createLocalVolume(properties, segmentationId);
+  } else {
+    // create a labelmap from a reference volume
+    const { uid: volumeId } = viewport.getDefaultActor();
+    await volumeLoader.createAndCacheDerivedVolume(volumeId, {
+      volumeId: segmentationId,
+    });
+  }
+
+  return segmentationId;
+}

package/src/utilities/segmentation/createMergedLabelmapForIndex.ts

@@ -0,0 +1,65 @@
+import { Types } from '@cornerstonejs/core';
+import { volumeLoader, utilities as csUtils } from '@cornerstonejs/core';
+
+/**
+ * Given a list of labelmaps (with the possibility of overlapping regions), and
+ * a segmentIndex it creates a new labelmap with the same dimensions as the input labelmaps,
+ * but merges them into a single labelmap for the segmentIndex. It wipes out
+ * all other segment Indices. This is useful for calculating statistics regarding
+ * a specific segment when there are overlapping regions between labelmap (e.g. TMTV)
+ *
+ * @param labelmaps - Array of labelmaps
+ * @param segmentIndex - The segment index to merge
+ * @returns Merged labelmap
+ */
+function createMergedLabelmapForIndex(
+  labelmaps: Array<Types.IImageVolume>,
+  segmentIndex = 1,
+  volumeId = 'mergedLabelmap'
+): Types.IImageVolume {
+  labelmaps.forEach(({ direction, dimensions, origin, spacing }) => {
+    if (
+      !csUtils.isEqual(dimensions, labelmaps[0].dimensions) ||
+      !csUtils.isEqual(direction, labelmaps[0].direction) ||
+      !csUtils.isEqual(spacing, labelmaps[0].spacing) ||
+      !csUtils.isEqual(origin, labelmaps[0].origin)
+    ) {
+      throw new Error('labelmaps must have the same size and shape');
+    }
+  });
+
+  const labelmap = labelmaps[0];
+
+  const arrayType = (labelmap.getScalarData() as any).constructor;
+  const outputData = new arrayType(labelmap.getScalarData().length);
+
+  labelmaps.forEach((labelmap) => {
+    const scalarData = labelmap.getScalarData();
+    for (let i = 0; i < scalarData.length; i++) {
+      if (scalarData[i] === segmentIndex) {
+        outputData[i] = segmentIndex;
+      }
+    }
+  });
+
+  const options = {
+    scalarData: outputData,
+    metadata: labelmap.metadata,
+    spacing: labelmap.spacing,
+    origin: labelmap.origin,
+    direction: labelmap.direction,
+    dimensions: labelmap.dimensions,
+  };
+
+  const preventCache = true;
+  // Todo: following should be async
+  const mergedVolume = volumeLoader.createLocalVolume(
+    options,
+    volumeId,
+    preventCache
+  );
+
+  return mergedVolume;
+}
+
+export default createMergedLabelmapForIndex;