CellTypes

Source

Constants.js
export const CellType = {
// Linear cells
VTK_EMPTY_CELL: 0,
VTK_VERTEX: 1,
VTK_POLY_VERTEX: 2,
VTK_LINE: 3,
VTK_POLY_LINE: 4,
VTK_TRIANGLE: 5,
VTK_TRIANGLE_STRIP: 6,
VTK_POLYGON: 7,
VTK_PIXEL: 8,
VTK_QUAD: 9,
VTK_TETRA: 10,
VTK_VOXEL: 11,
VTK_HEXAHEDRON: 12,
VTK_WEDGE: 13,
VTK_PYRAMID: 14,
VTK_PENTAGONAL_PRISM: 15,
VTK_HEXAGONAL_PRISM: 16,

// Quadratic, isoparametric cells
VTK_QUADRATIC_EDGE: 21,
VTK_QUADRATIC_TRIANGLE: 22,
VTK_QUADRATIC_QUAD: 23,
VTK_QUADRATIC_POLYGON: 36,
VTK_QUADRATIC_TETRA: 24,
VTK_QUADRATIC_HEXAHEDRON: 25,
VTK_QUADRATIC_WEDGE: 26,
VTK_QUADRATIC_PYRAMID: 27,
VTK_BIQUADRATIC_QUAD: 28,
VTK_TRIQUADRATIC_HEXAHEDRON: 29,
VTK_QUADRATIC_LINEAR_QUAD: 30,
VTK_QUADRATIC_LINEAR_WEDGE: 31,
VTK_BIQUADRATIC_QUADRATIC_WEDGE: 32,
VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON: 33,
VTK_BIQUADRATIC_TRIANGLE: 34,

// Cubic, isoparametric cell
VTK_CUBIC_LINE: 35,

// Special class of cells formed by convex group of points
VTK_CONVEX_POINT_SET: 41,

// Polyhedron cell (consisting of polygonal faces)
VTK_POLYHEDRON: 42,

// Higher order cells in parametric form
VTK_PARAMETRIC_CURVE: 51,
VTK_PARAMETRIC_SURFACE: 52,
VTK_PARAMETRIC_TRI_SURFACE: 53,
VTK_PARAMETRIC_QUAD_SURFACE: 54,
VTK_PARAMETRIC_TETRA_REGION: 55,
VTK_PARAMETRIC_HEX_REGION: 56,

// Higher order cells
VTK_HIGHER_ORDER_EDGE: 60,
VTK_HIGHER_ORDER_TRIANGLE: 61,
VTK_HIGHER_ORDER_QUAD: 62,
VTK_HIGHER_ORDER_POLYGON: 63,
VTK_HIGHER_ORDER_TETRAHEDRON: 64,
VTK_HIGHER_ORDER_WEDGE: 65,
VTK_HIGHER_ORDER_PYRAMID: 66,
VTK_HIGHER_ORDER_HEXAHEDRON: 67,

// Arbitrary order Lagrange elements (formulated separated from generic higher order cells)
VTK_LAGRANGE_CURVE: 68,
VTK_LAGRANGE_TRIANGLE: 69,
VTK_LAGRANGE_QUADRILATERAL: 70,
VTK_LAGRANGE_TETRAHEDRON: 71,
VTK_LAGRANGE_HEXAHEDRON: 72,
VTK_LAGRANGE_WEDGE: 73,
VTK_LAGRANGE_PYRAMID: 74,

VTK_NUMBER_OF_CELL_TYPES: 75,
};

// This list should contain the cell class names in
// the same order as in CellType.
export const CellTypesStrings = [
'vtkEmptyCell',
'vtkVertex',
'vtkPolyVertex',
'vtkLine',
'vtkPolyLine',
'vtkTriangle',
'vtkTriangleStrip',
'vtkPolygon',
'vtkPixel',
'vtkQuad',
'vtkTetra',
'vtkVoxel',
'vtkHexahedron',
'vtkWedge',
'vtkPyramid',
'vtkPentagonalPrism',
'vtkHexagonalPrism',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'vtkQuadraticEdge',
'vtkQuadraticTriangle',
'vtkQuadraticQuad',
'vtkQuadraticTetra',
'vtkQuadraticHexahedron',
'vtkQuadraticWedge',
'vtkQuadraticPyramid',
'vtkBiQuadraticQuad',
'vtkTriQuadraticHexahedron',
'vtkQuadraticLinearQuad',
'vtkQuadraticLinearWedge',
'vtkBiQuadraticQuadraticWedge',
'vtkBiQuadraticQuadraticHexahedron',
'vtkBiQuadraticTriangle',
'vtkCubicLine',
'vtkQuadraticPolygon',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'vtkConvexPointSet',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'vtkParametricCurve',
'vtkParametricSurface',
'vtkParametricTriSurface',
'vtkParametricQuadSurface',
'vtkParametricTetraRegion',
'vtkParametricHexRegion',
'UnknownClass',
'UnknownClass',
'UnknownClass',
'vtkHigherOrderEdge',
'vtkHigherOrderTriangle',
'vtkHigherOrderQuad',
'vtkHigherOrderPolygon',
'vtkHigherOrderTetrahedron',
'vtkHigherOrderWedge',
'vtkHigherOrderPyramid',
'vtkHigherOrderHexahedron',
];

export default {
CellType,
CellTypesStrings,
};
index.js
import macro from 'vtk.js/Sources/macro';
import {
CellType,
CellTypesStrings,
} from 'vtk.js/Sources/Common/DataModel/CellTypes/Constants';

// ----------------------------------------------------------------------------
// Global methods
// ----------------------------------------------------------------------------

/**
* Given an int (as defined in vtkCellType.h) identifier for a class
* return it's classname.
*/
function getClassNameFromTypeId(typeId) {
return typeId < CellTypesStrings.length
? CellTypesStrings[typeId]
: 'UnknownClass';
}

/**
* Given a data object classname, return it's int identified (as
* defined in vtkCellType.h)
*/
function getTypeIdFromClassName(cellTypeString) {
return CellTypesStrings.findIndex(cellTypeString);
}

/**
* This convenience method is a fast check to determine if a cell type
* represents a linear or nonlinear cell. This is generally much more
* efficient than getting the appropriate vtkCell and checking its IsLinear
* method.
*/
function isLinear(type) {
return (
type < CellType.VTK_QUADRATIC_EDGE ||
type === CellType.VTK_CONVEX_POINT_SET ||
type === CellType.VTK_POLYHEDRON
);
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------

export const STATIC = {
getClassNameFromTypeId,
getTypeIdFromClassName,
isLinear,
};

// ----------------------------------------------------------------------------
// vtkCellTypes methods
// ----------------------------------------------------------------------------

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

/**
* Allocate memory for this array. Delete old storage only if necessary.
*/
publicAPI.allocate = (sz = 512, ext = 1000) => {
model.size = sz > 0 ? sz : 1;
model.extend = ext > 0 ? ext : 1;
model.maxId = -1;
model.typeArray = new Uint8Array(sz);
model.locationArray = new Uint32Array(sz);
};

/**
* Add a cell at specified id.
*/
publicAPI.insertCell = (cellId, type, loc) => {
model.typeArray[cellId] = type;
model.locationArray[cellId] = loc;

if (cellId > model.maxId) {
model.maxId = cellId;
}
};

/**
* Add a cell to the object in the next available slot.
*/
publicAPI.insertNextCell = (type, loc) => {
publicAPI.insertCell(++model.maxId, type, loc);
return model.maxId;
};

/**
* Specify a group of cell types. This version is provided to maintain
* backwards compatibility and does a copy of the cellLocations
*/
publicAPI.setCellTypes = (ncells, cellTypes, cellLocations) => {
model.size = ncells;

model.typeArray = cellTypes;
model.locationArray = cellLocations;

model.maxId = ncells - 1;
};

/**
* Return the location of the cell in the associated vtkCellArray.
*/
publicAPI.getCellLocation = (cellId) => model.locationArray[cellId];

/**
* Delete cell by setting to nullptr cell type.
*/
publicAPI.deleteCell = (cellId) => {
model.typeArray[cellId] = CellType.VTK_EMPTY_CELL;
};

/**
* Return the number of types in the list.
*/
publicAPI.getNumberOfTypes = () => model.maxId + 1;

/**
* Return true if type specified is contained in list; false otherwise.
*/
publicAPI.isType = (type) => {
const numTypes = publicAPI.getNumberOfTypes();

for (let i = 0; i < numTypes; ++i) {
if (type === publicAPI.getCellType(i)) {
return true;
}
}
return false;
};

/**
* Add the type specified to the end of the list. Range checking is performed.
*/
publicAPI.insertNextType = (type) => publicAPI.insertNextCell(type, -1);

/**
* Return the type of cell.
*/
publicAPI.getCellType = (cellId) => model.typeArray[cellId];

/**
* Reclaim any extra memory.
*/
// TODO: publicAPI.squeeze = () => {};

/**
* Initialize object without releasing memory.
*/
publicAPI.reset = () => {
model.maxId = -1;
};

/**
* Standard DeepCopy method. Since this object contains no reference
* to other objects, there is no ShallowCopy.
*/
publicAPI.deepCopy = (src) => {
publicAPI.allocate(src.getSize(), src.getExtend());
model.typeArray.set(src.getTypeArray());
model.locationArray.set(src.getLocationArray());
model.maxId = src.getMaxId();
};
}

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

const DEFAULT_VALUES = {
// typeArray: null, // pointer to types array
// locationArray: null; // pointer to array of offsets
size: 0, // allocated size of data
maxId: -1, // maximum index inserted thus far
extend: 1000, // grow array by this point
};

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

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

macro.obj(publicAPI, model);

macro.get(publicAPI, model, ['size', 'maxId', 'extend']);
macro.getArray(publicAPI, model, ['typeArray', 'locationArray']);

vtkCellTypes(publicAPI, model);
}

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

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

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

export default Object.assign({ newInstance, extend }, STATIC);