If you want to get the best out of your products, our Technical Support Team is available to assist you in any question, request, or technical issue that you may have.

Open Inventor 9.5

Home › Open Inventor Mentor, 2nd Edition - Volume II › Chapter 2. MeshViz XLM › 2.3. MeshViz API: 3DdataMaster and GraphMaster › 2.3.5. Mesh Types

**PoCartesianGrid2D** **PoCartesianGrid2D** **PoCartesianGrid2D**
or
**PbCartesianGrid2D** **PbCartesianGrid2D** **PbCartesianGrid2D**

This mesh represents a grid in Cartesian coordinates. Even if a grid is
of regular topology, the geometry of this type of mesh is not necessarily regular. The cells
are quadrilaterals with opposite sides that are not necessarily parallel. The topology of
the mesh is defined by two integers, *numX* and
*numY*. Hence the mesh is composed of (*numX* -1) *
(*numY* -1) cells. The geometry is defined by an x and y coordinate
array of *numX* * *numY* floats.

These arrays are in a y-line after y-line order: the node Pij, in the
previous figure, has coordinatesxP = x[i*numY+j], yP = y[i*numY+j]. A data set of this type
of mesh is also defined by an array *v* of *numX* *
*numY* floats, where *v* [i**
numY* +j] is the value of the node Pij.

**PoParalCartesianGrid2D** **PoParalCartesianGrid2D** **PoParalCartesianGrid2D** or **PbParalCartesianGrid2D** **PbParalCartesianGrid2D** **PbParalCartesianGrid2D** This mesh represents a rectangular grid in Cartesian
coordinates. Each cell of the mesh is a rectangle. The topology of the mesh is defined by
two integers, *numX* and *numY*. Hence, the mesh is
composed of (*numX* -1) * (*numY* -1) cells. The
geometry is defined by an array *x* of *numX* floats
and by an array *y* of *numY* floats.
*x* is the list of the *numX* abscissas of the
vertical lines, and *y* is the list of the *numY*
ordinates of the horizontal lines. These arrays must be given in a monotonically increasing
or decreasing order.

Example 2.35. Parallel Cartesian grid 2D mesh

*numX* =7, *numY* =6

A data set of this kind of mesh is defined by an array * v* of *numX* * *numY* floats, in a y-line after y-line order. *v* [i** numY* +j] is the value of the node Pij which has coordinates *x* [i],* y* [j].

**PoRegularCartesianGrid2D** **PoRegularCartesianGrid2D** **PoRegularCartesianGrid2D** or **PbRegularCartesianGrid2D** **PbRegularCartesianGrid2D** **PbRegularCartesianGrid2D** This mesh represents a rectangular and regular grid in
Cartesian coordinates. Each cell of the mesh is a rectangle. Each cell has the same width
and the same height. The topology of the mesh is defined by two integers,
*numX* and *numY*. So, the mesh is composed of
(*numX* -1) * (*numY* -1) cells. The geometry is
defined by the bounding box of the mesh, i.e. by four floats: x_min, x_max, y_min, y_max.

Example 2.36. Regular Cartesian grid 2D mesh

*numX* =8, *numY* =7

A data set of this type of mesh is defined by an array * v* of *numX* * *numY* floats, in a y-line after y-line order. *v* [i** numY* +j] is the value of the node Pij which has coordinates *x* [i],* y* [j].

**PoPolarGrid2D** **PoPolarGrid2D** **PoPolarGrid2D** or **PbPolarGrid2D** **PbPolarGrid2D** **PbPolarGrid2D** This mesh represents a grid in polar coordinates. Each cell of the mesh is an area between two arcs and two radius lines. The topology of the mesh is defined by two integers, * numRadius* and *numAngles*. Hence, the mesh is composed of (*numRadius* -1) * (*numAngles* -1) cells. The geometry is defined by an array *radius* of *numRadius* floats and by an array *angles* of *numAngles* floats. *radius* is the list of the radius values of the *numRadius* arc lines, and *angles* is the list of angles of the *numAngles* radius lines.

A data set for this kind of mesh is defined by an array *
v* of *numRadius* * *numAngles* floats, in
an arc-line after arc-line order. *v* [i** numAngles*
+j] is the value of the node Pij which has polar coordinates *radius*
[i], *angles* [j].

**PoIndexedMesh2D** **PoIndexedMesh2D** **PoIndexedMesh2D** or **PbIndexedMesh2D** **PbIndexedMesh2D** **PbIndexedMesh2D** This mesh represents any shape composed by a list of
cells. The mesh can be convex or not, and connected or not. Each cell is a convex polygon
with any number of nodes. The mesh is said to be indexed because each cell is defined by its
nodes whose indices point to an array of node coordinates. Two adjacent cells must have 2
common node indices. If a cell edge (defined by 2 consecutive node indices) belongs to only
one cell, this edge is considered to be part of an external or internal mesh limit. A cell
can only have 1 adjacent cell along one edge or no adjacent cell at all.

The topology of the mesh is defined by the number of cells *
numElems*, the number of nodes *numNodes*, the node indices
list of each cell *elemIndex*, and the number of nodes of each cell
*elemType*. *elemType* is an array of
*numElems* integers. For example, *elemType* [i] = 3
means that the i-th cell is a triangle. *elemIndex* is an array of N
integers where N = *elemType* [0] + *elemType* [1]
+... + *elemType* [* numElems* -1].

Example 2.37. Indexed 2D mesh

numElems = 3, numNodes = 6,

elemType = { 3,3,4},

elemIndex = { 0,1,2, 3,5,4, 2,1,5,3}

The geometry of the mesh is defined by the two arrays * xNode* and *yNode* of *numNodes* float coordinates. A data set of this type of mesh is defined by an array *v* of *numNodes* floats. *v* [i] is the value of the node which has coordinates *xNode* [i],* yNode* [i].

**PoTriangleMesh2D** **PoTriangleMesh2D** **PoTriangleMesh2D** or **PbTriangleMesh2D** **PbTriangleMesh2D** **PbTriangleMesh2D** This mesh represents any shape composed of a list of
triangular cells. The mesh can be convex or not, and connected or not. Each cell is defined
by three nodes whose indices point to an array of node coordinates. Two adjacent cells must
have two common node indices. If a cell’s edge (defined by two consecutive node indices)
belongs to only one cell, this cell is considered to be part of an external or internal mesh
limit. A cell can only have one adjacent cell along one edge or no adjacent cell at all.

The topology of the mesh is defined by the number of cells *
numTriangles*, the number of nodes *numNodes*, and the three
node indices of each triangle *triangleIndex*.
*triangleIndex* is an array of *numTriangles* *3
integers, where *triangleIndex* [i*3 + j] is the j-th node of the i-th
triangle (0<=j<3).

Example 2.38. Triangle 2D mesh

*numTriangles = 3, numNodes = 5, *

*triangleIndex = { 1,2,4, 0,2,1, 1,4,3} *

The geometry of the mesh is defined by the 2 arrays * xNode* and *yNode* of *numNodes* float coordinates. A data set of this type of mesh is defined by an array *v* of *numNodes* floats. *v* [i] is the value of the node which has coordinates *xNode* [i],* yNode* [i].

**PoQuadrangleMesh2D** **PoQuadrangleMesh2D** **PoQuadrangleMesh2D** or **PbQuadrangleMesh2D** **PbQuadrangleMesh2D** **PbQuadrangleMesh2D** This mesh represents any shape composed of a list of
quadrangular (quadrilateral) cells. The mesh can be convex or not, and connected or not.
Each cell is defined by its four nodes whose indices point to an array of nodes coordinates.
Two adjacent cells must have two common node indices. If a cell edge (defined by two
consecutive node indices) belongs to only one cell, this cell is considered to be a part of
an external or internal mesh limit. A cell can only have one adjacent cell along one edge or
no adjacent cell at all.

The topology of the mesh is defined by the number of cells *
numQuadrangles*, the number of nodes *numNodes*, and the four
node indices of each cell *quadrangleIndex*. *
quadrangleIndex* is an array of *numQuadrangles* *4 integers,
where *quadrangleIndex* [i*4 + j] is the j-th node of the i-th quadrangle
(0<=j<4).

Example 2.39. Quadrangle 2D mesh

*numQuadrangles = 3, numNodes = 7, *

*quadrangleIndex = { 0,4,5,1, 0,1,2,6, 0,6,3,4}*

The geometry of the mesh is defined by the two arrays * xNode* and *yNode* of *numNodes* float coordinates. A data set of this type of mesh is defined by an array *v* of *numNodes* floats. *v* [i] is the value of the node which has coordinates *xNode* [i],* yNode* [i].

**PoCartesianGrid3D** **PoCartesianGrid3D** **PoCartesianGrid3D** or **PbCartesianGrid3D** **PbCartesianGrid3D** **PbCartesianGrid3D** This mesh represents a 3D volume grid in Cartesian
coordinates. Even if a grid is of regular topology, the geometry of this type of mesh is not
necessarily regular. The cells are hexahedrons with opposite facets that are not necessarily
parallel. The topology of the mesh is defined by three integers *numX*,
*numY*, and *numZ*. The mesh is thus composed of
(*numX* -1) * (*numY* -1) * (*numZ* -1) cells.

Example 2.40. Irregular Cartesian grid 3D mesh

*numX* = 5, *numY* = 4, *numZ* = 2

The geometry is defined by *x*,
*y*, and *z* coordinates arrays of
*numX* * *numY* * *numZ* floats.
These arrays are in a z-lines after z-lines order: the node Pijk, in the previous figure,
has coordinatesxP = *x* [i** numY* ** numZ
* + j** numZ * + k], yP = *y* [i**
numY* ** numZ* + j** numZ* + k], zP =
*z* [i** numY* ** numZ* +
j** numZ* + k]. A data set of this type of mesh is also defined by an
array *v* of *numX* * *numY* *
*numZ* floats where *v* [i** numY*
** numZ* + j** numZ* + k] is the value of the node
Pijk.

**PoParalCartesianGrid3D** **PoParalCartesianGrid3D** **PoParalCartesianGrid3D** or
**PbParalCartesianGrid3D** **PbParalCartesianGrid3D** **PbParalCartesianGrid3D** This mesh represents a parallelepiped grid in Cartesian
coordinates. Each cell of the mesh is a parallelepiped. The topology of the mesh is defined
by three integers *numX*, *numY*, and *
numZ*. The mesh is thus composed of (*numX* -1) * (*numY* -1) * (*numZ* -1) cells. The geometry is defined by an
array *x* of *numX* floats, an array
*y* of *numY* floats, and by an array
*z* of *numZ* floats. *x* is the
list of the *numX* abscissas of the lines perpendicular to the X-plane.
*y* is the list of the *numY* ordinates of the lines
perpendicular to the Y-plane. *z* is the list of the
*numZ* z-coordinates of the lines perpendicular to the Z-plane. These
arrays must be given in monotonically increasing or decreasing order.

Example 2.41. Parallel Cartesian grid 3D mesh

*numX* = 7, *numY* = 6, *numZ* = 3

A data set of this type of mesh is defined by an array * v* of *numX* * *numY* * *numZ* floats, in a z-lines after z-lines order. *v* [i** numY* ** numZ* + j** numZ* + k] is the value of the node which has the coordinates *x* [i],* y* [j],* z* [k].

**PoRegularCartesianGrid3D** **PoRegularCartesianGrid3D** **PoRegularCartesianGrid3D** or **PbRegularCartesianGrid3D** **PbRegularCartesianGrid3D** **PbRegularCartesianGrid3D** This mesh represents a parallelepiped and regular grid in
Cartesian coordinates. Each cell of the mesh is a parallelepiped, and each one has the same
size. The topology of the mesh is defined by three integers *numX*,
*numY*, and *numZ*. The mesh is thus composed of
(*numX* -1) * (*numY* -1) * (*numZ* -1) cells. The geometry is defined by the bounding box of the mesh, i.e. by
six floats: x_min, x_max, y_min, y_max, z_min, z_max.

Example 2.42. Regular Cartesian grid 3D mesh

*numX = 5, numY = 4, numZ = 4*

A data set of this type of mesh is defined by an array *
v* of *numX* * *numY* *
*numZ* floats, in a z-lines after z-lines order. *v*
[i** numY* ** numZ* + j** numZ* +
k] is the value of the node which has the coordinates *x* [i],*
y* [j],* z* [k].

Each z “slice” is defined in left-to-right (x), bottom-to-top (y) order. Slices are defined front-to-back.

**PoIndexedMesh3D** **PoIndexedMesh3D** **PoIndexedMesh3D** or **PbIndexedMesh3D** **PbIndexedMesh3D** **PbIndexedMesh3D** This mesh represents any 3D volume shape composed of a
list of cells. The mesh can be convex or not, and can be connected or not. Each cell is a
polyhedron which can either be a tetrahedron (4 nodes), a pyramid (5 nodes), a pentahedron
(6 nodes), or a hexahedron (8 nodes). The mesh is said to be indexed because each cell is
defined by its node indices pointing to an array of node coordinates. Two adjacent cells
must have three or four common node indices. If a cell’s facet belongs to only one cell,
this facet is considered to be a part of an external or internal mesh limit (an internal
mesh limit is the limit of an inside hole). The cell’s facets that do not belong to the mesh
limit must be referenced exactly twice in the mesh. A cell can only have one adjacent cell
along one facet or no adjacent cell at all.

The cells must be numbered as shown: The following rule is applied: for each cell, the first three or four indices (depending on the cell type) define a cell’s facet, and orient this facet towards the interior side of the element. The topology of the mesh is defined by the number of cells *numElems*, the number of nodes *numNodes*, the node indices list of each cells * elemIndex*, and the number of nodes of each cell *elemType*. *elemType* is an array of *numElems* integers. For example, *elemType* [i] = 8 means that the i-th cell is a hexahedron. *elemIndex* is an array of N integers where N = *elemType* [0]+ *elemType* [1]+...+ *elemType* [* numElems* -1].

Example 2.43. Indexed 3D mesh

*
numElems = 3, numNodes = 8, elemType = { 6,4,4}, elemIndex = { 1,7,0,2,5,3, 0,6,7,1, 2,5,3,4}
*

The geometry of the mesh is defined by the three arrays *xNode*, *yNode*, and *zNode* of *numNodes* float coordinates. A data set of this type of mesh is defined by an array *v* of *numNodes* floats. *v* [i] is the value of the node which has coordinates *xNode* [i], *yNode* [i], *zNode* [i].

**PoTetrahedronMesh3D** **PoTetrahedronMesh3D** **PoTetrahedronMesh3D** or **PbTetrahedronMesh3D** **PbTetrahedronMesh3D** **PbTetrahedronMesh3D** This mesh represents any 3D volume shape composed of a
list of tetrahedrons. The mesh can be convex or not, and can be connected or not. Each
tetrahedron is defined by four nodes whose indices point to an array of nodes coordinates.
Two adjacent tetrahedrons must have three common node indices. If a tetrahedron’s facet
belongs to only one tetrahedron, this facet is considered to be a part of an external or
internal mesh limit. The tetrahedron’s facet which do not belong to the mesh limit must be
referenced exactly twice in the mesh. A tetrahedron can only have one adjacent tetrahedron
along one facet or no adjacent tetrahedron at all.

Each tetrahedron must be numbered as shown:

The following rule is applied: for each tetrahedron, the first three indices define a facet, and orient this facet towards the interior side of the tetrahedron.

The topology of the mesh is defined by the number of tetrahedrons *numTetrahedrons*, the number of nodes *numNodes*, and the four node indices of each tetrahedron *tetrahedronIndex*. *tetrahedronIndex* is an array of *numTetrahedrons* *4 integers, where *tetrahedronIndex* [i*4 + j] is the j-th node of the i-th tetrahedron (0<=j<4).

Example 2.44. Tetrahedron mesh

*numTetrahedrons = 3, numNodes = 6, tetrahedronIndex = { 0,5,1,3, 3,5,4,0,0,4,2,5}
*

The geometry of the mesh is defined by the three arrays *xNode*, *yNode,* and *zNode* of *numNodes* float coordinates. A data set of this type of mesh is defined by an array *v* of *numNodes* floats. *v* [i] is the value of the node which has coordinates *xNode* [i], *yNode* [i], *zNode* [i].

**PoHexahedronMesh3D** **PoHexahedronMesh3D** **PoHexahedronMesh3D** or **PbHexahedronMesh3D** **PbHexahedronMesh3D** **PbHexahedronMesh3D** This mesh represents any 3D volume shape composed of a
list of hexahedrons. The mesh can be convex or not, and can be connected or not. Each
hexahedron is defined by its eight nodes whose indices point to an array of nodes
coordinates. Two adjacent hexahedrons must have four common node indices. If a hexahedron’s
facet belongs to only one hexahedron, this facet is considered to be a part of an external
or internal mesh limit. The hexahedron’s facets which do not belong to the mesh limit must
be referenced exactly twice in the mesh. A hexahedron can only have one adjacent hexahedron
along one facet or no adjacent hexahedron at all.

Each hexahedron must be numbered as shown:

The following rule is applied: for each hexahedron, the first four indices define a facet, and orient this facet towards the interior side of the hexahedron.

The topology of the mesh is defined by the number of hexahedrons *numHexahedrons*, the number of nodes *numNodes*, and the eight node indices of each hexahedron *hexahedronIndex*. * hexahedronIndex* is an array of *numHexahedrons* *8 integers, where* hexahedronIndex* [i*8 + j] is the j-th node of the i-th hexahedron (0<=j<8).

Example 2.45. Hexahedron mesh

*numHexahedrons = 2, numNodes = 12, *

hexahedronIndex = { 10,7,6,11,4,1,2,5,4,1,0,3,10,7,8,9 }

The geometry of the mesh is defined by the three arrays * xNode*, *yNode*, and *zNode* of * numNodes* float coordinates. A data set of this type of mesh is defined by an array *v* of *numNodes* floats. *v* [i] is the value of the node which has coordinates *xNode* [i],* yNode* [i],* zNode* [i].

/Users_Guide/MeshViz_XLM/MeshViz_API_3DdataMaster_and_GraphMaster/Attaching_a_Legend.html

/Users_Guide/MeshViz_XLM/MeshViz_API_3DdataMaster_and_GraphMaster/MeshViz_API_3DdataMaster_and_GraphMaster.html

/Users_Guide/MeshViz_XLM/MeshViz_API_3DdataMaster_and_GraphMaster/Example_using_3DdataMaster.html

Hotline & support

If you want to get the best out of your products, our Technical Support Team is available to assist you in any question, request, or technical issue that you may have.

Contact us

FEI Visualization Sciences Group operates at a worldwide level through offices in the United States, United Kingdom, France and distributors. Feel free to contact us.

Trial Versions

Request an evaluation version of Open Inventor. Evaluation versions include full access to our technical support and product experts.

Website

FEI Visualization Sciences Group is the leading provider of advanced 3D visualization and analysis software tools for developers, engineers and scientists in natural resources, medical and life sciences, and engineering.

©2015 FEI. FEI, the FEI logo, and Open Inventor are trademarks of FEI Company or its affiliates. All other trademarks belong to their respective owners.