## Synopsis#

How to add points and edges to a mesh.

## Results#

Output:

```Points = 4
[-1, -1, 0]
[1, -1, 0]
[1, 1, 0]
[1, 1, 1]
line first point id: 2
line second point id: 3
```

## Code#

### C++#

```#include "itkMesh.h"
#include "itkLineCell.h"

constexpr unsigned int Dimension = 3;
using MeshType = itk::Mesh<float, Dimension>;

MeshType::Pointer
CreatePointOnlyMesh();
void
CreateMeshWithEdges();

int
main()
{
// CreatePointOnlyMesh();
CreateMeshWithEdges();

return 0;
}

MeshType::Pointer
CreatePointOnlyMesh()
{
auto mesh = MeshType::New();

// Create points
MeshType::PointType p0, p1, p2, p3;

p0[0] = -1.0;
p0[1] = -1.0;
p0[2] = 0.0; // first  point ( -1, -1, 0 )
p1[0] = 1.0;
p1[1] = -1.0;
p1[2] = 0.0; // second point (  1, -1, 0 )
p2[0] = 1.0;
p2[1] = 1.0;
p2[2] = 0.0; // third  point (  1,  1, 0 )
p3[0] = 1.0;
p3[1] = 1.0;
p3[2] = 1.0; // third  point (  1,  1, 1 )

mesh->SetPoint(0, p0);
mesh->SetPoint(1, p1);
mesh->SetPoint(2, p2);
mesh->SetPoint(3, p3);

std::cout << "Points = " << mesh->GetNumberOfPoints() << std::endl;

// Access points
using PointsIterator = MeshType::PointsContainer::Iterator;

PointsIterator pointIterator = mesh->GetPoints()->Begin();

PointsIterator end = mesh->GetPoints()->End();
while (pointIterator != end)
{
MeshType::PointType p = pointIterator.Value(); // access the point
std::cout << p << std::endl;                   // print the point
++pointIterator;                               // advance to next point
}

return mesh;
}

void
CreateMeshWithEdges()
{
MeshType::Pointer mesh = CreatePointOnlyMesh();

using CellAutoPointer = MeshType::CellType::CellAutoPointer;
using LineType = itk::LineCell<MeshType::CellType>;

// Create a link to the previous point in the column (below the current point)
CellAutoPointer colline;
colline.TakeOwnership(new LineType);

// unsigned int pointId0 = 0;
// unsigned int pointId1 = 1;

unsigned int pointId0 = 2;
unsigned int pointId1 = 3;

colline->SetPointId(0, pointId0); // line between points 0 and 1
colline->SetPointId(1, pointId1);
// std::cout << "Linked point: " << MeshIndex << " and " << MeshIndex - 1 << std::endl;
mesh->SetCell(0, colline);

using CellIterator = MeshType::CellsContainer::Iterator;
CellIterator cellIterator = mesh->GetCells()->Begin();
CellIterator CellsEnd = mesh->GetCells()->End();

while (cellIterator != CellsEnd)
{
MeshType::CellType * cellptr = cellIterator.Value();
auto *               line = dynamic_cast<LineType *>(cellptr);

itk::IdentifierType * linePoint0 = line->PointIdsBegin();
// itk::IdentifierType* linePoint1 = line->PointIdsEnd();
itk::IdentifierType * linePoint1 = linePoint0 + 1;
std::cout << "line first point id: " << *linePoint0 << std::endl;
std::cout << "line second point id: " << *linePoint1 << std::endl;

++cellIterator;
}
}
```

## Classes demonstrated#

template<typename TPixelType, unsigned int VDimension = 3, typename TMeshTraits = DefaultStaticMeshTraits<TPixelType, VDimension, VDimension>>
class Mesh : public itk::PointSet<TPixelType, VDimension, TMeshTraits>

Implements the N-dimensional mesh structure.

Mesh is an adaptive, evolving structure. Typically points and cells are created, with the cells referring to their defining points. If additional topological information is required, then BuildCellLinks() is called and links from the points back to the cells that use them are created. This allows implicit topological information about the faces and edges of the cells to be determined. (For example, a “face” neighbor to a cell can be determined by intersection the sets of cells that use the points defining the face. This is an inherent assumption on the manifold relationship of the cells in the mesh.) In some cases, either because the mesh is non-manifold, because we wish to explicitly store information with the faces and edges of the mesh, or because performance requirements demand that boundaries are explicitly represented (the set intersection does not need to be performed); then Mesh can be further extended by adding explicit boundary assignments.

Overview

Mesh implements the N-dimensional mesh structure for ITK. It provides an API to perform operations on points, cells, boundaries, etc., but does not tie down the underlying implementation and storage. A “MeshTraits” structure is used to define the container and identifier types that will be used to access the mesh. See DefaultStaticMeshTraits for the set of type definitions needed. All types that are defined in the “MeshTraits” structure will have duplicate type alias in the resulting mesh itself.

One of the most important parts of using this mesh is how to create cells to insert into it. The cells for the mesh take two template parameters. The first is the pixel type, and should correspond exactly to that type given to the mesh. The second is a “CellTraits” which holds a sub-set of the “MeshTraits” structure definitions, and is also a member of them. Any cell which is to be inserted to a mesh should have MeshTraits::CellTraits as its second template parameter.

Usage

Mesh has three template parameters. The first is the pixel type, or the type of data stored (optionally) with points, cells, and/or boundaries. The second is the geometric dimension of the points defining the mesh. This also limits the maximum topological dimension of the cells that can be inserted. The third template parameter is the “MeshTraits” structure controlling type information for the mesh. Most users will be happy with the defaults, and will not have to worry about this third argument.

Template parameters for Mesh:

TPixelType = The type stored as data for an entity (cell, point, or boundary).

TMeshTraits = Type information structure for the mesh.

References

No reference information is available.

ITK Sphinx Examples:

Subclassed by itk::SimplexMesh< TPixelType, VDimension, TMeshTraits >