Cell

Introduction

vtkCell is an abstract method to define a cell

Methods

deepCopy

Copy this cell by completely copying internal data structures.

Argument	Type	Required	Description
cell	vtkCell	Yes	The cell you want to use.

extend

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

getBounds

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

getLength2

Compute Length squared of cell (i.e., bounding box diagonal squared).

getNumberOfPoints

Get the number of points in the cell.

getParametricDistance

Get the distance of the parametric coordinate provided to the cell. If
inside the cell, a distance of zero is returned. This is used during
picking to get the correct cell picked. (The tolerance will occasionally
allow cells to be picked who are not really intersected “inside” the
cell.)

Argument	Type	Required	Description
pcoords	Vector3	Yes	The coordinates of the point.

getPoints

getPointsIds

initialize

Initialize the cell with point coordinates and cell point ids, example :

const points = vtkPoints.newInstance();
points.setData(Float32Array.from([0, 0, 0, 0, 0, 1, ..., 255, 255, 255]));
const pointIdsList = [13, 10, 235];
// Create cell
const triangle = vtkTriangle.newInstance();
// Initialize cell
triangle.initialize(points, pointIdsList);

If pointIdsList is null, points are shallow copied and pointIdsList is
generated as such: [0, 1, …, N-1] where N is the number of points. If
pointIdsList is not null, only pointIdsList point coordinates are copied into
the cell. pointIdsList is shallow copied.

Argument	Type	Required	Description
points	vtkPoints	Yes
pointIdsList	Array.	No

newInstance

Method used to create a new instance of vtkCell.

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

Source

index.d.ts

import { vtkObject } from '../../../interfaces';
import { Bounds, Vector3 } from '../../../types';
import vtkPoints from '../../Core/Points';

export interface ICellInitialValues {
  bounds?: Bounds;
  pointsIds?: number[];
}

export interface vtkCell extends vtkObject {
  /**
   * Copy this cell by completely copying internal data structures.
   * @param {vtkCell} cell The cell you want to use.
   */
  deepCopy(cell: vtkCell): void;

  /**
   * Initialize the cell with point coordinates and cell point ids, example :
   *
   * ```js
   * const points = vtkPoints.newInstance();
   * points.setData(Float32Array.from([0, 0, 0, 0, 0, 1, ..., 255, 255, 255]));
   * const pointIdsList = [13, 10, 235];
   * // Create cell
   * const triangle = vtkTriangle.newInstance();
   * // Initialize cell
   * triangle.initialize(points, pointIdsList);
   * ```
   *
   * If pointIdsList is null, points are shallow copied and pointIdsList is
   * generated as such: [0, 1, ..., N-1] where N is the number of points. If
   * pointIdsList is not null, only pointIdsList point coordinates are copied into
   * the cell. pointIdsList is shallow copied.
   * @param {vtkPoints} points
   * @param {Number[]} [pointIdsList]
   */
  initialize(points: vtkPoints, pointIdsList?: number[]): void;

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

  /**
   * Compute Length squared of cell (i.e., bounding box diagonal squared).
   */
  getLength2(): number;

  /**
   * Get the distance of the parametric coordinate provided to the cell. If
   * inside the cell, a distance of zero is returned. This is used during
   * picking to get the correct cell picked. (The tolerance will occasionally
   * allow cells to be picked who are not really intersected "inside" the
   * cell.)
   * @param {Vector3} pcoords The coordinates of the point.
   *
   */
  getParametricDistance(pcoords: Vector3): number;

  /**
   *
   */
  getPoints(): vtkPoints;

  /**
   *
   */
  getPointsIds(): number[];

  /**
   * Get the number of points in the cell.
   */
  getNumberOfPoints(): number;

  // getCellDimension(): void;
  // intersectWithLine(p1: any, p2: any, tol: any, t: any, x: any, pcoords: any, subId: any): void;
  // evaluatePosition(x: Vector3, closestPoint: Vector3, subId: number, pcoords: Vector3, dist2: number, weights: any): void;
}

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

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

/**
 * vtkCell is an abstract method to define a cell
 */
export declare const vtkCell: {
  newInstance: typeof newInstance;
  extend: typeof extend;
};
export default vtkCell;

index.js

import macro from 'vtk.js/Sources/macros';
import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
import vtkPoints from 'vtk.js/Sources/Common/Core/Points';

// ----------------------------------------------------------------------------
// vtkCell methods
// ----------------------------------------------------------------------------

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

  publicAPI.initialize = (points, pointIdsList = null) => {
    if (!pointIdsList) {
      model.points = points;
      model.pointsIds = new Array(points.getNumberOfPoints());
      for (let i = points.getNumberOfPoints() - 1; i >= 0; --i) {
        model.pointsIds[i] = i;
      }
    } else {
      model.pointsIds = pointIdsList;
      let triangleData = model.points.getData();
      if (triangleData.length !== 3 * model.pointsIds.length) {
        triangleData = macro.newTypedArray(
          points.getDataType(),
          3 * model.pointsIds.length
        );
      }
      const pointsData = points.getData();
      model.pointsIds.forEach((pointId, index) => {
        // const start = 3 * pointId;
        // pointsData.set(p.subarray(start, start + 3), 3 * index);
        let pointOffset = 3 * pointId;
        let trianglePointOffset = 3 * index;
        triangleData[trianglePointOffset] = pointsData[pointOffset];
        triangleData[++trianglePointOffset] = pointsData[++pointOffset];
        triangleData[++trianglePointOffset] = pointsData[++pointOffset];
      });
      model.points.setData(triangleData);
    }
  };

  publicAPI.getBounds = () => {
    const nbPoints = model.points.getNumberOfPoints();
    const x = [];
    if (nbPoints) {
      model.points.getPoint(0, x);
      model.bounds[0] = x[0];
      model.bounds[1] = x[0];
      model.bounds[2] = x[1];
      model.bounds[3] = x[1];
      model.bounds[4] = x[2];
      model.bounds[5] = x[2];

      for (let i = 1; i < nbPoints; i++) {
        model.points.getPoint(i, x);
        model.bounds[0] = x[0] < model.bounds[0] ? x[0] : model.bounds[0];
        model.bounds[1] = x[0] > model.bounds[1] ? x[0] : model.bounds[1];
        model.bounds[2] = x[1] < model.bounds[2] ? x[1] : model.bounds[2];
        model.bounds[3] = x[1] > model.bounds[3] ? x[1] : model.bounds[3];
        model.bounds[4] = x[2] < model.bounds[4] ? x[2] : model.bounds[4];
        model.bounds[5] = x[2] > model.bounds[5] ? x[2] : model.bounds[5];
      }
    } else {
      vtkMath.uninitializeBounds(model.bounds);
    }
    return model.bounds;
  };

  publicAPI.getLength2 = () => {
    publicAPI.getBounds();
    let length = 0.0;
    let diff = 0;
    for (let i = 0; i < 3; i++) {
      diff = model.bounds[2 * i + 1] - model.bounds[2 * i];
      length += diff * diff;
    }
    return length;
  };

  publicAPI.getParametricDistance = (pcoords) => {
    let pDist;
    let pDistMax = 0.0;

    for (let i = 0; i < 3; i++) {
      if (pcoords[i] < 0.0) {
        pDist = -pcoords[i];
      } else if (pcoords[i] > 1.0) {
        pDist = pcoords[i] - 1.0;
      } else {
        // inside the cell in the parametric direction
        pDist = 0.0;
      }
      if (pDist > pDistMax) {
        pDistMax = pDist;
      }
    }
    return pDistMax;
  };

  publicAPI.getNumberOfPoints = () => model.points.getNumberOfPoints();

  publicAPI.deepCopy = (cell) => {
    cell.initialize(model.points, model.pointsIds);
  };

  publicAPI.getCellDimension = () => {}; // virtual
  publicAPI.intersectWithLine = (p1, p2, tol, t, x, pcoords, subId) => {}; // virtual
  publicAPI.evaluatePosition = (
    x,
    closestPoint,
    subId,
    pcoords,
    dist2,
    weights
  ) => {
    macro.vtkErrorMacro('vtkCell.evaluatePosition is not implemented.');
  }; // virtual
}

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

const DEFAULT_VALUES = {
  bounds: [-1, -1, -1, -1, -1, -1],
  pointsIds: [],
};

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

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

  macro.obj(publicAPI, model);

  if (!model.points) {
    model.points = vtkPoints.newInstance();
  }

  macro.get(publicAPI, model, ['points', 'pointsIds']);

  vtkCell(publicAPI, model);
}

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

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

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

export default { newInstance, extend };