@cornerstonejs/tools 2.0.0-beta.6 → 2.0.0-beta.7

package/src/stateManagement/segmentation/helpers/normalizeSegmentationInput.ts

@@ -1,7 +1,9 @@
+import { SegmentationRepresentations } from '../../../enums';
 import {
   SegmentationPublicInput,
   Segmentation,
 } from '../../../types/SegmentationStateTypes';
+import type { ContourSegmentationData } from '../../../types/ContourTypes';
 
 /**
  * It takes in a segmentation input and returns a segmentation with default values
@@ -13,6 +15,30 @@ function normalizeSegmentationInput(
   segmentationInput: SegmentationPublicInput
 ): Segmentation {
   const { segmentationId, representation } = segmentationInput;
+  const isContourRepresentation =
+    representation.type === SegmentationRepresentations.Contour;
+  let data = representation.data ? { ...representation.data } : null;
+
+  // Contour representation data is defined internally
+  data = !data && isContourRepresentation ? {} : data;
+
+  // Data cannot be undefined for labelmap and surface
+  if (!data) {
+    throw new Error('Segmentation representation data may not be undefined');
+  }
+
+  if (isContourRepresentation) {
+    const contourData = <ContourSegmentationData>data;
+
+    // geometryIds will be removed in a near future. It still exist in the
+    // code for compatibility only but it is optional from now on.
+    contourData.geometryIds = contourData.geometryIds ?? [];
+
+    // Make sure annotationUIDsMap is defined because an empty contour is
+    // created before adding contour annotations to the map. Also it prevents
+    // breaking legacy code after moving from geometryIds to annotationUIDsMap.
+    contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
+  }
 
   // Todo: we should be able to let the user pass in non-default values for
   // cachedStats, label, activeSegmentIndex, etc.
@@ -26,7 +52,7 @@ function normalizeSegmentationInput(
     activeSegmentIndex: 1,
     representationData: {
       [representation.type]: {
-        ...representation.data,
+        ...data,
       },
     },
   };

package/src/stateManagement/segmentation/helpers/validateSegmentationInput.ts

@@ -1,31 +1,36 @@
 import * as Enums from '../../../enums';
 import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
-import validateLabelmap from '../../../tools/displayTools/Labelmap/validateRepresentationData';
+import { validatePublic as validatePublicLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 
 /**
- * Checks if the segmentationInputArray is valid meaning it contains
- * correct representationProps for the representation type that is being used.
+ * Validates the given segmentationInputArray to ensure it contains
+ * appropriate representationProps for the representation type being used.
  *
  * @param segmentationInputArray - Array of segmentation inputs
+ * @throws If the segmentationInputArray is undefined or empty
+ * @throws If the segmentationInput.segmentationId is undefined
+ * @throws If the segmentationInput.representation is undefined
  * @internal
  */
 function validateSegmentationInput(
   segmentationInputArray: SegmentationPublicInput[]
 ): void {
-  if (!segmentationInputArray || !segmentationInputArray.length) {
-    throw new Error('The segmentationInputArray is undefined or empty array');
+  if (!segmentationInputArray || segmentationInputArray.length === 0) {
+    throw new Error(
+      'The segmentationInputArray is undefined or an empty array'
+    );
   }
 
   segmentationInputArray.forEach((segmentationInput) => {
     if (segmentationInput.segmentationId === undefined) {
       throw new Error(
-        'The segmentationInput.segmentationId is undefined, please provide a valid segmentationId'
+        'Undefined segmentationInput.segmentationId. Please provide a valid segmentationId'
       );
     }
 
     if (segmentationInput.representation === undefined) {
       throw new Error(
-        'The segmentationInput.representation is undefined, please provide a valid representation'
+        'Undefined segmentationInput.representation. Please provide a valid representation'
       );
     }
 
@@ -33,7 +38,7 @@ function validateSegmentationInput(
       segmentationInput.representation.type ===
       Enums.SegmentationRepresentations.Labelmap
     ) {
-      validateLabelmap(segmentationInput);
+      validatePublicLabelmap(segmentationInput);
     }
   });
 }

package/src/stateManagement/segmentation/index.ts

@@ -1,6 +1,10 @@
 import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
 import addSegmentations from './addSegmentations';
 import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentationData from './addRepresentationData';
+import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
+import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
+// import { polySegManager } from './polySegManager';
 
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -8,15 +12,22 @@ import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import * as polySegManager from './polySeg';
 
 export {
-  state,
+  // functions
   addSegmentations,
-  activeSegmentation,
   addSegmentationRepresentations,
   removeSegmentationsFromToolGroup,
+  addRepresentationData,
+  // name spaces
+  state,
+  activeSegmentation,
   segmentLocking,
   config,
   segmentIndex,
   triggerSegmentationEvents,
+  convertStackToVolumeSegmentation,
+  convertVolumeToStackSegmentation,
+  polySegManager as polySeg,
 };

package/src/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.ts

@@ -0,0 +1,24 @@
+import { SegmentationRepresentations } from '../../../../enums';
+import { PolySegConversionOptions } from '../../../../types';
+import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
+import { computeContourData } from './contourComputationStrategies';
+/**
+ * Computes and adds the contour representation for a given segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Optional parameters for computing the labelmap representation.
+ * @param options.segmentIndices - An array of segment indices to include in the labelmap representation.
+ * @param options.segmentationRepresentationUID - The UID of the segmentation representation.
+ * @returns A promise that resolves when the labelmap representation is computed and added.
+ */
+export function computeAndAddContourRepresentation(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  return computeAndAddRepresentation(
+    segmentationId,
+    SegmentationRepresentations.Contour,
+    () => computeContourData(segmentationId, options),
+    () => undefined
+  );
+}

package/src/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.ts

@@ -0,0 +1,201 @@
+import { cache } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
+import {
+  getSegmentation,
+  setSegmentationRepresentationSpecificConfig,
+} from '../../segmentationState';
+import { PolySegConversionOptions } from '../../../../types';
+import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
+import {
+  SurfaceClipResult,
+  clipAndCacheSurfacesForViewport,
+} from '../../helpers/clipAndCacheSurfacesForViewport';
+import { extractContourData } from './utils/extractContourData';
+import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
+import { getToolGroupForViewport } from '../../../../store/ToolGroupManager';
+
+// the map between segment index and the intersection points and lines
+export type RawContourData = Map<number, SurfaceClipResult[]>;
+
+/**
+ * Computes contour data for a given segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Optional parameters for the computation.
+ * @returns An object containing the annotation UIDs map.
+ * @throws Error if there is not enough data to convert to contour.
+ */
+export async function computeContourData(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  let rawContourData: RawContourData;
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData;
+
+  try {
+    if (representationData.SURFACE) {
+      rawContourData = await computeContourFromSurfaceSegmentation(
+        segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    } else if (representationData.LABELMAP) {
+      rawContourData = await computeContourFromLabelmapSegmentation(
+        segmentationId,
+        {
+          segmentIndices,
+          ...options,
+        }
+      );
+    }
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+
+  if (!rawContourData) {
+    throw new Error(
+      'Not enough data to convert to contour, currently only support converting volume labelmap to contour if available'
+    );
+  }
+
+  const { viewport, segmentationRepresentationUID } = options;
+
+  // create the new annotations and add them to the segmentation state representation
+  // data for the contour representation
+  const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(
+    rawContourData,
+    viewport,
+    segmentationId
+  );
+
+  // make the segmentation configuration fillAlpha 0 since
+  // we don't have proper hole support right now
+  // Todo: add hole support
+  const toolGroupId = getToolGroupForViewport(viewport.id)?.id;
+
+  setSegmentationRepresentationSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    {
+      CONTOUR: {
+        fillAlpha: 0,
+      },
+    }
+  );
+
+  return {
+    annotationUIDsMap,
+  };
+}
+
+/**
+ * Computes the contour from a labelmap segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - The options for the contour computation.
+ * @returns The raw contour data.
+ */
+async function computeContourFromLabelmapSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+) {
+  if (!options.viewport) {
+    throw new Error('Viewport is required to compute contour from labelmap');
+  }
+
+  const results = await computeSurfaceFromLabelmapSegmentation(
+    segmentationId,
+    options
+  );
+
+  if (!results?.length) {
+    console.error('Failed to convert labelmap to surface or labelmap is empty');
+    return;
+  }
+
+  const { viewport, segmentationRepresentationUID } = options;
+
+  const pointsAndPolys = results.map((surface) => {
+    return {
+      id: surface.segmentIndex.toString(),
+      points: surface.data.points,
+      polys: surface.data.polys,
+      segmentIndex: surface.segmentIndex,
+    };
+  });
+
+  const polyDataCache = await clipAndCacheSurfacesForViewport(
+    pointsAndPolys,
+    viewport as Types.IVolumeViewport,
+    segmentationRepresentationUID
+  );
+
+  const rawResults = extractContourData(polyDataCache);
+
+  return rawResults;
+}
+
+/**
+ * Computes the contour from a surface segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - The options for the contour computation.
+ * @returns A promise that resolves to the raw contour data.
+ * @throws An error if the viewport is not provided.
+ */
+async function computeContourFromSurfaceSegmentation(
+  segmentationId,
+  options: PolySegConversionOptions = {}
+): Promise<RawContourData> {
+  if (!options.viewport) {
+    throw new Error('Viewport is required to compute contour from surface');
+  }
+  const { viewport, segmentationRepresentationUID } = options;
+
+  const segmentIndices = options.segmentIndices?.length
+    ? options.segmentIndices
+    : getUniqueSegmentIndices(segmentationId);
+
+  const segmentIndexToSurfaceId = new Map() as Map<number, string>;
+  const surfaceIdToSegmentIndex = new Map() as Map<string, number>;
+
+  const segmentation = getSegmentation(segmentationId);
+  const representationData = segmentation.representationData.SURFACE;
+
+  const surfacesInfo = [];
+  representationData.geometryIds.forEach((geometryId, segmentIndex) => {
+    if (segmentIndices.includes(segmentIndex)) {
+      segmentIndexToSurfaceId.set(segmentIndex, geometryId);
+      const surface = cache.getGeometry(geometryId)?.data as Types.ISurface;
+      if (surface) {
+        surfacesInfo.push({
+          id: geometryId,
+          points: surface.getPoints(),
+          polys: surface.getPolys(),
+        });
+      }
+    }
+  });
+
+  segmentIndexToSurfaceId.forEach((surfaceId, segmentIndex) => {
+    surfaceIdToSegmentIndex.set(surfaceId, segmentIndex);
+  });
+
+  const polyDataCache = await clipAndCacheSurfacesForViewport(
+    surfacesInfo,
+    viewport as Types.IVolumeViewport,
+    segmentationRepresentationUID
+  );
+
+  const rawResults = extractContourData(polyDataCache, surfaceIdToSegmentIndex);
+
+  return rawResults;
+}
+
+export { computeContourFromLabelmapSegmentation };

package/src/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.ts

@@ -0,0 +1,103 @@
+import { PlanarFreehandContourSegmentationTool } from '../../../../../tools';
+import { addAnnotation } from '../../../../annotation/annotationState';
+import { RawContourData } from '../contourComputationStrategies';
+import { utilities, type Types } from '@cornerstonejs/core';
+
+/**
+ * Creates and adds contour segmentations from a clipped surface.
+ *
+ * @param rawContourData - The raw contour data.
+ * @param viewport - The viewport.
+ * @param segmentationId - The segmentation ID.
+ */
+export function createAndAddContourSegmentationsFromClippedSurfaces(
+  rawContourData: RawContourData,
+  viewport: Types.IViewport,
+  segmentationId: string
+) {
+  const annotationUIDsMap = new Map<number, Set<string>>();
+
+  for (const [segmentIndex, contoursData] of rawContourData) {
+    for (const contourData of contoursData) {
+      const { points } = contourData;
+
+      const { lineSegments, linesNumberOfPoints } =
+        _extractLineSegments(contourData);
+
+      // There may be a few lines as the surface might not be closed and could have holes in it.
+      // Currently, we simply render the generated contour as empty fill to indicate
+      // the presence of holes. However, filling the proper area with
+      //  fillAlpha requires further work.
+      for (let i = 0; i < lineSegments.length; i++) {
+        const line = lineSegments[i];
+        const polyline = [];
+
+        for (let j = 0; j < linesNumberOfPoints[i]; j++) {
+          const pointIndex = line[j];
+          polyline.push([
+            points[3 * pointIndex],
+            points[3 * pointIndex + 1],
+            points[3 * pointIndex + 2],
+          ]);
+        }
+
+        if (polyline.length < 3) {
+          continue;
+        }
+
+        const contourSegmentationAnnotation = {
+          annotationUID: utilities.uuidv4(),
+          data: {
+            contour: {
+              closed: true,
+              polyline,
+            },
+            segmentation: {
+              segmentationId,
+              segmentIndex,
+            },
+            handles: {},
+          },
+          handles: {},
+          highlighted: false,
+          autoGenerated: false,
+          invalidated: false,
+          isLocked: false,
+          isVisible: true,
+          metadata: {
+            toolName: PlanarFreehandContourSegmentationTool.toolName,
+            ...viewport.getViewReference(),
+          },
+        };
+
+        addAnnotation(contourSegmentationAnnotation, viewport.element);
+
+        const currentSet = annotationUIDsMap.get(segmentIndex) || new Set();
+        currentSet.add(contourSegmentationAnnotation.annotationUID);
+        annotationUIDsMap.set(segmentIndex, currentSet);
+      }
+    }
+  }
+
+  return annotationUIDsMap;
+}
+
+const _extractLineSegments = (contourData) => {
+  const { numberOfCells, lines } = contourData;
+
+  const lineSegments = [];
+  const linesNumberOfPoints = [];
+
+  for (let i = 0; i < lines.length; ) {
+    const pointsInLine = lines[i];
+    linesNumberOfPoints.push(pointsInLine);
+    lineSegments.push(lines.slice(i + 1, i + pointsInLine + 1));
+    i += pointsInLine + 1;
+
+    if (lineSegments.length === numberOfCells) {
+      break;
+    }
+  }
+
+  return { lineSegments, linesNumberOfPoints };
+};

package/src/stateManagement/segmentation/polySeg/Contour/utils/extractContourData.ts

@@ -0,0 +1,38 @@
+import { PolyDataClipCacheType } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import { RawContourData } from '../contourComputationStrategies';
+
+/**
+ * Extracts contour data from the given polyDataCache.
+ * @param polyDataCache - The polyData cache containing intersection information.
+ * @param segmentIndexMap - Optional map for mapping surface IDs to segment indices.
+ * @returns A map of segment indices to an array of contour results.
+ */
+export function extractContourData(
+  polyDataCache: PolyDataClipCacheType,
+  segmentIndexMap?: Map<string, number>
+) {
+  const rawResults = new Map() as RawContourData;
+
+  for (const [cacheId, intersectionInfo] of polyDataCache) {
+    // Todo; fix this
+    const surfaceId = cacheId.split('_')[1];
+
+    for (const [_, result] of intersectionInfo) {
+      if (!result) {
+        continue;
+      }
+      const segmentIndex = Number(surfaceId) || segmentIndexMap?.get(surfaceId);
+
+      if (!segmentIndex) {
+        continue;
+      }
+
+      if (!rawResults.has(segmentIndex)) {
+        rawResults.set(segmentIndex, []);
+      }
+
+      rawResults.get(segmentIndex).push(result);
+    }
+  }
+  return rawResults;
+}

package/src/stateManagement/segmentation/polySeg/Contour/utils/updateContoursOnCameraModified.ts

@@ -0,0 +1,58 @@
+import { utilities, type Types, Enums } from '@cornerstonejs/core';
+import { extractContourData } from './extractContourData';
+import { clipAndCacheSurfacesForViewport } from '../../../helpers/clipAndCacheSurfacesForViewport';
+import { createAndAddContourSegmentationsFromClippedSurfaces } from './createAndAddContourSegmentationsFromClippedSurfaces';
+
+const currentViewportNormal = new Map();
+
+export function updateContoursOnCameraModified(
+  surfacesInfo,
+  viewport,
+  segmentationRepresentationUID
+) {
+  async function cameraModifiedCallback(
+    evt: Types.EventTypes.CameraModifiedEvent
+  ) {
+    const { camera } = evt.detail;
+    const { viewPlaneNormal } = camera;
+
+    // Note: I think choosing one of the surfaces to see
+    // if the viewPlaneNormal is the same for all surfaces is ok enough
+    // to decide if we should recompute the clipping planes
+    const surface1 = surfacesInfo[0];
+
+    const currentNormal = currentViewportNormal.get(surface1.id);
+    if (utilities.isEqual(viewPlaneNormal, currentNormal)) {
+      return;
+    }
+    currentViewportNormal.set(surface1.id, viewPlaneNormal);
+
+    const polyDataCache = await clipAndCacheSurfacesForViewport(
+      surfacesInfo,
+      viewport as Types.IVolumeViewport,
+      segmentationRepresentationUID
+    );
+
+    const results = extractContourData(polyDataCache);
+
+    createAndAddContourSegmentationsFromClippedSurfaces(
+      results,
+      viewport,
+      segmentationRepresentationUID
+    );
+
+    viewport.render();
+  }
+
+  const camera = viewport.getCamera();
+  currentViewportNormal.set(surfacesInfo[0].id, camera.viewPlaneNormal);
+
+  // Remove the existing event listener
+  viewport.element.removeEventListener(
+    Enums.Events.CAMERA_MODIFIED,
+    cameraModifiedCallback
+  );
+
+  // Add the event listener
+  viewport.element.addEventListener(Enums.Events.CAMERA_MODIFIED);
+}

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

@@ -0,0 +1,25 @@
+import { SegmentationRepresentations } from '../../../../enums';
+import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
+import { computeLabelmapData } from './labelmapComputationStrategies';
+import { PolySegConversionOptions } from '../../../../types';
+
+/**
+ * Computes and adds the labelmap representation for a given segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Optional parameters for computing the labelmap representation.
+ * @param options.segmentIndices - An array of segment indices to include in the labelmap representation.
+ * @param options.segmentationRepresentationUID - The UID of the segmentation representation.
+ * @returns A promise that resolves when the labelmap representation is computed and added.
+ */
+export function computeAndAddLabelmapRepresentation(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  return computeAndAddRepresentation(
+    segmentationId,
+    SegmentationRepresentations.Labelmap,
+    () => computeLabelmapData(segmentationId, options),
+    () => undefined
+  );
+}