Skip to main content

StackViewport

An object representing a single stack viewport, which is a camera looking into an internal viewport, and an associated target output canvas.

StackViewports can be rendered using both GPU and a fallback CPU is the GPU is not available (or low performance). Read more about StackViewports in the documentation section of this website.

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • Constructor for the StackViewport class


    Parameters

    • props: ViewportInput

      ViewportInput

    Returns StackViewport

Properties

_actors

_actors: Map<string, any>

a Map containing the actor uid and actors

_suppressCameraModifiedEvents

_suppressCameraModifiedEvents: boolean = false

informs if a new actor was added before a resetCameraClippingRange phase

publicaddActor

addActor: (actorEntry: ActorEntry) => void

Type declaration

    • If the renderer is CPU based, throw an error. Otherwise, add the actor to the viewport


      Parameters

      • actorEntry: ActorEntry

        The ActorEntry object that was created by the user.

      Returns void

publicaddActors

addActors: (actors: ActorEntry[]) => void

Type declaration

    • If the renderer is CPU based, throw an error. Otherwise, add a list of actors to the viewport


      Parameters

      • actors: ActorEntry[]

        An array of ActorEntry objects.

      Returns void

readonlycanvas

canvas: HTMLCanvasElement

an internal canvas that is created on the provided HTML element

publiccanvasToWorld

canvasToWorld: (canvasPos: Point2) => Point3

Type declaration

    • canvasToWorld Returns the world coordinates of the given canvasPos projected onto the plane defined by the Viewport‘s camera.


      Parameters

      • canvasPos: Point2

        The position in canvas coordinates.

      Returns Point3

      The corresponding world coordinates.

readonlydefaultOptions

defaultOptions: Record<string, any>

Default options for the viewport which includes orientation, viewPlaneNormal and backgroundColor

readonlyelement

element: HTMLDivElement

HTML element in DOM that is used for rendering the viewport

publicgetActor

getActor: (actorUID: string) => ActorEntry

Type declaration

    • If the renderer is CPU based, throw an error. Otherwise, it returns the actor entry for the given actor UID.


      Parameters

      • actorUID: string

        The unique ID of the actor you want to get.

      Returns ActorEntry

      An ActorEntry object.

publicgetActors

getActors: () => ActorEntry[]

Type declaration

    • If the renderer is CPU based, throw an error. Otherwise, return the actors in the viewport


      Returns ActorEntry[]

      An array of ActorEntry objects.

publicgetCamera

getCamera: () => ICamera

Type declaration

    • If the user has selected CPU rendering, return the CPU camera, otherwise return the default camera


      Returns ICamera

      The camera object.

publicgetDefaultActor

getDefaultActor: () => ActorEntry

Type declaration

    • If the renderer is CPU based, throw an error. Otherwise, return the default actor which is the first actor in the renderer.


      Returns ActorEntry

      An actor entry.

publicgetImageData

getImageData: () => IImageData | CPUIImageData

Type declaration

    • Returns the image and its properties that is being shown inside the stack viewport. It returns, the image dimensions, image direction, image scalar data, vtkImageData object, metadata, and scaling (e.g., PET suvbw)


      Returns IImageData | CPUIImageData

      IImageData: dimensions, direction, scalarData, vtkImageData, metadata, scaling

publicgetRenderer

getRenderer: () => any

Type declaration

    • (): any
    • If the renderer is CPU based, throw an error. Otherwise, returns the vtkRenderer responsible for rendering the Viewport.


      Returns any

      The vtkRenderer for the Viewport.

publicgetRotation

getRotation: () => number

Type declaration

    • (): number
    • Returns number

readonlyid

id: string

unique identifier for the viewport

publicisDisabled

isDisabled: boolean

if the viewport has been disabled

publicmodality

modality: string

options

options for the viewport which includes orientation axis, backgroundColor and displayArea

publicremoveAllActors

removeAllActors: () => void

Type declaration

    • (): void
    • It throws an error if the renderer is CPU based. Otherwise, it removes the actors from the viewport.


      Returns void

readonlyrenderingEngineId

renderingEngineId: string

RenderingEngine id that the viewport belongs to

publicresetCamera

resetCamera: (resetPan?: boolean, resetZoom?: boolean) => boolean

Type declaration

    • (resetPan?: boolean, resetZoom?: boolean): boolean
    • Centers Pan and resets the zoom for stack viewport.


      Parameters

      • optionalresetPan: boolean
      • optionalresetZoom: boolean

      Returns boolean

sHeight

sHeight: number

sHeight of viewport on the offscreen canvas

sWidth

sWidth: number

sWidth of viewport on the offscreen canvas

publicscaling

scaling: Scaling

Scaling parameters

publicsetActors

setActors: (actors: ActorEntry[]) => void

Type declaration

    • If the renderer is CPU-based, throw an error; otherwise, set the actors in the viewport.


      Parameters

      • actors: ActorEntry[]

        An array of ActorEntry objects.

      Returns void

publicsetCamera

setCamera: (cameraInterface: ICamera, storeAsInitialCamera?: boolean) => void

Type declaration

    • (cameraInterface: ICamera, storeAsInitialCamera?: boolean): void
    • Set the camera based on the provided camera object.


      Parameters

      • cameraInterface: ICamera

        The camera interface that will be used to render the scene.

      • optionalstoreAsInitialCamera: boolean

      Returns void

publicstackActorReInitialized

stackActorReInitialized: boolean

readonlysuppressEvents

suppressEvents: boolean

A flag representing if viewport methods should fire events or not

sx

sx: number

sx of viewport on the offscreen canvas

sy

sy: number

sy of viewport on the offscreen canvas

readonlytype

Type of viewport

publicunsetColormap

unsetColormap: () => void

Type declaration

    • (): void
    • It sets the colormap to the default colormap.


      Returns void

publicviewportStatus

viewportStatus: ViewportStatus = ViewportStatus.NO_DATA

Record the rendering status, mostly for testing purposes, but can also be useful for knowing things like whether the viewport is initialized

publicworldToCanvas

worldToCanvas: (worldPos: Point3) => Point2

Type declaration

    • Returns the canvas coordinates of the given worldPos projected onto the Viewport‘s canvas.


      Parameters

      • worldPos: Point3

        The position in world coordinates.

      Returns Point2

      The corresponding canvas coordinates.

publicstaticreadonlyCameraViewPresentation

CameraViewPresentation: ViewPresentationSelector = ...

CameraViewPresentation is a view preentation selector that has all the camera related presentation selections, and would typically be used for choosing presentation information between two viewports showing the same type of orientation of a view, such as the CT, PT and fusion views in the same orientation view.

publicstaticreadonlyTransferViewPresentation

TransferViewPresentation: ViewPresentationSelector = ...

TransferViewPresentation is a view presentation selector that selects all the transfer function related attributes. It would typically be used for synchronizing different orientations of the same series, or for synchronizing two views of the same type of series such as a CT.

Accessors

staticuseCustomRenderingPipeline

  • get useCustomRenderingPipeline(): boolean
  • Returns boolean

Methods

_getCorners

  • _getCorners(bounds: number[]): number[][]
  • Parameters

    • bounds: number[]

    Returns number[][]

_getEdges

  • _getEdges(bounds: number[]): [number[], number[]][]
  • Returns a list of edges for the imageData bounds, which are the cube edges in the case of volumeViewport edges. p1: front, bottom, left p2: front, top, left p3: back, bottom, left p4: back, top, left p5: front, bottom, right p6: front, top, right p7: back, bottom, right p8: back, top, right


    Parameters

    • bounds: number[]

      Bounds of the renderer

    Returns [number[], number[]][]

    Edges of the containing bounds

_getFocalPointForResetCamera

  • _getFocalPointForResetCamera(centeredFocalPoint: Point3, previousCamera: ICamera, __namedParameters: Object): Point3
  • Parameters

    • centeredFocalPoint: Point3
    • previousCamera: ICamera
    • __namedParameters: Object

    Returns Point3

_isInBounds

  • _isInBounds(point: Point3, bounds: number[]): boolean
  • Determines whether or not the 3D point position is inside the boundaries of the 3D imageData.


    Parameters

    • point: Point3

      3D coordinate

    • bounds: number[]

      Bounds of the image

    Returns boolean

    boolean

_removeActor

  • _removeActor(actorUID: string): void
  • Remove the actor from the viewport


    Parameters

    • actorUID: string

      The unique identifier for the actor.

    Returns void

publicaddImages

  • This method is used to add images to the stack viewport. It takes an array of stack inputs, each containing an imageId and an actor UID. For each stack input, it retrieves the image from the cache and creates a VTK image data object. It then creates an actor mapper for the image data and adds it to the list of actors. Finally, it sets the actors for the stack viewport.


    Parameters

    • stackInputs: IStackInput[]

      An array of stack inputs, each containing an image ID and an actor UID.

    Returns Promise<void>

publicaddWidget

  • addWidget(widgetId: any, widget: any): void
  • Parameters

    • widgetId: any
    • widget: any

    Returns void

publiccalibrateSpacing

  • calibrateSpacing(imageId: string): void
  • Calibrates the image with new metadata that has been added for imageId. To calibrate a viewport, you should add your calibration data manually to calibratedPixelSpacingMetadataProvider and call viewport.calibrateSpacing for it get applied.


    Parameters

    • imageId: string

      imageId to be calibrated

    Returns void

publicclearDefaultProperties

  • clearDefaultProperties(imageId?: string): void
  • Remove the global default properties of the viewport or remove default properties for an imageId if specified


    Parameters

    • optionalimageId: string

      If given, we remove the default properties only for this imageID, if not the global default properties will be removed

    Returns void

createVTKImageData

  • createVTKImageData(__namedParameters: Object): vtkImageData
  • Parameters

    • __namedParameters: Object

    Returns vtkImageData

publiccustomRenderViewportToCanvas

  • customRenderViewportToCanvas(): { canvas: HTMLCanvasElement; element: HTMLDivElement; renderingEngineId: string; viewportId: string; viewportStatus: ViewportStatus }
  • Custom rendering pipeline for the rendering for the CPU fallback


    Returns { canvas: HTMLCanvasElement; element: HTMLDivElement; renderingEngineId: string; viewportId: string; viewportStatus: ViewportStatus }

    • canvas: HTMLCanvasElement
    • element: HTMLDivElement
    • renderingEngineId: string
    • viewportId: string
    • viewportStatus: ViewportStatus

publicerrorCallback

  • errorCallback(imageId: any, permanent: any, error: any): void
  • Parameters

    • imageId: any
    • permanent: any
    • error: any

    Returns void

publicgetActorByIndex

  • Get an actor by its index


    Parameters

    • index: number

      array index.

    Returns ActorEntry

    actorUID

publicgetActorUIDByIndex

  • getActorUIDByIndex(index: number): string
  • Get an actor UID by its index


    Parameters

    • index: number

      array index.

    Returns string

    actorUID

publicgetActorUIDs

  • getActorUIDs(): string[]
  • Returns an array of unique identifiers for all the actors in the viewport.


    Returns string[]

    An array of strings

publicgetCanvas

  • getCanvas(): HTMLCanvasElement
  • Gets the target output canvas for the Viewport.


    Returns HTMLCanvasElement

    an HTMLCanvasElement.

publicgetClippingPlanesForActor

  • getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[]
  • Method to get the clipping planes of a given actor


    Parameters

    • optionalactorEntry: ActorEntry

      The actor entry (a specific type you’ll define dependent on your code)

    Returns vtkPlane[]

    vtkPlanes - An array of vtkPlane objects associated with the given actor

publicgetCornerstoneImage

  • Returns the raw/loaded image being shown inside the stack viewport.


    Returns IImage

publicgetCurrentImageId

  • getCurrentImageId(): string
  • Returns the currently rendered imageId


    Returns string

    string for imageId

publicgetCurrentImageIdIndex

  • getCurrentImageIdIndex(): number
  • Returns the index of the imageId being renderer


    Returns number

    currently shown imageId index

publicgetDefaultProperties

  • Retrieve the viewport default properties


    Parameters

    • optionalimageId: string

      If given, we retrieve the default properties of an image index if it exists If not given,we return the global properties of the viewport

    Returns StackViewportProperties

    viewport properties including voi, invert, interpolation type, rotation, flip

publicgetDisplayArea

  • returns the displayArea


    Returns DisplayArea

publicgetFrameOfReferenceUID

  • getFrameOfReferenceUID(): string
  • Returns the frame of reference UID, if the image doesn’t have imagePlaneModule metadata, it returns undefined, otherwise, frameOfReferenceUID is returned.


    Returns string

    frameOfReferenceUID : string representing frame of reference id

publicgetImageDataMetadata

  • getImageDataMetadata(image: IImage): ImageDataMetaData
  • Calculates image metadata based on the image object. It calculates normal axis for the images, and output image metadata


    Parameters

    • image: IImage

      stack image containing cornerstone image

    Returns ImageDataMetaData

    image metadata: bitsAllocated, number of components, origin, direction, dimensions, spacing, number of voxels.

publicgetImageIds

  • getImageIds(): string[]
  • Returns the list of image Ids for the current viewport


    Returns string[]

    list of strings for image Ids

publicgetLoaderImageOptions

  • getLoaderImageOptions(imageId: string): { additionalDetails: { imageId: string; imageIdIndex: number }; preScale: { enabled: boolean }; priority: number; requestType: RequestType; targetBuffer: { type: string }; transferSyntaxUID: any; useNativeDataType: boolean; useRGBA: boolean }
  • Parameters

    • imageId: string

    Returns { additionalDetails: { imageId: string; imageIdIndex: number }; preScale: { enabled: boolean }; priority: number; requestType: RequestType; targetBuffer: { type: string }; transferSyntaxUID: any; useNativeDataType: boolean; useRGBA: boolean }

    • additionalDetails: { imageId: string; imageIdIndex: number }
      • imageId: string
      • imageIdIndex: number
    • preScale: { enabled: boolean }
      • enabled: boolean
    • priority: number
    • requestType: RequestType
    • targetBuffer: { type: string }
      • type: string
    • transferSyntaxUID: any
    • useNativeDataType: boolean
    • useRGBA: boolean

publicgetNumberOfSlices

  • getNumberOfSlices(): number
  • Gets the number of slices


    Returns number

publicgetPan

  • Helper function to return the current canvas pan value.


    Parameters

    Returns Point2

    a Point2 containing the current pan values on the canvas, computed from the current camera, where the initial pan value is [0,0].

publicgetProperties

  • Retrieve the viewport properties


    Returns StackViewportProperties

    viewport properties including voi, invert, interpolation type, rotation, flip

publicgetReferenceId

  • Gets a referenced image url of some sort - could be a real image id, or could be a URL with parameters


    Parameters

    Returns string

publicgetRenderingEngine

  • Returns the rendering engine driving the Viewport.


    Returns default

    The RenderingEngine instance.

publicgetSliceIndex

  • getSliceIndex(): number
  • Returns number

publicgetTargetImageIdIndex

  • getTargetImageIdIndex(): number
  • Returns the imageIdIndex that is targeted to be loaded, in case of debounced loading (with scroll), the targetImageIdIndex is the latest imageId index that is requested to be loaded but debounced.


    Returns number

publicgetViewPresentation

  • Gets a view presentation information specifying HOW a viewport displays something, but not what is being displayed. See getViewReference to get information on WHAT is being displayed.

    This is intended to have information on how an image is presented to the user, without specifying what image s displayed. All of this information is available externally, but this method combines the parts of this that are appropriate for remember or applying to other views, without necessarily needing to know what all the atributes are. That differs from methods like getCamera which fetch exact view details that are not likely to be identical between viewports as they change sizes or apply to different images.

    Note that the results of this can be used on different viewports, for example, the pan values can be applied to a volume viewport showing a CT, and a stack viewport showing an ultrasound.

    The selector allows choosing which view presentation attributes to return. Some default values are available from Viewport.CameraViewPresentation and Viewport.TransferViewPresentation


    Parameters

    Returns ViewPresentation

publicgetViewReference

  • Gets a standard target to show this image instance.


    Parameters

    Returns ViewReference

publicgetWidget

  • getWidget(id: any): any
  • Parameters

    • id: any

    Returns any

publicgetWidgets

  • getWidgets(): any[]
  • Returns any[]

publicgetZoom

  • getZoom(compareCamera?: ICamera): number
  • Returns a current zoom level relative to the initial parallel scale originally applied to the image. That is, on initial display, the zoom level is 1. Computed as a function of the camera.


    Parameters

    Returns number

publichasImageId

  • hasImageId(imageId: string): boolean
  • Returns true if the viewport contains the given imageId


    Parameters

    • imageId: string

      imageId

    Returns boolean

    boolean if imageId is in viewport

publichasImageURI

  • hasImageURI(imageURI: string): boolean
  • Returns true if the viewport contains the given imageURI (no data loader scheme)


    Parameters

    • imageURI: string

      imageURI

    Returns boolean

    boolean if imageURI is in viewport

publicisReferenceViewable

  • Checks to see if this target is or could be shown in this viewport


    Parameters

    Returns boolean

publicloadImages

  • Parameters

    Returns Promise<unknown>

publicremoveActors

  • removeActors(actorUIDs: string[]): void
  • Remove the actors with the given UIDs from the viewport


    Parameters

    • actorUIDs: string[]

      An array of actor UIDs to remove.

    Returns void

publicremoveWidgets

  • removeWidgets(): void
  • Returns void

publicrender

  • render(): void
  • Renders the Viewport using the RenderingEngine.


    Returns void

publicrenderImageObject

  • renderImageObject(image: any): void
  • Renders the given Cornerstone image object in the viewport. This method is intended to be used by utilities to render an individual image, rather than by applications that want to display a complete image stack. If you want to load and display a complete image stack, use the setStack method instead of this one.

    The rendered image will appear in the viewport’s element. Use this method if you have other means of loading and the cornerstone image object is already available.

    If you don’t understand the difference between this method and setStack, you probably want to use setStack.


    Parameters

    • image: any

      The Cornerstone image object to render.

    Returns void

publicreset

  • reset(immediate?: boolean): void
  • Resets the options the Viewport‘s defaultOptions


    Parameters

    • immediate: boolean = false

      If true, renders the viewport after the options are reset.

    Returns void

publicresetProperties

  • resetProperties(): void
  • Reset the viewport properties to the default values


    Returns void

publicresetToDefaultProperties

  • resetToDefaultProperties(): void
  • Reset the viewport properties to the his default values if possible


    Returns void

publicresize

  • resize(): void
  • Resizes the viewport - only used in CPU fallback for StackViewport. The GPU resizing happens inside the RenderingEngine.


    Returns void

publicscroll

  • scroll(delta: number, debounce?: boolean, loop?: boolean): void
  • It scrolls the stack of imageIds by the delta amount provided. If the debounce flag is set, it will only scroll the stack if the delta is greater than the debounceThreshold which is 40 milliseconds by default.


    Parameters

    • delta: number

      number of indices to scroll, it can be positive or negative

    • debounce: boolean = true

      whether to debounce the scroll event

    • loop: boolean = false

      whether to loop the stack

    Returns void

publicsetDefaultProperties

  • Update the default properties of the viewport and add properties by imageId if specified


    Parameters

    • ViewportProperties: StackViewportProperties

      The properties to set

    • optionalimageId: string

      If given, we set the default properties only for this image index, if not the default properties will be set for all imageIds

    Returns void

publicsetDisplayArea

  • setDisplayArea(displayArea: DisplayArea, suppressEvents?: boolean): void
  • Sets the camera to an initial bounds. If resetPan and resetZoom are true it places the focal point at the center of the volume (or slice); otherwise, only the camera zoom and camera Pan or Zoom is reset for the current view.


    Parameters

    • displayArea: DisplayArea

      The display area of interest.

    • suppressEvents: boolean = false

      If true, don’t fire displayArea event.

    Returns void

publicsetImageIdIndex

  • setImageIdIndex(imageIdIndex: number): Promise<string>
  • Loads the image based on the provided imageIdIndex. It is an Async function which returns a promise that resolves to the imageId.


    Parameters

    • imageIdIndex: number

      number represents imageId index in the list of provided imageIds in setStack

    Returns Promise<string>

publicsetOptions

  • Sets new options and (TODO) applies them.


    Parameters

    • options: ViewportInputOptions

      The viewport options to set.

    • immediate: boolean = false

      If true, renders the viewport after the options are set.

    Returns void

publicsetOrientationOfClippingPlanes

  • setOrientationOfClippingPlanes(vtkPlanes: vtkPlane[], slabThickness: number, viewPlaneNormal: Point3, focalPoint: Point3): void
  • Parameters

    • vtkPlanes: vtkPlane[]
    • slabThickness: number
    • viewPlaneNormal: Point3
    • focalPoint: Point3

    Returns void

publicsetPan

  • setPan(pan: Point2, storeAsInitialCamera?: boolean): void
  • Sets the canvas pan value relative to the initial view position of 0,0 Modifies the camera to perform the pan.


    Parameters

    • pan: Point2
    • storeAsInitialCamera: boolean = false

    Returns void

publicsetProperties

  • Configures the properties of the viewport. This method allows customization of the viewport by setting attributes like VOI (Value of Interest), color inversion, interpolation type, and image rotation. If setProperties is called for the first time, the provided properties will become the default settings for all images in the stack in case the resetPropertiese need to be called


    Parameters

    • properties: StackViewportProperties = {}

      An object containing the properties to be set.

    • suppressEvents: boolean = false

      A boolean value to control event suppression. If true, the related events will not be triggered. Default is false.

    Returns void

publicsetRendered

  • setRendered(): void
  • Indicate that the image has been rendered. This will set the viewportStatus to RENDERED if there is image data available to actually be rendered - otherwise, the rendering simply showed the background image.


    Returns void

publicsetStack

  • setStack(imageIds: string[], currentImageIdIndex?: number): Promise<string>
  • Sets the imageIds to be visualized inside the stack viewport. It accepts list of imageIds, the index of the first imageId to be viewed. It is a asynchronous function that returns a promise resolving to imageId being displayed in the stack viewport.


    Parameters

    • imageIds: string[]

      list of strings, that represents list of image Ids

    • currentImageIdIndex: number = 0

      number representing the index of the initial image to be displayed

    Returns Promise<string>

publicsetUseCPURendering

  • setUseCPURendering(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

publicsetView

  • Applies the view reference, which may navigate the slice index and apply other camera modifications


    Parameters

    Returns void

publicsetZoom

  • setZoom(value: number, storeAsInitialCamera?: boolean): void
  • Zooms the image using parallel scale by updating the camera value.


    Parameters

    • value: number

      The relative parallel scale to apply. It is relative to the initial offsets value.

    • storeAsInitialCamera: boolean = false

      can be set to true to reset the camera after applying this zoom as the initial camera. A subsequent getZoom call will return “1”, but the zoom will have been applied.

    Returns void

publicsuccessCallback

  • successCallback(imageId: any, image: any): void
  • Parameters

    • imageId: any
    • image: any

    Returns void

publictriggerCameraModifiedEventIfNecessary

  • triggerCameraModifiedEventIfNecessary(previousCamera: ICamera, updatedCamera: ICamera): void
  • Trigger camera modified event


    Parameters

    Returns void

publicupdateCameraClippingPlanesAndRange

  • updateCameraClippingPlanesAndRange(): void
  • Updates the camera’s clipping planes and range.


    Returns void

publicupdateRenderingPipeline

  • updateRenderingPipeline(): void
  • Returns void

staticboundsRadius

  • boundsRadius(bounds: number[]): number
  • Computes the bounds radius value


    Parameters

    • bounds: number[]

    Returns number