@cornerstonejs/tools 0.56.1 → 0.56.3

package/src/stateManagement/segmentation/segmentIndex.ts

@@ -0,0 +1,38 @@
+import { getSegmentation } from './segmentationState';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+
+/**
+ * Set the active segment index for a segmentation Id. It fires a global state
+ * modified event.
+ *
+ * @triggers SEGMENTATION_MODIFIED
+ * @param segmentationId - The id of the segmentation that the segment belongs to.
+ * @param segmentIndex - The index of the segment to be activated.
+ */
+function setActiveSegmentIndex(
+  segmentationId: string,
+  segmentIndex: number
+): void {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (segmentation?.activeSegmentIndex !== segmentIndex) {
+    segmentation.activeSegmentIndex = segmentIndex;
+
+    triggerSegmentationModified(segmentationId);
+  }
+}
+
+/**
+ * Get the active segment index for a segmentation in the global state
+ * @param segmentationId - The id of the segmentation to get the active segment index from.
+ * @returns The active segment index for the given segmentation.
+ */
+function getActiveSegmentIndex(segmentationId: string): number | undefined {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (segmentation) {
+    return segmentation.activeSegmentIndex;
+  }
+}
+
+export { getActiveSegmentIndex, setActiveSegmentIndex };

package/src/stateManagement/segmentation/segmentLocking.ts

@@ -0,0 +1,72 @@
+import { getActiveSegmentationRepresentation } from './activeSegmentation';
+
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+
+/**
+ * Get the locked status for a segment index in a segmentation
+ * @param segmentationId - The id of the segmentation that the segment
+ * belongs to.
+ * @param segmentIndex - The index of the segment
+ * @returns A boolean value indicating whether the segment is locked or not.
+ */
+function isSegmentIndexLocked(
+  segmentationId: string,
+  segmentIndex: number
+): boolean {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    throw new Error(`No segmentation state found for ${segmentationId}`);
+  }
+
+  const { segmentsLocked } = segmentation;
+  return segmentsLocked.has(segmentIndex);
+}
+
+/**
+ * Set the locked status of a segment index in a segmentation
+ * @param segmentationId - The id of the segmentation whose segment
+ * index is being modified.
+ * @param segmentIndex - The index of the segment to lock/unlock.
+ */
+function setSegmentIndexLocked(
+  segmentationId: string,
+  segmentIndex: number,
+  locked = true
+): void {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    throw new Error(`No segmentation state found for ${segmentationId}`);
+  }
+
+  const { segmentsLocked } = segmentation;
+
+  if (locked) {
+    segmentsLocked.add(segmentIndex);
+  } else {
+    segmentsLocked.delete(segmentIndex);
+  }
+
+  triggerSegmentationModified(segmentationId);
+}
+
+/**
+ * Get the locked segments for a segmentation
+ * @param segmentationId - The id of the segmentation to get locked
+ * segments for.
+ * @returns An array of locked segment indices.
+ */
+function getLockedSegments(segmentationId: string): number[] | [] {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (!segmentation) {
+    throw new Error(`No segmentation state found for ${segmentationId}`);
+  }
+
+  const { segmentsLocked } = segmentation;
+  return Array.from(segmentsLocked);
+}
+
+export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegments };

package/src/stateManagement/segmentation/segmentationState.ts

@@ -0,0 +1,429 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import {
+  triggerSegmentationRepresentationModified,
+  triggerSegmentationModified,
+  triggerSegmentationRepresentationRemoved,
+  triggerSegmentationRemoved,
+} from './triggerSegmentationEvents';
+import type {
+  ColorLUT,
+  RepresentationConfig,
+  Segmentation,
+  SegmentationPublicInput,
+  SegmentationRepresentationConfig,
+  SegmentSpecificRepresentationConfig,
+  ToolGroupSpecificRepresentation,
+  ToolGroupSpecificRepresentations,
+} from '../../types/SegmentationStateTypes';
+
+import normalizeSegmentationInput from './helpers/normalizeSegmentationInput';
+import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
+import { SegmentationRepresentations } from '../../enums';
+
+/**
+ * It returns the defaultSegmentationStateManager.
+ */
+function getDefaultSegmentationStateManager() {
+  return defaultSegmentationStateManager;
+}
+
+/*************************
+ *
+ * Segmentation State
+ *
+ **************************/
+
+/**
+ * Get the segmentation for the given segmentationId
+ * @param segmentationId - The Id of the segmentation
+ * @returns A GlobalSegmentationData object
+ */
+function getSegmentation(segmentationId: string): Segmentation | undefined {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getSegmentation(segmentationId);
+}
+
+/**
+ * Get the segmentations inside the state
+ * @returns Segmentation array
+ */
+function getSegmentations(): Segmentation[] | [] {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  const state = segmentationStateManager.getState();
+
+  return state.segmentations;
+}
+
+/**
+ * It takes a segmentation input and adds it to the segmentation state manager
+ * @param segmentationInput - The segmentation to add.
+ * @param suppressEvents - If true, the event will not be triggered.
+ */
+function addSegmentation(
+  segmentationInput: SegmentationPublicInput,
+  suppressEvents?: boolean
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+
+  const segmentation = normalizeSegmentationInput(segmentationInput);
+
+  segmentationStateManager.addSegmentation(segmentation);
+
+  if (!suppressEvents) {
+    triggerSegmentationModified(segmentation.segmentationId);
+  }
+}
+
+/**
+ * Get the segmentation state for a tool group. It will return an array of
+ * segmentation representation objects.
+ * @param toolGroupId - The unique identifier of the tool group.
+ * @returns An array of segmentation representation objects.
+ */
+function getSegmentationRepresentations(
+  toolGroupId: string
+): ToolGroupSpecificRepresentations | [] {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getSegmentationRepresentations(toolGroupId);
+}
+
+/**
+ * Get the tool group IDs that have a segmentation representation with the given
+ * segmentationId
+ * @param segmentationId - The id of the segmentation
+ * @returns An array of tool group IDs.
+ */
+function getToolGroupIdsWithSegmentation(segmentationId: string): string[] {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  const state = segmentationStateManager.getState();
+  const toolGroupIds = Object.keys(state.toolGroups);
+
+  const foundToolGroupIds = [];
+  toolGroupIds.forEach((toolGroupId) => {
+    const toolGroupSegmentationRepresentations =
+      segmentationStateManager.getSegmentationRepresentations(toolGroupId);
+
+    toolGroupSegmentationRepresentations.forEach((representation) => {
+      if (representation.segmentationId === segmentationId) {
+        foundToolGroupIds.push(toolGroupId);
+      }
+    });
+  });
+
+  return foundToolGroupIds;
+}
+
+/**
+ * Get the segmentation representations config for a given tool group
+ * @param toolGroupId - The Id of the tool group that the segmentation
+ * config belongs to.
+ * @returns A SegmentationConfig object.
+ */
+function getToolGroupSpecificConfig(
+  toolGroupId: string
+): SegmentationRepresentationConfig {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getToolGroupSpecificConfig(toolGroupId);
+}
+
+/**
+ * Set the segmentation representation config for the provided toolGroup. ToolGroup specific
+ * configuration overwrites the global configuration for each representation.
+ * It fires SEGMENTATION_REPRESENTATION_MODIFIED event if not suppressed.
+ *
+ * @triggers SEGMENTATION_REPRESENTATION_MODIFIED
+ * @param toolGroupId - The Id of the tool group that the segmentation
+ * config is being set for.
+ * @param config - The new configuration for the tool group.
+ * @param suppressEvents - If true, the event will not be triggered.
+ */
+function setToolGroupSpecificConfig(
+  toolGroupId: string,
+  config: SegmentationRepresentationConfig,
+  suppressEvents?: boolean
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.setSegmentationRepresentationConfig(
+    toolGroupId,
+    config
+  );
+
+  if (!suppressEvents) {
+    triggerSegmentationRepresentationModified(toolGroupId);
+  }
+}
+
+/**
+ * It sets the segmentation representation specific config for all the segments
+ * inside the segmentation.
+ * @param segmentationRepresentationUID - The unique identifier of the segmentation representation.
+ * @param config  - The new configuration for the segmentation representation it is an object with keys of
+ * different representation types, and values of the configuration for each representation type.
+ */
+function setSegmentationRepresentationSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  config: RepresentationConfig,
+  suppressEvents = false
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.setSegmentationRepresentationSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    config
+  );
+
+  if (!suppressEvents) {
+    triggerSegmentationRepresentationModified(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+  }
+}
+
+/**
+ * It returns the segmentation representation specific config which is the same for all the segments
+ * @param segmentationRepresentationUID - The unique identifier of the segmentation representation.
+ * @returns - The segmentation representation specific config.
+ */
+function getSegmentationRepresentationSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): RepresentationConfig {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getSegmentationRepresentationSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+function getSegmentSpecificRepresentationConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  segmentIndex: number
+): RepresentationConfig {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getSegmentSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    segmentIndex
+  );
+}
+
+function setSegmentSpecificRepresentationConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  config: SegmentSpecificRepresentationConfig,
+  suppressEvents = false
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.setSegmentSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    config
+  );
+
+  // Todo: this can be even more performant if we create a new event for
+  // triggering a specific segment config change.
+  if (!suppressEvents) {
+    triggerSegmentationRepresentationModified(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+  }
+}
+
+/**
+ * Add the given segmentation representation data to the given tool group state. It fires
+ * SEGMENTATION_REPRESENTATION_MODIFIED event if not suppressed.
+ *
+ * @triggers SEGMENTATION_REPRESENTATION_MODIFIED
+ *
+ * @param toolGroupId - The Id of the tool group that the segmentation representation is for.
+ * @param segmentationData - The data to add to the segmentation state.
+ * @param suppressEvents - boolean
+ */
+function addSegmentationRepresentation(
+  toolGroupId: string,
+  segmentationRepresentation: ToolGroupSpecificRepresentation,
+  suppressEvents?: boolean
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.addSegmentationRepresentation(
+    toolGroupId,
+    segmentationRepresentation
+  );
+
+  if (!suppressEvents) {
+    triggerSegmentationRepresentationModified(
+      toolGroupId,
+      segmentationRepresentation.segmentationRepresentationUID
+    );
+  }
+}
+
+/**
+ * It returns the global segmentation config. Note that the toolGroup-specific
+ * configuration has higher priority than the global configuration and overwrites
+ * the global configuration for each representation.
+ * @returns The global segmentation configuration for all segmentations.
+ */
+function getGlobalConfig(): SegmentationRepresentationConfig {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getGlobalConfig();
+}
+
+/**
+ * Set the global segmentation configuration. It fires SEGMENTATION_MODIFIED
+ * event if not suppressed.
+ *
+ * @triggers SEGMENTATION_MODIFIED
+ * @param config - The new global segmentation config.
+ * @param suppressEvents - If true, the `segmentationGlobalStateModified` event will not be triggered.
+ */
+function setGlobalConfig(
+  config: SegmentationRepresentationConfig,
+  suppressEvents?: boolean
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.setGlobalConfig(config);
+
+  if (!suppressEvents) {
+    triggerSegmentationModified();
+  }
+}
+
+/**
+ * Get the segmentation data object for a given tool group and
+ * segmentation data UID. It searches all the toolGroup specific segmentation
+ * data objects and returns the first one that matches the UID.
+ * @param toolGroupId - The Id of the tool group that the segmentation
+ * data belongs to.
+ * @param segmentationRepresentationUID - The uid of the segmentation representation
+ * @returns Segmentation Data object.
+ */
+function getSegmentationRepresentationByUID(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): ToolGroupSpecificRepresentation | undefined {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getSegmentationRepresentationByUID(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+/**
+ * It removes the segmentation from the segmentation state manager
+ *
+ * @triggers SEGMENTATION_REMOVED
+ *
+ * @param segmentationId - The id of the segmentation
+ */
+function removeSegmentation(segmentationId: string): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.removeSegmentation(segmentationId);
+  triggerSegmentationRemoved(segmentationId);
+}
+
+/**
+ * Remove a segmentation representation from the segmentation state manager for a toolGroup.
+ * It fires SEGMENTATION_REPRESENTATION_MODIFIED event.
+ *
+ * @triggers SEGMENTATION_REPRESENTATION_REMOVED
+ *
+ * @param toolGroupId - The Id of the tool group that the segmentation
+ * data belongs to.
+ * @param segmentationRepresentationUID - The uid of the segmentation representation to remove.
+ * remove.
+ * @param - immediate - If true, the viewports will be updated immediately.
+ */
+function removeSegmentationRepresentation(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.removeSegmentationRepresentation(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+
+  triggerSegmentationRepresentationRemoved(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+/**
+ * Add a color LUT to the segmentation state manager
+ * @param colorLUT - The color LUT array to add.
+ * @param index - The index of the color LUT to add.
+ */
+function removeColorLUT(colorLUTIndex: number): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.removeColorLUT(colorLUTIndex);
+}
+
+/**
+ * Get the color lut for a given index
+ * @param index - The index of the color lut to retrieve.
+ * @returns A ColorLUT array.
+ */
+function getColorLUT(index: number): ColorLUT | undefined {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getColorLUT(index);
+}
+
+/**
+ * Add a color LUT to the segmentation state manager
+ * @param colorLUT - The color LUT array to add.
+ * @param index - The index of the color LUT to add.
+ */
+function addColorLUT(colorLUT: ColorLUT, index: number): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  segmentationStateManager.addColorLUT(colorLUT, index);
+  // Todo: trigger event color LUT added
+}
+
+// Initialize the default configuration
+// Note: when we get other representations, we should set their default representations too.
+const defaultLabelmapConfig = getDefaultLabelmapConfig();
+
+const newGlobalConfig: SegmentationRepresentationConfig = {
+  renderInactiveSegmentations: true,
+  representations: {
+    [SegmentationRepresentations.Labelmap]: defaultLabelmapConfig,
+  },
+};
+
+setGlobalConfig(newGlobalConfig, true);
+
+export {
+  // state manager
+  getDefaultSegmentationStateManager,
+  // Segmentation
+  getSegmentation,
+  getSegmentations,
+  addSegmentation,
+  removeSegmentation,
+  // ToolGroup specific Segmentation Representation
+  getSegmentationRepresentations,
+  addSegmentationRepresentation,
+  removeSegmentationRepresentation,
+  // config
+  getToolGroupSpecificConfig,
+  setToolGroupSpecificConfig,
+  getGlobalConfig,
+  setGlobalConfig,
+  getSegmentationRepresentationSpecificConfig,
+  setSegmentationRepresentationSpecificConfig,
+  getSegmentSpecificRepresentationConfig,
+  setSegmentSpecificRepresentationConfig,
+  // helpers s
+  getToolGroupIdsWithSegmentation,
+  getSegmentationRepresentationByUID,
+  // color
+  addColorLUT,
+  getColorLUT,
+  removeColorLUT,
+};

package/src/stateManagement/segmentation/triggerSegmentationEvents.ts

@@ -0,0 +1,157 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+
+import { Events } from '../../enums';
+import {
+  getSegmentationRepresentations,
+  getSegmentations,
+} from '../../stateManagement/segmentation/segmentationState';
+import {
+  SegmentationRepresentationModifiedEventDetail,
+  SegmentationDataModifiedEventDetail,
+  SegmentationModifiedEventDetail,
+  SegmentationRepresentationRemovedEventDetail,
+  SegmentationRemovedEventDetail,
+} from '../../types/EventTypes';
+
+/**
+ * Trigger an event that a segmentation is removed
+ * @param segmentationId - The Id of segmentation
+ */
+function triggerSegmentationRemoved(segmentationId: string): void {
+  const eventDetail: SegmentationRemovedEventDetail = {
+    segmentationId,
+  };
+
+  triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
+}
+
+/**
+ * Trigger an event that a segmentation representation was removed
+ * @param toolGroupId - The id of the tool group that the segmentation
+ * representation was removed from.
+ * @param segmentationRepresentationUID - The UID of the segmentation
+ * representation that was removed.
+ */
+function triggerSegmentationRepresentationRemoved(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): void {
+  const eventDetail: SegmentationRepresentationRemovedEventDetail = {
+    toolGroupId,
+    segmentationRepresentationUID,
+  };
+
+  triggerEvent(
+    eventTarget,
+    Events.SEGMENTATION_REPRESENTATION_REMOVED,
+    eventDetail
+  );
+}
+
+/**
+ * Trigger an event on the eventTarget that the segmentation representation for
+ * toolGroupId has been updated
+ * @param toolGroupId - The Id of the toolGroup
+ */
+function triggerSegmentationRepresentationModified(
+  toolGroupId: string,
+  segmentationRepresentationUID?: string
+): void {
+  const eventDetail: SegmentationRepresentationModifiedEventDetail = {
+    toolGroupId,
+    segmentationRepresentationUID,
+  };
+
+  if (segmentationRepresentationUID) {
+    triggerEvent(
+      eventTarget,
+      Events.SEGMENTATION_REPRESENTATION_MODIFIED,
+      eventDetail
+    );
+    return;
+  }
+
+  // If no segmentationRepresentationUID is provided, then we need to trigger
+  // the event for all segmentation representations in the toolGroup
+
+  // Get all segmentation representations in the toolGroup
+  const segmentationRepresentations =
+    getSegmentationRepresentations(toolGroupId) || [];
+
+  segmentationRepresentations.forEach((segmentationRepresentation) => {
+    const { segmentationRepresentationUID } = segmentationRepresentation;
+    const eventDetail: SegmentationRepresentationModifiedEventDetail = {
+      toolGroupId,
+      segmentationRepresentationUID,
+    };
+
+    triggerEvent(
+      eventTarget,
+      Events.SEGMENTATION_REPRESENTATION_MODIFIED,
+      eventDetail
+    );
+  });
+}
+
+/**
+ * Triggers segmentation global state updated event, notifying all toolGroups
+ * that the global state has been updated, If a segmentationId is provided
+ * the event will only be triggered for that segmentation, otherwise it will
+ * be triggered for all segmentations.
+ *
+ * @param segmentationId - The id of the segmentation that has been updated
+ */
+function triggerSegmentationModified(segmentationId?: string): void {
+  let segmentationIds;
+
+  if (segmentationId) {
+    segmentationIds = [segmentationId];
+  } else {
+    // get all toolGroups
+    segmentationIds = getSegmentations().map(
+      ({ segmentationId }) => segmentationId
+    );
+  }
+
+  // 1. Trigger an event notifying all listeners about the segmentationId
+  // that has been updated.
+  segmentationIds.forEach((segmentationId) => {
+    const eventDetail: SegmentationModifiedEventDetail = {
+      segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
+  });
+
+  // Todo: I don't think we need the following lines of code
+  // // 2. Notify all viewports that render the segmentationId in order to update the
+  // // rendering based on the new global state.
+  // toolGroupIds.forEach((toolGroupId) => {
+  //   triggerSegmentationRepresentationModified(toolGroupId)
+  // })
+}
+
+/**
+ * Trigger an event that a segmentation data has been modified
+ * @param segmentationId - The Id of segmentation
+ */
+function triggerSegmentationDataModified(
+  segmentationId: string,
+  modifiedSlicesToUse?: number[]
+): void {
+  const eventDetail: SegmentationDataModifiedEventDetail = {
+    segmentationId,
+    modifiedSlicesToUse,
+  };
+
+  triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
+}
+
+export {
+  // ToolGroup Specific
+  triggerSegmentationRepresentationModified,
+  triggerSegmentationRepresentationRemoved,
+  // Global
+  triggerSegmentationDataModified,
+  triggerSegmentationModified,
+  triggerSegmentationRemoved,
+};