@cornerstonejs/tools 1.73.0 → 1.74.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.73.0",
+  "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.73.0",
+    "@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": "7d9375494668c1b3857c560643e490470d35523d"
+  "gitHead": "092b216feafeede75c7dff4ddd415f034a218f19"
 }

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;
   };