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

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

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

	/**
	 *
	 * @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;

	/**
	 * 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 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 = new Uint16Array(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: 'Float64Array',
  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 };