Initial commit from prod-batam

extensions/tmtv/src/utils/calculateSUVPeakWorker.js

@@ -0,0 +1,209 @@
+import { utilities } from '@cornerstonejs/core';
+import { utilities as cstUtils } from '@cornerstonejs/tools';
+import { vec3 } from 'gl-matrix';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import { expose } from 'comlink';
+
+const createVolume = ({ dimensions, origin, direction, spacing, metadata, scalarData }) => {
+  const imageData = vtkImageData.newInstance();
+  imageData.setDimensions(dimensions);
+  imageData.setOrigin(origin);
+  imageData.setDirection(direction);
+  imageData.setSpacing(spacing);
+
+  const scalarArray = vtkDataArray.newInstance({
+    name: 'Pixels',
+    numberOfComponents: 1,
+    values: scalarData,
+  });
+
+  imageData.getPointData().setScalars(scalarArray);
+
+  imageData.modified();
+
+  const voxelManager = utilities.VoxelManager.createScalarVolumeVoxelManager({
+    scalarData,
+    dimensions,
+    numberOfComponents: 1,
+  });
+  return {
+    imageData,
+    spacing,
+    origin,
+    direction,
+    metadata,
+    voxelManager,
+  };
+};
+
+/**
+ * This method calculates the SUV peak on a segmented ROI from a reference PET
+ * volume. If a rectangle annotation is provided, the peak is calculated within that
+ * rectangle. Otherwise, the calculation is performed on the entire volume which
+ * will be slower but same result.
+ * @param viewport Viewport to use for the calculation
+ * @param labelmap Labelmap from which the mask is taken
+ * @param referenceVolume PET volume to use for SUV calculation
+ * @param toolData [Optional] list of toolData to use for SUV calculation
+ * @param segmentIndex The index of the segment to use for masking
+ * @returns
+ */
+function calculateSuvPeak({ labelmapProps, referenceVolumeProps, annotations, segmentIndex = 1 }) {
+  const labelmapInfo = createVolume(labelmapProps);
+  const referenceInfo = createVolume(referenceVolumeProps);
+
+  if (referenceInfo.metadata.Modality !== 'PT') {
+    return;
+  }
+
+  const { dimensions, imageData: labelmapImageData } = labelmapInfo;
+  const { imageData: referenceVolumeImageData } = referenceInfo;
+
+  let boundsIJK;
+  // Todo: using the first annotation for now
+  if (annotations?.length && annotations[0].data?.cachedStats) {
+    const { projectionPoints } = annotations[0].data.cachedStats;
+    const pointsToUse = [].concat(...projectionPoints); // cannot use flat() because of typescript compiler right now
+
+    const rectangleCornersIJK = pointsToUse.map(world => {
+      const ijk = vec3.fromValues(0, 0, 0);
+      referenceVolumeImageData.worldToIndex(world, ijk);
+      return ijk;
+    });
+
+    boundsIJK = cstUtils.boundingBox.getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
+  }
+
+  let max = 0;
+  let maxIJK = [0, 0, 0];
+  let maxLPS = [0, 0, 0];
+
+  const callback = ({ pointIJK, pointLPS }) => {
+    const value = labelmapInfo.voxelManager.getAtIJKPoint(pointIJK);
+
+    if (value !== segmentIndex) {
+      return;
+    }
+
+    const referenceValue = referenceInfo.voxelManager.getAtIJKPoint(pointIJK);
+
+    if (referenceValue > max) {
+      max = referenceValue;
+      maxIJK = pointIJK;
+      maxLPS = pointLPS;
+    }
+  };
+
+  labelmapInfo.voxelManager.forEach(callback, {
+    boundsIJK,
+    imageData: labelmapImageData,
+    isInObject: () => true,
+    returnPoints: true,
+  });
+
+  const direction = labelmapImageData.getDirection().slice(0, 3);
+
+  /**
+   * 2. Find the bottom and top of the great circle for the second sphere (1cc sphere)
+   * V = (4/3)πr3
+   */
+  const radius = Math.pow(1 / ((4 / 3) * Math.PI), 1 / 3) * 10;
+  const diameter = radius * 2;
+
+  const secondaryCircleWorld = vec3.create();
+  const bottomWorld = vec3.create();
+  const topWorld = vec3.create();
+  referenceVolumeImageData.indexToWorld(maxIJK, secondaryCircleWorld);
+  vec3.scaleAndAdd(bottomWorld, secondaryCircleWorld, direction, -diameter / 2);
+  vec3.scaleAndAdd(topWorld, secondaryCircleWorld, direction, diameter / 2);
+  const suvPeakCirclePoints = [bottomWorld, topWorld];
+
+  /**
+   * 3. Find the Mean and Max of the 1cc sphere centered on the suv Max of the previous
+   * sphere
+   */
+  let count = 0;
+  let acc = 0;
+  const suvPeakMeanCallback = ({ value }) => {
+    acc += value;
+    count += 1;
+  };
+
+  cstUtils.pointInSurroundingSphereCallback(
+    referenceVolumeImageData,
+    suvPeakCirclePoints,
+    suvPeakMeanCallback
+  );
+
+  const mean = acc / count;
+
+  return {
+    max,
+    maxIJK,
+    maxLPS,
+    mean,
+  };
+}
+
+function calculateTMTV(labelmapProps, segmentIndex = 1) {
+  const labelmaps = labelmapProps.map(props => createVolume(props));
+
+  const mergedLabelmap =
+    labelmaps.length === 1
+      ? labelmaps[0]
+      : cstUtils.segmentation.createMergedLabelmapForIndex(labelmaps);
+
+  const { imageData, spacing } = mergedLabelmap;
+  const values = imageData.getPointData().getScalars().getData();
+
+  // count non-zero values inside the outputData, this would
+  // consider the overlapping regions to be only counted once
+  const numVoxels = values.reduce((acc, curr) => {
+    if (curr > 0) {
+      return acc + 1;
+    }
+    return acc;
+  }, 0);
+
+  return 1e-3 * numVoxels * spacing[0] * spacing[1] * spacing[2];
+}
+
+function getTotalLesionGlycolysis({ labelmapProps, referenceVolumeProps }) {
+  const labelmaps = labelmapProps.map(props => createVolume(props));
+
+  const mergedLabelmap =
+    labelmaps.length === 1
+      ? labelmaps[0]
+      : cstUtils.segmentation.createMergedLabelmapForIndex(labelmaps);
+
+  // grabbing the first labelmap referenceVolume since it will be the same for all
+  const { spacing } = labelmaps[0];
+
+  const ptVolume = createVolume(referenceVolumeProps);
+
+  let suv = 0;
+  let totalLesionVoxelCount = 0;
+  const scalarDataLength = mergedLabelmap.voxelManager.getScalarDataLength();
+  for (let i = 0; i < scalarDataLength; i++) {
+    // if not background
+    if (mergedLabelmap.voxelManager.getAtIndex(i) !== 0) {
+      suv += ptVolume.voxelManager.getAtIndex(i);
+      totalLesionVoxelCount += 1;
+    }
+  }
+
+  // Average SUV for the merged labelmap
+  const averageSuv = suv / totalLesionVoxelCount;
+
+  // total Lesion Glycolysis [suv * ml]
+  return averageSuv * totalLesionVoxelCount * spacing[0] * spacing[1] * spacing[2] * 1e-3;
+}
+
+const obj = {
+  calculateSuvPeak,
+  calculateTMTV,
+  getTotalLesionGlycolysis,
+};
+
+expose(obj);