@cornerstonejs/tools 2.0.0-beta.5 → 2.0.0-beta.7

package/src/stateManagement/annotation/AnnotationGroup.ts

@@ -0,0 +1,120 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
+import Events from '../../enums/Events';
+import { getAnnotation } from './annotationState';
+
+export type BaseEventDetail = {
+  viewportId: string;
+  renderingEngineId: string;
+};
+
+/**
+ * An annotation group
+ */
+
+export default class AnnotationGroup {
+  private annotationUIDs = new Set<string>();
+  private _isVisible = true;
+
+  public visibleFilter: (uid: string) => boolean;
+
+  constructor() {
+    this.visibleFilter = this.unboundVisibleFilter.bind(this);
+  }
+
+  /**
+   * Returns true if other groups are free to hide this annotation.
+   * That is, if the annotation is not a member or is hidden.
+   */
+  protected unboundVisibleFilter(uid: string): boolean {
+    return !this._isVisible || !this.annotationUIDs.has(uid);
+  }
+
+  public has(uid: string): boolean {
+    return this.annotationUIDs.has(uid);
+  }
+  /**
+   * Sets whether annotations belonging to this group are visible or not.
+   * If there are multiple groups, then the set visible false should be called
+   * before before re-enabling the other groups with setVisible true.
+   */
+  public setVisible(
+    isVisible = true,
+    baseEvent: BaseEventDetail,
+    filter?: (annotationUID: string) => boolean
+  ) {
+    if (this._isVisible === isVisible) {
+      return;
+    }
+    this._isVisible = isVisible;
+    this.annotationUIDs.forEach((uid) => {
+      const annotation = getAnnotation(uid);
+      if (!annotation) {
+        this.annotationUIDs.delete(uid);
+        return;
+      }
+      if (annotation.isVisible === isVisible) {
+        return;
+      }
+      if (!isVisible && filter?.(uid) === false) {
+        return;
+      }
+      annotation.isVisible = isVisible;
+      const eventDetail = {
+        ...baseEvent,
+        annotation,
+      };
+      triggerEvent(eventTarget, Events.ANNOTATION_MODIFIED, eventDetail);
+    });
+  }
+
+  public get isVisible() {
+    return this._isVisible;
+  }
+
+  /** Finds the nearby/next annotation in the given direction */
+  public findNearby(uid: string, direction: 1) {
+    const uids = [...this.annotationUIDs];
+    if (uids.length === 0) {
+      return null;
+    }
+    if (!uid) {
+      return uids[direction === 1 ? 0 : uids.length - 1];
+    }
+    const index = uids.indexOf(uid);
+    if (
+      index === -1 ||
+      index + direction < 0 ||
+      index + direction >= uids.length
+    ) {
+      return null;
+    }
+    return uids[index + direction];
+  }
+
+  /**
+   * Adds the annotation to the group
+   * Does NOT change the visibility status of the annotation.
+   */
+  public add(...annotationUIDs: string[]) {
+    annotationUIDs.forEach((annotationUID) =>
+      this.annotationUIDs.add(annotationUID)
+    );
+  }
+
+  /**
+   * Removes the annotation from the group.
+   * Does not affect the visibility status of the annotation.
+   */
+  public remove(...annotationUIDs: string[]) {
+    annotationUIDs.forEach((annotationUID) =>
+      this.annotationUIDs.delete(annotationUID)
+    );
+  }
+
+  /**
+   * Removes everything from the group.
+   */
+  public clear() {
+    this.annotationUIDs.clear();
+  }
+}

package/src/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.ts

@@ -18,6 +18,11 @@ import {
 import { checkAndDefineIsLockedProperty } from './annotationLocking';
 import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 
+import {
+  checkAndDefineTextBoxProperty,
+  checkAndDefineCachedStatsProperty,
+} from './utilities/defineProperties';
+
 /**
  * This is the default annotation manager. It stores annotations by default
  * based on the FrameOfReferenceUID. However, it is possible to override the
@@ -126,6 +131,7 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
    * @param toolName - Optional. The name of the tool to retrieve annotations for.
    * @returns The annotations associated with the specified group (default FrameOfReferenceUID) and tool,
    * or all annotations for the group (FrameOfReferenceUID) if the tool name is not provided.
+   * WARNING: The list returned here is internal tool data, not a copy, so do NOT modify it.
    */
   getAnnotations = (
     groupKey: string,
@@ -138,7 +144,9 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     }
 
     if (toolName) {
-      return annotations[groupKey][toolName];
+      return annotations[groupKey][toolName]
+        ? annotations[groupKey][toolName]
+        : [];
     }
 
     return annotations[groupKey];
@@ -232,6 +240,8 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     toolSpecificAnnotations.push(annotation);
     checkAndDefineIsLockedProperty(annotation);
     checkAndDefineIsVisibleProperty(annotation);
+    checkAndDefineTextBoxProperty(annotation);
+    checkAndDefineCachedStatsProperty(annotation);
   };
 
   /**
@@ -274,16 +284,34 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
    *
    * @param groupKey - The group key to remove annotations for (in default manager it is FrameOfReferenceUID).
    * @param toolName - Optional. The name of the tool to remove annotations for.
+   *
+   * @returns The removed annotations
    */
-  removeAnnotations = (groupKey: string, toolName?: string): void => {
+  removeAnnotations = (groupKey: string, toolName?: string): Annotations => {
     const annotations = this.annotations;
-    if (annotations[groupKey]) {
-      if (toolName) {
-        delete annotations[groupKey][toolName];
-      } else {
-        delete annotations[groupKey];
+    const removedAnnotations = [];
+
+    if (!annotations[groupKey]) {
+      return removedAnnotations;
+    }
+
+    if (toolName) {
+      const annotationsForTool = annotations[groupKey][toolName];
+      for (const annotation of annotationsForTool) {
+        this.removeAnnotation(annotation.annotationUID);
+        removedAnnotations.push(annotation);
+      }
+    } else {
+      for (const toolName in annotations[groupKey]) {
+        const annotationsForTool = annotations[groupKey][toolName];
+        for (const annotation of annotationsForTool) {
+          this.removeAnnotation(annotation.annotationUID);
+          removedAnnotations.push(annotation);
+        }
       }
     }
+
+    return removedAnnotations;
   };
 
   /**
@@ -364,6 +392,17 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     }
   };
 
+  /**
+   * return all annotations as a single array
+   */
+  getAllAnnotations = (): Annotations => {
+    return Object.values(this.annotations)
+      .map((frameOfReferenceSpecificAnnotations) =>
+        Object.values(frameOfReferenceSpecificAnnotations)
+      )
+      .flat(2);
+  };
+
   /**
    * A function that returns the number of all annotations in the annotation state
    *
@@ -385,9 +424,18 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
 
   /**
    * Removes all annotations in the annotation state.
+   *
+   * @returns The removed annotations
    */
-  removeAllAnnotations = (): void => {
-    this.annotations = {};
+  removeAllAnnotations = (): Annotations => {
+    const removedAnnotations = [];
+
+    for (const annotation of this.getAllAnnotations()) {
+      this.removeAnnotation(annotation.annotationUID);
+      removedAnnotations.push(annotation);
+    }
+
+    return removedAnnotations;
   };
 }
 

package/src/stateManagement/annotation/annotationSelection.ts

@@ -94,7 +94,7 @@ function getAnnotationsSelected(): Array<string> {
 function getAnnotationsSelectedByToolName(toolName: string): Array<string> {
   return getAnnotationsSelected().filter((annotationUID) => {
     const annotation = getAnnotation(annotationUID);
-    return annotation.metadata.toolName === toolName;
+    return annotation?.metadata?.toolName === toolName;
   });
 }
 

package/src/stateManagement/annotation/annotationState.ts

@@ -1,16 +1,12 @@
-import {
-  triggerEvent,
-  eventTarget,
-  utilities as csUtils,
-} from '@cornerstonejs/core';
-import { Events } from '../../enums';
+import { utilities as csUtils } from '@cornerstonejs/core';
 import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
 import { Annotations, Annotation } from '../../types/AnnotationTypes';
-import { AnnotationRemovedEventDetail } from '../../types/EventTypes';
 import { AnnotationGroupSelector } from '../../types';
+
 import {
   triggerAnnotationAddedForElement,
   triggerAnnotationAddedForFOR,
+  triggerAnnotationRemoved,
 } from './helpers/state';
 
 // our default annotation manager
@@ -59,6 +55,86 @@ function getAnnotations(
   return manager.getAnnotations(groupKey, toolName) as Annotations;
 }
 
+function getAllAnnotations(): Annotations {
+  const manager = getAnnotationManager();
+  return manager.getAllAnnotations();
+}
+
+/**
+ * Removes the association between the annotation passed as parameter and its
+ * parent in case it has one (eg: contour holes).
+ * @param annotation - Annotation
+ */
+function clearParentAnnotation(annotation: Annotation): void {
+  const { annotationUID: childUID, parentAnnotationUID } = annotation;
+
+  if (!parentAnnotationUID) {
+    return;
+  }
+
+  const parentAnnotation = getAnnotation(parentAnnotationUID);
+  const childUIDIndex = parentAnnotation.childAnnotationUIDs.indexOf(childUID);
+
+  parentAnnotation.childAnnotationUIDs.splice(childUIDIndex, 1);
+  annotation.parentAnnotationUID = undefined;
+}
+
+/**
+ * Creates a parent/child association between annotations.
+ * A annotation may have only one parent and multiple children (eg: a contour
+ * may have multiple holes in it).
+ * @param parentAnnotation - Parent annotation
+ * @param childAnnotation - Child annotation
+ */
+function addChildAnnotation(
+  parentAnnotation: Annotation,
+  childAnnotation: Annotation
+): void {
+  const { annotationUID: parentUID } = parentAnnotation;
+  const { annotationUID: childUID } = childAnnotation;
+
+  // Make sure it is not associated with any other tool
+  clearParentAnnotation(childAnnotation);
+
+  if (!parentAnnotation.childAnnotationUIDs) {
+    parentAnnotation.childAnnotationUIDs = [];
+  }
+
+  // Check if it is already a child
+  if (parentAnnotation.childAnnotationUIDs.includes(childUID)) {
+    return;
+  }
+
+  parentAnnotation.childAnnotationUIDs.push(childUID);
+  childAnnotation.parentAnnotationUID = parentUID;
+}
+
+/**
+ * Returns the parent annotation of a given one since annotations can be
+ * associated in a parent/child way (eg: polyline holes)
+ * @param annotation - Annotation
+ * @returns Parent annotation
+ */
+function getParentAnnotation(annotation: Annotation) {
+  return annotation.parentAnnotationUID
+    ? getAnnotation(annotation.parentAnnotationUID)
+    : undefined;
+}
+
+/**
+ * Returns all children annotation of a given one since annotations can be
+ * associated in a parent/child way (eg: polyline holes)
+ * @param annotation - Annotation
+ * @returns Child annotations
+ */
+function getChildAnnotations(annotation: Annotation) {
+  return (
+    annotation.childAnnotationUIDs?.map((childAnnotationUID) =>
+      getAnnotation(childAnnotationUID)
+    ) ?? []
+  );
+}
+
 /**
  * Add the annotation to the annotation manager along with the options that is
  * used to filter the annotation manager and the annotation group that
@@ -75,23 +151,23 @@ function addAnnotation(
   annotation: Annotation,
   annotationGroupSelector: AnnotationGroupSelector
 ): string {
-  if (annotation.annotationUID === undefined) {
+  if (!annotation.annotationUID) {
     annotation.annotationUID = csUtils.uuidv4() as string;
   }
 
   const manager = getAnnotationManager();
-  const groupKey = manager.getGroupKey(annotationGroupSelector);
-
-  manager.addAnnotation(annotation, groupKey);
 
   // if the annotation manager selector is an element, trigger the
   // annotation added event for that element.
   if (annotationGroupSelector instanceof HTMLDivElement) {
+    const groupKey = manager.getGroupKey(annotationGroupSelector);
+    manager.addAnnotation(annotation, groupKey);
     triggerAnnotationAddedForElement(annotation, annotationGroupSelector);
   } else {
     // if no element is provided, render all viewports that have the
     // same frame of reference.
     // Todo: we should do something else here for other types of annotation managers.
+    manager.addAnnotation(annotation);
     triggerAnnotationAddedForFOR(annotation);
   }
 
@@ -126,6 +202,9 @@ function getNumberOfAnnotations(
  * @param annotationUID - The unique identifier for the annotation.
  */
 function removeAnnotation(annotationUID: string): void {
+  if (!annotationUID) {
+    return;
+  }
   const manager = getAnnotationManager();
   const annotation = manager.getAnnotation(annotationUID);
 
@@ -134,17 +213,14 @@ function removeAnnotation(annotationUID: string): void {
     return;
   }
 
-  manager.removeAnnotation(annotationUID);
+  // Remove all child annotations first
+  annotation.childAnnotationUIDs?.forEach((childAnnotationUID) =>
+    removeAnnotation(childAnnotationUID)
+  );
 
-  // trigger annotation removed
-  const eventType = Events.ANNOTATION_REMOVED;
-
-  const eventDetail: AnnotationRemovedEventDetail = {
-    annotation,
-    annotationManagerUID: manager.uid,
-  };
+  manager.removeAnnotation(annotationUID);
 
-  triggerEvent(eventTarget, eventType, eventDetail);
+  triggerAnnotationRemoved({ annotation, annotationManagerUID: manager.uid });
 }
 
 /**
@@ -163,18 +239,70 @@ function getAnnotation(annotationUID: string): Annotation {
  */
 function removeAllAnnotations(): void {
   const manager = getAnnotationManager();
-  manager.removeAllAnnotations();
+  const removedAnnotations = manager.removeAllAnnotations();
+
+  for (const annotation of removedAnnotations) {
+    triggerAnnotationRemoved({
+      annotation,
+      annotationManagerUID: manager.uid,
+    });
+  }
+}
+
+/**
+ * Removes all annotations associated with the specified group (FrameOfReferenceUID) and tool, or
+ * all annotations for the group (FrameOfReferenceUID) if the tool name is not provided.
+ * @param toolName - Optional. The name of the tool to remove annotations for.
+ * @param annotationGroupSelector - The group (FrameOfReferenceUID) to remove annotations for.
+ */
+function removeAnnotations(
+  toolName: string,
+  annotationGroupSelector: AnnotationGroupSelector
+): void {
+  const manager = getAnnotationManager();
+  const groupKey = manager.getGroupKey(annotationGroupSelector);
+  const removedAnnotations = manager.removeAnnotations(groupKey, toolName);
+
+  for (const annotation of removedAnnotations) {
+    triggerAnnotationRemoved({
+      annotation,
+      annotationManagerUID: manager.uid,
+    });
+  }
+}
+
+/**
+ * Invalidate current and all parent annotations (eg: contour holes)
+ * @param annotation - Annotation
+ */
+function invalidateAnnotation(annotation: Annotation): void {
+  let currAnnotation = annotation;
+
+  while (currAnnotation) {
+    currAnnotation.invalidated = true;
+
+    currAnnotation = currAnnotation.parentAnnotationUID
+      ? getAnnotation(currAnnotation.parentAnnotationUID)
+      : undefined;
+  }
 }
 
 export {
+  getAllAnnotations,
   getAnnotations,
+  getParentAnnotation,
+  getChildAnnotations,
+  clearParentAnnotation,
+  addChildAnnotation,
   getNumberOfAnnotations,
   addAnnotation,
   getAnnotation,
   removeAnnotation,
+  removeAnnotations,
   removeAllAnnotations,
   // annotation manager
   setAnnotationManager,
   getAnnotationManager,
   resetAnnotationManager,
+  invalidateAnnotation,
 };

package/src/stateManagement/annotation/config/ToolStyle.ts

@@ -193,56 +193,71 @@ class ToolStyle {
     toolName: string
   ) {
     if (annotationUID) {
-      const styles = this.getAnnotationToolStyles(annotationUID);
+      const annotationToolStyles = this.getAnnotationToolStyles(annotationUID);
 
-      if (styles) {
+      if (annotationToolStyles) {
         // check first in the toolSpecific styles
-        if (styles[property]) {
-          return styles[property];
+        if (annotationToolStyles[property] !== undefined) {
+          return annotationToolStyles[property];
         }
       }
     }
 
     if (viewportId) {
-      const styles = this.getViewportToolStyles(viewportId);
+      const viewportToolStyles = this.getViewportToolStyles(viewportId);
 
-      if (styles) {
+      if (viewportToolStyles) {
         // check if we have the viewportId specific style
         // check first in the toolSpecific styles
-        if (styles[toolName] && styles[toolName][property]) {
-          return styles[toolName][property];
+        if (
+          viewportToolStyles[toolName] &&
+          viewportToolStyles[toolName][property] !== undefined
+        ) {
+          return viewportToolStyles[toolName][property];
         }
 
         // check if we have the style in the viewport specific global viewportSpecificStyles
-        if (styles.global && styles.global[property]) {
-          return styles.global[property];
+        if (
+          viewportToolStyles.global &&
+          viewportToolStyles.global[property] !== undefined
+        ) {
+          return viewportToolStyles.global[property];
         }
       }
     }
 
     if (toolGroupId) {
-      const styles = this.getToolGroupToolStyles(toolGroupId);
+      const toolGroupToolStyles = this.getToolGroupToolStyles(toolGroupId);
 
-      if (styles) {
+      if (toolGroupToolStyles) {
         // check first in the toolSpecific styles
-        if (styles[toolName] && styles[toolName][property]) {
-          return styles[toolName][property];
+        if (
+          toolGroupToolStyles[toolName] &&
+          toolGroupToolStyles[toolName][property] !== undefined
+        ) {
+          return toolGroupToolStyles[toolName][property];
         }
 
         // check if we have the style in the toolGroup specific global styles
-        if (styles.global && styles.global[property]) {
-          return styles.global[property];
+        if (
+          toolGroupToolStyles.global &&
+          toolGroupToolStyles.global[property] !== undefined
+        ) {
+          return toolGroupToolStyles.global[property];
         }
       }
     }
 
     const globalStyles = this.getDefaultToolStyles();
 
-    if (globalStyles[toolName] && globalStyles[toolName][property]) {
+    if (
+      globalStyles[toolName] &&
+      globalStyles[toolName][property] !== undefined
+    ) {
       return globalStyles[toolName][property];
     }
 
-    if (globalStyles.global && globalStyles.global[property]) {
+    if (globalStyles.global && globalStyles.global[property] !== undefined) {
       return globalStyles.global[property];
     }
   }

package/src/stateManagement/annotation/config/getState.ts

@@ -5,9 +5,19 @@ import { AnnotationStyleStates } from '../../../enums';
 
 /**
  * Given a Annotation object, return the annotationStyle State that it
- * should be in based on its data
+ * should be in based on its data.
+ * The ordering of states is:
+ *   * Highlighted
+ *   * Selected
+ *   * Locked
+ *   * Autogenerated
+ *   * Default
+ * So the first one that applies will be returned.
+ * For the autogenerated state, it depends on the autoGenerated flag on the
+ * annotation, so once that is gone/false, the annotation will go to default.
+ *
  * @param annotation - The annotation that we want to style.
- * @returns The state of the annotation whether it is Default, Highlighted, Locked, or Selected.
+ * @returns The state of the annotation whether it is Default, Highlighted, Locked, Selected, or AutoGenerated.
  */
 function getState(annotation?: Annotation): AnnotationStyleStates {
   if (annotation) {
@@ -22,6 +32,10 @@ function getState(annotation?: Annotation): AnnotationStyleStates {
     if (isAnnotationLocked(annotation)) {
       return AnnotationStyleStates.Locked;
     }
+
+    if (annotation.data && annotation.autoGenerated) {
+      return AnnotationStyleStates.AutoGenerated;
+    }
   }
 
   return AnnotationStyleStates.Default;