@cornerstonejs/tools 1.72.6 → 1.74.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.72.6",
+  "version": "1.74.0",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,7 +29,7 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.72.6",
+    "@cornerstonejs/core": "^1.74.0",
     "@icr/polyseg-wasm": "0.4.0",
     "@types/offscreencanvas": "2019.7.3",
     "comlink": "^4.4.1",
@@ -59,5 +59,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "992f6c69b8f57a3344a1e8ec676376be693ec555"
+  "gitHead": "092b216feafeede75c7dff4ddd415f034a218f19"
 }

package/src/tools/annotation/PlanarFreehandROITool.ts

@@ -170,6 +170,12 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     annotation: PlanarFreehandROIAnnotation
   ) => void;
 
+  private renderPointContourWithMarker: (
+    enabledElement: Types.IEnabledElement,
+    svgDrawingHelper: SVGDrawingHelper,
+    annotation: PlanarFreehandROIAnnotation
+  ) => void;
+
   constructor(
     toolProps: PublicToolProps = {},
     defaultToolProps: ToolProps = {
@@ -242,6 +248,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
            */
           epsilon: 0.1,
         },
+        displayOnePointAsCrosshairs: false,
         calculateStats: true,
         getTextLines: defaultGetTextLines,
         statsCalculator: BasicStatsCalculator,
@@ -578,7 +585,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     if (!(isDrawing || isEditingOpen || isEditingClosed)) {
       // No annotations are currently being modified, so we can just use the
       // render contour method to render all of them
-      this.renderContour(enabledElement, svgDrawingHelper, annotation);
+      if (
+        this.configuration.displayOnePointAsCrosshairs &&
+        annotation.data.contour.polyline.length === 1
+      ) {
+        this.renderPointContourWithMarker(
+          enabledElement,
+          svgDrawingHelper,
+          annotation
+        );
+      } else {
+        this.renderContour(enabledElement, svgDrawingHelper, annotation);
+      }
     } else {
       // The active annotation will need special rendering treatment. Render all
       // other annotations not being interacted with using the standard renderContour
@@ -610,7 +628,18 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
           );
         }
       } else {
-        this.renderContour(enabledElement, svgDrawingHelper, annotation);
+        if (
+          this.configuration.displayOnePointAsCrosshairs &&
+          annotation.data.contour.polyline.length === 1
+        ) {
+          this.renderPointContourWithMarker(
+            enabledElement,
+            svgDrawingHelper,
+            annotation
+          );
+        } else {
+          this.renderContour(enabledElement, svgDrawingHelper, annotation);
+        }
       }
 
       // Todo: return boolean flag for each rendering route in the planar tool.

package/src/tools/annotation/planarFreehandROITool/renderMethods.ts

@@ -407,6 +407,71 @@ function renderOpenContourBeingEdited(
   );
 }
 
+/**
+ * Renders a point `PlanarFreehandROIAnnotation` annotation by drawing a circle and a crosshair
+ */
+
+function renderPointContourWithMarker(
+  enabledElement: Types.IEnabledElement,
+  svgDrawingHelper: SVGDrawingHelper,
+  annotation: PlanarFreehandROIAnnotation
+): void {
+  if (annotation.parentAnnotationUID) {
+    return;
+  }
+  const { viewport } = enabledElement;
+  const options = this._getRenderingOptions(enabledElement, annotation);
+  const canvasPolyline = annotation.data.contour.polyline.map((worldPos) =>
+    viewport.worldToCanvas(worldPos)
+  );
+  const childContours = getContourHolesDataCanvas(annotation, viewport);
+  const polylineUID = '1';
+
+  const center = canvasPolyline[0];
+  const radius = 6;
+  const numberOfPoints = 100;
+  const circlePoints = [];
+
+  for (let i = 0; i < numberOfPoints; i++) {
+    const angle = (i / numberOfPoints) * 2 * Math.PI;
+    const x = center[0] + radius * Math.cos(angle);
+    const y = center[1] + radius * Math.sin(angle);
+    circlePoints.push([x, y]);
+  }
+
+  const crosshair = [
+    [center[0] - radius * 2, center[1]],
+    [center[0] + radius * 2, center[1]],
+    [center[0], center[1] - radius * 2],
+    [center[0], center[1] + radius * 2],
+  ] as Types.Point2[];
+
+  drawPathSvg(
+    svgDrawingHelper,
+    annotation.annotationUID,
+    polylineUID + '-crosshair_v',
+    [crosshair[0], crosshair[1]],
+    options
+  );
+
+  drawPathSvg(
+    svgDrawingHelper,
+    annotation.annotationUID,
+    polylineUID + '-crosshair_h',
+    [crosshair[2], crosshair[3]],
+    options
+  );
+
+  const allContours = [circlePoints, ...childContours];
+
+  drawPathSvg(
+    svgDrawingHelper,
+    annotation.annotationUID,
+    polylineUID,
+    allContours,
+    options
+  );
+}
 /**
  * Registers the render methods of various contour states to the tool instance.
  */
@@ -414,6 +479,8 @@ function registerRenderMethods(toolInstance) {
   toolInstance.renderContour = renderContour.bind(toolInstance);
   toolInstance.renderClosedContour = renderClosedContour.bind(toolInstance);
   toolInstance.renderOpenContour = renderOpenContour.bind(toolInstance);
+  toolInstance.renderPointContourWithMarker =
+    renderPointContourWithMarker.bind(toolInstance);
   toolInstance.renderOpenUShapedContour =
     renderOpenUShapedContour.bind(toolInstance);
 

package/src/tools/displayTools/Contour/contourHandler/handleContourSegmentation.ts

@@ -163,7 +163,7 @@ function addContourSetsToElement(
         highlighted: false,
         autoGenerated: false,
         invalidated: false,
-        isLocked: false,
+        isLocked: true,
         isVisible: true,
         metadata: {
           referencedImageId: viewport.getCurrentImageId(),

package/src/types/CalculatorTypes.ts

@@ -1,3 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+
 type Statistics = {
   name: string;
   label?: string;
@@ -8,12 +10,13 @@ type Statistics = {
 type NamedStatistics = {
   mean: Statistics & { name: 'mean' };
   max: Statistics & { name: 'max' };
+  min: Statistics & { name: 'min' };
   stdDev: Statistics & { name: 'stdDev' };
-  stdDevWithSumSquare: Statistics & { name: 'stdDevWithSumSquare' };
   count: Statistics & { name: 'count' };
   area?: Statistics & { name: 'area' };
   volume?: Statistics & { name: 'volume' };
-  circumferance?: Statistics & { name: 'circumferance' };
+  circumference?: Statistics & { name: 'circumference' };
+  pointsInShape?: Types.PointsManager<Types.Point3>;
   array: Statistics[];
 };
 

package/src/utilities/math/basic/BasicStatsCalculator.ts

@@ -1,113 +1,143 @@
-import { NamedStatistics, Statistics } from '../../../types';
+import { utilities } from '@cornerstonejs/core';
+import { NamedStatistics } from '../../../types';
 import Calculator from './Calculator';
 
+const { PointsManager } = utilities;
+
 export default class BasicStatsCalculator extends Calculator {
   private static max = [-Infinity];
+  private static min = [Infinity];
   private static sum = [0];
-  private static sumSquares = [0];
-  private static squaredDiffSum = [0];
   private static count = 0;
 
+  // private static sumSquares = [0];
+  // Values for Welford's algorithm
+  private static runMean = [0];
+  private static m2 = [0];
+
+  // Collect the points to be returned
+  private static pointsInShape = PointsManager.create3(1024);
+
+  public static statsInit(options: { noPointsCollection: boolean }) {
+    if (options.noPointsCollection) {
+      BasicStatsCalculator.pointsInShape = null;
+    }
+  }
+
   /**
-   * This callback is used when we verify if the point is in the annotion drawn so we can get every point
-   * in the shape to calculate the statistics
-   * @param value of the point in the shape of the annotation
+   * This callback is used when we verify if the point is in the annotation drawn
+   * so we can get every point in the shape to calculate the statistics
    */
-  static statsCallback = ({ value: newValue }): void => {
+  static statsCallback = ({ value: newValue, pointLPS = null }): void => {
     if (
       Array.isArray(newValue) &&
       newValue.length > 1 &&
       this.max.length === 1
     ) {
       this.max.push(this.max[0], this.max[0]);
+      this.min.push(this.min[0], this.min[0]);
       this.sum.push(this.sum[0], this.sum[0]);
-      this.sumSquares.push(this.sumSquares[0], this.sumSquares[0]);
-      this.squaredDiffSum.push(this.squaredDiffSum[0], this.squaredDiffSum[0]);
+      this.runMean.push(0, 0);
+      // this.sumSquares.push(this.sumSquares[0], this.sumSquares[0]);
+      this.m2.push(this.m2[0], this.m2[0]);
     }
 
+    this.pointsInShape?.push(pointLPS);
     const newArray = Array.isArray(newValue) ? newValue : [newValue];
+
     this.count += 1;
+    this.max.map((it, idx) => {
+      const value = newArray[idx];
 
-    this.max.forEach(
-      (it, idx) => (this.max[idx] = Math.max(it, newArray[idx]))
-    );
-    this.sum.map((it, idx) => (this.sum[idx] += newArray[idx]));
-    this.sumSquares.map(
-      (it, idx) => (this.sumSquares[idx] += newArray[idx] ** 2)
-    );
-    this.squaredDiffSum.map(
-      (it, idx) =>
-        (this.squaredDiffSum[idx] += Math.pow(
-          newArray[idx] - this.sum[idx] / this.count,
-          2
-        ))
-    );
+      const delta = value - this.runMean[idx];
+      this.sum[idx] += value;
+      this.runMean[idx] += delta / this.count;
+      const delta2 = value - this.runMean[idx];
+      this.m2[idx] += delta * delta2;
+      // this.sumSquares[idx] += value * value;
+
+      this.min[idx] = Math.min(this.min[idx], value);
+      this.max[idx] = Math.max(it, value);
+    });
   };
 
   /**
-   * Basic function that calculates statictics for a given array of points.
+   * Basic function that calculates statistics for a given array of points.
    * @returns An object that contains :
    * max : The maximum value of the array
    * mean : mean of the array
    * stdDev : standard deviation of the array
-   * stdDevWithSumSquare : standard deviation of the array using sum²
    * array : An array of hte above values, in order.
    */
 
-  static getStatistics = (): NamedStatistics => {
+  static getStatistics = (options?: { unit: string }): NamedStatistics => {
     const mean = this.sum.map((sum) => sum / this.count);
-    const stdDev = this.squaredDiffSum.map((squaredDiffSum) =>
+    const stdDev = this.m2.map((squaredDiffSum) =>
       Math.sqrt(squaredDiffSum / this.count)
     );
-    const stdDevWithSumSquare = this.sumSquares.map((it, idx) =>
-      Math.sqrt(this.sumSquares[idx] / this.count - mean[idx] ** 2)
-    );
+    // const stdDevWithSumSquare = this.sumSquares.map((it, idx) =>
+    //   Math.sqrt(this.sumSquares[idx] / this.count - mean[idx] ** 2)
+    // );
+
+    const unit = options?.unit || null;
 
     const named: NamedStatistics = {
       max: {
         name: 'max',
         label: 'Max Pixel',
         value: singleArrayAsNumber(this.max),
-        unit: null,
+        unit,
+      },
+      min: {
+        name: 'min',
+        label: 'Min Pixel',
+        value: singleArrayAsNumber(this.min),
+        unit,
       },
       mean: {
         name: 'mean',
         label: 'Mean Pixel',
         value: singleArrayAsNumber(mean),
-        unit: null,
+        unit,
       },
       stdDev: {
         name: 'stdDev',
         label: 'Standard Deviation',
         value: singleArrayAsNumber(stdDev),
-        unit: null,
-      },
-      stdDevWithSumSquare: {
-        name: 'stdDevWithSumSquare',
-        value: singleArrayAsNumber(stdDevWithSumSquare),
-        unit: null,
+        unit,
       },
+      // stdDevWithSumSquare: {
+      //   name: 'stdDevWithSumSquare',
+      //   value: singleArrayAsNumber(stdDevWithSumSquare),
+      //   unit,
+      // },
       count: {
         name: 'count',
         label: 'Pixel Count',
         value: this.count,
         unit: null,
       },
+      pointsInShape: this.pointsInShape,
       array: [],
     };
     named.array.push(
       named.max,
       named.mean,
       named.stdDev,
-      named.stdDevWithSumSquare,
+      // Use the stdDev twice to preserve old ordering - this is updated to be
+      // correct value with Welford's algorithm now.
+      named.stdDev,
       named.count
     );
 
     this.max = [-Infinity];
+    this.min = [Infinity];
     this.sum = [0];
-    this.sumSquares = [0];
-    this.squaredDiffSum = [0];
+    // this.sumSquares = [0];
+    this.m2 = [0];
+    this.runMean = [0];
     this.count = 0;
+    this.pointsInShape = PointsManager.create3(1024);
 
     return named;
   };