@cornerstonejs/tools 1.53.0 → 1.54.0

package/src/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.ts

@@ -0,0 +1,81 @@
+import {
+  Types,
+  cache,
+  eventTarget,
+  triggerEvent,
+  Enums,
+} from '@cornerstonejs/core';
+import { getWebWorkerManager } from '@cornerstonejs/core';
+import {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../../../types/LabelmapTypes';
+import { computeVolumeSegmentationFromStack } from '../../convertStackToVolumeSegmentation';
+import { WorkerTypes } from '../../../../enums';
+
+const workerManager = getWebWorkerManager();
+
+const triggerWorkerProgress = (eventTarget, progress) => {
+  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+    progress,
+    type: WorkerTypes.POLYSEG_LABELMAP_TO_SURFACE,
+  });
+};
+
+/**
+ * Converts a labelmap representation to a surface representation.
+ *
+ * @param labelmapRepresentationData - The labelmap segmentation data.
+ * @param segmentIndex - The index of the segment to convert.
+ * @param isVolume - Optional flag indicating whether the labelmap is a volume or a stack. Default is true.
+ * @returns A promise that resolves to the surface data.
+ */
+export async function convertLabelmapToSurface(
+  labelmapRepresentationData: LabelmapSegmentationData,
+  segmentIndex: number,
+  isVolume = true
+): Promise<Types.SurfaceData> {
+  let volumeId;
+  if (isVolume) {
+    volumeId = (labelmapRepresentationData as LabelmapSegmentationDataVolume)
+      .volumeId;
+  } else {
+    const { imageIdReferenceMap } =
+      labelmapRepresentationData as LabelmapSegmentationDataStack;
+    ({ volumeId } = await computeVolumeSegmentationFromStack({
+      imageIdReferenceMap,
+    }));
+  }
+
+  const volume = cache.getVolume(volumeId);
+
+  const scalarData = volume.getScalarData();
+  const { dimensions, spacing, origin, direction } = volume;
+
+  triggerWorkerProgress(eventTarget, 0);
+
+  const results = await workerManager.executeTask(
+    'polySeg',
+    'convertLabelmapToSurface',
+    {
+      scalarData,
+      dimensions,
+      spacing,
+      origin,
+      direction,
+      segmentIndex,
+    },
+    {
+      callbacks: [
+        (progress) => {
+          triggerWorkerProgress(eventTarget, progress);
+        },
+      ],
+    }
+  );
+
+  triggerWorkerProgress(eventTarget, 100);
+
+  return results;
+}

package/src/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.ts

@@ -0,0 +1,81 @@
+import { Enums, Types, geometryLoader } from '@cornerstonejs/core';
+import { getColorForSegmentIndex } from '../../config/segmentationColor';
+import {
+  findSegmentationRepresentationByUID,
+  getSegmentation,
+} from '../../segmentationState';
+import { RawSurfacesData } from './surfaceComputationStrategies';
+import { PolySegConversionOptions } from '../../../../types';
+
+/**
+ * Creates and caches surfaces from raw surface data.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param rawSurfacesData - The raw surface data.
+ * @param options - Additional options for creating and caching surfaces.
+ * @param options.segmentIndices - An array of segment indices.
+ * @param options.segmentationRepresentationUID - The UID of the segmentation representation.
+ * @returns An object containing the IDs of the created surfaces.
+ */
+export async function createAndCacheSurfacesFromRaw(
+  segmentationId: string,
+  rawSurfacesData: RawSurfacesData,
+  options: PolySegConversionOptions = {}
+) {
+  // Initialize segmentationRepresentation and toolGroupId if a representation UID is provided
+  let segmentationRepresentation: any, toolGroupId: any;
+  if (options.segmentationRepresentationUID) {
+    ({ segmentationRepresentation, toolGroupId } =
+      findSegmentationRepresentationByUID(
+        options.segmentationRepresentationUID
+      ));
+  }
+
+  const segmentation = getSegmentation(segmentationId);
+
+  const geometryIds = new Map<number, string>();
+
+  // Loop through raw surfaces data and create surfaces
+  const promises = Object.keys(rawSurfacesData).map(async (index: string) => {
+    const rawSurfaceData = rawSurfacesData[index];
+    const segmentIndex = rawSurfaceData.segmentIndex;
+
+    // Get the color either from the segmentation representation or randomly generated
+    const color = segmentationRepresentation;
+    getColorForSegmentIndex(
+      toolGroupId,
+      segmentationRepresentation.segmentationRepresentationUID,
+      segmentIndex
+    ).slice(0, 3);
+
+    if (!color) {
+      throw new Error(
+        'No color found for segment index, unable to create surface'
+      );
+    }
+
+    const closedSurface = {
+      id: `segmentation_${segmentation.segmentationId}_surface_${segmentIndex}`,
+      color,
+      frameOfReferenceUID: 'test-frameOfReferenceUID',
+      data: {
+        points: rawSurfaceData.data.points,
+        polys: rawSurfaceData.data.polys,
+      },
+    };
+
+    const geometryId = closedSurface.id;
+    geometryIds.set(segmentIndex, geometryId);
+
+    return geometryLoader.createAndCacheGeometry(geometryId, {
+      type: Enums.GeometryType.SURFACE,
+      geometryData: closedSurface as Types.PublicSurfaceData,
+    });
+  });
+
+  await Promise.all(promises);
+
+  return {
+    geometryIds,
+  };
+}

package/src/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.ts

@@ -0,0 +1,167 @@
+import type { Types } from '@cornerstonejs/core';
+import {
+  ContourSegmentationData,
+  PolySegConversionOptions,
+} from '../../../../types';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import { getSegmentation } from '../../segmentationState';
+import { convertContourToSurface } from './convertContourToSurface';
+import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
+import {
+  LabelmapSegmentationData,
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../../../types/LabelmapTypes';
+import { isVolumeSegmentation } from '../../../../tools/segmentation/strategies/utils/stackVolumeCheck';
+import { convertLabelmapToSurface } from './convertLabelmapToSurface';
+
+export type RawSurfacesData = {
+  segmentIndex: number;
+  data: Types.SurfaceData;
+}[];
+
+/**
+ * Computes surface data for a given segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Additional options for surface computation.
+ * @returns A promise that resolves to the computed surface data.
+ * @throws An error if there is no surface data available for the segmentation.
+ */
+export async function computeSurfaceData(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  let rawSurfacesData: RawSurfacesData;
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData;
+
+  try {
+    if (representationData.CONTOUR) {
+      rawSurfacesData = await computeSurfaceFromContourSegmentation(
+        segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    } else if (representationData.LABELMAP as LabelmapSegmentationData) {
+      // convert volume labelmap to surface
+      rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(
+        segmentation.segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    }
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+
+  if (!rawSurfacesData) {
+    throw new Error(
+      'Not enough data to convert to surface, currently only support converting volume labelmap to surface if available'
+    );
+  }
+
+  const surfacesData = await createAndCacheSurfacesFromRaw(
+    segmentationId,
+    rawSurfacesData,
+    options
+  );
+
+  return surfacesData;
+}
+
+async function computeSurfaceFromLabelmapSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+): Promise<RawSurfacesData> {
+  // Todo: validate valid labelmap representation
+  const segmentation = getSegmentation(segmentationId);
+
+  if (!segmentation?.representationData?.LABELMAP) {
+    console.warn('Only support surface update from labelmaps');
+    return;
+  }
+
+  const isVolume = isVolumeSegmentation(
+    segmentation.representationData.LABELMAP
+  );
+
+  const labelmapRepresentationData = segmentation.representationData.LABELMAP;
+
+  const segmentIndices =
+    options.segmentIndices || getUniqueSegmentIndices(segmentationId);
+
+  const promises = segmentIndices.map((index) => {
+    const surface = convertLabelmapToSurface(
+      labelmapRepresentationData as
+        | LabelmapSegmentationDataVolume
+        | LabelmapSegmentationDataStack,
+      index,
+      isVolume
+    );
+
+    return surface;
+  });
+
+  const surfaces = await Promise.allSettled(promises);
+  const errors = surfaces.filter((p) => p.status === 'rejected');
+
+  if (errors.length > 0) {
+    console.error(errors);
+    throw new Error('Failed to convert labelmap to surface');
+  }
+
+  const rawSurfacesData = surfaces
+    .map((surface, index) => {
+      if (surface.status === 'fulfilled') {
+        return { segmentIndex: segmentIndices[index], data: surface.value };
+      }
+    })
+    .filter(Boolean);
+
+  return rawSurfacesData;
+}
+
+/**
+ * Computes the surface from contour segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - The options for surface computation.
+ * @returns A promise that resolves to the raw surfaces data.
+ */
+async function computeSurfaceFromContourSegmentation(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+): Promise<RawSurfacesData> {
+  const segmentation = getSegmentation(segmentationId);
+
+  const contourRepresentationData = segmentation.representationData.CONTOUR;
+
+  const segmentIndices =
+    options.segmentIndices || getUniqueSegmentIndices(segmentationId);
+
+  const promises = segmentIndices.map(async (index) => {
+    const surface = await convertContourToSurface(
+      contourRepresentationData as ContourSegmentationData,
+      index
+    );
+
+    return { segmentIndex: index, data: surface };
+  });
+
+  const surfaces = await Promise.all(promises);
+
+  return surfaces;
+}
+
+export {
+  computeSurfaceFromContourSegmentation,
+  computeSurfaceFromLabelmapSegmentation,
+};

package/src/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.ts

@@ -0,0 +1,95 @@
+import { Types, cache } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import {
+  getSegmentation,
+  getSegmentationRepresentations,
+  getToolGroupIdsWithSegmentation,
+} from '../../segmentationState';
+import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
+import { ToolGroupSpecificRepresentations } from '../../../../types/SegmentationStateTypes';
+import { SegmentationRepresentations } from '../../../../enums';
+import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
+import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
+
+export async function updateSurfaceData(segmentationId) {
+  const surfacesObj = await computeSurfaceFromLabelmapSegmentation(
+    segmentationId
+  );
+
+  if (!surfacesObj) {
+    return;
+  }
+
+  const segmentation = getSegmentation(segmentationId);
+  const indices = getUniqueSegmentIndices(segmentationId);
+
+  if (!indices.length) {
+    // means all segments were removed so we need to empty out
+    // the geometry data
+    const geometryIds = segmentation.representationData.SURFACE.geometryIds;
+    geometryIds.forEach((geometryId) => {
+      const geometry = cache.getGeometry(geometryId);
+      const surface = geometry.data as Types.ISurface;
+      surface.setPoints([]);
+      surface.setPolys([]);
+    });
+
+    triggerSegmentationModified(segmentationId);
+
+    return;
+  }
+
+  const promises = surfacesObj.map(({ data, segmentIndex }) => {
+    const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
+
+    const geometry = cache.getGeometry(geometryId);
+
+    if (!geometry) {
+      // means it is a new segment getting added while we were
+      // listening to the segmentation data modified event
+      const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
+
+      return toolGroupIds.map((toolGroupId) => {
+        const segmentationRepresentations = getSegmentationRepresentations(
+          toolGroupId
+        ) as ToolGroupSpecificRepresentations;
+
+        return segmentationRepresentations.map((segmentationRepresentation) => {
+          if (
+            segmentationRepresentation.type !==
+            SegmentationRepresentations.Surface
+          ) {
+            return;
+          }
+          segmentation.representationData.SURFACE.geometryIds.set(
+            segmentIndex,
+            geometryId
+          );
+
+          return createAndCacheSurfacesFromRaw(
+            segmentationId,
+            [{ segmentIndex, data }],
+            {
+              segmentationRepresentationUID:
+                segmentationRepresentation.segmentationRepresentationUID,
+            }
+          );
+        });
+      });
+    } else if (indices.includes(segmentIndex)) {
+      // if the geometry already exists and the segmentIndex is
+      // still present, update the geometry data
+      const surface = geometry.data as Types.ISurface;
+      surface.setPoints(data.points);
+      surface.setPolys(data.polys);
+    } else {
+      const surface = geometry.data as Types.ISurface;
+      surface.setPoints([]);
+      surface.setPolys([]);
+    }
+  });
+
+  await Promise.all(promises);
+
+  triggerSegmentationModified(segmentationId);
+}

package/src/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.ts

@@ -0,0 +1,123 @@
+import { SegmentationRepresentations } from '../../../enums';
+import { validateLabelmap } from '../../../tools/displayTools/Labelmap';
+import { SegmentationRepresentationData } from '../../../types';
+import {
+  findSegmentationRepresentationByUID,
+  getSegmentation,
+} from '../segmentationState';
+
+// Map of conversion paths between source and target representations
+// You should read it as "source" -> "targets"
+const conversionPaths = new Map<
+  SegmentationRepresentations,
+  Set<SegmentationRepresentations>
+>([
+  [
+    SegmentationRepresentations.Labelmap,
+    new Set([
+      SegmentationRepresentations.Surface,
+      SegmentationRepresentations.Contour,
+    ]),
+  ],
+  [
+    SegmentationRepresentations.Contour,
+    new Set([
+      SegmentationRepresentations.Labelmap,
+      SegmentationRepresentations.Surface,
+    ]),
+  ],
+  [
+    SegmentationRepresentations.Surface,
+    new Set([SegmentationRepresentations.Labelmap]),
+  ],
+]);
+
+/**
+ * Determines whether the requested representation can be computed, based on
+ * the existing representation types and available conversion paths.
+ * This is used in the labelmapDisplay and surfaceDisplay logic if the
+ * requested representation is not available whether we can use the existing
+ * representation to compute the requested representation. You can checkout the polySeg
+ * examples to see how this is used polyDataActorManipulationTools and others
+ *
+ * @param segmentationRepresentationUID - The UID of the desired segmentation representation.
+ * @returns true if the requested representation can be computed, otherwise false.
+ */
+function canComputeRequestedRepresentation(
+  segmentationRepresentationUID: string
+): boolean {
+  const representationInfo = findSegmentationRepresentationByUID(
+    segmentationRepresentationUID
+  );
+
+  if (!representationInfo?.segmentationRepresentation) {
+    return false;
+  }
+
+  const { segmentationRepresentation } = representationInfo;
+  const { type: representationType, polySeg } = segmentationRepresentation;
+
+  if (!polySeg || !polySeg.enabled) {
+    return false;
+  }
+
+  const { representationData } = getSegmentation(
+    segmentationRepresentation.segmentationId
+  );
+
+  const existingRepresentationTypes =
+    getExistingRepresentationTypes(representationData);
+
+  return existingRepresentationTypes.some((existingRepresentationType) =>
+    canConvertFromTo(existingRepresentationType, representationType)
+  );
+}
+
+/**
+ * Retrieves the existing representation types for the given representationData
+ * by verifying the validity of each representation type.
+ *
+ * @param representationData - The representation data
+ * @returns supportedTypes - An array of valid representation types
+ */
+function getExistingRepresentationTypes(
+  representationData: SegmentationRepresentationData
+): string[] {
+  const supportedTypes: string[] = [];
+
+  Object.keys(representationData).forEach((representationType) => {
+    const representationTypeData = representationData[representationType];
+
+    let validateFn;
+    switch (representationType) {
+      case SegmentationRepresentations.Labelmap:
+        validateFn = validateLabelmap;
+        break;
+      // Todo: add validation for other representation types
+    }
+
+    if (validateFn) {
+      try {
+        validateFn(representationTypeData);
+        supportedTypes.push(representationType);
+      } catch (error) {
+        console.warn(
+          `Validation failed for labelmap of type ${representationType}`
+        );
+      }
+    } else {
+      supportedTypes.push(representationType);
+    }
+  });
+
+  return supportedTypes;
+}
+
+async function canConvertFromTo(fromRepresentationType, toRepresentationType) {
+  return (
+    conversionPaths.get(fromRepresentationType)?.has(toRepresentationType) ||
+    false
+  );
+}
+
+export { canComputeRequestedRepresentation };

package/src/stateManagement/segmentation/polySeg/computeAndAddRepresentation.ts

@@ -0,0 +1,97 @@
+import { eventTarget } from '@cornerstonejs/core';
+import { Events, SegmentationRepresentations } from '../../../enums';
+import addRepresentationData from '../addRepresentationData';
+import { triggerSegmentationModified } from '../triggerSegmentationEvents';
+import { debounce } from '../../../utilities';
+import { registerPolySegWorker } from './registerPolySegWorker';
+
+const computedRepresentations = new Map<
+  string,
+  SegmentationRepresentations[]
+>();
+
+/**
+ * Computes a representation using the provided computation function, adds the computed data,
+ * subscribes to segmentation changes, and triggers segmentation modification.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param representationType - The type of the segmentation representation.
+ * @param computeFunction - The function that computes the representation data.
+ * @param options - Additional options for computing the representation.
+ * @returns - A promise that resolves with the computed representation data.
+ */
+async function computeAndAddRepresentation<T>(
+  segmentationId: string,
+  representationType: SegmentationRepresentations,
+  computeFunction: () => Promise<T>,
+  updateFunction?: () => void
+): Promise<T> {
+  // register the worker if it hasn't been registered yet
+  registerPolySegWorker();
+
+  // Compute the specific representation data
+  const data = await computeFunction();
+
+  // Add the computed data to the system
+  addRepresentationData({
+    segmentationId,
+    type: representationType,
+    data: { ...data },
+  });
+
+  // Update internal structures and possibly UI components
+  if (!computedRepresentations.has(segmentationId)) {
+    computedRepresentations.set(segmentationId, []);
+  }
+
+  const representations = computedRepresentations.get(segmentationId);
+  if (!representations.includes(representationType)) {
+    representations.push(representationType);
+  }
+
+  // Subscribe to any changes in the segmentation data for real-time updates
+  subscribeToSegmentationChanges(updateFunction);
+
+  // Notify other system parts that segmentation data has been modified
+  triggerSegmentationModified(segmentationId);
+
+  return data;
+}
+
+/**
+ * Subscribes to segmentation changes by adding an event listener for the SEGMENTATION_DATA_MODIFIED event.
+ * If there is an existing listener, it will be unsubscribed before adding the new listener.
+ */
+function subscribeToSegmentationChanges(updateFunction) {
+  const debouncedUpdateFunction = (event) => {
+    _debouncedSegmentationModified(event, updateFunction);
+  };
+
+  updateFunction._debouncedUpdateFunction = debouncedUpdateFunction;
+
+  eventTarget.removeEventListener(
+    Events.SEGMENTATION_DATA_MODIFIED,
+    updateFunction._debouncedUpdateFunction
+  );
+
+  eventTarget.addEventListener(
+    Events.SEGMENTATION_DATA_MODIFIED,
+    updateFunction._debouncedUpdateFunction
+  );
+}
+
+const _debouncedSegmentationModified = debounce((event, updateFunction) => {
+  const segmentationId = event.detail.segmentationId;
+  const representations = computedRepresentations.get(segmentationId);
+  if (!representations || !representations.length) {
+    return;
+  }
+
+  updateFunction(segmentationId);
+
+  if (representations.length) {
+    triggerSegmentationModified(segmentationId);
+  }
+}, 300);
+
+export { computeAndAddRepresentation };

package/src/stateManagement/segmentation/polySeg/index.ts

@@ -0,0 +1,12 @@
+import { computeAndAddSurfaceRepresentation } from './Surface/computeAndAddSurfaceRepresentation';
+import { computeAndAddLabelmapRepresentation } from './Labelmap/computeAndAddLabelmapRepresentation';
+import { computeAndAddContourRepresentation } from './Contour/computeAndAddContourRepresentation';
+import { canComputeRequestedRepresentation } from './canComputeRequestedRepresentation';
+
+export {
+  canComputeRequestedRepresentation,
+  // computed representations
+  computeAndAddSurfaceRepresentation,
+  computeAndAddLabelmapRepresentation,
+  computeAndAddContourRepresentation,
+};

package/src/stateManagement/segmentation/polySeg/registerPolySegWorker.ts

@@ -0,0 +1,34 @@
+import { getWebWorkerManager } from '@cornerstonejs/core';
+
+let registered = false;
+
+export function registerPolySegWorker() {
+  if (registered) {
+    return;
+  }
+
+  registered = true;
+
+  const workerFn = () => {
+    // @ts-ignore
+    return new Worker(
+      // @ts-ignore
+      new URL('../../../workers/polySegConverters', import.meta.url),
+      {
+        name: 'polySeg',
+      }
+    );
+  };
+
+  const workerManager = getWebWorkerManager();
+
+  const options = {
+    maxWorkerInstances: 1, // Todo, make this configurable
+    autoTerminateOnIdle: {
+      enabled: true,
+      idleTimeThreshold: 2000,
+    },
+  };
+
+  workerManager.registerWorker('polySeg', workerFn, options);
+}