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 };