@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

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

@@ -1,203 +0,0 @@
-import {
-  Types,
-  Enums,
-  getWebWorkerManager,
-  eventTarget,
-  triggerEvent,
-} from '@cornerstonejs/core';
-
-import { WorkerTypes } from '../../../enums';
-import { pointToString } from '../../../utilities';
-import { registerPolySegWorker } from '../polySeg/registerPolySegWorker';
-const workerManager = getWebWorkerManager();
-
-/**
- * Surfaces info for clipping
- */
-export type SurfacesInfo = {
-  id: string;
-  points: number[];
-  polys: number[];
-  segmentIndex: number;
-};
-
-/**
- * The result of the surface clipping
- */
-export type SurfaceClipResult = {
-  points: number[];
-  lines: number[];
-  numberOfCells: number;
-};
-
-export type PolyDataClipCacheType = Map<string, Map<string, SurfaceClipResult>>;
-
-/**
- * a cache from actorUID to cacheId to SurfaceClipResult
- * Map<actorUID, Map<cacheId, SurfaceClipResult>>
- * cacheId is slice specific (viewPlaneNormal, sliceIndex)
- */
-const polyDataCache = new Map() as PolyDataClipCacheType;
-const surfacesAABBCache = new Map();
-
-const triggerWorkerProgress = (eventTarget, progress) => {
-  triggerEvent(eventTarget, Enums.Events.WEB_WORKER_PROGRESS, {
-    progress,
-    type: WorkerTypes.SURFACE_CLIPPING,
-  });
-};
-
-/**
- * Clips and caches surfaces for a specific viewport.
- *
- * @param surfacesInfo - An array of surfaces information.
- * @param viewport - The volume viewport.
- * @param segmentationRepresentationUID - The UID of the segmentation representation.
- * @returns The cached polydata.
- */
-export async function clipAndCacheSurfacesForViewport(
-  surfacesInfo: SurfacesInfo[],
-  viewport: Types.IVolumeViewport,
-  segmentationRepresentationUID: string
-) {
-  registerPolySegWorker();
-  // All planes is an array of planes pairs for each slice, so we should loop over them and
-  // add the planes to the clipping filter and cache the results for that slice
-
-  // Fix these ts ignores
-  // @ts-ignore
-  const planesInfo = viewport.getSlicesClippingPlanes?.();
-
-  if (!planesInfo) {
-    // this means it is probably the stack viewport not being ready
-    // in terms of planes which we should wait for the first render to
-    // get the planes
-    return;
-  }
-
-  // @ts-ignore
-  const currentSliceIndex = viewport.getSliceIndex();
-
-  // Reorder planesInfo based on proximity to currentSliceIndex
-  planesInfo.sort((a, b) => {
-    const diffA = Math.abs(a.sliceIndex - currentSliceIndex);
-    const diffB = Math.abs(b.sliceIndex - currentSliceIndex);
-    return diffA - diffB;
-  });
-
-  triggerWorkerProgress(eventTarget, 0);
-
-  // check which surfaces don't have a cached AABB
-  // make a list of the surfaces that don't have a cached AABB
-  await updateSurfacesAABBCache(surfacesInfo);
-
-  const surfacesAABB = new Map();
-  surfacesInfo.forEach((surface) => {
-    surfacesAABB.set(surface.id, surfacesAABBCache.get(surface.id));
-  });
-
-  const camera = viewport.getCamera();
-
-  await workerManager
-    .executeTask(
-      'polySeg',
-      'cutSurfacesIntoPlanes',
-      {
-        surfacesInfo,
-        planesInfo,
-        surfacesAABB,
-      },
-      {
-        callbacks: [
-          // progress callback
-          ({ progress }) => {
-            triggerWorkerProgress(eventTarget, progress);
-          },
-          // update cache callback
-          ({ sliceIndex, polyDataResults }) => {
-            polyDataResults.forEach((polyDataResult, surfaceId) => {
-              const actorUID = `${segmentationRepresentationUID}_${surfaceId}`;
-              const cacheId = generateCacheId(
-                viewport,
-                camera.viewPlaneNormal,
-                sliceIndex
-              );
-              updatePolyDataCache(actorUID, cacheId, polyDataResult);
-            });
-          },
-        ],
-      }
-    )
-    .catch((error) => {
-      console.error(error);
-    });
-
-  triggerWorkerProgress(eventTarget, 1);
-
-  return polyDataCache;
-}
-
-/**
- * Updates the surfaces AABB cache with the AABB information for the given surfaces.
- * If the AABB information for a surface already exists in the cache, it will not be updated.
- * @param surfacesInfo - An array of surfaces information.
- * @returns A Promise that resolves when the surfaces AABB cache has been updated.
- */
-async function updateSurfacesAABBCache(surfacesInfo: SurfacesInfo[]) {
-  const surfacesWithoutAABB = surfacesInfo.filter(
-    (surface) => !surfacesAABBCache.has(surface.id)
-  );
-
-  if (!surfacesWithoutAABB.length) {
-    return;
-  }
-
-  const surfacesAABB = await workerManager.executeTask(
-    'polySeg',
-    'getSurfacesAABBs',
-    {
-      surfacesInfo: surfacesWithoutAABB,
-    },
-    {
-      callbacks: [
-        // progress callback
-        ({ progress }) => {
-          triggerWorkerProgress(eventTarget, progress);
-        },
-      ],
-    }
-  );
-
-  // update the surfacesAABBCache with the new surfacesAABB
-  surfacesAABB.forEach((aabb, id) => {
-    surfacesAABBCache.set(id, aabb);
-  });
-}
-
-export function getSurfaceActorUID(
-  segmentationRepresentationUID: string,
-  surfaceId: string
-) {
-  return `${segmentationRepresentationUID}_${surfaceId}`;
-}
-
-// Helper function to generate a cache ID
-export function generateCacheId(viewport, viewPlaneNormal, sliceIndex) {
-  return `${viewport.id}-${pointToString(viewPlaneNormal)}-${sliceIndex}`;
-}
-
-// Helper function to update PolyData cache
-export function updatePolyDataCache(
-  actorUID: string,
-  cacheId: string,
-  polyDataResult: SurfaceClipResult
-) {
-  const { points, lines, numberOfCells } = polyDataResult;
-
-  let actorCache = polyDataCache.get(actorUID);
-  if (!actorCache) {
-    actorCache = new Map<string, SurfaceClipResult>();
-    polyDataCache.set(actorUID, actorCache);
-  }
-  actorCache.set(cacheId, { points, lines, numberOfCells });
-}

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

@@ -1,15 +0,0 @@
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { RepresentationPublicInput } from '../../../types';
-import { getRepresentationRenderingConfig as getLabelmapRenderingConfig } from '../../../tools/displayTools/Labelmap/labelmapDisplay';
-
-export function getRepresentationSpecificConfig(
-  representationInput: RepresentationPublicInput
-) {
-  const { type } = representationInput;
-
-  if (type === SegmentationRepresentations.Labelmap) {
-    return getLabelmapRenderingConfig();
-  } else {
-    return {};
-  }
-}

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

@@ -1,3 +0,0 @@
-import validateSegmentationInput from './validateSegmentationInput';
-
-export { validateSegmentationInput };

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

@@ -1,61 +0,0 @@
-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
- * @param segmentationInput - The input to the segmentation.
- * @returns A Segmentation object.
- * @internal
- */
-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.
-  return {
-    segmentationId,
-    cachedStats: {},
-    segmentLabels: {},
-    label: null,
-    segmentsLocked: new Set(),
-    type: representation.type,
-    activeSegmentIndex: 1,
-    representationData: {
-      [representation.type]: {
-        ...data,
-      },
-    },
-  };
-}
-
-export default normalizeSegmentationInput;

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

@@ -1,46 +0,0 @@
-import * as Enums from '../../../enums';
-import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
-import { validatePublic as validatePublicLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
-
-/**
- * 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 === 0) {
-    throw new Error(
-      'The segmentationInputArray is undefined or an empty array'
-    );
-  }
-
-  segmentationInputArray.forEach((segmentationInput) => {
-    if (segmentationInput.segmentationId === undefined) {
-      throw new Error(
-        'Undefined segmentationInput.segmentationId. Please provide a valid segmentationId'
-      );
-    }
-
-    if (segmentationInput.representation === undefined) {
-      throw new Error(
-        'Undefined segmentationInput.representation. Please provide a valid representation'
-      );
-    }
-
-    if (
-      segmentationInput.representation.type ===
-      Enums.SegmentationRepresentations.Labelmap
-    ) {
-      validatePublicLabelmap(segmentationInput);
-    }
-  });
-}
-
-export default validateSegmentationInput;

package/src/stateManagement/segmentation/index.ts

@@ -1,33 +0,0 @@
-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';
-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 {
-  // functions
-  addSegmentations,
-  addSegmentationRepresentations,
-  removeSegmentationsFromToolGroup,
-  addRepresentationData,
-  // name spaces
-  state,
-  activeSegmentation,
-  segmentLocking,
-  config,
-  segmentIndex,
-  triggerSegmentationEvents,
-  convertStackToVolumeSegmentation,
-  convertVolumeToStackSegmentation,
-  polySegManager as polySeg,
-};

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

@@ -1,24 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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 };
-};