Main Page | Modules | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

Using iterators and circulators

This examples shows:

This example is the first version of the simple mesh smoother. Here we will introduce iterators and circulators. These two concepts provide functionality to linearly enumerate e.g. all vertices of a mesh, and to circulate around a vertex, i.e. to enumerate all its one-ring neighbors. For a more detailed description, see Mesh Iterators and Circulators.

First we have to define the mesh type we want to use. This time we use a triangle mesh instead of a polygonal mesh:

#include <OpenMesh/Core/Mesh/Types/TriMesh_ArrayKernelT.hh>
typedef OpenMesh::TriMesh_ArrayKernelT<>  MyMesh;


We read the mesh to be smoothed from a file:

  if ( ! OpenMesh::IO::read_mesh(mesh, argv[2]) )


One smoothing iteration is done in two steps:

  1. For each vertex: calculate the barycenter of its one-ring neighbors.
  2. For each vertex: move the vertex to the computed barycenter.

This can easily be implemented using vertex iterators. The mesh provides begin and end iterators by vertices_begin() and vertices_end().

  MyMesh::VertexIter          v_it, v_end(mesh.vertices_end());
    for (v_it=mesh.vertices_begin(); v_it!=v_end; ++v_it)


For calculating the barycenter, we have to iterate through the one-ring neighborhood of the current vertex. This functionality is provided by the VertexVertexIter:

  MyMesh::VertexVertexIter    vv_it;
      for (vv_it=mesh.vv_iter( v_it ); vv_it; ++vv_it)


Now we can calculate the barycenters for each vertex and store them in the array cogs:

  std::vector<MyMesh::Point>  cogs;
    for (v_it=mesh.vertices_begin(); v_it!=v_end; ++v_it)
    {
      cog[0] = cog[1] = cog[2] = valence = 0.0;
      
      for (vv_it=mesh.vv_iter( v_it ); vv_it; ++vv_it)
      {
        cog += mesh.point( vv_it );
        ++valence;
      }

      cogs.push_back(cog / valence);
    }


After we have calculated the barycenters all that is left to do is to move the vertices to the corresponding barycenters. The complete source code is listed below.

#include <iostream>
#include <vector>
// -------------------- OpenMesh
#include <OpenMesh/Core/IO/MeshIO.hh>
#include <OpenMesh/Core/Mesh/Types/TriMesh_ArrayKernelT.hh>

typedef OpenMesh::TriMesh_ArrayKernelT<>  MyMesh;


int main(int argc, char **argv)
{
  MyMesh  mesh;


  // check command line options
  if (argc != 4) 
  {
    std::cerr << "Usage:  " << argv[0] << " #iterations infile outfile\n";
    return 1;
  }


  // read mesh from stdin
  if ( ! OpenMesh::IO::read_mesh(mesh, argv[2]) )
  {
    std::cerr << "Error: Cannot read mesh from " << argv[2] << std::endl;
    return 1;
  }


  // this vector stores the computed centers of gravity
  std::vector<MyMesh::Point>  cogs;
  std::vector<MyMesh::Point>::iterator cog_it;
  cogs.reserve(mesh.n_vertices());


  // smoothing mesh argv[1] times
  MyMesh::VertexIter          v_it, v_end(mesh.vertices_end());
  MyMesh::VertexVertexIter    vv_it;
  MyMesh::Point               cog;
  MyMesh::Scalar              valence;
  unsigned int                i, N(atoi(argv[1]));


  for (i=0; i < N; ++i)
  {
    cogs.clear();
    for (v_it=mesh.vertices_begin(); v_it!=v_end; ++v_it)
    {
      cog[0] = cog[1] = cog[2] = valence = 0.0;
      
      for (vv_it=mesh.vv_iter( v_it ); vv_it; ++vv_it)
      {
        cog += mesh.point( vv_it );
        ++valence;
      }

      cogs.push_back(cog / valence);
    }
    
    for (v_it=mesh.vertices_begin(), cog_it=cogs.begin(); 
         v_it!=v_end; ++v_it, ++cog_it)
      if ( !mesh.is_boundary( v_it ) )
        mesh.set_point( v_it, *cog_it );
  }


  // write mesh to stdout
  if ( ! OpenMesh::IO::write_mesh(mesh, argv[3]) )
  {
    std::cerr << "Error: cannot write mesh to " << argv[3] << std::endl;
    return 1;
  }

  return 0;
}

acg pic Project OpenMesh, ©  Computer Graphics Group, RWTH Aachen. Documentation generated using doxygen .