Introduction

vtkImageProperty provides 2D image display support for vtk.
It can be associated with a vtkImageSlice prop and placed within a Renderer.

This class resolves coincident topology with the same methods as vtkMapper.

Methods

extend

Method use to decorate a given object (publicAPI+model) with vtkImageProperty characteristics.

Argument	Type	Required	Description
`publicAPI`		Yes	object on which methods will be bounds (public)
`model`		Yes	object on which data structure will be bounds (protected)
`initialValues`	IImagePropertyInitialValues	No	(default: {})

getAmbient

Get the lighting coefficient.

getColorLevel

Get the level value for window/level.

getColorWindow

Get the window value for window/level.

getComponentWeight

Argument	Type	Required	Description
`index`	Number	Yes

getDiffuse

Get the diffuse lighting coefficient.

getIndependentComponents

getInterpolationType

Get the interpolation type

getInterpolationTypeAsString

Get the interpolation type as a string

getLabelOutlineOpacity

Get the 0 to 1 opacity of the label outline.

getLabelOutlineThickness

gets the label outline thickness

getOpacity

Get the opacity of the object.

getPiecewiseFunction

Get the component weighting function.

Argument	Type	Required	Description
`idx`	Number	No

getRGBTransferFunction

Get the currently set RGB transfer function.

Argument	Type	Required	Description
`idx`	Number	No

getScalarOpacity

Alias to get the piecewise function (backwards compatibility)

Argument	Type	Required	Description
`idx`	Number	No

getUseLabelOutline

Check if label outline rendering.

newInstance

Method use to create a new instance of vtkImageProperty

Argument	Type	Required	Description
`initialValues`	IImagePropertyInitialValues	No	for pre-setting some of its content

setAmbient

Set the ambient lighting coefficient.

Argument	Type	Required	Description
`ambient`	Number	Yes	The ambient lighting coefficient.

setColorLevel

Set the level value for window/level.

Argument	Type	Required	Description
`colorLevel`	Number	Yes	The level value for window/level.

setColorWindow

Set the window value for window/level.

Argument	Type	Required	Description
`colorWindow`	Number	Yes	The window value for window/level.

setComponentWeight

Argument	Type	Required	Description
`index`	Number	Yes
`value`	Number	Yes

setDiffuse

Set the diffuse lighting coefficient.

Argument	Type	Required	Description
`diffuse`	Number	Yes	The diffuse lighting coefficient.

setIndependentComponents

Argument	Type	Required	Description
`independentComponents`	Boolean	Yes

setInterpolationType

Set the interpolation type.

Argument	Type	Required	Description
`interpolationType`	InterpolationType	Yes	The interpolation type.

setInterpolationTypeToLinear

Set interpolationType to InterpolationType.LINEAR.

setInterpolationTypeToNearest

Set interpolationType to InterpolationType.NEAREST.

setLabelOutlineOpacity

Set the 0 to 1 opacity of the label outline.

Argument	Type	Required	Description
`opacity`	Number	Yes

setLabelOutlineThickness

It will set the label outline thickness for the labelmaps. It can accept
a single number or an array of numbers. If a single number is provided,
it will be used for all the segments. If an array is provided, it indicates
the thickness for each segment index. For instance if you have a labelmap
with 3 segments (0: background 1: liver 2: tumor), you can set the thickness
to [2,4] to have a thicker outline for the tumor (thickness 4). It should be
noted that the thickness is in pixel and also the first array value will
control the default thickness for all labels when 0 or not specified.

Argument	Type	Required	Description
`labelOutlineThickness`	Number or Array[Number]	Yes

setOpacity

Set the opacity of the object

Argument	Type	Required	Description
`opacity`	Number	Yes	The opacity value.

setPiecewiseFunction

Set the piecewise function

Argument	Type	Required	Description
`index`	Number	Yes
`func`	vtkPiecewiseFunction	Yes

setRGBTransferFunction

Set the color of a volume to an RGB transfer function

Argument	Type	Required	Description
`index`	Number	Yes
`func`	vtkColorTransferFunction	Yes

setScalarOpacity

Alias to set the piecewise function

Argument	Type	Required	Description
`index`	Number	Yes
`func`	vtkPiecewiseFunction	Yes

setUseLabelOutline

Enable label outline rendering.

Argument	Type	Required	Description
`useLabelOutline`	Boolean	Yes

setUseLookupTableScalarRange

Use the range that is set on the lookup table, instead of setting the range from the
ColorWindow/ColorLevel settings

Argument	Type	Required	Description
`useLookupTableScalarRange`	Boolean	Yes

Source

Constants.d.ts

export declare enum InterpolationType {
  NEAREST = 0,
  LINEAR = 1,
}

declare const _default: {
  InterpolationType: typeof InterpolationType;
};
export default _default;

Constants.js

export const InterpolationType = {
  NEAREST: 0,
  LINEAR: 1,
};

export default {
  InterpolationType,
};

index.d.ts

import { vtkObject } from '../../../interfaces';
import { Nullable } from '../../../types';
import vtkColorTransferFunction from '../ColorTransferFunction';
import vtkPiecewiseFunction from '../../../Common/DataModel/PiecewiseFunction';
import { InterpolationType } from './Constants';

interface IComponentData {
  piecewiseFunction: number;
  componentWeight: number;
}

export interface IImagePropertyInitialValues {
  independentComponents?: boolean;
  interpolationType?: InterpolationType;
  colorWindow?: number;
  colorLevel?: number;
  ambient?: number;
  diffuse?: number;
  opacity?: number;
  componentData?: IComponentData[];
  useLookupTableScalarRange?: boolean;
  useLabelOutline?: boolean;
  labelOutlineThickness?: number | number[];
}

export interface vtkImageProperty extends vtkObject {
  /**
   * Get the lighting coefficient.
   * @default 1.0
   */
  getAmbient(): number;

  /**
   * Get the level value for window/level.
   * @default 127.5
   */
  getColorLevel(): number;

  /**
   * Get the window value for window/level.
   * @default 255
   */
  getColorWindow(): number;

  /**
   *
   * @param {Number} index
   */
  getComponentWeight(index: number): number;

  /**
   * Get the diffuse lighting coefficient.
   * @default 1.0
   */
  getDiffuse(): number;

  /**
   *
   * @default false
   */
  getIndependentComponents(): boolean;

  /**
   * Get the interpolation type
   */
  getInterpolationType(): InterpolationType;

  /**
   * Get the interpolation type as a string
   */
  getInterpolationTypeAsString(): string;

  /**
   * Get the opacity of the object.
   * @default 1.0
   */
  getOpacity(): number;

  /**
   * Get the component weighting function.
   * @param {Number} [idx]
   */
  getPiecewiseFunction(idx?: number): Nullable<vtkPiecewiseFunction>;

  /**
   * Get the currently set RGB transfer function.
   * @param {Number} [idx]
   */
  getRGBTransferFunction(idx?: number): Nullable<vtkColorTransferFunction>;

  /**
   * Alias to get the piecewise function (backwards compatibility)
   * @param {Number} [idx]
   */
  getScalarOpacity(idx?: number): vtkPiecewiseFunction;

  /**
   * Enable label outline rendering.
   * @param {Boolean} useLabelOutline
   */
  setUseLabelOutline(useLabelOutline: boolean): boolean;

  /**
   * Check if label outline rendering.
   */
  getUseLabelOutline(): boolean;

  /**
   * Set the 0 to 1 opacity of the label outline.
   * @param {Number} opacity
   */
  setLabelOutlineOpacity(opacity: number): boolean;

  /**
   * Get the 0 to 1 opacity of the label outline.
   */
  getLabelOutlineOpacity(): number;

  /**
   * gets the label outline thickness
   */
  getLabelOutlineThickness(): number;

  /**
   * It will set the label outline thickness for the labelmaps. It can accept
   * a single number or an array of numbers. If a single number is provided,
   * it will be used for all the segments. If an array is provided, it indicates
   * the thickness for each segment index. For instance if you have a labelmap
   * with 3 segments (0: background 1: liver 2: tumor), you can set the thickness
   * to [2,4] to have a thicker outline for the tumor (thickness 4). It should be
   * noted that the thickness is in pixel and also the first array value will
   * control the default thickness for all labels when 0 or not specified.
   *
   * @param {Number | Number[]} labelOutlineThickness
   */
  setLabelOutlineThickness(labelOutlineThickness: number | number[]): boolean;

  /**
   * Set the ambient lighting coefficient.
   * @param {Number} ambient The ambient lighting coefficient.
   */
  setAmbient(ambient: number): boolean;

  /**
   * Set the level value for window/level.
   * @param {Number} colorLevel The level value for window/level.
   */
  setColorLevel(colorLevel: number): boolean;

  /**
   * Set the window value for window/level.
   * @param {Number} colorWindow The window value for window/level.
   */
  setColorWindow(colorWindow: number): boolean;

  /**
   *
   * @param {Number} index
   * @param {Number} value
   */
  setComponentWeight(index: number, value: number): boolean;

  /**
   * Set the diffuse lighting coefficient.
   * @param {Number} diffuse  The diffuse lighting coefficient.
   */
  setDiffuse(diffuse: number): boolean;

  /**
   *
   * @param {Boolean} independentComponents
   */
  setIndependentComponents(independentComponents: boolean): boolean;

  /**
   * Set the interpolation type.
   * @param {InterpolationType} interpolationType The interpolation type.
   */
  setInterpolationType(interpolationType: InterpolationType): boolean;

  /**
   * Set `interpolationType` to `InterpolationType.LINEAR`.
   */
  setInterpolationTypeToLinear(): boolean;

  /**
   * Set `interpolationType` to `InterpolationType.NEAREST`.
   */
  setInterpolationTypeToNearest(): boolean;

  /**
   * Set the opacity of the object
   * @param {Number} opacity The opacity value.
   */
  setOpacity(opacity: number): boolean;

  /**
   * Set the piecewise function
   * @param {Number} index
   * @param {vtkPiecewiseFunction} func
   */
  setPiecewiseFunction(
    index: number,
    func: Nullable<vtkPiecewiseFunction>
  ): boolean;

  /**
   * Set the color of a volume to an RGB transfer function
   * @param {Number} index
   * @param {vtkColorTransferFunction} func
   */
  setRGBTransferFunction(
    index: number,
    func: Nullable<vtkColorTransferFunction>
  ): boolean;

  /**
   * Alias to set the piecewise function
   * @param {Number} index
   * @param {vtkPiecewiseFunction} func
   */
  setScalarOpacity(
    index: number,
    func: Nullable<vtkPiecewiseFunction>
  ): boolean;

  /**
   * Use the range that is set on the lookup table, instead of setting the range from the
   * ColorWindow/ColorLevel settings
   * @default false
   * @param {Boolean} useLookupTableScalarRange
   */
  setUseLookupTableScalarRange(useLookupTableScalarRange: boolean): boolean;
}

/**
 * Method use to decorate a given object (publicAPI+model) with vtkImageProperty characteristics.
 *
 * @param publicAPI object on which methods will be bounds (public)
 * @param model object on which data structure will be bounds (protected)
 * @param {IImagePropertyInitialValues} [initialValues] (default: {})
 */
export function extend(
  publicAPI: object,
  model: object,
  initialValues?: IImagePropertyInitialValues
): void;

/**
 * Method use to create a new instance of vtkImageProperty
 * @param {IImagePropertyInitialValues} [initialValues] for pre-setting some of its content
 */
export function newInstance(
  initialValues?: IImagePropertyInitialValues
): vtkImageProperty;

/**
 * vtkImageProperty provides 2D image display support for vtk.
 * It can be associated with a vtkImageSlice prop and placed within a Renderer.
 *
 * This class resolves coincident topology with the same methods as vtkMapper.
 */
export declare const vtkImageProperty: {
  newInstance: typeof newInstance;
  extend: typeof extend;
};
export default vtkImageProperty;

index.js

import macro from 'vtk.js/Sources/macros';
import Constants from 'vtk.js/Sources/Rendering/Core/ImageProperty/Constants';

const { InterpolationType } = Constants;
const { vtkErrorMacro } = macro;

const VTK_MAX_VRCOMP = 4;

// ----------------------------------------------------------------------------
// vtkImageProperty methods
// ----------------------------------------------------------------------------

function vtkImageProperty(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkImageProperty');

  publicAPI.getMTime = () => {
    let mTime = model.mtime;
    let time;

    for (let index = 0; index < VTK_MAX_VRCOMP; index++) {
      // Color MTimes
      if (model.componentData[index].rGBTransferFunction) {
        // time that RGB transfer function was last modified
        time = model.componentData[index].rGBTransferFunction.getMTime();
        mTime = mTime > time ? mTime : time;
      }

      // Piecewise function MTimes
      if (model.componentData[index].piecewiseFunction) {
        // time that weighting function was last modified
        time = model.componentData[index].piecewiseFunction.getMTime();
        mTime = mTime > time ? mTime : time;
      }
    }

    return mTime;
  };

  // Set the color of a volume to an RGB transfer function
  publicAPI.setRGBTransferFunction = (index = 0, func = null) => {
    // backwards compatible call without the component index
    let idx = index;
    let transferFunc = func;
    if (!Number.isInteger(index)) {
      transferFunc = index;
      idx = 0;
    }
    if (model.componentData[idx].rGBTransferFunction !== transferFunc) {
      model.componentData[idx].rGBTransferFunction = transferFunc;
      publicAPI.modified();
      return true;
    }
    return false;
  };

  // Get the currently set RGB transfer function.
  publicAPI.getRGBTransferFunction = (idx = 0) =>
    model.componentData[idx].rGBTransferFunction;

  // Set the piecewise function
  publicAPI.setPiecewiseFunction = (index = 0, func = null) => {
    let idx = index;
    let transferFunc = func;
    if (!Number.isInteger(index)) {
      transferFunc = index;
      idx = 0;
    }
    if (model.componentData[idx].piecewiseFunction !== transferFunc) {
      model.componentData[idx].piecewiseFunction = transferFunc;
      publicAPI.modified();
      return true;
    }
    return false;
  };

  // Get the component weighting function.
  publicAPI.getPiecewiseFunction = (idx = 0) =>
    model.componentData[idx].piecewiseFunction;

  // Alias to set the piecewise function
  publicAPI.setScalarOpacity = (index = 0, func = null) => {
    // backwards compatible call without the component index
    let idx = index;
    let transferFunc = func;
    if (!Number.isInteger(index)) {
      transferFunc = index;
      idx = 0;
    }
    return publicAPI.setPiecewiseFunction(idx, transferFunc);
  };

  // Alias to get the piecewise function (backwards compatibility)
  publicAPI.getScalarOpacity = (idx = 0) => publicAPI.getPiecewiseFunction(idx);

  publicAPI.setComponentWeight = (index = 0, value = 1) => {
    if (index < 0 || index >= VTK_MAX_VRCOMP) {
      vtkErrorMacro('Invalid index');
      return false;
    }

    const val = Math.min(1, Math.max(0, value));
    if (model.componentData[index].componentWeight !== val) {
      model.componentData[index].componentWeight = val;
      publicAPI.modified();
      return true;
    }
    return false;
  };

  publicAPI.getComponentWeight = (index = 0) => {
    if (index < 0 || index >= VTK_MAX_VRCOMP) {
      vtkErrorMacro('Invalid index');
      return 0.0;
    }

    return model.componentData[index].componentWeight;
  };

  publicAPI.setInterpolationTypeToNearest = () =>
    publicAPI.setInterpolationType(InterpolationType.NEAREST);

  publicAPI.setInterpolationTypeToLinear = () =>
    publicAPI.setInterpolationType(InterpolationType.LINEAR);

  publicAPI.getInterpolationTypeAsString = () =>
    macro.enumToString(InterpolationType, model.interpolationType);
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------
const DEFAULT_VALUES = {
  independentComponents: false,
  interpolationType: InterpolationType.LINEAR,
  colorWindow: 255,
  colorLevel: 127.5,
  ambient: 1.0,
  diffuse: 0.0,
  opacity: 1.0,
  useLookupTableScalarRange: false,
  useLabelOutline: false,
  labelOutlineThickness: [1],
  labelOutlineOpacity: 1.0,
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
  Object.assign(model, DEFAULT_VALUES, initialValues);

  // Build VTK API
  macro.obj(publicAPI, model);

  if (!model.componentData) {
    model.componentData = [];
    for (let i = 0; i < VTK_MAX_VRCOMP; i++) {
      model.componentData.push({
        rGBTransferFunction: null,
        piecewiseFunction: null,
        componentWeight: 1.0,
      });
    }
  }

  macro.setGet(publicAPI, model, [
    'independentComponents',
    'interpolationType',
    'colorWindow',
    'colorLevel',
    'ambient',
    'diffuse',
    'opacity',
    'useLookupTableScalarRange',
    'useLabelOutline',
    'labelOutlineOpacity',
  ]);

  macro.setGetArray(publicAPI, model, ['labelOutlineThickness']);

  // Object methods
  vtkImageProperty(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkImageProperty');

// ----------------------------------------------------------------------------

export default { newInstance, extend };