Skip to main content

Types

Index

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 }

Type declaration

  • [toolName string]: AnnotationStyle
  • optionalglobal?: AnnotationStyle

CINETypes

CINETypes:

ToolData

ToolData:

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

PlayClipOptions

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

Type declaration

  • 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

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: NormalizedMouseEventDetail & { currentPoints: IPoints; deltaPoints: IPoints; lastPoints: IPoints; mouseButton: number; startPoints: IPoints }

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

MouseClickEventType

MouseClickEventType: Types.CustomEventType<MouseClickEventDetail>

Event for mouse click

MouseDoubleClickEventDetail

MouseDoubleClickEventDetail: NormalizedMouseEventDetail & { currentPoints: IPoints; deltaPoints: IPoints; lastPoints: IPoints; startPoints: IPoints }

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

MouseDoubleClickEventType

MouseDoubleClickEventType: Types.CustomEventType<MouseDoubleClickEventDetail>

Event for mouse double click

MouseDownActivateEventDetail

MouseDownActivateEventDetail: NormalizedMouseEventDetail & { currentPoints: IPoints; deltaPoints: IPoints; lastPoints: IPoints; mouseButton: number; startPoints: IPoints }

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: NormalizedMouseEventDetail & { currentPoints: IPoints; deltaPoints: IPoints; lastPoints: IPoints; mouseButton: number; startPoints: IPoints }

EventDetail for mouseDown event

MouseDownEventType

MouseDownEventType: Types.CustomEventType<MouseDownEventDetail>

Event for when a mouse button is pressed

MouseDragEventDetail

MouseDragEventDetail: NormalizedMouseEventDetail & { currentPoints: IPoints; deltaPoints: IPoints; lastPoints: IPoints; mouseButton: number; startPoints: IPoints }

EventDetail for mouseDrag event

MouseDragEventType

MouseDragEventType: Types.CustomEventType<MouseDragEventDetail>

Event for mouse drag

MouseMoveEventDetail

MouseMoveEventDetail: NormalizedMouseEventDetail & { currentPoints: IPoints }

EventDetail mouseMove event

MouseMoveEventType

MouseMoveEventType: Types.CustomEventType<MouseMoveEventDetail>

Event for mouse move

MouseUpEventDetail

MouseUpEventDetail: NormalizedMouseEventDetail & { currentPoints: IPoints; deltaPoints: IPoints; lastPoints: IPoints; mouseButton: number; startPoints: IPoints }

EventDetail for mouseUp event

MouseUpEventType

MouseUpEventType: Types.CustomEventType<MouseUpEventDetail>

Event for mouse up

MouseWheelEventDetail

MouseWheelEventDetail: NormalizedMouseEventDetail & { 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

NormalizedMouseEventDetail

NormalizedMouseEventDetail: { camera: Record<string, unknown>; element: HTMLDivElement; event: Record<string, unknown> | MouseEvent; eventName: string; renderingEngineId: string; viewportId: string }

The normalized mouse 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.

  • event: Record<string, unknown> | MouseEvent

    The original event object.

  • 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<NormalizedMouseEventDetail>

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

LabelmapTypes

LabelmapTypes:

LabelmapConfig

LabelmapConfig: { fillAlpha?: number; fillAlphaInactive?: 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

  • 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.

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 } }; 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: { 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

  • 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

Interfaces

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

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

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

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

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

getViewportIds

  • getViewportIds(): string[]
  • Get viewportIds in the toolGroup


    Returns string[]

getViewportsInfo

  • Get viewports info in the toolGroup


    Returns default[]

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.

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

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], ….]

FrameOfReferenceSpecificAnnotations

FrameOfReferenceSpecificAnnotations: {}

FrameOfReferenceSpecificAnnotations which has all annotations from all tools for the each frame of reference.


Type declaration

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 }

Type declaration

  • optionalmodifierKey?: ToolBindingKeyboardType

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

  • mouseButton: ToolBindingMouseType

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

InteractionTypes

InteractionTypes: Mouse

Supported Interactions for tools

JumpToSliceOptions

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

Type declaration

  • optionaldebounceLoading?: boolean
  • imageIndex: number

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: { LABELMAP?: LabelmapConfig }

Segmentation Config


Type declaration

  • 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: { svgLayerElement: HTMLDivElement; svgNodeCacheForCanvas: Record<string, unknown>; appendNode: any; clearUntouched: any; getSvgNode: any; setNodeTouched: any }

Type declaration

  • svgLayerElement: HTMLDivElement
  • svgNodeCacheForCanvas: Record<string, unknown>
  • appendNode: function
    • appendNode(svgNode: SVGElement, cacheKey: string): void

    • Parameters

      • svgNode: SVGElement
      • cacheKey: string

      Returns void

  • clearUntouched: function
    • clearUntouched(): void

    • Returns void

  • getSvgNode: function
    • getSvgNode(cacheKey: string): SVGGElement

    • Parameters

      • cacheKey: string

      Returns SVGGElement

  • setNodeTouched: function
    • setNodeTouched(cacheKey: string): void

    • Parameters

      • cacheKey: string

      Returns void

SVGPoint

SVGPoint: { x: number; y: number }

Type declaration

  • x: number
  • y: number

ScrollOptions

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

Type declaration

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

Segmentation

Segmentation: { activeSegmentIndex: number; cachedStats: {}; label: string; representationData: SegmentationRepresentationData; 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)

  • 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: { LABELMAP?: LabelmapSegmentationData }

Type declaration

  • optionalLABELMAP?: LabelmapSegmentationData

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: {
point: Float32Array,
},
},
},
{
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(),
// LabelmapRenderingConfig
config: {
"cfun",
"ofun",
},
},
],
config: {
renderInactiveSegmentations: false,
representations: {
LABELMAP: {
renderFill: true,
renderOutline: true,
},
},
},
},
},
}

Type declaration

  • colorLUT: ColorLUT[]

    Array of colorLUT for segmentation to render

  • globalConfig: SegmentationRepresentationConfig

    global segmentation state with config

  • segmentations: Segmentation[]

    segmentations

  • toolGroups: {}

    ToolGroup specific segmentation state with config

    • [key string]: { config: SegmentationRepresentationConfig; segmentationRepresentations: ToolGroupSpecificRepresentations }

      toolGroupId and their toolGroup specific segmentation state with config

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

ToolGroupSpecificLabelmapRepresentation

ToolGroupSpecificLabelmapRepresentation: ToolGroupSpecificRepresentationState & { config: LabelmapRenderingConfig }

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

ToolGroupSpecificRepresentationState

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

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

  • visibility: boolean

    Whether the segmentation is visible

ToolHandle

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