@cornerstonejs/tools 1.22.0 → 1.23.0

package/src/tools/displayTools/Surface/surfaceDisplay.ts

@@ -0,0 +1,215 @@
+import {
+  cache,
+  getEnabledElementByIds,
+  Types,
+  utilities,
+  Enums,
+} from '@cornerstonejs/core';
+
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
+import Representations from '../../../enums/SegmentationRepresentations';
+import { getToolGroup } from '../../../store/ToolGroupManager';
+import {
+  RepresentationPublicInput,
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificRepresentation,
+} from '../../../types/SegmentationStateTypes';
+
+import removeSurfaceFromElement from './removeSurfaceFromElement';
+import addSurfaceToElement from './addSurfaceToElement';
+
+/**
+ * It adds a new segmentation representation to the segmentation state
+ * @param toolGroupId - The id of the toolGroup that the segmentation
+ * belongs to
+ * @param representationInput - RepresentationPublicInput
+ * @param toolGroupSpecificConfig - The configuration that is specific to the toolGroup.
+ * @returns The segmentationRepresentationUID
+ */
+async function addSegmentationRepresentation(
+  toolGroupId: string,
+  representationInput: RepresentationPublicInput,
+  toolGroupSpecificConfig?: SegmentationRepresentationConfig
+): Promise<string> {
+  const { segmentationId } = representationInput;
+  const segmentationRepresentationUID = utilities.uuidv4();
+  // Todo: make these configurable during representation input by user
+  const segmentsHidden = new Set() as Set<number>;
+  const colorLUTIndex = 0;
+  const active = true;
+  const toolGroupSpecificRepresentation: ToolGroupSpecificRepresentation = {
+    segmentationId,
+    segmentationRepresentationUID,
+    type: Representations.Surface,
+    segmentsHidden,
+    colorLUTIndex,
+    active,
+    segmentationRepresentationSpecificConfig: {},
+    segmentSpecificConfig: {},
+    config: {},
+  };
+  // Update the toolGroup specific configuration
+  if (toolGroupSpecificConfig) {
+    // Since setting configuration on toolGroup will trigger a segmentationRepresentation
+    // update event, we don't want to trigger the event twice, so we suppress
+    // the first one
+    const currentToolGroupConfig =
+      SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
+    const mergedConfig = utilities.deepMerge(
+      currentToolGroupConfig,
+      toolGroupSpecificConfig
+    );
+    SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
+      renderInactiveSegmentations:
+        mergedConfig.renderInactiveSegmentations || true,
+      representations: {
+        ...mergedConfig.representations,
+      },
+    });
+  }
+  SegmentationState.addSegmentationRepresentation(
+    toolGroupId,
+    toolGroupSpecificRepresentation
+  );
+  return segmentationRepresentationUID;
+}
+
+/**
+ * It removes a segmentation representation from the tool group's viewports and
+ * from the segmentation state
+ * @param toolGroupId - The toolGroupId of the toolGroup that the
+ * segmentationRepresentation belongs to.
+ * @param segmentationRepresentationUID - This is the unique identifier
+ * for the segmentation representation.
+ * @param renderImmediate - If true, the viewport will be rendered
+ * immediately after the segmentation representation is removed.
+ */
+function removeSegmentationRepresentation(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  renderImmediate = false
+): void {
+  _removeSurfaceFromToolGroupViewports(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+  SegmentationState.removeSegmentationRepresentation(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+
+  if (renderImmediate) {
+    const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
+    viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+      const enabledElement = getEnabledElementByIds(
+        viewportId,
+        renderingEngineId
+      );
+      enabledElement.viewport.render();
+    });
+  }
+}
+
+/**
+ * It renders the Surface  for the given segmentation
+ * @param viewport - The viewport object
+ * @param representation - ToolGroupSpecificRepresentation
+ * @param toolGroupConfig - This is the configuration object for the tool group
+ */
+async function render(
+  viewport: Types.IVolumeViewport,
+  representation: ToolGroupSpecificRepresentation,
+  toolGroupConfig: SegmentationRepresentationConfig
+): Promise<void> {
+  const {
+    colorLUTIndex,
+    active,
+    segmentationId,
+    segmentationRepresentationUID,
+    segmentsHidden,
+  } = representation;
+
+  const segmentation = SegmentationState.getSegmentation(segmentationId);
+  const SurfaceData = segmentation.representationData[Representations.Surface];
+  const { geometryId } = SurfaceData;
+
+  if (!geometryId) {
+    console.warn(
+      `No Surfaces found for segmentationId ${segmentationId}. Skipping render.`
+    );
+  }
+
+  const geometry = cache.getGeometry(geometryId);
+  if (!geometry) {
+    throw new Error(`No Surfaces found for geometryId ${geometryId}`);
+  }
+
+  if (geometry.type !== Enums.GeometryType.SURFACE) {
+    // Todo: later we can support converting other geometries to Surfaces
+    throw new Error(
+      `Geometry type ${geometry.type} not supported for rendering.`
+    );
+  }
+
+  if (!geometry.data) {
+    console.warn(
+      `No Surfaces found for geometryId ${geometryId}. Skipping render.`
+    );
+    return;
+  }
+
+  const surface = geometry.data;
+
+  const surfaceUID = `${segmentationRepresentationUID}_${surface.id}}`;
+  _renderSurface(viewport, surface, surfaceUID);
+
+  viewport.resetCamera();
+  viewport.render();
+}
+
+function _renderSurface(
+  viewport: Types.IVolumeViewport,
+  surface: any,
+  surfaceUID: string
+): void {
+  const actorUID = surfaceUID;
+  const actorEntry = viewport.getActor(actorUID);
+
+  if (!actorEntry) {
+    addSurfaceToElement(viewport.element, surface, actorUID);
+  } else {
+    throw new Error('Not implemented yet. (Update surface)');
+  }
+}
+
+function _removeSurfaceFromToolGroupViewports(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): void {
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (toolGroup === undefined) {
+    throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
+  }
+
+  const { viewportsInfo } = toolGroup;
+
+  for (const viewportInfo of viewportsInfo) {
+    const { viewportId, renderingEngineId } = viewportInfo;
+    const enabledElement = getEnabledElementByIds(
+      viewportId,
+      renderingEngineId
+    );
+    removeSurfaceFromElement(
+      enabledElement.viewport.element,
+      segmentationRepresentationUID
+    );
+  }
+}
+
+export default {
+  render,
+  addSegmentationRepresentation,
+  removeSegmentationRepresentation,
+};

package/src/tools/index.ts

@@ -13,6 +13,7 @@ import MagnifyTool from './MagnifyTool';
 import AdvancedMagnifyTool from './AdvancedMagnifyTool';
 import ReferenceLinesTool from './ReferenceLinesTool';
 import OverlayGridTool from './OverlayGridTool';
+import SegmentationIntersectionTool from './SegmentationIntersectionTool';
 //
 import BidirectionalTool from './annotation/BidirectionalTool';
 import LengthTool from './annotation/LengthTool';
@@ -62,6 +63,7 @@ export {
   CrosshairsTool,
   ReferenceLinesTool,
   OverlayGridTool,
+  SegmentationIntersectionTool,
   BidirectionalTool,
   LengthTool,
   ProbeTool,

package/src/types/SegmentationStateTypes.ts

@@ -9,6 +9,10 @@ import type {
   LabelmapRenderingConfig,
   LabelmapSegmentationData,
 } from './LabelmapTypes';
+import {
+  SurfaceSegmentationData,
+  SurfaceRenderingConfig,
+} from './SurfaceTypes';
 
 /**
  * Four elements RGBA as 0-255
@@ -30,6 +34,8 @@ export type RepresentationConfig = {
   LABELMAP?: LabelmapConfig;
   /** contour configuration */
   CONTOUR?: ContourConfig;
+  /** surface configuration */
+  SURFACE?: any;
 };
 
 export type SegmentationRepresentationConfig = {
@@ -42,6 +48,7 @@ export type SegmentationRepresentationConfig = {
 export type SegmentationRepresentationData = {
   LABELMAP?: LabelmapSegmentationData;
   CONTOUR?: ContourSegmentationData;
+  SURFACE?: SurfaceSegmentationData;
 };
 
 /**
@@ -132,6 +139,13 @@ export type ToolGroupSpecificContourRepresentation =
     segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
   };
 
+export type ToolGroupSpecificSurfaceRepresentation =
+  ToolGroupSpecificRepresentationState & {
+    config: SurfaceRenderingConfig;
+    segmentationRepresentationSpecificConfig?: RepresentationConfig;
+    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+  };
+
 export type ToolGroupSpecificRepresentation =
   | ToolGroupSpecificLabelmapRepresentation
   | ToolGroupSpecificContourRepresentation;
@@ -252,7 +266,10 @@ export type SegmentationPublicInput = {
   segmentationId: string;
   representation: {
     type: Enums.SegmentationRepresentations;
-    data: LabelmapSegmentationData | ContourSegmentationData;
+    data:
+      | LabelmapSegmentationData
+      | ContourSegmentationData
+      | SurfaceSegmentationData;
   };
 };
 

package/src/types/SurfaceTypes.ts

@@ -0,0 +1,10 @@
+/**
+ * Labelmap representation type
+ */
+export type SurfaceRenderingConfig = {
+  // not much here yet
+};
+
+export type SurfaceSegmentationData = {
+  geometryId: string;
+};

package/src/utilities/dynamicVolume/generateImageFromTimeData.ts

@@ -5,10 +5,10 @@ import { Enums, Types } from '@cornerstonejs/core';
  * array of scalar data after performing AVERAGE, SUM or SUBTRACT to be used to
  * create a 3D volume
  *
- * @param dynamicVolume4D: volume to compute time frame data from
- * @param operation: operation to perform on time frame data, operations include
+ * @param dynamicVolume4D - volume to compute time frame data from
+ * @param operation - operation to perform on time frame data, operations include
  * SUM, AVERAGE, and SUBTRACT (can only be used with 2 time frames provided)
- * @param frameNumbers: an array of frame indexs to perform the operation on, if
+ * @param frameNumbers - an array of frame indices to perform the operation on, if
  * left empty, all frames will be used
  * @returns
  */

package/src/utilities/dynamicVolume/getDataInTime.ts

@@ -1,12 +1,14 @@
 import { utilities, cache, Types } from '@cornerstonejs/core';
+import { getVoxelOverlap } from '../segmentation/utilities';
+import pointInShapeCallback from '../pointInShapeCallback';
 
 /**
  * Gets the scalar data for a series of time points for either a single
  * coordinate or a segmentation mask, it will return the an array of scalar
  * data for a single coordinate or an array of arrays for a segmentation.
  *
- * @param dynamicVolume: 4D volume to compute time point data from
- * @param options: frameNumbers: which frames to use as timepoints, if left
+ * @param dynamicVolume - 4D volume to compute time point data from
+ * @param options - frameNumbers: which frames to use as timepoints, if left
  * blank, gets data timepoints over all frames
  * maskVolumeId: segmentationId to get timepoint data of
  * imageCoordinate: world coordinate to get timepoint data of
@@ -31,26 +33,23 @@ function getDataInTime(
   // Throws error if neither maskVolumeId or imageCoordinate is given,
   // throws error if BOTH maskVolumeId and imageCoordinate is given
   if (!options.maskVolumeId && !options.imageCoordinate) {
-    throw new Error('No ROI provided');
+    throw new Error(
+      'You should provide either maskVolumeId or imageCoordinate'
+    );
   }
 
   if (options.maskVolumeId && options.imageCoordinate) {
-    throw new Error('Please provide only one ROI');
+    throw new Error('You can only use one of maskVolumeId or imageCoordinate');
   }
 
   if (options.maskVolumeId) {
     const segmentationVolume = cache.getVolume(options.maskVolumeId);
-    const segScalarData = segmentationVolume.getScalarData();
-    const indexArray = [];
-
-    // Get the index of every non-zero voxel in mask
-    for (let i = 0, len = segScalarData.length; i < len; i++) {
-      if (segScalarData[i] !== 0) {
-        indexArray.push(i);
-      }
-    }
 
-    const dataInTime = _getTimePointDataMask(frames, indexArray, dynamicVolume);
+    const dataInTime = _getTimePointDataMask(
+      frames,
+      dynamicVolume,
+      segmentationVolume
+    );
 
     return dataInTime;
   }
@@ -95,19 +94,110 @@ function _getTimePointDataCoordinate(frames, coordinate, volume) {
   return value;
 }
 
-function _getTimePointDataMask(frames, indexArray, volume) {
-  const allScalarData = volume.getScalarDataArrays();
-  const value = [];
+function _getTimePointDataMask(frames, dynamicVolume, segmentationVolume) {
+  const { imageData: maskImageData } = segmentationVolume;
+  const segScalarData = segmentationVolume.getScalarData();
 
-  for (let i = 0; i < indexArray.length; i++) {
-    const indexValues = [];
-    frames.forEach((frame) => {
-      const activeScalarData = allScalarData[frame];
-      indexValues.push(activeScalarData[indexArray[i]]);
-    });
-    value.push(indexValues);
+  const len = segScalarData.length;
+
+  // Pre-allocate memory for array
+  const nonZeroVoxelIndices = [];
+  nonZeroVoxelIndices.length = len;
+
+  // Get the index of every non-zero voxel in mask
+  let actualLen = 0;
+  for (let i = 0, len = segScalarData.length; i < len; i++) {
+    if (segScalarData[i] !== 0) {
+      nonZeroVoxelIndices[actualLen++] = i;
+    }
   }
-  return value;
+
+  // Trim the array to actual size
+  nonZeroVoxelIndices.length = actualLen;
+
+  const dynamicVolumeScalarDataArray = dynamicVolume.getScalarDataArrays();
+  const values = [];
+  const isSameVolume =
+    dynamicVolumeScalarDataArray[0].length === len &&
+    JSON.stringify(dynamicVolume.spacing) ===
+      JSON.stringify(segmentationVolume.spacing);
+
+  // if the segmentation mask is the same size as the dynamic volume (one frame)
+  // means we can just return the scalar data for the non-zero voxels
+  if (isSameVolume) {
+    for (let i = 0; i < nonZeroVoxelIndices.length; i++) {
+      const indexValues = [];
+      frames.forEach((frame) => {
+        const activeScalarData = dynamicVolumeScalarDataArray[frame];
+        indexValues.push(activeScalarData[nonZeroVoxelIndices[i]]);
+      });
+      values.push(indexValues);
+    }
+
+    return values;
+  }
+
+  // In case that the segmentation mask is not the same size as the dynamic volume (one frame)
+  // then we need to consider each voxel in the segmentation mask and check if it
+  // overlaps with the other volume, and if so we need to average the values of the
+  // overlapping voxels.
+  const callback = ({ pointLPS: segPointLPS, value: segValue }) => {
+    // see if the value is non-zero
+    if (segValue === 0) {
+      // not interested
+      return;
+    }
+
+    // Then for each non-zero voxel in the segmentation mask, we should
+    // again perform the pointInShapeCallback to run the averaging callback
+    // function to get the average value of the overlapping voxels.
+    const overlapIJKMinMax = getVoxelOverlap(
+      dynamicVolume.imageData,
+      dynamicVolume.dimensions,
+      dynamicVolume.spacing,
+      segPointLPS
+    );
+
+    // count represents the number of voxels of the dynamic volume that represents
+    // one voxel of the segmentation mask
+    let count = 0;
+    const perFrameSum = new Map();
+
+    // Pre-initialize the Map
+    frames.forEach((frame) => perFrameSum.set(frame, 0));
+
+    const averageCallback = ({ index }) => {
+      for (let i = 0; i < frames.length; i++) {
+        const value = dynamicVolumeScalarDataArray[i][index];
+        const frame = frames[i];
+        perFrameSum.set(frame, perFrameSum.get(frame) + value);
+      }
+      count++;
+    };
+
+    pointInShapeCallback(
+      dynamicVolume.imageData,
+      () => true,
+      averageCallback,
+      overlapIJKMinMax
+    );
+
+    // average the values
+    const averageValues = [];
+    perFrameSum.forEach((sum) => {
+      averageValues.push(sum / count);
+    });
+
+    values.push(averageValues);
+  };
+
+  // Since we have the non-zero voxel indices of the segmentation mask,
+  // we theoretically can use them, however, we kind of need to compute the
+  // pointLPS for each of the non-zero voxel indices, which is a bit of a pain.
+  // Todo: consider using the nonZeroVoxelIndices to compute the pointLPS
+  pointInShapeCallback(maskImageData, () => true, callback);
+
+  return values;
 }
 
 export default getDataInTime;

package/src/utilities/index.ts

@@ -17,6 +17,7 @@ import pointInShapeCallback from './pointInShapeCallback';
 import pointInSurroundingSphereCallback from './pointInSurroundingSphereCallback';
 import scroll from './scroll';
 import roundNumber from './roundNumber';
+import { pointToString } from './pointToString';
 
 // name spaces
 import * as segmentation from './segmentation';
@@ -33,6 +34,7 @@ import { stackPrefetch, stackContextPrefetch } from './stackPrefetch';
 import * as viewport from './viewport';
 import * as touch from './touch';
 import * as dynamicVolume from './dynamicVolume';
+import * as polyDataUtils from './polyData/utils';
 
 // Events
 import { triggerEvent } from '@cornerstonejs/core';
@@ -68,4 +70,6 @@ export {
   stackContextPrefetch,
   scroll,
   roundNumber,
+  pointToString,
+  polyDataUtils,
 };

package/src/utilities/math/point/distanceToPoint.ts

@@ -1,22 +1,23 @@
 import type { Types } from '@cornerstonejs/core';
 
+type Point = Types.Point2 | Types.Point3;
+
 /**
  * Calculates the distance of a point to another point
  *
- * @param p1 - x,y of the point
- * @param p2 - x,y of the point
+ * @param p1 - x,y or x,y,z of the point
+ * @param p2 - x,y or x,y,z of the point
  * @returns distance
  */
-export default function distanceToPoint(
-  p1: Types.Point2,
-  p2: Types.Point2
-): number {
-  if (p1?.length !== 2 || p2?.length !== 2) {
-    throw Error('points should have 2 elements of [x, y]');
+export default function distanceToPoint(p1: Point, p2: Point): number {
+  if (p1.length !== p2.length) {
+    throw Error('Both points should have the same dimensionality');
   }
 
-  const [x1, y1] = p1;
-  const [x2, y2] = p2;
+  const [x1, y1, z1 = 0] = p1;
+  const [x2, y2, z2 = 0] = p2;
 
-  return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+  return Math.sqrt(
+    Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2) + Math.pow(z1 - z2, 2)
+  );
 }

package/src/utilities/pointToString.ts

@@ -0,0 +1,10 @@
+export function pointToString(point, decimals = 5) {
+  return (
+    parseFloat(point[0]).toFixed(decimals) +
+    ',' +
+    parseFloat(point[1]).toFixed(decimals) +
+    ',' +
+    parseFloat(point[2]).toFixed(decimals) +
+    ','
+  );
+}

package/src/utilities/polyData/utils.ts

@@ -0,0 +1,82 @@
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+
+/**
+ * Gets a point from an array of numbers given its index
+ * @param points array of number, each point defined by three consecutive numbers
+ * @param idx index of the point to retrieve
+ * @returns
+ */
+export function getPoint(points, idx) {
+  if (idx < points.length / 3) {
+    return [points[idx * 3], points[idx * 3 + 1], points[idx * 3 + 2]];
+  }
+}
+
+/**
+ * Extract contour point sets from the outline of a poly data actor
+ * @param polyData - vtk polyData
+ * @returns
+ */
+export function getPolyDataPointIndexes(polyData: vtkPolyData) {
+  const linesData = polyData.getLines().getData();
+  let idx = 0;
+  const lineSegments = new Map<number, number[]>();
+
+  // Populate lineSegments map
+  while (idx < linesData.length) {
+    const segmentSize = linesData[idx++];
+    const segment = [];
+    for (let i = 0; i < segmentSize; i++) {
+      segment.push(linesData[idx + i]);
+    }
+    lineSegments.set(segment[0], segment);
+    idx += segmentSize;
+  }
+
+  const contours = [];
+
+  // Function to find an available starting point
+  const findStartingPoint = (map) => {
+    for (const [key, value] of map.entries()) {
+      if (value !== undefined) {
+        return key;
+      }
+    }
+    return -1;
+  };
+
+  // Build contours
+  let startPoint = findStartingPoint(lineSegments);
+  while (startPoint !== -1) {
+    const contour = [startPoint];
+    while (lineSegments.has(startPoint)) {
+      const nextPoint = lineSegments.get(startPoint)[1];
+      if (lineSegments.has(nextPoint)) {
+        contour.push(nextPoint);
+      }
+      lineSegments.delete(startPoint);
+      startPoint = nextPoint;
+    }
+    contours.push(contour);
+    startPoint = findStartingPoint(lineSegments);
+  }
+
+  return contours.length ? contours : undefined;
+}
+
+/**
+ * Extract contour points from a poly data object
+ * @param polyData - vtk polyData
+ * @returns
+ */
+export function getPolyDataPoints(polyData: vtkPolyData) {
+  const contoursIndexes = getPolyDataPointIndexes(polyData);
+  if (!contoursIndexes) {
+    return;
+  }
+
+  const rawPointsData = polyData.getPoints().getData();
+  return contoursIndexes.map((contourIndexes) =>
+    contourIndexes.map((index) => getPoint(rawPointsData, index))
+  );
+}

package/src/utilities/segmentation/utilities.ts

@@ -56,7 +56,7 @@ export function getVoxelOverlap(
   for (let i = 0; i < 2; i++) {
     for (let j = 0; j < 2; j++) {
       for (let k = 0; k < 2; k++) {
-        const point = voxelCenter;
+        const point = [...voxelCenter]; // Create a new point from 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;
@@ -79,8 +79,7 @@ export function processVolumes(
   segmentationVolume: Types.IImageVolume,
   thresholdVolumeInformation: ThresholdInformation[]
 ) {
-  const { spacing: segmentationSpacing, imageData: segmentationImageData } =
-    segmentationVolume;
+  const { spacing: segmentationSpacing } = segmentationVolume;
   const scalarData = segmentationVolume.getScalarData();
 
   // prepare a list of volume information objects for callback functions