@cornerstonejs/tools 0.56.2 → 0.56.4

package/src/stateManagement/segmentation/SegmentationStateManager.ts

@@ -0,0 +1,491 @@
+import cloneDeep from 'lodash.clonedeep';
+import { utilities as csUtils } from '@cornerstonejs/core';
+
+import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+
+import type {
+  SegmentationState,
+  ColorLUT,
+  Segmentation,
+  ToolGroupSpecificRepresentation,
+  SegmentationRepresentationConfig,
+  ToolGroupSpecificRepresentations,
+  RepresentationConfig,
+  SegmentSpecificRepresentationConfig,
+} from '../../types/SegmentationStateTypes';
+import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
+import { SegmentationRepresentations } from '../../enums';
+
+// 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,
+  },
+};
+
+/* A default initial state for the segmentation manager. */
+const initialDefaultState: SegmentationState = {
+  colorLUT: [],
+  segmentations: [],
+  globalConfig: newGlobalConfig,
+  toolGroups: {},
+};
+
+/**
+ * The SegmentationStateManager Class is responsible for managing the state of the
+ * segmentations. It stores the segmentations and toolGroup specific representations
+ * of the segmentation. It also stores a global config and a toolGroup specific
+ * config. Note that this is a singleton state manager.
+ */
+export default class SegmentationStateManager {
+  private state: SegmentationState;
+  public readonly uid: string;
+
+  constructor(uid?: string) {
+    if (!uid) {
+      uid = csUtils.uuidv4();
+    }
+    this.state = cloneDeep(initialDefaultState);
+    this.uid = uid;
+  }
+
+  /**
+   * It returns a copy of the current state of the segmentation
+   * @returns A deep copy of the state.
+   */
+  getState(): SegmentationState {
+    return this.state;
+  }
+
+  /**
+   * It returns an array of toolGroupIds currently in the segmentation state.
+   * @returns An array of strings.
+   */
+  getToolGroups(): string[] {
+    return Object.keys(this.state.toolGroups);
+  }
+
+  /**
+   * It returns the colorLUT at the specified index.
+   * @param lutIndex - The index of the color LUT to retrieve.
+   * @returns A ColorLUT object.
+   */
+  getColorLUT(lutIndex: number): ColorLUT | undefined {
+    return this.state.colorLUT[lutIndex];
+  }
+
+  /**
+   * Reset the state to the default state
+   */
+  resetState(): void {
+    this.state = cloneDeep(initialDefaultState);
+  }
+
+  /**
+   * Given a segmentation Id, return the segmentation state
+   * @param segmentationId - The id of the segmentation to get the data for.
+   * @returns - The segmentation data
+   */
+  getSegmentation(segmentationId: string): Segmentation | undefined {
+    return this.state.segmentations.find(
+      (segmentation) => segmentation.segmentationId === segmentationId
+    );
+  }
+
+  /**
+   * It adds a segmentation to the segmentations array.
+   * @param segmentation - Segmentation
+   */
+  addSegmentation(segmentation: Segmentation): void {
+    this._initDefaultColorLUTIfNecessary();
+
+    // Check if the segmentation already exists with the segmentationId
+    if (this.getSegmentation(segmentation.segmentationId)) {
+      throw new Error(
+        `Segmentation with id ${segmentation.segmentationId} already exists`
+      );
+    }
+
+    this.state.segmentations.push(segmentation);
+  }
+
+  /**
+   * Get the segmentation representations for a tool group
+   * @param toolGroupId - string
+   * @returns A list of segmentation representations.
+   */
+  getSegmentationRepresentations(
+    toolGroupId: string
+  ): ToolGroupSpecificRepresentations | undefined {
+    const toolGroupSegRepresentationsWithConfig =
+      this.state.toolGroups[toolGroupId];
+
+    if (!toolGroupSegRepresentationsWithConfig) {
+      return;
+    }
+
+    return toolGroupSegRepresentationsWithConfig.segmentationRepresentations;
+  }
+
+  /**
+   * Add a new segmentation representation to the toolGroup's segmentation representations.
+   * @param toolGroupId - The Id of the tool group .
+   * @param segmentationRepresentation - The segmentation representation to add.
+   */
+  addSegmentationRepresentation(
+    toolGroupId: string,
+    segmentationRepresentation: ToolGroupSpecificRepresentation
+  ): void {
+    // Initialize the default toolGroup state if not created yet
+    if (!this.state.toolGroups[toolGroupId]) {
+      this.state.toolGroups[toolGroupId] = {
+        segmentationRepresentations: [],
+        config: {} as SegmentationRepresentationConfig,
+      };
+    }
+
+    // local toolGroupSpecificSegmentationState
+    this.state.toolGroups[toolGroupId].segmentationRepresentations.push(
+      segmentationRepresentation
+    );
+
+    this._handleActiveSegmentation(toolGroupId, segmentationRepresentation);
+  }
+
+  /**
+   * Get the global config containing both representation config
+   * and render inactive segmentations config
+   * @returns The global config object.
+   */
+  getGlobalConfig(): SegmentationRepresentationConfig {
+    return this.state.globalConfig;
+  }
+
+  /**
+   * It sets the global segmentation config including both representation config
+   * and render inactive segmentations config
+   * @param config - The global configuration for the segmentations.
+   */
+  setGlobalConfig(config: SegmentationRepresentationConfig): void {
+    this.state.globalConfig = config;
+  }
+
+  /**
+   * Given a toolGroupId and a segmentationRepresentationUID, return the segmentation
+   * representation for that tool group.
+   * @param toolGroupId - The Id of the tool group
+   * @param segmentationRepresentationUID - string
+   * @returns The segmentation representation.
+   */
+  getSegmentationRepresentationByUID(
+    toolGroupId: string,
+    segmentationRepresentationUID: string
+  ): ToolGroupSpecificRepresentation | undefined {
+    const toolGroupSegRepresentations =
+      this.getSegmentationRepresentations(toolGroupId);
+
+    const segmentationData = toolGroupSegRepresentations.find(
+      (representation) =>
+        representation.segmentationRepresentationUID ===
+        segmentationRepresentationUID
+    );
+
+    return segmentationData;
+  }
+
+  /**
+   * It removes the segmentation from the segmentation state.
+   * @param segmentationId - The id of the segmentation to remove.
+   */
+  removeSegmentation(segmentationId: string): void {
+    this.state.segmentations = this.state.segmentations.filter(
+      (segmentation) => segmentation.segmentationId !== segmentationId
+    );
+  }
+
+  /**
+   * Remove a segmentation representation from the toolGroup
+   * @param toolGroupId - The Id of the tool group
+   * @param segmentationRepresentationUID - the uid of the segmentation representation to remove
+   * @param immediate - If true, the viewport will be updated immediately.
+   */
+  removeSegmentationRepresentation(
+    toolGroupId: string,
+    segmentationRepresentationUID: string
+  ): void {
+    const toolGroupSegmentationRepresentations =
+      this.getSegmentationRepresentations(toolGroupId);
+
+    if (
+      !toolGroupSegmentationRepresentations ||
+      !toolGroupSegmentationRepresentations.length
+    ) {
+      throw new Error(
+        `No viewport specific segmentation state found for viewport ${toolGroupId}`
+      );
+    }
+
+    const state =
+      toolGroupSegmentationRepresentations as ToolGroupSpecificRepresentations;
+    const index = state.findIndex(
+      (segData) =>
+        segData.segmentationRepresentationUID === segmentationRepresentationUID
+    );
+
+    if (index === -1) {
+      console.warn(
+        `No viewport specific segmentation state data found for viewport ${toolGroupId} and segmentation data UID ${segmentationRepresentationUID}`
+      );
+    }
+
+    const removedSegmentationRepresentation =
+      toolGroupSegmentationRepresentations[index];
+
+    toolGroupSegmentationRepresentations.splice(index, 1);
+
+    this._handleActiveSegmentation(
+      toolGroupId,
+      removedSegmentationRepresentation
+    );
+  }
+
+  /**
+   * Set the active segmentation data for a tool group
+   * @param toolGroupId - The Id of the tool group that owns the
+   * segmentation data.
+   * @param segmentationRepresentationUID - string
+   */
+  setActiveSegmentationRepresentation(
+    toolGroupId: string,
+    segmentationRepresentationUID: string
+  ): void {
+    const toolGroupSegmentations =
+      this.getSegmentationRepresentations(toolGroupId);
+
+    if (!toolGroupSegmentations || !toolGroupSegmentations.length) {
+      throw new Error(
+        `No segmentation data found for toolGroupId: ${toolGroupId}`
+      );
+    }
+
+    const segmentationData = toolGroupSegmentations.find(
+      (segmentationData) =>
+        segmentationData.segmentationRepresentationUID ===
+        segmentationRepresentationUID
+    );
+
+    if (!segmentationData) {
+      throw new Error(
+        `No segmentation data found for segmentation data UID ${segmentationRepresentationUID}`
+      );
+    }
+
+    segmentationData.active = true;
+    this._handleActiveSegmentation(toolGroupId, segmentationData);
+  }
+
+  /**
+   * Given a tool group Id it returns the tool group specific representation config
+   *
+   * @param toolGroupId - The Id of the tool group
+   * @returns A SegmentationConfig object.
+   */
+  getToolGroupSpecificConfig(
+    toolGroupId: string
+  ): SegmentationRepresentationConfig | undefined {
+    const toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+
+    if (!toolGroupStateWithConfig) {
+      return;
+    }
+
+    return toolGroupStateWithConfig.config;
+  }
+
+  getSegmentationRepresentationSpecificConfig(
+    toolGroupId: string,
+    segmentationRepresentationUID: string
+  ): RepresentationConfig {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+    if (!segmentationRepresentation) {
+      return;
+    }
+
+    return segmentationRepresentation.segmentationRepresentationSpecificConfig;
+  }
+
+  setSegmentationRepresentationSpecificConfig(
+    toolGroupId: string,
+    segmentationRepresentationUID: string,
+    config: RepresentationConfig
+  ): void {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+    if (!segmentationRepresentation) {
+      return;
+    }
+
+    segmentationRepresentation.segmentationRepresentationSpecificConfig =
+      config;
+  }
+
+  getSegmentSpecificConfig(
+    toolGroupId: string,
+    segmentationRepresentationUID: string,
+    segmentIndex: number
+  ): RepresentationConfig {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+    if (!segmentationRepresentation) {
+      return;
+    }
+
+    return segmentationRepresentation.segmentSpecificConfig[segmentIndex];
+  }
+
+  setSegmentSpecificConfig(
+    toolGroupId: string,
+    segmentationRepresentationUID: string,
+    config: SegmentSpecificRepresentationConfig
+  ): void {
+    const segmentationRepresentation = this.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+    if (!segmentationRepresentation) {
+      return;
+    }
+
+    segmentationRepresentation.segmentSpecificConfig = config;
+  }
+
+  /**
+   * Set the segmentation representations config for a given tool group. It will create a new
+   * tool group specific config if one does not exist.
+   *
+   * @param toolGroupId - The Id of the tool group that the segmentation
+   * belongs to.
+   * @param config - SegmentationConfig
+   */
+  setSegmentationRepresentationConfig(
+    toolGroupId: string,
+    config: SegmentationRepresentationConfig
+  ): void {
+    let toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+
+    if (!toolGroupStateWithConfig) {
+      this.state.toolGroups[toolGroupId] = {
+        segmentationRepresentations: [],
+        config: {
+          renderInactiveSegmentations: true,
+          representations: {},
+        },
+      };
+
+      toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+    }
+
+    toolGroupStateWithConfig.config = {
+      ...toolGroupStateWithConfig.config,
+      ...config,
+    };
+  }
+
+  /**
+   * It adds a color LUT to the state.
+   * @param colorLUT - ColorLUT
+   * @param lutIndex - The index of the color LUT table to add.
+   */
+  addColorLUT(colorLUT: ColorLUT, lutIndex: number): void {
+    if (this.state.colorLUT[lutIndex]) {
+      console.log('Color LUT table already exists, overwriting');
+    }
+
+    this.state.colorLUT[lutIndex] = colorLUT;
+  }
+
+  /**
+   * Removes a color LUT to the state.
+   * @param colorLUTIndex - The index of the color LUT table to remove.
+   */
+  removeColorLUT(colorLUTIndex: number): void {
+    delete this.state.colorLUT[colorLUTIndex];
+  }
+
+  /**
+   * It handles the active segmentation representation based on the active status of the
+   * segmentation representation that was added or removed.
+   *
+   * @param toolGroupId - The Id of the tool group that the segmentation representation belongs to.
+   * @param recentlyAddedOrRemovedSegmentationRepresentation - ToolGroupSpecificSegmentationData
+   */
+  _handleActiveSegmentation(
+    toolGroupId: string,
+    recentlyAddedOrRemovedSegmentationRepresentation: ToolGroupSpecificRepresentation
+  ): void {
+    const segmentationRepresentations =
+      this.getSegmentationRepresentations(toolGroupId);
+
+    // 1. If there is no segmentation representations, return early
+    if (segmentationRepresentations.length === 0) {
+      return;
+    }
+
+    // 2. If there is only one segmentation representation, make that one active
+    if (segmentationRepresentations.length === 1) {
+      segmentationRepresentations[0].active = true;
+      return;
+    }
+
+    // 3. If removed Segmentation representation was active, make the first one active
+    const activeSegmentationRepresentations =
+      segmentationRepresentations.filter(
+        (representation) => representation.active
+      );
+
+    if (activeSegmentationRepresentations.length === 0) {
+      segmentationRepresentations[0].active = true;
+      return;
+    }
+
+    // 4. If the added segmentation representation is active, make other segmentation
+    // representations inactive
+    if (recentlyAddedOrRemovedSegmentationRepresentation.active) {
+      segmentationRepresentations.forEach((representation) => {
+        if (
+          representation.segmentationRepresentationUID !==
+          recentlyAddedOrRemovedSegmentationRepresentation.segmentationRepresentationUID
+        ) {
+          representation.active = false;
+        }
+      });
+    }
+
+    // 5. if added/removed segmentation is is inactive, do nothing
+  }
+
+  _initDefaultColorLUTIfNecessary() {
+    // if colorLUTTable is not specified or the default one is not found
+    if (this.state.colorLUT.length === 0 || !this.state.colorLUT[0]) {
+      this.addColorLUT(CORNERSTONE_COLOR_LUT as ColorLUT, 0);
+    }
+  }
+}
+
+const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');
+export { defaultSegmentationStateManager };

package/src/stateManagement/segmentation/activeSegmentation.ts

@@ -0,0 +1,60 @@
+import { ToolGroupSpecificRepresentation } from '../../types/SegmentationStateTypes';
+import { getDefaultSegmentationStateManager } from './segmentationState';
+import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
+
+/**
+ * Get the active segmentation representation for the tool group with
+ * the given toolGroupId.
+ * @param toolGroupId - The Id of the tool group
+ * @returns The active segmentation representation for the tool group.
+ */
+function getActiveSegmentationRepresentation(
+  toolGroupId: string
+): ToolGroupSpecificRepresentation {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+
+  const toolGroupSegmentationRepresentations =
+    segmentationStateManager.getSegmentationRepresentations(toolGroupId);
+
+  if (!toolGroupSegmentationRepresentations) {
+    return;
+  }
+
+  const activeRepresentation = toolGroupSegmentationRepresentations.find(
+    (representation) => representation.active
+  );
+
+  return activeRepresentation;
+}
+
+/**
+ * Set the active segmentation for the given tool group for all its viewports
+ *
+ * @param toolGroupId - The Id of the tool group to set the active
+ * segmentation for.
+ * @param segmentationRepresentationUID - The id of the segmentation representation to set as
+ * active.
+ */
+function setActiveSegmentationRepresentation(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): void {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+
+  segmentationStateManager.setActiveSegmentationRepresentation(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+
+  triggerSegmentationRepresentationModified(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+export {
+  // get
+  getActiveSegmentationRepresentation,
+  // set
+  setActiveSegmentationRepresentation,
+};

package/src/stateManagement/segmentation/addSegmentationRepresentations.ts

@@ -0,0 +1,77 @@
+import _cloneDeep from 'lodash.clonedeep';
+import {
+  SegmentationRepresentationConfig,
+  RepresentationPublicInput,
+} from '../../types/SegmentationStateTypes';
+import Representations from '../../enums/SegmentationRepresentations';
+import { getToolGroup } from '../../store/ToolGroupManager';
+
+import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
+import { contourDisplay } from '../../tools/displayTools/Contour';
+
+/**
+ * Set the specified segmentation representations on the viewports of the specified
+ * toolGroup. It accepts a second argument which is a toolGroup specific representation
+ * configuration.
+ *
+ * @param toolGroupId - The Id of the toolGroup to add the segmentation representations to
+ * @param representationInputArray - An array of segmentation representations to add to the toolGroup
+ * @param toolGroupSpecificRepresentationConfig - The toolGroup specific configuration
+ * for the segmentation representations
+ */
+async function addSegmentationRepresentations(
+  toolGroupId: string,
+  representationInputArray: RepresentationPublicInput[],
+  toolGroupSpecificRepresentationConfig?: SegmentationRepresentationConfig
+): Promise<string[]> {
+  // Check if there exists a toolGroup with the toolGroupId
+  const toolGroup = getToolGroup(toolGroupId);
+
+  if (!toolGroup) {
+    throw new Error(`No tool group found for toolGroupId: ${toolGroupId}`);
+  }
+
+  const promises = representationInputArray.map((representationInput) => {
+    return _addSegmentationRepresentation(
+      toolGroupId,
+      representationInput,
+      toolGroupSpecificRepresentationConfig
+    );
+  });
+
+  const segmentationRepresentationUIDs = await Promise.all(promises);
+
+  return segmentationRepresentationUIDs;
+}
+
+async function _addSegmentationRepresentation(
+  toolGroupId: string,
+  representationInput: RepresentationPublicInput,
+  toolGroupSpecificRepresentationConfig?: SegmentationRepresentationConfig
+): Promise<string> {
+  let segmentationRepresentationUID;
+
+  if (representationInput.type === Representations.Labelmap) {
+    segmentationRepresentationUID =
+      await labelmapDisplay.addSegmentationRepresentation(
+        toolGroupId,
+        representationInput,
+        toolGroupSpecificRepresentationConfig
+      );
+  } else if (representationInput.type === Representations.Contour) {
+    segmentationRepresentationUID =
+      await contourDisplay.addSegmentationRepresentation(
+        toolGroupId,
+        representationInput,
+        toolGroupSpecificRepresentationConfig
+      );
+  } else {
+    throw new Error(
+      `The representation type ${representationInput.type} is not supported`
+    );
+  }
+
+  return segmentationRepresentationUID;
+}
+
+export default addSegmentationRepresentations;

package/src/stateManagement/segmentation/addSegmentations.ts

@@ -0,0 +1,27 @@
+import _cloneDeep from 'lodash.clonedeep';
+import { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+import { validateSegmentationInput } from './helpers';
+import { addSegmentation as addSegmentationToState } from './segmentationState';
+/**
+ * Adds the segmentation to the cornerstone3D segmentation state. It should be
+ * noted that segmentations are not added to any toolGroup's viewports. In order to
+ * do so, you should add a "representation" of the segmentation to the toolGroup
+ * using addSegmentationRepresentations helper. The reason for this is that there
+ * can be multiple representations of the same segmentation (e.g. Labelmap and
+ * Contour, etc. - Currently only Labelmap representations is supported).
+ * @param segmentationInputArray - The array of segmentation input, each of which
+ * defining the segmentationId and the main representation data for the segmentation.
+ */
+function addSegmentations(
+  segmentationInputArray: SegmentationPublicInput[]
+): void {
+  validateSegmentationInput(segmentationInputArray);
+
+  segmentationInputArray.map((segInput) => {
+    const segmentationInput = _cloneDeep(segInput);
+
+    addSegmentationToState(segmentationInput);
+  });
+}
+
+export default addSegmentations;

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

@@ -0,0 +1,29 @@
+import * as color from './segmentationColor';
+import * as visibility from './segmentationVisibility';
+import {
+  getGlobalConfig,
+  getGlobalRepresentationConfig,
+  getToolGroupSpecificConfig,
+  setGlobalConfig,
+  setGlobalRepresentationConfig,
+  setToolGroupSpecificConfig,
+  setSegmentSpecificConfig,
+  getSegmentSpecificConfig,
+  setSegmentationRepresentationSpecificConfig,
+  getSegmentationRepresentationSpecificConfig,
+} from './segmentationConfig';
+
+export {
+  color,
+  visibility,
+  getGlobalConfig,
+  getGlobalRepresentationConfig,
+  getToolGroupSpecificConfig,
+  setGlobalConfig,
+  setGlobalRepresentationConfig,
+  setToolGroupSpecificConfig,
+  setSegmentSpecificConfig,
+  getSegmentSpecificConfig,
+  setSegmentationRepresentationSpecificConfig,
+  getSegmentationRepresentationSpecificConfig,
+};