PlaneSource

Introduction

vtkPlaneSource creates an m x n array of quadrilaterals arranged as a regular
tiling in a plane. The plane is defined by specifying an origin point, and then
two other points that, together with the origin, define two axes for the plane.
These axes do not have to be orthogonal - so you can create a parallelogram.
(The axes must not be parallel.) The resolution of the plane (i.e., number of
subdivisions) is controlled by the ivars XResolution and YResolution.

By default, the plane is centered at the origin and perpendicular to the z-axis,
with width and height of length 1 and resolutions set to 1.

Usage

import vtkPlaneSource from 'vtk.js/Sources/Filters/Sources/PlaneSource';

const plane = vtkPlaneSource.newInstance({ xResolution: 10, yResolution: 10 });
const polydata = plane.getOutputData();

Methods

extend

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

getCenter

Get the center of the plane.

getCenterByReference

Get the center of the plane.

getNormal

Get the normal of the plane.

getNormalByReference

Get the normal of the plane.

getOrigin

Get the origin of the plane, lower-left corner.

getOriginByReference

Get the origin of the plane, lower-left corner.

getPoint1

Get the x axes of the plane.

getPoint1ByReference

Get the x axes of the plane.

getPoint2

Get the y axes of the plane.

getPoint2ByReference

Get the y axes of the plane.

getXResolution

Get the x resolution of the plane.

getYResolution

Get the y resolution of the plane.

newInstance

Method used to create a new instance of vtkPlaneSource.

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

requestData

Argument Type Required Description
inData Yes
outData Yes

rotate

Rotate plane around a given axis

Argument Type Required Description
angle Yes theta Angle (radian) to rotate about
rotationAxis Yes Axis to rotate around

setCenter

Set the center of the plane.

Argument Type Required Description
center Array. Yes The coordinate of the center point.

setCenter

Set the center of the plane.

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

setNormal

Set the normal of the plane.

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

setNormal

Set the normal of the plane.

Argument Type Required Description
normal Array. Yes The normal coordinate.

setNormalFrom

Set the normal of the plane.

Argument Type Required Description
normal Array. Yes The normal coordinate.

setOrigin

Set the origin of the plane.

Argument Type Required Description
x Number Yes The x coordinate of the origin point.
y Number Yes The y coordinate of the origin point.
z Number Yes The z coordinate of the origin point.

setOrigin

Set the origin of the plane.

Argument Type Required Description
origin Array. Yes The coordinate of the origin point.

setOriginFrom

Set the origin of the plane.

Argument Type Required Description
origin Array. Yes The coordinate of the origin point.

setPoint1

Specify a point defining the first axis of the plane.

Argument Type Required Description
point1 Array. Yes

setPoint1

Specify a point defining the first axis of the plane.

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

setPoint2

Specify a point defining the second axis of the plane.

Argument Type Required Description
point2 Array. Yes

setPoint2

Specify a point defining the second axis of the plane.

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

setXResolution

Set the number of facets used to represent the cone.

Argument Type Required Description
xResolution Number Yes

setYResolution

Set the number of facets used to represent the cone.

Argument Type Required Description
yResolution Number Yes

updatePlane

Argument Type Required Description
v1 vec3 Yes
v2 vec3 Yes

Source

index.d.ts
import { vec3 } from 'gl-matrix';
import { vtkAlgorithm, vtkObject } from "vtk.js/Sources/interfaces";

/**
*
*/
interface IPlaneSourceInitialValues {
xResolution?: number;
yResolution?: number;
origin?: number[];
point1?: number[];
point2?: number[];
pointType?: string;
}

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

export interface vtkPlaneSource extends vtkPlaneSourceBase {

/**
* Get the center of the plane.
* @default [0, 0, 0]
*/
getCenter(): number[];

/**
* Get the center of the plane.
*/
getCenterByReference(): number[];

/**
* Get the normal of the plane.
* @default [0, 0, 1]
*/
getNormal(): number[];

/**
* Get the normal of the plane.
*/
getNormalByReference(): number[];

/**
* Get the origin of the plane, lower-left corner.
* @default [0, 0, 0]
*/
getOrigin(): number[];

/**
* Get the origin of the plane, lower-left corner.
*/
getOriginByReference(): number[];

/**
* Get the x axes of the plane.
* @default [1, 0, 0]
*/
getPoint1(): number[];

/**
* Get the x axes of the plane.
*/
getPoint1ByReference(): number[];

/**
* Get the y axes of the plane.
* @default [0, 1, 0]
*/
getPoint2(): number[];

/**
* Get the y axes of the plane.
*/
getPoint2ByReference(): number[];

/**
* Get the x resolution of the plane.
* @default 10
*/
getXResolution(): number;

/**
* Get the y resolution of the plane.
* @default 10
*/
getYResolution(): number;

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

/**
* Rotate plane around a given axis
* @param angle theta Angle (radian) to rotate about
* @param rotationAxis Axis to rotate around
*/
rotate(angle: number, rotationAxis: vec3): void;

/**
* Set the center of the plane.
* @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): void;

/**
* Set the center of the plane.
* @param {Number[]} center The coordinate of the center point.
*/
setCenter(center: number[]): void;

/**
* Set the normal of the plane.
* @param {Number[]} normal The normal coordinate.
*/
setNormal(normal: number[]): boolean;

/**
* Set the normal of the plane.
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Number} z The z coordinate.
*/
setNormal(x: number, y: number, z: number): boolean;

/**
* Set the normal of the plane.
* @param {Number[]} normal The normal coordinate.
*/
setNormalFrom(normal: number[]): boolean;

/**
* Set the origin of the plane.
* @param {Number[]} origin The coordinate of the origin point.
*/
setOrigin(origin: number[]): boolean;

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

/**
* Set the origin of the plane.
* @param {Number[]} origin The coordinate of the origin point.
*/
setOriginFrom(origin: number[]): boolean;

/**
* Specify a point defining the first axis of the plane.
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Number} z The z coordinate.
*/
setPoint1(x: number, y: number, z: number): boolean;

/**
* Specify a point defining the first axis of the plane.
* @param {Number[]} point1
*/
setPoint1(point1: number[]): boolean;

/**
* Specify a point defining the second axis of the plane.
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Number} z The z coordinate.
*/
setPoint2(x: number, y: number, z: number): boolean;

/**
* Specify a point defining the second axis of the plane.
* @param {Number[]} point2
*/
setPoint2(point2: number[]): boolean;

/**
* Set the number of facets used to represent the cone.
* @param {Number} xResolution
*/
setXResolution(xResolution: number): boolean;

/**
* Set the number of facets used to represent the cone.
* @param {Number} yResolution
*/
setYResolution(yResolution: number): boolean;

/**
*
* @param {vec3} v1
* @param {vec3} v2
*/
updatePlane(v1: vec3, v2: vec3): boolean;
}

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

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

/**
* vtkPlaneSource creates an m x n array of quadrilaterals arranged as a regular
* tiling in a plane. The plane is defined by specifying an origin point, and then
* two other points that, together with the origin, define two axes for the plane.
* These axes do not have to be orthogonal - so you can create a parallelogram.
* (The axes must not be parallel.) The resolution of the plane (i.e., number of
* subdivisions) is controlled by the ivars XResolution and YResolution.
*
* By default, the plane is centered at the origin and perpendicular to the z-axis,
* with width and height of length 1 and resolutions set to 1.
*
* @example
* ```js
* import vtkPlaneSource from 'vtk.js/Sources/Filters/Sources/PlaneSource';
*
* const plane = vtkPlaneSource.newInstance({ xResolution: 10, yResolution: 10 });
* const polydata = plane.getOutputData();
* ```
*/
export declare const vtkPlaneSource: {
newInstance: typeof newInstance,
extend: typeof extend,
};
export default vtkPlaneSource;
index.js
import { vec3, mat4 } from 'gl-matrix';
import macro from 'vtk.js/Sources/macro';
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
import vtkMatrixBuilder from 'vtk.js/Sources/Common/Core/MatrixBuilder';

import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';

const { vtkWarningMacro } = macro;

const EPSILON = 1e-6;

// ----------------------------------------------------------------------------
// vtkPlaneSource methods
// ----------------------------------------------------------------------------

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

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

const dataset = outData[0];

// Check input
const pointDataType = dataset
? dataset.getPoints().getDataType()
: 'Float32Array';
const pd = vtkPolyData.newInstance();
const v10 = new Float32Array(3);
const v20 = new Float32Array(3);
vtkMath.subtract(model.point1, model.origin, v10);
vtkMath.subtract(model.point2, model.origin, v20);

if (!publicAPI.updatePlane(v10, v20)) {
vtkWarningMacro('Bad plane definition');
return;
}

// hand create a plane with special scalars
const xres = model.xResolution;
const yres = model.yResolution;
const numPts = (xres + 1) * (yres + 1);
const numPolys = xres * yres;

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

// Cells
const polys = new Uint32Array(5 * numPolys);
pd.getPolys().setData(polys, 1);

// Normals
const normalsData = new Float32Array(numPts * 3);
const normals = vtkDataArray.newInstance({
numberOfComponents: 3,
values: normalsData,
name: 'Normals',
});
pd.getPointData().setNormals(normals);

// Texture coords
const tcData = new Float32Array(numPts * 2);
const tcoords = vtkDataArray.newInstance({
numberOfComponents: 2,
values: tcData,
name: 'TextureCoordinates',
});
pd.getPointData().setTCoords(tcoords);

const tc = new Float32Array(2);
let idx = 0;
for (let j = 0; j < yres + 1; j++) {
tc[1] = j / yres;
for (let i = 0; i < xres + 1; i++) {
tc[0] = i / xres;

points[idx * 3] = model.origin[0] + tc[0] * v10[0] + tc[1] * v20[0];
points[idx * 3 + 1] = model.origin[1] + tc[0] * v10[1] + tc[1] * v20[1];
points[idx * 3 + 2] = model.origin[2] + tc[0] * v10[2] + tc[1] * v20[2];

tcData[idx * 2] = tc[0];
tcData[idx * 2 + 1] = tc[1];

normalsData[idx * 3] = model.normal[0];
normalsData[idx * 3 + 1] = model.normal[1];
normalsData[idx * 3 + 2] = model.normal[2];

idx++;
}
}

// Generate polygon connectivity
//
idx = 0;
for (let j = 0; j < yres; j++) {
for (let i = 0; i < xres; i++) {
polys[idx * 5 + 0] = 4;
polys[idx * 5 + 1] = i + j * (xres + 1);
polys[idx * 5 + 2] = polys[idx * 5 + 1] + 1;
polys[idx * 5 + 3] = polys[idx * 5 + 1] + xres + 2;
polys[idx * 5 + 4] = polys[idx * 5 + 1] + xres + 1;

idx++;
}
}

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

publicAPI.setNormal = (...normal) => {
let n = [];

if (normal.length === 1 || Array.isArray(normal[0])) {
n = [...normal[0]];
} else if (normal.length === 3) {
n = [normal[0], normal[1], normal[2]];
}

if (vtkMath.normalize(n) !== 0) {
const dp = vtkMath.dot(model.normal, n);

let theta = 0;
const rotationVector = [];

if (dp < 1.0) {
if (dp <= -1.0) {
theta = vtkMath.radiansFromDegrees(180.0);
vtkMath.subtract(model.point1, model.origin, rotationVector);
} else {
vtkMath.cross(model.normal, n, rotationVector);
theta = Math.acos(dp);
}
publicAPI.rotate(theta, rotationVector);
}
}
};

/**
* Rotate plane around a given axis
* @param {float} theta Angle (radian) to rotate about
* @param {vec3} rotationAxis Axis to rotate around
*/
publicAPI.rotate = (angle, rotationAxis) => {
if (Math.abs(angle) < EPSILON) {
return;
}
// Create rotation matrix
const transform = mat4.identity(new Float64Array(16));
const negCenter = [];
vec3.negate(negCenter, model.center);

mat4.translate(transform, transform, model.center);
mat4.rotate(transform, transform, angle, rotationAxis);
mat4.translate(transform, transform, negCenter);

vec3.transformMat4(model.origin, model.origin, transform);
vec3.transformMat4(model.point1, model.point1, transform);
vec3.transformMat4(model.point2, model.point2, transform);

vtkMatrixBuilder
.buildFromRadian()
.rotate(angle, rotationAxis)
.apply(model.normal);

publicAPI.modified();
};

publicAPI.setCenter = (...center) => {
let c = [];

if (center.length === 1 || Array.isArray(center[0])) {
c = [...center[0]];
} else if (center.length === 3) {
c = [center[0], center[1], center[2]];
}

if (!vec3.exactEquals(c, model.center)) {
const v1 = [];
vtkMath.subtract(model.point1, model.origin, v1);

const v2 = [];
vtkMath.subtract(model.point2, model.origin, v2);

for (let i = 0; i < 3; i++) {
model.center[i] = c[i];
model.origin[i] = model.center[i] - 0.5 * (v1[i] + v2[i]);
model.point1[i] = model.origin[i] + v1[i];
model.point2[i] = model.origin[i] + v2[i];
}
publicAPI.modified();
}
};

publicAPI.setPoint1 = (...point) => {
let point1 = [];

if (point.length === 1 || Array.isArray(point[0])) {
point1 = [...point[0]];
} else if (point.length === 3) {
point1 = [point[0], point[1], point[2]];
}

if (!vec3.exactEquals(point1, model.point1)) {
const v1 = [];
const v2 = [];

model.point1 = [...point1];
vtkMath.subtract(model.point1, model.origin, v1);
vtkMath.subtract(model.point2, model.origin, v2);

// set plane normal
publicAPI.updatePlane(v1, v2);
publicAPI.modified();
}
};

publicAPI.setPoint2 = (...point) => {
let point2 = [];

if (point.length === 1 || Array.isArray(point[0])) {
point2 = [...point[0]];
} else if (point.length === 3) {
point2 = [point[0], point[1], point[2]];
}

if (!vec3.exactEquals(point2, model.point2)) {
const v1 = [];
const v2 = [];

model.point2 = [...point2];
vtkMath.subtract(model.point1, model.origin, v1);
vtkMath.subtract(model.point2, model.origin, v2);

// set plane normal
publicAPI.updatePlane(v1, v2);
publicAPI.modified();
}
};

publicAPI.updatePlane = (v1, v2) => {
// set plane center
for (let i = 0; i < 3; i++) {
model.center[i] = model.origin[i] + 0.5 * (v1[i] + v2[i]);
}

// set plane normal
vtkMath.cross(v1, v2, model.normal);

return vtkMath.normalize(model.normal) !== 0.0;
};
}

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

const DEFAULT_VALUES = {
xResolution: 10,
yResolution: 10,
origin: [0, 0, 0],
point1: [1, 0, 0],
point2: [0, 1, 0],
pointType: 'Float32Array',
};

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

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

model.normal = [0, 0, 1];
model.center = [0, 0, 0];

// Build VTK API
macro.obj(publicAPI, model);
macro.setGet(publicAPI, model, ['xResolution', 'yResolution']);
macro.setGetArray(publicAPI, model, ['origin'], 3);
macro.getArray(publicAPI, model, ['point1', 'point2', 'normal', 'center'], 3);

macro.algo(publicAPI, model, 0, 1);
vtkPlaneSource(publicAPI, model);

publicAPI.setPoint1(model.point1);
publicAPI.setPoint2(model.point2);
}

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

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

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

export default { newInstance, extend };