Actor

Introduction

vtkActor is used to represent an entity in a rendering scene. It inherits
functions related to the actors position, and orientation from
vtkProp3D. The actor also has scaling and maintains a reference to the
defining geometry (i.e., the mapper), rendering properties, and possibly a
texture map. vtkActor combines these instance variables into one 4x4
transformation matrix as follows: [x y z 1] = [x y z 1] Translate(-origin)
Scale(scale) Rot(y) Rot(x) Rot (z) Trans(origin) Trans(position)

See Also

vtkMapper

vtkProperty

Methods

extend

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

getActors

For some exporters and other other operations we must be
able to collect all the actors or volumes. These methods
are used in that process.

getBackfaceProperty

Get the property object that controls this actors backface surface
properties.

getBounds

Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].

getForceOpaque

Check whether the opaque is forced or not.

getForceTranslucent

Check whether the translucency is forced or not.

getIsOpaque

Check if the actor is opaque or not

getMapper

Get the Mapper that this actor is getting its data from.

getProperty

Get the property object that controls this actors surface
properties. This should be an instance of a vtkProperty object. Every
actor must have a property associated with it. If one isn’t specified,
then one will be generated automatically. Multiple actors can share one
property object.

getSupportsSelection

Check whether if the actor supports selection

hasTranslucentPolygonalGeometry

Return if the prop have some translucent polygonal geometry

makeProperty

Create a new property suitable for use with this type of Actor.

Argument Type Required Description
initialValues IPropertyInitialValues No (default: {})

newInstance

Method used to create a new instance of vtkActor with the following defaults:

  • origin = [0, 0, 0]
  • position = [0, 0, 0]
  • scale = [1, 1, 1]
  • visibility = 1
  • pickable = 1
  • dragable = 1
  • orientation = [0, 0, 0]

No user defined matrix and no texture map.

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

setBackfaceProperty

Set the property object that controls this actors backface surface
properties.

Argument Type Required Description
backfaceProperty vtkProperty Yes The backfaceProperty instance.

setForceOpaque

Force the actor to be treated as opaque or translucent.

Argument Type Required Description
forceOpaque Boolean Yes

setForceTranslucent

Force the actor to be treated as opaque or translucent.

Argument Type Required Description
forceTranslucent Boolean Yes

setMapper

This is the method that is used to connect an actor to the end of a
visualization pipeline, i.e. the mapper.

Argument Type Required Description
mapper vtkMapper Yes The vtkMapper instance.

setProperty

Set the property object that controls this actors surface properties.

Argument Type Required Description
property vtkProperty Yes The vtkProperty instance.

Source

index.d.ts
import { Bounds, Nullable } from '../../../types';
import vtkMapper from '../Mapper';
import vtkProp3D, { IProp3DInitialValues } from '../Prop3D';
import vtkProperty, { IPropertyInitialValues } from '../Property';

/**
*
*/
export interface IActorInitialValues extends IProp3DInitialValues {
mapper?: vtkMapper;
property?: vtkProperty;
backfaceProperty?: vtkProperty;
forceOpaque?: boolean;
forceTranslucent?: boolean;
bounds?: Bounds;
}

export interface vtkActor extends vtkProp3D {
/**
* Return if the prop have some translucent polygonal geometry
*/
hasTranslucentPolygonalGeometry(): boolean;

/**
* For some exporters and other other operations we must be
* able to collect all the actors or volumes. These methods
* are used in that process.
* @return {vtkActor[]} list of actors
*/
getActors(): vtkActor[];

/**
* Get the property object that controls this actors backface surface
* properties.
* @return {vtkProperty} the backface property.
*/
getBackfaceProperty(): vtkProperty;

/**
* Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
* @return {Bounds} The bounds for the mapper.
*/
getBounds(): Bounds;

/**
* Check whether the opaque is forced or not.
*/
getForceOpaque(): boolean;

/**
* Check whether the translucency is forced or not.
*/
getForceTranslucent(): boolean;

/**
* Check if the actor is opaque or not
* @return true if the actor is opaque
*/
getIsOpaque(): boolean;

/**
* Get the Mapper that this actor is getting its data from.
*/
getMapper(): Nullable<vtkMapper>;

/**
* Get the property object that controls this actors surface
* properties. This should be an instance of a vtkProperty object. Every
* actor must have a property associated with it. If one isn’t specified,
* then one will be generated automatically. Multiple actors can share one
* property object.
* @return {vtkProperty} The property object
*/
getProperty(): vtkProperty;

/**
* Check whether if the actor supports selection
* @return {Boolean} true if the actor support selection.
*/
getSupportsSelection(): boolean;

/**
* Create a new property suitable for use with this type of Actor.
* @param {IPropertyInitialValues} [initialValues] (default: {})
*/
makeProperty(initialValues?: IPropertyInitialValues): vtkProperty;

/**
* Set the property object that controls this actors backface surface
* properties.
* @param {vtkProperty} backfaceProperty The backfaceProperty instance.
*/
setBackfaceProperty(backfaceProperty: vtkProperty): boolean;

/**
* Force the actor to be treated as opaque or translucent.
* @param {Boolean} forceOpaque
*/
setForceOpaque(forceOpaque: boolean): boolean;

/**
* Force the actor to be treated as opaque or translucent.
* @param {Boolean} forceTranslucent
*/
setForceTranslucent(forceTranslucent: boolean): boolean;

/**
* This is the method that is used to connect an actor to the end of a
* visualization pipeline, i.e. the mapper.
* @param {vtkMapper} mapper The vtkMapper instance.
*/
setMapper(mapper: vtkMapper): boolean;

/**
* Set the property object that controls this actors surface properties.
* @param {vtkProperty} property The vtkProperty instance.
*/
setProperty(property: vtkProperty): boolean;
}

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

/**
* Method used to create a new instance of vtkActor with the following defaults:
*
* * origin = [0, 0, 0]
* * position = [0, 0, 0]
* * scale = [1, 1, 1]
* * visibility = 1
* * pickable = 1
* * dragable = 1
* * orientation = [0, 0, 0]
*
* No user defined matrix and no texture map.
* @param {IActorInitialValues} [initialValues] for pre-setting some of its content
*/
export function newInstance(initialValues?: IActorInitialValues): vtkActor;

/**
* vtkActor is used to represent an entity in a rendering scene. It inherits
* functions related to the actors position, and orientation from
* vtkProp3D. The actor also has scaling and maintains a reference to the
* defining geometry (i.e., the mapper), rendering properties, and possibly a
* texture map. vtkActor combines these instance variables into one 4x4
* transformation matrix as follows: [x y z 1] = [x y z 1] Translate(-origin)
* Scale(scale) Rot(y) Rot(x) Rot (z) Trans(origin) Trans(position)
* @see [vtkMapper](./Rendering_Core_Mapper.html)
* @see [vtkProperty](./Rendering_Core_Property.html)
*/
export declare const vtkActor: {
newInstance: typeof newInstance;
extend: typeof extend;
};
export default vtkActor;
index.js
import { vec3, mat4 } from 'gl-matrix';
import macro from 'vtk.js/Sources/macros';
import vtkBoundingBox from 'vtk.js/Sources/Common/DataModel/BoundingBox';
import vtkProp3D from 'vtk.js/Sources/Rendering/Core/Prop3D';
import vtkProperty from 'vtk.js/Sources/Rendering/Core/Property';

const { vtkDebugMacro } = macro;

// ----------------------------------------------------------------------------
// vtkActor methods
// ----------------------------------------------------------------------------

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

// Capture 'parentClass' api for internal use
const superClass = { ...publicAPI };

publicAPI.getActors = () => [publicAPI];

publicAPI.getIsOpaque = () => {
if (model.forceOpaque) {
return true;
}
if (model.forceTranslucent) {
return false;
}
// make sure we have a property
if (!model.property) {
// force creation of a property
publicAPI.getProperty();
}

let isOpaque = model.property.getOpacity() >= 1.0;

// are we using an opaque texture, if any?
isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());

// are we using an opaque scalar array, if any?
isOpaque = isOpaque && (!model.mapper || model.mapper.getIsOpaque());

return isOpaque;
};

publicAPI.hasTranslucentPolygonalGeometry = () => {
if (model.mapper === null) {
return false;
}
// make sure we have a property
if (model.property === null) {
// force creation of a property
publicAPI.setProperty(publicAPI.makeProperty());
}

// is this actor opaque ?
return !publicAPI.getIsOpaque();
};

publicAPI.makeProperty = vtkProperty.newInstance;

publicAPI.getProperty = () => {
if (model.property === null) {
model.property = publicAPI.makeProperty();
}
return model.property;
};

publicAPI.getBounds = () => {
if (model.mapper === null) {
return model.bounds;
}

// Check for the special case when the mapper's bounds are unknown
const bds = model.mapper.getBounds();
if (!bds || bds.length !== 6) {
return bds;
}

// Check for the special case when the actor is empty.
if (bds[0] > bds[1]) {
model.mapperBounds = bds.concat(); // copy the mapper's bounds
model.bounds = [1, -1, 1, -1, 1, -1];
model.boundsMTime.modified();
return bds;
}

// Check if we have cached values for these bounds - we cache the
// values returned by model.mapper.getBounds() and we store the time
// of caching. If the values returned this time are different, or
// the modified time of this class is newer than the cached time,
// then we need to rebuild.
if (
!model.mapperBounds ||
bds[0] !== model.mapperBounds[0] ||
bds[1] !== model.mapperBounds[1] ||
bds[2] !== model.mapperBounds[2] ||
bds[3] !== model.mapperBounds[3] ||
bds[4] !== model.mapperBounds[4] ||
bds[5] !== model.mapperBounds[5] ||
publicAPI.getMTime() > model.boundsMTime.getMTime()
) {
vtkDebugMacro('Recomputing bounds...');
model.mapperBounds = bds.concat(); // copy the mapper's bounds
const bbox = [];
vtkBoundingBox.getCorners(bds, bbox);

publicAPI.computeMatrix();
const tmp4 = new Float64Array(16);
mat4.transpose(tmp4, model.matrix);
bbox.forEach((pt) => vec3.transformMat4(pt, pt, tmp4));

/* eslint-disable no-multi-assign */
model.bounds[0] = model.bounds[2] = model.bounds[4] = Number.MAX_VALUE;
model.bounds[1] = model.bounds[3] = model.bounds[5] = -Number.MAX_VALUE;
/* eslint-enable no-multi-assign */

model.bounds = model.bounds.map((d, i) =>
i % 2 === 0
? bbox.reduce((a, b) => (a > b[i / 2] ? b[i / 2] : a), d)
: bbox.reduce((a, b) => (a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a), d)
);

model.boundsMTime.modified();
}
return model.bounds;
};

publicAPI.getMTime = () => {
let mt = superClass.getMTime();
if (model.property !== null) {
const time = model.property.getMTime();
mt = time > mt ? time : mt;
}

if (model.backfaceProperty !== null) {
const time = model.backfaceProperty.getMTime();
mt = time > mt ? time : mt;
}

return mt;
};

publicAPI.getRedrawMTime = () => {
let mt = model.mtime;
if (model.mapper !== null) {
let time = model.mapper.getMTime();
mt = time > mt ? time : mt;
if (model.mapper.getInput() !== null) {
// FIXME !!! getInputAlgorithm / getInput
model.mapper.getInputAlgorithm().update();
time = model.mapper.getInput().getMTime();
mt = time > mt ? time : mt;
}
}
return mt;
};

publicAPI.getSupportsSelection = () =>
model.mapper ? model.mapper.getSupportsSelection() : false;

publicAPI.processSelectorPixelBuffers = (selector, pixelOffsets) => {
if (model.mapper && model.mapper.processSelectorPixelBuffers) {
model.mapper.processSelectorPixelBuffers(selector, pixelOffsets);
}
};
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
mapper: null,
property: null,
backfaceProperty: null,

forceOpaque: false,
forceTranslucent: false,

bounds: [1, -1, 1, -1, 1, -1],
};

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

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

// Inheritance
vtkProp3D.extend(publicAPI, model, initialValues);

// vtkTimeStamp
model.boundsMTime = {};
macro.obj(model.boundsMTime);

// Build VTK API
macro.set(publicAPI, model, ['property']);
macro.setGet(publicAPI, model, [
'backfaceProperty',
'forceOpaque',
'forceTranslucent',
'mapper',
]);

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

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

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

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

export default { newInstance, extend };