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 'vtk.js/Sources/Filters/Sources/CubeSource';

const cubeSource = vtkCubeSource.newInstance({ xLength: 5, yLength: 5, zLength: 5 });
const cubePolydata = 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

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 Yes

setBounds

Convenience methods allows creation of cube by specifying bounding box.

Argument Type Required Description
xMin Yes
xMax Yes
yMin Yes
yMax Yes
zMin Yes
zMax 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

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 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 { vtkAlgorithm, vtkObject } from "vtk.js/Sources/interfaces";

/**
*
*/
interface ICircleSourceInitialValues {
xLength?: number;
yLength?: number;
zLength?: number;
center?: number[];
rotations?: number[];
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(): number[];

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

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

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

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

/**
* 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 xMin
* @param xMax
* @param yMin
* @param yMax
* @param zMin
* @param 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
*/
setBounds(bounds: number[]): 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: number[]): boolean;

/**
*
* @param generate3DTextureCoordinates
*/
setGenerate3DTextureCoordinates(generate3DTextureCoordinates: boolean): 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 rotations
*/
setRotationsFrom(rotations: number[]): 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 'vtk.js/Sources/Filters/Sources/CubeSource';
*
* const cubeSource = vtkCubeSource.newInstance({ xLength: 5, yLength: 5, zLength: 5 });
* const cubePolydata = cubeSource.getOutputData();
* ```
*/
export declare const vtkCubeSource: {
newInstance: typeof newInstance,
extend: typeof extend,
};
export default vtkCubeSource;
index.js
import macro from 'vtk.js/Sources/macro';
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';

// ----------------------------------------------------------------------------
// 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 numberOfPolys = 6;
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
vtkMatrixBuilder
.buildFromDegree()
.rotateX(model.rotations[0])
.rotateY(model.rotations[1])
.rotateZ(model.rotations[2])
.apply(points)
.apply(normals);

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

// Define quads
const polys = macro.newTypedArray(model.pointType, numberOfPolys * 5);
polyData.getPolys().setData(polys, 1);

let polyIndex = 0;

polys[polyIndex++] = 4;
polys[polyIndex++] = 0;
polys[polyIndex++] = 1;
polys[polyIndex++] = 3;
polys[polyIndex++] = 2;

polys[polyIndex++] = 4;
polys[polyIndex++] = 4;
polys[polyIndex++] = 6;
polys[polyIndex++] = 7;
polys[polyIndex++] = 5;

polys[polyIndex++] = 4;
polys[polyIndex++] = 8;
polys[polyIndex++] = 10;
polys[polyIndex++] = 11;
polys[polyIndex++] = 9;

polys[polyIndex++] = 4;
polys[polyIndex++] = 12;
polys[polyIndex++] = 13;
polys[polyIndex++] = 15;
polys[polyIndex++] = 14;

polys[polyIndex++] = 4;
polys[polyIndex++] = 16;
polys[polyIndex++] = 18;
polys[polyIndex++] = 19;
polys[polyIndex++] = 17;

polys[polyIndex++] = 4;
polys[polyIndex++] = 20;
polys[polyIndex++] = 21;
polys[polyIndex++] = 23;
polys[polyIndex] = 22;
}

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

model.xLength = boundsArray[1] - boundsArray[0];
model.yLength = boundsArray[3] - boundsArray[2];
model.zLength = boundsArray[5] - boundsArray[4];
model.center = [
(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,
center: [0.0, 0.0, 0.0],
rotations: [0.0, 0.0, 0.0],
pointType: 'Float32Array',
generate3DTextureCoordinates: 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',
]);
macro.setGetArray(publicAPI, model, ['center', 'rotations'], 3);

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

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

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

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

export default { newInstance, extend };