utilities

Index

References

triggerEvent

Namespaces

Variables

Functions

References

triggerEvent

Re-exports triggerEvent

Namespaces

colormap

colormap:

getColormap

getColormap(name: any): any

Get a colormap by name
Parameters
- name: any
  name of the colormap
Returns any
colormap object

getColormapNames

getColormapNames(): any[]

Get all registered colormap names
Returns any[]
array of colormap names

registerColormap

registerColormap(colormap: ColormapRegistration): void

planar

planar:

linePlaneIntersection

linePlaneIntersection(p0: Point3, p1: Point3, plane: Plane): Point3

It calculates the intersection of a line and a plane. Plane equation is Ax+By+Cz=D
Parameters
- p0: Point3
  [x,y,z] of the first point of the line
- p1: Point3
  [x,y,z] of the second point of the line
- plane: Plane
  [A, B, C, D] Plane parameter: Ax+By+Cz=D
Returns Point3
- [X,Y,Z] coordinates of the intersection

planeDistanceToPoint

planeDistanceToPoint(plane: Plane, point: Point3, signed?: boolean): number

Computes the distance of a point in 3D space to a plane
Parameters
- plane: Plane
  [A, B, C, D] of plane equation AX + BY + C*Z = D
- point: Point3
  [A, B, C] the plane in World coordinate
- signed: boolean = false
  if true, the distance is signed
Returns number
- the distance of the point to the plane

planeEquation

planeEquation(normal: Point3, point: Point3 | vec3): Plane

It returns the plane equation defined by a point and a normal vector.
Parameters
- normal: Point3
  normal vector
- point: Point3 | vec3
  a point on the plane
Returns Plane
- [A, B,C, D] of plane equation AX + BY + C*Z = D

threePlaneIntersection

threePlaneIntersection(firstPlane: Plane, secondPlane: Plane, thirdPlane: Plane): Point3

Computes the intersection of three planes in 3D space with equations: A1X + B1Y + C1Z = D1 A2X + B2Y + C2Z = D2 A3X + B3Y + C3*Z = D3
Parameters
- firstPlane: Plane
- secondPlane: Plane
- thirdPlane: Plane
Returns Point3
- [x, y, z] the intersection in the world coordinate

windowLevel

windowLevel:

toLowHighRange

toLowHighRange(windowWidth: number, windowCenter: number): { lower: number; upper: number }

Given a window width and center, return the lower and upper bounds of the window
Parameters
- windowWidth: number
  the width of the window in HU
- windowCenter: number
  The center of the window.
Returns { lower: number; upper: number }
a JavaScript object with two properties: lower and upper.
- lower: number
- upper: number

toWindowLevel

toWindowLevel(low: number, high: number): { windowCenter: number; windowWidth: number }

Given a low and high window level, return the window width and window center
Parameters
- low: number
  The low window level.
- high: number
  The high window level.
Returns { windowCenter: number; windowWidth: number }
a JavaScript object with two properties: windowWidth and windowCenter.
- windowCenter: number
- windowWidth: number

Variables

constcalibratedPixelSpacingMetadataProvider

calibratedPixelSpacingMetadataProvider: { add: (imageId: string, payload: CalibratedPixelValue) => void; get: (type: string, imageId: string) => CalibratedPixelValue } = ...

Simple metadataProvider object to store metadata for calibrated spacings. This can be added via cornerstone.metaData.addProvider(…) in order to store and return calibrated pixel spacings when metaData type is “calibratedPixelSpacing”.

Type declaration

add: (imageId: string, payload: CalibratedPixelValue) => void
- - (imageId: string, payload: CalibratedPixelValue): void
  - Adds metadata for an imageId.
    Parameters
    - imageId: string
      the imageId for the metadata to store
    - payload: CalibratedPixelValue
      the payload composed of new calibrated pixel spacings
    Returns void
get: (type: string, imageId: string) => CalibratedPixelValue
- - (type: string, imageId: string): CalibratedPixelValue
  - Returns the metadata for an imageId if it exists.
    Parameters
    - type: string
      the type of metadata to enquire about
    - imageId: string
      the imageId to enquire about
    Returns CalibratedPixelValue
    the calibrated pixel spacings for the imageId if it exists, otherwise undefined

constspatialRegistrationMetadataProvider

spatialRegistrationMetadataProvider: { add: (query: string[], payload: mat4) => void; get: (type: string, query: string[]) => mat4 } = ...

Simple metadataProvider object to store metadata for spatial registration module.

Type declaration

add: (query: string[], payload: mat4) => void
- - (query: string[], payload: mat4): void
  - Parameters
    - query: string[]
    - payload: mat4
    Returns void
get: (type: string, query: string[]) => mat4
- - (type: string, query: string[]): mat4
  - Parameters
    - type: string
    - query: string[]
    Returns mat4

Functions

actorIsA

actorIsA(actorEntry: ActorEntry, actorType: actorTypes): boolean

Parameters
- actorEntry: ActorEntry
- actorType: actorTypes
Returns boolean

applyPreset

applyPreset(actor: vtkVolume, preset: ViewportPreset): void

Applies a preset to a volume actor.
Parameters
- actor: vtkVolume
  The volume actor to apply the preset to.
- preset: ViewportPreset
  The preset to apply.
Returns void

calculateViewportsSpatialRegistration

calculateViewportsSpatialRegistration(viewport1: default, viewport2: default): void

It calculates the registration matrix between two viewports (currently only translation is supported) If the viewports are in the same frame of reference, it will return early, but otherwise it will use the current image’s metadata to calculate the translation between the two viewports and adds it to the spatialRegistrationModule metadata provider
Parameters
- viewport1: default
  The first stack viewport
- viewport2: default
  The second stack viewport
Returns void

publiccreateFloat32SharedArray

createFloat32SharedArray(length: number): Float32Array

A helper function that creates a new Float32Array that utilized a shared array buffer. This allows the array to be updated simultaneously in workers or the main thread. Depending on the system (the CPU, the OS, the Browser) it can take a while until the change is propagated to all contexts.
@see
SharedArrayBuffer
@remarks
We use SharedArrayBuffers in our ImageCache class. It’s what allows us to stream data to build a volume. It’s important to note that SharedArrayBuffer does not work out of the box for all web browsers. In some, it is disabled behind a flag; in others, it has been removed entirely.
@example
Creating an array for a Volume with known dimensions:
const dimensions = [512, 512, 25]; const scalarData = createFloat32SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
Parameters
- length: number
  frame size * number of frames
Returns Float32Array
a Float32Array with an underlying SharedArrayBuffer

publiccreateInt16SharedArray

createInt16SharedArray(length: number): Int16Array

A helper function that creates a new Int16 that utilized a shared array buffer. This allows the array to be updated simultaneously in workers or the main thread. Depending on the system (the CPU, the OS, the Browser) it can take a while until the change is propagated to all contexts.
@see
SharedArrayBuffer
@remarks
We use SharedArrayBuffers in our ImageCache class. It’s what allows us to stream data to build a volume. It’s important to note that SharedArrayBuffer does not work out of the box for all web browsers. In some, it is disabled behind a flag; in others, it has been removed entirely.
@example
Creating an array for a Volume with known dimensions:
const dimensions = [512, 512, 25]; const scalarData = createInt16SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
Parameters
- length: number
  frame size * number of frames
Returns Int16Array
a Int8Array with an underlying SharedArrayBuffer

createLinearRGBTransferFunction

createLinearRGBTransferFunction(voiRange: VOIRange): vtkColorTransferFunction

Parameters
- voiRange: VOIRange
Returns vtkColorTransferFunction

createSigmoidRGBTransferFunction

createSigmoidRGBTransferFunction(voiRange: VOIRange, approximationNodes?: number): vtkColorTransferFunction

A utility that can be used to generate an Sigmoid RgbTransferFunction. Sigmoid transfer functions are used in the dicom specification: https://dicom.nema.org/medical/dicom/2018b/output/chtml/part03/sect_C.11.2.html
@example
Setting an RGB Transfer function from the viewport:
const sigmoidRGBTransferFunction = createSigmoidRGBTransferFunction(0, 255, { lower: 0, upper: 255} ); viewport .getActor() .getProperty() .setRGBTransferFunction(0, sigmoidRGBTransferFunction);
@see
ColorTransferFunction
Parameters
- voiRange: VOIRange
- approximationNodes: number = 1024
Returns vtkColorTransferFunction

publiccreateUint16SharedArray

createUint16SharedArray(length: number): Uint16Array

A helper function that creates a new Uint16 that utilized a shared array buffer. This allows the array to be updated simultaneously in workers or the main thread. Depending on the system (the CPU, the OS, the Browser) it can take a while until the change is propagated to all contexts.
@see
SharedArrayBuffer
@remarks
We use SharedArrayBuffers in our ImageCache class. It’s what allows us to stream data to build a volume. It’s important to note that SharedArrayBuffer does not work out of the box for all web browsers. In some, it is disabled behind a flag; in others, it has been removed entirely.
@example
Creating an array for a Volume with known dimensions:
const dimensions = [512, 512, 25]; const scalarData = createUint16SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
Parameters
- length: number
  frame size * number of frames
Returns Uint16Array
a Uint8Array with an underlying SharedArrayBuffer

publiccreateUint8SharedArray

createUint8SharedArray(length: number): Uint8Array

A helper function that creates a new Float32Array that utilized a shared array buffer. This allows the array to be updated simultaneously in workers or the main thread. Depending on the system (the CPU, the OS, the Browser) it can take a while until the change is propagated to all contexts.
@see
SharedArrayBuffer
@remarks
We use SharedArrayBuffers in our ImageCache class. It’s what allows us to stream data to build a volume. It’s important to note that SharedArrayBuffer does not work out of the box for all web browsers. In some, it is disabled behind a flag; in others, it has been removed entirely.
@example
Creating an array for a Volume with known dimensions:
const dimensions = [512, 512, 25]; const scalarData = createUint8SharedArray(dimensions[0] * dimensions[1] * dimensions[2]);
Parameters
- length: number
  frame size * number of frames
Returns Uint8Array
a Uint8Array with an underlying SharedArrayBuffer

deepMerge

deepMerge(target?: {}, source?: {}, optionsArgument?: any): any

Merge two objects, recursively merging any objects that are arrays
Parameters
- target: {} = {}
  The target object.
- source: {} = {}
  The source object to merge into the target object.
- optionsArgument: any = undefined
  The options object.
Returns any
The merged object.

getClosestImageId

getClosestImageId(imageVolume: IImageVolume, worldPos: Point3, viewPlaneNormal: Point3): string

Given an image, a point in space and the viewPlaneNormal it returns the closest imageId of the image volume that is within half voxel spacing of the point in space.
Parameters
- imageVolume: IImageVolume
  The image volume
- worldPos: Point3
  The position in the world coordinate system (from mouse click)
- viewPlaneNormal: Point3
  The normal vector of the viewport
Returns string
The imageId for the tool.

getClosestStackImageIndexForPoint

getClosestStackImageIndexForPoint(point: Point3, viewport: default): number | null

Given a point in 3D space and a viewport it returns the index of the closest imageId, it assumes that stack images are sorted according to their sliceLocation
Parameters
- point: Point3
  [A, B, C] coordinates of the point in 3D space
- viewport: default
  The StackViewport to search for the closest imageId
Returns number | null
The imageId index of the closest imageId or null if no imageId is found

getImageLegacy

getImageLegacy(element: HTMLDivElement): Types.IImage | undefined

Gets the IImage rendered by the given element. This is provided as a convenience for the legacy cornerstone getImage function. However it is encouraged for IStackViewport.getImage to be used instead.
Parameters
- element: HTMLDivElement
  the element rendering/containing the image
Returns Types.IImage | undefined
the image

getImageSliceDataForVolumeViewport

getImageSliceDataForVolumeViewport(viewport: default): ImageSliceData

It calculates the number of slices and the current slice index for a given Volume viewport
Parameters
- viewport: default
  volume viewport
Returns ImageSliceData
An object with two properties: numberOfSlices and imageIndex.

getMinMax

getMinMax(storedPixelData: number[]): { max: number; min: number }

Calculate the minimum and maximum values in an Array
Parameters
- storedPixelData: number[]
  The pixel data to calculate the min and max values for
Returns { max: number; min: number }
an object with two properties: min and max
- max: number
- min: number

getRuntimeId

getRuntimeId(context?: unknown, separator?: string, max?: number): string

Generate a unique numeric ID string valid during a single runtime session;
Parameters
- optionalcontext: unknown
  An optional object to be used as context. Defaults to a global context;
- optionalseparator: string
  The component separator. Defaults to “-“;
- optionalmax: number
  The maximum component value. Defaults to 4294967295;
Returns string
The string representation of the the unique ID;

getScalarDataType

getScalarDataType(scalingParameters: ScalingParameters, scalarData?: any): string

If the scalar data is a Uint8Array, return ‘Uint8Array’. If the scalar data is a Float32Array, return ‘Float32Array’. If the scalar data is a Int16Array, return ‘Int16Array’. If the scalar data is a Uint16Array, return ‘Uint16Array’. If the scalar data is none of the above, throw an error.
Parameters
- scalingParameters: ScalingParameters
  {
- optionalscalarData: any
  The data to be converted.
Returns string
The data type of the scalar data.

getScalingParameters

getScalingParameters(imageId: string): ScalingParameters

It returns the scaling parameters for the image with the given imageId. This can be used to get passed (as an option) to the imageLoader in order to apply scaling to the image inside the imageLoader.
Parameters
- imageId: string
  The imageId of the image
Returns ScalingParameters
ScalingParameters

getSliceRange

getSliceRange(volumeActor: vtkVolume, viewPlaneNormal: Point3, focalPoint: Point3): ActorSliceRange

Given a vtkVolumeActor, and a normal direction, calculate the range of slices in the focal normal direction that encapsulate the volume. Also project the focalPoint onto this range.
Parameters
- volumeActor: vtkVolume
  The vtkVolumeActor.
- viewPlaneNormal: Point3
  The normal to the camera view.
- focalPoint: Point3
  The focal point of the camera.
Returns ActorSliceRange
an object containing the min, max and current positions in the normal direction.

getSpacingInNormalDirection

getSpacingInNormalDirection(imageVolume: IImageVolume, viewPlaneNormal: Point3): number

Given an imageVolume and a normal direction (viewPlaneNormal), calculates the spacing between voxels in the normal direction. If (viewPlaneNormal) is parallel to one of the directions you will obtain the spacing in that direction. Otherwise each of the imageVolume‘s directions are projected onto the volume, so that you obtain a spacing of the order of “seeing a new set of voxels if the camera where to dolly”.
Parameters
- imageVolume: IImageVolume
  The image volume to calculate the spacing in the normal direction.
- viewPlaneNormal: Point3
  The normal direction of the view plane.
Returns number

getTargetVolumeAndSpacingInNormalDir

getTargetVolumeAndSpacingInNormalDir(viewport: default, camera: ICamera, targetVolumeId?: string): { actorUID: string; imageVolume: IImageVolume; spacingInNormalDirection: number }

Given a volume viewport and camera, find the target volume. The imageVolume is retrieved from cache for the specified targetVolumeId or in case it is not provided, it chooses the volumeId on the viewport (there might be more than one in case of fusion) that has the finest resolution in the direction of view (normal).
Parameters
- viewport: default
  volume viewport
- camera: ICamera
  current camera
- optionaltargetVolumeId: string
  If a target volumeId is given that volume is forced to be used.
Returns { actorUID: string; imageVolume: IImageVolume; spacingInNormalDirection: number }
An object containing the imageVolume and spacingInNormalDirection.
- actorUID: string
- imageVolume: IImageVolume
- spacingInNormalDirection: number

getViewportImageCornersInWorld

getViewportImageCornersInWorld(viewport: default | default): Point3[]

Given a viewport, return the corners of the image in the viewport in world coordinates. Note that this is different than the corners of the canvas in world coordinates since an image can be zoomed out and the canvas can be larger than the image; hence, the corners of the canvas in world coordinates will be outside the image.
Parameters
- viewport: default | default
  The viewport to get the corners of.
Returns Point3[]
The corners of the image in the viewport in world coordinates.

getViewportsWithImageURI

getViewportsWithImageURI(imageURI: string, renderingEngineId?: string): Viewport[]

Get the viewport that is rendering the image with the given imageURI (imageId without the loader schema), this can be a stackViewport or a volumeViewport.
Parameters
- imageURI: string
  The imageURI of the image that is requested
- optionalrenderingEngineId: string
Returns Viewport[]
A Viewport

getViewportsWithVolumeId

getViewportsWithVolumeId(volumeId: string, renderingEngineId?: string): IVolumeViewport[]

Similar to getVolumeViewportsContainingSameVolumes, but uses the volumeId to filter viewports that contain the same volume.
Parameters
- volumeId: string
- optionalrenderingEngineId: string
Returns IVolumeViewport[]
VolumeViewport viewports array

getVoiFromSigmoidRGBTransferFunction

getVoiFromSigmoidRGBTransferFunction(cfun: vtkColorTransferFunction): [number, number]

Parameters
- cfun: vtkColorTransferFunction
Returns [number, number]

getVolumeActorCorners

getVolumeActorCorners(volumeActor: any): Point3[]

Converts vtkVolumeActor bounds to corners in world space.
Parameters
- volumeActor: any
  The vtkVolumeActor.
Returns Point3[]
An array of the corners of the volumeActor in world space.

getVolumeSliceRangeInfo

getVolumeSliceRangeInfo(viewport: default, volumeId: string): { camera: ICamera; sliceRange: ActorSliceRange; spacingInNormalDirection: number }

Calculates the slice range for the given volume based on its orientation
Parameters
- viewport: default
  Volume viewport
- volumeId: string
  Id of one of the volumes loaded on the given viewport
Returns { camera: ICamera; sliceRange: ActorSliceRange; spacingInNormalDirection: number }
slice range information
- camera: ICamera
- sliceRange: ActorSliceRange
- spacingInNormalDirection: number

getVolumeViewportScrollInfo

getVolumeViewportScrollInfo(viewport: default, volumeId: string): { currentStepIndex: number; numScrollSteps: number; sliceRangeInfo: { camera: ICamera; sliceRange: ActorSliceRange; spacingInNormalDirection: number } }

Calculates the number os steps the volume can scroll based on its orientation
Parameters
- viewport: default
  Volume viewport
- volumeId: string
  Id of one of the volumes loaded on the given viewport
Returns { currentStepIndex: number; numScrollSteps: number; sliceRangeInfo: { camera: ICamera; sliceRange: ActorSliceRange; spacingInNormalDirection: number } }
number of steps the volume can scroll and its current position
- currentStepIndex: number
- numScrollSteps: number
- sliceRangeInfo: { camera: ICamera; sliceRange: ActorSliceRange; spacingInNormalDirection: number }
  - camera: ICamera
  - sliceRange: ActorSliceRange
  - spacingInNormalDirection: number

getVolumeViewportsContainingSameVolumes

getVolumeViewportsContainingSameVolumes(targetViewport: default, renderingEngineId?: string): IVolumeViewport[]

Returns the viewports containing the same volume actors (all actors) the same as the target viewport. If renderingEngineId is provided, it will only return viewports that are associated with the renderingEngineId; otherwise, it will return search in all rendering engines.

This method is useful for finding viewports that are associated with the same volume (e.g., for tools that share state between viewports).
Parameters
- targetViewport: default
- optionalrenderingEngineId: string
Returns IVolumeViewport[]
array of viewports that have the same volume actor as the target viewport

hasNaNValues

hasNaNValues(input: number | number[]): boolean

A function that checks if there is a value in the array that is NaN. or if the input is a number it just checks if it is NaN.
Parameters
- input: number | number[]
  The input to check if it is NaN.
Returns boolean
- True if the input is NaN, false otherwise.

imageIdToURI

imageIdToURI(imageId: string): string

Removes the data loader scheme from the imageId
Parameters
- imageId: string
  Image ID
Returns string
imageId without the data loader scheme

imageToWorldCoords

imageToWorldCoords(imageId: string, imageCoords: Point2): Point3 | undefined

Given the imageId and a 2d coordinates on the image space with [0,0] being the top left corner of the top left pixel, and options which includes the imageId, it returns the 3d coordinates on the world space.
Parameters
- imageId: string
  The image id
- imageCoords: Point2
  The 2d coordinates on the image
Returns Point3 | undefined
The 3d coordinates on the world.

indexWithinDimensions

indexWithinDimensions(index: Point3, dimensions: Point3): boolean

Returns true if the specified index is within the given dimensions.
Parameters
- index: Point3
  The index to check.
- dimensions: Point3
  The dimensions to check against.
Returns boolean
True if the index is in-bounds.

invertRgbTransferFunction

invertRgbTransferFunction(rgbTransferFunction: any): void

A utility that can be used to invert (in place) an RgbTransferFunction.
@example
Grabbing a reference to the RGB Transfer function from the viewport:
const rgbTransferFunction = viewport .getActor() .getProperty() .getRGBTransferFunction(0); rgbTransferFunction.setRange(0, 5); invertRgbTransferFunction(rgbTransferFunction);
@see
ColorTransferFunction
Parameters
- rgbTransferFunction: any
Returns void

isEqual

isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean

Returns whether two values are equal or not, based on epsilon comparison. For array comparison, it does NOT strictly compare them but only compare its values. It can compare array of numbers and also typed array. Otherwise it will just return false.
Type parameters
- ValueType
Parameters
- v1: ValueType
  The first value to compare
- v2: ValueType
  The second value to compare
- tolerance: number = 1e-5
  The acceptable tolerance, the default is 0.00001
Returns boolean
True if the two values are within the tolerance levels.

isImageActor

isImageActor(actorEntry: ActorEntry): boolean

Checks if a vtk Actor is an image actor (vtkVolume or vtkImageSlice) otherwise returns false.
Parameters
- actorEntry: ActorEntry
Returns boolean
A boolean value.

isOpposite

isOpposite(v1: Point3, v2: Point3, tolerance?: number): boolean

returns equal if the two vec3s are opposite within the given tolerance in each dimension.
Parameters
- v1: Point3
  The first 3 vector
- v2: Point3
  The second 3 vector.
- tolerance: number = 1e-5
  The acceptable tolerance.
Returns boolean
True if the two values are within the tolerance levels.

isPTPrescaledWithSUV

isPTPrescaledWithSUV(image: IImage): number

Parameters
- image: IImage
Returns number

loadImageToCanvas

loadImageToCanvas(options: LoadImageOptions): Promise<string>

Loads and renders an imageId to a Canvas. It will use the GPU rendering pipeline for image by default but you can force the CPU rendering pipeline by setting the useCPURendering parameter to true.
@example
const canvas = document.getElementById('myCanvas') const imageId = 'myImageId' loadImageToCanvas(canvas, imageId)
Parameters
- options: LoadImageOptions
Returns Promise<string>
- A promise that resolves when the image has been rendered with the imageId

renderToCanvasCPU

renderToCanvasCPU(canvas: HTMLCanvasElement, image: IImage, modality?: string, renderingEngineId?: string): Promise<string>

Renders a cornerstone image object to a canvas. Note: this does not load the image but only takes care of the rendering pipeline
Parameters
- canvas: HTMLCanvasElement
  Canvas element to render to
- image: IImage
  Cornerstone image object
- optionalmodality: string
- optionalrenderingEngineId: string
Returns Promise<string>

renderToCanvasGPU

renderToCanvasGPU(canvas: HTMLCanvasElement, image: IImage, modality?: any, renderingEngineId?: string): Promise<string>

Renders an cornerstone image to a Canvas. This method will handle creation of a temporary enabledElement, setting the imageId, and rendering the image via a StackViewport, copying the canvas drawing to the given canvas Element, and disabling the created temporary element. SuppressEvents argument is used to prevent events from firing during the render process (e.g. during a series of renders to a thumbnail image).
@example
const canvas = document.getElementById('myCanvas') renderToCanvasGPU(canvas, image)
Parameters
- canvas: HTMLCanvasElement
  Canvas element to render to
- image: IImage
  The image to render
- modality: any = undefined
  [Default = undefined] The modality of the image
- renderingEngineId: string = '_thumbnails'
Returns Promise<string>
- A promise that resolves when the image has been rendered with the imageId

scaleRgbTransferFunction

scaleRgbTransferFunction(rgbTransferFunction: any, scalingFactor: number): void

A utility that can be used to scale (in place) an RgbTransferFunction. We often use this to scale the transfer function based on a PET calculation.
@example
Grabbing a reference to the RGB Transfer function from the viewport:
const rgbTransferFunction = viewport .getActor() .getProperty() .getRGBTransferFunction(0); scaleRgbTransferFunction(rgbTransferFunction, 2);
@see
ColorTransferFunction
Parameters
- rgbTransferFunction: any
- scalingFactor: number
Returns void

snapFocalPointToSlice

snapFocalPointToSlice(focalPoint: Point3, position: Point3, sliceRange: ActorSliceRange, viewPlaneNormal: Point3, spacingInNormalDirection: number, deltaFrames: number): { newFocalPoint: Point3; newPosition: Point3 }

Given a number of frames, deltaFrames, move the focalPoint and camera position so that it moves forward/backwards deltaFrames in the camera’s normal direction, and snaps to the nearest frame.
Parameters
- focalPoint: Point3
  The focal point to move.
- position: Point3
  The camera position to move.
- sliceRange: ActorSliceRange
  The scroll range used to find the current position in the stack, as well as prevent scrolling past the extent of the volume.
- viewPlaneNormal: Point3
  The normal direction of the camera.
- spacingInNormalDirection: number
  The spacing of frames the normal direction of the camera.
- deltaFrames: number
  The number of frames to jump.
Returns { newFocalPoint: Point3; newPosition: Point3 }
The newFocalPoint and newPosition of the camera.
- newFocalPoint: Point3
- newPosition: Point3

transformWorldToIndex

transformWorldToIndex(imageData: any, worldPos: Point3): any

Given an imageData object and a point in physical space, return the index of the voxel that contains the point. TODO: this should be pushed to vtk upstream.
Parameters
- imageData: any
  The image data object.
- worldPos: Point3
Returns any
An array of integers.

uuidv4

uuidv4(): string

Generates a unique id that has limited chance of collision
@see
Source
Returns string
a v4 compliant GUID

worldToImageCoords

worldToImageCoords(imageId: string, worldCoords: Point3): Point2 | undefined

Given the imageId, and 3d coordinates on the world space, it returns the continuos image coordinates (IJ) on the image space. The image space is defined with [0,0] being on the top left corner of the top left pixel, the [1,1] being on the bottom right corner of the top left pixel.
Parameters
- imageId: string
  The image id
- worldCoords: Point3
  The 3d coordinates on the world.
Returns Point2 | undefined
The 2d coordinates on the image.

Index

References

Namespaces

Variables

Functions

References

triggerEvent

Namespaces

colormap

getColormap

Parameters

name: any

Returns any

getColormapNames

Returns any[]

registerColormap

Parameters

colormap: ColormapRegistration

Returns void

planar

linePlaneIntersection

Parameters

p0: Point3

p1: Point3

plane: Plane

Returns Point3

planeDistanceToPoint

Parameters

plane: Plane

point: Point3

signed: boolean = false

Returns number

planeEquation

Parameters

normal: Point3

point: Point3 | vec3

Returns Plane

threePlaneIntersection

Parameters

firstPlane: Plane

secondPlane: Plane

thirdPlane: Plane

Returns Point3

windowLevel

toLowHighRange

Parameters

windowWidth: number

windowCenter: number

Returns { lower: number; upper: number }

lower: number

upper: number

toWindowLevel

Parameters

low: number

high: number

Returns { windowCenter: number; windowWidth: number }

windowCenter: number

windowWidth: number

Variables

constcalibratedPixelSpacingMetadataProvider

Type declaration

add: (imageId: string, payload: CalibratedPixelValue) => void

Parameters

imageId: string

payload: CalibratedPixelValue

Returns void

get: (type: string, imageId: string) => CalibratedPixelValue

Parameters

type: string

imageId: string

Returns CalibratedPixelValue

constspatialRegistrationMetadataProvider

Type declaration

add: (query: string[], payload: mat4) => void

Parameters

query: string[]

payload: mat4

Returns void

get: (type: string, query: string[]) => mat4

Parameters