Points

Introduction

vtkPoints represents 3D points. The data model for vtkPoints is an array
of vx-vy-vz triplets accessible by (point or cell) id.

Methods

computeBounds

Trigger the computation of bounds

extend

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

findPoint

Convenient method to search a point in the array.
This is a naïve search. Consider using a “locator” instead.

Argument	Type	Required	Description
pointToSearch	Array. or TypedArray	Yes
precision	Number	Yes	(1e-6 by default)

Returns

Type	Description
Number	the index of the point if found, -1 otherwise.

getBounds

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

getNumberOfPoints

Get the number of points for this object can hold.

getPoint

Get the coordinate of a point.

Argument	Type	Required	Description
idx	Number	Yes	The index of point.
tupleToFill	Array. or TypedArray	No	(default [])

Returns

Type	Description
Array. or TypedArray

insertNextPoint

Insert the (x,y,z) coordinates of a point at the next available slot.

Argument	Type	Required	Description
x	Number	Yes	The x coordinate.
y	Number	Yes	The y coordinate.
z	Number	Yes	The z coordinate.

Returns

Type	Description
Number	Index of the inserted point.

newInstance

Method used to create a new instance of vtkPoints

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

setNumberOfPoints

Set the number of points for this object to hold.

points.getData()[0] = x;
points.getData()[1] = y;
points.getData()[2] = z;

Argument	Type	Required	Description
nbPoints	Number	Yes
dimension	Number	No

setPoint

Set the (x,y,z) coordinates of a point based on its index.

Argument	Type	Required	Description
idx	Number	Yes	The index of point.
x	Number	Yes	The x coordinate.
y	Number	Yes	The y coordinate.
z	Number	Yes	The z coordinate.

Source

index.d.ts

import vtkDataArray from '../../../Common/Core/DataArray';
import { Bounds, TypedArray } from '../../../types';

/**
 *
 */
export interface IPointsInitialValues {
  empty?: boolean;
  numberOfComponents?: number;
  bounds?: Bounds;
}

export interface vtkPoints extends vtkDataArray {
  /**
   * Trigger the computation of bounds
   */
  computeBounds(): Bounds;

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

  /**
   * Get the coordinate of a point.
   * @param {Number} idx The index of point.
   * @param {Number[]|TypedArray} [tupleToFill] (default [])
   * @returns {Number[]|TypedArray}
   */
  getPoint(
    idx: number,
    tupleToFill?: number[] | TypedArray
  ): number[] | TypedArray;

  /**
   * Convenient method to search a point in the array.
   * This is a naïve search. Consider using a "locator" instead.
   * @param {Array<Number>|TypedArray} pointToSearch
   * @param {Number} precision (1e-6 by default)
   * @returns {Number} the index of the point if found, -1 otherwise.
   */
  findPoint(
    pointToSearch: Array<number> | TypedArray,
    precision?: number
  ): number;

  /**
   * Get the number of points for this object can hold.
   */
  getNumberOfPoints(): number;

  /**
   * Set the number of points for this object to hold.
   *
   * ```js
   * points.getData()[0] = x;
   * points.getData()[1] = y;
   * points.getData()[2] = z;
   * ```
   *
   * @param {Number} nbPoints
   * @param {Number} [dimension]
   */
  setNumberOfPoints(nbPoints: number, dimension?: number): void;

  /**
   * Set the (x,y,z) coordinates of a point based on its index.
   * @param {Number} idx The index of point.
   * @param {Number} x The x coordinate.
   * @param {Number} y The y coordinate.
   * @param {Number} z The z coordinate.
   */
  setPoint(idx: number, x: number, y: number, z: number): void;

  /**
   * Insert the (x,y,z) coordinates of a point at the next available slot.
   * @param {Number} x The x coordinate.
   * @param {Number} y The y coordinate.
   * @param {Number} z The z coordinate.
   * @returns {Number} Index of the inserted point.
   */
  insertNextPoint(x: number, y: number, z: number): number;
}

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

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

/**
 * vtkPoints represents 3D points. The data model for vtkPoints is an array
 * of vx-vy-vz triplets accessible by (point or cell) id.
 */

export declare const vtkPoints: {
  newInstance: typeof newInstance;
  extend: typeof extend;
};
export default vtkPoints;

index.js

import macro from 'vtk.js/Sources/macros';
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
import { VtkDataTypes } from 'vtk.js/Sources/Common/Core/DataArray/Constants';

const { vtkErrorMacro } = macro;

const INVALID_BOUNDS = [1, -1, 1, -1, 1, -1];

// ----------------------------------------------------------------------------
// vtkPoints methods
// ----------------------------------------------------------------------------

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

  // Forwarding methods
  publicAPI.getNumberOfPoints = publicAPI.getNumberOfTuples;

  publicAPI.setNumberOfPoints = (nbPoints, dimension = 3) => {
    if (publicAPI.getNumberOfPoints() !== nbPoints) {
      model.size = nbPoints * dimension;
      model.values = macro.newTypedArray(model.dataType, model.size);
      publicAPI.setNumberOfComponents(dimension);
      publicAPI.modified();
    }
  };

  publicAPI.setPoint = (idx, ...xyz) => {
    publicAPI.setTuple(idx, xyz);
  };

  publicAPI.getPoint = publicAPI.getTuple;
  publicAPI.findPoint = publicAPI.findTuple;

  publicAPI.insertNextPoint = (x, y, z) => publicAPI.insertNextTuple([x, y, z]);

  publicAPI.getBounds = () => {
    if (publicAPI.getNumberOfComponents() === 3) {
      const xRange = publicAPI.getRange(0);
      model.bounds[0] = xRange[0];
      model.bounds[1] = xRange[1];
      const yRange = publicAPI.getRange(1);
      model.bounds[2] = yRange[0];
      model.bounds[3] = yRange[1];
      const zRange = publicAPI.getRange(2);
      model.bounds[4] = zRange[0];
      model.bounds[5] = zRange[1];
      return model.bounds;
    }

    if (publicAPI.getNumberOfComponents() !== 2) {
      vtkErrorMacro(`getBounds called on an array with components of
        ${publicAPI.getNumberOfComponents()}`);
      return INVALID_BOUNDS;
    }

    const xRange = publicAPI.getRange(0);
    model.bounds[0] = xRange[0];
    model.bounds[1] = xRange[1];
    const yRange = publicAPI.getRange(1);
    model.bounds[2] = yRange[0];
    model.bounds[3] = yRange[1];
    model.bounds[4] = 0;
    model.bounds[5] = 0;

    return model.bounds;
  };

  // Trigger the computation of bounds
  publicAPI.computeBounds = publicAPI.getBounds;

  // Initialize
  publicAPI.setNumberOfComponents(
    model.numberOfComponents < 2 ? 3 : model.numberOfComponents
  );
}

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

const DEFAULT_VALUES = {
  empty: true,
  numberOfComponents: 3,
  dataType: VtkDataTypes.FLOAT,
  bounds: [1, -1, 1, -1, 1, -1],
};

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

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

  vtkDataArray.extend(publicAPI, model, initialValues);
  vtkPoints(publicAPI, model);
}

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

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

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

export default { newInstance, extend };