Added example source code of tutorials to src folder.

git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@208 fdac6126-5c0c-442c-9429-916003d36597

src/OpenMesh/Examples/Examples.pro

+Subdirs()
+
+addSubdirs( Tutorial01 )
+addSubdirs( Tutorial02 )
+addSubdirs( Tutorial03 )
+addSubdirs( Tutorial04 )
+addSubdirs( Tutorial05 )
+addSubdirs( Tutorial06 )
+addSubdirs( Tutorial07 )
+addSubdirs( Tutorial08 )
+addSubdirs( Tutorial09 )
+addSubdirs( Tutorial10 )

src/OpenMesh/Examples/Tutorial01/Tutorial01.pro

+################################################################################
+#
+################################################################################
+
+include( $$TOPDIR/qmake/all.include )
+
+INCLUDEPATH += ../../..
+
+Application()
+openmesh()
+
+DIRECTORIES = . 
+
+# Input
+HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
+SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
+FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
+
+################################################################################

src/OpenMesh/Examples/Tutorial01/cube.cc

+//=============================================================================
+//                                                                            
+//                               OpenMesh                                     
+//      Copyright (C) 2001-2005 by Computer Graphics Group, RWTH Aachen       
+//                           www.openmesh.org                                 
+//                                                                            
+//-----------------------------------------------------------------------------
+//                                                                            
+//                                License                                     
+//                                                                            
+//   This library is free software; you can redistribute it and/or modify it 
+//   under the terms of the GNU Library General Public License as published  
+//   by the Free Software Foundation, version 2.                             
+//                                                                             
+//   This library is distributed in the hope that it will be useful, but       
+//   WITHOUT ANY WARRANTY; without even the implied warranty of                
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         
+//   Library General Public License for more details.                          
+//                                                                            
+//   You should have received a copy of the GNU Library General Public         
+//   License along with this library; if not, write to the Free Software       
+//   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 
+//                                                                            
+//-----------------------------------------------------------------------------
+//                                                                            
+//   $Revision: 83 $
+//   $Date: 2009-02-27 17:31:45 +0100 (Fri, 27 Feb 2009) $
+//                                                                            
+//=============================================================================
+
+
+#include <iostream>
+// -------------------- OpenMesh
+#include <OpenMesh/Core/IO/MeshIO.hh>
+#include <OpenMesh/Core/Mesh/PolyMesh_ArrayKernelT.hh>
+
+
+// ----------------------------------------------------------------------------
+
+typedef OpenMesh::PolyMesh_ArrayKernelT<>  MyMesh;
+
+
+// ----------------------------------------------------------------------------
+// Build a simple cube and write it to std::cout
+  
+int main()
+{
+  MyMesh mesh;
+
+  // generate vertices
+
+  MyMesh::VertexHandle vhandle[8];
+
+  vhandle[0] = mesh.add_vertex(MyMesh::Point(-1, -1,  1));
+  vhandle[1] = mesh.add_vertex(MyMesh::Point( 1, -1,  1));
+  vhandle[2] = mesh.add_vertex(MyMesh::Point( 1,  1,  1));
+  vhandle[3] = mesh.add_vertex(MyMesh::Point(-1,  1,  1));
+  vhandle[4] = mesh.add_vertex(MyMesh::Point(-1, -1, -1));
+  vhandle[5] = mesh.add_vertex(MyMesh::Point( 1, -1, -1));
+  vhandle[6] = mesh.add_vertex(MyMesh::Point( 1,  1, -1));
+  vhandle[7] = mesh.add_vertex(MyMesh::Point(-1,  1, -1));
+
+
+  // generate (quadrilateral) faces
+
+  std::vector<MyMesh::VertexHandle>  face_vhandles;
+
+  face_vhandles.clear();
+  face_vhandles.push_back(vhandle[0]);
+  face_vhandles.push_back(vhandle[1]);
+  face_vhandles.push_back(vhandle[2]);
+  face_vhandles.push_back(vhandle[3]);
+  mesh.add_face(face_vhandles);
+ 
+  face_vhandles.clear();
+  face_vhandles.push_back(vhandle[7]);
+  face_vhandles.push_back(vhandle[6]);
+  face_vhandles.push_back(vhandle[5]);
+  face_vhandles.push_back(vhandle[4]);
+  mesh.add_face(face_vhandles);
+
+  face_vhandles.clear();
+  face_vhandles.push_back(vhandle[1]);
+  face_vhandles.push_back(vhandle[0]);
+  face_vhandles.push_back(vhandle[4]);
+  face_vhandles.push_back(vhandle[5]);
+  mesh.add_face(face_vhandles);
+
+  face_vhandles.clear();
+  face_vhandles.push_back(vhandle[2]);
+  face_vhandles.push_back(vhandle[1]);
+  face_vhandles.push_back(vhandle[5]);
+  face_vhandles.push_back(vhandle[6]);
+  mesh.add_face(face_vhandles);
+
+  face_vhandles.clear();
+  face_vhandles.push_back(vhandle[3]);
+  face_vhandles.push_back(vhandle[2]);
+  face_vhandles.push_back(vhandle[6]);
+  face_vhandles.push_back(vhandle[7]);
+  mesh.add_face(face_vhandles);
+
+  face_vhandles.clear();
+  face_vhandles.push_back(vhandle[0]);
+  face_vhandles.push_back(vhandle[3]);
+  face_vhandles.push_back(vhandle[7]);
+  face_vhandles.push_back(vhandle[4]);
+  mesh.add_face(face_vhandles);
+
+
+  // write mesh to output.obj
+  try
+  {
+    if ( !OpenMesh::IO::write_mesh(mesh, "output.off") )
+    {
+      std::cerr << "Cannot write mesh to file 'output.off'" << std::endl;
+      return 1;
+    }
+  }
+  catch( std::exception& x )
+  {
+    std::cerr << x.what() << std::endl;
+    return 1;
+  }
+
+  return 0;
+}

src/OpenMesh/Examples/Tutorial02/Tutorial02.pro

+################################################################################
+#
+################################################################################
+
+include( $$TOPDIR/qmake/all.include )
+
+INCLUDEPATH += ../../..
+
+Application()
+openmesh()
+
+DIRECTORIES = . 
+
+# Input
+HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
+SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
+FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
+
+################################################################################

src/OpenMesh/Examples/Tutorial02/smooth.cc

+#include <iostream>
+#include <vector>
+// -------------------- OpenMesh
+#include <OpenMesh/Core/IO/MeshIO.hh>
+#include <OpenMesh/Core/Mesh/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;
+}

src/OpenMesh/Examples/Tutorial03/Tutorial03.pro

+################################################################################
+#
+################################################################################
+
+include( $$TOPDIR/qmake/all.include )
+
+INCLUDEPATH += ../../..
+
+Application()
+openmesh()
+
+DIRECTORIES = . 
+
+# Input
+HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
+SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
+FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
+
+################################################################################

src/OpenMesh/Examples/Tutorial03/smooth.cc

+#include <iostream>
+#include <vector>
+// --------------------
+#include <OpenMesh/Core/IO/MeshIO.hh>
+#include <OpenMesh/Core/Mesh/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 vertex property stores the computed centers of gravity
+  OpenMesh::VPropHandleT<MyMesh::Point> cogs;
+  mesh.add_property(cogs);
+
+  // 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)
+  {
+    for (v_it=mesh.vertices_begin(); v_it!=v_end; ++v_it)
+    {      
+      mesh.property(cogs,v_it).vectorize(0.0f);
+      valence = 0;
+      
+      for (vv_it=mesh.vv_iter( v_it ); vv_it; ++vv_it)
+      {
+	mesh.property(cogs,v_it) += mesh.point( vv_it );
+	++valence;
+      }
+      mesh.property(cogs,v_it) /= valence;
+    }
+    
+    for (v_it=mesh.vertices_begin(); v_it!=v_end; ++v_it)
+      if ( !mesh.is_boundary( v_it ) )
+	mesh.set_point( v_it, mesh.property(cogs,v_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;
+}

src/OpenMesh/Examples/Tutorial04/Tutorial04.pro

+################################################################################
+#
+################################################################################
+
+include( $$TOPDIR/qmake/all.include )
+
+INCLUDEPATH += ../../..
+
+Application()
+openmesh()
+
+DIRECTORIES = . 
+
+# Input
+HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
+SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
+FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
+
+################################################################################

src/OpenMesh/Examples/Tutorial04/smooth.cc

+#include <iostream>
+#include <vector>
+// -------------------- OpenMesh
+#include <OpenMesh/Core/IO/MeshIO.hh>
+#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
+// -------------------- 
+#include "smooth_algo.hh"
+
+
+// ----------------------------------------------------------------------------
+
+#ifndef DOXY_IGNORE_THIS
+
+struct MyTraits : public OpenMesh::DefaultTraits
+{
+  HalfedgeAttributes(OpenMesh::Attributes::PrevHalfedge);
+};
+
+#endif
+
+typedef OpenMesh::TriMesh_ArrayKernelT<MyTraits>  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;
+  }
+
+
+  // smoothing mesh argv[1] times
+  SmootherT<MyMesh> smoother(mesh);
+  smoother.smooth(atoi(argv[1]));
+
+
+  // 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;
+}

src/OpenMesh/Examples/Tutorial04/smooth_algo.hh

+#include <algorithm>
+#include <OpenMesh/Core/Utils/Property.hh>
+
+#ifndef DOXY_IGNORE_THIS
+
+template <class Mesh> class SmootherT
+{
+public:
+
+  typedef typename Mesh::Point            cog_t;
+  typedef OpenMesh::VPropHandleT< cog_t > Property_cog;
+
+public:
+
+  // construct with a given mesh
+  SmootherT(Mesh& _mesh) 
+    : mesh_(_mesh)
+  { 
+    mesh_.add_property( cog_ );
+  }
+
+  ~SmootherT()
+  {
+    mesh_.remove_property( cog_ );
+  }
+
+  // smooth mesh _iterations times
+  void smooth(unsigned int _iterations)
+  {
+    for (unsigned int i=0; i < _iterations; ++i)
+    {
+      std::for_each(mesh_.vertices_begin(), 
+		    mesh_.vertices_end(), 
+		    ComputeCOG(mesh_, cog_));
+
+      std::for_each(mesh_.vertices_begin(), 
+		    mesh_.vertices_end(), 
+		    SetCOG(mesh_, cog_));
+    }
+  }
+
+
+private:
+
+
+  //--- private classes ---
+
+  class ComputeCOG
+  {
+  public:
+    ComputeCOG(Mesh& _mesh, Property_cog& _cog) 
+      : mesh_(_mesh), cog_(_cog)
+    {}
+
+    void operator()(typename Mesh::Vertex& _v)
+    {
+      typename Mesh::VertexHandle      vh( mesh_.handle(_v) );
+      typename Mesh::VertexVertexIter  vv_it;
+      typename Mesh::Scalar            valence(0.0);
+    
+      mesh_.property(cog_, vh) = typename Mesh::Point(0.0, 0.0, 0.0);
+
+      for (vv_it=mesh_.vv_iter(vh); vv_it; ++vv_it)
+      {
+	mesh_.property(cog_, vh) += mesh_.point( vv_it );
+	++valence;
+      }
+
+      mesh_.property(cog_, mesh_.handle(_v) ) /= valence;
+    }
+
+  private:
+    Mesh&         mesh_;
+    Property_cog& cog_;
+  };
+
+
+  class SetCOG
+  {
+  public:
+    SetCOG(Mesh& _mesh, Property_cog& _cog) 
+      : mesh_(_mesh), cog_(_cog)
+    {}
+
+    void operator()(typename Mesh::Vertex& _v)
+    {
+      typename Mesh::VertexHandle vh(mesh_.handle(_v));
+
+      if (!mesh_.is_boundary(vh))
+	mesh_.set_point( vh, mesh_.property(cog_, vh) );
+    }
+
+  private:
+
+    Mesh&         mesh_;
+    Property_cog& cog_;
+  };
+
+
+  //--- private elements ---
+
+  Mesh&        mesh_;
+  Property_cog cog_;
+};
+
+#endif

src/OpenMesh/Examples/Tutorial05/Tutorial05.pro

+################################################################################
+#
+################################################################################
+
+include( $$TOPDIR/qmake/all.include )
+
+INCLUDEPATH += ../../..
+
+Application()
+openmesh()
+
+DIRECTORIES = . 
+
+# Input
+HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
+SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
+FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
+
+################################################################################

src/OpenMesh/Examples/Tutorial05/properties.cc

+#include <iostream>
+// --------------------
+#include <OpenMesh/Core/IO/MeshIO.hh>
+#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
+
+
+typedef OpenMesh::TriMesh_ArrayKernelT<>  MyMesh;
+
+
+int main(int argc, char **argv)
+{
+  MyMesh  mesh;
+
+  if (argc!=2)
+  {
+    std::cerr << "Usage: " << argv[0] << " <input>\n";
+    return 1;
+  }
+
+  // request vertex normals, so the mesh reader can use normal information
+  // if available
+  mesh.request_vertex_normals();
+
+  // assure we have vertex normals
+  if (!mesh.has_vertex_normals())
+  {
+    std::cerr << "ERROR: Standard vertex property 'Normals' not available!\n";
+    return 1;
+  }
+
+  OpenMesh::IO::Options opt;
+  if ( ! OpenMesh::IO::read_mesh(mesh,argv[1], opt))
+  {
+    std::cerr << "Error loading mesh from file " << argv[1] << std::endl;
+    return 1;
+  }
+
+  // If the file did not provide vertex normals, then calculate them
+  if ( !opt.check( OpenMesh::IO::Options::VertexNormal ) )
+  {
+    // we need face normals to update the vertex normals
+    mesh.request_face_normals();
+
+    // let the mesh update the normals
+    mesh.update_normals();
+
+    // dispose the face normals, as we don't need them anymore
+    mesh.release_face_normals();
+  }
+
+  // move all vertices one unit length along it's normal direction
+  for (MyMesh::VertexIter v_it = mesh.vertices_begin();
+       v_it != mesh.vertices_end(); ++v_it)
+  {
+    std::cout << "Vertex #" << v_it << ": " << mesh.point( v_it );
+    mesh.set_point( v_it, mesh.point(v_it)+mesh.normal(v_it) );
+    std::cout << " moved to " << mesh.point( v_it ) << std::endl;
+  }
+
+  // don't need the normals anymore? Remove them!
+  mesh.release_vertex_normals();
+
+  // just check if it really works
+  if (mesh.has_vertex_normals())
+  {
+    std::cerr << "Ouch! ERROR! Shouldn't have any vertex normals anymore!\n";
+    return 1;
+  }
+
+  return 0;
+}

src/OpenMesh/Examples/Tutorial06/Tutorial06.pro

+################################################################################
+#
+################################################################################
+
+include( $$TOPDIR/qmake/all.include )
+
+INCLUDEPATH += ../../..
+
+Application()
+openmesh()
+
+DIRECTORIES = . 
+
+# Input
+HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
+SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
+FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
+
+################################################################################

src/OpenMesh/Examples/Tutorial06/attributes.cc

+#include <iostream>
+#include <typeinfo>
+// --------------------
+#include <OpenMesh/Core/IO/MeshIO.hh>
+
+#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
+#include <OpenMesh/Core/Geometry/VectorT.hh>
+
+#ifndef DOXY_IGNORE_THIS
+
+// Define my personal traits
+struct MyTraits : OpenMesh::DefaultTraits
+{
+  // Let Point and Normal be a vector of doubles
+  typedef OpenMesh::Vec3d Point;
+  typedef OpenMesh::Vec3d Normal;
+
+  // Already defined in OpenMesh::DefaultTraits
+  // HalfedgeAttributes( OpenMesh::Attributes::PrevHalfedge );
+  
+  // Uncomment next line to disable attribute PrevHalfedge
+  // HalfedgeAttributes( OpenMesh::Attributes::None );
+  //
+  // or
+  //
+  // HalfedgeAttributes( 0 );
+};
+
+#endif
+
+// Define my mesh with the new traits!
+typedef OpenMesh::TriMesh_ArrayKernelT<MyTraits>  MyMesh;
+
+// ------------------------------------------------------------------ main ----
+
+int main(int argc, char **argv)
+{
+  MyMesh mesh;
+
+  if (argc!=2)
+  {
+    std::cerr << "Usage: " << argv[0] << " <input>\n";
+    return 1;
+  }
+
+  // Just make sure that point element type is double
+  if ( typeid( OpenMesh::vector_traits<MyMesh::Point>::value_type ) 
+       != typeid(double) )
+  {
+    std::cerr << "Ouch! ERROR! Data type is wrong!\n";
+    return 1;
+  }
+
+  // Make sure that normal element type is double