Skip to main content

Types

Index

Namespaces

Interfaces

Type Aliases

Namespaces

AnnotationStyle

AnnotationStyle:

AnnotationStyle

AnnotationStyle: { [ key in `${Properties}${States}${Modes}` ]?: string }

StyleConfig

StyleConfig: { annotations?: {}; default: ToolStyleConfig; toolGroups?: {}; viewports?: {} }

Type declaration

  • optionalannotations?: {}
    • [annotationUID string]: AnnotationStyle
  • default: ToolStyleConfig
  • optionaltoolGroups?: {}
    • [toolGroupId string]: ToolStyleConfig
  • optionalviewports?: {}
    • [viewportId string]: ToolStyleConfig

StyleSpecifier

StyleSpecifier: { annotationUID?: string; toolGroupId?: string; toolName?: string; viewportId?: string }

Type declaration

  • optionalannotationUID?: string
  • optionaltoolGroupId?: string
  • optionaltoolName?: string
  • optionalviewportId?: string

ToolStyleConfig

ToolStyleConfig: {} & { global?: AnnotationStyle }

CINETypes

CINETypes:

ToolData

ToolData:

optionaldynamicCineEnabled

dynamicCineEnabled?: boolean

frameTimeVector

frameTimeVector: number[]

framesPerSecond

framesPerSecond: number

ignoreFrameTimeVector

ignoreFrameTimeVector: boolean

intervalId

intervalId: number

lastFrameTimeStamp

lastFrameTimeStamp: number

loop

loop: boolean

reverse

reverse: boolean

speed

speed: number

usingFrameTimeVector

usingFrameTimeVector: boolean

CinePlayContext

CinePlayContext: { currentStepIndex: any; frameTimeVectorEnabled: any; numScrollSteps: any; scroll: any }

Type declaration

  • get currentStepIndex(): number
  • get frameTimeVectorEnabled(): boolean
  • get numScrollSteps(): number
  • scroll: function
    • scroll(delta: number): void

    • Parameters

      • delta: number

      Returns void

PlayClipOptions

PlayClipOptions: { dynamicCineEnabled?: boolean; frameTimeVector?: number[]; frameTimeVectorSpeedMultiplier?: number; framesPerSecond?: number; loop?: boolean; reverse?: boolean }

Type declaration

  • optionaldynamicCineEnabled?: boolean
  • optionalframeTimeVector?: number[]
  • optionalframeTimeVectorSpeedMultiplier?: number
  • optionalframesPerSecond?: number
  • optionalloop?: boolean
  • optionalreverse?: boolean

EventTypes

EventTypes:

AnnotationAddedEventDetail

AnnotationAddedEventDetail: { annotation: Annotation; renderingEngineId: string; viewportId: string }

The data that is passed to the event handler when a new annotation is added to the annotations.

Type declaration

  • annotation: Annotation

    The annotation that is being added to the annotations manager.

  • renderingEngineId: string

    unique id of the rendering engine

  • viewportId: string

    unique id of the viewport

AnnotationAddedEventType

AnnotationAddedEventType: Types.CustomEventType<AnnotationAddedEventDetail>

The AnnotationAdded event type

AnnotationCompletedEventDetail

AnnotationCompletedEventDetail: { annotation: Annotation }

The data that is passed to the event handler when a new annotation is completed drawing on the viewport.

Type declaration

  • annotation: Annotation

    The annotation that is being added to the annotations manager.

AnnotationCompletedEventType

AnnotationCompletedEventType: Types.CustomEventType<AnnotationCompletedEventDetail>

The AnnotationCompleted event type

AnnotationLockChangeEventDetail

AnnotationLockChangeEventDetail: { added: Annotation[]; locked: Annotation[]; removed: Annotation[] }

The data that is passed to the event handler when an annotation lock status changes.

Type declaration

AnnotationLockChangeEventType

AnnotationLockChangeEventType: Types.CustomEventType<AnnotationLockChangeEventDetail>

The AnnotationLockChange event type

AnnotationModifiedEventDetail

AnnotationModifiedEventDetail: { annotation: Annotation; renderingEngineId: string; viewportId: string }

The data that is passed to the event handler when an annotation is modified.

Type declaration

  • annotation: Annotation

    The annotation that is being added to the annotations manager.

  • renderingEngineId: string

    unique id of the rendering engine

  • viewportId: string

    unique id of the viewport

AnnotationModifiedEventType

AnnotationModifiedEventType: Types.CustomEventType<AnnotationModifiedEventDetail>

The AnnotationModified event type

AnnotationRemovedEventDetail

AnnotationRemovedEventDetail: { annotation: Annotation; annotationManagerUID: string }

The data that is passed to the event handler when an annotation is completed drawing.

Type declaration

  • annotation: Annotation

    The annotation that is being added to the annotations manager.

  • annotationManagerUID: string

    annotationManagerUID

AnnotationRemovedEventType

AnnotationRemovedEventType: Types.CustomEventType<AnnotationRemovedEventDetail>

The AnnotationRemoved event type

AnnotationRenderedEventDetail

AnnotationRenderedEventDetail: { element: HTMLDivElement; renderingEngineId: string; viewportId: string }

The data that is passed to the event handler when an annotation selection status changes.

Type declaration

  • element: HTMLDivElement

    The HTML element that the annotation was rendered on.

  • renderingEngineId: string

    unique id of the rendering engine

  • viewportId: string

    unique id of the viewport

AnnotationRenderedEventType

AnnotationRenderedEventType: Types.CustomEventType<AnnotationRenderedEventDetail>

The AnnotationRendered event type

AnnotationSelectionChangeEventDetail

AnnotationSelectionChangeEventDetail: { added: string[]; removed: string[]; selection: string[] }

The data that is passed to the event handler when an annotation selection status changes.

Type declaration

  • added: string[]

    AnnotationUID added to the selection

  • removed: string[]

    AnnotationUID removed from the selection

  • selection: string[]

    Updated selection

AnnotationSelectionChangeEventType

AnnotationSelectionChangeEventType: Types.CustomEventType<AnnotationSelectionChangeEventDetail>

The AnnotationSelectionChange event type

AnnotationVisibilityChangeEventDetail

AnnotationVisibilityChangeEventDetail: { hidden: string[]; lastHidden: string[]; lastVisible: string[] }

Type declaration

  • hidden: string[]
  • lastHidden: string[]
  • lastVisible: string[]

AnnotationVisibilityChangeEventType

AnnotationVisibilityChangeEventType: Types.CustomEventType<AnnotationVisibilityChangeEventDetail>

The AnnotationVisibilityChange event type

InteractionEndType

InteractionEndType: Types.CustomEventType<InteractionEndEventDetail>

Event for interaction end

InteractionEventType

InteractionEventType: Types.CustomEventType<InteractionEventDetail>

Event for interaction

InteractionStartType

InteractionStartType: Types.CustomEventType<InteractionStartEventDetail>

Event for interaction start

KeyDownEventDetail

KeyDownEventDetail: { element: HTMLDivElement; key: string; keyCode: number; renderingEngineId: string; viewportId: string }

EventDetail for keyDown event

Type declaration

  • element: HTMLDivElement

    html element

  • key: string

    The key that was pressed

  • keyCode: number

    key code

  • renderingEngineId: string

    unique id of the rendering engine

  • viewportId: string

    unique id of the viewport

KeyDownEventType

KeyDownEventType: Types.CustomEventType<KeyDownEventDetail>

Event for when a key is pressed

KeyUpEventDetail

KeyUpEventDetail: KeyDownEventDetail

EventDetail for keyDown event

KeyUpEventType

KeyUpEventType: Types.CustomEventType<KeyUpEventDetail>

Event for when a key is released

MouseClickEventDetail

MouseClickEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & { mouseButton: number }

EventDetail mouseClick (a mouse down which is followed by a mouse up)

MouseClickEventType

MouseClickEventType: Types.CustomEventType<MouseClickEventDetail>

Event for mouse click

MouseDoubleClickEventDetail

MouseDoubleClickEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail

EventDetail mouseClick (a mouse down which is followed by a mouse up)

MouseDoubleClickEventType

MouseDoubleClickEventType: Types.CustomEventType<MouseDoubleClickEventDetail>

Event for mouse double click

MouseDownActivateEventDetail

MouseDownActivateEventDetail: NormalizedInteractionEventDetail & MousePointsDetail & MouseCustomEventDetail & { mouseButton: number }

EventDetail for mouseDown Activate, it is triggered when mouseDown event is fired but stopPropagation is not called, used for creating new annotation

MouseDownActivateEventType

MouseDownActivateEventType: Types.CustomEventType<MouseDownActivateEventDetail>

Event for mouse down event

MouseDownEventDetail

MouseDownEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & { mouseButton: number }

EventDetail for mouseDown event

MouseDownEventType

MouseDownEventType: Types.CustomEventType<MouseDownEventDetail>

Event for when a mouse button is pressed

MouseDragEventDetail

MouseDragEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & { mouseButton: number }

EventDetail for mouseDrag event

MouseDragEventType

MouseDragEventType: Types.CustomEventType<MouseDragEventDetail>

Event for mouse drag

MouseMoveEventDetail

MouseMoveEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & { currentPoints: IPoints }

EventDetail mouseMove event

MouseMoveEventType

MouseMoveEventType: Types.CustomEventType<MouseMoveEventDetail>

Event for mouse move

MouseUpEventDetail

MouseUpEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & MousePointsDetail & { mouseButton: number }

EventDetail for mouseUp event

MouseUpEventType

MouseUpEventType: Types.CustomEventType<MouseUpEventDetail>

Event for mouse up

MouseWheelEventDetail

MouseWheelEventDetail: NormalizedInteractionEventDetail & MouseCustomEventDetail & { detail: Record<string, any>; points: IPoints; wheel: { direction: number; pixelX: number; pixelY: number; spinX: number; spinY: number } }

Mouse Wheel event detail

MouseWheelEventType

MouseWheelEventType: Types.CustomEventType<MouseWheelEventDetail>

Event for mouse wheel

NormalizedInteractionEventDetail

NormalizedInteractionEventDetail: { camera: Record<string, unknown>; element: HTMLDivElement; eventName: string; renderingEngineId: string; viewportId: string }

The normalized interaction event detail

Type declaration

  • camera: Record<string, unknown>

    The camera at the time of the event.

  • element: HTMLDivElement

    The element that the event was fired on.

  • eventName: string

    The normalized event name.

  • renderingEngineId: string

    The unique identifier of the rendering engine.

  • viewportId: string

    The unique identifier of the viewport that the event was fired in.

NormalizedMouseEventType

NormalizedMouseEventType: Types.CustomEventType<MouseCustomEventDetail>

The Normalized mouse event type

NormalizedTouchEventType

NormalizedTouchEventType: Types.CustomEventType<TouchCustomEventDetail>

The Normalized mouse event type

SegmentationDataModifiedEventDetail

SegmentationDataModifiedEventDetail: { modifiedSlicesToUse?: number[]; segmentationId: string }

EventDetail for when a Segmentation Data is modified by a tool

Type declaration

  • optionalmodifiedSlicesToUse?: number[]

    array of slice indices in a labelmap which have been modified

  • segmentationId: string

    unique id of the segmentationData

SegmentationDataModifiedEventType

SegmentationDataModifiedEventType: Types.CustomEventType<SegmentationDataModifiedEventDetail>

Event for when SegmentationData is modified

SegmentationModifiedEventDetail

SegmentationModifiedEventDetail: { segmentationId: string }

EventDetail for when a Segmentation Global State is modified

Type declaration

  • segmentationId: string

    unique id of segmentation (not segmentationData), for volumes (labelMaps) it is volumeId

SegmentationModifiedEventType

SegmentationModifiedEventType: Types.CustomEventType<SegmentationModifiedEventDetail>

Event for when Segmentation Global State is modified

SegmentationRemovedEventDetail

SegmentationRemovedEventDetail: { segmentationId: string }

EventDetail for when a Segmentation is removed

Type declaration

  • segmentationId: string

    the id of the removed segmentation

SegmentationRemovedEventType

SegmentationRemovedEventType: Types.CustomEventType<SegmentationRemovedEventDetail>

Event for when Segmentation is removed

SegmentationRenderedEventDetail

SegmentationRenderedEventDetail: { toolGroupId: string; viewportId: string }

EventDetail for when a Segmentation is rendered by segmentation rendering engine

Type declaration

  • toolGroupId: string

    unique id of the toolGroup segmentation belongs to

  • viewportId: string

    unique id of the viewport

SegmentationRenderedEventType

SegmentationRenderedEventType: Types.CustomEventType<SegmentationRenderedEventDetail>

Event for when Segmentation is rendered

SegmentationRepresentationModifiedEventDetail

SegmentationRepresentationModifiedEventDetail: { segmentationRepresentationUID: string; toolGroupId: string }

EventDetail for when a Segmentation Representation for a toolGroup is modified

Type declaration

  • segmentationRepresentationUID: string

    segmentation representationUID

  • toolGroupId: string

    unique id of the toolGroup

SegmentationRepresentationModifiedEventType

SegmentationRepresentationModifiedEventType: Types.CustomEventType<SegmentationRepresentationModifiedEventDetail>

Event for when Segmentation Representation is modified

SegmentationRepresentationRemovedEventDetail

SegmentationRepresentationRemovedEventDetail: { segmentationRepresentationUID: string; toolGroupId: string }

EventDetail for when a Segmentation Representation is removed

Type declaration

  • segmentationRepresentationUID: string

    segmentation representationUID

  • toolGroupId: string

    unique id of the toolGroup

SegmentationRepresentationRemovedEventType

SegmentationRepresentationRemovedEventType: Types.CustomEventType<SegmentationRepresentationRemovedEventDetail>

Event for when Segmentation Representation is modified

TouchDragEventDetail

TouchDragEventDetail: NormalizedInteractionEventDetail & TouchCustomEventDetail & TouchPointsDetail

EventDetail for touch drag event

TouchDragEventType

TouchDragEventType: Types.CustomEventType<TouchDragEventDetail>

Event for touch drag

TouchEndEventDetail

TouchEndEventDetail: NormalizedInteractionEventDetail & TouchPointsDetail & TouchCustomEventDetail

EventDetail for touch end event

TouchEndEventType

TouchEndEventType: Types.CustomEventType<TouchEndEventDetail>

Event for touch end

TouchPressEventDetail

TouchPressEventDetail: NormalizedInteractionEventDetail & TouchCustomEventDetail & { lastPoints: ITouchPoints; lastPointsList: ITouchPoints[]; startPoints: ITouchPoints; startPointsList: ITouchPoints[] }

EventDetail touchPress (a longer press in the same spot)

TouchPressEventType

TouchPressEventType: Types.CustomEventType<TouchPressEventDetail>

Event for when a touch is long pressed

TouchStartActivateEventDetail

TouchStartActivateEventDetail: NormalizedInteractionEventDetail & TouchCustomEventDetail & TouchPointsDetail

EventDetail for touchStart Activate, it is triggered when touchStart event is fired but stopPropagation is not called, used for creating new annotation

TouchStartActivateEventType

TouchStartActivateEventType: Types.CustomEventType<TouchStartActivateEventDetail>

Event for touch start event

TouchStartEventDetail

TouchStartEventDetail: NormalizedInteractionEventDetail & TouchCustomEventDetail & TouchPointsDetail

EventDetail for touchstart event

TouchStartEventType

TouchStartEventType: Types.CustomEventType<TouchStartEventDetail>

Event for when a touch starts

TouchSwipeEventDetail

TouchSwipeEventDetail: NormalizedInteractionEventDetail & TouchCustomEventDetail & { swipe: Swipe }

TouchSwipeEventType

TouchSwipeEventType: Types.CustomEventType<TouchSwipeEventDetail>

Event for when a touch is swiped

TouchTapEventDetail

TouchTapEventDetail: NormalizedInteractionEventDetail & TouchCustomEventDetail & { currentPoints: ITouchPoints; currentPointsList: ITouchPoints[]; taps: number }

EventDetail touchTap (successive taps which do not trigger touchstart)

TouchTapEventType

TouchTapEventType: Types.CustomEventType<TouchTapEventDetail>

Event for when a touch is tapped

VolumeScrollOutOfBoundsEventDetail

VolumeScrollOutOfBoundsEventDetail: { currentImageId: string; currentStepIndex: number; delta: number; desiredStepIndex: number; numScrollSteps: number; viewport: Types.IVolumeViewport; volumeId: string }

Volume Scroll Out of Bounds event detail

Type declaration

  • currentImageId: string
  • currentStepIndex: number
  • delta: number
  • desiredStepIndex: number
  • numScrollSteps: number
  • viewport: Types.IVolumeViewport
  • volumeId: string

VolumeScrollOutOfBoundsEventType

VolumeScrollOutOfBoundsEventType: Types.CustomEventType<VolumeScrollOutOfBoundsEventDetail>

Event for volume scroll out of bounds

LabelmapTypes

LabelmapTypes:

LabelmapConfig

LabelmapConfig: { fillAlpha?: number; fillAlphaInactive?: number; outlineOpacity?: number; outlineOpacityInactive?: number; outlineWidthActive?: number; outlineWidthInactive?: number; renderFill?: boolean; renderFillInactive?: boolean; renderOutline?: boolean }

Label map config for the label map representation

Type declaration

  • optionalfillAlpha?: number

    alpha of the fill

  • optionalfillAlphaInactive?: number

    alpha of the fill when inactive

  • optionaloutlineOpacity?: number

    alpha of outline for active segmentation

  • optionaloutlineOpacityInactive?: number

    alpha of outline for inactive segmentation

  • optionaloutlineWidthActive?: number

    thickness of the outline when segmentation is active

  • optionaloutlineWidthInactive?: number

    thickness of the outline when segmentation is inactive

  • optionalrenderFill?: boolean

    whether to render segmentation filling

  • optionalrenderFillInactive?: boolean

    whether to render segmentation filling when inactive

  • optionalrenderOutline?: boolean

    whether to render segmentation outline

LabelmapRenderingConfig

LabelmapRenderingConfig: { cfun?: vtkColorTransferFunction; ofun?: vtkPiecewiseFunction }

Labelmap representation type

Type declaration

  • optionalcfun?: vtkColorTransferFunction

    color transfer function

  • optionalofun?: vtkPiecewiseFunction

    opacity transfer function

LabelmapSegmentationData

LabelmapSegmentationData: { referencedVolumeId?: string; volumeId: string }

Type declaration

  • optionalreferencedVolumeId?: string
  • volumeId: string

ToolSpecificAnnotationTypes

ToolSpecificAnnotationTypes:

AngleAnnotation

AngleAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats: {}; handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; label: string }

Type declaration

  • cachedStats: {}
    • [targetId string]: { angle: number }
  • handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }
  • label: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

ArrowAnnotation

ArrowAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { handles: { activeHandleIndex: number; arrowFirst: boolean; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; text: string }

Type declaration

  • handles: { activeHandleIndex: number; arrowFirst: boolean; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }
  • text: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

BidirectionalAnnotation

BidirectionalAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats: {}; handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; label: string }

Type declaration

  • cachedStats: {}
    • [targetId string]: { length: number; unit: string; width: number }
  • handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }
  • label: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

CircleROIAnnotation

CircleROIAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats?: ROICachedStats & {}; handles: { activeHandleIndex: number; points: [Point3, Point3]; textBox?: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; label: string }

Type declaration

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

EllipticalROIAnnotation

EllipticalROIAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats?: ROICachedStats; handles: { activeHandleIndex: number; points: [Point3, Point3, Point3, Point3]; textBox?: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; initialRotation: number; label: string }

Type declaration

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

LengthAnnotation

LengthAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats: {}; handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; label: string }

Type declaration

  • cachedStats: {}
    • [targetId string]: { length: number; unit: string }
  • handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }
  • label: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

PlanarFreehandROIAnnotation

PlanarFreehandROIAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats?: ROICachedStats; handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; isOpenContour?: boolean; isOpenUShapeContour?: boolean; label?: string; openUShapeContourVectorToPeak?: Point3[]; polyline: Point3[] }

Type declaration

  • optionalcachedStats?: ROICachedStats
  • handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }
  • optionalisOpenContour?: boolean
  • optionalisOpenUShapeContour?: boolean
  • optionallabel?: string
  • optionalopenUShapeContourVectorToPeak?: Point3[]
  • polyline: Point3[]

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; annotationUID?: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3 }

Type declaration

  • FrameOfReferenceUID: string
  • optionalannotationUID?: string
  • optionalcameraFocalPoint?: Point3
  • optionalcameraPosition?: Point3
  • optionalreferencedImageId?: string
  • toolName: string
  • optionalviewPlaneNormal?: Point3
  • optionalviewUp?: Point3

ProbeAnnotation

ProbeAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats: {}; handles: { points: Point3[] }; label: string }

Type declaration

  • cachedStats: {}
    • [targetId string]: { Modality: string; index: Types.Point3; value: number }
  • handles: { points: Point3[] }
  • label: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

RectangleROIAnnotation

RectangleROIAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats?: ROICachedStats | { projectionPoints?: Point3[]; projectionPointsImageIds?: string[] }; handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }; label: string }

Type declaration

  • optionalcachedStats?: ROICachedStats | { projectionPoints?: Point3[]; projectionPointsImageIds?: string[] }
  • handles: { activeHandleIndex: number; points: Point3[]; textBox: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Point3; bottomRight: Point3; topLeft: Point3; topRight: Point3 }; worldPosition: Point3 } }
  • label: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

RectangleROIStartEndThresholdAnnotation

RectangleROIStartEndThresholdAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { cachedStats: { projectionPoints: Point3[][]; projectionPointsImageIds: string[] }; endSlice: number; handles: { activeHandleIndex: number; points: Point3[] }; label: string; startSlice: number }

Type declaration

  • cachedStats: { projectionPoints: Point3[][]; projectionPointsImageIds: string[] }
    • projectionPoints: Point3[][]
    • projectionPointsImageIds: string[]
  • endSlice: number
  • handles: { activeHandleIndex: number; points: Point3[] }
    • activeHandleIndex: number
    • points: Point3[]
  • label: string
  • startSlice: number

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; annotationUID?: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; enabledElement: any; referencedImageId?: string; spacingInNormal: number; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId: string }

Type declaration

  • FrameOfReferenceUID: string
  • optionalannotationUID?: string
  • optionalcameraFocalPoint?: Point3
  • optionalcameraPosition?: Point3
  • enabledElement: any
  • optionalreferencedImageId?: string
  • spacingInNormal: number
  • toolName: string
  • optionalviewPlaneNormal?: Point3
  • optionalviewUp?: Point3
  • volumeId: string

RectangleROIThresholdAnnotation

RectangleROIThresholdAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { handles: { activeHandleIndex: number; points: Point3[] }; label: string }

Type declaration

  • handles: { activeHandleIndex: number; points: Point3[] }
    • activeHandleIndex: number
    • points: Point3[]
  • label: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; annotationUID?: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; enabledElement: IEnabledElement; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId: string }

Type declaration

  • FrameOfReferenceUID: string
  • optionalannotationUID?: string
  • optionalcameraFocalPoint?: Point3
  • optionalcameraPosition?: Point3
  • enabledElement: IEnabledElement
  • optionalreferencedImageId?: string
  • toolName: string
  • optionalviewPlaneNormal?: Point3
  • optionalviewUp?: Point3
  • volumeId: string

ReferenceCursor

ReferenceCursor:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { handles: { points: [Point3] } }

Type declaration

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

ReferenceLineAnnotation

ReferenceLineAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { handles: { points: Point3[] } }

Type declaration

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

ScaleOverlayAnnotation

ScaleOverlayAnnotation:

optionalannotationUID

annotationUID?: string

A unique identifier for this annotation

data

data: { handles: { points: Point3[] }; viewportId: string }

Type declaration

  • handles: { points: Point3[] }
  • viewportId: string

optionalhighlighted

highlighted?: boolean

If the annotation is being hovered over and is highlighted

optionalinvalidated

invalidated?: boolean

Has annotation data been invalidated (e.g., as a result of mouse interactions)

optionalisLocked

isLocked?: boolean

If the annotation is locked for manipulation

optionalisVisible

isVisible?: boolean

If the annotation is visible for manipulation

metadata

metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Point3; cameraPosition?: Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Point3; viewUp?: Point3; volumeId?: string }

Metadata for annotation

Type declaration

  • FrameOfReferenceUID: string

    The FrameOfReferenceUID

  • optionalcameraFocalPoint?: Point3

    The focal point of the camera in world space

  • optionalcameraPosition?: Point3

    The position of the camera in world space

  • optionalreferencedImageId?: string

    An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

  • toolName: string

    The registered name of the tool

  • optionalviewPlaneNormal?: Point3

    The normal on which the tool was drawn

  • optionalviewUp?: Point3

    The viewUp on which the tool was drawn.

  • optionalvolumeId?: string

    VolumeId of the volume that the tool was configured to work on.

Interfaces

IAnnotationManager

IAnnotationManager:

The interface for any annotation manager (custom or default)

addAnnotation

addAnnotation: (annotation: Annotation, groupKey: string) => void

Type declaration

    • Adds an annotation to the specified group.

      Parameters

      • annotation: Annotation

        The annotation to add.

      • groupKey: string

        The group key to add the annotation to.

      Returns void

getAnnotation

getAnnotation: (annotationUID: string) => Annotation

Type declaration

    • Returns the annotation with the specified UID.

      Parameters

      • annotationUID: string

        The UID of the annotation to retrieve.

      Returns Annotation

      The annotation with the specified UID.

getAnnotations

getAnnotations: (groupKey: string, toolName?: string) => Annotations | GroupSpecificAnnotations

Type declaration

    • Returns the annotations associated with the specified group, if the toolName is specified, it will return the annotations for the specified tool.

      Parameters

      • groupKey: string

        The group key to retrieve annotations for.

      • optionaltoolName: string

        The name of the tool to retrieve annotations for.

      Returns Annotations | GroupSpecificAnnotations

      The annotations associated with the specified group and tool.

getGroupKey

getGroupKey: (annotationGroupSelector: AnnotationGroupSelector) => string

Type declaration

    • Annotations are stored in Groups. Our default annotation manager groups the annotations based on FrameOfReferenceUID, but it is possible that you can group them based on different aspects or you only have one group totally.

      This function returns the group key associated with the specified annotationGroupSelector. The annotationGroupSelector can be an HTML element or a string.

      Parameters

      Returns string

      The group key associated with the element.

getNumberOfAllAnnotations

getNumberOfAllAnnotations: () => number

Type declaration

    • (): number

    • Returns the total number of annotations across all groups.

      Returns number

      The total number of annotations across all groups.

getNumberOfAnnotations

getNumberOfAnnotations: (groupKey: string, toolName?: string) => number

Type declaration

    • (groupKey: string, toolName?: string): number

    • Returns the number of annotations associated with the specified group. If the toolName is specified, it will return the number of annotations

      Parameters

      • groupKey: string

        The group key to count annotations for.

      • optionaltoolName: string

        The name of the tool to count annotations for.

      Returns number

      The number of annotations associated with the specified group.

removeAllAnnotations

removeAllAnnotations: () => void

Type declaration

    • (): void

    • Removes all annotations.

      Returns void

removeAnnotation

removeAnnotation: (annotationUID: string) => void

Type declaration

    • (annotationUID: string): void

    • Removes the annotation with the specified UID.

      Parameters

      • annotationUID: string

        The UID of the annotation to remove.

      Returns void

removeAnnotations

removeAnnotations: (groupKey: string) => void

Type declaration

    • (groupKey: string): void

    • Removes all annotations associated with the specified group.

      Parameters

      • groupKey: string

        The group key to remove annotations for.

      Returns void

ISynchronizerEventHandler

IToolGroup

IToolGroup:

ToolGroup interface

_toolInstances

_toolInstances: Record<string, any>

Unserializable instantiated tool classes, keyed by name

addTool

addTool: (toolName: string, toolConfiguration?: any) => void

Type declaration

    • (toolName: string, toolConfiguration?: any): void

    • Add a tool to toolGroup with its configuration

      Parameters

      • toolName: string
      • optionaltoolConfiguration: any

      Returns void

addToolInstance

addToolInstance: (ttoolName: string, parentClassName: string, configuration?: any) => void

Type declaration

    • (ttoolName: string, parentClassName: string, configuration?: any): void

    • Add tool instance, if you want to create more than one instance from the same tool e.g., brush/eraser tool

      Parameters

      • ttoolName: string
      • parentClassName: string
      • optionalconfiguration: any

      Returns void

addViewport

addViewport: (viewportId: string, renderingEngineId?: string) => void

Type declaration

    • (viewportId: string, renderingEngineId?: string): void

    • Add viewports to share the tools for the ToolGroup

      Parameters

      • viewportId: string
      • optionalrenderingEngineId: string

      Returns void

getActivePrimaryMouseButtonTool

getActivePrimaryMouseButtonTool: () => string

Type declaration

    • (): string

    • Returns string

getToolConfiguration

getToolConfiguration: (toolName: string, configurationPath: string) => any

Type declaration

    • (toolName: string, configurationPath: string): any

    • Parameters

      • toolName: string
      • configurationPath: string

      Returns any

getToolInstance

getToolInstance: (toolName: string) => any

Type declaration

    • (toolName: string): any

    • Get the toolInstance of the toolName

      Parameters

      • toolName: string

      Returns any

getToolOptions

getToolOptions: (toolName: string) => ToolOptionsType

Type declaration

getViewportIds

getViewportIds: () => string[]

Type declaration

    • (): string[]

    • Get viewportIds in the toolGroup

      Returns string[]

getViewportsInfo

getViewportsInfo: () => default[]

Type declaration

id

id: string

ToolGroup ID

removeViewports

removeViewports: (renderingEngineId: string, viewportId?: string) => void

Type declaration

    • (renderingEngineId: string, viewportId?: string): void

    • Remove viewports from the ToolGroup

      Parameters

      • renderingEngineId: string
      • optionalviewportId: string

      Returns void

setToolActive

setToolActive: (toolName: string, toolBindingsOption?: SetToolBindingsType) => void

Type declaration

    • Setting the tool to be Active by its name

      Parameters

      Returns void

setToolConfiguration

setToolConfiguration: (toolName: string, configuration: Record<any, any>, overwrite?: boolean) => void

Type declaration

    • (toolName: string, configuration: Record<any, any>, overwrite?: boolean): void

    • Parameters

      • toolName: string
      • configuration: Record<any, any>
      • optionaloverwrite: boolean

      Returns void

setToolDisabled

setToolDisabled: (toolName: string) => void

Type declaration

    • (toolName: string): void

    • Setting the tool to be Disabled by its name

      Parameters

      • toolName: string

      Returns void

setToolEnabled

setToolEnabled: (toolName: string) => void

Type declaration

    • (toolName: string): void

    • Setting the tool to be Enabled by its name

      Parameters

      • toolName: string

      Returns void

setToolPassive

setToolPassive: (toolName: string) => void

Type declaration

    • (toolName: string): void

    • Setting the tool to be Passive by its name

      Parameters

      • toolName: string

      Returns void

setViewportsCursorByToolName

setViewportsCursorByToolName: (toolName: string, strategyName?: string) => void

Type declaration

    • (toolName: string, strategyName?: string): void

    • Parameters

      • toolName: string
      • optionalstrategyName: string

      Returns void

toolOptions

toolOptions: Record<string, any>

Options for each tool including bindings and mode

viewportsInfo

viewportsInfo: default[]

Viewports Info inside the ToolGroup - including viewportId and renderingEngineId

Type Aliases

Annotation

Annotation: { annotationUID?: string; data: { cachedStats?: unknown; handles?: { activeHandleIndex?: number | null; points?: Types.Point3[]; textBox?: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Types.Point3; bottomRight: Types.Point3; topLeft: Types.Point3; topRight: Types.Point3 }; worldPosition: Types.Point3 } } }; highlighted?: boolean; invalidated?: boolean; isLocked?: boolean; isVisible?: boolean; metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Types.Point3; cameraPosition?: Types.Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Types.Point3; viewUp?: Types.Point3; volumeId?: string } }

Type declaration

  • optionalannotationUID?: string

    A unique identifier for this annotation

  • data: { cachedStats?: unknown; handles?: { activeHandleIndex?: number | null; points?: Types.Point3[]; textBox?: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Types.Point3; bottomRight: Types.Point3; topLeft: Types.Point3; topRight: Types.Point3 }; worldPosition: Types.Point3 } } }

    Data for annotation, Derivatives need to define their own data types.

    • [key string]: any
    • optionalcachedStats?: unknown

      Cached Annotation statistics which is specific to the tool

    • optionalhandles?: { activeHandleIndex?: number | null; points?: Types.Point3[]; textBox?: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Types.Point3; bottomRight: Types.Point3; topLeft: Types.Point3; topRight: Types.Point3 }; worldPosition: Types.Point3 } }

      Annotation handles that are grabbable for manipulation

      • [key string]: any
      • optionalactiveHandleIndex?: number | null

        index of the active handle being manipulated

      • optionalpoints?: Types.Point3[]

        world location of the handles in the space

      • optionaltextBox?: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Types.Point3; bottomRight: Types.Point3; topLeft: Types.Point3; topRight: Types.Point3 }; worldPosition: Types.Point3 }

        annotation text box information

        • hasMoved: boolean

          whether the text box has moved

        • worldBoundingBox: { bottomLeft: Types.Point3; bottomRight: Types.Point3; topLeft: Types.Point3; topRight: Types.Point3 }

          text box bounding box information

          • bottomLeft: Types.Point3

            Bottom left location of the text box in the world space

          • bottomRight: Types.Point3

            Bottom right location of the text box in the world space

          • topLeft: Types.Point3

            Top left location of the text box in the world space

          • topRight: Types.Point3

            Top right location of the text box in the world space

        • worldPosition: Types.Point3

          the world location of the text box

  • optionalhighlighted?: boolean

    If the annotation is being hovered over and is highlighted

  • optionalinvalidated?: boolean

    Has annotation data been invalidated (e.g., as a result of mouse interactions)

  • optionalisLocked?: boolean

    If the annotation is locked for manipulation

  • optionalisVisible?: boolean

    If the annotation is visible for manipulation

  • metadata: { FrameOfReferenceUID: string; cameraFocalPoint?: Types.Point3; cameraPosition?: Types.Point3; referencedImageId?: string; toolName: string; viewPlaneNormal?: Types.Point3; viewUp?: Types.Point3; volumeId?: string }

    Metadata for annotation

    • FrameOfReferenceUID: string

      The FrameOfReferenceUID

    • optionalcameraFocalPoint?: Types.Point3

      The focal point of the camera in world space

    • optionalcameraPosition?: Types.Point3

      The position of the camera in world space

    • optionalreferencedImageId?: string

      An optional property used when annotating on a slice in a StackViewport, or when annotating in a VolumeViewport on a viewPlane that corresponds to original slice-based image data.

    • toolName: string

      The registered name of the tool

    • optionalviewPlaneNormal?: Types.Point3

      The normal on which the tool was drawn

    • optionalviewUp?: Types.Point3

      The viewUp on which the tool was drawn.

    • optionalvolumeId?: string

      VolumeId of the volume that the tool was configured to work on.

AnnotationGroupSelector

AnnotationGroupSelector: HTMLDivElement | string

AnnotationGroupSelector is a type that can be used to specify the group of annotations to which an annotation should be added.

AnnotationHandle

AnnotationHandle: Types.Point3

Handle position in the world coordinates

AnnotationState

AnnotationState: {}

All frame of reference specific annotations for all tools.

Type declaration

Annotations

Annotations: Annotation[]

Array of annotations

BoundsIJK

BoundsIJK: [Types.Point2, Types.Point2, Types.Point2]

Color

Color: [number, number, number, number]

Four elements RGBA as 0-255

ColorLUT

ColorLUT: Color[]

Color LUT Array - Array of colors [[0,0,0,0], [200,200,200,200], ….]

ContourSegmentationData

ContourSegmentationData: { geometryIds: string[] }

Type declaration

  • geometryIds: string[]

FloodFillGetter

FloodFillGetter: FloodFillGetter2D | FloodFillGetter3D

FloodFillOptions

FloodFillOptions: { diagonals?: boolean; equals?: (a: any, b: any) => boolean; onBoundary?: (x: any, y: any) => void; onFlood?: (x: any, y: any) => void }

Type declaration

  • optionaldiagonals?: boolean
  • optionalequals?: (a: any, b: any) => boolean
      • (a: any, b: any): boolean

      • Parameters

        • a: any
        • b: any

        Returns boolean

  • optionalonBoundary?: (x: any, y: any) => void
      • (x: any, y: any): void

      • Parameters

        • x: any
        • y: any

        Returns void

  • optionalonFlood?: (x: any, y: any) => void
      • (x: any, y: any): void

      • Parameters

        • x: any
        • y: any

        Returns void

FloodFillResult

FloodFillResult: { boundaries: Types.Point2[] | Types.Point3[]; flooded: Types.Point2[] | Types.Point3[] }

Type declaration

GroupSpecificAnnotations

GroupSpecificAnnotations: {}

Type declaration

IDistance

IDistance: { canvas: number; client: number; page: number; world: number }

Distance in page, client, canvas and world coordinates.

Type declaration

  • canvas: number

    canvas distance

  • client: number

    client distance

  • page: number

    page distance

  • world: number

    world distance

IPoints

IPoints: { canvas: Types.Point2; client: Types.Point2; page: Types.Point2; world: Types.Point3 }

Points in page, client, canvas and world coordinates.

Type declaration

IToolBinding

IToolBinding: { modifierKey?: ToolBindingKeyboardType; mouseButton?: ToolBindingMouseType; numTouchPoints?: number }

Type declaration

  • optionalmodifierKey?: ToolBindingKeyboardType

    Keyboard bindings e.g., KeyboardBindings.Shift/Ctrl etc.

  • optionalmouseButton?: ToolBindingMouseType

    Mouse button bindings e.g., MouseBindings.Primary/Secondary etc.

  • optionalnumTouchPoints?: number

    Number of touch points

IToolClassReference

IToolClassReference: new <T>(config: any) => T

Type declaration

    • new <T>(config: any): T

    • Type parameters

      Parameters

      • config: any

      Returns T

ITouchPoints

ITouchPoints: IPoints & { touch: { force: number; identifier: string; radiusX: number; radiusY: number; rotationAngle: number } }

InteractionTypes

InteractionTypes: Mouse | Touch

Supported Interactions for tools

JumpToSliceOptions

JumpToSliceOptions: { debounceLoading?: boolean; imageIndex: number; volumeId?: string }

Type declaration

  • optionaldebounceLoading?: boolean
  • imageIndex: number
  • optionalvolumeId?: string

PlanarBoundingBox

PlanarBoundingBox: { height: number; width: number; x: number; y: number }

Type declaration

  • height: number
  • width: number
  • x: number
  • y: number

PublicToolProps

PublicToolProps: SharedToolProp & { name?: string }

Tool specific tool properties which includes the supported interaction types and the configuration.

RepresentationConfig

RepresentationConfig: { CONTOUR?: ContourConfig; LABELMAP?: LabelmapConfig }

Type declaration

  • optionalCONTOUR?: ContourConfig

    contour configuration

  • optionalLABELMAP?: LabelmapConfig

    labelmap configuration

RepresentationPublicInput

RepresentationPublicInput: { segmentationId: string; type: Enums.SegmentationRepresentations }

Type declaration

SVGCursorDescriptor

SVGCursorDescriptor: { iconContent: string; iconSize: number; mousePoint: SVGPoint; mousePointerGroupString: string; viewBox: SVGPoint }

Type declaration

  • iconContent: string
  • iconSize: number
  • mousePoint: SVGPoint
  • mousePointerGroupString: string
  • viewBox: SVGPoint

SVGDrawingHelper

SVGDrawingHelper: { appendNode: (svgNode: SVGElement, cacheKey: string) => void; clearUntouched: () => void; getSvgNode: (cacheKey: string) => SVGGElement | undefined; setNodeTouched: (cacheKey: string) => void; svgLayerElement: HTMLDivElement; svgNodeCacheForCanvas: Record<string, unknown> }

Type declaration

  • appendNode: (svgNode: SVGElement, cacheKey: string) => void
      • (svgNode: SVGElement, cacheKey: string): void

      • Parameters

        • svgNode: SVGElement
        • cacheKey: string

        Returns void

  • clearUntouched: () => void
      • (): void

      • Returns void

  • getSvgNode: (cacheKey: string) => SVGGElement | undefined
      • (cacheKey: string): SVGGElement | undefined

      • Parameters

        • cacheKey: string

        Returns SVGGElement | undefined

  • setNodeTouched: (cacheKey: string) => void
      • (cacheKey: string): void

      • Parameters

        • cacheKey: string

        Returns void

  • svgLayerElement: HTMLDivElement
  • svgNodeCacheForCanvas: Record<string, unknown>

SVGPoint

SVGPoint: { x: number; y: number }

Type declaration

  • x: number
  • y: number

ScrollOptions

ScrollOptions: { debounceLoading?: boolean; delta: number; loop?: boolean; volumeId?: string }

Type declaration

  • optionaldebounceLoading?: boolean
  • delta: number
  • optionalloop?: boolean
  • optionalvolumeId?: string

Segmentation

Segmentation: { activeSegmentIndex: number; cachedStats: {}; label: string; representationData: SegmentationRepresentationData; segmentLabels: {}; segmentationId: string; segmentsLocked: Set<number>; type: Enums.SegmentationRepresentations }

Global Segmentation Data which is used for the segmentation

Type declaration

  • activeSegmentIndex: number

    Active segment index in the segmentation, this index will get used inside the segmentation tools

  • cachedStats: {}

    If there is any derived statistics for the segmentation (e.g., mean, volume, etc)

    • [key string]: number
  • label: string

    segmentation label

  • representationData: SegmentationRepresentationData

    Representations of the segmentation. Each segmentation “can” be viewed in various representations. For instance, if a DICOM SEG is loaded, the main representation is the labelmap. However, for DICOM RT the main representation is contours, and other representations can be derived from the contour (currently only labelmap representation is supported)

  • segmentLabels: {}
    • [key string]: string
  • segmentationId: string

    segmentation id

  • segmentsLocked: Set<number>

    Locked segments in the segmentation, if a segment is locked no tool will be able to modify it

  • type: Enums.SegmentationRepresentations

    segmentation main representation type

SegmentationRepresentationConfig

SegmentationRepresentationConfig: { renderInactiveSegmentations: boolean; representations: RepresentationConfig }

Type declaration

  • renderInactiveSegmentations: boolean

    Whether to render Inactive segmentations

  • representations: RepresentationConfig

    Representations configuration

SegmentationRepresentationData

SegmentationRepresentationData: { CONTOUR?: ContourSegmentationData; LABELMAP?: LabelmapSegmentationData }

Type declaration

SegmentationState

SegmentationState: { colorLUT: ColorLUT[]; globalConfig: SegmentationRepresentationConfig; segmentations: Segmentation[]; toolGroups: {} }

Segmentation State stored inside the cornerstone3DTools

 {
  colorLUT: [],
  globalConfig: {
    renderInactiveSegmentations: false,
    representations: {
      LABELMAP: {
        renderFill: true,
        renderOutline: true,
      },
    },
  },
  segmentations: [
    {
      segmentationId: 'segmentation1',
      mainType: 'Labelmap',
      activeSegmentIndex: 0,
      segmentsLocked: new Set(),
      label: 'segmentation1',
      cachedStats: {},
      representationData: {
        LABELMAP: {
          volumeId: 'segmentation1',
        },
        CONTOUR: {
          geometryIds: ['contourSet1', 'contourSet2'],
        },
      },
    },
    {
      segmentationId: 'segmentation2',
      type: 'Labelmap',
      activeSegmentIndex: 1,
      segmentsLocked: new Set(),
      label: 'segmentation2',
      cachedStats: {},
      representationData: {
        CONTOUR: {
          points: Float32Array,
        },
      },
    },
  ],
  toolGroups: {
    toolGroupUID1: {
      segmentationRepresentations: [
        {
          segmentationRepresentationUID: '12123123123132',
          segmentationId: '123123',
          type: 'Labelmap',
          active: true,
          colorLUTIndex: 0,
          visibility: true,
          segmentsHidden: Set(),
          // rendering config
          config: {
            "cfun",
            "ofun",
          },
          // segmentation representation specific config, has priority over the one in the outer scope
          segmentationRepresentationSpecificConfig: {
            LABELMAP: {
              renderFill: true,
            }
          }
          // segment specific config
          segmentSpecificConfig: {
            1: {
             renderFill: false,
             }
          },
        },
      ],
      config: {
        renderInactiveSegmentations: false,
        representations: {
          LABELMAP: {
            renderFill: true,
            renderOutline: true,
          },
        },
      },
    },
  },
}

Type declaration

SetToolBindingsType

SetToolBindingsType: { bindings: IToolBinding[] }

Type declaration

  • bindings: IToolBinding[]

    bindings for the toolGroup’s tool when it is set to be active

TextBoxHandle

TextBoxHandle: { hasMoved: boolean; worldBoundingBox: { bottomLeft: Types.Point3; bottomRight: Types.Point3; topLeft: Types.Point3; topRight: Types.Point3 }; worldPosition: Types.Point3 }

TextBox handle type specifying its location in the world including bottomLeft and topRight and bottomRight and topLeft points, and its center world coordinates.

Type declaration

ToolGroupSpecificContourRepresentation

ToolGroupSpecificContourRepresentation: ToolGroupSpecificRepresentationState & { config: ContourRenderingConfig; segmentSpecificConfig?: SegmentSpecificRepresentationConfig; segmentationRepresentationSpecificConfig?: RepresentationConfig }

ToolGroupSpecificLabelmapRepresentation

ToolGroupSpecificLabelmapRepresentation: ToolGroupSpecificRepresentationState & { config: LabelmapRenderingConfig; segmentSpecificConfig?: SegmentSpecificRepresentationConfig; segmentationRepresentationSpecificConfig?: RepresentationConfig }

ToolGroup Specific Segmentation Data for segmentations. As one segmentation can be represented in various ways (currently only labelmap is supported) we store ToolGroup specific segmentation data in this object

ToolGroupSpecificRepresentation

ToolGroupSpecificRepresentation: ToolGroupSpecificLabelmapRepresentation | ToolGroupSpecificContourRepresentation

ToolGroupSpecificRepresentationState

ToolGroupSpecificRepresentationState: { active: boolean; colorLUTIndex: number; segmentationId: string; segmentationRepresentationUID: string; segmentsHidden: Set<number>; type: Enums.SegmentationRepresentations }

Representation state of the segmentation which is common between all representations (we don’t need to separate these states for each representation)

Type declaration

  • active: boolean

    Whether the segmentation is the active (manipulatable) segmentation or not which means it is inactive

  • colorLUTIndex: number

    The index of the colorLUT from the state that this segmentationData is using to render

  • segmentationId: string

    The segmentationId that this representation is derived from

  • segmentationRepresentationUID: string

    Segmentation Representation UID

  • segmentsHidden: Set<number>

    Hidden segment indices in the segmentation

  • type: Enums.SegmentationRepresentations

    The representation type

ToolHandle

ToolHandle: AnnotationHandle | TextBoxHandle

Tool Handle type can be either AnnotationHandle or TextBoxHandle

ToolOptionsType

ToolOptionsType: { bindings: IToolBinding[]; mode: ToolModes }

Type declaration

  • bindings: IToolBinding[]

    bindings for the toolGroup’s tool when it is set to be active

  • mode: ToolModes

    mode of the tool

ToolProps

ToolProps: SharedToolProp