AbstractMapper

Introduction

vtkAbstractMapper is an abstract class to specify interface between data and
graphics primitives or software rendering techniques. Subclasses of
vtkAbstractMapper can be used for rendering 2D data, geometry, or volumetric
data.

Methods

addClippingPlane

Added plane needs to be a vtkPlane object.

Argument	Type	Required	Description
plane	vtkPlane	Yes

extend

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

getClippingPlaneInDataCoords

Get the ith clipping plane as a homogeneous plane equation.
Use getNumberOfClippingPlanes() to get the number of planes.

Argument	Type	Required	Description
propMatrix	mat4	Yes
i	Number	Yes
hnormal	Array.	Yes

getClippingPlanes

Get all clipping planes.

getNumberOfClippingPlanes

Get number of clipping planes.

removeAllClippingPlanes

Remove all clipping planes.

removeClippingPlane

Remove clipping plane.

Argument	Type	Required	Description
plane	vtkPlane	Yes

setClippingPlanes

Set clipping planes.

Argument	Type	Required	Description
planes	Array.	Yes

update

Source

index.d.ts

import { vtkAlgorithm, vtkObject } from '../../../interfaces';
import vtkPlane from '../../../Common/DataModel/Plane';
import { mat4 } from 'gl-matrix';

/**
 *
 */
export interface IAbstractMapperInitialValues {
  clippingPlanes?: vtkPlane[];
}

type vtkAbstractMapperBase = vtkObject &
  Omit<vtkAlgorithm, 'getOutputData' | 'getOutputPort'>;

export interface vtkAbstractMapper extends vtkAbstractMapperBase {
  /**
   * Added plane needs to be a vtkPlane object.
   * @param {vtkPlane} plane
   */
  addClippingPlane(plane: vtkPlane): boolean;

  /**
   * Get number of clipping planes.
   * @return {Number} The number of clipping planes.
   */
  getNumberOfClippingPlanes(): number;

  /**
   * Get all clipping planes.
   * @return {vtkPlane[]} An array of the clipping planes objects
   */
  getClippingPlanes(): vtkPlane[];

  /**
   * Remove all clipping planes.
   * @return true if there were planes, false otherwise.
   */
  removeAllClippingPlanes(): boolean;

  /**
   * Remove clipping plane.
   * @param {vtkPlane} plane
   * @return true if plane existed and therefore is removed, false otherwise.
   */
  removeClippingPlane(plane: vtkPlane): boolean;

  /**
   * Set clipping planes.
   * @param {vtkPlane[]} planes
   */
  setClippingPlanes(planes: vtkPlane[]): void;

  /**
   * Get the ith clipping plane as a homogeneous plane equation.
   * Use getNumberOfClippingPlanes() to get the number of planes.
   * @param {mat4} propMatrix
   * @param {Number} i
   * @param {Number[]} hnormal
   */
  getClippingPlaneInDataCoords(
    propMatrix: mat4,
    i: number,
    hnormal: number[]
  ): void;

  /**
   *
   */
  update(): void;
}

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

/**
 * vtkAbstractMapper is an abstract class to specify interface between data and
 * graphics primitives or software rendering techniques. Subclasses of
 * vtkAbstractMapper can be used for rendering 2D data, geometry, or volumetric
 * data.
 */
export declare const vtkAbstractMapper: {
  extend: typeof extend;
};
export default vtkAbstractMapper;

index.js

import macro from 'vtk.js/Sources/macros';

// ----------------------------------------------------------------------------
// vtkAbstractMapper methods
// ----------------------------------------------------------------------------

function vtkAbstractMapper(publicAPI, model) {
  model.classHierarchy.push('vtkAbstractMapper');
  publicAPI.update = () => {
    publicAPI.getInputData();
  };

  publicAPI.addClippingPlane = (plane) => {
    if (!plane.isA('vtkPlane')) {
      return false;
    }
    if (!model.clippingPlanes.includes(plane)) {
      model.clippingPlanes.push(plane);
      publicAPI.modified();
      return true;
    }
    return false;
  };

  publicAPI.getNumberOfClippingPlanes = () => model.clippingPlanes.length;

  publicAPI.removeAllClippingPlanes = () => {
    if (model.clippingPlanes.length === 0) {
      return false;
    }
    model.clippingPlanes.length = 0;
    publicAPI.modified();
    return true;
  };

  publicAPI.removeClippingPlane = (clippingPlane) => {
    const i = model.clippingPlanes.indexOf(clippingPlane);
    if (i === -1) {
      return false;
    }
    model.clippingPlanes.splice(i, 1);
    publicAPI.modified();
    return true;
  };

  publicAPI.getClippingPlanes = () => model.clippingPlanes;

  publicAPI.setClippingPlanes = (planes) => {
    if (!planes) {
      return;
    }
    if (!Array.isArray(planes)) {
      publicAPI.addClippingPlane(planes);
    } else {
      const nbPlanes = planes.length;
      for (let i = 0; i < nbPlanes && i < 6; i++) {
        publicAPI.addClippingPlane(planes[i]);
      }
    }
  };

  publicAPI.getClippingPlaneInDataCoords = (propMatrix, i, hnormal) => {
    const clipPlanes = model.clippingPlanes;
    const mat = propMatrix;

    if (clipPlanes) {
      const n = clipPlanes.length;
      if (i >= 0 && i < n) {
        // Get the plane
        const plane = clipPlanes[i];
        const normal = plane.getNormal();
        const origin = plane.getOrigin();

        // Compute the plane equation
        const v1 = normal[0];
        const v2 = normal[1];
        const v3 = normal[2];
        const v4 = -(v1 * origin[0] + v2 * origin[1] + v3 * origin[2]);

        // Transform normal from world to data coords
        hnormal[0] = v1 * mat[0] + v2 * mat[4] + v3 * mat[8] + v4 * mat[12];
        hnormal[1] = v1 * mat[1] + v2 * mat[5] + v3 * mat[9] + v4 * mat[13];
        hnormal[2] = v1 * mat[2] + v2 * mat[6] + v3 * mat[10] + v4 * mat[14];
        hnormal[3] = v1 * mat[3] + v2 * mat[7] + v3 * mat[11] + v4 * mat[15];

        return;
      }
    }
    macro.vtkErrorMacro(`Clipping plane index ${i} is out of range.`);
  };
}

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

const DEFAULT_VALUES = {
  clippingPlanes: [],
};

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

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

  // Object methods
  macro.obj(publicAPI, model);
  macro.algo(publicAPI, model, 1, 0);

  if (!model.clippingPlanes) {
    model.clippingPlanes = [];
  }

  vtkAbstractMapper(publicAPI, model);
}

// ----------------------------------------------------------------------------
export default { extend };