PointSource

Introduction

vtkPointSource is a source object that creates a user-specified number of
points within a specified radius about a specified center point. By default
location of the points is random within the sphere. It is also possible to
generate random points only on the surface of the sphere. The output PolyData
has the specified number of points and 1 cell - a vtkPolyVertex containing
all of the points.

Usage

import vtkPointSource from '@kitware/vtk.js/Filters/Sources/PointSource';

const point = vtkPointSource.newInstance({ numberOfPoints: 10 });
const polydata = point.getOutputData();

Methods

extend

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

getCenter

Get the center of the plane.

getCenterByReference

Get the center of the plane.

getNumberOfPoints

Get the number of points to generate.

getRadius

Get the radius of the point cloud.

newInstance

Method used to create a new instance of vtkPointSource.

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

requestData

Argument Type Required Description
inData Yes
outData Yes

setCenter

Set the center of the point cloud.

Argument Type Required Description
center Vector3 Yes The center point’s coordinates.

setCenter

Set the center of the point cloud.

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

setCenterFrom

Set the center of the point cloud.

Argument Type Required Description
center Vector3 Yes The center point’s coordinates.

setNumberOfPoints

Set the number of points to generate.

Argument Type Required Description
numberOfPoints Number Yes The number of points to generate.

setRadius

Set the radius of the point cloud. If you are generating a Gaussian
distribution, then this is the standard deviation for each of x, y, and
z.

Argument Type Required Description
radius Number Yes The radius value.

Source

index.d.ts
import { vtkAlgorithm, vtkObject } from '../../../interfaces';
import { Vector3 } from '../../../types';

/**
*
*/
export interface IPointSourceInitialValues {
numberOfPoints?: number;
center?: Vector3;
radius?: number;
pointType?: string;
}

type vtkPointSourceBase = vtkObject &
Omit<
vtkAlgorithm,
| 'getInputData'
| 'setInputData'
| 'setInputConnection'
| 'getInputConnection'
| 'addInputConnection'
| 'addInputData'
>;

export interface vtkPointSource extends vtkPointSourceBase {
/**
* Get the center of the plane.
* @default [0, 0, 0]
*/
getCenter(): Vector3;

/**
* Get the center of the plane.
*/
getCenterByReference(): Vector3;

/**
* Get the number of points to generate.
* @default 10
*/
getNumberOfPoints(): number;

/**
* Get the radius of the point cloud.
* @default 0.5
*/
getRadius(): number;

/**
*
* @param inData
* @param outData
*/
requestData(inData: any, outData: any): void;

/**
* Set the center of the point cloud.
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Number} z The z coordinate.
*/
setCenter(x: number, y: number, z: number): boolean;

/**
* Set the center of the point cloud.
* @param {Vector3} center The center point's coordinates.
*/
setCenter(center: Vector3): boolean;

/**
* Set the center of the point cloud.
* @param {Vector3} center The center point's coordinates.
*/
setCenterFrom(center: Vector3): boolean;

/**
* Set the number of points to generate.
* @param {Number} numberOfPoints The number of points to generate.
*/
setNumberOfPoints(numberOfPoints: number): boolean;

/**
* Set the radius of the point cloud. If you are generating a Gaussian
* distribution, then this is the standard deviation for each of x, y, and
* z.
* @param {Number} radius The radius value.
*/
setRadius(radius: number): boolean;
}

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

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

/**
* vtkPointSource is a source object that creates a user-specified number of
* points within a specified radius about a specified center point. By default
* location of the points is random within the sphere. It is also possible to
* generate random points only on the surface of the sphere. The output PolyData
* has the specified number of points and 1 cell - a vtkPolyVertex containing
* all of the points.
*
* @example
* ```js
* import vtkPointSource from '@kitware/vtk.js/Filters/Sources/PointSource';
*
* const point = vtkPointSource.newInstance({ numberOfPoints: 10 });
* const polydata = point.getOutputData();
* ```
*/
export declare const vtkPointSource: {
newInstance: typeof newInstance;
extend: typeof extend;
};
export default vtkPointSource;
index.js
import macro from 'vtk.js/Sources/macros';
import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';

// ----------------------------------------------------------------------------
// vtkPointSource methods
// ----------------------------------------------------------------------------

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

publicAPI.requestData = (inData, outData) => {
if (model.deleted) {
return;
}

const dataset = outData[0];

// Check input
const pointDataType = dataset
? dataset.getPoints().getDataType()
: model.pointType;
const pd = vtkPolyData.newInstance();

// hand create a point cloud
const numPts = model.numberOfPoints;

// Points
const points = macro.newTypedArray(pointDataType, numPts * 3);
pd.getPoints().setData(points, 3);

// Cells
const verts = new Uint32Array(numPts + 1);
pd.getVerts().setData(verts, 1);

let cosphi;
let sinphi;
let rho;
let radius;
let theta;
for (let i = 0; i < numPts; i++) {
cosphi = 1 - 2.0 * vtkMath.random();
sinphi = Math.sqrt(1 - cosphi * cosphi);
rho = model.radius * vtkMath.random() ** 0.33333333;
radius = rho * sinphi;
theta = 2.0 * Math.PI * vtkMath.random();
points[i * 3] = model.center[0] + radius * Math.cos(theta);
points[i * 3 + 1] = model.center[1] + radius * Math.sin(theta);
points[i * 3 + 2] = model.center[2] + rho * cosphi;
}

// Generate point connectivity
//
verts[0] = numPts;
for (let i = 0; i < numPts; i++) {
verts[i + 1] = i;
}

// Update output
outData[0] = pd;
};
}

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

const DEFAULT_VALUES = {
numberOfPoints: 10,
center: [0, 0, 0],
radius: 0.5,
pointType: 'Float64Array',
};

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

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

// Build VTK API
macro.obj(publicAPI, model);
macro.setGet(publicAPI, model, ['numberOfPoints', 'radius']);
macro.setGetArray(publicAPI, model, ['center'], 3);
macro.algo(publicAPI, model, 0, 1);
vtkPointSource(publicAPI, model);
}

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

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

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

export default { newInstance, extend };