Property2D

Introduction

vtkProperty2D is an object that represents lighting and other surface
properties of a 2D geometric object. The primary properties that can be
set are colors (overall, ambient, diffuse, specular, and edge color);
specular power; opacity of the object; the representation of the
object (points, wireframe, or surface); and the shading method to be
used (flat, Gouraud, and Phong). Also, some special graphics features
like backface properties can be set and manipulated with this object.

Methods

extend

Method use to decorate a given object (publicAPI+model) with vtkProperty2D 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	IProperty2DInitialValues	No	(default: {})

getColor

Get the color of the object.

getColorByReference

Get the color of the object.

getDisplayLocation

Get the display location of the object.

getLineWidth

Get the width of a Line.
The width is expressed in screen units.

getOpacity

Get the opacity of the object.

getPointSize

Get the diameter of a point.
The size is expressed in screen units.

newInstance

Method use to create a new instance of vtkProperty2D with object color, ambient color, diffuse color,
specular color, and edge color white; ambient coefficient=0; diffuse
coefficient=0; specular coefficient=0; specular power=1; Gouraud shading;
and surface representation. Backface and frontface culling are off.

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

setColor

Set the color of the object. Has the side effect of setting the
ambient diffuse and specular colors as well. This is basically
a quick overall color setting method.

Argument	Type	Required	Description
color	RGBColor	Yes	Defines the RGB color array..

setColor

Set the color of the object. Has the side effect of setting the
ambient diffuse and specular colors as well. This is basically
a quick overall color setting method.

Argument	Type	Required	Description
r	Number	Yes	Defines the red component (between 0 and 1).
g	Number	Yes	Defines the green component (between 0 and 1).
b	Number	Yes	Defines the blue component (between 0 and 1).

setColorFrom

Set the color of the object. Has the side effect of setting the
ambient diffuse and specular colors as well. This is basically
a quick overall color setting method.

Argument	Type	Required	Description
color	RGBColor	Yes	Defines the RGB color array..

setColorFrom

Set the color of the object. Has the side effect of setting the
ambient diffuse and specular colors as well. This is basically
a quick overall color setting method.

Argument	Type	Required	Description
r	Number	Yes	Defines the red component (between 0 and 1).
g	Number	Yes	Defines the green component (between 0 and 1).
b	Number	Yes	Defines the blue component (between 0 and 1).

setDisplayLocation

Set the display location of the object.

Argument	Type	Required	Description
displayLocation	String	Yes

setLineWidth

Set the width of a Line. The width is expressed in screen units.
This is only implemented for OpenGL.

Argument	Type	Required	Description
lineWidth	Number	Yes	The width of the Line.

setOpacity

Set the object’s opacity. 1.0 is totally opaque and 0.0 is
completely transparent.

Argument	Type	Required	Description
opacity	Number	Yes	The opacity value.

setPointSize

Set the diameter of a point. The size is expressed in screen units.
This is only implemented for OpenGL.

Argument	Type	Required	Description
pointSize	Number	Yes	The diameter of the point.

Source

Constants.d.ts

export declare enum DisplayLocation {
  BACKGROUND = 0,
  FOREGROUND = 1,
}

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

Constants.js

export const DisplayLocation = {
  BACKGROUND: 0,
  FOREGROUND: 1,
};

export default {
  DisplayLocation,
};

index.d.ts

import { vtkObject } from '../../../interfaces';
import { RGBColor } from '../../../types';
import { DisplayLocation } from './Constants';

export interface IProperty2DInitialValues {
  color?: RGBColor;
  opacity?: number;
  pointSize?: number;
  lineWidth?: number;
  displayLocation?: DisplayLocation;
}

export interface vtkProperty2D extends vtkObject {
  /**
   * Get the color of the object.
   */
  getColor(): RGBColor;

  /**
   * Get the color of the object.
   */
  getColorByReference(): RGBColor;

  /**
   * Get the display location of the object.
   * @default 'Foreground'
   */
  getDisplayLocation(): DisplayLocation;

  /**
   * Get the width of a Line.
   * The width is expressed in screen units.
   */
  getLineWidth(): number;

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

  /**
   * Get the diameter of a point.
   * The size is expressed in screen units.
   */
  getPointSize(): number;

  /**
   * Set the color of the object. Has the side effect of setting the
   * ambient diffuse and specular colors as well. This is basically
   * a quick overall color setting method.
   * @param {Number} r Defines the red component (between 0 and 1).
   * @param {Number} g Defines the green component (between 0 and 1).
   * @param {Number} b Defines the blue component (between 0 and 1).
   */
  setColor(r: number, g: number, b: number): boolean;

  /**
   * Set the color of the object. Has the side effect of setting the
   * ambient diffuse and specular colors as well. This is basically
   * a quick overall color setting method.
   * @param {RGBColor} color Defines the RGB color array..
   */
  setColor(color: RGBColor): boolean;

  /**
   * Set the color of the object. Has the side effect of setting the
   * ambient diffuse and specular colors as well. This is basically
   * a quick overall color setting method.
   * @param {Number} r Defines the red component (between 0 and 1).
   * @param {Number} g Defines the green component (between 0 and 1).
   * @param {Number} b Defines the blue component (between 0 and 1).
   */
  setColorFrom(r: number, g: number, b: number): boolean;

  /**
   * Set the color of the object. Has the side effect of setting the
   * ambient diffuse and specular colors as well. This is basically
   * a quick overall color setting method.
   * @param {RGBColor} color Defines the RGB color array..
   */
  setColorFrom(color: RGBColor): boolean;

  /**
   * Set the display location of the object.
   * @param {String} displayLocation
   */
  setDisplayLocation(displayLocation: DisplayLocation): boolean;

  /**
   * Set the width of a Line. The width is expressed in screen units.
   * This is only implemented for OpenGL.
   * @param {Number} lineWidth The width of the Line.
   * @default 1.0
   */
  setLineWidth(lineWidth: number): boolean;

  /**
   * Set the object’s opacity. 1.0 is totally opaque and 0.0 is
   * completely transparent.
   * @param {Number} opacity The opacity value.
   */
  setOpacity(opacity: number): boolean;

  /**
   * Set the diameter of a point. The size is expressed in screen units.
   * This is only implemented for OpenGL.
   * @param {Number} pointSize The diameter of the point.
   * @default 1.0
   */
  setPointSize(pointSize: number): boolean;
}

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

/**
 * Method use to create a new instance of vtkProperty2D with object color, ambient color, diffuse color,
 * specular color, and edge color white; ambient coefficient=0; diffuse
 * coefficient=0; specular coefficient=0; specular power=1; Gouraud shading;
 * and surface representation. Backface and frontface culling are off.
 * @param {IProperty2DInitialValues} [initialValues] for pre-setting some of its content
 */
export function newInstance(
  initialValues?: IProperty2DInitialValues
): vtkProperty2D;

/**
 * vtkProperty2D is an object that represents lighting and other surface
 * properties of a 2D geometric object. The primary properties that can be
 * set are colors (overall, ambient, diffuse, specular, and edge color);
 * specular power; opacity of the object; the representation of the
 * object (points, wireframe, or surface); and the shading method to be
 * used (flat, Gouraud, and Phong). Also, some special graphics features
 * like backface properties can be set and manipulated with this object.
 */
export declare const vtkProperty2D: {
  newInstance: typeof newInstance;
  extend: typeof extend;
};
export default vtkProperty2D;

index.js

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

import { Representation } from 'vtk.js/Sources/Rendering/Core/Property/Constants';

const { DisplayLocation } = Constants;

// ----------------------------------------------------------------------------
// vtkProperty2D methods
// ----------------------------------------------------------------------------

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

  publicAPI.setDisplayLocationToBackground = () =>
    publicAPI.setDisplayLocation(DisplayLocation.BACKGROUND);
  publicAPI.setDisplayLocationToForeground = () =>
    publicAPI.setDisplayLocation(DisplayLocation.FOREGROUND);

  publicAPI.setRepresentationToWireframe = () =>
    publicAPI.setRepresentation(Representation.WIREFRAME);
  publicAPI.setRepresentationToSurface = () =>
    publicAPI.setRepresentation(Representation.SURFACE);
  publicAPI.setRepresentationToPoints = () =>
    publicAPI.setRepresentation(Representation.POINTS);
  publicAPI.getRepresentationAsString = () =>
    macro.enumToString(Representation, model.representation);
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------
const DEFAULT_VALUES = {
  color: [1, 1, 1],
  opacity: 1,
  pointSize: 1,
  lineWidth: 1,
  representation: Representation.SURFACE,
  displayLocation: DisplayLocation.FOREGROUND,
};

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

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

  // Build VTK API
  macro.obj(publicAPI, model);
  macro.setGet(publicAPI, model, [
    'opacity',
    'lineWidth',
    'pointSize',
    'displayLocation',
    'representation',
  ]);
  macro.setGetArray(publicAPI, model, ['color'], 3);

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

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

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

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

export default { newInstance, extend, ...Constants };