@cornerstonejs/tools 1.53.0 → 1.54.0

package/src/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.ts

@@ -0,0 +1,273 @@
+import { vec3 } from 'gl-matrix';
+import {
+  Types,
+  cache,
+  utilities,
+  getWebWorkerManager,
+  volumeLoader,
+  imageLoader,
+  metaData,
+  Enums,
+  triggerEvent,
+  eventTarget,
+} from '@cornerstonejs/core';
+import {
+  Annotation,
+  ContourSegmentationData,
+  PolySegConversionOptions,
+} from '../../../../types';
+import { getAnnotation } from '../../..';
+import { WorkerTypes } from '../../../../enums';
+
+const workerManager = getWebWorkerManager();
+
+const triggerWorkerProgress = (eventTarget, progress) => {
+  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+    progress,
+    type: WorkerTypes.POLYSEG_CONTOUR_TO_LABELMAP,
+  });
+};
+
+export async function convertContourToVolumeLabelmap(
+  contourRepresentationData: ContourSegmentationData,
+  options: PolySegConversionOptions = {}
+) {
+  const { viewport } = options;
+
+  const imageIds = utilities.getViewportImageIds(viewport);
+
+  if (!imageIds) {
+    throw new Error(
+      'No imageIds found, labelmap computation from contour requires viewports with imageIds'
+    );
+  }
+
+  const segmentationVolumeId = utilities.uuidv4();
+
+  const volumeProps = utilities.generateVolumePropsFromImageIds(
+    imageIds,
+    segmentationVolumeId
+  );
+
+  const { metadata, dimensions, origin, direction, spacing, scalarData } =
+    volumeProps;
+
+  const segmentationVolume = await volumeLoader.createLocalSegmentationVolume(
+    {
+      dimensions,
+      origin,
+      direction,
+      spacing,
+      metadata,
+      imageIds: imageIds.map((imageId) => `generated://${imageId}`),
+      referencedImageIds: imageIds,
+    },
+    segmentationVolumeId
+  );
+
+  const { segmentIndices, annotationUIDsInSegmentMap } =
+    _getAnnotationMapFromSegmentation(contourRepresentationData, options);
+
+  triggerWorkerProgress(eventTarget, 0);
+
+  const newScalarData = await workerManager.executeTask(
+    'polySeg',
+    'convertContourToVolumeLabelmap',
+    {
+      segmentIndices,
+      dimensions,
+      scalarData,
+      origin,
+      direction,
+      spacing,
+      annotationUIDsInSegmentMap,
+    },
+    {
+      callbacks: [
+        (progress) => {
+          triggerWorkerProgress(eventTarget, progress);
+        },
+      ],
+    }
+  );
+
+  triggerWorkerProgress(eventTarget, 100);
+
+  segmentationVolume.imageData
+    .getPointData()
+    .getScalars()
+    .setData(newScalarData);
+  segmentationVolume.imageData.modified();
+
+  // update the scalarData in the volume as well
+  segmentationVolume.modified();
+
+  return {
+    volumeId: segmentationVolume.volumeId,
+  };
+}
+
+export async function convertContourToStackLabelmap(
+  contourRepresentationData: ContourSegmentationData,
+  options: PolySegConversionOptions = {}
+) {
+  if (!options.viewport) {
+    throw new Error(
+      'No viewport provided, labelmap computation from contour requires viewports'
+    );
+  }
+
+  const viewport = options.viewport as Types.IStackViewport;
+
+  const imageIds = viewport.getImageIds();
+
+  if (!imageIds) {
+    throw new Error(
+      'No imageIds found, labelmap computation from contour requires viewports with imageIds'
+    );
+  }
+
+  // check if the imageIds are already cached
+  imageIds.forEach((imageId) => {
+    if (!cache.getImageLoadObject(imageId)) {
+      throw new Error(
+        'ImageIds must be cached before converting contour to labelmap'
+      );
+    }
+  });
+
+  // create
+  const { imageIds: segmentationImageIds } =
+    await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+
+  const { segmentIndices, annotationUIDsInSegmentMap } =
+    _getAnnotationMapFromSegmentation(contourRepresentationData, options);
+
+  // information for the referenced to the segmentation image
+  // Define constant to hold segmentation information
+  const segmentationsInfo = new Map();
+
+  // Loop through each segmentation image ID
+  segmentationImageIds.forEach((segImageId, index) => {
+    // Fetch the image from cache
+    const segImage = cache.getImage(segImageId);
+
+    // Fetch metadata for the image
+    const imagePlaneModule = metaData.get(
+      Enums.MetadataModules.IMAGE_PLANE,
+      segImageId
+    );
+
+    // Extract properties from image metadata
+    let {
+      columnCosines,
+      rowCosines,
+      rowPixelSpacing,
+      columnPixelSpacing,
+      imagePositionPatient,
+    } = imagePlaneModule;
+
+    // Set defaults if necessary
+    columnCosines = columnCosines ?? [0, 1, 0];
+    rowCosines = rowCosines ?? [1, 0, 0];
+    rowPixelSpacing = rowPixelSpacing ?? 1;
+    columnPixelSpacing = columnPixelSpacing ?? 1;
+    imagePositionPatient = imagePositionPatient ?? [0, 0, 0];
+
+    // Create vector from row and column cosines
+    const rowCosineVec = vec3.fromValues(
+      rowCosines[0],
+      rowCosines[1],
+      rowCosines[2]
+    );
+    const colCosineVec = vec3.fromValues(
+      columnCosines[0],
+      columnCosines[1],
+      columnCosines[2]
+    );
+
+    // Calculate scan axis normal
+    const scanAxisNormal = vec3.create();
+    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+
+    // Define direction and spacing
+    const direction = [...rowCosineVec, ...colCosineVec, ...scanAxisNormal];
+    const spacing = [rowPixelSpacing, columnPixelSpacing, 1];
+
+    // Set origin
+    const origin = imagePositionPatient;
+
+    // Store segmentation information
+    segmentationsInfo.set(imageIds[index], {
+      direction,
+      spacing,
+      origin,
+      scalarData: segImage.getPixelData(),
+      imageId: segImageId,
+      dimensions: [segImage.width, segImage.height, 1],
+    });
+  });
+
+  triggerWorkerProgress(eventTarget, 0);
+
+  const newSegmentationsScalarData = await workerManager.executeTask(
+    'polySeg',
+    'convertContourToStackLabelmap',
+    {
+      segmentationsInfo,
+      annotationUIDsInSegmentMap,
+      segmentIndices,
+    },
+    {
+      callbacks: [
+        (progress) => {
+          triggerWorkerProgress(eventTarget, progress);
+        },
+      ],
+    }
+  );
+
+  triggerWorkerProgress(eventTarget, 100);
+
+  const imageIdReferenceMap = new Map();
+  newSegmentationsScalarData.forEach(({ scalarData }, referencedImageId) => {
+    const segmentationInfo = segmentationsInfo.get(referencedImageId);
+    const { imageId: segImageId } = segmentationInfo;
+
+    const segImage = cache.getImage(segImageId);
+    segImage.getPixelData().set(scalarData);
+    segImage.imageFrame?.pixelData?.set(scalarData);
+
+    imageIdReferenceMap.set(referencedImageId, segImageId);
+  });
+
+  return {
+    imageIdReferenceMap,
+  };
+}
+
+function _getAnnotationMapFromSegmentation(
+  contourRepresentationData: ContourSegmentationData,
+  options: PolySegConversionOptions = {}
+) {
+  const annotationMap = contourRepresentationData.annotationUIDsMap;
+
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : Array.from(annotationMap.keys());
+
+  const annotationUIDsInSegmentMap = new Map<number, Annotation[]>();
+  segmentIndices.forEach((index) => {
+    const annotationUIDsInSegment = annotationMap.get(index);
+
+    const annotations = Array.from(annotationUIDsInSegment).map((uid) => {
+      const annotation = getAnnotation(uid);
+
+      return annotation;
+    });
+
+    annotationUIDsInSegmentMap.set(index, annotations);
+  });
+
+  return { segmentIndices, annotationUIDsInSegmentMap };
+}

package/src/stateManagement/segmentation/polySeg/Labelmap/convertSurfaceToLabelmap.ts

@@ -0,0 +1,89 @@
+import {
+  Enums,
+  Types,
+  cache,
+  eventTarget,
+  getWebWorkerManager,
+  triggerEvent,
+} from '@cornerstonejs/core';
+import { SurfaceSegmentationData } from '../../../../types/SurfaceTypes';
+import { WorkerTypes } from '../../../../enums';
+
+const workerManager = getWebWorkerManager();
+
+const triggerWorkerProgress = (eventTarget, progress) => {
+  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+    progress,
+    type: WorkerTypes.POLYSEG_SURFACE_TO_LABELMAP,
+  });
+};
+
+export async function convertSurfaceToVolumeLabelmap(
+  surfaceRepresentationData: SurfaceSegmentationData,
+  segmentationVolume: Types.IImageVolume
+) {
+  const { geometryIds } = surfaceRepresentationData;
+  if (!geometryIds?.size) {
+    throw new Error('No geometry IDs found for surface representation');
+  }
+
+  const segmentsInfo = new Map() as Map<
+    number,
+    {
+      points: number[];
+      polys: number[];
+    }
+  >;
+
+  geometryIds.forEach((geometryId, segmentIndex) => {
+    const geometry = cache.getGeometry(geometryId);
+    const geometryData = geometry.data as Types.ISurface;
+    const points = geometryData.getPoints();
+    const polys = geometryData.getPolys();
+
+    segmentsInfo.set(segmentIndex, {
+      points,
+      polys,
+    });
+  });
+
+  const { dimensions, direction, origin, spacing } = segmentationVolume;
+
+  triggerWorkerProgress(eventTarget, 0);
+
+  const newScalarData = await workerManager.executeTask(
+    'polySeg',
+    'convertSurfacesToVolumeLabelmap',
+    {
+      segmentsInfo,
+      dimensions,
+      spacing,
+      direction,
+      origin,
+    },
+    {
+      callbacks: [
+        (progress) => {
+          triggerWorkerProgress(eventTarget, progress);
+        },
+      ],
+    }
+  );
+
+  triggerWorkerProgress(eventTarget, 100);
+
+  segmentationVolume.imageData
+    .getPointData()
+    .getScalars()
+    .setData(newScalarData);
+  segmentationVolume.imageData.modified();
+
+  // update the scalarData in the volume as well
+  segmentationVolume.modified();
+
+  return {
+    volumeId: segmentationVolume.volumeId,
+  };
+}
+
+export async function convertSurfaceToStackLabelmap() {}

package/src/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.ts

@@ -0,0 +1,193 @@
+import {
+  Types,
+  VolumeViewport,
+  volumeLoader,
+  utilities,
+} from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import { getSegmentation } from '../../segmentationState';
+import {
+  LabelmapSegmentationDataStack,
+  LabelmapSegmentationDataVolume,
+} from '../../../../types/LabelmapTypes';
+import {
+  convertContourToStackLabelmap,
+  convertContourToVolumeLabelmap,
+} from './convertContourToLabelmap';
+import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
+import { computeStackSegmentationFromVolume } from '../../convertVolumeToStackSegmentation';
+import { PixelDataTypedArray } from '@cornerstonejs/core/dist/types/types';
+import { PolySegConversionOptions } from '../../../../types';
+
+export type RawLabelmapData =
+  | LabelmapSegmentationDataVolume
+  | LabelmapSegmentationDataStack;
+
+export async function computeLabelmapData(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  let rawLabelmapData: RawLabelmapData;
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData;
+
+  try {
+    if (representationData.CONTOUR) {
+      rawLabelmapData = await computeLabelmapFromContourSegmentation(
+        segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    } else if (representationData.SURFACE) {
+      rawLabelmapData = await computeLabelmapFromSurfaceSegmentation(
+        segmentation.segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    }
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+
+  if (!rawLabelmapData) {
+    throw new Error(
+      'Not enough data to convert to surface, currently only support converting volume labelmap to surface if available'
+    );
+  }
+
+  return rawLabelmapData;
+}
+
+async function computeLabelmapFromContourSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+): Promise<LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack> {
+  const isVolume = options.viewport instanceof VolumeViewport ?? true;
+
+  if (isVolume && !options.viewport) {
+    // Todo: we don't have support for volume viewport without providing the
+    // viewport, since we need to get the referenced volumeId from the viewport
+    // but we can alternatively provide the volumeId directly, or even better
+    // the target metadata for the volume (spacing, origin, dimensions, etc.)
+    // and then we can create the volume from that
+    throw new Error(
+      'Cannot compute labelmap from contour segmentation without providing the viewport'
+    );
+  }
+
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData.CONTOUR;
+
+  let result;
+
+  if (isVolume) {
+    result = await convertContourToVolumeLabelmap(representationData, {
+      segmentIndices,
+      segmentationRepresentationUID: options.segmentationRepresentationUID,
+      viewport: options.viewport,
+    });
+  } else {
+    result = await convertContourToStackLabelmap(representationData, {
+      segmentIndices,
+      segmentationRepresentationUID: options.segmentationRepresentationUID,
+      viewport: options.viewport,
+    });
+  }
+
+  return result;
+}
+
+async function computeLabelmapFromSurfaceSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+): Promise<LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack> {
+  const isVolume = options.viewport instanceof VolumeViewport ?? true;
+
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  const segmentation = getSegmentation(segmentationId);
+
+  const segmentsGeometryIds = new Map() as Map<number, string>;
+  const representationData = segmentation.representationData.SURFACE;
+  representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+    if (segmentIndices.includes(segmentIndex)) {
+      segmentsGeometryIds.set(segmentIndex, geometryId);
+    }
+  });
+
+  if (isVolume && !options.viewport) {
+    // Todo: we don't have support for volume viewport without providing the
+    // viewport, since we need to get the referenced volumeId from the viewport
+    // but we can alternatively provide the volumeId directly, or even better
+    // the target metadata for the volume (spacing, origin, dimensions, etc.)
+    // and then we can create the volume from that
+    throw new Error(
+      'Cannot compute labelmap from surface segmentation without providing the viewport'
+    );
+  }
+
+  let segmentationVolume;
+  if (isVolume) {
+    const defaultActor = options.viewport.getDefaultActor();
+    const { uid: volumeId } = defaultActor;
+    segmentationVolume =
+      await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId);
+  } else {
+    // for stack we basically need to create a volume from the stack
+    // imageIds and then create a segmentation volume from that and finally
+    // convert the surface to a labelmap and later on convert the labelmap
+    // to a stack labelmap
+    const imageIds = (options.viewport as Types.IStackViewport).getImageIds();
+    const volumeId = 'generatedSegmentationVolumeId';
+    const volumeProps = utilities.generateVolumePropsFromImageIds(
+      imageIds,
+      volumeId
+    );
+
+    // we don't need the imageIds for the viewport (e.g., CT), but rather
+    // want to use the imageIds as a reference
+    delete volumeProps.imageIds;
+
+    segmentationVolume = await volumeLoader.createLocalSegmentationVolume(
+      {
+        ...volumeProps,
+        scalarData: volumeProps.scalarData as PixelDataTypedArray,
+        referencedImageIds: imageIds,
+      },
+      volumeId
+    );
+  }
+
+  const result = await convertSurfaceToVolumeLabelmap(
+    { geometryIds: segmentsGeometryIds },
+    segmentationVolume
+  );
+
+  if (isVolume) {
+    return result;
+  }
+
+  // we need to convert the volume labelmap to a stack labelmap
+  const stackData = (await computeStackSegmentationFromVolume({
+    volumeId: segmentationVolume.volumeId,
+  })) as LabelmapSegmentationDataStack;
+
+  return stackData;
+}
+
+export { computeLabelmapFromContourSegmentation };

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

@@ -0,0 +1,26 @@
+import { SegmentationRepresentations } from '../../../../enums';
+import { PolySegConversionOptions } from '../../../../types';
+import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
+import { computeSurfaceData } from './surfaceComputationStrategies';
+import { updateSurfaceData } from './updateSurfaceData';
+
+/**
+ * Computes and adds a surface representation for a given segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Additional options for computing the surface representation.
+ * @param options.segmentIndices - The indices of the segments to compute the surface for.
+ * @param options.segmentationRepresentationUID - The UID of the segmentation representation to compute the surface for.
+ *
+ * @returns A promise that resolves when the surface representation is computed and added.
+ */
+export function computeAndAddSurfaceRepresentation(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  return computeAndAddRepresentation(
+    segmentationId,
+    SegmentationRepresentations.Surface,
+    () => computeSurfaceData(segmentationId, options),
+    () => updateSurfaceData(segmentationId)
+  );
+}

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

@@ -0,0 +1,62 @@
+import { Enums, Types, eventTarget, triggerEvent } from '@cornerstonejs/core';
+import { getWebWorkerManager } from '@cornerstonejs/core';
+import { ContourSegmentationData } from '../../../../types';
+import { getAnnotation } from '../../../annotation/annotationState';
+import { WorkerTypes } from '../../../../enums';
+
+const workerManager = getWebWorkerManager();
+
+const triggerWorkerProgress = (eventTarget, progress) => {
+  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
+    progress,
+    type: WorkerTypes.POLYSEG_CONTOUR_TO_SURFACE,
+  });
+};
+
+/**
+ * Converts a contour representation to a surface representation.
+ *
+ * @param contourRepresentationData - The contour segmentation data.
+ * @param segmentIndex - The index of the segment to convert.
+ * @returns A promise that resolves to the surface data.
+ */
+export async function convertContourToSurface(
+  contourRepresentationData: ContourSegmentationData,
+  segmentIndex: number
+): Promise<Types.SurfaceData> {
+  const { annotationUIDsMap } = contourRepresentationData;
+
+  // loop over all annotations in the segment and flatten their polylines
+  const polylines = [];
+  const numPointsArray = [];
+  const annotationUIDs = annotationUIDsMap.get(segmentIndex);
+
+  for (const annotationUID of annotationUIDs) {
+    const annotation = getAnnotation(annotationUID);
+    const { polyline } = annotation.data.contour;
+    numPointsArray.push(polyline.length);
+    polyline.forEach((polyline) => polylines.push(...polyline));
+  }
+
+  triggerWorkerProgress(eventTarget, 0);
+
+  const results = await workerManager.executeTask(
+    'polySeg',
+    'convertContourToSurface',
+    {
+      polylines,
+      numPointsArray,
+    },
+    {
+      callbacks: [
+        (progress) => {
+          triggerWorkerProgress(eventTarget, progress);
+        },
+      ],
+    }
+  );
+
+  triggerWorkerProgress(eventTarget, 100);
+
+  return results;
+}