@kitware/vtk.js

import { mat3, mat4, quat, vec3 } from 'gl-matrix'; import { Nullable } from './../../types'; import { vtkOutputPort } from './../../interfaces'; import { vtkAbstractMapper3D, IAbstractMapper3DInitialValues, } from './AbstractMapper3D'; import { vtkDataArray } from './../../Common/Core/DataArray'; import { vtkImageData } from './../../Common/DataModel/ImageData'; import { vtkPolyData } from './../../Common/DataModel/PolyData'; import { vtkPolyLine } from './../../Common/DataModel/PolyLine'; import { ProjectionMode } from './ImageCPRMapper/Constants'; import { CoincidentTopologyHelper, StaticCoincidentTopologyMethods, } from './Mapper/CoincidentTopologyHelper'; type TOrientation = mat4 | mat3 | quat | vec3; export interface IImageCPRMapperInitialValues extends IAbstractMapper3DInitialValues { width: number; uniformOrientation: TOrientation; // Don't use vec3 if possible useUniformOrientation: boolean; preferSizeOverAccuracy: boolean; // Whether to use halfFloat representation of float, when it is inaccurate orientationArrayName: Nullable<string>; tangentDirection: vec3; bitangentDirection: vec3; normalDirection: vec3; } export interface vtkImageCPRMapper extends vtkAbstractMapper3D, CoincidentTopologyHelper { /** * @returns the width of the image in model coordinates of the input volume */ getWidth(): number; /** * @see getWidth * @param width */ setWidth(width: number): boolean; /** * Use @see getUseUniformOrientation to use the uniform orientation instead of the orientation specified by the centerline * @returns the uniform orientation of the centerline */ getUniformOrientation(): TOrientation; /** * @see getUniformOrientation * @param orientation */ setUniformOrientation(orientation: TOrientation): boolean; /** * This flag specifies wether the mapper should use the uniformOrientation ( @see getUniformOrientation ) or the orientation specified in centerline at centerline input ( @see setCenterlineData ) * Defaults to false. * @returns the useUniformOrientation flag */ getUseUniformOrientation(): boolean; /** * @see getUseUniformOrientation * @param useUniformOrientation */ setUseUniformOrientation(useUniformOrientation: boolean): boolean; /** * A point used to offset each line of pixel in the rendering * The line of pixel is offseted such as the center of the line is as close as possible to the center point * This can be used in combination with @see getUseUniformOrientation and a custom distance function for @see getOrientedCenterline to visualize a CPR in projected mode or stretched mode * Defaults to null. * @returns the center point */ getCenterPoint(): Nullable<vec3>; /** * @see getCenterPoint * @param point */ setCenterPoint(point: Nullable<vec3>): boolean; /** * This flag indicates wether the GPU should use half float or not * When true, will use half float * When false, may use half float if there is no loss of accuracy (see in Texture: checkUseHalfFloat) * Defaults to false. * @returns the preferSizeOverAccuracy flag */ getPreferSizeOverAccuracy(): boolean; /** * @see getPreferSizeOverAccuracy * @param preferSizeOverAccuracy */ setPreferSizeOverAccuracy(preferSizeOverAccuracy: boolean): boolean; /** * OrientationArrayName specifies the name of the data array which gives an orientation for each point of the centerline * The data array has to be in the PointData attribute of the centerline input * If null, look for the orientation data array in: "Orientation", "Direction", Vectors, Tensors, Normals * The data array should be an array of mat4, mat3, quat or vec3 but using vec3 makes the CPRInteractor unusable * Default to null. */ getOrientationArrayName(): Nullable<string>; /** * @see getOrientationArrayName * @param arrayName */ setOrientationArrayName(arrayName: Nullable<string>): boolean; /** * For each point on the oriented centerline, the tangent direction is the direction in which the mapper will sample * Let O (a mat3) be the orientation at a point on a centerline, and N (a vec3) the tangent direction * Then the mapper will sample along O * N * Default value: [1, 0, 0] */ getTangentDirection(): vec3; /** * @see getTangentDirection * @param tangent */ setTangentDirection(tangent: vec3): boolean; /** * For each point on the oriented centerline, the bitangent direction forms with the normal and the tangent direction a new basis * Default value: [0, 1, 0] */ getBitangentDirection(): vec3; /** * @see getBitangentDirection * @param bitangent */ setBitangentDirection(bitangent: vec3): boolean; /** * For each point on the oriented centerline, the normal direction is the direction along the centerline * Default value: [0, 0, 1] */ getNormalDirection(): vec3; /** * @see getNormalDirection * @param normal */ setNormalDirection(normal: vec3): boolean; /** * The direction matrix is the matrix composed of tangent, bitangent and normal directions * It is used to orient the camera or the actor */ getDirectionMatrix(): mat3; /** * @see getDirectionMatrix * @param mat */ setDirectionMatrix(mat: mat3): boolean; /** * Thickness of the projection slab in image coordinates (NOT in voxels) * Usually in millimeters if the spacing of the input image is set from a DICOM */ getProjectionSlabThickness(): number; /** * @see getProjectionSlabThickness * @param projectionSlabThickness */ setProjectionSlabThickness(ProjectionSlabThickness: number): boolean; /** * Total number of samples of the volume done by the projection mode * If this number is equal or less than 1, projection is disabled * Using an odd number is advised * If this number is even, the center of the slab will not be sampled */ getProjectionSlabNumberOfSamples(): number; /** * @see getProjectionSlabNumberOfSamples * @param projectionSlabNumberOfSamples */ setProjectionSlabNumberOfSamples( projectionSlabNumberOfSamples: number ): boolean; /** * Returns wether projection is enabled * It is based on the number of samples * @see getProjectionSlabNumberOfSamples */ isProjectionEnabled(): boolean; /** * The different modes of projection * Available modes include MIP, MinIP and AverageIP */ getProjectionMode(): ProjectionMode; /** * @see getProjectionMode * @param projectionMode */ setProjectionMode(projectionMode: ProjectionMode): boolean; /** * Find the data array to use for orientation in the input polydata ( @see getOrientationArrayName ) */ getOrientationDataArray(): Nullable<vtkDataArray>; /** * Recompute the oriented centerline from the input polydata if needed and return the result * If there is no polydata as input, return the last oriented centerline * It means that if no polydata is given as input and the centerline is set using @see setOrientedCenterline , the given centerline will be used */ getOrientedCenterline(): vtkPolyLine; /** * Set the internal oriented centerline * WARNING: this centerline will be overwritten if the polydata centerline is specified (input 1 @see setCenterlineData ) * @param centerline An oriented centerline */ setOrientedCenterline(centerline: vtkPolyLine): boolean; /** * @returns The total height of the image in model coordinates. */ getHeight(): number; /** * @param distance Distance from the beginning of the centerline, following the centerline, in model coordinates * @returns The position and orientation which is at the given distance from the beginning of the centerline. * If the distance is negative or greater than the length of the centerline, position and orientation are not defined. * If the centerline is not oriented, orientation is not defined. */ getCenterlinePositionAndOrientation(distance: number): { position?: vec3; orientation?: quat; }; /** * @returns A flat array of vec3 representing the direction at each point of the centerline * It is computed from the orientations of the centerline and tangentDirection * Uses caching to avoid recomputing at each frame */ getCenterlineTangentDirections(): Float32Array; /** * @returns The direction to sample, in model space, computed using uniform orientation and tangent direction */ getUniformDirection(): vec3; /** * @returns A boolean indicating if the mapper is ready to render */ preRenderCheck(): boolean; /** * Configure the mapper and the centerline to be in straightened CPR mode */ useStraightenedMode(): void; /** * Configure the mapper and the centerline to be in strectched CPR mode * @param centerPoint The center point, optional, default to the first point of the centerline or [0, 0, 0] */ useStretchedMode(centerPoint?: Nullable<vec3>): void; /** * Set the polydata used as a centerline * You can also use `publicAPI.setInputData(centerlineData, 1);` * Use all the segments of all the polylines (the centerline can be in multiple pieces) * The polydata can contain a PointData DataArray to specify the direction in which the mapper should sample for each point of the centerline ( @see getDirectionArrayName @see getDirectionArrayOffset ) * If no such point data is specified, a uniform direction can be used instead ( @see getUniformDirection @see getUseUniformOrientation ) * The points of the centerline are in model coordinates of the volume used as input ( @see setImageDataData ) and not index coordinates (see MCTC matrix of the OpenGL ImageCPRMapper) * Use `imageData.getWorldToIndex();` or `imageData.getIndexToWorld();` to go from model coordinates to index coordinates or the other way around * @param centerlineData A polydata containing one or multiple polyline(s) and optionnally a PointData DataArray for direction */ setCenterlineData(centerlineData: vtkPolyData): void; /** * Same as setCenterlineData except it uses an output port instead of a polydata * You can also use `publicAPI.setInputConnection(centerlineConnection, 1);` * @see setCenterlineData * @param centerlineConnection */ setCenterlineConnection(centerlineConnection: vtkOutputPort): void; /** * Set the volume which should be sampled by the mapper * You can also use `publicAPI.setInputData(imageData, 0);` * The model coordinates of this imageData are used by this mapper when specifying points, vectors or width (see MCTC matrix of the OpenGL ImageCPRMapper) * You can use `imageData.getWorldToIndex();` or `imageData.getIndexToWorld();` to go from this model coordinates to index coordinates or the other way around * @param imageData */ setImageData(imageData: vtkImageData): void; /** * Set the connection for the volume * You can also use `publicAPI.setInputConnection(imageData, 0);` * @see setImageData * @param imageData */ setImageConnection(imageData: vtkOutputPort): void; } /** * Method used to decorate a given object (publicAPI+model) with vtkImageCPRMapper characteristics. * * @param publicAPI object on which methods will be bounds (public) * @param model object on which data structure will be bounds (protected) * @param {IImageCPRMapperInitialValues} [initialValues] (default: {}) */ export function extend( publicAPI: object, model: object, initialValues?: IImageCPRMapperInitialValues ): void; /** * Method used to create a new instance of vtkImageCPRMapper * @param {IImageCPRMapperInitialValues} [initialValues] for pre-setting some of its content */ export function newInstance( initialValues?: IImageCPRMapperInitialValues ): vtkImageCPRMapper; /** * CPR in vtkImageCPRMapper stands for Curved Planar Reformation. This mapper * can be used to visualize tubular structures such as blood vessels. It can be * used in projected mode, stretched mode or straightened mode depending on the * settings @see getUseUniformOrientation , @see getCenterPoint and the distance * function of @see getOrientedCenterline . * * This specialised mapper takes as input a vtkImageData representing a volume * ( @see setImageData ) and a vtkPolyData representing a centerline * ( @see setCenterlineData ). The mapper also need to have an orientation per * point or for all points. This can be specified using a uniform orientation * ( @see getUniformOrientation @see getUseUniformOrientation ) or a point * data array ( @see getOrientationArrayName ). Every point, vector or length * specified to the mapper (centerline points, orientation, width...) use model * coordinates of the volume used as input ( @see setImageData ). * * For each segment of the centerline the mapper creates a quad of the * specified width ( @see getWidth ) and of height equal to the length of the * segment. The position and the orientation of the centerline are * interpolated along the y-axis of the quad. The position is linearly * interpolated (lerp) and the orientation is interpolated using * spherical linear interpolation (slerp). For a point (x, y) on the quad, * the value of y gives the interpolated position P and interpolated * orientation O which combined with tangentDirection gives D * ( @see getTangentDirection ). The value of x between -0.5 and 0.5 then gives * the position to sample in the volume: P + x*D. * * By computing the right centerline positions and orientations, one * can simulate Stretched CPR and Straightened CPR. * * This class resolves coincident topology with the same methods as vtkMapper. */ export declare const vtkImageCPRMapper: { newInstance: typeof newInstance; extend: typeof extend; } & StaticCoincidentTopologyMethods; export default vtkImageCPRMapper;