CubeSource

Introduction

vtkCubeSource creates a cube centered at origin. The cube is represented with four-sided polygons.
It is possible to specify the length, width, and height of the cube independently.

Usage

import vtkCubeSource from '@kitware/vtk.js/Filters/Sources/CubeSource';

const cubeSource = vtkCubeSource.newInstance({ xLength: 5, yLength: 5, zLength: 5 });
const polydata = cubeSource.getOutputData();

Methods

extend

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

getCenter

Get the center of the cube.

getCenterByReference

Get the center of the cube.

getGenerate3DTextureCoordinates

getGenerateFaces

Flag that indicates whether the output will generate faces of the outline.

Returns

Type Description
boolean

getGenerateLines

Flag that indicates whether the output will generate wireframe lines of the outline.

Returns

Type Description
boolean

getMatrix

Get the 4x4 transformation set to apply as a final trasformation to the output.

Argument Type Required Description
matrix Yes

getRotations

getRotationsByReference

getXLength

Get the length of the cube in the x-direction.

getYLength

Get the length of the cube in the y-direction.

getZLength

Get the length of the cube in the z-direction.

newInstance

Method used to create a new instance of vtkCubeSource.

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

requestData

Expose methods

Argument Type Required Description
inData Yes
outData Yes

setBounds

Convenience methods allows creation of cube by specifying bounding box.

Argument Type Required Description
bounds Bounds Yes The bounds for the cube.

setBounds

Convenience methods allows creation of cube by specifying bounding box.

Argument Type Required Description
xMin Number Yes
xMax Number Yes
yMin Number Yes
yMax Number Yes
zMin Number Yes
zMax Number Yes

setCenter

Set the center of the cube.

Argument Type Required Description
x Yes
y Yes
z Yes

setCenterFrom

Set the center of the cube.

Argument Type Required Description
center Yes

setGenerate3DTextureCoordinates

Argument Type Required Description
generate3DTextureCoordinates Yes

setGenerateFaces

Flag to indicate that the output should generate triangulated faces of the outline.

Argument Type Required Description
generateFaces boolean Yes

setGenerateLines

Flag to indicate that the output should generate wireframe of the outline.

Argument Type Required Description
generateLines boolean Yes

setMatrix

Set a 4x4 transformation that will be applied as a final trasformation to the output.

Argument Type Required Description
matrix Yes

setRotations

Float array of size 3 representing the angles, in degrees, of rotation for the cube.

Argument Type Required Description
xAngle Yes
yAngle Yes
zAngle Yes

setRotationsFrom

Argument Type Required Description
rotations Vector3 Yes

setXLength

Set the length of the cube in the x-direction.

Argument Type Required Description
xLength Yes

setYLength

Set the length of the cube in the y-direction.

Argument Type Required Description
yLength Yes

setZLength

Set the length of the cube in the z-direction.

Argument Type Required Description
zLength Yes

Source

index.d.ts
import { mat4 } from 'gl-matrix';
import { vtkAlgorithm, vtkObject } from "../../../interfaces";
import { Bounds, Vector3 } from "../../../types";

/**
*
*/
export interface ICircleSourceInitialValues {
xLength?: number;
yLength?: number;
zLength?: number;
center?: Vector3;
rotations?: Vector3;
pointType?: string;
generate3DTextureCoordinates?: boolean;
}

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

export interface vtkCubeSource extends vtkCubeSourceBase {

/**
* Get the center of the cube.
* @default [0.0, 0.0, 0.0]
*/
getCenter(): Vector3;

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

/**
*
* @default false
*/
getGenerate3DTextureCoordinates(): boolean;

/**
* Flag that indicates whether the output will generate faces of the outline.
* @returns {boolean}
*/
getGenerateFaces(): boolean;

/**
* Flag that indicates whether the output will generate wireframe lines of the outline.
* @returns {boolean}
*/
getGenerateLines(): boolean;

/**
* Get the 4x4 transformation set to apply as a final trasformation to the output.
* @param matrix
*/
getMatrix(): mat4;

/**
*
* @default [0.0, 0.0, 0.0]
*/
getRotations(): Vector3;

/**
*
* @default [0.0, 0.0, 0.0]
*/
getRotationsByReference(): Vector3;

/**
* Get the length of the cube in the x-direction.
* @default 1.0
*/
getXLength(): number;

/**
* Get the length of the cube in the y-direction.
* @default 1.0
*/
getYLength(): number;

/**
* Get the length of the cube in the z-direction.
* @default 1.0
*/
getZLength(): number;

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

/**
* Convenience methods allows creation of cube by specifying bounding box.
* @param {Number} xMin
* @param {Number} xMax
* @param {Number} yMin
* @param {Number} yMax
* @param {Number} zMin
* @param {Number} zMax
*/
setBounds(xMin: number, xMax: number, yMin: number, yMax: number, zMin: number, zMax: number): boolean;

/**
* Convenience methods allows creation of cube by specifying bounding box.
* @param {Bounds} bounds The bounds for the cube.
*/
setBounds(bounds: Bounds): boolean;

/**
* Set the center of the cube.
* @param x
* @param y
* @param z
* @default [0, 0, 0]
*/
setCenter(x: number, y: number, z: number): boolean;

/**
* Set the center of the cube.
* @param center
* @default [0, 0, 0]
*/
setCenterFrom(center: Vector3): boolean;

/**
*
* @param generate3DTextureCoordinates
*/
setGenerate3DTextureCoordinates(generate3DTextureCoordinates: boolean): boolean;

/**
* Flag to indicate that the output should generate wireframe of the outline.
* @param {boolean} generateLines
*/
setGenerateLines(generateLines: boolean): boolean;

/**
* Flag to indicate that the output should generate triangulated faces of the outline.
* @param {boolean} generateFaces
*/
setGenerateFaces(generateFaces: boolean): boolean;

/**
* Set a 4x4 transformation that will be applied as a final trasformation to the output.
* @param matrix
*/
setMatrix(matrix: mat4): boolean;

/**
* Float array of size 3 representing the angles, in degrees, of rotation for the cube.
* @param xAngle
* @param yAngle
* @param zAngle
*/
setRotations(xAngle: number, yAngle: number, zAngle: number): boolean;

/**
*
* @param {Vector3} rotations
*/
setRotationsFrom(rotations: Vector3): boolean;

/**
* Set the length of the cube in the x-direction.
* @param xLength
*/
setXLength(xLength: number): boolean;

/**
* Set the length of the cube in the y-direction.
* @param yLength
*/
setYLength(yLength: number): boolean;

/**
* Set the length of the cube in the z-direction.
* @param zLength
*/
setZLength(zLength: number): boolean;
}

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

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

/**
* vtkCubeSource creates a cube centered at origin. The cube is represented with four-sided polygons.
* It is possible to specify the length, width, and height of the cube independently.
*
* @example
* ```js
* import vtkCubeSource from '@kitware/vtk.js/Filters/Sources/CubeSource';
*
* const cubeSource = vtkCubeSource.newInstance({ xLength: 5, yLength: 5, zLength: 5 });
* const polydata = cubeSource.getOutputData();
* ```
*/
export declare const vtkCubeSource: {
newInstance: typeof newInstance,
extend: typeof extend,
};
export default vtkCubeSource;
index.js
import macro from 'vtk.js/Sources/macros';
import vtkCellArray from 'vtk.js/Sources/Common/Core/CellArray';
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';
import vtkMatrixBuilder from 'vtk.js/Sources/Common/Core/MatrixBuilder';

// prettier-ignore
const LINE_ARRAY = [
2, 0, 1,
2, 2, 3,
2, 4, 5,
2, 6, 7,
2, 0, 2,
2, 1, 3,
2, 4, 6,
2, 5, 7,
2, 0, 4,
2, 1, 5,
2, 2, 6,
2, 3, 7,
];

// prettier-ignore
const POLY_ARRAY = [
4, 0, 1, 3, 2,
4, 4, 6, 7, 5,
4, 8, 10, 11, 9,
4, 12, 13, 15, 14,
4, 16, 18, 19, 17,
4, 20, 21, 23, 22,
];

// ----------------------------------------------------------------------------
// vtkCubeSource methods
// ----------------------------------------------------------------------------

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

function requestData(inData, outData) {
if (model.deleted) {
return;
}

const polyData = vtkPolyData.newInstance();
outData[0] = polyData;

const numberOfPoints = 24;

// Define points
const points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
polyData.getPoints().setData(points, 3);

const normals = macro.newTypedArray(model.pointType, numberOfPoints * 3);
const normalArray = vtkDataArray.newInstance({
name: 'Normals',
values: normals,
numberOfComponents: 3,
});
polyData.getPointData().setNormals(normalArray);

let tcdim = 2;
if (model.generate3DTextureCoordinates === true) {
tcdim = 3;
}

const textureCoords = macro.newTypedArray(
model.pointType,
numberOfPoints * tcdim
);
const tcoords = vtkDataArray.newInstance({
name: 'TextureCoordinates',
values: textureCoords,
numberOfComponents: tcdim,
});
polyData.getPointData().setTCoords(tcoords);

const x = [0.0, 0.0, 0.0];
const n = [0.0, 0.0, 0.0];
const tc = [0.0, 0.0];

let pointIndex = 0;

x[0] = -model.xLength / 2.0;
n[0] = -1.0;
n[1] = 0.0;
n[2] = 0.0;
for (let i = 0; i < 2; i++) {
x[1] = -model.yLength / 2.0;

for (let j = 0; j < 2; j++) {
tc[1] = x[1] + 0.5;
x[2] = -model.zLength / 2.0;

for (let k = 0; k < 2; k++) {
tc[0] = (x[2] + 0.5) * (1 - 2 * i);
points[pointIndex * 3] = x[0];
points[pointIndex * 3 + 1] = x[1];
points[pointIndex * 3 + 2] = x[2];

normals[pointIndex * 3] = n[0];
normals[pointIndex * 3 + 1] = n[1];
normals[pointIndex * 3 + 2] = n[2];

if (tcdim === 2) {
textureCoords[pointIndex * tcdim] = tc[0];
textureCoords[pointIndex * tcdim + 1] = tc[1];
} else {
textureCoords[pointIndex * tcdim] = 2 * i - 1;
textureCoords[pointIndex * tcdim + 1] = 2 * j - 1;
textureCoords[pointIndex * tcdim + 2] = 2 * k - 1;
}

pointIndex++;

x[2] += model.zLength;
}
x[1] += model.yLength;
}
x[0] += model.xLength;
n[0] += 2.0;
}

x[1] = -model.yLength / 2.0;
n[1] = -1.0;
n[0] = 0.0;
n[2] = 0.0;
for (let i = 0; i < 2; i++) {
x[0] = -model.xLength / 2.0;

for (let j = 0; j < 2; j++) {
tc[0] = (x[0] + 0.5) * (2 * i - 1);
x[2] = -model.zLength / 2.0;

for (let k = 0; k < 2; k++) {
tc[1] = (x[2] + 0.5) * -1;

points[pointIndex * 3] = x[0];
points[pointIndex * 3 + 1] = x[1];
points[pointIndex * 3 + 2] = x[2];

normals[pointIndex * 3] = n[0];
normals[pointIndex * 3 + 1] = n[1];
normals[pointIndex * 3 + 2] = n[2];

if (tcdim === 2) {
textureCoords[pointIndex * tcdim] = tc[0];
textureCoords[pointIndex * tcdim + 1] = tc[1];
} else {
textureCoords[pointIndex * tcdim] = 2 * j - 1;
textureCoords[pointIndex * tcdim + 1] = 2 * i - 1;
textureCoords[pointIndex * tcdim + 2] = 2 * k - 1;
}

pointIndex++;
x[2] += model.zLength;
}
x[0] += model.xLength;
}
x[1] += model.yLength;
n[1] += 2.0;
}

x[2] = -model.zLength / 2.0;
n[2] = -1.0;
n[0] = 0.0;
n[1] = 0.0;
for (let i = 0; i < 2; i++) {
x[1] = -model.yLength / 2.0;

for (let j = 0; j < 2; j++) {
tc[1] = x[1] + 0.5;
x[0] = -model.xLength / 2.0;

for (let k = 0; k < 2; k++) {
tc[0] = (x[0] + 0.5) * (2 * i - 1);

points[pointIndex * 3] = x[0];
points[pointIndex * 3 + 1] = x[1];
points[pointIndex * 3 + 2] = x[2];

normals[pointIndex * 3] = n[0];
normals[pointIndex * 3 + 1] = n[1];
normals[pointIndex * 3 + 2] = n[2];

if (tcdim === 2) {
textureCoords[pointIndex * tcdim] = tc[0];
textureCoords[pointIndex * tcdim + 1] = tc[1];
} else {
textureCoords[pointIndex * tcdim] = 2 * k - 1;
textureCoords[pointIndex * tcdim + 1] = 2 * j - 1;
textureCoords[pointIndex * tcdim + 2] = 2 * i - 1;
}

pointIndex++;
x[0] += model.xLength;
}
x[1] += model.yLength;
}
x[2] += model.zLength;
n[2] += 2.0;
}

// Apply rotation to the points coordinates and normals
if (model.rotations) {
vtkMatrixBuilder
.buildFromDegree()
.rotateX(model.rotations[0])
.rotateY(model.rotations[1])
.rotateZ(model.rotations[2])
.apply(points)
.apply(normals);
}

// Apply transformation to the points coordinates
if (model.center) {
vtkMatrixBuilder
.buildFromRadian()
.translate(...model.center)
.apply(points);
}

// Apply optional additionally specified matrix transformation
if (model.matrix) {
vtkMatrixBuilder.buildFromRadian().setMatrix(model.matrix).apply(points);

// prettier-ignore
const rotMatrix = [
model.matrix[0], model.matrix[1], model.matrix[2], 0,
model.matrix[4], model.matrix[5], model.matrix[6], 0,
model.matrix[8], model.matrix[9], model.matrix[10], 0,
0, 0, 0, 1
];
vtkMatrixBuilder.buildFromRadian().setMatrix(rotMatrix).apply(normals);
}

// Lastly, generate the necessary cell arrays.
if (model.generateFaces) {
polyData.getPolys().deepCopy(model._polys);
} else {
polyData.getPolys().initialize();
}
if (model.generateLines) {
polyData.getLines().deepCopy(model._lineCells);
// only set normals for faces, not for lines.
polyData.getPointData().setNormals(null);
} else {
polyData.getLines().initialize();
}
polyData.modified();
}

publicAPI.setBounds = (...bounds) => {
let boundsArray = [];

if (Array.isArray(bounds[0])) {
boundsArray = bounds[0];
} else {
for (let i = 0; i < bounds.length; i++) {
boundsArray.push(bounds[i]);
}
}

if (boundsArray.length !== 6) {
return;
}

publicAPI.setXLength(boundsArray[1] - boundsArray[0]);
publicAPI.setYLength(boundsArray[3] - boundsArray[2]);
publicAPI.setZLength(boundsArray[5] - boundsArray[4]);
publicAPI.setCenter([
(boundsArray[0] + boundsArray[1]) / 2.0,
(boundsArray[2] + boundsArray[3]) / 2.0,
(boundsArray[4] + boundsArray[5]) / 2.0,
]);
};

// Expose methods
publicAPI.requestData = requestData;
}

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

const DEFAULT_VALUES = {
xLength: 1.0,
yLength: 1.0,
zLength: 1.0,
pointType: 'Float64Array',
generate3DTextureCoordinates: false,
generateFaces: true,
generateLines: false,
};

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

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

// Build VTK API
macro.obj(publicAPI, model);
macro.setGet(publicAPI, model, [
'xLength',
'yLength',
'zLength',
'generate3DTextureCoordinates',
'generateFaces',
'generateLines',
]);
macro.setGetArray(publicAPI, model, ['center', 'rotations'], 3);
macro.setGetArray(publicAPI, model, ['matrix'], 16);

// Internal persistent/static objects
model._polys = vtkCellArray.newInstance({
values: Uint16Array.from(POLY_ARRAY),
});
model._lineCells = vtkCellArray.newInstance({
values: Uint16Array.from(LINE_ARRAY),
});
macro.moveToProtected(publicAPI, model, ['polys', 'lineCells']);

macro.algo(publicAPI, model, 0, 1);
vtkCubeSource(publicAPI, model);
}

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

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

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

export default { newInstance, extend };