@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.2

package/src/tools/annotation/LengthTool.ts

@@ -113,6 +113,7 @@ class LengthTool extends AnnotationTool {
       supportedInteractionTypes: ['Mouse', 'Touch'],
       configuration: {
         preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
       },
     }
   ) {
@@ -731,7 +732,22 @@ class LengthTool extends AnnotationTool {
         return renderStatus;
       }
 
-      const textLines = this._getTextLines(data, targetId);
+      const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+      if (!options.visibility) {
+        data.handles.textBox = {
+          hasMoved: false,
+          worldPosition: <Types.Point3>[0, 0, 0],
+          worldBoundingBox: {
+            topLeft: <Types.Point3>[0, 0, 0],
+            topRight: <Types.Point3>[0, 0, 0],
+            bottomLeft: <Types.Point3>[0, 0, 0],
+            bottomRight: <Types.Point3>[0, 0, 0],
+          },
+        };
+        continue;
+      }
+
+      const textLines = this.configuration.getTextLines(data, targetId);
 
       // Need to update to sync with annotation while unlinked/not moved
       if (!data.handles.textBox.hasMoved) {
@@ -754,7 +770,7 @@ class LengthTool extends AnnotationTool {
         textBoxPosition,
         canvasCoordinates,
         {},
-        this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+        options
       );
 
       const { x: left, y: top, width, height } = boundingBox;
@@ -770,21 +786,6 @@ class LengthTool extends AnnotationTool {
     return renderStatus;
   };
 
-  // text line for the current active length annotation
-  _getTextLines(data, targetId) {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { length, unit } = cachedVolumeStats;
-
-    // Can be null on load
-    if (length === undefined || length === null || isNaN(length)) {
-      return;
-    }
-
-    const textLines = [`${roundNumber(length)} ${unit}`];
-
-    return textLines;
-  }
-
   _calculateLength(pos1, pos2) {
     const dx = pos1[0] - pos2[0];
     const dy = pos1[1] - pos2[1];
@@ -862,5 +863,19 @@ class LengthTool extends AnnotationTool {
   }
 }
 
+function defaultGetTextLines(data, targetId): string[] {
+  const cachedVolumeStats = data.cachedStats[targetId];
+  const { length, unit } = cachedVolumeStats;
+
+  // Can be null on load
+  if (length === undefined || length === null || isNaN(length)) {
+    return;
+  }
+
+  const textLines = [`${roundNumber(length)} ${unit}`];
+
+  return textLines;
+}
+
 LengthTool.toolName = 'Length';
 export default LengthTool;

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -59,6 +59,7 @@ import {
   ModalityUnitOptions,
   getModalityUnit,
 } from '../../utilities/getModalityUnit';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
 
 const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
@@ -124,6 +125,7 @@ const PARALLEL_THRESHOLD = 1 - EPSILON;
  *
  * Read more in the Docs section of the website.
  */
+
 class PlanarFreehandROITool extends AnnotationTool {
   static toolName;
 
@@ -215,6 +217,8 @@ class PlanarFreehandROITool extends AnnotationTool {
           knotsRatioPercentageOnEdit: 40,
         },
         calculateStats: false,
+        getTextLines: defaultGetTextLines,
+        statsCalculator: BasicStatsCalculator,
       },
     }
   ) {
@@ -662,15 +666,18 @@ class PlanarFreehandROITool extends AnnotationTool {
       renderStatus = true;
     }
 
-    if (!this.configuration.calculateStats) return;
+    if (!this.configuration.calculateStats) {
+      return;
+    }
 
     annotations.forEach((annotation) => {
       const activeAnnotationUID = this.commonData?.annotation.annotationUID;
       if (
         annotation.annotationUID === activeAnnotationUID &&
         !this.commonData?.movingTextBox
-      )
+      ) {
         return;
+      }
 
       const modalityUnitOptions = {
         isPreScaled: isViewportPreScaled(viewport, targetId),
@@ -802,25 +809,10 @@ class PlanarFreehandROITool extends AnnotationTool {
       const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
       const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
 
-      let count = 0;
-      let sum = 0;
-      let sumSquares = 0;
-      let max = -Infinity;
-
-      const statCalculator = ({ value: newValue }) => {
-        if (newValue > max) {
-          max = newValue;
-        }
-
-        sum += newValue;
-        sumSquares += newValue ** 2;
-        count += 1;
-      };
-
       let curRow = 0;
       let intersections = [];
       let intersectionCounter = 0;
-      pointInShapeCallback(
+      const pointsInShape = pointInShapeCallback(
         imageData,
         (pointLPS, pointIJK) => {
           let result = true;
@@ -854,28 +846,26 @@ class PlanarFreehandROITool extends AnnotationTool {
           }
           return result;
         },
-        statCalculator,
+        this.configuration.statsCalculator.statsCallback,
         boundsIJK
       );
 
-      const mean = sum / count;
-
-      // https://www.strchr.com/standard_deviation_in_one_pass?allcomments=1
-      let stdDev = sumSquares / count - mean ** 2;
-      stdDev = Math.sqrt(stdDev);
-
       const modalityUnit = getModalityUnit(
         metadata.Modality,
         annotation.metadata.referencedImageId,
         modalityUnitOptions
       );
 
+      const stats = this.configuration.statsCalculator.getStatistics();
+
       cachedStats[targetId] = {
         Modality: metadata.Modality,
         area,
-        mean,
-        max,
-        stdDev,
+        mean: stats[1]?.value,
+        max: stats[0]?.value,
+        stdDev: stats[3]?.value,
+        statsArray: stats,
+        pointsInShape: pointsInShape,
         areaUnit: getCalibratedAreaUnits(null, image),
         modalityUnit,
       };
@@ -892,8 +882,21 @@ class PlanarFreehandROITool extends AnnotationTool {
     const data = annotation.data;
     const targetId = this.getTargetId(viewport);
 
-    const textLines = this._getTextLines(data, targetId);
-    if (!textLines || textLines.length === 0) return;
+    const styleSpecifier: AnnotationStyle.StyleSpecifier = {
+      toolGroupId: this.toolGroupId,
+      toolName: this.getToolName(),
+      viewportId: enabledElement.viewport.id,
+    };
+
+    const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+    if (!options.visibility) {
+      return;
+    }
+
+    const textLines = this.configuration.getTextLines(data, targetId);
+    if (!textLines || textLines.length === 0) {
+      return;
+    }
 
     const canvasCoordinates = data.polyline.map((p) =>
       viewport.worldToCanvas(p)
@@ -909,12 +912,6 @@ class PlanarFreehandROITool extends AnnotationTool {
       data.handles.textBox.worldPosition
     );
 
-    const styleSpecifier: AnnotationStyle.StyleSpecifier = {
-      toolGroupId: this.toolGroupId,
-      toolName: this.getToolName(),
-      viewportId: enabledElement.viewport.id,
-    };
-
     const textBoxUID = '1';
     const boundingBox = drawLinkedTextBox(
       svgDrawingHelper,
@@ -924,7 +921,7 @@ class PlanarFreehandROITool extends AnnotationTool {
       textBoxPosition,
       canvasCoordinates,
       {},
-      this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+      options
     );
 
     const { x: left, y: top, width, height } = boundingBox;
@@ -936,35 +933,35 @@ class PlanarFreehandROITool extends AnnotationTool {
       bottomRight: viewport.canvasToWorld([left + width, top + height]),
     };
   };
+}
 
-  _getTextLines = (data, targetId: string): string[] => {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } =
-      cachedVolumeStats;
+function defaultGetTextLines(data, targetId): string[] {
+  const cachedVolumeStats = data.cachedStats[targetId];
+  const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } =
+    cachedVolumeStats;
 
-    const textLines: string[] = [];
+  const textLines: string[] = [];
 
-    if (area) {
-      const areaLine = isEmptyArea
-        ? `Area: Oblique not supported`
-        : `Area: ${roundNumber(area)} ${areaUnit}`;
-      textLines.push(areaLine);
-    }
+  if (area) {
+    const areaLine = isEmptyArea
+      ? `Area: Oblique not supported`
+      : `Area: ${roundNumber(area)} ${areaUnit}`;
+    textLines.push(areaLine);
+  }
 
-    if (mean) {
-      textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
-    }
+  if (mean) {
+    textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+  }
 
-    if (max) {
-      textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
-    }
+  if (max) {
+    textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+  }
 
-    if (stdDev) {
-      textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
-    }
+  if (stdDev) {
+    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+  }
 
-    return textLines;
-  };
+  return textLines;
 }
 
 PlanarFreehandROITool.toolName = 'PlanarFreehandROI';

package/src/tools/annotation/ProbeTool.ts

@@ -94,6 +94,7 @@ const { transformWorldToIndex } = csUtils;
  * Read more in the Docs section of the website.
  *
  */
+
 class ProbeTool extends AnnotationTool {
   static toolName;
 
@@ -118,6 +119,7 @@ class ProbeTool extends AnnotationTool {
       configuration: {
         shadow: true,
         preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
       },
     }
   ) {
@@ -525,7 +527,12 @@ class ProbeTool extends AnnotationTool {
 
       renderStatus = true;
 
-      const textLines = this._getTextLines(data, targetId);
+      const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+      if (!options.visibility) {
+        continue;
+      }
+
+      const textLines = this.configuration.getTextLines(data, targetId);
       if (textLines) {
         const textCanvasCoordinates = [
           canvasCoordinates[0] + 6,
@@ -539,7 +546,7 @@ class ProbeTool extends AnnotationTool {
           textUID,
           textLines,
           [textCanvasCoordinates[0], textCanvasCoordinates[1]],
-          this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+          options
         );
       }
     }
@@ -547,23 +554,6 @@ class ProbeTool extends AnnotationTool {
     return renderStatus;
   };
 
-  _getTextLines(data, targetId: string): string[] | undefined {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, modalityUnit } = cachedVolumeStats;
-
-    if (value === undefined) {
-      return;
-    }
-
-    const textLines = [];
-
-    textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-
-    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
-
-    return textLines;
-  }
-
   _calculateCachedStats(
     annotation,
     renderingEngine,
@@ -662,5 +652,22 @@ class ProbeTool extends AnnotationTool {
   }
 }
 
+function defaultGetTextLines(data, targetId): string[] {
+  const cachedVolumeStats = data.cachedStats[targetId];
+  const { index, value, modalityUnit } = cachedVolumeStats;
+
+  if (value === undefined) {
+    return;
+  }
+
+  const textLines = [];
+
+  textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
+
+  textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
+
+  return textLines;
+}
+
 ProbeTool.toolName = 'Probe';
 export default ProbeTool;

package/src/tools/annotation/RectangleROITool.ts

@@ -56,6 +56,8 @@ import {
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 import { getModalityUnit } from '../../utilities/getModalityUnit';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
+import { pointInShapeCallback } from '../../utilities/';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -97,6 +99,7 @@ const { transformWorldToIndex } = csUtils;
  *
  * Read more in the Docs section of the website.
  */
+
 class RectangleROITool extends AnnotationTool {
   static toolName;
 
@@ -119,6 +122,8 @@ class RectangleROITool extends AnnotationTool {
       configuration: {
         shadow: true,
         preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
+        statsCalculator: BasicStatsCalculator,
       },
     }
   ) {
@@ -786,7 +791,22 @@ class RectangleROITool extends AnnotationTool {
 
       renderStatus = true;
 
-      const textLines = this._getTextLines(data, targetId);
+      const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+      if (!options.visibility) {
+        data.handles.textBox = {
+          hasMoved: false,
+          worldPosition: <Types.Point3>[0, 0, 0],
+          worldBoundingBox: {
+            topLeft: <Types.Point3>[0, 0, 0],
+            topRight: <Types.Point3>[0, 0, 0],
+            bottomLeft: <Types.Point3>[0, 0, 0],
+            bottomRight: <Types.Point3>[0, 0, 0],
+          },
+        };
+        continue;
+      }
+
+      const textLines = this.configuration.getTextLines(data, targetId);
       if (!textLines || textLines.length === 0) {
         continue;
       }
@@ -811,7 +831,7 @@ class RectangleROITool extends AnnotationTool {
         textBoxPosition,
         canvasCoordinates,
         {},
-        this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+        options
       );
 
       const { x: left, y: top, width, height } = boundingBox;
@@ -845,33 +865,6 @@ class RectangleROITool extends AnnotationTool {
     };
   };
 
-  /**
-   * _getTextLines - Returns the Area, mean and std deviation of the area of the
-   * target volume enclosed by the rectangle.
-   *
-   * @param data - The annotation tool-specific data.
-   * @param targetId - The volumeId of the volume to display the stats for.
-   * @param isPreScaled - Whether the viewport is pre-scaled or not.
-   */
-  _getTextLines = (data, targetId: string): string[] | undefined => {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnit, modalityUnit } =
-      cachedVolumeStats;
-
-    if (mean === undefined) {
-      return;
-    }
-
-    const textLines: string[] = [];
-
-    textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
-    textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
-    textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
-    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
-
-    return textLines;
-  };
-
   /**
    * _calculateCachedStats - For each volume in the frame of reference that a
    * tool instance in particular viewport defines as its target volume, find the
@@ -945,6 +938,12 @@ class RectangleROITool extends AnnotationTool {
         const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
         const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
 
+        const boundsIJK = [
+          [iMin, iMax],
+          [jMin, jMax],
+          [kMin, kMax],
+        ] as [Types.Point2, Types.Point2, Types.Point2];
+
         const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(
           viewPlaneNormal,
           viewUp,
@@ -955,61 +954,29 @@ class RectangleROITool extends AnnotationTool {
 
         const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
 
-        let count = 0;
-        let mean = 0;
-        let stdDev = 0;
-        let max = -Infinity;
-
-        const yMultiple = dimensions[0];
-        const zMultiple = dimensions[0] * dimensions[1];
-
-        //Todo: this can be replaced by pointInShapeCallback....
-        // This is a triple loop, but one of these 3 values will be constant
-        // In the planar view.
-        for (let k = kMin; k <= kMax; k++) {
-          for (let j = jMin; j <= jMax; j++) {
-            for (let i = iMin; i <= iMax; i++) {
-              const value = scalarData[k * zMultiple + j * yMultiple + i];
-
-              if (value > max) {
-                max = value;
-              }
-
-              count++;
-              mean += value;
-            }
-          }
-        }
-
-        mean /= count;
-
-        for (let k = kMin; k <= kMax; k++) {
-          for (let j = jMin; j <= jMax; j++) {
-            for (let i = iMin; i <= iMax; i++) {
-              const value = scalarData[k * zMultiple + j * yMultiple + i];
-
-              const valueMinusMean = value - mean;
-
-              stdDev += valueMinusMean * valueMinusMean;
-            }
-          }
-        }
-
-        stdDev /= count;
-        stdDev = Math.sqrt(stdDev);
-
         const modalityUnit = getModalityUnit(
           metadata.Modality,
           annotation.metadata.referencedImageId,
           modalityUnitOptions
         );
 
+        const pointsInShape = pointInShapeCallback(
+          imageData,
+          () => true,
+          this.configuration.statsCalculator.statsCallback,
+          boundsIJK
+        );
+
+        const stats = this.configuration.statsCalculator.getStatistics();
+
         cachedStats[targetId] = {
           Modality: metadata.Modality,
           area,
-          mean,
-          stdDev,
-          max,
+          mean: stats[1]?.value,
+          stdDev: stats[2]?.value,
+          max: stats[0]?.value,
+          statsArray: stats,
+          pointsInShape: pointsInShape,
           areaUnit: getCalibratedAreaUnits(null, image),
           modalityUnit,
         };
@@ -1044,5 +1011,30 @@ class RectangleROITool extends AnnotationTool {
   };
 }
 
+/**
+ * _getTextLines - Returns the Area, mean and std deviation of the area of the
+ * target volume enclosed by the rectangle.
+ *
+ * @param data - The annotation tool-specific data.
+ * @param targetId - The volumeId of the volume to display the stats for.
+ */
+function defaultGetTextLines(data, targetId: string): string[] {
+  const cachedVolumeStats = data.cachedStats[targetId];
+  const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+
+  if (mean === undefined) {
+    return;
+  }
+
+  const textLines: string[] = [];
+
+  textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
+  textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+  textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+  textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+
+  return textLines;
+}
+
 RectangleROITool.toolName = 'RectangleROI';
 export default RectangleROITool;

package/src/tools/base/AnnotationTool.ts

@@ -18,10 +18,12 @@ import {
   EventTypes,
   ToolHandle,
   InteractionTypes,
+  ToolProps,
+  PublicToolProps,
 } from '../../types';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 
-/**
+/**-q
  * Abstract class for tools which create and display annotations on the
  * cornerstone3D canvas. In addition, it provides a base class for segmentation
  * tools that require drawing an annotation before running the segmentation strategy
@@ -37,6 +39,19 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
   // Abstract Methods - Must be implemented.
   // ===================================================================
 
+  constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
+    super(toolProps, defaultToolProps);
+
+    if (toolProps.configuration?.getTextLines) {
+      this.configuration.getTextLines = toolProps.configuration.getTextLines;
+    }
+
+    if (toolProps.configuration?.statsCalculator) {
+      this.configuration.statsCalculator =
+        toolProps.configuration.statsCalculator;
+    }
+  }
+
   /**
    * @abstract addNewAnnotation Creates a new annotation based on the clicked mouse position
    *
@@ -185,24 +200,26 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
 
     const { data } = annotation;
     const { points, textBox } = data.handles;
-    const { worldBoundingBox } = textBox;
 
-    if (worldBoundingBox) {
-      const canvasBoundingBox = {
-        topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
-        topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
-        bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
-        bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
-      };
+    if (textBox) {
+      const { worldBoundingBox } = textBox;
+      if (worldBoundingBox) {
+        const canvasBoundingBox = {
+          topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
+          topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
+          bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
+          bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
+        };
 
-      if (
-        canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
-        canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
-        canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
-        canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
-      ) {
-        data.handles.activeHandleIndex = null;
-        return textBox;
+        if (
+          canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
+          canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
+          canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
+          canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
+        ) {
+          data.handles.activeHandleIndex = null;
+          return textBox;
+        }
       }
     }
 
@@ -240,6 +257,11 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
     // for the textBox.
 
     return {
+      visibility: this.getStyle(
+        'textBoxVisibility',
+        specifications,
+        annotation
+      ),
       fontFamily: this.getStyle(
         'textBoxFontFamily',
         specifications,

package/src/tools/base/index.ts

@@ -1,4 +1,5 @@
 import BaseTool from './BaseTool';
 import AnnotationTool from './AnnotationTool';
+import AnnotationDisplayTool from './AnnotationDisplayTool';
 
-export { BaseTool, AnnotationTool };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool };

package/src/tools/displayTools/Labelmap/labelmapDisplay.ts

@@ -276,6 +276,9 @@ function _setLabelmapColorAndOpacity(
     isActiveLabelmap
   );
 
+  // Todo: the below loop probably can be optimized so that we don't hit it
+  // unless a config has changed. Right now we get into the following loop
+  // even for brush drawing which does not makes sense
   for (let i = 0; i < numColors; i++) {
     const segmentIndex = i;
     const segmentColor = colorLUT[segmentIndex];