@kitware/vtk.js 30.5.3 → 30.6.1

package/Imaging/Core/ImageReslice.d.ts

@@ -1,4 +1,10 @@
-import { Bounds, Extent, Nullable, RGBAColor, TypedArray } from './../../types';
+import {
+  Bounds,
+  Extent,
+  Nullable,
+  RGBAColor,
+  TypedArray,
+} from './../../types';
 import { InterpolationMode } from './AbstractImageInterpolator/Constants';
 import { SlabMode } from './ImageReslice/Constants';
 import { vtkAlgorithm, vtkObject, vtkRange } from './../../interfaces';
@@ -8,50 +14,50 @@ import vtkTransform from './../../Common/Transform/Transform';
 import { mat3, mat4, vec3, vec4 } from 'gl-matrix';
 
 /**
- * 
+ *
  */
 export interface IImageResliceInitialValues {
-  transformInputSampling: boolean,
-  autoCropOutput: boolean,
-  outputDimensionality: number,
-  outputSpacing: Nullable<vec3>, // automatically computed if null
-  outputOrigin: Nullable<vec3>, // automatically computed if null
-  outputDirection: Nullable<mat3>, // identity if null
-  outputExtent: Nullable<Extent>, // automatically computed if null
-  outputScalarType: Nullable<string>,
-  wrap: boolean, // don't wrap
-  mirror: boolean, // don't mirror
-  border: boolean, // apply a border
-  interpolationMode: InterpolationMode, // only NEAREST supported so far
-  slabMode: SlabMode,
-  slabTrapezoidIntegration: boolean,
-  slabNumberOfSlices: number,
-  slabSliceSpacingFraction: number,
-  optimization: boolean, // not supported yet
-  scalarShift: number, // for rescaling the data
-  scalarScale: number,
-  backgroundColor: RGBAColor,
-  resliceAxes: Nullable<mat4>,
-  resliceTransform?: vtkTransform,
-  interpolator: any, // A vtkImageInterpolator (missing typescript header)
-  usePermuteExecute: boolean, // no supported yet
+  transformInputSampling: boolean;
+  autoCropOutput: boolean;
+  outputDimensionality: number;
+  outputSpacing: Nullable<vec3>; // automatically computed if null
+  outputOrigin: Nullable<vec3>; // automatically computed if null
+  outputDirection: Nullable<mat3>; // identity if null
+  outputExtent: Nullable<Extent>; // automatically computed if null
+  outputScalarType: Nullable<string>;
+  wrap: boolean; // don't wrap
+  mirror: boolean; // don't mirror
+  border: boolean; // apply a border
+  interpolationMode: InterpolationMode; // only NEAREST supported so far
+  slabMode: SlabMode;
+  slabTrapezoidIntegration: boolean;
+  slabNumberOfSlices: number;
+  slabSliceSpacingFraction: number;
+  optimization: boolean; // not supported yet
+  scalarShift: number; // for rescaling the data
+  scalarScale: number;
+  backgroundColor: RGBAColor;
+  resliceAxes: Nullable<mat4>;
+  resliceTransform?: vtkTransform;
+  interpolator: any; // A vtkImageInterpolator (missing typescript header)
+  usePermuteExecute: boolean; // no supported yet
 }
 
 type vtkImageResliceBase = Omit<vtkObject, 'set'> & vtkAlgorithm;
 
 export interface vtkImageReslice extends vtkImageResliceBase {
   /**
-	 *
-	 * @param inData
-	 * @param outData
-	 */
-	requestData(inData: any, outData: any): void;
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
 
   /**
    * Main filter logic
-   * @param input 
-   * @param output 
-   * @returns 
+   * @param input
+   * @param output
+   * @returns
    */
   vtkImageResliceExecute: (input: vtkImageData, output: vtkImageData) => void;
 
@@ -72,137 +78,184 @@ export interface vtkImageReslice extends vtkImageResliceBase {
 
   /**
    * Compute the bounds required to ensure that none of the data will be cropped
-   * @param input 
-   * @returns 
+   * @param input
+   * @returns
    */
   getAutoCroppedOutputBounds: (input: vtkImageData) => Bounds;
 
   /**
    * The min and max of each data type
    * Defaults to a range of 0 to 255
-   * @param dataType 
-   * @returns 
+   * @param dataType
+   * @returns
    */
   getDataTypeMinMax: (dataType: string) => vtkRange;
 
   /**
    * Internal function uses vtkInterpolationMathClamp on `numscalars * n` elements
-   * @param outPtr 
-   * @param inPtr 
-   * @param numscalars 
-   * @param n 
-   * @param min 
-   * @param max 
+   * @param outPtr
+   * @param inPtr
+   * @param numscalars
+   * @param n
+   * @param min
+   * @param max
    * @returns The number of elements processed
    */
-  clamp: (outPtr: TypedArray, inPtr: TypedArray, numscalars: number, n: number, min: number, max: number) => number;
+  clamp: (
+    outPtr: TypedArray,
+    inPtr: TypedArray,
+    numscalars: number,
+    n: number,
+    min: number,
+    max: number
+  ) => number;
 
   /**
    * Internal function uses Math.round on `numscalars * n` elements
-   * @param outPtr 
-   * @param inPtr 
-   * @param numscalars 
-   * @param n 
+   * @param outPtr
+   * @param inPtr
+   * @param numscalars
+   * @param n
    * @returns The number of elements processed
    */
-  convert: (outPtr: TypedArray, inPtr: TypedArray, numscalars: number, n: number) => number;
+  convert: (
+    outPtr: TypedArray,
+    inPtr: TypedArray,
+    numscalars: number,
+    n: number
+  ) => number;
 
   /**
    * Setup the conversion function and return the right one
-   * @param inputType 
-   * @param dataType 
-   * @param scalarShift 
-   * @param scalarScale 
-   * @param forceClamping 
+   * @param inputType
+   * @param dataType
+   * @param scalarShift
+   * @param scalarScale
+   * @param forceClamping
    * @returns publicAPI.convert or publicAPI.clamp
    */
-  getConversionFunc: (inputType: string, dataType: string, scalarShift: number, scalarScale: number, forceClamping: boolean) => (this["convert"] & this["clamp"]);
+  getConversionFunc: (
+    inputType: string,
+    dataType: string,
+    scalarShift: number,
+    scalarScale: number,
+    forceClamping: boolean
+  ) => this['convert'] & this['clamp'];
 
   /**
    * Copy the `numscalars * n` first elements from an array to another
-   * @param outPtr 
-   * @param inPtr 
-   * @param numscalars 
-   * @param n 
+   * @param outPtr
+   * @param inPtr
+   * @param numscalars
+   * @param n
    * @returns The number of copied elements
    */
-  set: (outPtr: TypedArray, inPtr: TypedArray, numscalars: number, n: number) => number;
+  set: (
+    outPtr: TypedArray,
+    inPtr: TypedArray,
+    numscalars: number,
+    n: number
+  ) => number;
 
   /**
    * Fill the `n` first elements of the output array with the very first element of the input array
-   * @param outPtr 
-   * @param inPtr 
-   * @param numscalars 
-   * @param n 
+   * @param outPtr
+   * @param inPtr
+   * @param numscalars
+   * @param n
    * @returns The number of elements set in the output array
    */
-  set1: (outPtr: TypedArray, inPtr: TypedArray, numscalars: number, n: number) => number;
+  set1: (
+    outPtr: TypedArray,
+    inPtr: TypedArray,
+    numscalars: number,
+    n: number
+  ) => number;
 
   /**
    * Returns the right function used to copy the pixels
-   * @param dataType 
-   * @param dataSize 
-   * @param numscalars 
-   * @param dataPtr 
+   * @param dataType
+   * @param dataSize
+   * @param numscalars
+   * @param dataPtr
    * @returns publicAPI.set or publicAPI.set1
    */
-  getSetPixelsFunc: (dataType: any, dataSize: any, numscalars: number, dataPtr: any) => (this["set"] & this["set1"]);
+  getSetPixelsFunc: (
+    dataType: any,
+    dataSize: any,
+    numscalars: number,
+    dataPtr: any
+  ) => this['set'] & this['set1'];
 
   /**
    * Returns the right composition function
-   * @param slabMode 
-   * @param slabTrapezoidIntegration 
-   * @returns 
+   * @param slabMode
+   * @param slabTrapezoidIntegration
+   * @returns
    */
-  getCompositeFunc: (slabMode: SlabMode, slabTrapezoidIntegration: boolean) => ((tmpPtr: TypedArray, inComponents: number, sampleCount: number) => void);
+  getCompositeFunc: (
+    slabMode: SlabMode,
+    slabTrapezoidIntegration: boolean
+  ) => (tmpPtr: TypedArray, inComponents: number, sampleCount: number) => void;
 
   /**
    * Apply `newTrans`, then translate by `-origin`, then scale by `inInvSpacing`
-   * @param newTrans 
-   * @param inPoint 
-   * @param inOrigin 
-   * @param inInvSpacing 
-   * @returns 
+   * @param newTrans
+   * @param inPoint
+   * @param inOrigin
+   * @param inInvSpacing
+   * @returns
    */
-  applyTransform: (newTrans: mat4, inPoint: vec4, inOrigin: vec3, inInvSpacing: vec3) => void;
+  applyTransform: (
+    newTrans: mat4,
+    inPoint: vec4,
+    inOrigin: vec3,
+    inInvSpacing: vec3
+  ) => void;
 
   /**
-   * 
-   * @param floatData 
-   * @param components 
-   * @param n 
-   * @param scalarShift 
-   * @param scalarScale 
-   * @returns 
+   *
+   * @param floatData
+   * @param components
+   * @param n
+   * @param scalarShift
+   * @param scalarScale
+   * @returns
    */
-  rescaleScalars: (floatData: TypedArray, components: number, n: number, scalarShift: number, scalarScale: number) => void;
+  rescaleScalars: (
+    floatData: TypedArray,
+    components: number,
+    n: number,
+    scalarShift: number,
+    scalarScale: number
+  ) => void;
 
   /**
    * A permutation matrix is the identity matrix with the colomn (or rows) shuffled
-   * @param matrix 
-   * @returns 
+   * @param matrix
+   * @returns
    */
   isPermutationMatrix: (matrix: mat4) => boolean;
 
   /**
-   * 
-   * @param matrix 
-   * @returns 
+   *
+   * @param matrix
+   * @returns
    */
   isIdentityMatrix: (matrix: mat4) => boolean;
 
   /**
-   * 
-   * @param matrix 
-   * @returns 
+   *
+   * @param matrix
+   * @returns
    */
   isPerspectiveMatrix: (matrix: mat4) => boolean;
 
   /**
-   * 
-   * @param matrix 
-   * @param outExt 
-   * @returns 
+   *
+   * @param matrix
+   * @param outExt
+   * @returns
    */
   canUseNearestNeighbor: (matrix: mat4, outExt: Extent) => boolean;
 
@@ -213,28 +266,28 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * The default is SlabMode.MIN. If SetSlabNumberOfSlices(N) is called with N
    * greater than one, then each output slice will actually be a composite of N
    * slices. This method specifies the compositing mode to be used.
-   * @param slabMode 
-   * @returns 
+   * @param slabMode
+   * @returns
    */
   setSlabMode: (slabMode: SlabMode) => boolean;
 
   /**
    * @see setSlabMode
-   * @returns 
+   * @returns
    */
   getSlabMode: () => SlabMode;
 
   /**
    * Set the number of slices that will be combined to create the slab.
    * Defaults to 1.
-   * @param numberOfSlices 
-   * @returns 
+   * @param numberOfSlices
+   * @returns
    */
   setSlabNumberOfSlices: (slabNumberOfSlices: number) => boolean;
 
   /**
    * @see setSlabNumberOfSlices
-   * @returns 
+   * @returns
    */
   getSlabNumberOfSlices: () => number;
 
@@ -244,14 +297,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * the ResliceAxes before applying them as the default output spacing, origin
    * and extent.
    * Defaults to false.
-   * @param transformInputSampling 
-   * @returns 
+   * @param transformInputSampling
+   * @returns
    */
   setTransformInputSampling: (transformInputSampling: boolean) => boolean;
 
   /**
    * @see setTransformInputSampling
-   * @returns 
+   * @returns
    */
   getTransformInputSampling: () => boolean;
 
@@ -259,14 +312,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * Turn this on if you want to guarantee that the extent of the output will
    * be large enough to ensure that none of the data will be cropped.
    * Defaults to false.
-   * @param autoCropOutput 
-   * @returns 
+   * @param autoCropOutput
+   * @returns
    */
   setAutoCropOutput: (autoCropOutput: boolean) => boolean;
 
   /**
    * @see setAutoCropOutput
-   * @returns 
+   * @returns
    */
   getAutoCropOutput: () => boolean;
 
@@ -278,14 +331,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * output extent is confined to the x axis. For 0D, the output extent
    * consists of a single voxel at (0,0,0).
    * Defaults to 3.
-   * @param outputDimensionality 
-   * @returns 
+   * @param outputDimensionality
+   * @returns
    */
   setOutputDimensionality: (outputDimensionality: number) => boolean;
 
   /**
    * @see setOutputDimensionality
-   * @returns 
+   * @returns
    */
   getOutputDimensionality: () => number;
 
@@ -294,14 +347,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * The default output spacing is the input spacing permuted through the
    * ResliceAxes.
    * Defaults to null (automatically computed).
-   * @param outputSpacing 
-   * @returns 
+   * @param outputSpacing
+   * @returns
    */
   setOutputSpacing: (outputSpacing: vec3 | null) => boolean;
 
   /**
    * @see setOutputSpacing
-   * @returns 
+   * @returns
    */
   getOutputSpacing: () => vec3 | null;
 
@@ -310,14 +363,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * The default output origin is the input origin permuted through the
    * ResliceAxes.
    * Defaults to null (automatically computed).
-   * @param outputOrigin 
-   * @returns 
+   * @param outputOrigin
+   * @returns
    */
   setOutputOrigin: (outputOrigin: vec3 | null) => boolean;
 
   /**
    * @see setOutputOrigin
-   * @returns 
+   * @returns
    */
   getOutputOrigin: () => vec3 | null;
 
@@ -326,14 +379,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * The default output extent is the input extent permuted through the
    * ResliceAxes.
    * Defaults to null (automatically computed).
-   * @param outputExtent 
-   * @returns 
+   * @param outputExtent
+   * @returns
    */
   setOutputExtent: (outputExtent: Extent | null) => boolean;
 
   /**
    * @see setOutputExtent
-   * @returns 
+   * @returns
    */
   getOutputExtent: () => Extent | null;
 
@@ -346,28 +399,28 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * changes the orientation of the sampling grid while maintaining the same
    * physical coordinate system.
    * Defaults to null (automatically computed).
-   * @param outputDirection 
-   * @returns 
+   * @param outputDirection
+   * @returns
    */
   setOutputDirection: (outputDirection: mat3 | null) => boolean;
 
   /**
    * @see setOutputDirection
-   * @returns 
+   * @returns
    */
   getOutputDirection: () => mat3 | null;
 
   /**
    * Set the background color (for multi-component images).
    * Defaults to full opaque black.
-   * @param backgroundColor 
-   * @returns 
+   * @param backgroundColor
+   * @returns
    */
   setBackgroundColor: (backgroundColor: RGBAColor) => boolean;
 
   /**
    * @see setBackgroundColor
-   * @returns 
+   * @returns
    */
   getBackgroundColor: () => RGBAColor;
 
@@ -382,14 +435,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * column specifies the y-axis, and the third column the
    * z-axis.  The fourth column is the origin of the
    * axes (the fourth element must be set to one).
-   * @param resliceAxes 
-   * @returns 
+   * @param resliceAxes
+   * @returns
    */
   setResliceAxes: (resliceAxes: mat4) => boolean;
 
   /**
    * @see setResliceAxes
-   * @returns 
+   * @returns
    */
   getResliceAxes: () => mat4;
 
@@ -403,17 +456,17 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * VtkDataTypes.DOUBLE. Other types are not permitted. If the output type
    * is an integer type, the output will be rounded and clamped to the limits of
    * the type.
-   * 
+   *
    * See the documentation for [vtkDataArray::getDataType()](../api/Common_Core_DataArray.html#getDataType-String) for additional data type settings.
    * Defaults to null (automatically computed).
-   * @param outputScalarType 
-   * @returns 
+   * @param outputScalarType
+   * @returns
    */
   setOutputScalarType: (outputScalarType: string | null) => boolean;
 
   /**
    * @see setOutputScalarType
-   * @returns 
+   * @returns
    */
   getOutputScalarType: () => string | null;
 
@@ -424,14 +477,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * it is written to the output image.  The result will always be clamped to
    * the limits of the output data type.
    * Defaults to 0.
-   * @param scalarShift 
-   * @returns 
+   * @param scalarShift
+   * @returns
    */
   setScalarShift: (scalarShift: number) => boolean;
 
   /**
    * @see setScalarShift
-   * @returns 
+   * @returns
    */
   getScalarShift: () => number;
 
@@ -442,42 +495,42 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * it is written to the output image.  The result will always be clamped to
    * the limits of the output data type.
    * Defaults to 1.
-   * @param scalarScale 
-   * @returns 
+   * @param scalarScale
+   * @returns
    */
   setScalarScale: (scalarScale: number) => boolean;
 
   /**
    * @see setScalarScale
-   * @returns 
+   * @returns
    */
   getScalarScale: () => number;
 
   /**
    * Turn on wrap-pad feature.
    * Defaults to false.
-   * @param wrap 
-   * @returns 
+   * @param wrap
+   * @returns
    */
   setWrap: (wrap: boolean) => boolean;
 
   /**
    * @see setWrap
-   * @returns 
+   * @returns
    */
   getWrap: () => boolean;
 
   /**
    * Turn on mirror-pad feature. This will override the wrap-pad.
    * Defaults to false.
-   * @param mirror 
-   * @returns 
+   * @param mirror
+   * @returns
    */
   setMirror: (mirror: boolean) => boolean;
 
   /**
    * @see setMirror
-   * @returns 
+   * @returns
    */
   getMirror: () => boolean;
 
@@ -491,29 +544,29 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * the edges of the input.
    * This has no effect if Mirror or Wrap are on.
    * Defaults to true.
-   * @param border 
-   * @returns 
+   * @param border
+   * @returns
    */
   setBorder: (border: boolean) => boolean;
 
   /**
    * @see setBorder
-   * @returns 
+   * @returns
    */
   getBorder: () => boolean;
 
   /**
-   * Set interpolation mode. 
+   * Set interpolation mode.
    * Only nearest neighbor is supported at the moment.
    * Defaults to nearest neighbor.
-   * @param interpolationMode 
-   * @returns 
+   * @param interpolationMode
+   * @returns
    */
   setInterpolationMode: (interpolationMode: InterpolationMode) => boolean;
 
   /**
    * @see setInterpolationMode
-   * @returns 
+   * @returns
    */
   getInterpolationMode: () => InterpolationMode;
 
@@ -525,14 +578,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * that transform to the input volume. Nonlinear transforms such as
    * vtkGridTransform and vtkThinPlateSplineTransform can be used here.
    * Defaults to undefined.
-   * @param resliceTransform 
-   * @returns 
+   * @param resliceTransform
+   * @returns
    */
   setResliceTransform: (resliceTransform: vtkTransform | undefined) => boolean;
 
   /**
    * @see setResliceTransform
-   * @returns 
+   * @returns
    */
   getResliceTransform: () => vtkTransform | undefined;
 
@@ -541,14 +594,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * All this does is weigh the first and last slices by half when doing sum
    * and mean. It is off by default.
    * Defaults to false.
-   * @param slabTrapezoidIntegration 
-   * @returns 
+   * @param slabTrapezoidIntegration
+   * @returns
    */
   setSlabTrapezoidIntegration: (slabTrapezoidIntegration: boolean) => boolean;
 
   /**
    * @see setSlabTrapezoidIntegration
-   * @returns 
+   * @returns
    */
   getSlabTrapezoidIntegration: () => boolean;
 
@@ -561,14 +614,14 @@ export interface vtkImageReslice extends vtkImageResliceBase {
    * method sets the spacing between these temporary slices to be a fraction of
    * the output spacing.
    * Defaults to 1.
-   * @param slabSliceSpacingFraction 
-   * @returns 
+   * @param slabSliceSpacingFraction
+   * @returns
    */
   setSlabSliceSpacingFraction: (slabSliceSpacingFraction: number) => boolean;
 
   /**
    * @see setSlabSliceSpacingFraction
-   * @returns 
+   * @returns
    */
   getSlabSliceSpacingFraction: () => number;
 }
@@ -580,18 +633,23 @@ export interface vtkImageReslice extends vtkImageResliceBase {
  * @param model object on which data structure will be bounds (protected)
  * @param {IImageResliceInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IImageResliceInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IImageResliceInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkImageReslice
  * @param {IImageResliceInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IImageResliceInitialValues): vtkImageReslice;
-
+export function newInstance(
+  initialValues?: IImageResliceInitialValues
+): vtkImageReslice;
 
 /**
  * vtkImageReslice - Reslices a volume along a new set of axes
- * 
+ *
  * vtkImageReslice is the swiss-army-knife of image geometry filters:
  * It can permute, rotate, flip, scale, resample, deform, and pad image
  * data in any combination with reasonably high efficiency.  Simple
@@ -610,7 +668,7 @@ export function newInstance(initialValues?: IImageResliceInitialValues): vtkImag
  * volume that you have applied a transformation to.
  * */
 export declare const vtkImageReslice: {
-	newInstance: typeof newInstance;
-	extend: typeof extend;
-}
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
 export default vtkImageReslice;