@cornerstonejs/tools 0.56.1 → 0.56.3

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

@@ -0,0 +1,132 @@
+import { utilities } from '@cornerstonejs/core';
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { Color } from '../../../types/SegmentationStateTypes';
+import { ColorLUT } from '../../../types/SegmentationStateTypes';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+
+/**
+ * addColorLUT - Adds a new color LUT to the state at the given colorLUTIndex.
+ * If no colorLUT is provided, a new color LUT is generated.
+ *
+ * @param colorLUTIndex - the index of the colorLUT in the state
+ * @param colorLUT - An array of The colorLUT to set.
+ * @returns
+ */
+function addColorLUT(colorLUT: ColorLUT, colorLUTIndex: number): void {
+  if (!colorLUT) {
+    throw new Error('addColorLUT: colorLUT is required');
+  }
+
+  // Append the "zero" (no label) color to the front of the LUT, if necessary.
+  if (!utilities.isEqual(colorLUT[0], [0, 0, 0, 0])) {
+    console.warn(
+      'addColorLUT: [0, 0, 0, 0] color is not provided for the background color (segmentIndex =0), automatically adding it'
+    );
+    colorLUT.unshift([0, 0, 0, 0]);
+  }
+
+  SegmentationState.addColorLUT(colorLUT, colorLUTIndex);
+}
+
+/**
+ * It sets the toolGroup's segmentationRepresentation to use the provided
+ * colorLUT at the given colorLUTIndex.
+ * @param toolGroupId - the id of the toolGroup that renders the representation
+ * @param segmentationRepresentationUID - the representationUID for the segmentation
+ * @param colorLUTIndex - the index of the colorLUT to use
+ */
+function setColorLUT(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  colorLUTIndex: number
+): void {
+  const segRepresentation =
+    SegmentationState.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+  if (!segRepresentation) {
+    throw new Error(
+      `setColorLUT: could not find segmentation representation with UID ${segmentationRepresentationUID}`
+    );
+  }
+
+  if (!SegmentationState.getColorLUT(colorLUTIndex)) {
+    throw new Error(
+      `setColorLUT: could not find colorLUT with index ${colorLUTIndex}`
+    );
+  }
+
+  segRepresentation.colorLUTIndex = colorLUTIndex;
+
+  triggerSegmentationRepresentationModified(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+/**
+ * Given a tool group UID, a segmentation representationUID, and a segment index, return the
+ * color for that segment. It can be used for segmentation tools that need to
+ * display the color of their annotation.
+ *
+ * @param toolGroupId - The Id of the tool group that owns the segmentation representation.
+ * @param segmentationRepresentationUID - The uid of the segmentation representation
+ * @param segmentIndex - The index of the segment in the segmentation
+ * @returns A color.
+ */
+function getColorForSegmentIndex(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  segmentIndex: number
+): Color {
+  const segmentationRepresentation =
+    SegmentationState.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+  if (!segmentationRepresentation) {
+    throw new Error(
+      `segmentation representation with UID ${segmentationRepresentationUID} does not exist for tool group ${toolGroupId}`
+    );
+  }
+
+  const { colorLUTIndex } = segmentationRepresentation;
+
+  // get colorLUT
+  const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+  return colorLUT[segmentIndex];
+}
+
+function setColorForSegmentIndex(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  segmentIndex: number,
+  color: Color
+): void {
+  // Get the reference to the color in the colorLUT.
+  const colorReference = getColorForSegmentIndex(
+    toolGroupId,
+    segmentationRepresentationUID,
+    segmentIndex
+  );
+
+  // Modify the values by reference
+  for (let i = 0; i < color.length; i++) {
+    colorReference[i] = color[i];
+  }
+
+  triggerSegmentationRepresentationModified(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+export {
+  getColorForSegmentIndex,
+  addColorLUT,
+  setColorLUT,
+  setColorForSegmentIndex,
+};

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

@@ -0,0 +1,195 @@
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+
+import {
+  RepresentationConfig,
+  SegmentationRepresentationConfig,
+  SegmentSpecificRepresentationConfig,
+} from '../../../types/SegmentationStateTypes';
+
+/**
+ * It returns the global segmentation config.
+ * @returns The global segmentation config containing the representations
+ * config for each representation type and renderInactiveSegmentations flag.
+ */
+function getGlobalConfig(): SegmentationRepresentationConfig {
+  return SegmentationState.getGlobalConfig();
+}
+
+/**
+ * Set the global segmentation config
+ * @param segmentationConfig - SegmentationConfig
+ */
+function setGlobalConfig(
+  segmentationConfig: SegmentationRepresentationConfig
+): void {
+  SegmentationState.setGlobalConfig(segmentationConfig);
+}
+
+/**
+ * Given a representation type, return the corresponding global representation config
+ * @param representationType - The type of representation to query
+ * @returns A representation configuration object.
+ */
+function getGlobalRepresentationConfig(
+  representationType: SegmentationRepresentations
+): RepresentationConfig['LABELMAP'] {
+  const globalConfig = getGlobalConfig();
+  return globalConfig.representations[representationType];
+}
+
+/**
+ * Set the global configuration for a given representation type. It fires
+ * a SEGMENTATION_MODIFIED event.
+ *
+ * @triggers SEGMENTATION_MODIFIED
+ * @param representationType - The type of representation to set config for
+ * @param config - The configuration for the representation.
+ */
+function setGlobalRepresentationConfig(
+  representationType: SegmentationRepresentations,
+  config: RepresentationConfig['LABELMAP']
+): void {
+  const globalConfig = getGlobalConfig();
+
+  setGlobalConfig({
+    ...globalConfig,
+    representations: {
+      ...globalConfig.representations,
+      [representationType]: {
+        ...globalConfig.representations[representationType],
+        ...config,
+      },
+    },
+  });
+}
+
+/**
+ * Get the toolGroup specific segmentation config
+ * @param toolGroupId - The Id of the tool group
+ * @returns A SegmentationConfig object.
+ */
+function getToolGroupSpecificConfig(
+  toolGroupId: string
+): SegmentationRepresentationConfig {
+  return SegmentationState.getToolGroupSpecificConfig(toolGroupId);
+}
+
+/**
+ * Sets the tool group specific configuration for the segmentation
+ * representation. This will apply to all segmentation representations.
+ * @param toolGroupId - The tool group id where the segmentation representation belongs to.
+ * @param segmentationRepresentationConfig - This is the configuration object that you will use to set the default values for
+ * the segmentation representation.
+ */
+function setToolGroupSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationConfig: SegmentationRepresentationConfig
+): void {
+  SegmentationState.setToolGroupSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationConfig
+  );
+}
+
+/**
+ * Give the segmentation representation UID, return the corresponding config
+ * which is shared by all segments in the segmentation representation. This is
+ * an optional level of configuration that can be set by the user, by default
+ * it will fallback to the toolGroup specific config, if not set, it will fallback
+ * to the global config.
+ *
+ * @param segmentationRepresentationUID - The uid of the segmentation representation
+ * @param config - The configuration for the representation. This is an object
+ * only containing the representation type as key and the config as value.
+ * @returns - The configuration for the representation.
+ */
+function getSegmentationRepresentationSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): RepresentationConfig {
+  return SegmentationState.getSegmentationRepresentationSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+/**
+ * Set the segmentation representation specific configuration for the
+ * segmentation representation. This will apply to all segments in the
+ * segmentation representation and has higher priority than the toolGroup
+ * specific config.
+ *
+ * @param segmentationRepresentationUID - The uid of the segmentation representation
+ * @param config - The configuration for the representation. This is an object
+ * only containing the representation type as key and the config as value.
+ */
+function setSegmentationRepresentationSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  config: RepresentationConfig
+): void {
+  SegmentationState.setSegmentationRepresentationSpecificConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    config
+  );
+}
+
+/**
+ * Get the segment specific configuration for the segmentation representation.
+ *
+ * @param toolGroupId - The tool group id where the segmentation representation belongs to.
+ * @param segmentationRepresentationUID  - The uid of the segmentation representation
+ * @param segmentIndex - The index of the segment
+ * @returns - The configuration for the segment index in the segmentation representation that is shown in the toolGroup's viewport
+ */
+function getSegmentSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  segmentIndex: number
+): RepresentationConfig {
+  return SegmentationState.getSegmentSpecificRepresentationConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    segmentIndex
+  );
+}
+
+/**
+ * Set the segment specific configuration for the segmentation representation.
+ * This configuration, if specified, has higher priority than the segmentation representation specific config,
+ * and the toolGroup specific config. The order of priority is: segment specific config > segmentation representation specific config > toolGroup specific config > global config
+ * @param toolGroupId - The tool group id where the segmentation representation belongs to.
+ * @param segmentationRepresentationUID - The uid of the segmentation representation
+ * @param segmentIndex - The index of the segment
+ * @param config - The configuration for the representation. This is an object
+ */
+function setSegmentSpecificConfig(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  config: SegmentSpecificRepresentationConfig
+): void {
+  SegmentationState.setSegmentSpecificRepresentationConfig(
+    toolGroupId,
+    segmentationRepresentationUID,
+    config
+  );
+}
+
+export {
+  // Global
+  getGlobalConfig,
+  setGlobalConfig,
+  getGlobalRepresentationConfig,
+  setGlobalRepresentationConfig,
+  // ToolGroup Specific
+  getToolGroupSpecificConfig,
+  setToolGroupSpecificConfig,
+  // segmentation representation specific config
+  getSegmentationRepresentationSpecificConfig,
+  setSegmentationRepresentationSpecificConfig,
+  // segment specific config
+  getSegmentSpecificConfig,
+  setSegmentSpecificConfig,
+};

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

@@ -0,0 +1,171 @@
+import { cache } from '@cornerstonejs/core';
+import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/segmentationState';
+import { ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+
+function getSegmentationIndices(segmentationId) {
+  const volume = cache.getVolume(segmentationId);
+  const scalarData = volume.getScalarData();
+
+  const keySet = {};
+  scalarData.forEach((it) => (keySet[it] = it));
+  return Object.keys(keySet).map((it) => parseInt(it, 10));
+}
+
+/**
+ * Set the visibility of a segmentation representation for a given tool group. It fires
+ * a SEGMENTATION_REPRESENTATION_MODIFIED event. Visibility true will show all segments
+ * and visibility false will hide all segments"
+ *
+ * @triggers SEGMENTATION_REPRESENTATION_MODIFIED
+ * @param toolGroupId - The Id of the tool group that contains the segmentation.
+ * @param segmentationRepresentationUID - The id of the segmentation representation to modify its visibility.
+ * @param visibility - boolean
+ */
+function setSegmentationVisibility(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  visibility: boolean
+): void {
+  const toolGroupSegmentationRepresentations =
+    getSegmentationRepresentations(toolGroupId);
+
+  if (!toolGroupSegmentationRepresentations) {
+    return;
+  }
+
+  const representation = toolGroupSegmentationRepresentations.find(
+    (representation: ToolGroupSpecificRepresentation) =>
+      representation.segmentationRepresentationUID ===
+      segmentationRepresentationUID
+  );
+
+  if (!representation) {
+    return;
+  }
+
+  const { segmentsHidden, segmentationId } = representation;
+
+  const indices = getSegmentationIndices(segmentationId);
+
+  // if visibility is set to be true, we need to remove all the segments
+  // from the segmentsHidden set, otherwise we need to add all the segments
+  // to the segmentsHidden set
+  if (visibility) {
+    segmentsHidden.clear();
+  } else {
+    indices.forEach((index) => {
+      segmentsHidden.add(index);
+    });
+  }
+
+  triggerSegmentationRepresentationModified(
+    toolGroupId,
+    representation.segmentationRepresentationUID
+  );
+}
+
+/**
+ * Get the visibility of a segmentation data for a given tool group.
+ *
+ * @param toolGroupId - The Id of the tool group that the segmentation
+ * data belongs to.
+ * @param segmentationRepresentationUID - The id of the segmentation data to get
+ * @returns A boolean value that indicates whether the segmentation data is visible or
+ * not on the toolGroup
+ */
+function getSegmentationVisibility(
+  toolGroupId: string,
+  segmentationRepresentationUID: string
+): boolean | undefined {
+  const toolGroupSegmentationRepresentations =
+    getSegmentationRepresentations(toolGroupId);
+
+  const representation = toolGroupSegmentationRepresentations.find(
+    (representation: ToolGroupSpecificRepresentation) =>
+      representation.segmentationRepresentationUID ===
+      segmentationRepresentationUID
+  );
+
+  if (!representation) {
+    return;
+  }
+
+  const { segmentsHidden } = representation;
+
+  return segmentsHidden.size === 0;
+}
+
+/**
+ * Set the visibility of the given segment indices to the given visibility. This
+ * is a helper to set the visibility of multiple segments at once and reduces
+ * the number of events fired.
+ *
+ * @param toolGroupId -  The tool group id of the segmentation representation.
+ * @param segmentationRepresentationUID -  The UID of the segmentation
+ * representation.
+ * @param segmentIndices -  The indices of the segments to be hidden/shown.
+ * @param visibility -  The visibility to set the segments to.
+ *
+ */
+function setSegmentsVisibility(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  segmentIndices: number[],
+  visibility: boolean
+): void {
+  const segRepresentation =
+    SegmentationState.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+  if (!segRepresentation) {
+    return;
+  }
+
+  segmentIndices.forEach((segmentIndex) => {
+    visibility
+      ? segRepresentation.segmentsHidden.delete(segmentIndex)
+      : segRepresentation.segmentsHidden.add(segmentIndex);
+  });
+
+  triggerSegmentationRepresentationModified(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+function setSegmentVisibility(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  segmentIndex: number,
+  visibility: boolean
+): void {
+  const segRepresentation =
+    SegmentationState.getSegmentationRepresentationByUID(
+      toolGroupId,
+      segmentationRepresentationUID
+    );
+
+  if (!segRepresentation) {
+    return;
+  }
+
+  visibility
+    ? segRepresentation.segmentsHidden.delete(segmentIndex)
+    : segRepresentation.segmentsHidden.add(segmentIndex);
+
+  triggerSegmentationRepresentationModified(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+}
+
+export {
+  setSegmentationVisibility,
+  getSegmentationVisibility,
+  setSegmentVisibility,
+  setSegmentsVisibility,
+};

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

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

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

@@ -0,0 +1,35 @@
+import {
+  SegmentationPublicInput,
+  Segmentation,
+} from '../../../types/SegmentationStateTypes';
+
+/**
+ * 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;
+
+  // 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]: {
+        ...representation.data,
+      },
+    },
+  };
+}
+
+export default normalizeSegmentationInput;

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

@@ -0,0 +1,41 @@
+import * as Enums from '../../../enums';
+import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
+import validateLabelmap from '../../../tools/displayTools/Labelmap/validateRepresentationData';
+
+/**
+ * Checks if the segmentationInputArray is valid meaning it contains
+ * correct representationProps for the representation type that is being used.
+ *
+ * @param segmentationInputArray - Array of segmentation inputs
+ * @internal
+ */
+function validateSegmentationInput(
+  segmentationInputArray: SegmentationPublicInput[]
+): void {
+  if (!segmentationInputArray || !segmentationInputArray.length) {
+    throw new Error('The segmentationInputArray is undefined or empty array');
+  }
+
+  segmentationInputArray.forEach((segmentationInput) => {
+    if (segmentationInput.segmentationId === undefined) {
+      throw new Error(
+        'The segmentationInput.segmentationId is undefined, please provide a valid segmentationId'
+      );
+    }
+
+    if (segmentationInput.representation === undefined) {
+      throw new Error(
+        'The segmentationInput.representation is undefined, please provide a valid representation'
+      );
+    }
+
+    if (
+      segmentationInput.representation.type ===
+      Enums.SegmentationRepresentations.Labelmap
+    ) {
+      validateLabelmap(segmentationInput);
+    }
+  });
+}
+
+export default validateSegmentationInput;

package/src/stateManagement/segmentation/index.ts

@@ -0,0 +1,22 @@
+import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
+import addSegmentations from './addSegmentations';
+import addSegmentationRepresentations from './addSegmentationRepresentations';
+
+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';
+
+export {
+  state,
+  addSegmentations,
+  activeSegmentation,
+  addSegmentationRepresentations,
+  removeSegmentationsFromToolGroup,
+  segmentLocking,
+  config,
+  segmentIndex,
+  triggerSegmentationEvents,
+};

package/src/stateManagement/segmentation/removeSegmentationsFromToolGroup.ts

@@ -0,0 +1,85 @@
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
+
+import {
+  getSegmentationRepresentations,
+  getSegmentationRepresentationByUID,
+} from './segmentationState';
+
+/**
+ * Remove the segmentation representation (representation) from the viewports of the toolGroup.
+ * @param toolGroupId - The Id of the toolGroup to remove the segmentation from.
+ * @param segmentationRepresentationUIDs - The UIDs of the segmentation representations to remove.
+ * @param immediate - if True the viewport will be re-rendered immediately.
+ */
+function removeSegmentationsFromToolGroup(
+  toolGroupId: string,
+  segmentationRepresentationUIDs?: string[] | undefined,
+  immediate?: boolean
+): void {
+  const toolGroupSegRepresentations =
+    getSegmentationRepresentations(toolGroupId);
+
+  if (
+    !toolGroupSegRepresentations ||
+    toolGroupSegRepresentations.length === 0
+  ) {
+    return;
+  }
+
+  const toolGroupSegRepresentationUIDs = toolGroupSegRepresentations.map(
+    (representation) => representation.segmentationRepresentationUID
+  );
+
+  let segRepresentationUIDsToRemove = segmentationRepresentationUIDs;
+  if (segRepresentationUIDsToRemove) {
+    // make sure the segmentationDataUIDs that are going to be removed belong
+    // to the toolGroup
+    const invalidSegRepresentationUIDs = segmentationRepresentationUIDs.filter(
+      (segRepresentationUID) =>
+        !toolGroupSegRepresentationUIDs.includes(segRepresentationUID)
+    );
+
+    if (invalidSegRepresentationUIDs.length > 0) {
+      throw new Error(
+        `The following segmentationRepresentationUIDs are not part of the toolGroup: ${JSON.stringify(
+          invalidSegRepresentationUIDs
+        )}`
+      );
+    }
+  } else {
+    // remove all segmentation representations
+    segRepresentationUIDsToRemove = toolGroupSegRepresentationUIDs;
+  }
+
+  segRepresentationUIDsToRemove.forEach((segmentationDataUID) => {
+    _removeSegmentation(toolGroupId, segmentationDataUID, immediate);
+  });
+}
+
+function _removeSegmentation(
+  toolGroupId: string,
+  segmentationRepresentationUID: string,
+  immediate?: boolean
+): void {
+  const segmentationRepresentation = getSegmentationRepresentationByUID(
+    toolGroupId,
+    segmentationRepresentationUID
+  );
+
+  const { type } = segmentationRepresentation;
+
+  if (type === SegmentationRepresentations.Labelmap) {
+    labelmapDisplay.removeSegmentationRepresentation(
+      toolGroupId,
+      segmentationRepresentationUID,
+      immediate
+    );
+  } else if (type === SegmentationRepresentations.Contour) {
+    console.debug('Contour representation is not supported yet, ignoring...');
+  } else {
+    throw new Error(`The representation ${type} is not supported yet`);
+  }
+}
+
+export default removeSegmentationsFromToolGroup;