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: {})

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. No

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

Insert point into object.

Argument Type Required Description
idx Number Yes The index of point.
coord Array. Yes The point’s coordinates.

setPoint

Set the (x,y,z) coordinate 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 'vtk.js/Sources/Common/Core/DataArray';

/**
*
*/
interface IPointsInitialValues {
empty?: boolean;
numberOfComponents?: number;
bounds?: number[];
}

export interface vtkPoints extends vtkDataArray {

/**
* Trigger the computation of bounds
*/
computeBounds(): number[];

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

/**
* Get the coordinate of a point.
* @param {Number} idx The index of point.
* @param {Number[]} [tupleToFill]
* @default []
*/
getPoint(idx: number, tupleToFill?: 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) coordinate 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 point into object.
* @param {Number} idx The index of point.
* @param {Number[]} coord The point's coordinates.
*/
setPoint(idx: number, coord: number[]): void;
}

/**
* 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/macro';
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) => {
const offset = idx * model.numberOfComponents;
for (let i = 0; i < model.numberOfComponents; i++) {
model.values[offset + i] = xyz[i];
}
};

publicAPI.getPoint = publicAPI.getTuple;

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