初始化内容

third/OpenMesh/Doc/Tutorial/04-stl_algorithms/smooth.cc

@@ -0,0 +1,59 @@
+#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;
+}

third/OpenMesh/Doc/Tutorial/04-stl_algorithms/smooth_algo.hh

@@ -0,0 +1,104 @@
+#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
+  explicit 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()(const typename Mesh::VertexHandle& _vh)
+    {
+      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.is_valid(); ++vv_it)
+      {
+	mesh_.property(cog_, _vh) += mesh_.point( *vv_it );
+	++valence;
+      }
+
+      mesh_.property(cog_, _vh ) /= valence;
+    }
+
+  private:
+    Mesh&         mesh_;
+    Property_cog& cog_;
+  };
+
+
+  class SetCOG
+  {
+  public:
+    SetCOG(Mesh& _mesh, Property_cog& _cog) 
+      : mesh_(_mesh), cog_(_cog)
+    {}
+
+    void operator()(const typename Mesh::VertexHandle& _vh)
+    {
+
+      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