@kitware/vtk.js 25.1.2 → 25.2.1

package/Rendering/Core/Actor.d.ts

@@ -1,7 +1,7 @@
-import { Bounds } from './../../types';
+import { Bounds, Nullable } from './../../types';
 import vtkMapper from './Mapper';
 import vtkProp3D, { IProp3DInitialValues } from './Prop3D';
-import vtkProperty from './Property';
+import vtkProperty, { IPropertyInitialValues } from './Property';
 
 /**
  * 
@@ -62,7 +62,7 @@ export interface vtkActor extends vtkProp3D {
 	/**
 	 * Get the Mapper that this actor is getting its data from.
 	 */
-	getMapper(): null | vtkMapper;
+	getMapper(): Nullable<vtkMapper>;
 
 	/**
 	 * Get the property object that controls this actors surface
@@ -82,8 +82,9 @@ export interface vtkActor extends vtkProp3D {
 
 	/**
 	 * Create a new property suitable for use with this type of Actor.
+	 * @param {IPropertyInitialValues} [initialValues] (default: {})
 	 */
-	makeProperty(): vtkProperty;
+	makeProperty(initialValues?: IPropertyInitialValues): vtkProperty;
 
 	/**
 	 * Set the property object that controls this actors backface surface

package/Rendering/Core/ImageSlice.d.ts

@@ -1,5 +1,5 @@
 import { Bounds } from './../../types';
-import vtkImageProperty from './ImageProperty';
+import vtkImageProperty, { IImagePropertyInitialValues } from './ImageProperty';
 import vtkImageMapper from './ImageMapper';
 import vtkProp3D, { IProp3DInitialValues } from './Prop3D';
 
@@ -23,6 +23,12 @@ export interface vtkImageSlice extends vtkProp3D {
 	 */
 	getBounds(): Bounds;
 
+	/**
+	 * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @return {Bounds} The bounds for the mapper.
+	 */
+	getBoundsByReference(): Bounds;
+
 	/**
 	 * Get the bounds for a given slice as [xmin, xmax, ymin, ymax,zmin, zmax].
 	 * @param {Number} slice The slice index.
@@ -111,6 +117,24 @@ export interface vtkImageSlice extends vtkProp3D {
 	 * and the Renderer will do the images in their own pass.
 	 */
 	hasTranslucentPolygonalGeometry(): boolean;
+
+	/**
+	 * Create a new property suitable for use with this type of Actor.
+	 * @param {IImageSliceInitialValues} [initialValues] (default: {})
+	 */
+	makeProperty(initialValues?: IImagePropertyInitialValues): vtkImageProperty;
+
+	/**
+	 * 
+	 * @param {vtkImageMapper} mapper The vtkImageMapper instance.
+	 */
+	setMapper(mapper: vtkImageMapper): boolean;
+
+	/**
+	 * 
+	 * @param {vtkImageProperty} property The vtkImageProperty instance.
+	 */
+	setProperty(property: vtkImageProperty): boolean;
 }
 
 /**

package/Rendering/Core/Light.d.ts

@@ -5,7 +5,7 @@ import { RGBColor, Vector3 } from './../../types';
 export enum LIGHT_TYPES {
 	'HeadLight',
 	'CameraLight',
-	'SceneLight'
+	'SceneLight',
 }
 
 export interface ILightInitialValues {
@@ -17,6 +17,7 @@ export interface ILightInitialValues {
 	positional?: boolean;
 	exponent?: number;
 	coneAngle?: number;
+	coneFalloff?: number;
 	attenuationValues?: number[];
 	lightType?: LIGHT_TYPES;
 	shadowAttenuation?: number;
@@ -54,6 +55,15 @@ export interface vtkLight extends vtkObject {
 	 */
 	getConeAngle(): number;
 
+	/**
+	 * Get the lighting falloff angle of a positional light in degrees.
+	 * This is the angle that sets how much the cone will be extended to
+	 * smooth the border. A value of 0 indicates that the spot light will
+	 * have a completely sharp edge (this does not mean completely sharp
+	 * lighting, just that the border will be sharp).
+	 */
+	getConeFalloff(): number;
+
 	/**
 	 * Set the position and focal point of a light based on elevation and azimuth.
 	 * The light is moved so it is shining from the given angle. Angles are
@@ -174,6 +184,16 @@ export interface vtkLight extends vtkObject {
 	 */
 	setConeAngle(coneAngle: number): boolean;
 
+	/**
+	 * Set the lighting falloff angle of a positional light in degrees.
+	 * This is the angle that sets how much the cone will be extended to
+	 * smooth the border. A value of 0 indicates that the spot light will
+	 * have a completely sharp edge (this does not mean completely sharp
+	 * lighting, just that the border will be sharp).
+	 * @param {Number} coneFalloff The cone falloff angle.
+	 */
+	setConeFalloff(coneFalloff: number): boolean;
+
 	/**
 	 * Set the position and focal point of a light based on elevation and
 	 * azimuth. The light is moved so it is shining from the given angle. Angles
@@ -184,6 +204,20 @@ export interface vtkLight extends vtkObject {
 	 */
 	setDirectionAngle(elevation: number, azimuth: number): boolean;
 
+	/**
+	 * Set the direction vector of the light from X, Y, and Z values
+	 * @param {Number} x The x coordinate.
+	 * @param {Number} y The y coordinate.
+	 * @param {Number} z The z coordinate.
+	 */
+	setDirection(x: number, y: number, z: number): boolean;
+
+	/**
+	 * Set the direction vector of the light from X, Y, and Z values
+	 * @param {Vector3} direction
+	 */
+	setDirection(direction: Vector3): boolean;
+
 	/**
 	 * Set the exponent of the cosine used in positional lighting.
 	 * @param {Number} exponent The exponent of the cosine.
@@ -299,7 +333,7 @@ export function extend(publicAPI: object, model: object, initialValues?: ILightI
 /**
  * Method use to create a new instance of vtkLight with the focal point at the origin and its position
  * set to [0, 0, 1]. The light is a SceneLight, its color is white, intensity=1, the light is turned on, 
- * positional lighting is off, coneAngle=30, AttenuationValues=[1, 0, 0], exponent=1 and the transformMatrix is null.
+ * positional lighting is off, coneAngle=30, coneFalloff=5, AttenuationValues=[1, 0, 0], exponent=1 and the transformMatrix is null.
  * @param {ILightInitialValues} [initialValues] for pre-setting some of its content
  */
 export function newInstance(initialValues?: ILightInitialValues): vtkLight;

package/Rendering/Core/Light.js

@@ -33,14 +33,19 @@ function vtkLight(publicAPI, model) {
 
   publicAPI.getDirection = function () {
     if (model.directionMTime < model.mtime) {
-      model.direction[0] = model.focalPoint[0] - model.position[0];
-      model.direction[1] = model.focalPoint[1] - model.position[1];
-      model.direction[2] = model.focalPoint[2] - model.position[2];
+      vec3.sub(model.direction, model.focalPoint, model.position);
       normalize(model.direction);
       model.directionMTime = model.mtime;
     }
 
     return model.direction;
+  }; // Sets the direction from a vec3 instead of a focal point
+
+
+  publicAPI.setDirection = function (directionVector) {
+    var newFocalPoint = new Float64Array(3);
+    vec3.sub(newFocalPoint, model.position, directionVector);
+    model.focalPoint = newFocalPoint;
   };
 
   publicAPI.setDirectionAngle = function (elevation, azimuth) {
@@ -89,6 +94,7 @@ var DEFAULT_VALUES = {
   positional: false,
   exponent: 1,
   coneAngle: 30,
+  coneFalloff: 5,
   attenuationValues: [1, 0, 0],
   transformMatrix: null,
   lightType: 'SceneLight',
@@ -102,7 +108,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'transformMatrix', 'lightType', 'shadowAttenuation', 'attenuationValues']);
+  macro.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'coneFalloff', 'transformMatrix', 'lightType', 'shadowAttenuation', 'attenuationValues']);
   macro.setGetArray(publicAPI, model, ['color', 'position', 'focalPoint', 'attenuationValues'], 3); // Object methods
 
   vtkLight(publicAPI, model);

package/Rendering/Core/Property.d.ts

@@ -1,15 +1,27 @@
 import { vtkObject } from './../../interfaces';
 import { RGBColor } from './../../types';
 import { Interpolation, Representation, Shading } from './Property/Constants';
+import { vtkTexture } from './Texture';
 
 export interface IPropertyInitialValues {
 	color?: RGBColor;
 	ambientColor?: RGBColor;
 	diffuseColor?: RGBColor;
 	specularColor?: RGBColor;
+	diffuseTexture?: vtkTexture;
+	metallicTexture?: vtkTexture;
+	roughnessTexture?: vtkTexture;
+	normalTexture?: vtkTexture;
+	ambientOcclusionTexture?: vtkTexture;
+	emissionTexture?: vtkTexture;
 	edgeColor?: RGBColor;
 	ambient?: number;
 	diffuse?: number;
+	metallic?: number;
+	roughness?: number;
+	normalStrength?: number;
+	emission?: number;
+	baseIOR?: number;
 	specular?: number;
 	specularPower?: number;
 	opacity?: number;
@@ -161,6 +173,36 @@ export interface vtkProperty extends vtkObject {
 	 */
 	getSpecular(): number;
 
+	/**
+	 * Get the roughness coefficient.
+	 * @default 1
+	 */
+	getRoughness(): number;
+
+	/**
+	 * Get the metallic coefficient.
+	 * @default 0
+	 */
+	getMetallic(): number;
+
+	/**
+	 * Get the index of refraction.
+	 * @default 0
+	 */
+	getBaseIOR(): number;
+
+	/**
+	 * Get the strength of the normal map.
+	 * @default 1
+	 */
+	getNormalStrength(): number;
+
+	/**
+	 * Get the emission coefficient.
+	 * @default 0
+	 */
+	getEmission(): number;
+
 	/**
 	 * Get the specular surface color.
 	 * @return {RGBColor} Array of RGB color.
@@ -178,6 +220,36 @@ export interface vtkProperty extends vtkObject {
 	 */
 	getSpecularPower(): number;
 
+	/**
+	 * Get the diffuse texture.
+	 */
+	getDiffuseTexture(): vtkTexture;
+
+	/**
+	 * Get the metallic texture.
+	 */
+	getMetallicTexture(): vtkTexture;
+
+	/**
+	 * Get the roughness texture.
+	 */
+	getRoughnessTexture(): vtkTexture;
+
+	/**
+	 * Get the normal texture.
+	 */
+	getNormalTexture(): vtkTexture;
+
+	/**
+	 * Get the ambient occlusion texture.
+	 */
+	getAmbientOcclusionTexture(): vtkTexture;
+
+	/**
+	 * Get the emission texture.
+	 */
+	getEmissionTexture(): vtkTexture;
+
 	/**
 	 * Set the ambient lighting coefficient.
 	 * @param {Number} ambient The ambient lighting coefficient.
@@ -385,6 +457,18 @@ export interface vtkProperty extends vtkObject {
 	 */
 	setSpecular(specular: number): boolean;
 
+	/**
+	 * Set the normal map strength.
+	 * @param {Boolean} normal 
+	 */
+	setNormalStrength(normalStrength: number): boolean;
+
+	/**
+	 * Set the ambient occlusion map strength.
+	 * @param {Boolean} emission 
+	 */
+	setEmission(emission: number): boolean;
+
 	/**
 	 * Set the specular surface color.
 	 * @param {Number} r Defines the red component (between 0 and 1)
@@ -410,6 +494,42 @@ export interface vtkProperty extends vtkObject {
 	 * @param {Number} specularPower 
 	 */
 	setSpecularPower(specularPower: number): boolean;
+
+	/**
+	 * Set the diffuse texture.
+	 * @param {vtkTexture} diffuseTexture
+	 */
+	setDiffuseTexture(diffuseTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the metallic texture.
+	 * @param {vtkTexture} metallicTexture
+	 */
+	setMetallicTexture(metallicTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the roughness texture.
+	 * @param {vtkTexture} roughnessTexture
+	 */
+	setRoughnessTexture(roughnessTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the normal texture.
+	 * @param {vtkTexture} normalTexture
+	 */
+	setNormalTexture(normalTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the ambient occlusion texture.
+	 * @param {vtkTexture} ambientOcclusionTexture
+	 */
+	setAmbientOcclusionTexture(ambientOcclusionTexture: vtkTexture): boolean;
+
+	/**
+	 * Set the emission texture.
+	 * @param {vtkTexture} emissionTexture
+	 */
+	setEmissionTexture(emissionTexture: vtkTexture): boolean;
 }
 
 /**

package/Rendering/Core/Property.js

@@ -58,6 +58,17 @@ function vtkProperty(publicAPI, model) {
     return [].concat(model.color);
   };
 
+  publicAPI.setSpecularPower = function (specularPower) {
+    var roughness = 1 / Math.max(1.0, specularPower);
+
+    if (model.roughness !== roughness || model.specularPower !== specularPower) {
+      model.specularPower = specularPower; // Specular power still needs to be set as long as webgl is using it (otherwise testShaderReplacementsClear fails)
+
+      model.roughness = roughness;
+      publicAPI.modified();
+    }
+  };
+
   publicAPI.addShaderVariable = notImplemented('AddShaderVariable');
 
   publicAPI.setInterpolationToFlat = function () {
@@ -104,6 +115,11 @@ var DEFAULT_VALUES = {
   edgeColor: [0, 0, 0],
   ambient: 0,
   diffuse: 1,
+  metallic: 0,
+  roughness: 0.6,
+  normalStrength: 1,
+  emission: 1,
+  baseIOR: 1.45,
   specular: 0,
   specularPower: 1,
   opacity: 1,
@@ -124,7 +140,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['lighting', 'interpolation', 'ambient', 'diffuse', 'specular', 'specularPower', 'opacity', 'edgeVisibility', 'lineWidth', 'pointSize', 'backfaceCulling', 'frontfaceCulling', 'representation']);
+  macro.setGet(publicAPI, model, ['lighting', 'interpolation', 'ambient', 'diffuse', 'metallic', 'roughness', 'normalStrength', 'emission', 'baseIOR', 'specular', 'specularPower', 'opacity', 'edgeVisibility', 'lineWidth', 'pointSize', 'backfaceCulling', 'frontfaceCulling', 'representation', 'diffuseTexture', 'metallicTexture', 'roughnessTexture', 'normalTexture', 'ambientOcclusionTexture', 'emissionTexture']);
   macro.setGetArray(publicAPI, model, ['ambientColor', 'specularColor', 'diffuseColor', 'edgeColor'], 3); // Object methods
 
   vtkProperty(publicAPI, model);

package/Rendering/Core/Texture.js

@@ -72,6 +72,37 @@ function vtkTexture(publicAPI, model) {
 
     publicAPI.modified();
   };
+
+  publicAPI.getDimensionality = function () {
+    var width = 0;
+    var height = 0;
+    var depth = 1;
+
+    if (publicAPI.getInputData()) {
+      var data = publicAPI.getInputData();
+      width = data.getDimensions()[0];
+      height = data.getDimensions()[1];
+      depth = data.getDimensions()[2];
+    }
+
+    if (model.jsImageData) {
+      width = model.jsImageData.width;
+      height = model.jsImageData.height;
+    }
+
+    if (model.canvas) {
+      width = model.canvas.width;
+      height = model.canvas.height;
+    }
+
+    if (model.image) {
+      width = model.image.width;
+      height = model.image.height;
+    }
+
+    var dimensionality = (width > 1) + (height > 1) + (depth > 1);
+    return dimensionality;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/Core/Volume.d.ts

@@ -1,7 +1,7 @@
-import { Bounds } from './../../types';
+import { Bounds, Nullable } from './../../types';
 import vtkProp3D, { IProp3DInitialValues } from './Prop3D';
 import vtkVolumeMapper from './VolumeMapper';
-import vtkVolumeProperty from './VolumeProperty';
+import vtkVolumeProperty, { IVolumePropertyInitialValues } from './VolumeProperty';
 
 /**
  * 
@@ -20,7 +20,7 @@ export interface vtkVolume extends vtkProp3D {
 	/**
 	 * Get the volume mapper
 	 */
-	getMapper(): vtkVolumeMapper;
+	getMapper(): Nullable<vtkVolumeMapper>;
 
 	/**
 	 * For some exporters and other other operations we must be able to collect
@@ -63,9 +63,10 @@ export interface vtkVolume extends vtkProp3D {
 	getRedrawMTime(): number;
 
 	/**
-	 * 
+	 * Create a new property suitable for use with this type of Actor.
+	 * @param {IVolumePropertyInitialValues} [initialValues] (default: {})
 	 */
-	makeProperty(): void;
+	makeProperty(initialValues?: IVolumePropertyInitialValues): vtkVolumeProperty;
 
 	/**
 	 * Set the volume mapper

package/Rendering/Core/VolumeMapper.d.ts

@@ -5,7 +5,7 @@ import { BlendMode, FilterMode } from './VolumeMapper/Constants';
 /**
  * 
  */
-interface IVolumeMapperInitialValues extends IAbstractMapperInitialValues {
+export interface IVolumeMapperInitialValues extends IAbstractMapperInitialValues {
 	bounds?: Bounds;
 	blendMode?: BlendMode;
 	sampleDistance?: number;

package/Rendering/Core/VolumeProperty.d.ts

@@ -1,7 +1,9 @@
+import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { vtkObject } from './../../interfaces';
+import vtkColorTransferFunction from './ColorTransferFunction';
 import { InterpolationType, OpacityMode } from './VolumeProperty/Constants';
 
-interface IVolumePropertyInitialValues  {
+export interface IVolumePropertyInitialValues  {
 	independentComponents?: boolean;
 	shade?: number;
 	ambient?: number;
@@ -33,7 +35,7 @@ export interface vtkVolumeProperty extends vtkObject {
 
 	/**
 	 *
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
 	getColorChannels(index: number): number;
 
@@ -44,25 +46,25 @@ export interface vtkVolumeProperty extends vtkObject {
 
 	/**
 	 *
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
 	getGradientOpacityMaximumOpacity(index: number): number;
 
 	/**
 	 *
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
 	getGradientOpacityMaximumValue(index: number): number;
 
 	/**
 	 *
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
 	getGradientOpacityMinimumOpacity(index: number): number;
 
 	/**
 	 *
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
 	getGradientOpacityMinimumValue(index: number): number;
 
@@ -73,15 +75,15 @@ export interface vtkVolumeProperty extends vtkObject {
 
 	/**
 	 * Get the unit distance on which the scalar opacity transfer function is defined.
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
 	getScalarOpacityUnitDistance(index: number): number;
 
 	/**
 	 * Get the currently set gray transfer function. Create one if none set.
-	 * @param {Number} index 
+	 * @param {Number} index
 	 */
-	getGrayTransferFunction(index: number): any;
+	getGrayTransferFunction(index: number): vtkPiecewiseFunction;
 
 	/**
 	 *
@@ -98,13 +100,13 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * Get the currently set RGB transfer function. Create one if none set.
 	 * @param {Number} index 
 	 */
-	getRGBTransferFunction(index: number): any;
+	getRGBTransferFunction(index: number): vtkColorTransferFunction;
 
 	/**
 	 * Get the scalar opacity transfer function. Create one if none set.
 	 * @param {Number} index 
 	 */
-	getScalarOpacity(index: number): any;
+	getScalarOpacity(index: number): vtkPiecewiseFunction;
 
 	/**
 	 * Get the shading of a volume.
@@ -147,37 +149,37 @@ export interface vtkVolumeProperty extends vtkObject {
 	/**
 	 *
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setGradientOpacityMaximumOpacity(index: number, value: number): boolean;
 
 	/**
 	 *
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setGradientOpacityMaximumValue(index: number, value: number): boolean;
 
 	/**
 	 *
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setGradientOpacityMinimumOpacity(index: number, value: number): boolean;
 
 	/**
 	 *
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setGradientOpacityMinimumValue(index: number, value: number): boolean;
 
 	/**
 	 * Set the color of a volume to a gray transfer function
 	 * @param {Number} index 
-	 * @param func
+	 * @param {vtkPiecewiseFunction} func 
 	 */
-	setGrayTransferFunction(index: number, func: any): boolean;
+	setGrayTransferFunction(index: number, func: vtkPiecewiseFunction): boolean;
 
 	/**
 	 * Does the data have independent components, or do some define color only?
@@ -204,14 +206,14 @@ export interface vtkVolumeProperty extends vtkObject {
 
 	/**
 	 *
-	 * @param {Number} labelOutlineThickness
+	 * @param {Number} labelOutlineThickness 
 	 */
 	setLabelOutlineThickness(labelOutlineThickness: number): boolean;
 
 	/**
 	 *
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setOpacityMode(index: number, value: number): boolean;
 
@@ -219,7 +221,7 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * Set the unit distance on which the scalar opacity transfer function is
 	 * defined.
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setScalarOpacityUnitDistance(index: number, value: number): boolean;
 
@@ -234,7 +236,7 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * turning shading off is generally the same as setting ambient=1,
 	 * diffuse=0, specular=0. Shading can be independently turned on/off per
 	 * component.
-	 * @param {Number} shade
+	 * @param {Number} shade 
 	 */
 	setShade(shade: number): boolean;
 
@@ -252,35 +254,35 @@ export interface vtkVolumeProperty extends vtkObject {
 
 	/**
 	 *
-	 * @param {Boolean} index 
-	 * @param {Number} value
+	 * @param {Number} index 
+	 * @param {Boolean} value 
 	 */
 	setUseGradientOpacity(index: number, value: boolean): boolean;
 
 	/**
 	 *
-	 * @param {Boolean} useLabelOutline
+	 * @param {Boolean} useLabelOutline 
 	 */
 	setUseLabelOutline(useLabelOutline: boolean): boolean;
 
 	/**
 	 * Set the color of a volume to an RGB transfer function
 	 * @param {Number} index 
-	 * @param func
+	 * @param {vtkColorTransferFunction} func 
 	 */
-	setRGBTransferFunction(index: number, func: any): boolean;
+	setRGBTransferFunction(index: number, func: vtkColorTransferFunction): boolean;
 
 	/**
 	 * Set the scalar opacity of a volume to a transfer function
 	 * @param {Number} index 
-	 * @param func
+	 * @param {vtkPiecewiseFunction} func 
 	 */
-	setScalarOpacity(index: number, func: any): boolean;
+	setScalarOpacity(index: number, func: vtkPiecewiseFunction): boolean;
 
 	/**
 	 * Set the scalar component weights.
 	 * @param {Number} index 
-	 * @param {Number} value
+	 * @param {Number} value 
 	 */
 	setComponentWeight(index: number, value: number): boolean;
 
@@ -292,7 +294,7 @@ export interface vtkVolumeProperty extends vtkObject {
 
 	/**
 	 * Set the interpolation type for sampling a volume.
-	 * @param {InterpolationType} interpolationType
+	 * @param {InterpolationType} interpolationType 
 	 */
 	setInterpolationType(interpolationType: InterpolationType): boolean;