@cornerstonejs/tools 1.40.3 → 1.42.0

package/src/tools/index.ts

@@ -32,6 +32,7 @@ import LivewireContourTool from './annotation/LivewireContourTool';
 import ArrowAnnotateTool from './annotation/ArrowAnnotateTool';
 import AngleTool from './annotation/AngleTool';
 import CobbAngleTool from './annotation/CobbAngleTool';
+import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
 import KeyImageTool from './annotation/KeyImageTool';
 
 // Segmentation DisplayTool
@@ -81,6 +82,7 @@ export {
   ArrowAnnotateTool,
   AngleTool,
   CobbAngleTool,
+  UltrasoundDirectionalTool,
   KeyImageTool,
   // Segmentations Display
   SegmentationDisplayTool,

package/src/types/ToolSpecificAnnotationTypes.ts

@@ -346,6 +346,35 @@ export interface AngleAnnotation extends Annotation {
   };
 }
 
+export interface UltrasoundDirectionalAnnotation extends Annotation {
+  data: {
+    handles: {
+      points: Types.Point3[];
+      activeHandleIndex: number | null;
+      textBox: {
+        hasMoved: boolean;
+        worldPosition: Types.Point3;
+        worldBoundingBox: {
+          topLeft: Types.Point3;
+          topRight: Types.Point3;
+          bottomLeft: Types.Point3;
+          bottomRight: Types.Point3;
+        };
+      };
+    };
+    label: string;
+    cachedStats: {
+      [targetId: string]: {
+        xValues: number[];
+        yValues: number[];
+        units: string[];
+        isHorizontal: boolean;
+        isUnitless: boolean;
+      };
+    };
+  };
+}
+
 export interface CobbAngleAnnotation extends Annotation {
   data: {
     handles: {

package/src/types/index.ts

@@ -73,11 +73,13 @@ import type { ISpline } from './ISpline';
 import type { SplineCurveSegment } from './SplineCurveSegment';
 import type { SplineLineSegment } from './SplineLineSegment';
 import type { SplineProps } from './SplineProps';
+import type { BidirectionalData } from '../utilities/segmentation/createBidirectionalToolData';
 
 export type {
   // AnnotationState
   Annotation,
   Annotations,
+  BidirectionalData,
   CanvasCoordinates,
   IAnnotationManager,
   GroupSpecificAnnotations,

package/src/utilities/contours/AnnotationToPointData.ts

@@ -0,0 +1,61 @@
+import RectangleROIStartEndThreshold from './RectangleROIStartEndThreshold';
+
+function validateAnnotation(annotation) {
+  if (!annotation?.data) {
+    throw new Error('Tool data is empty');
+  }
+
+  if (!annotation.metadata || annotation.metadata.referenceImageId) {
+    throw new Error('Tool data is not associated with any imageId');
+  }
+}
+
+class AnnotationToPointData {
+  static TOOL_NAMES: Record<string, any> = {};
+
+  constructor() {
+    // empty
+  }
+
+  static convert(annotation, index, metadataProvider) {
+    validateAnnotation(annotation);
+
+    const { toolName } = annotation.metadata;
+    const toolClass = AnnotationToPointData.TOOL_NAMES[toolName];
+
+    if (!toolClass) {
+      throw new Error(
+        `Unknown tool type: ${toolName}, cannot convert to RTSSReport`
+      );
+    }
+
+    // Each toolData should become a list of contours, ContourSequence
+    // contains a list of contours with their pointData, their geometry
+    // type and their length.
+    const ContourSequence = toolClass.getContourSequence(
+      annotation,
+      metadataProvider
+    );
+
+    // Todo: random rgb color for now, options should be passed in
+    const color = [
+      Math.floor(Math.random() * 255),
+      Math.floor(Math.random() * 255),
+      Math.floor(Math.random() * 255),
+    ];
+
+    return {
+      ReferencedROINumber: index + 1,
+      ROIDisplayColor: color,
+      ContourSequence,
+    };
+  }
+
+  static register(toolClass) {
+    AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
+  }
+}
+
+AnnotationToPointData.register(RectangleROIStartEndThreshold);
+
+export default AnnotationToPointData;

package/src/utilities/contours/RectangleROIStartEndThreshold.ts

@@ -0,0 +1,60 @@
+// comment
+class RectangleROIStartEndThreshold {
+  static toolName: string;
+
+  constructor() {
+    // empty
+  }
+
+  static getContourSequence(toolData, metadataProvider) {
+    const { data } = toolData;
+    const { projectionPoints, projectionPointsImageIds } = data.cachedStats;
+
+    return projectionPoints.map((point, index) => {
+      const ContourData = getPointData(point);
+      const ContourImageSequence = getContourImageSequence(
+        projectionPointsImageIds[index],
+        metadataProvider
+      );
+
+      return {
+        NumberOfContourPoints: ContourData.length / 3,
+        ContourImageSequence,
+        ContourGeometricType: 'CLOSED_PLANAR',
+        ContourData,
+      };
+    });
+  }
+}
+
+RectangleROIStartEndThreshold.toolName = 'RectangleROIStartEndThreshold';
+
+function getPointData(points) {
+  // Since this is a closed contour, the order of the points is important.
+  // re-order the points to be in the correct order clockwise
+  // Spread to make sure Float32Arrays are converted to arrays
+  const orderedPoints = [
+    ...points[0],
+    ...points[1],
+    ...points[3],
+    ...points[2],
+  ];
+  const pointsArray = orderedPoints.flat();
+
+  // reduce the precision of the points to 2 decimal places
+  const pointsArrayWithPrecision = pointsArray.map((point) => {
+    return point.toFixed(2);
+  });
+
+  return pointsArrayWithPrecision;
+}
+
+function getContourImageSequence(imageId, metadataProvider) {
+  const sopCommon = metadataProvider.get('sopCommonModule', imageId);
+
+  return {
+    ReferencedSOPClassUID: sopCommon.sopClassUID,
+    ReferencedSOPInstanceUID: sopCommon.sopInstanceUID,
+  };
+}
+export default RectangleROIStartEndThreshold;

package/src/utilities/contours/contourFinder.ts

@@ -0,0 +1,78 @@
+function findNextLink(line, lines, contourPoints) {
+  let index = -1;
+  lines.forEach((cell, i) => {
+    if (index >= 0) {
+      return;
+    }
+
+    if (cell.a == line.b) {
+      index = i;
+    }
+  });
+
+  if (index >= 0) {
+    const nextLine = lines[index];
+    lines.splice(index, 1);
+
+    contourPoints.push(nextLine.b);
+
+    if (contourPoints[0] == nextLine.b) {
+      return {
+        remainingLines: lines,
+        contourPoints,
+        type: 'CLOSED_PLANAR',
+        //type: 'CLOSEDPLANAR_XOR',
+      };
+    }
+
+    return findNextLink(nextLine, lines, contourPoints);
+  }
+
+  return {
+    remainingLines: lines,
+    contourPoints,
+    type: 'OPEN_PLANAR',
+  };
+}
+
+/**
+ *
+ * @param {*} lines
+ */
+export function findContours(lines) {
+  if (lines.length == 0) {
+    return [];
+  }
+
+  const contourPoints = [];
+
+  const firstCell = lines.shift();
+  contourPoints.push(firstCell.a);
+  contourPoints.push(firstCell.b);
+  const result = findNextLink(firstCell, lines, contourPoints);
+
+  if (result.remainingLines.length == 0) {
+    return [
+      {
+        type: result.type,
+        contourPoints: result.contourPoints,
+      },
+    ];
+  } else {
+    const extraContours = findContours(result.remainingLines);
+    extraContours.push({
+      type: result.type,
+      contourPoints: result.contourPoints,
+    });
+    return extraContours;
+  }
+}
+
+export function findContoursFromReducedSet(lines) {
+  return findContours(lines);
+}
+
+export default {
+  findContours,
+  findContoursFromReducedSet,
+};

package/src/utilities/contours/detectContourHoles.ts

@@ -0,0 +1,147 @@
+/**
+ * Functions for detecting and dealing with holes within contours.
+ * Expected Contour format:
+ * {
+ *   type,
+ *   contourPoints
+ * }
+ */
+
+/**
+ * Checks if point is inside polygon defined by vertices array
+ * Code from
+ * https://stackoverflow.com/questions/22521982/check-if-point-is-inside-a-polygon
+ * most original version based on:
+ * https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html/pnpoly.html
+ * @param {*} point
+ * @param {*} vertices
+ * @returns
+ */
+const getIsPointInsidePolygon = (point, vertices) => {
+  const x = point[0];
+  const y = point[1];
+
+  let inside = false;
+  for (let i = 0, j = vertices.length - 1; i < vertices.length; j = i++) {
+    const xi = vertices[i][0],
+      yi = vertices[i][1];
+    const xj = vertices[j][0],
+      yj = vertices[j][1];
+
+    const intersect =
+      yi > y != yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+    if (intersect) {
+      inside = !inside;
+    }
+  }
+
+  return inside;
+};
+
+/**
+ * Check if inner contour is completely surrounded by outer contour.
+ * @param {*} outerContour
+ * @param {*} innerContour
+ * @returns
+ */
+function checkEnclosed(outerContour, innerContour, points) {
+  const vertices = [];
+  outerContour.contourPoints.forEach((point) => {
+    vertices.push([points[point][0], points[point][1]]);
+  });
+
+  let pointsNotEnclosed = 0;
+  innerContour.contourPoints.forEach((point) => {
+    const result = getIsPointInsidePolygon(
+      [points[point][0], points[point][1]],
+      vertices
+    );
+    //console.log(result);
+
+    if (!result) {
+      pointsNotEnclosed++;
+    }
+  });
+
+  return pointsNotEnclosed === 0;
+}
+
+/**
+ * Check if contours have holes, if so update contour accordingly
+ * @param {*} polyData
+ * @param {*} bypass
+ */
+export function processContourHoles(contours, points, useXOR = true) {
+  //console.log(points);
+
+  // Add non-closed planars to contour list
+  const retContours = contours.filter(
+    (contour) => contour.type !== 'CLOSED_PLANAR'
+  );
+
+  // Find closed planar contours
+  const closedContours = contours.filter(
+    (contour) => contour.type === 'CLOSED_PLANAR'
+  );
+
+  // Iterate through each contour in list check for contours that have holes
+  const contourWithHoles = [];
+  let contourWithoutHoles = [];
+  closedContours.forEach((contour, index) => {
+    const holes = [];
+
+    // Check if any other contour is a hole surrounded by current contour
+    closedContours.forEach((hContour, hIndex) => {
+      if (index != hIndex) {
+        // Check if inner loop contour is a hole of outer loop contour
+        if (checkEnclosed(contour, hContour, points)) {
+          holes.push(hIndex);
+        }
+      }
+    });
+
+    // Check if holes were found
+    if (holes.length > 0) {
+      // Note current contour and reference of its holes
+      contourWithHoles.push({
+        contour,
+        holes,
+      });
+    } else {
+      // Note contour index without holes
+      contourWithoutHoles.push(index);
+    }
+  });
+
+  if (useXOR) {
+    // XOR method
+    contourWithHoles.forEach((contourHoleSet) => {
+      // Modify contour with hole to type CLOSEDPLANAR_XOR
+      contourHoleSet.contour.type = 'CLOSEDPLANAR_XOR';
+      retContours.push(contourHoleSet.contour);
+
+      contourHoleSet.holes.forEach((holeIndex) => {
+        // Modify hole type to CLOSEDPLANAR_XOR
+        // and add to contour list to be returned
+        closedContours[holeIndex].type = 'CLOSEDPLANAR_XOR';
+        retContours.push(closedContours[holeIndex]);
+
+        // Remove hole from list of contours without holes
+        contourWithoutHoles = contourWithoutHoles.filter((contourIndex) => {
+          return contourIndex !== holeIndex;
+        });
+      });
+    });
+
+    // Add remaining contours to list (neither hole nor have holes)
+    contourWithoutHoles.forEach((contourIndex) => {
+      retContours.push(closedContours[contourIndex]);
+    });
+  } else {
+    // Keyhole method, not implemented
+  }
+
+  return retContours;
+}
+
+export default { processContourHoles };

package/src/utilities/contours/generateContourSetsFromLabelmap.ts

@@ -0,0 +1,160 @@
+import { cache as cornerstoneCache } from '@cornerstonejs/core';
+import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchingSquares';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+
+import { removeDuplicatePoints } from './mergePoints';
+import { findContoursFromReducedSet } from './contourFinder';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+
+const { Labelmap } = SegmentationRepresentations;
+
+function generateContourSetsFromLabelmap({ segmentations }) {
+  const { representationData, segments = [0, 1] } = segmentations;
+  const { volumeId: segVolumeId } = representationData[Labelmap];
+
+  // Get segmentation volume
+  const vol = cornerstoneCache.getVolume(segVolumeId);
+  if (!vol) {
+    console.warn(`No volume found for ${segVolumeId}`);
+    return;
+  }
+
+  const numSlices = vol.dimensions[2];
+
+  // Get image volume segmentation references
+  const imageVol = cornerstoneCache.getVolume(vol.referencedVolumeId);
+  if (!imageVol) {
+    console.warn(`No volume found for ${vol.referencedVolumeId}`);
+    return;
+  }
+
+  // NOTE: Workaround for marching squares not finding closed contours at
+  // boundary of image volume, clear pixels along x-y border of volume
+  const segData = vol.imageData.getPointData().getScalars().getData();
+  const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
+
+  for (let z = 0; z < numSlices; z++) {
+    for (let y = 0; y < vol.dimensions[1]; y++) {
+      const index = y * vol.dimensions[0] + z * pixelsPerSlice;
+      segData[index] = 0;
+      segData[index + vol.dimensions[0] - 1] = 0;
+    }
+  }
+
+  // end workaround
+  //
+  //
+  const ContourSets = [];
+
+  const { FrameOfReferenceUID } = imageVol.metadata;
+  // Iterate through all segments in current segmentation set
+  const numSegments = segments.length;
+  for (let segIndex = 0; segIndex < numSegments; segIndex++) {
+    const segment = segments[segIndex];
+
+    // Skip empty segments
+    if (!segment) {
+      continue;
+    }
+
+    const sliceContours = [];
+    const scalars = vtkDataArray.newInstance({
+      name: 'Scalars',
+      numberOfComponents: 1,
+      size: pixelsPerSlice * numSlices,
+      dataType: 'Uint8Array',
+    });
+    const { containedSegmentIndices } = segment;
+    for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
+      // Check if the slice is empty before running marching cube
+      if (
+        isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)
+      ) {
+        continue;
+      }
+      const frameStart = sliceIndex * pixelsPerSlice;
+
+      try {
+        // Modify segData for this specific segment directly
+        for (let i = 0; i < pixelsPerSlice; i++) {
+          const value = segData[i + frameStart];
+          if (value === segIndex || containedSegmentIndices?.has(value)) {
+            (scalars as any).setValue(i + frameStart, 1);
+          } else {
+            (scalars as any).setValue(i, 0);
+          }
+        }
+
+        const mSquares = vtkImageMarchingSquares.newInstance({
+          slice: sliceIndex,
+        });
+
+        // filter out the scalar data so that only it has background and
+        // the current segment index
+        const imageDataCopy = vtkImageData.newInstance();
+
+        imageDataCopy.shallowCopy(vol.imageData);
+        imageDataCopy.getPointData().setScalars(scalars);
+
+        // Connect pipeline
+        mSquares.setInputData(imageDataCopy);
+        const cValues = [1];
+        mSquares.setContourValues(cValues);
+        mSquares.setMergePoints(false);
+
+        // Perform marching squares
+        const msOutput = mSquares.getOutputData();
+
+        // Clean up output from marching squares
+        const reducedSet = removeDuplicatePoints(msOutput);
+        if (reducedSet.points?.length) {
+          const contours = findContoursFromReducedSet(reducedSet.lines);
+
+          sliceContours.push({
+            referencedImageId: imageVol.imageIds[sliceIndex],
+            contours,
+            polyData: reducedSet,
+            FrameNumber: sliceIndex + 1,
+            sliceIndex,
+            FrameOfReferenceUID,
+          });
+        }
+      } catch (e) {
+        console.warn(sliceIndex);
+        console.warn(e);
+      }
+    }
+
+    const metadata = {
+      referencedImageId: imageVol.imageIds[0], // just use 0 for overall
+      FrameOfReferenceUID,
+    };
+
+    const ContourSet = {
+      label: segment.label,
+      color: segment.color,
+      metadata,
+      sliceContours,
+    };
+
+    ContourSets.push(ContourSet);
+  }
+
+  return ContourSets;
+}
+
+function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+  const startIdx = sliceIndex * pixelsPerSlice;
+  const endIdx = startIdx + pixelsPerSlice;
+
+  for (let i = startIdx; i < endIdx; i++) {
+    if (segData[i] === segIndex) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export { generateContourSetsFromLabelmap };

package/src/utilities/contours/index.ts

@@ -0,0 +1,14 @@
+import contourFinder from './contourFinder';
+import mergePoints from './mergePoints';
+import detectContourHoles from './detectContourHoles';
+import { generateContourSetsFromLabelmap } from './generateContourSetsFromLabelmap';
+
+import AnnotationToPointData from './AnnotationToPointData';
+
+export {
+  contourFinder,
+  mergePoints,
+  detectContourHoles,
+  generateContourSetsFromLabelmap,
+  AnnotationToPointData,
+};

package/src/utilities/contours/mergePoints.ts

@@ -0,0 +1,108 @@
+/**
+ * Checks if point is within array
+ * @param {*} array
+ * @param {*} pt
+ * @returns
+ */
+function ptInArray(array, pt) {
+  let index = -1;
+  for (let i = 0; i < array.length; i++) {
+    if (isSamePoint(pt, array[i])) {
+      index = i;
+    }
+  }
+  return index;
+}
+
+/**
+ * Checks if point A and point B contain same values
+ * @param {*} ptA
+ * @param {*} ptB
+ * @returns
+ */
+function isSamePoint(ptA, ptB) {
+  if (ptA[0] == ptB[0] && ptA[1] == ptB[1] && ptA[2] == ptB[2]) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Goes through linesArray and replaces all references of old index with new index
+ * @param {*} linesArray
+ * @param {*} oldIndex
+ * @param {*} newIndex
+ */
+function replacePointIndexReferences(linesArray, oldIndex, newIndex) {
+  for (let i = 0; i < linesArray.length; i++) {
+    const line = linesArray[i];
+    if (line.a == oldIndex) {
+      line.a = newIndex;
+    } else if (line.b == oldIndex) {
+      line.b = newIndex;
+    }
+  }
+}
+
+/**
+ * Iterate through polyData from vtkjs and merge any points that are the same
+ * then update merged point references within lines array
+ * @param {*} polyData
+ * @param {*} bypass
+ * @returns
+ */
+export function removeDuplicatePoints(polyData, bypass = false) {
+  const points = polyData.getPoints();
+  const lines = polyData.getLines();
+
+  const pointsArray = [];
+  for (let i = 0; i < points.getNumberOfPoints(); i++) {
+    const pt = points.getPoint(i).slice();
+    pointsArray.push(pt);
+  }
+  const linesArray = [];
+  for (let i = 0; i < lines.getNumberOfCells(); i++) {
+    const cell = lines.getCell(i * 3).slice();
+    //console.log(JSON.stringify(cell));
+    const a = cell[0];
+    const b = cell[1];
+    const line = {
+      a,
+      b,
+    };
+    linesArray.push(line);
+  }
+
+  if (bypass) {
+    return { points: pointsArray, lines: linesArray };
+  }
+
+  // Iterate through points and replace any duplicates
+  const newPoints = [];
+  for (let i = 0; i < pointsArray.length; i++) {
+    const pt = pointsArray[i];
+    let index = ptInArray(newPoints, pt);
+
+    if (index >= 0) {
+      // Duplicate Point -> replace references in lines
+      replacePointIndexReferences(linesArray, i, index);
+    } else {
+      index = newPoints.length;
+      newPoints.push(pt);
+      replacePointIndexReferences(linesArray, i, index);
+    }
+  }
+
+  // Final pass through lines, remove any that refer to exact same point
+  const newLines = [];
+  linesArray.forEach((line) => {
+    if (line.a != line.b) {
+      newLines.push(line);
+    }
+  });
+
+  return { points: newPoints, lines: newLines };
+}
+
+export default { removeDuplicatePoints };