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

package/src/stateManagement/segmentation/segmentIndex.ts

@@ -1,9 +1,15 @@
-import { getSegmentation } from './segmentationState';
+import { invalidateBrushCursor } from '../../utilities/segmentation/';
+import {
+  getSegmentation,
+  getToolGroupIdsWithSegmentation,
+} from './segmentationState';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 
 /**
  * Set the active segment index for a segmentation Id. It fires a global state
- * modified event.
+ * modified event. Also it invalidates the brush cursor for all toolGroups that
+ * has the segmentationId as active segment (since the brush cursor color
+ * should change as well)
  *
  * @triggers SEGMENTATION_MODIFIED
  * @param segmentationId - The id of the segmentation that the segment belongs to.
@@ -15,11 +21,23 @@ function setActiveSegmentIndex(
 ): void {
   const segmentation = getSegmentation(segmentationId);
 
+  if (typeof segmentIndex === 'string') {
+    console.warn('segmentIndex is a string, converting to number');
+    segmentIndex = Number(segmentIndex);
+  }
+
   if (segmentation?.activeSegmentIndex !== segmentIndex) {
     segmentation.activeSegmentIndex = segmentIndex;
 
     triggerSegmentationModified(segmentationId);
   }
+
+  // get all toolGroups that has the segmentationId as active
+  // segment and call invalidateBrushCursor on them
+  const toolGroups = getToolGroupIdsWithSegmentation(segmentationId);
+  toolGroups.forEach((toolGroupId) => {
+    invalidateBrushCursor(toolGroupId);
+  });
 }
 
 /**

package/src/stateManagement/segmentation/segmentationState.ts

@@ -1,5 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
 import type {
-  ColorLUT,
   RepresentationConfig,
   Segmentation,
   SegmentationPublicInput,
@@ -97,6 +97,65 @@ function getAllSegmentationRepresentations(): Record<
   return segmentationStateManager.getAllSegmentationRepresentations();
 }
 
+/**
+ * Finds all segmentation representations with the given segmentationId.
+ * @param segmentationId - The ID of the segmentation.
+ * @returns An array of found segmentation representations.
+ */
+function getSegmentationIdRepresentations(segmentationId) {
+  const allRepresentations = getAllSegmentationRepresentations() || {};
+  const foundRepresentations = [];
+
+  for (const toolGroupId in allRepresentations) {
+    const toolGroupRepresentations = allRepresentations[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) => representation.segmentationId === segmentationId
+    );
+
+    if (foundRepresentation) {
+      foundRepresentations.push(foundRepresentation);
+    }
+  }
+
+  return foundRepresentations;
+}
+
+/**
+ * Finds a segmentation representation by its UID.
+ *
+ * @param segmentationRepresentationUID - The UID of the segmentation representation to find.
+ * @returns The found segmentation representation, or undefined if not found.
+ */
+function findSegmentationRepresentationByUID(
+  segmentationRepresentationUID: string
+): {
+  toolGroupId: string;
+  segmentationRepresentation: ToolGroupSpecificRepresentation;
+} {
+  const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
+
+  const toolGroupIds = Object.keys(allToolGroupRepresentations);
+
+  for (const toolGroupId of toolGroupIds) {
+    const toolGroupRepresentations =
+      getAllSegmentationRepresentations()[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) =>
+        representation.segmentationRepresentationUID ===
+        segmentationRepresentationUID
+    );
+
+    if (foundRepresentation) {
+      return {
+        segmentationRepresentation: foundRepresentation,
+        toolGroupId,
+      };
+    }
+  }
+}
+
 /**
  * Get the tool group IDs that have a segmentation representation with the given
  * segmentationId
@@ -247,6 +306,29 @@ function setSegmentSpecificRepresentationConfig(
   }
 }
 
+function getToolGroupIdFromSegmentationRepresentationUID(
+  segmentationRepresentationUID: string
+): string {
+  const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
+
+  const toolGroupIds = Object.keys(allToolGroupRepresentations);
+
+  for (const toolGroupId of toolGroupIds) {
+    const toolGroupRepresentations =
+      getAllSegmentationRepresentations()[toolGroupId];
+
+    const foundRepresentation = toolGroupRepresentations.find(
+      (representation) =>
+        representation.segmentationRepresentationUID ===
+        segmentationRepresentationUID
+    );
+
+    if (foundRepresentation) {
+      return toolGroupId;
+    }
+  }
+}
+
 /**
  * Add the given segmentation representation data to the given tool group state. It fires
  * SEGMENTATION_REPRESENTATION_MODIFIED event if not suppressed.
@@ -368,6 +450,22 @@ function removeSegmentationRepresentation(
   );
 }
 
+/**
+ * Removes all segmentation representations associated with a tool group.
+ * @param toolGroupId - The ID of the tool group.
+ */
+function removeSegmentationRepresentations(toolGroupId: string): void {
+  const segmentationRepresentations =
+    getSegmentationRepresentations(toolGroupId) || [];
+
+  segmentationRepresentations.forEach((representation) => {
+    removeSegmentationRepresentation(
+      toolGroupId,
+      representation.segmentationRepresentationUID
+    );
+  });
+}
+
 /**
  * Add a color LUT to the segmentation state manager
  * @param colorLUT - The color LUT array to add.
@@ -383,17 +481,22 @@ function removeColorLUT(colorLUTIndex: number): void {
  * @param index - The index of the color lut to retrieve.
  * @returns A ColorLUT array.
  */
-function getColorLUT(index: number): ColorLUT | undefined {
+function getColorLUT(index: number): Types.ColorLUT | undefined {
   const segmentationStateManager = getDefaultSegmentationStateManager();
   return segmentationStateManager.getColorLUT(index);
 }
 
+function getNextColorLUTIndex(): number {
+  const segmentationStateManager = getDefaultSegmentationStateManager();
+  return segmentationStateManager.getNextColorLUTIndex();
+}
+
 /**
  * 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 {
+function addColorLUT(colorLUT: Types.ColorLUT, index: number): void {
   const segmentationStateManager = getDefaultSegmentationStateManager();
   segmentationStateManager.addColorLUT(colorLUT, index);
   // Todo: trigger event color LUT added
@@ -410,6 +513,7 @@ export {
   getSegmentationRepresentations,
   addSegmentationRepresentation,
   removeSegmentationRepresentation,
+  removeSegmentationRepresentations,
   // config
   getToolGroupSpecificConfig,
   setToolGroupSpecificConfig,
@@ -423,8 +527,13 @@ export {
   getToolGroupIdsWithSegmentation,
   getAllSegmentationRepresentations,
   getSegmentationRepresentationByUID,
+  getSegmentationIdRepresentations,
   // color
   addColorLUT,
   getColorLUT,
+  getNextColorLUTIndex,
   removeColorLUT,
+  //
+  findSegmentationRepresentationByUID,
+  getToolGroupIdFromSegmentationRepresentationUID,
 };

package/src/stateManagement/segmentation/triggerSegmentationEvents.ts

@@ -12,6 +12,7 @@ import {
   SegmentationRepresentationRemovedEventDetail,
   SegmentationRemovedEventDetail,
 } from '../../types/EventTypes';
+import { setSegmentationDirty } from '../../utilities/segmentation/getUniqueSegmentIndices';
 
 /**
  * Trigger an event that a segmentation is removed
@@ -143,6 +144,10 @@ function triggerSegmentationDataModified(
     modifiedSlicesToUse,
   };
 
+  // set it to dirty to force the next call to getUniqueSegmentIndices to
+  // recalculate the segment indices
+  setSegmentationDirty(segmentationId);
+
   triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
 }
 

package/src/store/SynchronizerManager/Synchronizer.ts

@@ -17,6 +17,7 @@ class Synchronizer {
   //
   private _enabled: boolean;
   private _eventName: string;
+  private _auxiliaryEventNames: string[];
   private _eventHandler: ISynchronizerEventHandler;
   private _ignoreFiredEvents: boolean;
   private _sourceViewports: Array<Types.IViewportId>;
@@ -38,6 +39,7 @@ class Synchronizer {
     this._sourceViewports = [];
     this._targetViewports = [];
     this._options = options || {};
+    this._auxiliaryEventNames = this._options.auxiliaryEventNames || [];
 
     //
     this.id = synchronizerId;
@@ -64,6 +66,13 @@ class Synchronizer {
     this._viewportOptions[viewportId] = options;
   }
 
+  /**
+   * Sets a synchronizer enabled
+   */
+  public setEnabled(enabled: boolean) {
+    this._enabled = enabled;
+  }
+
   /** Gets the options for the given viewport id */
   public getOptions(viewportId: string): Record<string, unknown> | undefined {
     return this._viewportOptions[viewportId];
@@ -89,11 +98,26 @@ class Synchronizer {
 
     const { renderingEngineId, viewportId } = viewportInfo;
 
-    const { element } =
+    const viewport =
       getRenderingEngine(renderingEngineId).getViewport(viewportId);
 
-    // @ts-ignore
+    if (!viewport) {
+      console.warn(
+        `Synchronizer.addSource: No viewport for ${renderingEngineId} ${viewportId}`
+      );
+      return;
+    }
+
+    const element = viewport.element;
+
     element.addEventListener(this._eventName, this._onEvent.bind(this));
+
+    if (this._auxiliaryEventNames.length) {
+      this._auxiliaryEventNames.forEach((eventName) => {
+        element.addEventListener(eventName, this._onEvent.bind(this));
+      });
+    }
+
     this._updateDisableHandlers();
 
     this._sourceViewports.push(viewportInfo);
@@ -157,8 +181,16 @@ class Synchronizer {
     const element = _getViewportElement(viewportInfo);
 
     this._sourceViewports.splice(index, 1);
-    // @ts-ignore
+
+    //@ts-ignore
     element.removeEventListener(this._eventName, this._eventHandler);
+
+    if (this._auxiliaryEventNames) {
+      this._auxiliaryEventNames.forEach((eventName) => {
+        //@ts-ignore
+        element.removeEventListener(eventName, this._eventHandler);
+      });
+    }
     this._updateDisableHandlers();
   }
 
@@ -215,15 +247,19 @@ class Synchronizer {
         if (targetIsSource) {
           continue;
         }
-        promises.push(
-          this._eventHandler(
-            this,
-            sourceViewport,
-            targetViewport,
-            sourceEvent,
-            this._options
-          )
+        const result = this._eventHandler(
+          this,
+          sourceViewport,
+          targetViewport,
+          sourceEvent,
+          this._options
         );
+
+        // if the result is a promise, then add it to the list of promises
+        // to wait for before setting _ignoreFiredEvents to false
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
       }
     } catch (ex) {
       console.warn(`Synchronizer, for: ${this._eventName}`, ex);
@@ -290,15 +326,19 @@ class Synchronizer {
     };
 
     viewports.forEach(function (vUid) {
-      const renderingEngine = getRenderingEngine(
-        vUid.renderingEngineId
-      ).getViewport(vUid.viewportId);
+      const renderingEngine = getRenderingEngine(vUid.renderingEngineId);
 
       if (!renderingEngine) {
         return;
       }
 
-      const { element } = renderingEngine;
+      const viewport = renderingEngine.getViewport(vUid.viewportId);
+
+      if (!viewport) {
+        return;
+      }
+
+      const { element } = viewport;
 
       element.removeEventListener(
         Enums.Events.ELEMENT_DISABLED,

package/src/store/ToolGroupManager/ToolGroup.ts

@@ -1,5 +1,6 @@
 import { MouseBindings, ToolModes } from '../../enums';
 import get from 'lodash.get';
+import cloneDeep from 'lodash.clonedeep';
 import {
   triggerEvent,
   eventTarget,
@@ -7,7 +8,6 @@ import {
   getRenderingEngines,
   getEnabledElementByIds,
   Settings,
-  utilities as csUtils,
 } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import { Events } from '../../enums';
@@ -30,6 +30,8 @@ import { initElementCursor } from '../../cursors/elementCursor';
 
 const { Active, Passive, Enabled, Disabled } = ToolModes;
 
+const PRIMARY_BINDINGS = [{ mouseButton: MouseBindings.Primary }];
+
 /**
  * ToolGroup class which is a container for tools and their modes and states.
  * In Cornerstone3DTools, you need to create a tool group in order to use the
@@ -46,6 +48,12 @@ export default class ToolGroup implements IToolGroup {
   id: string;
   viewportsInfo = [];
   toolOptions = {};
+  currentActivePrimaryToolName: string | null = null;
+  prevActivePrimaryToolName: string | null = null;
+  /**
+   * Options used for restoring a tool
+   */
+  restoreToolOptions = {};
   _toolInstances = {};
 
   constructor(id: string) {
@@ -83,6 +91,25 @@ export default class ToolGroup implements IToolGroup {
 
     return toolInstance;
   }
+
+  /**
+   * Retrieves the tool instances associated with this tool group.
+   *
+   * @returns A record containing the tool instances, where the keys are the tool names and the values are the tool instances.
+   */
+  public getToolInstances(): Record<string, any> {
+    return this._toolInstances;
+  }
+
+  /**
+   * Check if a tool is already added to the tool group
+   * @param toolName - Tool name
+   * @returns True if the tool is already added or false otherwise
+   */
+  hasTool(toolName: string): boolean {
+    return !!this._toolInstances[toolName];
+  }
+
   /**
    * Add a tool to the tool group with the given tool name and tool configuration.
    * Note that adding a tool to a tool group will not automatically set the tool
@@ -181,6 +208,10 @@ export default class ToolGroup implements IToolGroup {
    * @param renderingEngineId - The rendering engine to use.
    */
   public addViewport(viewportId: string, renderingEngineId?: string): void {
+    if (typeof viewportId !== 'string') {
+      throw new Error('viewportId must be defined and be a string');
+    }
+
     const renderingEngines = getRenderingEngines();
 
     if (!renderingEngineId && renderingEngines.length > 1) {
@@ -208,6 +239,14 @@ export default class ToolGroup implements IToolGroup {
     if (runtimeSettings.get('useCursors')) {
       this.setViewportsCursorByToolName(toolName);
     }
+
+    const eventDetail = {
+      toolGroupId: this.id,
+      viewportId,
+      renderingEngineId: renderingEngineUIDToUse,
+    };
+
+    triggerEvent(eventTarget, Events.TOOLGROUP_VIEWPORT_ADDED, eventDetail);
   }
 
   /**
@@ -242,6 +281,14 @@ export default class ToolGroup implements IToolGroup {
         this.viewportsInfo.splice(indices[i], 1);
       }
     }
+
+    const eventDetail = {
+      toolGroupId: this.id,
+      viewportId,
+      renderingEngineId,
+    };
+
+    triggerEvent(eventTarget, Events.TOOLGROUP_VIEWPORT_REMOVED, eventDetail);
   }
 
   public setActiveStrategy(toolName: string, strategyName: string) {
@@ -269,7 +316,10 @@ export default class ToolGroup implements IToolGroup {
     }
 
     if (mode === ToolModes.Active) {
-      this.setToolActive(toolName, options);
+      this.setToolActive(
+        toolName,
+        options || this.restoreToolOptions[toolName]
+      );
       return;
     }
 
@@ -375,6 +425,18 @@ export default class ToolGroup implements IToolGroup {
       }
     }
 
+    // if it is a primary tool binding, we should store it as the previous primary tool
+    // so that we can restore it when the tool is disabled if desired
+    if (this._hasMousePrimaryButtonBinding(toolBindingsOptions)) {
+      if (this.prevActivePrimaryToolName === null) {
+        this.prevActivePrimaryToolName = toolName;
+      } else {
+        this.prevActivePrimaryToolName = this.currentActivePrimaryToolName;
+      }
+
+      this.currentActivePrimaryToolName = toolName;
+    }
+
     if (typeof toolInstance.onSetToolActive === 'function') {
       toolInstance.onSetToolActive();
     }
@@ -397,8 +459,14 @@ export default class ToolGroup implements IToolGroup {
    * - Renders data if the tool has a `renderAnnotation` method.
    *
    * @param toolName - tool name
+   * @param options - Options used when setting the tool as passive
+   *  - removeAllBindings: only the primary button bindings are removed but
+   *  if this parameter is set to true all bindings are removed.
    */
-  public setToolPassive(toolName: string): void {
+  public setToolPassive(
+    toolName: string,
+    options?: { removeAllBindings?: boolean | IToolBinding[] }
+  ): void {
     const toolInstance = this._toolInstances[toolName];
 
     if (toolInstance === undefined) {
@@ -422,12 +490,18 @@ export default class ToolGroup implements IToolGroup {
       }
     );
 
-    const defaultMousePrimary = this.getDefaultMousePrimary();
+    const matchBindings = Array.isArray(options?.removeAllBindings)
+      ? options.removeAllBindings
+      : this.getDefaultPrimaryBindings();
 
     // Remove the primary button bindings without modifiers, if they exist
     toolOptions.bindings = toolOptions.bindings.filter(
       (binding) =>
-        binding.mouseButton !== defaultMousePrimary || binding.modifierKey
+        options?.removeAllBindings !== true &&
+        !matchBindings.some((matchBinding) =>
+          hasSameBinding(binding, matchBinding)
+        )
+      //(binding.mouseButton !== defaultMousePrimary || binding.modifierKey)
     );
     // If there are other bindings, set the tool to be active
     let mode = Passive;
@@ -509,6 +583,8 @@ export default class ToolGroup implements IToolGroup {
       mode: Disabled,
     };
 
+    this.restoreToolOptions[toolName] = this.toolOptions[toolName];
+
     this.toolOptions[toolName] = toolOptions;
     toolInstance.mode = Disabled;
 
@@ -621,7 +697,8 @@ export default class ToolGroup implements IToolGroup {
     configuration: ToolConfiguration,
     overwrite?: boolean
   ): boolean {
-    if (this._toolInstances[toolName] === undefined) {
+    const toolInstance = this._toolInstances[toolName];
+    if (toolInstance === undefined) {
       console.warn(
         `Tool ${toolName} not present, can't set tool configuration.`
       );
@@ -636,13 +713,14 @@ export default class ToolGroup implements IToolGroup {
       // We should not deep copy here, it is the job of the application to
       // deep copy the configuration before passing it to the toolGroup, otherwise
       // some strange appending behaviour happens for the arrays
-      _configuration = Object.assign(
-        this._toolInstances[toolName].configuration,
-        configuration
-      );
+      _configuration = Object.assign(toolInstance.configuration, configuration);
     }
 
-    this._toolInstances[toolName].configuration = _configuration;
+    toolInstance.configuration = _configuration;
+
+    if (typeof toolInstance.onSetToolConfiguration === 'function') {
+      toolInstance.onSetToolConfiguration();
+    }
 
     this._renderViewports();
 
@@ -651,12 +729,20 @@ export default class ToolGroup implements IToolGroup {
 
   /**
    * Returns the default mouse primary button.
-   *
    */
   public getDefaultMousePrimary(): MouseBindings {
     return MouseBindings.Primary;
   }
 
+  /**
+   * Gets an array of bindings that is the full primary binding.
+   * Currently this is just the primary mouse button, but may be extended in the
+   * future to include touch or other binding types.
+   */
+  public getDefaultPrimaryBindings(): IToolBinding[] {
+    return PRIMARY_BINDINGS;
+  }
+
   /**
    * Get the configuration of tool. It returns only the config for the given path (in case exists).
    * ConfigurationPath is the the path of the property to get separated by '.'.
@@ -665,7 +751,7 @@ export default class ToolGroup implements IToolGroup {
    * getToolConfiguration('LengthTool', 'firstLevel.secondLevel')
    * // get from LengthTool instance the configuration value as being LengthToolInstance[configuration][firstLevel][secondLevel]
    */
-  getToolConfiguration(toolName: string, configurationPath: string): any {
+  getToolConfiguration(toolName: string, configurationPath?: string): any {
     if (this._toolInstances[toolName] === undefined) {
       console.warn(
         `Tool ${toolName} not present, can't set tool configuration.`
@@ -673,14 +759,21 @@ export default class ToolGroup implements IToolGroup {
       return;
     }
 
-    const _configuration = get(
-      this._toolInstances[toolName].configuration,
-      configurationPath
-    );
+    const _configuration =
+      get(this._toolInstances[toolName].configuration, configurationPath) ||
+      this._toolInstances[toolName].configuration;
 
     return structuredClone(_configuration);
   }
 
+  /**
+   * Gets the name of the previously active tool.
+   * @returns The name of the previously active tool.
+   */
+  public getPrevActivePrimaryToolName(): string {
+    return this.prevActivePrimaryToolName;
+  }
+
   /**
    *
    * @param newToolGroupId - Id of the new (clone) tool group
@@ -730,12 +823,9 @@ export default class ToolGroup implements IToolGroup {
    * @returns A boolean value.
    */
   private _hasMousePrimaryButtonBinding(toolOptions) {
-    const defaultMousePrimary = this.getDefaultMousePrimary();
-
-    return toolOptions?.bindings?.some(
-      (binding) =>
-        binding.mouseButton === defaultMousePrimary &&
-        binding.modifierKey === undefined
+    const primaryBindings = this.getDefaultPrimaryBindings();
+    return toolOptions?.bindings?.some((binding) =>
+      primaryBindings.some((primary) => hasSameBinding(binding, primary))
     );
   }
 
@@ -770,6 +860,9 @@ export default class ToolGroup implements IToolGroup {
   }
 }
 
+/**
+ * Figure out if the two bindings are the same
+ */
 function hasSameBinding(
   binding1: IToolBinding,
   binding2: IToolBinding
@@ -777,6 +870,9 @@ function hasSameBinding(
   if (binding1.mouseButton !== binding2.mouseButton) {
     return false;
   }
+  if (binding1.numTouchPoints !== binding2.numTouchPoints) {
+    return false;
+  }
 
   return binding1.modifierKey === binding2.modifierKey;
 }

package/src/store/ToolGroupManager/getToolGroupForViewport.ts

@@ -1,3 +1,4 @@
+import { getRenderingEngines } from '@cornerstonejs/core';
 import { state } from '../index';
 import { IToolGroup } from '../../types';
 
@@ -17,8 +18,14 @@ import { IToolGroup } from '../../types';
  */
 function getToolGroupForViewport(
   viewportId: string,
-  renderingEngineId: string
+  renderingEngineId?: string
 ): IToolGroup | undefined {
+  if (!renderingEngineId) {
+    renderingEngineId = getRenderingEngines().find((re) =>
+      re.getViewports().find((vp) => vp.id === viewportId)
+    )?.id;
+  }
+
   const toolGroupFilteredByIds = state.toolGroups.filter((tg) =>
     tg.viewportsInfo.some(
       (vp) =>